/**

* dashdash - A light, featureful and explicit option parsing library for
* node.js.
*/

// vim: set ts=4 sts=4 sw=4 et:

var assert = require('assert-plus'); var format = require('util').format; var fs = require('fs'); var path = require('path');

var DEBUG = true; if (DEBUG) {

var debug = console.warn;

} else {

var debug = function () {};

}

// —- internal support stuff

// Replace {{variable}} in `s` with the template data in `d`. function renderTemplate(s, d) {

return s.replace(/{{([a-zA-Z]+)}}/g, function (match, key) {
    return d.hasOwnProperty(key) ? d[key] : match;
});

}

/**

* Return a shallow copy of the given object;
*/

function shallowCopy(obj) {

if (!obj) {
    return (obj);
}
var copy = {};
Object.keys(obj).forEach(function (k) {
    copy[k] = obj[k];
});
return (copy);

}

function space(n) {

var s = '';
for (var i = 0; i < n; i++) {
    s += ' ';
}
return s;

}

function makeIndent(arg, deflen, name) {

if (arg === null || arg === undefined)
    return space(deflen);
else if (typeof (arg) === 'number')
    return space(arg);
else if (typeof (arg) === 'string')
    return arg;
else
    assert.fail('invalid "' + name + '": not a string or number: ' + arg);

}

/**

* Return an array of lines wrapping the given text to the given width.
* This splits on whitespace. Single tokens longer than `width` are not
* broken up.
*/

function textwrap(s, width) {

var words = s.trim().split(/\s+/);
var lines = [];
var line = '';
words.forEach(function (w) {
    var newLength = line.length + w.length;
    if (line.length > 0)
        newLength += 1;
    if (newLength > width) {
        lines.push(line);
        line = '';
    }
    if (line.length > 0)
        line += ' ';
    line += w;
});
lines.push(line);
return lines;

}

/**

* Transform an option name to a "key" that is used as the field
* on the `opts` object returned from `<parser>.parse()`.
*
* Transformations:
* - '-' -> '_': This allow one to use hyphen in option names (common)
*   but not have to do silly things like `opt["dry-run"]` to access the
*   parsed results.
*/

function optionKeyFromName(name) {

return name.replace(/-/g, '_');

}

// —- Option types

function parseBool(option, optstr, arg) {

return Boolean(arg);

}

function parseString(option, optstr, arg) {

assert.string(arg, 'arg');
return arg;

}

function parseNumber(option, optstr, arg) {

assert.string(arg, 'arg');
var num = Number(arg);
if (isNaN(num)) {
    throw new Error(format('arg for "%s" is not a number: "%s"',
        optstr, arg));
}
return num;

}

function parseInteger(option, optstr, arg) {

assert.string(arg, 'arg');
var num = Number(arg);
if (!/^[0-9-]+$/.test(arg) || isNaN(num)) {
    throw new Error(format('arg for "%s" is not an integer: "%s"',
        optstr, arg));
}
return num;

}

function parsePositiveInteger(option, optstr, arg) {

assert.string(arg, 'arg');
var num = Number(arg);
if (!/^[0-9]+$/.test(arg) || isNaN(num) || num === 0) {
    throw new Error(format('arg for "%s" is not a positive integer: "%s"',
        optstr, arg));
}
return num;

}

/**

* Supported date args:
* - epoch second times (e.g. 1396031701)
* - ISO 8601 format: YYYY-MM-DD[THH:MM:SS[.sss][Z]]
*      2014-03-28T18:35:01.489Z
*      2014-03-28T18:35:01.489
*      2014-03-28T18:35:01Z
*      2014-03-28T18:35:01
*      2014-03-28
*/

function parseDate(option, optstr, arg) {

assert.string(arg, 'arg');
var date;
if (/^\d+$/.test(arg)) {
    // epoch seconds
    date = new Date(Number(arg) * 1000);
/* JSSTYLED */
} else if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?Z?)?$/i.test(arg)) {
    // ISO 8601 format
    date = new Date(arg);
} else {
    throw new Error(format('arg for "%s" is not a valid date format: "%s"',
        optstr, arg));
}
if (date.toString() === 'Invalid Date') {
    throw new Error(format('arg for "%s" is an invalid date: "%s"',
        optstr, arg));
}
return date;

}

