lint child_process.js

lib/child_process.js

@@ -5,35 +5,34 @@ var InternalChildProcess = process.binding('child_process').ChildProcess;
 var constants;
 
 
-var spawn = exports.spawn = function (path, args /*, options OR env, customFds */) {
+var spawn = exports.spawn = function(path, args /*, options, customFds */) {
   var child = new ChildProcess();
   child.spawn.apply(child, arguments);
   return child;
 };
 
-exports.exec = function (command /*, options, callback */) {
+exports.exec = function(command /*, options, callback */) {
   var _slice = Array.prototype.slice;
-  var args = ["/bin/sh", ["-c", command]].concat(_slice.call(arguments, 1));
+  var args = ['/bin/sh', ['-c', command]].concat(_slice.call(arguments, 1));
-  return exports.execFile.apply(this, args)
+  return exports.execFile.apply(this, args);
 };
 
 
-// execFile("something.sh", { env: ENV }, function() { })
+// execFile('something.sh', { env: ENV }, function() { })
 
-exports.execFile = function (file /* args, options, callback */) {
+exports.execFile = function(file /* args, options, callback */) {
-  var options = { encoding: 'utf8'
+  var options = { encoding: 'utf8',
-                , timeout: 0
+                  timeout: 0,
-                , maxBuffer: 200*1024
+                  maxBuffer: 200 * 1024,
-                , killSignal: 'SIGTERM'
+                  killSignal: 'SIGTERM',
-                , cwd: null
+                  cwd: null,
-                , env: null
+                  env: null };
-                };
   var args, optionArg, callback;
 
   // Parse the parameters.
 
-  if (typeof arguments[arguments.length-1] === "function") {
+  if (typeof arguments[arguments.length - 1] === 'function') {
-    callback = arguments[arguments.length-1];
+    callback = arguments[arguments.length - 1];
   }
 
   if (Array.isArray(arguments[1])) {
@@ -54,13 +53,13 @@ exports.execFile = function (file /* args, options, callback */) {
   }
 
   var child = spawn(file, args, {cwd: options.cwd, env: options.env});
-  var stdout = "";
+  var stdout = '';
-  var stderr = "";
+  var stderr = '';
   var killed = false;
   var exited = false;
   var timeoutId;
 
-  function exithandler (code, signal) {
+  function exithandler(code, signal) {
     if (exited) return;
     exited = true;
 
@@ -74,7 +73,7 @@ exports.execFile = function (file /* args, options, callback */) {
     if (code === 0 && signal === null) {
       callback(null, stdout, stderr);
     } else {
-      var e = new Error("Command failed: " + stderr);
+      var e = new Error('Command failed: ' + stderr);
       e.killed = child.killed || killed;
       e.code = code;
       e.signal = signal;
@@ -82,16 +81,16 @@ exports.execFile = function (file /* args, options, callback */) {
     }
   }
 
-  function kill () {
+  function kill() {
     killed = true;
     child.kill(options.killSignal);
-    process.nextTick(function () {
+    process.nextTick(function() {
-      exithandler(null, options.killSignal)
+      exithandler(null, options.killSignal);
     });
   }
 
   if (options.timeout > 0) {
-    timeoutId = setTimeout(function () {
+    timeoutId = setTimeout(function() {
       kill();
       timeoutId = null;
     }, options.timeout);
@@ -100,27 +99,27 @@ exports.execFile = function (file /* args, options, callback */) {
   child.stdout.setEncoding(options.encoding);
   child.stderr.setEncoding(options.encoding);
 
-  child.stdout.addListener("data", function (chunk) {
+  child.stdout.addListener('data', function(chunk) {
     stdout += chunk;
     if (stdout.length > options.maxBuffer) {
       kill();
     }
   });
 
-  child.stderr.addListener("data", function (chunk) {
+  child.stderr.addListener('data', function(chunk) {
     stderr += chunk;
     if (stderr.length > options.maxBuffer) {
       kill();
     }
   });
 
-  child.addListener("exit", exithandler);
+  child.addListener('exit', exithandler);
 
   return child;
 };
 
 
-function ChildProcess () {
+function ChildProcess() {
   EventEmitter.call(this);
 
   var self = this;
@@ -132,57 +131,57 @@ function ChildProcess () {
   var termSignal;
   var internal = this._internal = new InternalChildProcess();
 
-  var stdin  = this.stdin  = new Stream();
+  var stdin = this.stdin = new Stream();
   var stdout = this.stdout = new Stream();
   var stderr = this.stderr = new Stream();
 
   var stderrClosed = false;
   var stdoutClosed = false;
 
-  stderr.addListener('close', function () {
+  stderr.addListener('close', function() {
     stderrClosed = true;
     if (gotCHLD && (!self.stdout || stdoutClosed)) {
       self.emit('exit', exitCode, termSignal);
     }
   });
 
-  stdout.addListener('close', function () {
+  stdout.addListener('close', function() {
     stdoutClosed = true;
     if (gotCHLD && (!self.stderr || stderrClosed)) {
       self.emit('exit', exitCode, termSignal);
     }
   });
 
-  internal.onexit = function (code, signal) {
+  internal.onexit = function(code, signal) {
     gotCHLD = true;
     exitCode = code;
     termSignal = signal;
     if (self.stdin) {
       self.stdin.end();
     }
-    if (   (!self.stdout || !self.stdout.readable)
+    if ((!self.stdout || !self.stdout.readable) &&
-        && (!self.stderr || !self.stderr.readable)) {
+        (!self.stderr || !self.stderr.readable)) {
       self.emit('exit', exitCode, termSignal);
     }
   };
 
-  this.__defineGetter__('pid', function () { return internal.pid; });
+  this.__defineGetter__('pid', function() { return internal.pid; });
 }
 util.inherits(ChildProcess, EventEmitter);
 
 
-ChildProcess.prototype.kill = function (sig) {
+ChildProcess.prototype.kill = function(sig) {
   if (this._internal.pid) {
     this.killed = true;
-    if (!constants) constants = process.binding("constants");
+    if (!constants) constants = process.binding('constants');
     sig = sig || 'SIGTERM';
-    if (!constants[sig]) throw new Error("Unknown signal: " + sig);
+    if (!constants[sig]) throw new Error('Unknown signal: ' + sig);
     return this._internal.kill(constants[sig]);
   }
 };
 
 
-ChildProcess.prototype.spawn = function (path, args, options, customFds) {
+ChildProcess.prototype.spawn = function(path, args, options, customFds) {
   args = args || [];
 
   var cwd, env;
@@ -190,12 +189,12 @@ ChildProcess.prototype.spawn = function (path, args, options, customFds) {
       options.env === undefined &&
       options.customFds === undefined) {
     // Deprecated API: (path, args, options, env, customFds)
-    cwd = "";
+    cwd = '';
     env = options || process.env;
     customFds = customFds || [-1, -1, -1];
   } else {
     // Recommended API: (path, args, options)
-    cwd = options.cwd || "";
+    cwd = options.cwd || '';
     env = options.env || process.env;
     customFds = options.customFds || [-1, -1, -1];
   }
@@ -204,10 +203,11 @@ ChildProcess.prototype.spawn = function (path, args, options, customFds) {
   var keys = Object.keys(env);
   for (var index = 0, keysLength = keys.length; index < keysLength; index++) {
     var key = keys[index];
-    envPairs.push(key + "=" + env[key]);
+    envPairs.push(key + '=' + env[key]);
   }
 
-  var fds = this.fds = this._internal.spawn(path, args, cwd, envPairs, customFds);
+  var fds = this._internal.spawn(path, args, cwd, envPairs, customFds);
+  this.fds = fds;
 
   if (customFds[0] === -1 || customFds[0] === undefined) {
     this.stdin.open(fds[0]);