node_task 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99371ce07a364bd79a8ebd136177535137e3442a
-  data.tar.gz: 20fb597da7f7c1de8f3e918a31d801a1a0690860
+  metadata.gz: 79735e5f4ab699858eef9104cf225f8e4e1a4f3e
+  data.tar.gz: d7bd36c0567068bcce877b3a9eb684e553d2cefa
 SHA512:
-  metadata.gz: 3fdd69c969a45c4c8fe489d2c46b0f196b71a1e1b01cff6357d9e3dea39ac21dc9882e44127f382079ba1f6311bbc8fd299f8b53025749a82e6862fb924c8784
-  data.tar.gz: 9606ed4cfb79ee0c791c6ed512be8adafb279d8c1ff3525f1818857d98406fb7b1c72d311805b36f3c75668002fbb76b6ba3b3abb89e7fd9effeb15c55bc44a6
+  metadata.gz: 27f366f9e2b2269b46eb86b6065e5cd6872924bc1299d4116b70713a04eb87f439e20025eb648cb63db301a422b9b93b5caffec0b73f1d2885010970ed117f90
+  data.tar.gz: cd225c6b382359ad8b550bde59043affc81f4e566d6978440844c008b0e79c8a99bee4a6411856f452b3bebe98f41f906c525110c2a9f65d72ac52aceda544e9

data/lib/node_task/index.js

@@ -1,16 +1,16 @@
 var fs = require('fs')
 var path = require('path')
 var net = require('net')
-var winston = require('winston')
 var ndjson = require('ndjson')
 
 var workingDir = path.resolve(process.env.NODE_TASK_CWD || __dirname)
 var errorLogPath = path.join(workingDir, 'ruby_node_task-error.log')
+var debugLogPath = path.join(workingDir, 'ruby_node_task-debug.log')
 
 // write pidfile
 fs.writeFileSync(path.join(workingDir, 'ruby_node_task.pid'), process.pid+'')
 
