lepu-test-platform-web/node_modules/clap/index.js

951 lines
22 KiB
JavaScript

var MAX_LINE_WIDTH = process.stdout.columns || 200;
var MIN_OFFSET = 25;
var errorHandler;
var commandsPath;
var reAstral = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
var ansiRegex = /\x1B\[([0-9]{1,3}(;[0-9]{1,3})*)?[m|K]/g;
var hasOwnProperty = Object.prototype.hasOwnProperty;
function stringLength(str){
return str
.replace(ansiRegex, '')
.replace(reAstral, ' ')
.length;
}
function camelize(name){
return name.replace(/-(.)/g, function(m, ch){
return ch.toUpperCase();
});
}
function assign(dest, source){
for (var key in source)
if (hasOwnProperty.call(source, key))
dest[key] = source[key];
return dest;
}
function returnFirstArg(value){
return value;
}
function pad(width, str){
return str + Array(Math.max(0, width - stringLength(str)) + 1).join(' ');
}
function noop(){
// nothing todo
}
function parseParams(str){
// params [..<required>] [..[optional]]
// <foo> - require
// [foo] - optional
var tmp;
var left = str.trim();
var result = {
minArgsCount: 0,
maxArgsCount: 0,
args: []
};
do {
tmp = left;
left = left.replace(/^<([a-zA-Z][a-zA-Z0-9\-\_]*)>\s*/, function(m, name){
result.args.push(new Argument(name, true));
result.minArgsCount++;
result.maxArgsCount++;
return '';
});
}
while (tmp != left);
do {
tmp = left;
left = left.replace(/^\[([a-zA-Z][a-zA-Z0-9\-\_]*)\]\s*/, function(m, name){
result.args.push(new Argument(name, false));
result.maxArgsCount++;
return '';
});
}
while (tmp != left);
if (left)
throw new SyntaxError('Bad parameter description: ' + str);
return result.args.length ? result : false;
}
/**
* @class
*/
var SyntaxError = function(message){
this.message = message;
};
SyntaxError.prototype = Object.create(Error.prototype);
SyntaxError.prototype.name = 'SyntaxError';
SyntaxError.prototype.clap = true;
/**
* @class
*/
var Argument = function(name, required){
this.name = name;
this.required = required;
};
Argument.prototype = {
required: false,
name: '',
normalize: returnFirstArg,
suggest: function(){
return [];
}
};
/**
* @class
* @param {string} usage
* @param {string} description
*/
var Option = function(usage, description){
var self = this;
var params;
var left = usage.trim()
// short usage
// -x
.replace(/^-([a-zA-Z])(?:\s*,\s*|\s+)/, function(m, name){
self.short = name;
return '';
})
// long usage
// --flag
// --no-flag - invert value if flag is boolean
.replace(/^--([a-zA-Z][a-zA-Z0-9\-\_]+)\s*/, function(m, name){
self.long = name;
self.name = name.replace(/(^|-)no-/, '$1');
self.defValue = self.name != self.long;
return '';
});
if (!this.long)
throw new SyntaxError('Usage has no long name: ' + usage);
try {
params = parseParams(left);
} catch(e) {
throw new SyntaxError('Bad paramenter description in usage for option: ' + usage, e);
}
if (params)
{
left = '';
this.name = this.long;
this.defValue = undefined;
assign(this, params);
}
if (left)
throw new SyntaxError('Bad usage description for option: ' + usage);
if (!this.name)
this.name = this.long;
this.description = description || '';
this.usage = usage.trim();
this.camelName = camelize(this.name);
};
Option.prototype = {
name: '',
description: '',
short: '',
long: '',
beforeInit: false,
required: false,
minArgsCount: 0,
maxArgsCount: 0,
args: null,
defValue: undefined,
normalize: returnFirstArg
};
//
// Command
//
function createOption(usage, description, opt_1, opt_2){
var option = new Option(usage, description);
// if (option.bool && arguments.length > 2)
// throw new SyntaxError('bool flags can\'t has default value or validator');
if (arguments.length == 3)
{
if (opt_1 && opt_1.constructor === Object)
{
for (var key in opt_1)
if (key == 'normalize' ||
key == 'defValue' ||
key == 'beforeInit')
option[key] = opt_1[key];
// old name for `beforeInit` setting is `hot`
if (opt_1.hot)
option.beforeInit = true;
}
else
{
if (typeof opt_1 == 'function')
option.normalize = opt_1;
else
option.defValue = opt_1;
}
}
if (arguments.length == 4)
{
if (typeof opt_1 == 'function')
option.normalize = opt_1;
option.defValue = opt_2;
}
return option;
}
function addOptionToCommand(command, option){
var commandOption;
// short
if (option.short)
{
commandOption = command.short[option.short];
if (commandOption)
throw new SyntaxError('Short option name -' + option.short + ' already in use by ' + commandOption.usage + ' ' + commandOption.description);
command.short[option.short] = option;
}
// long
commandOption = command.long[option.long];
if (commandOption)
throw new SyntaxError('Long option --' + option.long + ' already in use by ' + commandOption.usage + ' ' + commandOption.description);
command.long[option.long] = option;
// camel
commandOption = command.options[option.camelName];
if (commandOption)
throw new SyntaxError('Name option ' + option.camelName + ' already in use by ' + commandOption.usage + ' ' + commandOption.description);
command.options[option.camelName] = option;
// set default value
if (typeof option.defValue != 'undefined')
command.setOption(option.camelName, option.defValue, true);
// add to suggestions
command.suggestions.push('--' + option.long);
return option;
}
function findVariants(obj, entry){
return obj.suggestions.filter(function(item){
return item.substr(0, entry.length) == entry;
});
}
function processArgs(command, args, suggest){
function processOption(option, command){
var params = [];
if (option.maxArgsCount)
{
for (var j = 0; j < option.maxArgsCount; j++)
{
var suggestPoint = suggest && i + 1 + j >= args.length - 1;
var nextToken = args[i + 1];
// TODO: suggestions for options
if (suggestPoint)
{
// search for suggest
noSuggestions = true;
i = args.length;
return;
}
if (!nextToken || nextToken[0] == '-')
break;
params.push(args[++i]);
}
if (params.length < option.minArgsCount)
throw new SyntaxError('Option ' + token + ' should be used with at least ' + option.minArgsCount + ' argument(s)\nUsage: ' + option.usage);
if (option.maxArgsCount == 1)
params = params[0];
}
else
{
params = !option.defValue;
}
//command.values[option.camelName] = newValue;
resultToken.options.push({
option: option,
value: params
});
}
var resultToken = {
command: command,
args: [],
literalArgs: [],
options: []
};
var result = [resultToken];
var suggestStartsWith = '';
var noSuggestions = false;
var collectArgs = false;
var commandArgs = [];
var noOptionsYet = true;
var option;
commandsPath = [command.name];
for (var i = 0; i < args.length; i++)
{
var suggestPoint = suggest && i == args.length - 1;
var token = args[i];
if (collectArgs)
{
commandArgs.push(token);
continue;
}
if (suggestPoint && (token == '--' || token == '-' || token[0] != '-'))
{
suggestStartsWith = token;
break; // returns long option & command list outside the loop
}
if (token == '--')
{
resultToken.args = commandArgs;
commandArgs = [];
noOptionsYet = false;
collectArgs = true;
continue;
}
if (token[0] == '-')
{
noOptionsYet = false;
if (commandArgs.length)
{
//command.args_.apply(command, commandArgs);
resultToken.args = commandArgs;
commandArgs = [];
}
if (token[1] == '-')
{
// long option
option = command.long[token.substr(2)];
if (!option)
{
// option doesn't exist
if (suggestPoint)
return findVariants(command, token);
else
throw new SyntaxError('Unknown option: ' + token);
}
// process option
processOption(option, command);
}
else
{
// short flags sequence
if (!/^-[a-zA-Z]+$/.test(token))
throw new SyntaxError('Wrong short option sequence: ' + token);
if (token.length == 2)
{
option = command.short[token[1]];
if (!option)
throw new SyntaxError('Unknown short option name: -' + token[1]);
// single option
processOption(option, command);
}
else
{
// short options sequence
for (var j = 1; j < token.length; j++)
{
option = command.short[token[j]];
if (!option)
throw new SyntaxError('Unknown short option name: -' + token[j]);
if (option.maxArgsCount)
throw new SyntaxError('Non-boolean option -' + token[j] + ' can\'t be used in short option sequence: ' + token);
processOption(option, command);
}
}
}
}
else
{
if (command.commands[token] && (!command.params || commandArgs.length >= command.params.minArgsCount))
{
if (noOptionsYet)
{
resultToken.args = commandArgs;
commandArgs = [];
}
if (command.params && resultToken.args.length < command.params.minArgsCount)
throw new SyntaxError('Missed required argument(s) for command `' + command.name + '`');
// switch control to another command
command = command.commands[token];
noOptionsYet = true;
commandsPath.push(command.name);
resultToken = {
command: command,
args: [],
literalArgs: [],
options: []
};
result.push(resultToken);
}
else
{
if (noOptionsYet && command.params && commandArgs.length < command.params.maxArgsCount)
{
commandArgs.push(token);
continue;
}
if (suggestPoint)
return findVariants(command, token);
else
throw new SyntaxError('Unknown command: ' + token);
}
}
}
if (suggest)
{
if (collectArgs || noSuggestions)
return [];
return findVariants(command, suggestStartsWith);
}
else
{
if (!noOptionsYet)
resultToken.literalArgs = commandArgs;
else
resultToken.args = commandArgs;
if (command.params && resultToken.args.length < command.params.minArgsCount)
throw new SyntaxError('Missed required argument(s) for command `' + command.name + '`');
}
return result;
}
function setFunctionFactory(name){
return function(fn){
var property = name + '_';
if (this[property] !== noop)
throw new SyntaxError('Method `' + name + '` could be invoked only once');
if (typeof fn != 'function')
throw new SyntaxError('Value for `' + name + '` method should be a function');
this[property] = fn;
return this;
}
}
/**
* @class
*/
var Command = function(name, params){
this.name = name;
this.params = false;
try {
if (params)
this.params = parseParams(params);
} catch(e) {
throw new SyntaxError('Bad paramenter description in command definition: ' + this.name + ' ' + params);
}
this.commands = {};
this.options = {};
this.short = {};
this.long = {};
this.values = {};
this.defaults_ = {};
this.suggestions = [];
this.option('-h, --help', 'Output usage information', function(){
this.showHelp();
process.exit(0);
}, undefined);
};
Command.prototype = {
params: null,
commands: null,
options: null,
short: null,
long: null,
values: null,
defaults_: null,
suggestions: null,
description_: '',
version_: '',
initContext_: noop,
init_: noop,
delegate_: noop,
action_: noop,
args_: noop,
end_: null,
option: function(usage, description, opt_1, opt_2){
addOptionToCommand(this, createOption.apply(null, arguments));
return this;
},
shortcut: function(usage, description, fn, opt_1, opt_2){
if (typeof fn != 'function')
throw new SyntaxError('fn should be a function');
var command = this;
var option = addOptionToCommand(this, createOption(usage, description, opt_1, opt_2));
var normalize = option.normalize;
option.normalize = function(value){
var values;
value = normalize.call(command, value);
values = fn(value);
for (var name in values)
if (hasOwnProperty.call(values, name))
if (hasOwnProperty.call(command.options, name))
command.setOption(name, values[name]);
else
command.values[name] = values[name];
command.values[option.name] = value;
return value;
};
return this;
},
hasOption: function(name){
return hasOwnProperty.call(this.options, name);
},
hasOptions: function(){
return Object.keys(this.options).length > 0;
},
setOption: function(name, value, isDefault){
if (!this.hasOption(name))
throw new SyntaxError('Option `' + name + '` is not defined');
var option = this.options[name];
var oldValue = this.values[name];
var newValue = option.normalize.call(this, value, oldValue);
this.values[name] = option.maxArgsCount ? newValue : value;
if (isDefault && !hasOwnProperty.call(this.defaults_, name))
this.defaults_[name] = this.values[name];
},
setOptions: function(values){
for (var name in values)
if (hasOwnProperty.call(values, name) && this.hasOption(name))
this.setOption(name, values[name]);
},
reset: function(){
this.values = {};
assign(this.values, this.defaults_);
},
command: function(nameOrCommand, params){
var name;
var command;
if (nameOrCommand instanceof Command)
{
command = nameOrCommand;
name = command.name;
}
else
{
name = nameOrCommand;
if (!/^[a-zA-Z][a-zA-Z0-9\-\_]*$/.test(name))
throw new SyntaxError('Wrong command name: ' + name);
}
// search for existing one
var subcommand = this.commands[name];
if (!subcommand)
{
// create new one if not exists
subcommand = command || new Command(name, params);
subcommand.end_ = this;
this.commands[name] = subcommand;
this.suggestions.push(name);
}
return subcommand;
},
end: function() {
return this.end_;
},
hasCommands: function(){
return Object.keys(this.commands).length > 0;
},
version: function(version, usage, description){
if (this.version_)
throw new SyntaxError('Version for command could be set only once');
this.version_ = version;
this.option(
usage || '-v, --version',
description || 'Output version',
function(){
console.log(this.version_);
process.exit(0);
},
undefined
);
return this;
},
description: function(description){
if (this.description_)
throw new SyntaxError('Description for command could be set only once');
this.description_ = description;
return this;
},
init: setFunctionFactory('init'),
initContext: setFunctionFactory('initContext'),
args: setFunctionFactory('args'),
delegate: setFunctionFactory('delegate'),
action: setFunctionFactory('action'),
extend: function(fn){
fn.apply(null, [this].concat(Array.prototype.slice.call(arguments, 1)));
return this;
},
parse: function(args, suggest){
if (!args)
args = process.argv.slice(2);
if (!errorHandler)
return processArgs(this, args, suggest);
else
try {
return processArgs(this, args, suggest);
} catch(e) {
errorHandler(e.message || e);
}
},
run: function(args, context){
var commands = this.parse(args);
if (!commands)
return;
var prevCommand;
var context = assign({}, context || this.initContext_());
for (var i = 0; i < commands.length; i++)
{
var item = commands[i];
var command = item.command;
// reset command values
command.reset();
command.context = context;
command.root = this;
if (prevCommand)
prevCommand.delegate_(command);
// apply beforeInit options
item.options.forEach(function(entry){
if (entry.option.beforeInit)
command.setOption(entry.option.camelName, entry.value);
});
command.init_(item.args.slice()); // use slice to avoid args mutation in handler
if (item.args.length)
command.args_(item.args.slice()); // use slice to avoid args mutation in handler
// apply regular options
item.options.forEach(function(entry){
if (!entry.option.beforeInit)
command.setOption(entry.option.camelName, entry.value);
});
prevCommand = command;
}
// return last command action result
if (command)
return command.action_(item.args, item.literalArgs);
},
normalize: function(values){
var result = {};
if (!values)
values = {};
for (var name in this.values)
if (hasOwnProperty.call(this.values, name))
result[name] = hasOwnProperty.call(values, name) && hasOwnProperty.call(this.options, name)
? this.options[name].normalize.call(this, values[name])
: this.values[name];
for (var name in values)
if (hasOwnProperty.call(values, name) && !hasOwnProperty.call(result, name))
result[name] = values[name];
return result;
},
showHelp: function(){
console.log(showCommandHelp(this));
}
};
//
// help
//
/**
* Return program help documentation.
*
* @return {String}
* @api private
*/
function showCommandHelp(command){
function breakByLines(str, offset){
var words = str.split(' ');
var maxWidth = MAX_LINE_WIDTH - offset || 0;
var lines = [];
var line = '';
while (words.length)
{
var word = words.shift();
if (!line || (line.length + word.length + 1) < maxWidth)
{
line += (line ? ' ' : '') + word;
}
else
{
lines.push(line);
words.unshift(word);
line = '';
}
}
lines.push(line);
return lines.map(function(line, idx){
return (idx && offset ? pad(offset, '') : '') + line;
}).join('\n');
}
function args(command){
return command.params.args.map(function(arg){
return arg.required
? '<' + arg.name + '>'
: '[' + arg.name + ']';
}).join(' ');
}
function commandsHelp(){
if (!command.hasCommands())
return '';
var maxNameLength = MIN_OFFSET - 2;
var lines = Object.keys(command.commands).sort().map(function(name){
var subcommand = command.commands[name];
var line = {
name: chalk.green(name) + chalk.gray(
(subcommand.params ? ' ' + args(subcommand) : '')
// (subcommand.hasOptions() ? ' [options]' : '')
),
description: subcommand.description_ || ''
};
maxNameLength = Math.max(maxNameLength, stringLength(line.name));
return line;
});
return [
'',
'Commands:',
'',
lines.map(function(line){
return ' ' + pad(maxNameLength, line.name) + ' ' + breakByLines(line.description, maxNameLength + 4);
}).join('\n'),
''
].join('\n');
}
function optionsHelp(){
if (!command.hasOptions())
return '';
var hasShortOptions = Object.keys(command.short).length > 0;
var maxNameLength = MIN_OFFSET - 2;
var lines = Object.keys(command.long).sort().map(function(name){
var option = command.long[name];
var line = {
name: option.usage
.replace(/^(?:-., |)/, function(m){
return m || (hasShortOptions ? ' ' : '');
})
.replace(/(^|\s)(-[^\s,]+)/ig, function(m, p, flag){
return p + chalk.yellow(flag);
}),
description: option.description
};
maxNameLength = Math.max(maxNameLength, stringLength(line.name));
return line;
});
// Prepend the help information
return [
'',
'Options:',
'',
lines.map(function(line){
return ' ' + pad(maxNameLength, line.name) + ' ' + breakByLines(line.description, maxNameLength + 4);
}).join('\n'),
''
].join('\n');
}
var output = [];
var chalk = require('chalk');
chalk.enabled = module.exports.color && process.stdout.isTTY;
if (command.description_)
output.push(command.description_ + '\n');
output.push(
'Usage:\n\n ' +
chalk.cyan(commandsPath ? commandsPath.join(' ') : command.name) +
(command.params ? ' ' + chalk.magenta(args(command)) : '') +
(command.hasOptions() ? ' [' + chalk.yellow('options') + ']' : '') +
(command.hasCommands() ? ' [' + chalk.green('command') + ']' : ''),
commandsHelp() +
optionsHelp()
);
return output.join('\n');
};
//
// export
//
module.exports = {
color: true,
Error: SyntaxError,
Argument: Argument,
Command: Command,
Option: Option,
error: function(fn){
if (errorHandler)
throw new SyntaxError('Error handler should be set only once');
if (typeof fn != 'function')
throw new SyntaxError('Error handler should be a function');
errorHandler = fn;
return this;
},
create: function(name, params){
return new Command(name || require('path').basename(process.argv[1]) || 'cli', params);
},
confirm: function(message, fn){
process.stdout.write(message);
process.stdin.setEncoding('utf8');
process.stdin.once('data', function(val){
process.stdin.pause();
fn(/^y|yes|ok|true$/i.test(val.trim()));
});
process.stdin.resume();
}
};