var optionTypes = {

bool: {
    takesArg: false,
    parseArg: parseBool
},
string: {
    takesArg: true,
    helpArg: 'ARG',
    parseArg: parseString
},
number: {
    takesArg: true,
    helpArg: 'NUM',
    parseArg: parseNumber
},
integer: {
    takesArg: true,
    helpArg: 'INT',
    parseArg: parseInteger
},
positiveInteger: {
    takesArg: true,
    helpArg: 'INT',
    parseArg: parsePositiveInteger
},
date: {
    takesArg: true,
    helpArg: 'DATE',
    parseArg: parseDate
},
arrayOfBool: {
    takesArg: false,
    array: true,
    parseArg: parseBool
},
arrayOfString: {
    takesArg: true,
    helpArg: 'ARG',
    array: true,
    parseArg: parseString
},
arrayOfNumber: {
    takesArg: true,
    helpArg: 'NUM',
    array: true,
    parseArg: parseNumber
},
arrayOfInteger: {
    takesArg: true,
    helpArg: 'INT',
    array: true,
    parseArg: parseInteger
},
arrayOfPositiveInteger: {
    takesArg: true,
    helpArg: 'INT',
    array: true,
    parseArg: parsePositiveInteger
},
arrayOfDate: {
    takesArg: true,
    helpArg: 'INT',
    array: true,
    parseArg: parseDate
},

};

// —- Parser

/**

* Parser constructor.
*
* @param config {Object} The parser configuration
*      - options {Array} Array of option specs. See the README for how to
*        specify each option spec.
*      - allowUnknown {Boolean} Default false. Whether to throw on unknown
*        options. If false, then unknown args are included in the _args array.
*      - interspersed {Boolean} Default true. Whether to allow interspersed
*        arguments (non-options) and options. E.g.:
*              node tool.js arg1 arg2 -v
*        '-v' is after some args here. If `interspersed: false` then '-v'
*        would not be parsed out. Note that regardless of `interspersed`
*        the presence of '--' will stop option parsing, as all good
*        option parsers should.
*/

function Parser(config) {

assert.object(config, 'config');
assert.arrayOfObject(config.options, 'config.options');
assert.optionalBool(config.interspersed, 'config.interspersed');
var self = this;

// Allow interspersed arguments (true by default).
this.interspersed = (config.interspersed !== undefined
    ? config.interspersed : true);

// Don't allow unknown flags (true by default).
this.allowUnknown = (config.allowUnknown !== undefined
    ? config.allowUnknown : false);

this.options = config.options.map(function (o) { return shallowCopy(o); });
this.optionFromName = {};
this.optionFromEnv = {};
for (var i = 0; i < this.options.length; i++) {
    var o = this.options[i];
    if (o.group !== undefined && o.group !== null) {
        assert.optionalString(o.group,
            format('config.options.%d.group', i));
        continue;
    }
    assert.ok(optionTypes[o.type],
        format('invalid config.options.%d.type: "%s" in %j',
               i, o.type, o));
    assert.optionalString(o.name, format('config.options.%d.name', i));
    assert.optionalArrayOfString(o.names,
        format('config.options.%d.names', i));
    assert.ok((o.name || o.names) && !(o.name && o.names),
        format('exactly one of "name" or "names" required: %j', o));
    assert.optionalString(o.help, format('config.options.%d.help', i));
    var env = o.env || [];
    if (typeof (env) === 'string') {
        env = [env];
    }
    assert.optionalArrayOfString(env, format('config.options.%d.env', i));
    assert.optionalString(o.helpGroup,
        format('config.options.%d.helpGroup', i));
    assert.optionalBool(o.helpWrap,
        format('config.options.%d.helpWrap', i));
    assert.optionalBool(o.hidden, format('config.options.%d.hidden', i));

    if (o.name) {
        o.names = [o.name];
    } else {
        assert.string(o.names[0],
            format('config.options.%d.names is empty', i));
    }
    o.key = optionKeyFromName(o.names[0]);
    o.names.forEach(function (n) {
        if (self.optionFromName[n]) {
            throw new Error(format(
                'option name collision: "%s" used in %j and %j',
                n, self.optionFromName[n], o));
        }
        self.optionFromName[n] = o;
    });
    env.forEach(function (n) {
        if (self.optionFromEnv[n]) {
            throw new Error(format(
                'option env collision: "%s" used in %j and %j',
                n, self.optionFromEnv[n], o));
        }
        self.optionFromEnv[n] = o;
    });
}

}

