sproutit-narwhal 0.1.106

data/engines/rhino/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "narwhal-rhino",
+    "engine": "rhino"
+}

data/engines/secure/lib/file.js

@@ -0,0 +1,6 @@
+
+for (var name in system.fs) {
+    if (Object.prototype.hasOwnProperty.call(system.fs, name))
+        exports[name] = system.fs[name];
+}
+

data/engines/secure/lib/system.js

@@ -0,0 +1,6 @@
+
+for (var name in system) {
+    if (Object.prototype.hasOwnProperty.call(system, name)) {
+        exports[name] = system[name];
+    }
+}

data/engines/template/bin/narwhal-engine-name

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# get the absolute path of the executable
+SELF_PATH=$(cd -P -- "$(dirname -- "$0")" && pwd -P) && SELF_PATH=$SELF_PATH/$(basename -- "$0")
+
+# resolve symlinks
+while [ -h "$SELF_PATH" ]; do
+	DIR=$(dirname -- "$SELF_PATH")
+	SYM=$(readlink -- "$SELF_PATH")
+	SELF_PATH=$(cd -- "$DIR" && cd -- $(dirname -- "$SYM") && pwd)/$(basename -- "$SYM")
+done
+
+NARWHAL_ENGINE_HOME=$(dirname -- $(dirname -- $SELF_PATH))
+BOOTSTRAP="$NARWHAL_ENGINE_HOME/bootstrap.js"
+
+if [ ! "$NARWHAL_HOME" ]; then
+	NARWHAL_HOME=$(dirname -- $(dirname -- $NARWHAL_ENGINE_HOME))
+fi
+
+export NARWHAL_HOME
+
+# uses rlwrap (readline wrapper) if present
+NARWHAL="$(which rlwrap) narwhal-engine" # TODO replace narwhal-engine with js bin
+
+# drop into shell if there are no additional arguments
+if [ $# -lt 1 ]; then
+	# FIXME: no way to explicitly drop into shell
+	$NARWHAL $BOOTSTRAP "$@"
+else
+	MAIN=$(cd -P -- "$(dirname -- "$1")" && pwd -P) && MAIN=$MAIN/$(basename -- "$1" .js)
+	$NARWHAL $BOOTSTRAP $MAIN "$0" "$@"
+fi

data/engines/template/bootstrap.js

@@ -0,0 +1,40 @@
+(function (evalGlobal) {
+
+    var read = /*TODO*/; // function(path:string):string
+
+    var isFile = /*TODO*/; // function(path:string):boolean
+
+    var prefix = "/path/to/narwhal"; /*TODO*/
+    var enginePrefix = "/path/to/engine"; /*TODO*/
+    
+    eval(read(prefix + "/narwhal.js"))({
+        global: this,
+        evalGlobal: evalGlobal,
+        engine: '<<<name>>>', /*TODO*/
+        engines: ['<<<name>>>', 'default'], /*TODO*/
+        os: "", /* TODO /\bwindows\b/i for Windows FS support */
+        // XXX engines may include any number of
+        // prioritized generic engines like:
+        // rhino, java, c, v8, default
+        print: print,
+        evaluate: function (text) {
+            // TODO maybe something better here:
+            return eval(
+                "(function(require,exports,module,system,print){" +
+                text +
+                "/**/\n})"
+            );
+        },
+        fs: {
+            read: read,
+            isFile: isFile
+        },
+        prefix: prefix,
+        prefixes: [prefix, enginePrefix],
+        debug: false,
+        verbose: false
+    });
+
+}).call(this, function () {
+    return eval(arguments[0]);
+});

data/engines/template/lib/file-engine.js

@@ -0,0 +1,118 @@
+
+var exports = require('./file');
+
+exports.SEPARATOR = '/';
+
+exports.cwd = function () {
+    throw Error("cwd not yet implemented.");
+};
+
+// TODO necessary for package loading
+exports.list = function (path) {
+    throw Error("list not yet implemented.");
+};
+
+// TODO necessary for package loading
+exports.canonical = function (path) {
+    throw Error("canonical not yet implemented.");
+};
+
+exports.exists = function (path) {
+    throw Error("exists not yet implemented.");
+};
+
+// TODO necessary for lazy module reloading in sandboxes
+exports.mtime = function (path) {
+    throw Error("mtime not yet implemented.");
+};
+
+exports.size = function (path) {
+    throw Error("size not yet implemented.");
+};
+
+exports.stat = function (path) {
+    return {
+        mtime: exports.mtime(path),
+        size: exports.size(path)
+    }
+};
+
+// TODO necessary for package loading
+exports.isDirectory = function (path) {
+    throw Error("isDirectory not yet implemented.");
+};
+
+// TODO necessary for module loading
+exports.isFile = function (path) {
+    throw Error("isFile not yet implemented.");
+};
+// XXX remove this if you implement isFile here
+// from bootstrap system object:
+exports.isFile = system.fs.isFile;
+
+exports.isFile = system.fs.isFile; // TEMPORARY HACK
+
+exports.isLink = function (path) {
+    throw Error("isLink not yet implemented.");
+};
+
+exports.isReadable = function (path) {
+    throw Error("isReadable not yet implemented.");
+};
+
+exports.isWritable = function (path) {
+    throw Error("isWritable not yet implemented.");
+};
+
+exports.rename = function (source, target) {
+    throw Error("rename not yet implemented.");
+};
+
+exports.move = function (source, target) {
+    throw Error("move not yet implemented.");
+};
+
+exports.remove = function (path) {
+    throw Error("remove not yet implemented.");
+};
+
+exports.mkdir = function (path) {
+    throw Error("mkdir not yet implemented.");
+};
+
+exports.rmdir = function(path) {
+    throw Error("rmdir not yet implemented.");
+};
+
+exports.touch = function (path, mtime) {
+    throw Error("touch not yet implemented.");
+};
+
+// FIXME temporary hack
+var read = system.fs.read; // from bootstrap system object
+
+exports.FileIO = function (path, mode, permissions) {
+    mode = exports.mode(mode);
+    var read = mode.read,
+        write = mode.write,
+        append = mode.append,
+        update = mode.update;
+
+    if (update) {
+        throw new Error("Updating IO not yet implemented.");
+    } else if (write || append) {
+        throw new Error("Writing IO not yet implemented.");
+    } else if (read) {
+        // FIXME temporary hack
+        return {
+            'read': function () {
+                return read(path);
+            },
+            'close': function () {
+            }
+        };
+    } else {
+        throw new Error("Files must be opened either for read, write, or update mode.");
+    }
+};
+

data/engines/template/lib/system.js

@@ -0,0 +1,17 @@
+
+var IO = require("./io").IO;
+
+exports.stdin  = /*TODO*/
+exports.stdout = /*TODO*/
+exports.stderr = /*TODO*/
+
+exports.args = [/*TODO*/];
+
+exports.env = {}; /*TODO*/
+
+exports.fs = require('./file');
+
+// default logger
+var Logger = require("./logger").Logger;
+exports.log = new Logger(exports.stdout);
+

data/examples/browser-deployment-jackconfig.js

@@ -0,0 +1,35 @@
+
+var jackutil = require("jack/utils");
+
+var app = function (env) {
+    if (/^../.test(env.PATH_INFO))
+        return jackutil.responseForStatus(404, env.PATH_INFO);
+    return {
+        "status": 200,
+        "headers": {"Content-type": "text/html"},
+        "body": [
+            "<html><head><script>" +
+
+            // 1.) preload transitive dependencies and
+            //    then require.
+            env.script.require("narwhal/server-test") +
+
+            // 2.) embed with transitive dependencies
+            //env.script.embed("narwhal/server-test") +
+
+            // 3.) no preloading, all async
+            //env.script.loader("narwhal/server-test") +
+            //".async('narwhal/server-test');" +
+
+            "</script></head><body></body></html>"
+        ]
+    };
+};
+app = require("narwhal/server").App(app, {
+    "debug": true // turn off debug for minification
+    //"path": "javascript/", // to use an alternate path to the module tree
+    //"proxy": "http://example.com/.js/", // to use a caching proxy
+});
+app = require("jack").ContentLength(app);
+exports.app = app;
+

data/examples/fibonacci-worker.js

@@ -0,0 +1,35 @@
+// Adapted from https://developer.mozilla.org/En/Using_web_workers
+
+var Worker = require("worker").Worker;
+
+var results = [];
+
+function resultReceiver(event) {
+    results.push(parseInt(event.data));
+    if (results.length == 2) {
+        postMessage(results[0] + results[1]);
+    }
+}
+
+function errorReceiver(event) {
+    throw event.data;
+}
+
+onmessage = function(event) {
+    var n = parseInt(event.data);
+
+    if (n == 0 || n == 1) {
+        postMessage(n);
+        return;
+    }
+
+    for (var i = 1; i <= 2; i++) {
+        var worker = new Worker(module.path);
+        worker.onmessage = resultReceiver;
+        worker.onerror = errorReceiver;
+        worker.postMessage(n - i);
+    }
+};
+
+if (module.id == require.main)
+    print("Run fibonacci.js instead of fibonacci-worker.js");

data/examples/fibonacci.js

@@ -0,0 +1,19 @@
+// Adapted from https://developer.mozilla.org/En/Using_web_workers
+
+var FILE = require("file"),
+    Worker = require("worker").Worker;
+
+var worker = new Worker(FILE.join(FILE.dirname(module.path), "fibonacci-worker.js"));  
+
+worker.onmessage = function(event) {  
+    print("Got: " + event.data);  
+}
+
+worker.onerror = function(error) {  
+    print("Worker error: " + error.message);  
+}
+
+worker.postMessage(5);
+
+// event loop
+while(true) require("event-queue").nextEvent()();

data/examples/hello

@@ -0,0 +1,2 @@
+#!/usr/bin/env narwhal
+print("Hello, World!");

data/examples/narwhal

@@ -0,0 +1,3 @@
+#!/usr/bin/env narwhal
+var narwhal = require('narwhal');
+print(narwhal.LEFT);

data/examples/not-quite-a-quine.js

@@ -0,0 +1 @@
+system.stdout.write(system.fs.read(module.path)).flush();

data/extconf.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+
+# Choose the best default engine for this platform and make it if needed.
+
+NARWHAL_ROOT = File.expand_path(File.dirname(__FILE__))
+CONF_PATH = File.join(NARWHAL_ROOT, 'narwhal.conf')
+MAKEFILE = File.join(NARWHAL_ROOT, 'Makefile')
+
+TEST_PATH = File.join("", "System", "Library", "Frameworks", "JavaScriptCore.framework")
+JSC_ENGINE = File.join(NARWHAL_ROOT, 'engines', 'jsc')
+
+# Detect JSC
+if File.exists?(TEST_PATH) && File.exists?(JSC_ENGINE)
+  puts "Using JavaScript Core Engine"
+
+  fp = File.open(CONF_PATH, 'w+')
+  fp.write %(NARWHAL_ENGINE="jsc"\n)
+  fp.write %(NARWHAL_ENGINE_HOME="engines/jsc"\n)
+  fp.close
+
+  fp = File.open(MAKEFILE, 'w+')
+  fp.write %(default:\n)
+  fp.write %(\tcd #{JSC_ENGINE}; make\n)
+  fp.write %(\n)
+
+  fp.write %(install:\n)
+  fp.write %(\t# do nothing\n)
+  fp.close
+  
+# Fallback  
+else
+  puts "Using Default Rhino Engine"
+  fp = File.open(MAKEFILE, 'w+')
+  fp.write %(default:\n)
+  fp.write %(\n)
+  fp.write %(install:\n)
+  fp.write %(\n)
+  fp.close
+end
+
+  
+  
+  

data/gem_bin/narwhal

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+BIN_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin'))
+exec File.join(BIN_ROOT, 'narwhal'), *ARGV
+ 

data/gem_bin/sea

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+BIN_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin'))
+exec File.join(BIN_ROOT, 'sea'), *ARGV

data/gem_bin/tusk

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+BIN_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin'))
+exec File.join(BIN_ROOT, 'tusk'), *ARGV

data/lib/args.js

@@ -0,0 +1,849 @@
+
+var os = require('os');
+var util = require('util');
+var stream = require('term').stream;
+var system = require('system');
+
+exports.UsageError = function (message) {
+    this.name = "UsageError";
+    this.message = message;
+};
+
+exports.UsageError.prototype = Object.create(Error.prototype);
+
+exports.ConfigurationError = function (message) {
+    this.name = "ConfigurationError";
+    this.message = message;
+};
+
+exports.ConfigurationError.prototype = Object.create(Error.prototype);
+
+exports.Parser = function () {
+    this._options = [];
+    this._def = {};
+    this._long = {};
+    this._short = {};
+    this._commands = {};
+    this._args = [];
+    this._vargs = undefined;
+};
+
+exports.Parser.prototype.option = function () {
+    var option = new this.Option(this, arguments);
+    this._options.push(option);
+    return option;
+};
+
+exports.Parser.prototype.group = function (name) {
+    var group = new this.Group(this, this, name);
+    this._options.push(group);
+    return group;
+};
+
+exports.Parser.prototype.def = function (name, value) {
+    this._def[name] = value;
+    return this;
+};
+
+exports.Parser.prototype.reset = function (options) {
+    for (var name in this._def) {
+        if (util.has(this._def, name))
+            options[name] = util.copy(this._def[name]);
+    }
+    this._options.forEach(function (option) {
+        options[option.getName()] = option._def;
+    });
+};
+
+exports.Parser.prototype.command = function (name, handler) {
+    var parent = this;
+    if (!handler) {
+        var parser = new exports.Parser();
+        this._commands[name] = function () {
+            return parser;
+        };
+        return parser;
+    } else if (typeof handler == "string") {
+        this._commands[name] = function () {
+            return require(handler).parser;
+        };
+        return;
+    } else {
+        var parser = new this.Parser();
+        parser.action(handler);
+        this._commands[name] = function () {
+            return parser;
+        };
+        return parser;
+    }
+};
+
+exports.Parser.prototype.arg = function (name) {
+    var argument = new exports.Argument(this).name(name);
+    this._args.push(argument);
+    return argument;
+};
+
+exports.Parser.prototype.args = function (name) {
+    var argument = new exports.Argument(this).name(name);
+    this._vargs = argument;
+    return argument;
+};
+
+exports.Parser.prototype.act = function (args, options) {
+    if (!this._action) {
+        this.error(options, "Not yet implemented.");
+        this.exit(-1);
+    }
+    options.acted = true;
+    this._action.call(this, this.parse(args), options);
+};
+
+exports.Parser.prototype.action = function (action) {
+    if (this._action) {
+        action = (function (previous) {
+            return function () {
+                previous.apply(this, arguments);
+                action.apply(this, arguments);
+            };
+        })(action);
+    }
+    this._action = action;
+    return this;
+};
+
+// should be called last
+exports.Parser.prototype.helpful = function () {
+    var self = this;
+    this.option('-h', '--help')
+        .help('displays usage information')
+        .action(function (options) {
+            return self.printHelp(options);
+        })
+        .halt();
+    if (util.len(this._commands))
+        this.command('help', function (options) {
+            self.printHelp(options);
+        }).help('displays usage information');
+    return this;
+};
+
+exports.Parser.prototype.usage = function (usage) {
+    this._usage = usage;
+    return this;
+};
+
+exports.Parser.prototype.help = function (help) {
+    this._help = help;
+    return this;
+};
+
+exports.Parser.prototype.printHelp = function (options) {
+    var args = options.args || [];
+    if (args.length) {
+        // parse args for deep help
+        // TODO offer extended help for options
+        if (!util.has(this._commands, args[0])) {
+            this.error(options, util.repr(args[0]) + ' is not a command.');
+            this.printCommands(options);
+            this.exit(options);
+        } else {
+            util.put(args, 1, '--help');
+            this._commands[args[0]]().act(args, options);
+            this.exit(options);
+        }
+    } else {
+        this.printUsage(options);
+        if (this._help)
+            this.print('' + this._help + '');
+        this.printCommands(options);
+        this.printOptions(options);
+        this.exit(options);
+    }
+};
+
+exports.Parser.prototype.printUsage = function (options) {
+    this.print(
+        'Usage: \0bold(\0blue(' + system.fs.basename(options.command || '<unknown>') + ' [OPTIONS]' + 
+        (util.len(this._commands) ?
+            ' COMMAND' :
+            ''
+        ) + 
+        (util.len(this._args) ?
+            ' ' + this._args.map(function (arg) {
+                if (arg._optional) {
+                    return '[' + arg._name.toUpperCase() + ']';
+                } else {
+                    return arg._name.toUpperCase();
+                }
+            }).join(' ') :
+            ''
+        ) +
+        (this._vargs ?
+            ' [' + this._vargs._name.toUpperCase() + ' ...]':
+            ''
+        ) + 
+        (this._usage ?
+            ' ' + this._usage :
+            ''
+        ) + "\0)\0)"
+    );
+};
+
+exports.Parser.prototype.printCommands = function (options) {
+    var self = this;
+    util.forEachApply(
+        util.items(this._commands),
+        function (name, command) {
+            var parser = command();
+            self.print('  \0bold(\0green(' + name + '\0)\0)' + (
+                parser._help ?
+                (
+                    ': ' +
+                    (
+                        parser._action?
+                        '': '\0red(NYI\0): '
+                    ) + 
+                    parser._help
+                ) : ''
+            ));
+        }
+    );
+};
+
+exports.Parser.prototype.printOption = function (options, option, depth, parent) {
+    var self = this;
+    depth = depth || 0;
+    var indent = util.mul('   ', depth);
+
+    if (option._hidden)
+        return;
+    if (option._group !== parent)
+        return;
+
+    if (option instanceof exports.Group) {
+        self.print(indent + ' \0yellow(' + option._name + ':\0)');
+        var parent = option;
+        option._options.forEach(function (option) {
+            return self.printOption(options, option, depth + 1, parent);
+        });
+        return;
+    }
+
+    var message = [];
+    if (option._short.length)
+        message.push(option._short.map(function (_short) {
+            return ' \0bold(\0green(-' + _short + '\0)\0)';
+        }).join(''));
+    if (option._long.length)
+        message.push(option._long.map(function (_long) {
+            return ' \0bold(\0green(--' + _long + '\0)\0)';
+        }).join(''));
+    if (option._action && option._action.length > 2)
+        message.push(
+            ' ' +
+            util.range(option._action.length - 2)
+            .map(function () {
+                return '\0bold(\0green(' + util.upper(
+                    option.getDisplayName()
+                ) + '\0)\0)';
+            }).join(' ')
+        );
+    if (option._help)
+        message.push(': ' + option._help + '');
+    if (option._choices) {
+        var choices = option._choices;
+        if (!util.isArrayLike(choices))
+            choices = util.keys(choices);
+        message.push(' \0bold(\0blue((' + choices.join(', ') + ')\0)\0)');
+    }
+    if (option._halt)
+        message.push(' \0bold(\0blue((final option)\0)\0)');
+    self.print(indent + message.join(''));
+
+};
+
+exports.Parser.prototype.printOptions = function (options) {
+    var self = this;
+    self._options.forEach(function (option) {
+        self.printOption(options, option);
+    });
+};
+
+exports.Parser.prototype.error = function (options, message) {
+    if (this._parser) {
+        this._parser.error.apply(
+            this._parser,
+            arguments
+        );
+    } else {
+        this.print('\0red(' + message + '\0)');
+        this.exit();
+    }
+};
+
+exports.Parser.prototype.exit = function (status) {
+    if (this._parser) {
+        this._parser.exit.apply(
+            this._parser,
+            arguments
+        );
+    } else {
+        os.exit(status);
+        throw new Error("exit failed");
+    }
+};
+
+exports.Parser.prototype.print = function () {
+    if (this._parser)
+        this._parser.print.apply(
+            this._parser,
+            arguments
+        );
+    else
+        stream.print.apply(null, arguments);
+};
+
+// verifies that the parser is fully configured
+exports.Parser.prototype.check = function () {
+    // make sure all options have associated actions
+    var self = this;
+    self._options.forEach(function (option) {
+        if (!(option instanceof self.Option))
+            return;
+        if (!option._action)
+            throw new exports.ConfigurationError(
+                "No action associated with the option " + 
+                util.repr(option.getDisplayName())
+            );
+    });
+};
+
+// TODO break this into sub-functions
+// TODO wrap with a try catch and print the progress through the arguments
+exports.Parser.prototype.parse = function (args, options, noCommand) {
+    var self = this;
+
+    this.check();
+
+    if (!args)
+        args = system.args;
+    if (!options)
+        options = {};
+
+    options.args = args;
+    if (!noCommand && args.length && !/^-/.test(args[0]))
+        options.command = args.shift();
+
+    function mandatoryShift(n, name) {
+        if (n > args.length) {
+            this.error(
+                options,
+                'Error: The ' + util.enquote(name) +
+                ' option requires ' + n + ' arguments.'
+            );
+        }
+        var result = args.slice(0, n);
+        for (var i = 0; i < n; i++)
+            args.shift()
+        return result;
+    };
+
+    function validate(option, value) {
+        try {
+            return option._validate.call(self, value);
+        } catch (exception) {
+            self.error(options, exception);
+        }
+    };
+
+    // initial values
+    for (var name in this._def) {
+        if (util.has(this._def, name) && !util.has(options, name))
+            options[name] = util.copy(this._def[name]);
+    }
+    this._options.forEach(function (option) {
+        if (!(option instanceof self.Option))
+            return;
+        if (!util.has(options, option.getName()))
+            options[option.getName()] = option._def;
+    });
+
+    // walk args
+    ARGS: while (args.length) {
+        var arg = args.shift();
+        if (arg == "--") {
+            break;
+
+        } else if (/^--/.test(arg)) {
+
+            var pattern = arg.match(/^--([^=]+)(?:=(.*))?/).slice(1);
+            var word = pattern[0];
+            var value = pattern[1];
+
+            if (!!value) {
+                args.unshift(value);
+            }
+
+            if (util.has(this._long, word)) {
+
+                var option = this._long[word];
+                if (!option._action) {
+                    self.error(
+                        options,
+                        "Programmer error: The " + word +
+                        " option does not have an associated action."
+                    );
+                }
+
+                option._action.apply(
+                    self,
+                    [
+                        options,
+                        option.getName()
+                    ].concat(
+                        validate(option, mandatoryShift.call(
+                            this,
+                            Math.max(0, option._action.length - 2),
+                            option.getName()
+                        ))
+                    )
+                );
+
+                if (option._halt)
+                    break ARGS;
+
+            } else {
+                this.error(options, 'Error: Unrecognized option: ' + util.enquote(word));
+            }
+
+        } else if (/^-/.test(arg)) {
+
+            var letters = arg.match(/^-(.*)/)[1].split('');
+            while (letters.length) {
+                var letter = letters.shift();
+                if (util.has(this._short, letter)) {
+                    var option = this._short[letter];
+
+                    if (option._action.length > 2) {
+                        if (letters.length) {
+                            args.unshift(letters.join(''));
+                            letters = [];
+                        }
+                    }
+
+                    option._action.apply(
+                        self,
+                        [
+                            options,
+                            option.getName(),
+                        ].concat(
+                            validate(
+                                option,
+                                mandatoryShift.call(
+                                    this,
+                                    Math.max(0, option._action.length - 2),
+                                    option.getName()
+                                )
+                            )
+                        )
+                    );
+
+                    if (option._halt)
+                        break ARGS;
+
+                } else {
+                    this.error(options, 'Error: unrecognized option: ' + util.enquote(letter));
+                }
+            }
+
+        } else {
+            // TODO permit options interleaved with arguments,
+            //  with associated actions, for any of positional
+            //  args, variadic args, and accumulated args
+            args.unshift(arg);
+            break;
+        }
+
+    }
+
+    if (util.len(this._commands)) {
+        if (args.length) {
+            if (util.has(this._commands, args[0])) {
+                var command = this._commands[args[0]];
+                command().act(args, options);
+            } else {
+                this.error(options, 'Error: unrecognized command');
+            }
+        } else {
+            this.error(options, 'Error: command required');
+            this.exit(0);
+        }
+    }
+
+    return options;
+};
+
+exports.Argument = function (parser) {
+    this._parser = parser;
+    return this;
+};
+
+exports.Argument.prototype.name = function (name) {
+    this._name = name;
+    return this;
+};
+
+exports.Argument.prototype.optional = function () {
+    this._optional = true;
+    return this;
+};
+
+exports.Option = function (parser, args) {
+    var self = this;
+    this._parser = parser;
+    this._validate = function (value) {
+        return value;
+    };
+    this._long = [];
+    this._short = [];
+    util.forEach(args, function (arg) {
+        if (typeof arg == "function") {
+            self.action(arg);
+        } else if (typeof arg !== "string") {
+            for (var name in arg) {
+                var value = arg[name];
+                self[name](value);
+            }
+        } else if (/ /.test(arg)) {
+            self.help(arg);
+        } else if (/^--/.test(arg)) {
+            arg = arg.match(/^--(.*)/)[1];
+            self.__(arg);
+        } else if (/^-.$/.test(arg)) {
+            arg = arg.match(/^-(.)/)[1];
+            self._(arg);
+        } else if (/^-/.test(arg)) {
+            throw new Error("option names with one dash can only have one letter.");
+        } else {
+            if (!self._name) {
+                self.name(arg);
+                self.displayName(arg);
+            } else {
+                self.name(arg);
+            }
+        }
+    });
+    if (!(self._short.length || self._long.length || self._name))
+        throw new exports.ConfigurationError("Option has no name.");
+    return this;
+};
+
+exports.Option.prototype._ = function (letter) {
+    this._short.push(letter);
+    this._parser._short[letter] = this;
+    return this;
+};
+
+exports.Option.prototype.__ = function (word) {
+    this._long.push(word);
+    this._parser._long[word] = this;
+    return this;
+};
+
+exports.Option.prototype.name = function (name) {
+    this._name = name;
+    return this;
+};
+
+exports.Option.prototype.displayName = function (displayName) {
+    this._displayName = displayName;
+    return this;
+};
+
+exports.Option.prototype.getDisplayName = function () {
+    if (this._displayName)
+        return this._displayName;
+    return this.getName();
+};
+
+exports.Option.prototype.getName = function () {
+    if (this._name) {
+        return this._name;
+    }
+    if (this._long.length > 0) {
+        return this._long[0];
+    }
+    if (this._short.length > 0) {
+        return this._short[0];
+    }
+    throw new Error("Programmer error: unnamed option");
+};
+
+exports.Option.prototype.action = function (action) {
+    var self = this;
+    if (typeof action == "string") {
+        this._action = self._parser[action];
+    } else {
+        this._action = action;
+    }
+    return this;
+};
+
+exports.Option.prototype.set = function (value) {
+    var option = this;
+    if (arguments.length == 0)
+        return this.action(function (options, name, value) {
+            options[name] = value;
+        });
+    else if (arguments.length == 1)
+        return this.action(function (options, name) {
+            options[name] = value;
+        });
+    else
+        throw new exports.UsageError("Option().set takes 0 or 1 arguments");
+};
+
+exports.Option.prototype.push = function () {
+    var option = this;
+    return this.def([]).action(function (options, name, value) {
+        options[name].push(option._validate.call(
+            this,
+            value
+        ));
+    });
+};
+
+exports.Option.prototype.inc = function () {
+    return this.def(0).action(function (options, name) {
+        options[name]++;
+    });
+};
+
+exports.Option.prototype.dec = function () {
+    return this.def(0).action(function (options, name) {
+        options[name]--;
+    });
+};
+
+exports.Option.prototype.choices = function (choices) {
+    this.set();
+    this._choices = choices;
+    var self = this;
+    if (util.isArrayLike(choices)) {
+        return this.validate(function (value) {
+            if (choices.indexOf(value) < 0)
+                throw new exports.UsageError(
+                    "choice for " + util.upper(self.getDisplayName()) +
+                    " is invalid: " + util.enquote(value) + "\n" +
+                    "Use one of: " + choices.map(function (choice) {
+                        return util.enquote(choice);
+                    }).join(', ')
+                );
+            return value;
+        })
+    } else {
+        return this.validate(function (value) {
+            if (!util.has(choices, value))
+                throw new exports.UsageError(
+                    "choice for " + util.upper(self.getDisplayName()) +
+                    " is invalid: " + util.enquote(value) + "\n" +
+                    "Use one of: " + util.keys(choices).map(function (choice) {
+                        return util.enquote(choice);
+                    }).join(', ')
+                );
+            return choices[value];
+        });
+    }
+};
+
+exports.Option.prototype.def = function (value) {
+    if (this._def === undefined)
+        this._def = value;
+    return this;
+};
+
+exports.Option.prototype.validate = function (validate) {
+    var current = this._validate;
+    if (this._validate) {
+        validate = (function (previous) {
+            return function () {
+                return current.call(
+                    this,
+                    previous.apply(this, arguments)
+                );
+            };
+        })(validate);
+    }
+    this._validate = validate;
+    return this;
+};
+
+exports.Option.prototype.input = function () {
+    this.set().validate(function (value) {
+        if (value == "-")
+            return system.stdin;
+        else
+            return system.fs.open(value, 'r');
+    });
+};
+
+exports.Option.prototype.output = function () {
+    this.set().validate(function (value) {
+        if (value == "-")
+            return system.stdout;
+        else
+            return system.fs.open(value, 'w');
+    });
+};
+
+exports.Option.prototype.number = function () {
+    return this.set().validate(function (value) {
+        var result = +value;
+        if (isNaN(result))
+            throw new exports.UsageError("not a number");
+        return result;
+    });
+};
+
+exports.Option.prototype.oct = function () {
+    return this.set().validate(function (value) {
+        var result = parseInt(value, 8);
+        if (isNaN(result))
+            throw new exports.UsageError("not an octal value");
+        return result;
+    });
+};
+
+exports.Option.prototype.hex = function () {
+    return this.set().validate(function (value) {
+        var result = parseInt(value, 16);
+        if (isNaN(result))
+            throw new exports.UsageError("not an hex value");
+        return result;
+    });
+};
+
+exports.Option.prototype.integer = function () {
+    return this.set().validate(function (value) {
+        var result = parseInt(value, 10);
+        if (isNaN(result) || result !== +value)
+            throw new exports.UsageError("not an integer");
+        return result;
+    });
+};
+
+exports.Option.prototype.natural = function () {
+    return this.set().validate(function (value) {
+        var result = value >>> 0;
+        if (result !== +value || result < 0)
+            throw new exports.UsageError("not a natural number");
+        return result;
+    });
+};
+
+exports.Option.prototype.whole = function () {
+    return this.set().validate(function (value) {
+        var result = value >>> 0;
+        if (result !== +value || result < 1)
+            throw new exports.UsageError("not a whole number");
+        return result;
+    });
+};
+
+exports.Option.prototype.bool = function (def) {
+    if (def === undefined)
+        def = true;
+    return this.def(!def).set(!!def);
+};
+
+exports.Option.prototype.todo = function (command, value) {
+    this._parser.def('todo', []);
+    command = command || this.getName();
+    if (value)
+        return this.action(function (options, name, value) {
+            options.todo.push([command, value]);
+        });
+    else
+        return this.action(function (options, name) {
+            options.todo.push([command]);
+        });
+};
+
+exports.Option.prototype.inverse = function () {
+    var args = arguments;
+    if (!args.length) {
+        args = [];
+        this._short.forEach(function (_) {
+            args.push('-' + _.toUpperCase());
+        });
+        this._long.forEach(function (__) {
+            args.push('--no-' + __);
+        });
+        if (this.getName()) 
+            args.push(this.getName());
+    }
+    var parser = this._parser;
+    var inverse = this._inverse = parser.option.apply(
+        parser,
+        args
+    ).set(!this._def).help('^ inverse');
+    return this;
+};
+
+exports.Option.prototype.help = function (text) {
+    this._help = text;
+    return this;
+};
+
+exports.Option.prototype.halt = function () {
+    this._halt = true;
+    return this;
+};
+
+exports.Option.prototype.hidden = function () {
+    this._hidden = true;
+    return this;
+};
+
+exports.Option.prototype.end = function () {
+    return this._parser;
+};
+
+exports.Option.prototype.option = function () {
+    return this.end().option.apply(this, arguments);
+};
+
+exports.Parser.prototype.end = function () {
+    return this._parser;
+};
+
+exports.Group = function (parser, parent, name) {
+    this._name = name;
+    this._parser = parser;
+    this._parent = parent;
+    this._options = [];
+    return this;
+};
+
+exports.Group.prototype.option = function () {
+    var option = this._parser.option.apply(this._parser, arguments);
+    option._group = this;
+    this._options.push(option);
+    return option;
+};
+
+exports.Group.prototype.group = function (name) {
+    var Group = this.Group || this._parser.Group;
+    var group = new Group(this._parser, this, name);
+    return group;
+};
+
+exports.Group.prototype.end = function () {
+    return this._parent;
+};
+
+exports.Parser.prototype.Parser = exports.Parser;
+exports.Parser.prototype.Option = exports.Option;
+exports.Parser.prototype.Group = exports.Group;
+