[dist fix] Give in to more code style OCD.

Author: indexzero

README.md

@@ -1,54 +1,48 @@
 #ps-tree
 
-sometimes you cannot kill child processes like you would expect,  
-this a feature of UNIX.
+Sometimes you cannot kill child processes like you would expect, this a feature of UNIX.
 
->in UNIX,  a process may terminate by using the exit call, and it's parent process may wait for that event by using the wait system call. the wait system call returns the process identifier of a terminated child, so that the parent tell which of the possibly many children has terminated. If the parent terminates, however, all it's children have assigned as their new parent the init process. Thus, the children still have a parent to collect their status and execution statistics.  
+>in UNIX, a process may terminate by using the exit call, and it's parent process may wait for that event by using the wait system call. the wait system call returns the process identifier of a terminated child, so that the parent tell which of the possibly many children has terminated. If the parent terminates, however, all it's children have assigned as their new parent the init process. Thus, the children still have a parent to collect their status and execution statistics.
 > (from "operating system concepts")
 
-solution: use `ps-tree` to get all processes that a child_process may have started, so that they may all be terminated.
+Solution: use `ps-tree` to get all processes that a `child_process` may have started, so that they may all be terminated.
 
 ``` js
 var cp = require('child_process'),
     psTree = require('ps-tree')
 
 var child = cp.exec("node -e 'while (true);'",function () {...})
 
-child.kill() //this will not actually kill the child it will kill the `sh` process.
-
+// This will not actually kill the child it will kill the `sh` process.
+child.kill();
 ```
 
 wtf? it's because exec actually works like this:
 
 ``` js
 function exec (cmd, cb) {
-  spawn('sh', ['-c', cmd])
+  spawn('sh', ['-c', cmd]);
   ...
 }
-
 ```
 
-sh starts parses the command string and starts processes, and waits for them to terminate.  
-but exec returns a process object with the pid of the sh process.  
-but since it is in `wait` mode killing it does not kill the children.
+`sh` starts parses the command string and starts processes, and waits for them to terminate, but `exec` returns a process object with the pid of the `sh` process.
+However, since it is in `wait` mode killing it does not kill the children.
 
-used ps tree like this:
+Use `ps-tree` like this:
 
 ``` js
 var cp = require('child_process'),
-    psTree = require('ps-tree')
+    psTree = require('ps-tree');
 
-var child = cp.exec("node -e 'while (true);'",function () {...})
+var child = cp.exec("node -e 'while (true);'", function () { /*...*/ });
 
 psTree(child.pid, function (err, children) {
-  cp.spawn('kill', ['-9'].concat(children.map(function (p) {return p.PID})))
-})
-
+  cp.spawn('kill', ['-9'].concat(children.map(function (p) { return p.PID })));
+});
 ```
 
-If you prefer to run **psTree** from the command line,
-use: `node ./bin/ps-tree.js`
-
+If you prefer to run **psTree** from the command line, use: `node ./bin/ps-tree.js`
 
 [![Build Status](https://travis-ci.org/nelsonic/ps-tree.svg)](https://travis-ci.org/nelsonic/ps-tree)
 [![Code Climate](https://codeclimate.com/github/nelsonic/ps-tree/badges/gpa.svg)](https://codeclimate.com/github/nelsonic/ps-tree)

bin/ps-tree.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
+
 'use strict';
+
 require('../')(process.argv[2] || 1, function (err, data) {
-  console.log(data)
+  console.log(data);
 });

index.js

@@ -1,43 +1,50 @@
+'use strict';
+
 var spawn = require('child_process').spawn,
     es    = require('event-stream');
 
-module.exports = childrenOfPid
-
-function childrenOfPid( pid, callback) {
+module.exports = function childrenOfPid(pid, callback) {
   var headers = null;
 
-  if('function' !== typeof callback)
-    throw new Error('childrenOfPid(pid, callback) expects callback')
-  if('number' == typeof pid)
-    pid = pid.toString()
+  if (typeof callback !== 'function') {
+    throw new Error('childrenOfPid(pid, callback) expects callback');
+  }
+
+  if (typeof pid === 'number') {
+    pid = pid.toString();
+  }
 
   es.connect(
     spawn('ps', ['-A', '-o', 'ppid,pid,stat,comm']).stdout,
     es.split(),
     es.map(function (line, cb) { //this could parse alot of unix command output
-      var columns = line.trim().split(/\s+/)
-      if(!headers)
-        headers = columns
-      else {
-        var row = {}
-        //for each header,
-        var h = headers.slice()
-        while (h.length) {
-          row[h.shift()] = h.length ? columns.shift() : columns.join(' ')
-        }
-        return cb(null, row)
+      var columns = line.trim().split(/\s+/);
+      if (!headers) {
+        headers = columns;
+        return cb();
       }
-      return cb()
+
+      var row = {};
+      // For each header
+      var h = headers.slice();
+      while (h.length) {
+        row[h.shift()] = h.length ? columns.shift() : columns.join(' ');
+      }
+
+      return cb(null, row);
     }),
     es.writeArray(function (err, ps) {
-      var parents = [pid], children = []
+      var parents = [pid],
+          children = [];
+
       ps.forEach(function (proc) {
-        if(-1 != parents.indexOf(proc.PPID)) {
+        if (parents.indexOf(proc.PPID) !== -1) {
           parents.push(proc.PID)
           children.push(proc)
         }
-      })
-      callback(null, children)
+      });
+
+      callback(null, children);
     })
   ).on('error', callback)
 }