Parser.prototype.optionTakesArg = function optionTakesArg(option) {

return optionTypes[option.type].takesArg;

};

/**

* Parse options from the given argv.
*
* @param inputs {Object} Optional.
*      - argv {Array} Optional. The argv to parse. Defaults to
*        `process.argv`.
*      - slice {Number} The index into argv at which options/args begin.
*        Default is 2, as appropriate for `process.argv`.
*      - env {Object} Optional. The env to use for 'env' entries in the
*        option specs. Defaults to `process.env`.
* @returns {Object} Parsed `opts`. It has special keys `_args` (the
*      remaining args from `argv`) and `_order` (gives the order that
*      options were specified).
*/

Parser.prototype.parse = function parse(inputs) {

var self = this;

// Old API was `parse([argv, [slice]])`
if (Array.isArray(arguments[0])) {
    inputs = {argv: arguments[0], slice: arguments[1]};
}

assert.optionalObject(inputs, 'inputs');
if (!inputs) {
    inputs = {};
}
assert.optionalArrayOfString(inputs.argv, 'inputs.argv');
//assert.optionalNumber(slice, 'slice');
var argv = inputs.argv || process.argv;
var slice = inputs.slice !== undefined ? inputs.slice : 2;
var args = argv.slice(slice);
var env = inputs.env || process.env;
var opts = {};
var _order = [];

function addOpt(option, optstr, key, val, from) {
    var type = optionTypes[option.type];
    var parsedVal = type.parseArg(option, optstr, val);
    if (type.array) {
        if (!opts[key]) {
            opts[key] = [];
        }
        if (type.arrayFlatten && Array.isArray(parsedVal)) {
            for (var i = 0; i < parsedVal.length; i++) {
                opts[key].push(parsedVal[i]);
            }
        } else {
            opts[key].push(parsedVal);
        }
    } else {
        opts[key] = parsedVal;
    }
    var item = { key: key, value: parsedVal, from: from };
    _order.push(item);
}

// Parse args.
var _args = [];
var i = 0;
outer: while (i < args.length) {
    var arg = args[i];

    // End of options marker.
    if (arg === '--') {
        i++;
        break;

    // Long option
    } else if (arg.slice(0, 2) === '--') {
        var name = arg.slice(2);
        var val = null;
        var idx = name.indexOf('=');
        if (idx !== -1) {
            val = name.slice(idx + 1);
            name = name.slice(0, idx);
        }
        var option = this.optionFromName[name];
        if (!option) {
            if (!this.allowUnknown)
                throw new Error(format('unknown option: "--%s"', name));
            else if (this.interspersed)
                _args.push(arg);
            else
                break outer;
        } else {
            var takesArg = this.optionTakesArg(option);
            if (val !== null && !takesArg) {
                throw new Error(format('argument given to "--%s" option '
                    + 'that does not take one: "%s"', name, arg));
            }
            if (!takesArg) {
                addOpt(option, '--'+name, option.key, true, 'argv');
            } else if (val !== null) {
                addOpt(option, '--'+name, option.key, val, 'argv');
            } else if (i + 1 >= args.length) {
                throw new Error(format('do not have enough args for "--%s" '
                    + 'option', name));
            } else {
                addOpt(option, '--'+name, option.key, args[i + 1], 'argv');
                i++;
            }
        }

    // Short option
    } else if (arg[0] === '-' && arg.length > 1) {
        var j = 1;
        var allFound = true;
        while (j < arg.length) {
            var name = arg[j];
            var option = this.optionFromName[name];
            if (!option) {
                allFound = false;
                if (this.allowUnknown) {
                    if (this.interspersed) {
                        _args.push(arg);
                        break;
                    } else
                        break outer;
                } else if (arg.length > 2) {
                    throw new Error(format(
                        'unknown option: "-%s" in "%s" group',
                        name, arg));
                } else {
                    throw new Error(format('unknown option: "-%s"', name));
                }
            } else if (this.optionTakesArg(option)) {
                break;
            }
            j++;
        }

        j = 1;
        while (allFound && j < arg.length) {
            var name = arg[j];
            var val = arg.slice(j + 1);  // option val if it takes an arg
            var option = this.optionFromName[name];
            var takesArg = this.optionTakesArg(option);
            if (!takesArg) {
                addOpt(option, '-'+name, option.key, true, 'argv');
            } else if (val) {
                addOpt(option, '-'+name, option.key, val, 'argv');
                break;
            } else {
                if (i + 1 >= args.length) {
                    throw new Error(format('do not have enough args '
                        + 'for "-%s" option', name));
                }
                addOpt(option, '-'+name, option.key, args[i + 1], 'argv');
                i++;
                break;
            }
            j++;
        }

    // An interspersed arg
    } else if (this.interspersed) {
        _args.push(arg);

    // An arg and interspersed args are not allowed, so done options.
    } else {
        break outer;
    }
    i++;
}
_args = _args.concat(args.slice(i));

// Parse environment.
Object.keys(this.optionFromEnv).forEach(function (envname) {
    var val = env[envname];
    if (val === undefined)
        return;
    var option = self.optionFromEnv[envname];
    if (opts[option.key] !== undefined)
        return;
    var takesArg = self.optionTakesArg(option);
    if (takesArg) {
        addOpt(option, envname, option.key, val, 'env');
    } else if (val !== '') {
        // Boolean envvar handling:
        // - VAR=<empty-string>     not set (as if the VAR was not set)
        // - VAR=0                  false
        // - anything else          true
        addOpt(option, envname, option.key, (val !== '0'), 'env');
    }
});

// Apply default values.
this.options.forEach(function (o) {
    if (opts[o.key] === undefined) {
        if (o.default !== undefined) {
            opts[o.key] = o.default;
        } else if (o.type && optionTypes[o.type].default !== undefined) {
            opts[o.key] = optionTypes[o.type].default;
        }
    }
});

opts._order = _order;
opts._args = _args;
return opts;

};

