Opens the Explorer and executes the callback function in windows os
@param {string} path The path string to be opened in the explorer
@param {Function} callback Callback function to which error is passed if some error occurs
329417
function openExplorerinWindows(path, callback) {
    path = path || '=';
    let p = spawn('explorer', [path]);
    p.on('error', (err) => {
        p.kill();
        return callback(err);
    });
}
304983
function(callback) {
    var guid = Ember.guidFor(this);

    Ember.$(window).bind('popstate.ember-location-'+guid, function(e) {
      callback(location.pathname);
    });
  }
129995
function showFileOpenError(name, path) {
        return Dialogs.showModalDialog(
            DefaultDialogs.DIALOG_ID_ERROR,
            Strings.ERROR_OPENING_FILE_TITLE,
            StringUtils.format(
                Strings.ERROR_OPENING_FILE,
                StringUtils.breakableUrl(path),
                FileUtils.getFileErrorString(name)
            )
        );
    }
184253
function(path) {

		// If the path is empty
		if (!path) {
			return window.location;
		}

		// Chrome and FireFox support new URL() to extract URL objects
		else if (window.URL && URL instanceof Function && URL.length !== 0) {
			return new URL(path, window.location);
		}

		// Ugly shim, it works!
		else {
			var a = document.createElement('a');
			a.href = path;
			return a.cloneNode(false);
		}
	}
688401
function(key, path, callback) {
      var s = this;
      $.get(path, function(response) {
        s.set(key, response);
        if (callback) { callback.apply(this, [response]); }
      });
    }
168529
function(path, callback) {
      var self = this
      request({url: this.endpoint + path, json: true}, function(err, resp, body) {
        if (err) {
          return console.error(err);
        }
        callback.call(self, body);
      });
    }
661451
function ReadFile(path, callback) {
    if (typeof callback === "function") {
        return Fs.readFile(path, ENCODING, callback);
    }
    return Fs.readFileSync(path, ENCODING);
}
595319
def _open_path_window(self):
        
        self.data['top_assistant'] = self.top_assistant
        self.data['current_main_assistant'] = self.get_current_main_assistant()
        self.data['kwargs'] = self.kwargs
        self.path_window.open_window(self.data)
        self.main_win.hide()
1046559
function(path, callback){

        fs.exists(path, function(exists){
            if (exists) {
                fs.lstat(path, function(err, stats){
                    if (err) console.error(err.stack);

                    if ( stats.isSymbolicLink() ) fs.unlink(path, function(err){
                        if (err) {
                            console.error(err.stack);
                            callback(err)
                        } else {
                            //Trigger.
                            onSymlinkRemoved(self.paths, function(err){
                                if (err) console.error(err.stack);

                                callback(false)
                            })
                        }
                    })
                })
            } else {
                //log & ignore. This is not a real issue.
                //logger.warn('gina', 'UTILS:CONFIG:WARN:1', 'Path not found: ' + path, __stack);
                console.warn( 'Path not found: ' + path, __stack);
                onSymlinkRemoved(self.paths, function(err){
                    //if (err) logger.error('gina', 'UTILS:CONFIG:ERR:9', err, __stack);
                    if (err) console.error(err.stack||err.message);

                    callback(false)
                })
            }
        })
    }
325711
function(remotePath, callback) {
            client
                .stat(remotePath)
                .then(function(stat) {
                    __executeCallbackAsync(callback, [null, __convertStat(stat)]);
                })
                .catch(callback);
        }
840343
public static SeerClickableLabelAction createOpenParentFolderAction(final String path) {
        return () -> {
            File file = new File(path);
            try {
                if (file.exists() && System.getProperty("os.name").startsWith("Windows"))
                    Runtime.getRuntime().exec("Explorer /select," + file.getParentFile().getAbsolutePath() + "\\" + file.getName());
                else {
                    Desktop desktop = Desktop.isDesktopSupported() ? Desktop.getDesktop() : null;
                    if (desktop != null && desktop.isSupported(Action.OPEN))
                        Desktop.getDesktop().open(file.getParentFile());
                }
            }
            catch (IOException | RuntimeException e) {
                // ignored
            }
        };
    }
454151
function _openPath(treeData, path) {
        var objectPath = _filePathToObjectPath(treeData, path);

        function setOpen(node) {
            return node.set("open", true);
        }

        while (objectPath && objectPath.length) {
            var node = treeData.getIn(objectPath);
            if (isFile(node)) {
                objectPath.pop();
            } else {
                if (!node.get("open")) {
                    treeData = treeData.updateIn(objectPath, setOpen);
                }
                objectPath.pop();
                if (objectPath.length) {
                    objectPath.pop();
                }
            }
        }

        return treeData;
    }
322550
function open(url, location, noFlash) {
        console.assert(url.substr(0, 7) === "file://", "Cannot open non-file URLs");

        var result = new $.Deferred();

        url = _urlWithoutQueryString(url);
        // Extract the path, also strip the third slash when on Windows
        var path = url.slice(brackets.platform === "win" ? 8 : 7);
        // URL-decode the path ('%20' => ' ')
        path = decodeURI(path);
        var promise = CommandManager.execute(Commands.FILE_OPEN, {fullPath: path});
        promise.done(function onDone(doc) {
            if (location) {
                openLocation(location, noFlash);
            }
            result.resolve();
        });
        promise.fail(function onErr(err) {
            console.error(err);
            result.reject(err);
        });

        return result.promise();
    }
377764
function(path) {
		if (!path) return;
		
		for (var lib = IO.ls(SYS.pwd+path), i = 0; i < lib.length; i++) 
			if (/\.js$/i.test(lib[i])) load(lib[i]);
	}
787983
function readDir(path, callback) {
  nodeFs.readdir(path, function (err, names) {
    if (err) {
      if (err.code === "ENOENT") return callback();
      return callback(err);
    }
    return callback(null, names);
  });
}
1351842
function makeDir(path, callback) {
  fs.mkdir(path, err => {
    if (err) {
      // check if directory exists
      fs.stat(path, (err2, stat) => {
        if (err2 || !stat.isDirectory()) {
          callback(err);
        } else {
          callback();
        }
      });
    } else {
      callback();
    }
  });
}
908447
function (exec_path, onExec) {

		var onFound = function () {
			
			// if file found, execute directly
			// store starting path
			args.exec_path = exec_path;
			
			LOG.warn('starting ' + size + ' [' + server_type + '] servers', l_name);
			
			// store an entry for the callback when all servers are started as requested
			// TODO: if it takes too long to start all app servers, then force return in some interval
			l_pendingStart.push({
				onDone: onDone,
				total: size,
				curr: 0,
				server_type: server_type,
				servers: []
			});
			
			start_server();
		}
		
		var file_path = SR.path.join(exec_path, args.name, 'frontier.js');
		LOG.warn('validate file_path: ' + file_path, l_name);
		
		// verify frontier file exists, if not then we try package.json
		SR.fs.stat(file_path, function (err, stats) {

			// file not found
			if (err) {
				file_path = SR.path.join(exec_path, 'package.json');
				
				// remove server name from parameter 
				args.name = '';
				
				SR.fs.stat(file_path, function (err, stats) {
					if (err) {
						return onExec('cannot find entry file');
					}
					onFound();
				});
			}
			onFound();
		});
	}