-var logger = makeLogger(workingDir, process.env.NODE_TASK_DEBUG)
+var logger = makeLogger(debugLogPath, process.env.NODE_TASK_DEBUG_LOG)
 
 var sockPath = process.env.NODE_TASK_SOCK_PATH || makeSockPath(
   workingDir,
@@ -80,16 +80,13 @@ function onClientConnect(socket) {
 }
 
 function onUncaughtException(err) {
-  logger.error('uncaught exception: '+err.toString(), function () {
-    try {
-      fs.writeFileSync(errorLogPath, err.stack)
-    } catch (err) {
-      return logger.error('logging error: '+err.toString(), function () {
-        process.exit()
-      })
-    }
-    process.exit()
-  })
+  try {
+    fs.appendFileSync(errorLogPath, err.stack)
+  } catch (err) {}
+
+  logger.error('uncaught exception: '+formatError(err))
+
+  process.exit()
 }
 
 function onExit() {
@@ -101,15 +98,25 @@ function onExit() {
   }
 }
 
-function makeLogger(workingDir, debug) {
-  return new winston.Logger({
-    transports: [
-      debug ? new winston.transports.File({
-        filename: path.join(workingDir, 'ruby_node_task-debug.log'),
-        level: 'debug',
-      }) : new winston.transports.Console(),
-    ],
-  })
+function makeLogger(logFilePath, debug) {
+  function log(level, msg) {
+    try {
+      fs.appendFileSync(logFilePath, new Date().toISOString()+' -- '+level+' -- '+msg+'\n')
+    } catch (e) {}
+  }
+
+  return {
+    error: function(err) {
+      log('error', formatError(err))
+    },
+    debug: function(msg) {
+      if (debug) log('debug', msg)
+    },
+  }
+}
+
+function formatError(err) {
+  return err && err.stack && JSON.stringify(err.stack) || err
 }
 
 // make a path for a cross platform compatible socket path

data/lib/node_task/node_modules/ndjson/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+var fs = require('fs')
+var ndjson = require('./index.js')
+var minimist = require('minimist')
+
+var args = minimist(process.argv.slice(2))
+
+var inputStream
+
+var first = args._[0]
+if (!first) {
+  console.error('Usage: ndjson [input] <options>')
+  process.exit(1)
+}
+
+if (first === '-') inputStream = process.stdin
+else inputStream = fs.createReadStream(first)
+
+var parse = ndjson.parse(args)
+var serializer = ndjson.serialize(args)
+  
+inputStream.pipe(parse).pipe(serializer).pipe(process.stdout)

data/lib/node_task/node_modules/ndjson/collaborators.md

@@ -0,0 +1,7 @@
+## Collaborators
+
+ldjson-stream is only possible due to the excellent work of the following collaborators:
+
+<table><tbody><tr><th align="left">maxogden</th><td><a href="https://github.com/maxogden">GitHub/maxogden</a></td></tr>
+<tr><th align="left">finnp</th><td><a href="https://github.com/finnp">GitHub/finnp</a></td></tr>
+</tbody></table>

data/lib/node_task/node_modules/ndjson/index.js

@@ -0,0 +1,30 @@
+var through = require('through2')
+var split = require('split2')
+var EOL = require('os').EOL
+
+module.exports = parse
+module.exports.serialize = module.exports.stringify = serialize
+module.exports.parse = parse
+
+function parse (opts) {
+  opts = opts || {}
+  opts.strict = opts.strict !== false
+
+  function parseRow (row) {
+    try {
+      if (row) return JSON.parse(row)
+    } catch (e) {
+      if (opts.strict) {
+        this.emit('error', new Error('Could not parse row ' + row.slice(0, 50) + '...'))
+      }
+    }
+  }
+
+  return split(parseRow)
+}
+
+function serialize (opts) {
+  return through.obj(function(obj, enc, cb) {
+    cb(null, JSON.stringify(obj) + EOL)
+  })
+}

data/lib/node_task/node_modules/ndjson/node_modules/minimist/example/parse.js

@@ -0,0 +1,2 @@
+var argv = require('../')(process.argv.slice(2));
+console.dir(argv);

data/lib/node_task/node_modules/ndjson/node_modules/minimist/index.js

@@ -0,0 +1,236 @@
+module.exports = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {}, unknownFn: null };
+
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
+
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+     });
+
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
+
+    function setArg (key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false) return;
+        }
+
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+
+    function setKey (obj, keys, value) {
+        var o = obj;
+        keys.slice(0,-1).forEach(function (key) {
+            if (o[key] === undefined) o[key] = {};
+            o = o[key];
+        });
+
+        var key = keys[keys.length - 1];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [ o[key], value ];
+        }
+    }
+    
+    function aliasIsBoolean(key) {
+      return aliases[key].some(function (x) {
+          return flags.bools[x];
+      });
+    }
+
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
+            }
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next, arg)
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i+1], arg);
+                    i++;
+                }
+                else if (args[i+1] && /true|false/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(
+                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+                );
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
+    }
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+

data/lib/node_task/node_modules/ndjson/node_modules/minimist/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "minimist",
+  "version": "1.2.0",
+  "description": "parse argument options",
+  "main": "index.js",
+  "devDependencies": {
+    "covert": "^1.0.0",
+    "tap": "~0.4.0",
+    "tape": "^3.5.0"
+  },
+  "scripts": {
+    "test": "tap test/*.js",
+    "coverage": "covert test/*.js"
+  },
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/6..latest",
+      "ff/5",
+      "firefox/latest",
+      "chrome/10",
+      "chrome/latest",
+      "safari/5.1",
+      "safari/latest",
+      "opera/12"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/substack/minimist.git"
+  },
+  "homepage": "https://github.com/substack/minimist",
+  "keywords": [
+    "argv",
+    "getopt",
+    "parser",
+    "optimist"
+  ],
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "license": "MIT",
+  "gitHead": "dc624482fcfec5bc669c68cdb861f00573ed4e64",
+  "bugs": {
+    "url": "https://github.com/substack/minimist/issues"
+  },
+  "_id": "minimist@1.2.0",
+  "_shasum": "a35008b20f41383eec1fb914f4cd5df79a264284",
+  "_from": "minimist@>=1.2.0 <2.0.0",
+  "_npmVersion": "3.2.2",
+  "_nodeVersion": "2.4.0",
+  "_npmUser": {
+    "name": "substack",
+    "email": "substack@gmail.com"
+  },
+  "dist": {
+    "shasum": "a35008b20f41383eec1fb914f4cd5df79a264284",
+    "tarball": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz"
+  },
+  "maintainers": [
+    {
+      "name": "substack",
+      "email": "mail@substack.net"
+    }
+  ],
+  "directories": {},
+  "_resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