/**

* Return help output for the current options.
*
* E.g.: if the current options are:
*      [{names: ['help', 'h'], type: 'bool', help: 'Show help and exit.'}]
* then this would return:
*      '  -h, --help     Show help and exit.\n'
*
* @param config {Object} Config for controlling the option help output.
*      - indent {Number|String} Default 4. An indent/prefix to use for
*        each option line.
*      - nameSort {String} Default is 'length'. By default the names are
*        sorted to put the short opts first (i.e. '-h, --help' preferred
*        to '--help, -h'). Set to 'none' to not do this sorting.
*      - maxCol {Number} Default 80. Note that long tokens in a help string
*        can go past this.
*      - helpCol {Number} Set to specify a specific column at which
*        option help will be aligned. By default this is determined
*        automatically.
*      - minHelpCol {Number} Default 20.
*      - maxHelpCol {Number} Default 40.
*      - includeEnv {Boolean} Default false. If true, a note stating the `env`
*        envvar (if specified for this option) will be appended to the help
*        output.
*      - includeDefault {Boolean} Default false. If true, a note stating
*        the `default` for this option, if any, will be appended to the help
*        output.
*      - helpWrap {Boolean} Default true. Wrap help text in helpCol..maxCol
*        bounds.
* @returns {String}
*/

