You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
194 lines
5.9 KiB
JavaScript
194 lines
5.9 KiB
JavaScript
7 years ago
|
// validation-type-stuff, missing params,
|
||
|
// bad implications, custom checks.
|
||
|
module.exports = function (yargs, usage) {
|
||
|
var self = {};
|
||
|
|
||
|
// validate appropriate # of non-option
|
||
|
// arguments were provided, i.e., '_'.
|
||
|
self.nonOptionCount = function(argv) {
|
||
|
var demanded = yargs.getDemanded();
|
||
|
|
||
|
if (demanded._ && argv._.length < demanded._.count) {
|
||
|
if (demanded._.msg !== undefined) {
|
||
|
usage.fail(demanded._.msg);
|
||
|
} else {
|
||
|
usage.fail('Not enough non-option arguments: got '
|
||
|
+ argv._.length + ', need at least ' + demanded._.count
|
||
|
);
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// make sure that any args that require an
|
||
|
// value (--foo=bar), have a value.
|
||
|
self.missingArgumentValue = function(argv) {
|
||
|
var options = yargs.getOptions();
|
||
|
|
||
|
if (options.requiresArg.length > 0) {
|
||
|
var missingRequiredArgs = [];
|
||
|
|
||
|
options.requiresArg.forEach(function(key) {
|
||
|
var value = argv[key];
|
||
|
|
||
|
// parser sets --foo value to true / --no-foo to false
|
||
|
if (value === true || value === false) {
|
||
|
missingRequiredArgs.push(key);
|
||
|
}
|
||
|
});
|
||
|
|
||
|
if (missingRequiredArgs.length == 1) {
|
||
|
usage.fail("Missing argument value: " + missingRequiredArgs[0]);
|
||
|
}
|
||
|
else if (missingRequiredArgs.length > 1) {
|
||
|
var message = "Missing argument values: " + missingRequiredArgs.join(", ");
|
||
|
usage.fail(message);
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// make sure all the required arguments are present.
|
||
|
self.requiredArguments = function(argv) {
|
||
|
var demanded = yargs.getDemanded(),
|
||
|
missing = null;
|
||
|
|
||
|
Object.keys(demanded).forEach(function (key) {
|
||
|
if (!argv.hasOwnProperty(key)) {
|
||
|
missing = missing || {};
|
||
|
missing[key] = demanded[key];
|
||
|
}
|
||
|
});
|
||
|
|
||
|
if (missing) {
|
||
|
var customMsgs = [];
|
||
|
Object.keys(missing).forEach(function(key) {
|
||
|
var msg = missing[key].msg;
|
||
|
if (msg && customMsgs.indexOf(msg) < 0) {
|
||
|
customMsgs.push(msg);
|
||
|
}
|
||
|
});
|
||
|
var customMsg = customMsgs.length ? '\n' + customMsgs.join('\n') : '';
|
||
|
|
||
|
usage.fail('Missing required arguments: ' + Object.keys(missing).join(', ') + customMsg);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// check for unknown arguments (strict-mode).
|
||
|
self.unknownArguments = function(argv, aliases) {
|
||
|
var descriptions = usage.getDescriptions(),
|
||
|
demanded = yargs.getDemanded(),
|
||
|
unknown = [],
|
||
|
aliasLookup = {};
|
||
|
|
||
|
Object.keys(aliases).forEach(function (key) {
|
||
|
aliases[key].forEach(function (alias) {
|
||
|
aliasLookup[alias] = key;
|
||
|
});
|
||
|
});
|
||
|
|
||
|
Object.keys(argv).forEach(function (key) {
|
||
|
if (key !== "$0" && key !== "_" &&
|
||
|
!descriptions.hasOwnProperty(key) &&
|
||
|
!demanded.hasOwnProperty(key) &&
|
||
|
!aliasLookup.hasOwnProperty(key)) {
|
||
|
unknown.push(key);
|
||
|
}
|
||
|
});
|
||
|
|
||
|
if (unknown.length == 1) {
|
||
|
usage.fail("Unknown argument: " + unknown[0]);
|
||
|
}
|
||
|
else if (unknown.length > 1) {
|
||
|
usage.fail("Unknown arguments: " + unknown.join(", "));
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// custom checks, added using the `check` option on yargs.
|
||
|
var checks = [];
|
||
|
self.check = function (f) {
|
||
|
checks.push(f);
|
||
|
};
|
||
|
|
||
|
self.customChecks = function(argv, aliases) {
|
||
|
checks.forEach(function (f) {
|
||
|
try {
|
||
|
var result = f(argv, aliases);
|
||
|
if (!result) {
|
||
|
usage.fail('Argument check failed: ' + f.toString());
|
||
|
} else if (typeof result === 'string') {
|
||
|
usage.fail(result);
|
||
|
}
|
||
|
}
|
||
|
catch (err) {
|
||
|
usage.fail(err)
|
||
|
}
|
||
|
});
|
||
|
};
|
||
|
|
||
|
// check implications, argument foo implies => argument bar.
|
||
|
var implied = {};
|
||
|
self.implies = function (key, value) {
|
||
|
if (typeof key === 'object') {
|
||
|
Object.keys(key).forEach(function (k) {
|
||
|
self.implies(k, key[k]);
|
||
|
});
|
||
|
} else {
|
||
|
implied[key] = value;
|
||
|
}
|
||
|
};
|
||
|
self.getImplied = function() {
|
||
|
return implied;
|
||
|
}
|
||
|
|
||
|
self.implications = function(argv) {
|
||
|
var implyFail = [];
|
||
|
|
||
|
Object.keys(implied).forEach(function (key) {
|
||
|
var num, origKey = key, value = implied[key];
|
||
|
|
||
|
// convert string '1' to number 1
|
||
|
var num = Number(key);
|
||
|
key = isNaN(num) ? key : num;
|
||
|
|
||
|
if (typeof key === 'number') {
|
||
|
// check length of argv._
|
||
|
key = argv._.length >= key;
|
||
|
} else if (key.match(/^--no-.+/)) {
|
||
|
// check if key doesn't exist
|
||
|
key = key.match(/^--no-(.+)/)[1];
|
||
|
key = !argv[key];
|
||
|
} else {
|
||
|
// check if key exists
|
||
|
key = argv[key];
|
||
|
}
|
||
|
|
||
|
num = Number(value);
|
||
|
value = isNaN(num) ? value : num;
|
||
|
|
||
|
if (typeof value === 'number') {
|
||
|
value = argv._.length >= value;
|
||
|
} else if (value.match(/^--no-.+/)) {
|
||
|
value = value.match(/^--no-(.+)/)[1];
|
||
|
value = !argv[value];
|
||
|
} else {
|
||
|
value = argv[value];
|
||
|
}
|
||
|
|
||
|
if (key && !value) {
|
||
|
implyFail.push(origKey);
|
||
|
}
|
||
|
});
|
||
|
|
||
|
if (implyFail.length) {
|
||
|
var msg = 'Implications failed:\n';
|
||
|
|
||
|
implyFail.forEach(function (key) {
|
||
|
msg += (' ' + key + ' -> ' + implied[key]);
|
||
|
});
|
||
|
|
||
|
usage.fail(msg);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return self;
|
||
|
}
|