gina 0.1.6-alpha.86 → 0.1.6-alpha.88

package/framework/v0.1.6-alpha.88/core/deps/optimist-0.6.1/index.js

@@ -0,0 +1,343 @@
+var path = require('path');
+var minimist = require('minimist');
+var wordwrap = require('wordwrap');
+
+/*  Hack an instance of Argv with process.argv into Argv
+    so people can do
+        require('optimist')(['--beeble=1','-z','zizzle']).argv
+    to parse a list of args and
+        require('optimist').argv
+    to get a parsed version of process.argv.
+*/
+
+var inst = Argv(process.argv.slice(2));
+Object.keys(inst).forEach(function (key) {
+    Argv[key] = typeof inst[key] == 'function'
+        ? inst[key].bind(inst)
+        : inst[key];
+});
+
+var exports = module.exports = Argv;
+function Argv (processArgs, cwd) {
+    var self = {};
+    if (!cwd) cwd = process.cwd();
+    
+    self.$0 = process.argv
+        .slice(0,2)
+        .map(function (x) {
+            var b = rebase(cwd, x);
+            return x.match(/^\//) && b.length < x.length
+                ? b : x
+        })
+        .join(' ')
+    ;
+    
+    if (process.env._ != undefined && process.argv[1] == process.env._) {
+        self.$0 = process.env._.replace(
+            path.dirname(process.execPath) + '/', ''
+        );
+    }
+    
+    var options = {
+        boolean: [],
+        string: [],
+        alias: {},
+        default: []
+    };
+    
+    self.boolean = function (bools) {
+        options.boolean.push.apply(options.boolean, [].concat(bools));
+        return self;
+    };
+    
+    self.string = function (strings) {
+        options.string.push.apply(options.string, [].concat(strings));
+        return self;
+    };
+    
+    self.default = function (key, value) {
+        if (typeof key === 'object') {
+            Object.keys(key).forEach(function (k) {
+                self.default(k, key[k]);
+            });
+        }
+        else {
+            options.default[key] = value;
+        }
+        return self;
+    };
+    
+    self.alias = function (x, y) {
+        if (typeof x === 'object') {
+            Object.keys(x).forEach(function (key) {
+                self.alias(key, x[key]);
+            });
+        }
+        else {
+            options.alias[x] = (options.alias[x] || []).concat(y);
+        }
+        return self;
+    };
+    
+    var demanded = {};
+    self.demand = function (keys) {
+        if (typeof keys == 'number') {
+            if (!demanded._) demanded._ = 0;
+            demanded._ += keys;
+        }
+        else if (Array.isArray(keys)) {
+            keys.forEach(function (key) {
+                self.demand(key);
+            });
+        }
+        else {
+            demanded[keys] = true;
+        }
+        
+        return self;
+    };
+    
+    var usage;
+    self.usage = function (msg, opts) {
+        if (!opts && typeof msg === 'object') {
+            opts = msg;
+            msg = null;
+        }
+        
+        usage = msg;
+        
+        if (opts) self.options(opts);
+        
+        return self;
+    };
+    
+    function fail (msg) {
+        self.showHelp();
+        if (msg) console.error(msg);
+        process.exit(1);
+    }
+    
+    var checks = [];
+    self.check = function (f) {
+        checks.push(f);
+        return self;
+    };
+    
+    var descriptions = {};
+    self.describe = function (key, desc) {
+        if (typeof key === 'object') {
+            Object.keys(key).forEach(function (k) {
+                self.describe(k, key[k]);
+            });
+        }
+        else {
+            descriptions[key] = desc;
+        }
+        return self;
+    };
+    
+    self.parse = function (args) {
+        return parseArgs(args);
+    };
+    
+    self.option = self.options = function (key, opt) {
+        if (typeof key === 'object') {
+            Object.keys(key).forEach(function (k) {
+                self.options(k, key[k]);
+            });
+        }
+        else {
+            if (opt.alias) self.alias(key, opt.alias);
+            if (opt.demand) self.demand(key);
+            if (typeof opt.default !== 'undefined') {
+                self.default(key, opt.default);
+            }
+            
+            if (opt.boolean || opt.type === 'boolean') {
+                self.boolean(key);
+            }
+            if (opt.string || opt.type === 'string') {
+                self.string(key);
+            }
+            
+            var desc = opt.describe || opt.description || opt.desc;
+            if (desc) {
+                self.describe(key, desc);
+            }
+        }
+        
+        return self;
+    };
+    
+    var wrap = null;
+    self.wrap = function (cols) {
+        wrap = cols;
+        return self;
+    };
+    
+    self.showHelp = function (fn) {
+        if (!fn) fn = console.error;
+        fn(self.help());
+    };
+    
+    self.help = function () {
+        var keys = Object.keys(
+            Object.keys(descriptions)
+            .concat(Object.keys(demanded))
+            .concat(Object.keys(options.default))
+            .reduce(function (acc, key) {
+                if (key !== '_') acc[key] = true;
+                return acc;
+            }, {})
+        );
+        
+        var help = keys.length ? [ 'Options:' ] : [];
+        
+        if (usage) {
+            help.unshift(usage.replace(/\$0/g, self.$0), '');
+        }
+        
+        var switches = keys.reduce(function (acc, key) {
+            acc[key] = [ key ].concat(options.alias[key] || [])
+                .map(function (sw) {
+                    return (sw.length > 1 ? '--' : '-') + sw
+                })
+                .join(', ')
+            ;
+            return acc;
+        }, {});
+        
+        var switchlen = longest(Object.keys(switches).map(function (s) {
+            return switches[s] || '';
+        }));
+        
+        var desclen = longest(Object.keys(descriptions).map(function (d) { 
+            return descriptions[d] || '';
+        }));
+        
+        keys.forEach(function (key) {
+            var kswitch = switches[key];
+            var desc = descriptions[key] || '';
+            
+            if (wrap) {
+                desc = wordwrap(switchlen + 4, wrap)(desc)
+                    .slice(switchlen + 4)
+                ;
+            }
+            
+            var spadding = new Array(
+                Math.max(switchlen - kswitch.length + 3, 0)
+            ).join(' ');
+            
+            var dpadding = new Array(
+                Math.max(desclen - desc.length + 1, 0)
+            ).join(' ');
+            
+            var type = null;
+            
+            if (options.boolean[key]) type = '[boolean]';
+            if (options.string[key]) type = '[string]';
+            
+            if (!wrap && dpadding.length > 0) {
+                desc += dpadding;
+            }
+            
+            var prelude = '  ' + kswitch + spadding;
+            var extra = [
+                type,
+                demanded[key]
+                    ? '[required]'
+                    : null
+                ,
+                options.default[key] !== undefined
+                    ? '[default: ' + JSON.stringify(options.default[key]) + ']'
+                    : null
+                ,
+            ].filter(Boolean).join('  ');
+            
+            var body = [ desc, extra ].filter(Boolean).join('  ');
+            
+            if (wrap) {
+                var dlines = desc.split('\n');
+                var dlen = dlines.slice(-1)[0].length
+                    + (dlines.length === 1 ? prelude.length : 0)
+                
+                body = desc + (dlen + extra.length > wrap - 2
+                    ? '\n'
+                        + new Array(wrap - extra.length + 1).join(' ')
+                        + extra
+                    : new Array(wrap - extra.length - dlen + 1).join(' ')
+                        + extra
+                );
+            }
+            
+            help.push(prelude + body);
+        });
+        
+        help.push('');
+        return help.join('\n');
+    };
+    
+    Object.defineProperty(self, 'argv', {
+        get : function () { return parseArgs(processArgs) },
+        enumerable : true,
+    });
+    
+    function parseArgs (args) {
+        var argv = minimist(args, options);
+        argv.$0 = self.$0;
+        
+        if (demanded._ && argv._.length < demanded._) {
+            fail('Not enough non-option arguments: got '
+                + argv._.length + ', need at least ' + demanded._
+            );
+        }
+        
+        var missing = [];
+        Object.keys(demanded).forEach(function (key) {
+            if (!argv[key]) missing.push(key);
+        });
+        
+        if (missing.length) {
+            fail('Missing required arguments: ' + missing.join(', '));
+        }
+        
+        checks.forEach(function (f) {
+            try {
+                if (f(argv) === false) {
+                    fail('Argument check failed: ' + f.toString());
+                }
+            }
+            catch (err) {
+                fail(err)
+            }
+        });
+        
+        return argv;
+    }
+    
+    function longest (xs) {
+        return Math.max.apply(
+            null,
+            xs.map(function (x) { return x.length })
+        );
+    }
+    
+    return self;
+};
+
+// rebase an absolute path to a relative one with respect to a base directory
+// exported for tests
+exports.rebase = rebase;
+function rebase (base, dir) {
+    var ds = path.normalize(dir).split('/').slice(1);
+    var bs = path.normalize(base).split('/').slice(1);
+    
+    for (var i = 0; ds[i] && ds[i] == bs[i]; i++);
+    ds.splice(0, i); bs.splice(0, i);
+    
+    var p = path.normalize(
+        bs.map(function () { return '..' }).concat(ds).join('/')
+    ).replace(/\/$/,'').replace(/^$/, '.');
+    return p.match(/^[.\/]/) ? p : './' + p;
+};

package/framework/v0.1.6-alpha.88/core/deps/optimist-0.6.1/package.json

@@ -0,0 +1,31 @@
+{
+    "name" : "optimist",
+    "version" : "0.6.1",
+    "description" : "Light-weight option parsing with an argv hash. No optstrings attached.",
+    "main" : "./index.js",
+    "dependencies" : {
+        "wordwrap" : "~1.0.0",
+        "minimist" : "~1.2.8"
+    },
+    "scripts" : {
+        "test" : "tap ./test/*.js"
+    },
+    "keywords" : [
+        "argument",
+        "args",
+        "option",
+        "parser",
+        "parsing",
+        "cli",
+        "command"
+    ],
+    "author" : {
+        "name" : "James Halliday",
+        "email" : "mail@substack.net",
+        "url" : "http://substack.net"
+    },
+    "license" : "MIT/X11",
+    "engine" : {
+        "node" : ">=0.4"
+    }
+}

package/framework/v0.1.6-alpha.88/core/deps/optimist-0.6.1/package.json.dist

@@ -0,0 +1,39 @@
+{
+    "name" : "optimist",
+    "version" : "0.6.1",
+    "description" : "Light-weight option parsing with an argv hash. No optstrings attached.",
+    "main" : "./index.js",
+    "dependencies" : {
+        "wordwrap" : "~0.0.2",
+        "minimist" : "~0.0.1"
+    },
+    "devDependencies" : {
+        "hashish": "~0.0.4",
+        "tap" : "~0.4.0"
+    },
+    "scripts" : {
+        "test" : "tap ./test/*.js"
+    },
+    "repository" : {
+        "type" : "git",
+        "url" : "http://github.com/substack/node-optimist.git"
+    },
+    "keywords" : [
+        "argument",
+        "args",
+        "option",
+        "parser",
+        "parsing",
+        "cli",
+        "command"
+    ],
+    "author" : {
+        "name" : "James Halliday",
+        "email" : "mail@substack.net",
+        "url" : "http://substack.net"
+    },
+    "license" : "MIT/X11",
+    "engine" : {
+        "node" : ">=0.4"
+    }
+}