Parser.prototype.help = function help(config) {

config = config || {};
assert.object(config, 'config');

var indent = makeIndent(config.indent, 4, 'config.indent');
var headingIndent = makeIndent(config.headingIndent,
    Math.round(indent.length / 2), 'config.headingIndent');

assert.optionalString(config.nameSort, 'config.nameSort');
var nameSort = config.nameSort || 'length';
assert.ok(~['length', 'none'].indexOf(nameSort),
    'invalid "config.nameSort"');
assert.optionalNumber(config.maxCol, 'config.maxCol');
assert.optionalNumber(config.maxHelpCol, 'config.maxHelpCol');
assert.optionalNumber(config.minHelpCol, 'config.minHelpCol');
assert.optionalNumber(config.helpCol, 'config.helpCol');
assert.optionalBool(config.includeEnv, 'config.includeEnv');
assert.optionalBool(config.includeDefault, 'config.includeDefault');
assert.optionalBool(config.helpWrap, 'config.helpWrap');
var maxCol = config.maxCol || 80;
var minHelpCol = config.minHelpCol || 20;
var maxHelpCol = config.maxHelpCol || 40;

var lines = [];
var maxWidth = 0;
this.options.forEach(function (o) {
    if (o.hidden) {
        return;
    }
    if (o.group !== undefined && o.group !== null) {
        // We deal with groups in the next pass
        lines.push(null);
        return;
    }
    var type = optionTypes[o.type];
    var arg = o.helpArg || type.helpArg || 'ARG';
    var line = '';
    var names = o.names.slice();
    if (nameSort === 'length') {
        names.sort(function (a, b) {
            if (a.length < b.length)
                return -1;
            else if (b.length < a.length)
                return 1;
            else
                return 0;
        })
    }
    names.forEach(function (name, i) {
        if (i > 0)
            line += ', ';
        if (name.length === 1) {
            line += '-' + name
            if (type.takesArg)
                line += ' ' + arg;
        } else {
            line += '--' + name
            if (type.takesArg)
                line += '=' + arg;
        }
    });
    maxWidth = Math.max(maxWidth, line.length);
    lines.push(line);
});

// Add help strings.
var helpCol = config.helpCol;
if (!helpCol) {
    helpCol = maxWidth + indent.length + 2;
    helpCol = Math.min(Math.max(helpCol, minHelpCol), maxHelpCol);
}
var i = -1;
this.options.forEach(function (o) {
    if (o.hidden) {
        return;
    }
    i++;

    if (o.group !== undefined && o.group !== null) {
        if (o.group === '') {
            // Support a empty string "group" to have a blank line between
            // sets of options.
            lines[i] = '';
        } else {
            // Render the group heading with the heading-specific indent.
            lines[i] = (i === 0 ? '' : '\n') + headingIndent +
                o.group + ':';
        }
        return;
    }

    var helpDefault;
    if (config.includeDefault) {
        if (o.default !== undefined) {
            helpDefault = format('Default: %j', o.default);
        } else if (o.type && optionTypes[o.type].default !== undefined) {
            helpDefault = format('Default: %j',
                optionTypes[o.type].default);
        }
    }

    var line = lines[i] = indent + lines[i];
    if (!o.help && !(config.includeEnv && o.env) && !helpDefault) {
        return;
    }
    var n = helpCol - line.length;
    if (n >= 0) {
        line += space(n);
    } else {
        line += '\n' + space(helpCol);
    }

    var helpEnv = '';
    if (o.env && o.env.length && config.includeEnv) {
        helpEnv += 'Environment: ';
        var type = optionTypes[o.type];
        var arg = o.helpArg || type.helpArg || 'ARG';
        var envs = (Array.isArray(o.env) ? o.env : [o.env]).map(
            function (e) {
                if (type.takesArg) {
                    return e + '=' + arg;
                } else {
                    return e + '=1';
                }
            }
        );
        helpEnv += envs.join(', ');
    }
    var help = (o.help || '').trim();
    if (o.helpWrap !== false && config.helpWrap !== false) {
        // Wrap help description normally.
        if (help.length && !~'.!?"\''.indexOf(help.slice(-1))) {
            help += '.';
        }
        if (help.length) {
            help += ' ';
        }
        help += helpEnv;
        if (helpDefault) {
            if (helpEnv) {
                help += '. ';
            }
            help += helpDefault;
        }
        line += textwrap(help, maxCol - helpCol).join(
            '\n' + space(helpCol));
    } else {
        // Do not wrap help description, but indent newlines appropriately.
        var helpLines = help.split('\n').filter(
                function (ln) { return ln.length });
        if (helpEnv !== '') {
            helpLines.push(helpEnv);
        }
        if (helpDefault) {
            helpLines.push(helpDefault);
        }
        line += helpLines.join('\n' + space(helpCol));
    }

    lines[i] = line;
});

var rv = '';
if (lines.length > 0) {
    rv = lines.join('\n') + '\n';
}
return rv;

};

