updated bunch of file paths and changed the way posts are loaded

node_modules/optimist/index.js

@@ -1,5 +1,4 @@
 var path = require('path');
-var minimist = require('minimist');
 var wordwrap = require('wordwrap');
 
 /*  Hack an instance of Argv with process.argv into Argv
@@ -18,7 +17,7 @@ Object.keys(inst).forEach(function (key) {
 });
 
 var exports = module.exports = Argv;
-function Argv (processArgs, cwd) {
+function Argv (args, cwd) {
     var self = {};
     if (!cwd) cwd = process.cwd();
     
@@ -38,44 +37,50 @@ function Argv (processArgs, cwd) {
         );
     }
     
-    var options = {
-        boolean: [],
-        string: [],
-        alias: {},
-        default: []
-    };
+    var flags = { bools : {}, strings : {} };
     
     self.boolean = function (bools) {
-        options.boolean.push.apply(options.boolean, [].concat(bools));
+        if (!Array.isArray(bools)) {
+            bools = [].slice.call(arguments);
+        }
+        
+        bools.forEach(function (name) {
+            flags.bools[name] = true;
+        });
+        
         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;
-        }
+        if (!Array.isArray(strings)) {
+            strings = [].slice.call(arguments);
+        }
+        
+        strings.forEach(function (name) {
+            flags.strings[name] = true;
+        });
+        
         return self;
     };
     
+    var aliases = {};
     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);
+        else if (Array.isArray(y)) {
+            y.forEach(function (yy) {
+                self.alias(x, yy);
+            });
         }
+        else {
+            var zs = (aliases[x] || []).concat(aliases[y] || []).concat(x, y);
+            aliases[x] = zs.filter(function (z) { return z != x });
+            aliases[y] = zs.filter(function (z) { return z != y });
+        }
+        
         return self;
     };
     
@@ -123,6 +128,20 @@ function Argv (processArgs, cwd) {
         return self;
     };
     
+    var defaults = {};
+    self.default = function (key, value) {
+        if (typeof key === 'object') {
+            Object.keys(key).forEach(function (k) {
+                self.default(k, key[k]);
+            });
+        }
+        else {
+            defaults[key] = value;
+        }
+        
+        return self;
+    };
+    
     var descriptions = {};
     self.describe = function (key, desc) {
         if (typeof key === 'object') {
@@ -137,7 +156,7 @@ function Argv (processArgs, cwd) {
     };
     
     self.parse = function (args) {
-        return parseArgs(args);
+        return Argv(args).argv;
     };
     
     self.option = self.options = function (key, opt) {
@@ -184,7 +203,7 @@ function Argv (processArgs, cwd) {
         var keys = Object.keys(
             Object.keys(descriptions)
             .concat(Object.keys(demanded))
-            .concat(Object.keys(options.default))
+            .concat(Object.keys(defaults))
             .reduce(function (acc, key) {
                 if (key !== '_') acc[key] = true;
                 return acc;
@@ -198,7 +217,7 @@ function Argv (processArgs, cwd) {
         }
         
         var switches = keys.reduce(function (acc, key) {
-            acc[key] = [ key ].concat(options.alias[key] || [])
+            acc[key] = [ key ].concat(aliases[key] || [])
                 .map(function (sw) {
                     return (sw.length > 1 ? '--' : '-') + sw
                 })
@@ -235,8 +254,8 @@ function Argv (processArgs, cwd) {
             
             var type = null;
             
-            if (options.boolean[key]) type = '[boolean]';
-            if (options.string[key]) type = '[string]';
+            if (flags.bools[key]) type = '[boolean]';
+            if (flags.strings[key]) type = '[string]';
             
             if (!wrap && dpadding.length > 0) {
                 desc += dpadding;
@@ -249,8 +268,8 @@ function Argv (processArgs, cwd) {
                     ? '[required]'
                     : null
                 ,
-                options.default[key] !== undefined
-                    ? '[default: ' + JSON.stringify(options.default[key]) + ']'
+                defaults[key] !== undefined
+                    ? '[default: ' + JSON.stringify(defaults[key]) + ']'
                     : null
                 ,
             ].filter(Boolean).join('  ');
@@ -279,13 +298,110 @@ function Argv (processArgs, cwd) {
     };
     
     Object.defineProperty(self, 'argv', {
-        get : function () { return parseArgs(processArgs) },
+        get : parseArgs,
         enumerable : true,
     });
     
-    function parseArgs (args) {
-        var argv = minimist(args, options);
-        argv.$0 = self.$0;
+    function parseArgs () {
+        var argv = { _ : [], $0 : self.$0 };
+        Object.keys(flags.bools).forEach(function (key) {
+            setArg(key, defaults[key] || false);
+        });
+        
+        function setArg (key, val) {
+            var num = Number(val);
+            var value = typeof val !== 'string' || isNaN(num) ? val : num;
+            if (flags.strings[key]) value = val;
+            
+            setKey(argv, key.split('.'), value);
+            
+            (aliases[key] || []).forEach(function (x) {
+                argv[x] = argv[key];
+            });
+        }
+        
+        for (var i = 0; i < args.length; i++) {
+            var arg = args[i];
+            
+            if (arg === '--') {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+            else if (arg.match(/^--.+=/)) {
+                // 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]*)$/);
+                setArg(m[1], m[2]);
+            }
+            else if (arg.match(/^--no-.+/)) {
+                var key = arg.match(/^--no-(.+)/)[1];
+                setArg(key, false);
+            }
+            else if (arg.match(/^--.+/)) {
+                var key = arg.match(/^--(.+)/)[1];
+                var next = args[i + 1];
+                if (next !== undefined && !next.match(/^-/)
+                && !flags.bools[key]
+                && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
+                    setArg(key, next);
+                    i++;
+                }
+                else if (/^(true|false)$/.test(next)) {
+                    setArg(key, next === 'true');
+                    i++;
+                }
+                else {
+                    setArg(key, true);
+                }
+            }
+            else if (arg.match(/^-[^-]+/)) {
+                var letters = arg.slice(1,-1).split('');
+                
+                var broken = false;
+                for (var j = 0; j < letters.length; j++) {
+                    if (letters[j+1] && letters[j+1].match(/\W/)) {
+                        setArg(letters[j], arg.slice(j+2));
+                        broken = true;
+                        break;
+                    }
+                    else {
+                        setArg(letters[j], true);
+                    }
+                }
+                
+                if (!broken) {
+                    var key = arg.slice(-1)[0];
+                    
+                    if (args[i+1] && !args[i+1].match(/^-/)
+                    && !flags.bools[key]
+                    && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
+                        setArg(key, args[i+1]);
+                        i++;
+                    }
+                    else if (args[i+1] && /true|false/.test(args[i+1])) {
+                        setArg(key, args[i+1] === 'true');
+                        i++;
+                    }
+                    else {
+                        setArg(key, true);
+                    }
+                }
+            }
+            else {
+                var n = Number(arg);
+                argv._.push(flags.strings['_'] || isNaN(n) ? arg : n);
+            }
+        }
+        
+        Object.keys(defaults).forEach(function (key) {
+            if (!(key in argv)) {
+                argv[key] = defaults[key];
+                if (key in aliases) {
+                    argv[aliases[key]] = defaults[key];
+                }
+            }
+        });
         
         if (demanded._ && argv._.length < demanded._) {
             fail('Not enough non-option arguments: got '
@@ -341,3 +457,22 @@ function rebase (base, dir) {
     ).replace(/\/$/,'').replace(/^$/, '.');
     return p.match(/^[.\/]/) ? p : './' + p;
 };
+
+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 || typeof o[key] === 'boolean') {
+        o[key] = value;
+    }
+    else if (Array.isArray(o[key])) {
+        o[key].push(value);
+    }
+    else {
+        o[key] = [ o[key], value ];
+    }
+}