 + * has a boolean value, and thus the opposite of '--verbose' is ''.
 + */
 +function TrueNamedArgument(name, arg) {
-+    this.arg = arg;
-+    this.text = arg ? arg.text : '--' + name;
-+    this.prefix = arg ? arg.prefix : ' ';
-+    this.suffix = arg ? arg.suffix : '';
++  this.arg = arg;
++  this.text = arg ? arg.text : '--' + name;
++  this.prefix = arg ? arg.prefix : ' ';
++  this.suffix = arg ? arg.suffix : '';
 +}
 +
 +TrueNamedArgument.prototype = Object.create(Argument.prototype);
 +
 +TrueNamedArgument.prototype.assign = function(assignment) {
-+    if (this.arg) {
-+        this.arg.assign(assignment);
-+    }
-+    this.assignment = assignment;
++  if (this.arg) {
++    this.arg.assign(assignment);
++  }
++  this.assignment = assignment;
 +};
 +
 +TrueNamedArgument.prototype.getArgs = function() {
-+    // NASTY! getArgs has a fairly specific use: in removing used arguments
-+    // from a command line. Unlike other arguments which are EITHER used
-+    // in assignments directly OR grouped in things like MergedArguments,
-+    // TrueNamedArgument is used raw from the UI, or composed of another arg
-+    // from the CLI, so we return both here so they can both be removed.
-+    return this.arg ? [ this, this.arg ] : [ this ];
++  // NASTY! getArgs has a fairly specific use: in removing used arguments
++  // from a command line. Unlike other arguments which are EITHER used
++  // in assignments directly OR grouped in things like MergedArguments,
++  // TrueNamedArgument is used raw from the UI, or composed of another arg
++  // from the CLI, so we return both here so they can both be removed.
++  return this.arg ? [ this, this.arg ] : [ this ];
 +};
 +
 +TrueNamedArgument.prototype.equals = function(that) {
-+    if (this === that) {
-+        return true;
-+    }
-+    if (that == null || !(that instanceof TrueNamedArgument)) {
-+        return false;
-+    }
-+
-+    return this.text === that.text &&
-+           this.prefix === that.prefix && this.suffix === that.suffix;
++  if (this === that) {
++    return true;
++  }
++  if (that == null || !(that instanceof TrueNamedArgument)) {
++    return false;
++  }
++
++  return this.text === that.text &&
++       this.prefix === that.prefix && this.suffix === that.suffix;
 +};
 +
 +argument.TrueNamedArgument = TrueNamedArgument;

+ * But we also need named access ...
+ */
+Requisition.prototype.getAssignment = function(nameOrNumber) {
+    var name = (typeof nameOrNumber === 'string') ?
+        nameOrNumber :
+        Object.keys(this._assignments)[nameOrNumber];
+    return this._assignments[name];
+},
+
+/**
+ * Where parameter name == assignment names - they are the same.
+ */
+Requisition.prototype.getParameterNames = function() {
+    return Object.keys(this._assignments);
+},
+
+/**

+ * We don't currently plan to distinguish between integers and floats
+ */
+function NumberType(typeSpec) {
+  if (typeSpec) {
+    this.min = typeSpec.min || 0;
+    this.max = typeSpec.max;
+    this.step = typeSpec.step || 1;
+  }
+  else {
+    this.step = 1;
+  }
+}
+
+NumberType.prototype = new Type();
+
+NumberType.prototype.stringify = function(value) {
+  if (value == null) {
+    return '';
+  }
+  return '' + value;
+};
+
+NumberType.prototype.parse = function(arg) {
+  if (arg.text.replace(/\s/g, '').length === 0) {
+    return new Conversion(null, arg, Status.INCOMPLETE, '');
+  }
+
+  var value = parseInt(arg.text, 10);
+  if (isNaN(value)) {
+    return new Conversion(this.min, arg, Status.ERROR,
+      'Can\'t convert "' + arg.text + '" to a number.');
+  }
+
+  if (this.max != null && value > this.max) {
+    return new Conversion(value, arg, Status.ERROR,
+      '' + value + ' is greater that maximum allowed: ' + this.max + '.');
+  }
+
+  if (this.min != null && value < this.min) {
+    return new Conversion(value, arg, Status.ERROR,
+      '' + value + ' is smaller that minimum allowed: ' + this.min + '.');
+  }
+
+  return new Conversion(value, arg);
+};
+
+NumberType.prototype.decrement = function(value) {
+  if (typeof value !== 'number' || isNaN(value)) {
+    return this.max || 1;
+  }
+  var newValue = value - this.step;
+  // Snap to the nearest incremental of the step
+  newValue = Math.ceil(newValue / this.step) * this.step;
+  if (this.min == null) {
+    return newValue;
+  }
+  return this._boundsCheck(newValue);
+};
+
+NumberType.prototype.increment = function(value) {
+  if (typeof value !== 'number' || isNaN(value)) {
+    return this.min;
+  }
+  var newValue = value + this.step;
+  // Snap to the nearest incremental of the step
+  newValue = Math.floor(newValue / this.step) * this.step;
+  if (this.max == null) {
+    return newValue;
+  }
+  return this._boundsCheck(newValue);
+};
+
+/**
+ * Return the input value so long as it is within the max/min bounds. If it is
+ * lower than the minimum, return the minimum. If it is bigger than the maximum
+ * then return the maximum.
+ */
+NumberType.prototype._boundsCheck = function(value) {
+  if (value < this.min) {
+    return this.min;
+  }
+  if (value > this.max) {
+    return this.max;
+  }
+  return value;
+};
+
+NumberType.prototype.name = 'number';