data/lib/node_task/node_modules/ndjson/node_modules/minimist/readme.markdown

@@ -0,0 +1,91 @@
+# minimist
+
+parse argument options
+
+This module is the guts of optimist's argument parser without all the
+fanciful decoration.
+
+[![browser support](https://ci.testling.com/substack/minimist.png)](http://ci.testling.com/substack/minimist)
+
+[![build status](https://secure.travis-ci.org/substack/minimist.png)](http://travis-ci.org/substack/minimist)
+
+# example
+
+``` js
+var argv = require('minimist')(process.argv.slice(2));
+console.dir(argv);
+```
+
+```
+$ node example/parse.js -a beep -b boop
+{ _: [], a: 'beep', b: 'boop' }
+```
+
+```
+$ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
+{ _: [ 'foo', 'bar', 'baz' ],
+  x: 3,
+  y: 4,
+  n: 5,
+  a: true,
+  b: true,
+  c: true,
+  beep: 'boop' }
+```
+
+# methods
+
+``` js
+var parseArgs = require('minimist')
+```
+
+## var argv = parseArgs(args, opts={})
+
+Return an argument object `argv` populated with the array arguments from `args`.
+
+`argv._` contains all the arguments that didn't have an option associated with
+them.
+
+Numeric-looking arguments will be returned as numbers unless `opts.string` or
+`opts.boolean` is set for that argument name.
+
+Any arguments after `'--'` will not be parsed and will end up in `argv._`.
+
+options can be:
+
+* `opts.string` - a string or array of strings argument names to always treat as
+strings
+* `opts.boolean` - a boolean, string or array of strings to always treat as
+booleans. if `true` will treat all double hyphenated arguments without equal signs
+as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`)
+* `opts.alias` - an object mapping string names to strings or arrays of string
+argument names to use as aliases
+* `opts.default` - an object mapping string argument names to default values
+* `opts.stopEarly` - when true, populate `argv._` with everything after the
+first non-option
+* `opts['--']` - when true, populate `argv._` with everything before the `--`
+and `argv['--']` with everything after the `--`. Here's an example:
+* `opts.unknown` - a function which is invoked with a command line parameter not
+defined in the `opts` configuration object. If the function returns `false`, the
+unknown option is not added to `argv`.
+
+```
+> require('./')('one two three -- four five --six'.split(' '), { '--': true })
+{ _: [ 'one', 'two', 'three' ],
+  '--': [ 'four', 'five', '--six' ] }
+```
+
+Note that with `opts['--']` set, parsing for arguments still stops after the
+`--`.
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install minimist
+```
+
+# license
+
+MIT

data/lib/node_task/node_modules/ndjson/node_modules/minimist/test/all_bool.js

@@ -0,0 +1,32 @@
+var parse = require('../');
+var test = require('tape');
+
+test('flag boolean true (default all --args to boolean)', function (t) {
+    var argv = parse(['moo', '--honk', 'cow'], {
+        boolean: true
+    });
+    
+    t.deepEqual(argv, {
+        honk: true,
+        _: ['moo', 'cow']
+    });
+    
+    t.deepEqual(typeof argv.honk, 'boolean');
+    t.end();
+});
+
+test('flag boolean true only affects double hyphen arguments without equals signs', function (t) {
+    var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], {
+        boolean: true
+    });
+    
+    t.deepEqual(argv, {
+        honk: true,
+        tacos: 'good',
+        p: 55,
+        _: ['moo', 'cow']
+    });
+    
+    t.deepEqual(typeof argv.honk, 'boolean');
+    t.end();
+});