ton of work porting input.js from old bespin

plugins/pilot/lib/canon.js

@@ -123,7 +123,7 @@ exports.getCommand = function(name) {
     return commands[name];
 };
 
-exports.getCommands = function() {
+exports.getCommandNames = function() {
     return Object.keys(commands);
 };
 
@@ -148,7 +148,7 @@ exports.exec = function(name, args) {
  */
 exports.execRequisition = function(requisition) {
     var request = new Request();
-    requisition.command.exec(env, requisition.args, request);
+    requisition.command.exec(env, requisition.getArgs(), request);
 };
 
 /**
@@ -182,7 +182,18 @@ Requisition.prototype = {
      * The set of values that we are assigning to parameters in the command
      * @readonly
      */
-    assignments: undefined
+    assignments: undefined,
+
+    /**
+     *
+     */
+    getArgs: function() {
+        var args = {};
+        Object.keys(assignments).forEach(function(name) {
+            args[name] = getCommand(name);
+        });
+        return args;
+    }
 };
 exports.Requisition = Requisition;
 

plugins/pilot/lib/cli.js

@@ -0,0 +1,466 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Skywriter.
+ *
+ * The Initial Developer of the Original Code is
+ * Mozilla.
+ * Portions created by the Initial Developer are Copyright (C) 2009
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Joe Walker (jwalker@mozilla.com)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+define(function(require, exports, module) {
+
+
+var console = require('skywriter/console');
+var util = require('pilot/util');
+
+var keyboard = require('keyboard/keyboard');
+var Status = require('pilot/canon').Status;
+var Requisition = require('pilot/canon').Requisition;
+
+var typehint = require('command_line/typehint');
+
+/**
+ * The information required to tell the user there is a problem with their
+ * input.
+ * TODO: Consider formalizing alternatives
+ */
+function Hint(status, message, start, end) {
+    this.status = status;
+    this.message = message;
+    this.start = start;
+    this.end = end;
+}
+Hint.prototype = {
+
+};
+exports.Hint = Hint;
+
+
+/**
+ * An object used during command line parsing to hold the various intermediate
+ * data steps.
+ * <p>The 'output' of the parse is held in 2 objects: input.hints which is an
+ * array of hints to display to the user. In the future this will become a
+ * single value.
+ * <p>The other output value is input.requisition which gives access to an
+ * args object for use in executing the final command.
+ * @param typed {string} The instruction as typed by the user so far
+ * @param options {object} A list of optional named parameters. Can be any of:
+ * <b>flags</b>: Flags for us to check against the predicates specified with the
+ * commands. Defaulted to <tt>keyboard.buildFlags({ });</tt>
+ * if not specified.
+ * @constructor
+ */
+function Input(typed, options) {
+    if (util.none(typed)) {
+        throw new Error('Input requires something \'typed\' to work on');
+    }
+    this.typed = typed;
+    this.hints = [];
+
+    options = options || {};
+
+    // TODO: We were using a default of keyboard.buildFlags({ });
+    // I think this allowed us to have commands that only existed in certain
+    // contexts - i.e. Javascript specific commands.
+    this.flags = options.flags || {};
+
+    // Once tokenize() has been called, we have the #typed string cut up into
+    // #_parts
+    this._parts = [];
+
+    // Once split has been called we have #_parts split into #_unparsedArgs and
+    // #_command (if there is a matching command).
+    this._unparsedArgs = undefined;
+
+    // Once we know what the command is, we can fire up a Requisition
+    this.requisition = undefined;
+
+    // Assign matches #_unparsedArgs to the params declared by the #_command
+    // A list of arguments in _command.params order
+    this._assignments = undefined;
+
+    this._tokenize();
+};
+
+/**
+ * Implementation of Input.
+ * The majority of the functions in this class are called in sequence by the
+ * constructor. Their task is to add to <tt>hints</tt> fill out the requisition.
+ * <p>The general sequence is:<ul>
+ * <li>_tokenize(): convert _typed into _parts
+ * <li>_split(): convert _parts into _command and _unparsedArgs
+ * <li>_assign(): convert _unparsedArgs into _assignments
+ * </ul>
+ */
+Input.prototype = {
+    /**
+     * Split up the input taking into account ' and "
+     */
+    _tokenize: function() {
+        if (!this.typed || this.typed === '') {
+            // We would like to put some initial help here, but for anyone but
+            // a complete novice a 'type help' message is very annoying, so we
+            // need to find a way to only display this message once, or for
+            // until the user click a 'close' button or similar
+            this.hints.push(new Hint(Status.INCOMPLETE));
+            return;
+        }
+
+        // replace(/^\s\s*/, '') = trimLeft()
+        var incoming = this.typed.replace(/^\s\s*/, '').split(/\s+/);
+
+        var nextToken;
+        while (true) {
+            nextToken = incoming.shift();
+            if (util.none(nextToken)) {
+                break;
+            }
+            if (nextToken[0] == '"' || nextToken[0] == '\'') {
+                // It's quoting time
+                var eaten = [ nextToken.substring(1, nextToken.length) ];
+                var eataway;
+                while (true) {
+                    eataway = incoming.shift();
+                    if (!eataway) {
+                        break;
+                    }
+                    if (eataway[eataway.length - 1] == '"' ||
+                            eataway[eataway.length - 1] == '\'') {
+                        // End quoting time
+                        eaten.push(eataway.substring(0, eataway.length - 1));
+                        break;
+                    } else {
+                        eaten.push(eataway);
+                    }
+                }
+                this._parts.push(eaten.join(' '));
+            } else {
+                this._parts.push(nextToken);
+            }
+        }
+
+        // Split the command from the args
+        this._split();
+    },
+
+    /**
+     * Looks in the canon for a command extension that matches what has been
+     * typed at the command line.
+     */
+    _split: function() {
+        this._unparsedArgs = this._parts.slice(); // aka clone()
+        var initial = this._unparsedArgs.shift();
+        var command;
+
+        while (true) {
+            command = canon.getCommand(initial);
+
+            if (!command) {
+                // Not found. break with command == null
+                break;
+            }
+
+            if (!keyboard.flagsMatch(command.predicates, this.flags)) {
+                // If the predicates say 'no match' then go LA LA LA
+                command = null;
+                break;
+            }
+
+            if (command.exec) {
+                // Valid command, break with command valid
+                break;
+            }
+
+            // command, but no exec - this must be a sub-command
+            initial += ' ' + this._unparsedArgs.shift();
+        }
+
+        // Do we know what the command is.
+        if (!command) {
+            // We don't know what the command is
+            // TODO: We should probably cache this
+            var commands = [];
+            canon.getCommandNames().forEach(function(name) {
+                var command = canon.getCommand(name);
+                if (keyboard.flagsMatch(command.predicates, this.flags) &&
+                        command.description) {
+                    commands.push(command);
+                }
+            }.bind(this));
+
+            // TODO: make this a hint
+            var hintSpec = {
+                param: {
+                    type: { name: 'selection', data: commands },
+                    description: 'Commands'
+                },
+                value: this.typed
+            };
+
+            return;
+        }
+
+        // The user hasn't started to type any params
+        if (this._parts.length === 1) {
+            if (this.typed == command.name ||
+                    !command.params ||
+                    command.params.length === 0) {
+                this.hints.push(documentCommand(command, this.typed));
+            }
+        }
+
+        this.requisition = new Requisition(command);
+
+        // Assign input to declared parameters
+        this._assign();
+    },
+
+    /**
+     * Work out which arguments are applicable to which parameters.
+     * <p>This takes #_command.params and #_unparsedArgs and creates a map of
+     * param names to 'assignment' objects, which have the following properties:
+     * <ul>
+     * <li>param - The matching parameter.
+     * <li>index - Zero based index into where the match came from on the input
+     * <li>value - The matching input
+     * </ul>
+     * The resulting #_assignments member created by this function is a list of
+     * assignments of arguments in command.params order.
+     * TODO: _unparsedArgs should be a list of objects that contain the
+     * following values: name, param (when assigned) and maybe hints?
+     */
+    _assign: function() {
+        // TODO: something smarter than just assuming that they are all in order
+        this._assignments = [];
+        var params = this.requisition.command.params;
+        var unparsedArgs = this._unparsedArgs;
+        var message;
+
+        // Create an error if the command does not take parameters, but we have
+        // been given them ...
+        if (!params || params.length === 0) {
+            // No problem if we're passed nothing or an empty something
+            var argCount = 0;
+            unparsedArgs.forEach(function(unparsedArg) {
+                if (unparsedArg.trim() !== '') {
+                    argCount++;
+                }
+            });
+
+            if (argCount !== 0) {
+                message = this.requisition.command.name + ' does not take any parameters';
+                this.hints.push(new Hint(Status.INVALID, message));
+            }
+
+            return;
+        }
+
+        // Special case: if there is only 1 parameter, and that's of type
+        // text we put all the params into the first param
+        if (params.length == 1 && params[0].type == 'text') {
+            // Warning: There is some potential problem here if spaces are
+            // significant. It might be better to chop the command of the
+            // start of this.typed? But that's not easy because there could
+            // be multiple spaces in the command if we're doing sub-commands
+            this._assignments[0] = {
+                value: unparsedArgs.length === 0 ? null : unparsedArgs.join(' '),
+                param: params[0]
+            };
+        } else {
+            // The normal case where we have to assign params individually
+            var index = 0;
+            var used = [];
+            params.forEach(function(param) {
+                this._assignParam(param, index++, used);
+            }.bind(this));
+
+            // Check there are no params that don't fit
+            var unparsed = false;
+            unparsedArgs.forEach(function(unparsedArg) {
+                if (used.indexOf(unparsedArg) == -1) {
+                    message = 'Parameter \'' + unparsedArg + '\' makes no sense.';
+                    this.hints.push(new Hint(Status.INVALID, message));
+                    unparsed = true;
+                }
+            }.bind(this));
+
+            if (unparsed) {
+                return;
+            }
+        }
+
+        // Show a hint for the last parameter
+        if (this._parts.length > 1) {
+            var assignment = this._getAssignmentForLastArg();
+
+            // HACK! deferred types need to have some parameters
+            // by which to determine which type they should defer to
+            // so we hack in the assignments so the deferrer can work
+            assignment.param.type.assignments = this._assignments;
+
+            if (assignment) {
+                this.hints.push(typehint.getHint(this, assignment));
+            }
+        }
+
+        // Convert input into declared types
+        this._convertTypes();
+    },
+
+    /**
+     * Extract a value from the set of inputs for a given param.
+     * @param param The param that we are providing a value for. This is taken
+     * from the command meta-data for the command in question.
+     * @param index The number of the param - i.e. the index of <tt>param</tt>
+     * into the original params array.
+     */
+    _assignParam: function(param, index, used) {
+        var message;
+        // Look for '--param X' style inputs
+        for (var i = 0; i < this._unparsedArgs.length; i++) {
+            var unparsedArg = this._unparsedArgs[i];
+
+            if ('--' + param.name == unparsedArg) {
+                used.push(unparsedArg);
+                // boolean parameters don't have values, they default to false
+                if (param.type.name === 'boolean') {
+                    this._assignments[index] = {
+                        value: true,
+                        param: param
+                    };
+                } else {
+                    if (i + 1 < this._unparsedArgs.length) {
+                        message = 'Missing parameter: ' + param.name;
+                        // Missing value for this param
+                        this.hints.push(new Hint(Status.INCOMPLETE, message));
+                    } else {
+                        used.push(this._unparsedArgs[i + 1]);
+                    }
+                }
+                return;
+            }
+        }
+
+        var value = null;
+        if (this._unparsedArgs.length > index) {
+            value = this._unparsedArgs[index];
+            used.push(this._unparsedArgs[index]);
+        }
+
+        // null is a valid default value, and common because it identifies an
+        // parameter that is optional. undefined means there is no value from
+        // the command line
+        if (value !== undefined) {
+            this._assignments[index] = { value: value, param: param };
+        } else {
+            this._assignments[index] = { param: param };
+
+            if (param.defaultValue === undefined) {
+                // There is no default, and we've not supplied one so far
+                message = 'Missing parameter: ' + param.name;
+                this.hints.push(new Hint(Status.INCOMPLETE, message));
+            }
+        }
+    }
+};
+exports.Input = Input;
+
+/**
+ * Provide some documentation for a command.
+ * TODO: this should return a hint
+ */
+function documentCommand(cmdExt, typed) {
+    var docs = [];
+    docs.push('<h1>' + cmdExt.name + '</h1>');
+    docs.push('<h2>Summary</h2>');
+    docs.push('<p>' + cmdExt.description + '</p>');
+
+    if (cmdExt.manual) {
+        docs.push('<h2>Description</h2>');
+        docs.push('<p>' + cmdExt.description + '</p>');
+    }
+
+    if (cmdExt.params && cmdExt.params.length > 0) {
+        docs.push('<h2>Synopsis</h2>');
+        docs.push('<pre>');
+        docs.push(cmdExt.name);
+        var optionalParamCount = 0;
+        cmdExt.params.forEach(function(param) {
+            if (param.defaultValue === undefined) {
+                docs.push(' <i>');
+                docs.push(param.name);
+                docs.push('</i>');
+            } else if (param.defaultValue === null) {
+                docs.push(' <i>[');
+                docs.push(param.name);
+                docs.push(']</i>');
+            } else {
+                optionalParamCount++;
+            }
+        });
+        if (optionalParamCount > 3) {
+            docs.push(' [options]');
+        } else if (optionalParamCount > 0) {
+            cmdExt.params.forEach(function(param) {
+                if (param.defaultValue) {
+                    docs.push(' [--<i>');
+                    docs.push(param.name);
+                    if (param.type.name === 'boolean') {
+                        docs.push('</i>');
+                    } else {
+                        docs.push('</i> ' + param.type.name);
+                    }
+                    docs.push(']');
+                }
+            });
+        }
+        docs.push('</pre>');
+
+        docs.push('<h2>Parameters</h2>');
+        cmdExt.params.forEach(function(param) {
+            docs.push('<h3 class="cmd_body"><i>' + param.name + '</i></h3>');
+            docs.push('<p>' + param.description + '</p>');
+            if (param.type.defaultValue) {
+                docs.push('<p>Default: ' + param.type.defaultValue + '</p>');
+            }
+        });
+    }
+
+    return {
+        param: { type: 'text', description: docs.join('') },
+        value: typed
+    };
+};
+exports.documentCommand = documentCommand;
+
+
+});