Name: js-handler/node_modules/optimist/index.js 
1:
var path = require('path');
2:
var minimist = require('minimist');
3:
var wordwrap = require('wordwrap');
4:
 
5:
/*  Hack an instance of Argv with process.argv into Argv
6:
    so people can do
7:
        require('optimist')(['--beeble=1','-z','zizzle']).argv
8:
    to parse a list of args and
9:
        require('optimist').argv
10:
    to get a parsed version of process.argv.
11:
*/
12:
 
13:
var inst = Argv(process.argv.slice(2));
14:
Object.keys(inst).forEach(function (key) {
15:
    Argv[key] = typeof inst[key] == 'function'
16:
        ? inst[key].bind(inst)
17:
        : inst[key];
18:
});
19:
 
20:
var exports = module.exports = Argv;
21:
function Argv (processArgs, cwd) {
22:
    var self = {};
23:
    if (!cwd) cwd = process.cwd();
24:
    
25:
    self.$0 = process.argv
26:
        .slice(0,2)
27:
        .map(function (x) {
28:
            var b = rebase(cwd, x);
29:
            return x.match(/^\//) && b.length < x.length
30:
                ? b : x
31:
        })
32:
        .join(' ')
33:
    ;
34:
    
35:
    if (process.env._ != undefined && process.argv[1] == process.env._) {
36:
        self.$0 = process.env._.replace(
37:
            path.dirname(process.execPath) + '/', ''
38:
        );
39:
    }
40:
    
41:
    var options = {
42:
        boolean: [],
43:
        string: [],
44:
        alias: {},
45:
        default: []
46:
    };
47:
    
48:
    self.boolean = function (bools) {
49:
        options.boolean.push.apply(options.boolean, [].concat(bools));
50:
        return self;
51:
    };
52:
    
53:
    self.string = function (strings) {
54:
        options.string.push.apply(options.string, [].concat(strings));
55:
        return self;
56:
    };
57:
    
58:
    self.default = function (key, value) {
59:
        if (typeof key === 'object') {
60:
            Object.keys(key).forEach(function (k) {
61:
                self.default(k, key[k]);
62:
            });
63:
        }
64:
        else {
65:
            options.default[key] = value;
66:
        }
67:
        return self;
68:
    };
69:
    
70:
    self.alias = function (x, y) {
71:
        if (typeof x === 'object') {
72:
            Object.keys(x).forEach(function (key) {
73:
                self.alias(key, x[key]);
74:
            });
75:
        }
76:
        else {
77:
            options.alias[x] = (options.alias[x] || []).concat(y);
78:
        }
79:
        return self;
80:
    };
81:
    
82:
    var demanded = {};
83:
    self.demand = function (keys) {
84:
        if (typeof keys == 'number') {
85:
            if (!demanded._) demanded._ = 0;
86:
            demanded._ += keys;
87:
        }
88:
        else if (Array.isArray(keys)) {
89:
            keys.forEach(function (key) {
90:
                self.demand(key);
91:
            });
92:
        }
93:
        else {
94:
            demanded[keys] = true;
95:
        }
96:
        
97:
        return self;
98:
    };
99:
    
100:
    var usage;
101:
    self.usage = function (msg, opts) {
102:
        if (!opts && typeof msg === 'object') {
103:
            opts = msg;
104:
            msg = null;
105:
        }
106:
        
107:
        usage = msg;
108:
        
109:
        if (opts) self.options(opts);
110:
        
111:
        return self;
112:
    };
113:
    
114:
    function fail (msg) {
115:
        self.showHelp();
116:
        if (msg) console.error(msg);
117:
        process.exit(1);
118:
    }
119:
    
120:
    var checks = [];
121:
    self.check = function (f) {
122:
        checks.push(f);
123:
        return self;
124:
    };
125:
    
126:
    var descriptions = {};
127:
    self.describe = function (key, desc) {
128:
        if (typeof key === 'object') {
129:
            Object.keys(key).forEach(function (k) {
130:
                self.describe(k, key[k]);
131:
            });
132:
        }
133:
        else {
134:
            descriptions[key] = desc;
135:
        }
136:
        return self;
137:
    };
138:
    
139:
    self.parse = function (args) {
140:
        return parseArgs(args);
141:
    };
142:
    
143:
    self.option = self.options = function (key, opt) {
144:
        if (typeof key === 'object') {
145:
            Object.keys(key).forEach(function (k) {
146:
                self.options(k, key[k]);
147:
            });
148:
        }
149:
        else {
150:
            if (opt.alias) self.alias(key, opt.alias);
151:
            if (opt.demand) self.demand(key);
152:
            if (typeof opt.default !== 'undefined') {
153:
                self.default(key, opt.default);
154:
            }
155:
            
156:
            if (opt.boolean || opt.type === 'boolean') {
157:
                self.boolean(key);
158:
            }
159:
            if (opt.string || opt.type === 'string') {
160:
                self.string(key);
161:
            }
162:
            
163:
            var desc = opt.describe || opt.description || opt.desc;
164:
            if (desc) {
165:
                self.describe(key, desc);
166:
            }
167:
        }
168:
        
169:
        return self;
170:
    };
171:
    
172:
    var wrap = null;
173:
    self.wrap = function (cols) {
174:
        wrap = cols;
175:
        return self;
176:
    };
177:
    
178:
    self.showHelp = function (fn) {
179:
        if (!fn) fn = console.error;
180:
        fn(self.help());
181:
    };
182:
    
183:
    self.help = function () {
184:
        var keys = Object.keys(
185:
            Object.keys(descriptions)
186:
            .concat(Object.keys(demanded))
187:
            .concat(Object.keys(options.default))
188:
            .reduce(function (acc, key) {
189:
                if (key !== '_') acc[key] = true;
190:
                return acc;
191:
            }, {})
192:
        );
193:
        
194:
        var help = keys.length ? [ 'Options:' ] : [];
195:
        
196:
        if (usage) {
197:
            help.unshift(usage.replace(/\$0/g, self.$0), '');
198:
        }
199:
        
200:
        var switches = keys.reduce(function (acc, key) {
201:
            acc[key] = [ key ].concat(options.alias[key] || [])
202:
                .map(function (sw) {
203:
                    return (sw.length > 1 ? '--' : '-') + sw
204:
                })
205:
                .join(', ')
206:
            ;
207:
            return acc;
208:
        }, {});
209:
        
210:
        var switchlen = longest(Object.keys(switches).map(function (s) {
211:
            return switches[s] || '';
212:
        }));
213:
        
214:
        var desclen = longest(Object.keys(descriptions).map(function (d) {
215:
            return descriptions[d] || '';
216:
        }));
217:
        
218:
        keys.forEach(function (key) {
219:
            var kswitch = switches[key];
220:
            var desc = descriptions[key] || '';
221:
            
222:
            if (wrap) {
223:
                desc = wordwrap(switchlen + 4, wrap)(desc)
224:
                    .slice(switchlen + 4)
225:
                ;
226:
            }
227:
            
228:
            var spadding = new Array(
229:
                Math.max(switchlen - kswitch.length + 3, 0)
230:
            ).join(' ');
231:
            
232:
            var dpadding = new Array(
233:
                Math.max(desclen - desc.length + 1, 0)
234:
            ).join(' ');
235:
            
236:
            var type = null;
237:
            
238:
            if (options.boolean[key]) type = '[boolean]';
239:
            if (options.string[key]) type = '[string]';
240:
            
241:
            if (!wrap && dpadding.length > 0) {
242:
                desc += dpadding;
243:
            }
244:
            
245:
            var prelude = '  ' + kswitch + spadding;
246:
            var extra = [
247:
                type,
248:
                demanded[key]
249:
                    ? '[required]'
250:
                    : null
251:
                ,
252:
                options.default[key] !== undefined
253:
                    ? '[default: ' + JSON.stringify(options.default[key]) + ']'
254:
                    : null
255:
                ,
256:
            ].filter(Boolean).join('  ');
257:
            
258:
            var body = [ desc, extra ].filter(Boolean).join('  ');
259:
            
260:
            if (wrap) {
261:
                var dlines = desc.split('\n');
262:
                var dlen = dlines.slice(-1)[0].length
263:
                    + (dlines.length === 1 ? prelude.length : 0)
264:
                
265:
                body = desc + (dlen + extra.length > wrap - 2
266:
                    ? '\n'
267:
                        + new Array(wrap - extra.length + 1).join(' ')
268:
                        + extra
269:
                    : new Array(wrap - extra.length - dlen + 1).join(' ')
270:
                        + extra
271:
                );
272:
            }
273:
            
274:
            help.push(prelude + body);
275:
        });
276:
        
277:
        help.push('');
278:
        return help.join('\n');
279:
    };
280:
    
281:
    Object.defineProperty(self, 'argv', {
282:
        get : function () { return parseArgs(processArgs) },
283:
        enumerable : true,
284:
    });
285:
    
286:
    function parseArgs (args) {
287:
        var argv = minimist(args, options);
288:
        argv.$0 = self.$0;
289:
        
290:
        if (demanded._ && argv._.length < demanded._) {
291:
            fail('Not enough non-option arguments: got '
292:
                + argv._.length + ', need at least ' + demanded._
293:
            );
294:
        }
295:
        
296:
        var missing = [];
297:
        Object.keys(demanded).forEach(function (key) {
298:
            if (!argv[key]) missing.push(key);
299:
        });
300:
        
301:
        if (missing.length) {
302:
            fail('Missing required arguments: ' + missing.join(', '));
303:
        }
304:
        
305:
        checks.forEach(function (f) {
306:
            try {
307:
                if (f(argv) === false) {
308:
                    fail('Argument check failed: ' + f.toString());
309:
                }
310:
            }
311:
            catch (err) {
312:
                fail(err)
313:
            }
314:
        });
315:
        
316:
        return argv;
317:
    }
318:
    
319:
    function longest (xs) {
320:
        return Math.max.apply(
321:
            null,
322:
            xs.map(function (x) { return x.length })
323:
        );
324:
    }
325:
    
326:
    return self;
327:
};
328:
 
329:
// rebase an absolute path to a relative one with respect to a base directory
330:
// exported for tests
331:
exports.rebase = rebase;
332:
function rebase (base, dir) {
333:
    var ds = path.normalize(dir).split('/').slice(1);
334:
    var bs = path.normalize(base).split('/').slice(1);
335:
    
336:
    for (var i = 0; ds[i] && ds[i] == bs[i]; i++);
337:
    ds.splice(0, i); bs.splice(0, i);
338:
    
339:
    var p = path.normalize(
340:
        bs.map(function () { return '..' }).concat(ds).join('/')
341:
    ).replace(/\/$/,'').replace(/^$/, '.');
342:
    return p.match(/^[.\/]/) ? p : './' + p;
343:
};