/**

* Return a string suitable for a Bash completion file for this tool.
*
* @param args.name {String} The tool name.
* @param args.specExtra {String} Optional. Extra Bash code content to add
*      to the end of the "spec". Typically this is used to append Bash
*      "complete_TYPE" functions for custom option types. See
*      "examples/ddcompletion.js" for an example.
* @param args.argtypes {Array} Optional. Array of completion types for
*      positional args (i.e. non-options). E.g.
*          argtypes = ['fruit', 'veggie', 'file']
*      will result in completion of fruits for the first arg, veggies for the
*      second, and filenames for the third and subsequent positional args.
*      If not given, positional args will use Bash's 'default' completion.
*      See `specExtra` for providing Bash `complete_TYPE` functions, e.g.
*      `complete_fruit` and `complete_veggie` in this example.
*/

Parser.prototype.bashCompletion = function bashCompletion(args) {

assert.object(args, 'args');
assert.string(args.name, 'args.name');
assert.optionalString(args.specExtra, 'args.specExtra');
assert.optionalArrayOfString(args.argtypes, 'args.argtypes');

return bashCompletionFromOptions({
    name: args.name,
    specExtra: args.specExtra,
    argtypes: args.argtypes,
    options: this.options
});

};

// —- Bash completion

const BASH_COMPLETION_TEMPLATE_PATH = path.join(

__dirname, '../etc/dashdash.bash_completion.in');

/**

* Return the Bash completion "spec" (the string value for the "{{spec}}"
* var in the "dashdash.bash_completion.in" template) for this tool.
*
* The "spec" is Bash code that defines the CLI options and subcmds for
* the template's completion code. It looks something like this:
*
*      local cmd_shortopts="-J ..."
*      local cmd_longopts="--help ..."
*      local cmd_optargs="-p=tritonprofile ..."
*
* @param args.options {Array} The array of dashdash option specs.
* @param args.context {String} Optional. A context string for the "local cmd*"
*      vars in the spec. By default it is the empty string. When used to
*      scope for completion on a *sub-command* (e.g. for "git log" on a "git"
*      tool), then it would have a value (e.g. "__log"). See
*      <http://github.com/trentm/node-cmdln> Bash completion for details.
* @param opts.includeHidden {Boolean} Optional. Default false. By default
*      hidden options and subcmds are "excluded". Here excluded means they
*      won't be offered as a completion, but if used, their argument type
*      will be completed. "Hidden" options and subcmds are ones with the
*      `hidden: true` attribute to exclude them from default help output.
* @param args.argtypes {Array} Optional. Array of completion types for
*      positional args (i.e. non-options). E.g.
*          argtypes = ['fruit', 'veggie', 'file']
*      will result in completion of fruits for the first arg, veggies for the
*      second, and filenames for the third and subsequent positional args.
*      If not given, positional args will use Bash's 'default' completion.
*      See `specExtra` for providing Bash `complete_TYPE` functions, e.g.
*      `complete_fruit` and `complete_veggie` in this example.
*/

function bashCompletionSpecFromOptions(args) {

assert.object(args, 'args');
assert.object(args.options, 'args.options');
assert.optionalString(args.context, 'args.context');
assert.optionalBool(args.includeHidden, 'args.includeHidden');
assert.optionalArrayOfString(args.argtypes, 'args.argtypes');

var context = args.context || '';
var includeHidden = (args.includeHidden === undefined
    ? false : args.includeHidden);

var spec = [];
var shortopts = [];
var longopts = [];
var optargs = [];
(args.options || []).forEach(function (o) {
    if (o.group !== undefined && o.group !== null) {
        // Skip group headers.
        return;
    }

    var optNames = o.names || [o.name];
    var optType = getOptionType(o.type);
    if (optType.takesArg) {
        var completionType = o.completionType ||
            optType.completionType || o.type;
        optNames.forEach(function (optName) {
            if (optName.length === 1) {
                if (includeHidden || !o.hidden) {
                    shortopts.push('-' + optName);
                }
                // Include even hidden options in `optargs` so that bash
                // completion of its arg still works.
                optargs.push('-' + optName + '=' + completionType);
            } else {
                if (includeHidden || !o.hidden) {
                    longopts.push('--' + optName);
                }
                optargs.push('--' + optName + '=' + completionType);
            }
        });
    } else {
        optNames.forEach(function (optName) {
            if (includeHidden || !o.hidden) {
                if (optName.length === 1) {
                    shortopts.push('-' + optName);
                } else {
                    longopts.push('--' + optName);
                }
            }
        });
    }
});

spec.push(format('local cmd%s_shortopts="%s"',
    context, shortopts.sort().join(' ')));
spec.push(format('local cmd%s_longopts="%s"',
    context, longopts.sort().join(' ')));
spec.push(format('local cmd%s_optargs="%s"',
    context, optargs.sort().join(' ')));
if (args.argtypes) {
    spec.push(format('local cmd%s_argtypes="%s"',
        context, args.argtypes.join(' ')));
}
return spec.join('\n');

}

/**

* Return a string suitable for a Bash completion file for this tool.
*
* @param args.name {String} The tool name.
* @param args.options {Array} The array of dashdash option specs.
* @param args.specExtra {String} Optional. Extra Bash code content to add
*      to the end of the "spec". Typically this is used to append Bash
*      "complete_TYPE" functions for custom option types. See
*      "examples/ddcompletion.js" for an example.
* @param args.argtypes {Array} Optional. Array of completion types for
*      positional args (i.e. non-options). E.g.
*          argtypes = ['fruit', 'veggie', 'file']
*      will result in completion of fruits for the first arg, veggies for the
*      second, and filenames for the third and subsequent positional args.
*      If not given, positional args will use Bash's 'default' completion.
*      See `specExtra` for providing Bash `complete_TYPE` functions, e.g.
*      `complete_fruit` and `complete_veggie` in this example.
*/

function bashCompletionFromOptions(args) {

assert.object(args, 'args');
assert.object(args.options, 'args.options');
assert.string(args.name, 'args.name');
assert.optionalString(args.specExtra, 'args.specExtra');
assert.optionalArrayOfString(args.argtypes, 'args.argtypes');

// Gather template data.
var data = {
    name: args.name,
    date: new Date(),
    spec: bashCompletionSpecFromOptions({
        options: args.options,
        argtypes: args.argtypes
    }),
};
if (args.specExtra) {
    data.spec += '\n\n' + args.specExtra;
}

// Render template.
var template = fs.readFileSync(BASH_COMPLETION_TEMPLATE_PATH, 'utf8');
return renderTemplate(template, data);

}

// —- exports

function createParser(config) {

return new Parser(config);

}

/**

* Parse argv with the given options.
*
* @param config {Object} A merge of all the available fields from
*      `dashdash.Parser` and `dashdash.Parser.parse`: options, interspersed,
*      argv, env, slice.
*/

function parse(config) {

assert.object(config, 'config');
assert.optionalArrayOfString(config.argv, 'config.argv');
assert.optionalObject(config.env, 'config.env');
var config = shallowCopy(config);
var argv = config.argv;
delete config.argv;
var env = config.env;
delete config.env;

var parser = new Parser(config);
return parser.parse({argv: argv, env: env});

}

/**

* Add a new option type.
*
* @params optionType {Object}:
*      - name {String} Required.
*      - takesArg {Boolean} Required. Whether this type of option takes an
*        argument on process.argv. Typically this is true for all but the
*        "bool" type.
*      - helpArg {String} Required iff `takesArg === true`. The string to
*        show in generated help for options of this type.
*      - parseArg {Function} Require. `function (option, optstr, arg)` parser
*        that takes a string argument and returns an instance of the
*        appropriate type, or throws an error if the arg is invalid.
*      - array {Boolean} Optional. Set to true if this is an 'arrayOf' type
*        that collects multiple usages of the option in process.argv and
*        puts results in an array.
*      - arrayFlatten {Boolean} Optional. XXX
*      - default Optional. Default value for options of this type, if no
*        default is specified in the option type usage.
*/

function addOptionType(optionType) {

assert.object(optionType, 'optionType');
assert.string(optionType.name, 'optionType.name');
assert.bool(optionType.takesArg, 'optionType.takesArg');
if (optionType.takesArg) {
    assert.string(optionType.helpArg, 'optionType.helpArg');
}
assert.func(optionType.parseArg, 'optionType.parseArg');
assert.optionalBool(optionType.array, 'optionType.array');
assert.optionalBool(optionType.arrayFlatten, 'optionType.arrayFlatten');

optionTypes[optionType.name] = {
    takesArg: optionType.takesArg,
    helpArg: optionType.helpArg,
    parseArg: optionType.parseArg,
    array: optionType.array,
    arrayFlatten: optionType.arrayFlatten,
    default: optionType.default
}

}

function getOptionType(name) {

assert.string(name, 'name');
return optionTypes[name];

}

/**

* Return a synopsis string for the given option spec.
*
* Examples:
*      > synopsisFromOpt({names: ['help', 'h'], type: 'bool'});
*      '[ --help | -h ]'
*      > synopsisFromOpt({name: 'file', type: 'string', helpArg: 'FILE'});
*      '[ --file=FILE ]'
*/

function synopsisFromOpt(o) {

assert.object(o, 'o');

if (o.hasOwnProperty('group')) {
    return null;
}
var names = o.names || [o.name];
// `type` here could be undefined if, for example, the command has a
// dashdash option spec with a bogus 'type'.
var type = getOptionType(o.type);
var helpArg = o.helpArg || (type && type.helpArg) || 'ARG';
var parts = [];
names.forEach(function (name) {
    var part = (name.length === 1 ? '-' : '--') + name;
    if (type && type.takesArg) {
        part += (name.length === 1 ? ' ' + helpArg : '=' + helpArg);
    }
    parts.push(part);
});
return ('[ ' + parts.join(' | ') + ' ]');

};

module.exports = {

createParser: createParser,
Parser: Parser,
parse: parse,
addOptionType: addOptionType,
getOptionType: getOptionType,
synopsisFromOpt: synopsisFromOpt,

// Bash completion-related exports
BASH_COMPLETION_TEMPLATE_PATH: BASH_COMPLETION_TEMPLATE_PATH,
bashCompletionFromOptions: bashCompletionFromOptions,
bashCompletionSpecFromOptions: bashCompletionSpecFromOptions,

// Export the parseFoo parsers because they might be useful as primitives
// for custom option types.
parseBool: parseBool,
parseString: parseString,
parseNumber: parseNumber,
parseInteger: parseInteger,
parsePositiveInteger: parsePositiveInteger,
parseDate: parseDate

};