var parseArgs = function parseArgs() {
var parser = new ArgumentParser({
version: require('../package').version,
addHelp:true,
description: 'Dorusu Node.js Interopability Test Server.\n' +
'Runs the Interoperability test server used to validate' +
' RPCs implementations'
});
parser.addArgument(
[ '-p', '--port' ],
{
defaultValue: 50051,
help: 'The Interop Server port',
type: 'int'
}
);
parser.addArgument(
[ '-s', '--use_tls' ],
{
defaultValue: false,
action: 'storeTrue',
help: 'When set, indicates that the server should be accessed' +
' securely using the example test credentials'
}
);
return parser.parseArgs();
};
function buildArgParser() {
var ArgumentParser = require('argparse').ArgumentParser,
parser = new ArgumentParser({
version: packageInfo.version,
description: packageInfo.description,
addHelp: true,
prog: 'bem-csser'
});
parser.addArgument(
['action'],
{
action: 'store',
choices: ['count-sizes'],
help: 'What to do'
}
);
parser.addArgument(
['-p', '--path'],
{
action: 'store',
required: false,
defaultValue: process.cwd(),
help: 'Path for handling (cwd by default). May be a file or a directory'
}
);
return parser;
}
var parseArgs = function parseArgs() {
var parser = new ArgumentParser({
version: require('../package').version,
addHelp:true,
description: 'Dorusu Node.js Math Server example.\n' +
'Runs an example Math Server and handles sample' +
' RPCs.'
});
parser.addArgument(
[ '-p', '--port' ],
{
defaultValue: 50051,
help: 'The Math Server port',
type: 'int'
}
);
parser.addArgument(
[ '-s', '--use_tls' ],
{
defaultValue: false,
action: 'storeTrue',
help: 'When set, indicates that the server should be accessed' +
' securely using the example test credentials'
}
);
return parser.parseArgs();
};
const parseArguments = (args) => {
const parser = new argparse.ArgumentParser({ prog: 'hz init' });
parser.addArgument([ 'projectName' ],
{ action: 'store',
help: 'Name of directory to create. Defaults to current directory',
nargs: '?',
}
);
return parser.parseArgs(args);
};
let args = (function() {
let parser = new ArgumentParser();
parser.addArgument(["-d", "--db"], {
required: true,
help: "path to scrape-fcc sqlite database",
});
return parser.parseArgs();
})();
(function () {
"use strict";
var ArgumentParser = require('argparse').ArgumentParser
, parser
, subparsers
, args
;
parser = new ArgumentParser({
version: require('../package.json').version
, addHelp: true
, descriptions: require('../package.json').description
});
require('./argparsers/main').create(parser);
subparsers = parser.addSubparsers({
title:'subcommands',
dest:"subcommand_name"
});
// pakmanager build
require('./argparsers/build').create(subparsers.addParser('build',
{
addHelp: true
, aliases: ['b']
}
));
// pakmanager deps
require('./argparsers/deps').create(subparsers.addParser('deps',
{
aliases: ['d']
, addHelp: true
}
));
// pakmanager add
/*
parser.addArgument(
['anonymous']
, {
metavar: "N"
, type: 'string'
, nargs: '*'
, help: "some parameters"
}
);
//*/
exports.parse = function () {
return parser.parseArgs();
};
}());
module.exports.run = function(args){
//set up argparse
var parser = new ArgumentParser({
description: 'USGMailer - Mailing Application for the USG'
});
//add possible arguments
parser.addArgument(["--config", "-c"], {defaultValue: "config.json", help: "Path to configuration file to use. "});
parser.addArgument(["--keep-sessions"], {action: "storeTrue", help: "Keep sessions intact. Not recommended as it may cause security gaps. "});
(function(parser){
parser.addArgument(["--test-config", "-t"], {action: "storeTrue", help: "Tests configuration file and then exits. "});
parser.addArgument(["--clear-db", "-d"], {action: "storeTrue", help: "Clears the database on startup and then exits. "});
parser.addArgument(["--grant-user", "-u"], {metavar: "USER", help: "Grants the given user access and then exits. "});
parser.addArgument(["--grant-admin", "-a"], {metavar: "USER", help: "Grants the given user access, gives them admin privileges and then exits. "});
parser.addArgument(["--remove-user", "-r"], {metavar: "USER", help: "removes the given user from the database and then exits. "});
})(parser.addArgumentGroup({title: 'Startup modes'}).addMutuallyExclusiveGroup());
//parse the arguments
var args = parser.parseArgs(args.slice(2));
var theQueue = new QueueRunner(args, function(e){
console.error(e.stack);
console.log("Error processing tasks, exiting with status 1. ");
process.exit(1);
}, function(){
console.log("Done processing tasks, exiting with status 0. ");
process.exit(0);
});
//load the config
theQueue.push(module.exports.init_config);
if(!args.test_config){
theQueue.push(function(args, next){
console.log("Loading components ...");
//intialise everything else.
theQueue.push(require("./usermodel").core.init);
theQueue.push(require("./express").init);
console.log(" Done. ");
//and next.
next();
});
}
//and run it
theQueue.start();
}
function init() {
const parser = new ArgumentParser({
version: require('../package.json').version,
description: 'Deploy static files with a static.json file',
});
const subparsers = parser.addSubparsers({
dest: 'command',
});
const common = initCommon();
initSubFetch(subparsers, common);
initSubLink(subparsers, common);
initSubClean(subparsers, common);
return parser;
}
function initCommon() {
const parser = new ArgumentParser({
addHelp: false,
});
parser.addArgument(['-d', '--dist'], {
help: 'the directory to hold the static files',
defaultValue: '.',
});
parser.addArgument(['-V', '--verbose'], {
help: 'Show verbose log.',
action: 'storeTrue',
});
return [parser];
}
function getParser () {
let parser = new ArgumentParser({
version: pkgObj.version,
addHelp: true,
description: 'A webdriver-compatible server for use with native and hybrid iOS and Android applications.'
});
let allArgs = _.union(args, deprecatedArgs);
parser.rawArgs = allArgs;
for (let arg of allArgs) {
parser.addArgument(arg[0], arg[1]);
}
updateParseArgsForDefaultCapabilities(parser);
return parser;
}
/**
* @param {!Array<string>=} opt_args
* @return {!Promise<{errors:!Array<!ParseError>,text:(string|undefined)}>}
*/
async function main(opt_args) {
const args = argparser.parseArgs(opt_args);
if (!args.inputs && !args.roots) {
argparser.error('Must supply inputs and/or roots.');
return;
}
const sources = new Set((args.inputs || []).map(resolve));
const roots = (args.roots || []).map(resolve);
const excluded = new Set((args.exclude || []).map(resolve));
const allFiles =
await Promise.all(roots.map(r => findAllJsFiles(r, excluded)));
for (const files of allFiles) {
for (const file of files) {
sources.add(file);
}
}
const results = await Promise.all([...sources].map(parser.parseFileAsync));
let fatal = false;
const errors = [].concat.apply([], results.map(r => r.errors));
for (const error of errors) {
fatal = fatal || error.fatal;
}
if (fatal) {
return {errors};
}
const deps = results.map(r => r.dependency);
// Make a graph to perform validation and potentially get the path to Closure.
const graph = new depGraph.Graph(deps);
if (!args.closurePath && !graph.depsBySymbol.has('goog')) {
throw new Error(
'Could not find path to Closure. Closure\'s base.js either needs to ' +
'be included or --closure-path provided.');
}
const closurePath =
args.closurePath || path.dirname(graph.depsBySymbol.get('goog').path);
const text = depFile.getDepFileText(closurePath, deps);
return {errors, text};
}
function getParser () {
let parser = new ArgumentParser({
version: require(path.resolve(rootDir, 'package.json')).version,
addHelp: true,
description: 'A webdriver-compatible server for use with native and hybrid iOS and Android applications.',
prog: process.argv[1] || 'Appium'
});
let allArgs = _.union(args, deprecatedArgs);
parser.rawArgs = allArgs;
for (let arg of allArgs) {
parser.addArgument(arg[0], arg[1]);
}
updateParseArgsForDefaultCapabilities(parser);
return parser;
}
function parseSource( errBuf ) {
var parsers = {
monolith: function(){
return require( './monolith-parser.js' );
},
category: function(){
return require( './category-parser.js' );
},
language: function(){
return require( './language-parser.js' );
}
},
args = argv.parseArgs(),
file = path.resolve( path.extname( args.file ) ? args.file : args.file + '.json' ),
source;
if ( fs.existsSync( file ) ) {
try {
source = JSON.parse( fs.readFileSync( file, 'utf8' ) );
} catch (e) {
errBuf.push( 'Error (source): wrong format for "' + file + '"' );
return false;
} // try..catch
if ( commons.validateMeta( source.meta || source, errBuf ) ) {
return parsers[ (source.meta || source).format ]().parse( source, errBuf );
} // if
} else {
errBuf.push( 'Error (source): unable to open "' + file + '"' );
return false;
} // if..else
} // parseSource()
function parseArgs() {
var parser = new ArgumentParser({addHelp: true});
parser.addArgument(['-c', '--capacity'], {
help: 'capacity of connection pool',
type: Number,
defaultValue: 10,
dest: 'capacity'
});
parser.addArgument(['-n', '--numiters'], {
help: 'number of iterations to run',
type: Number,
defaultValue: 100,
dest: 'numiters'
});
return parser.parseArgs();
}
function parseArgs() {
var parser = new ArgumentParser({addHelp: true});
parser.addArgument(['-p', '--port'], {
help: 'port to listen on',
type: Number,
defaultValue: 8081,
dest: 'port'
});
parser.addArgument(['-H', '--host'], {
help: 'hostname/IP to bind to',
type: String,
defaultValue: 'localhost',
dest: 'host'
});
return parser.parseArgs();
}
function parserFactory(opts, defaults) {
if (!opts || !opts.cmd && (!opts.subCmds || !opts.subCmds.length)) {
throw new Error('opts.cmd or opts.subCmds must be set.');
}
const parser = new argparse.ArgumentParser({
version: opts.version || '0.0.0',
addHelp: opts.addHelp === false ? false : true,
description: opts.description || '',
formatterClass: argparse.RawTextHelpFormatter,
epilog: opts.epilog
});
parser.addArgument(['-d', '--debug' ], {
action: 'storeTrue',
help: 'print debug messages'
});
parser.addArgument(['-s', '--silent' ], {
action: 'storeTrue',
help: 'print only error messages'
});
if (opts.options) {
opts.options(parser, defaults);
}
if (opts.cmd) {
parser.setDefaults({cmd: opts.cmd});
return parser;
}
const subparsers = parser.addSubparsers();
opts.subCmds.forEach(sub => {
const parser = subparsers.addParser(sub.name, {
addHelp: true,
description: sub.description,
formatterClass: argparse.RawTextHelpFormatter
});
parser.setDefaults({cmd: sub.cmd});
sub.options(parser, defaults);
});
return parser;
}
function main() {
var parser = new argparse.ArgumentParser({
addHelp:true,
description: 'Serve presentations via HTTP'
});
parser.addArgument(['-l', '--launch-webbrowser'], {help: 'Launch a webbrowser that shows the presentation', action: 'storeTrue'});
parser.addArgument(['-p', '--port'], {help: 'Port to use', defaultValue: 0});
parser.addArgument(['-P', '--public-serv'], {help: 'Make this webserver available to the world', action: 'storeTrue'});
var args = parser.parseArgs();
var server = http.createServer(handleRequest);
server.listen(args.port, args.public_serv ? '' : 'localhost', function(ev) {
var srvUrl = 'http://localhost:' + server.address().port + '/';
console.log('presentation server running on ' + srvUrl);
if (args.launch_webbrowser) {
open(srvUrl);
}
});
// Set up watch
var reloadWatchers = [];
var WebSocketServer = require('websocket').server;
var wsServer = new WebSocketServer({
httpServer: server
});
wsServer.on('request', function(request) {
var conn;
try {
conn = request.accept('watch-changes-1.0', request.origin);
} catch (e) {
return;
}
reloadWatchers.push(conn);
conn.on('close', function() {
var index = reloadWatchers.indexOf(conn);
if (index !== -1) {
reloadWatchers.splice(index, 1);
}
});
});
watchTree(ROOT_DIR, { exclude: [".git", "node_modules"] }, function (e) {
reloadWatchers.forEach(function(conn) {
conn.sendUTF('reload');
});
});
}
function parseFlagsAndGetfile () {
var ArgumentParser = require('../lib/argparse').ArgumentParser;
var parser = new ArgumentParser({
version: '0.0.1',
addHelp: true,
description: 'Argparse examples: arguments'
});
parser.addArgument(
[ '-f', '--foo' ],
{
help: 'foo bar'
}
);
parser.addArgument(
[ '-b', '--bar' ],
{
help: 'bar foo'
}
);
parser.printHelp();
console.log('-----------');
var args;
args = parser.parseArgs('-f 1 -b2'.split(' '));
console.dir(args);
console.log('-----------');
args = parser.parseArgs('-f=3 --bar=4'.split(' '));
console.dir(args);
console.log('-----------');
args = parser.parseArgs('--foo 5 --bar 6'.split(' '));
console.dir(args);
console.log('-----------');
}
module.exports = function() {
var parser = new ap({
version: '0.0.1',
addHelp: true,
description: 'A webdriver-compatible server for use with native and hybrid iOS applications.'
});
parser.addArgument([ '--app' ]
, { required: true, help: 'path to simulators .app file or the bundle_id of the desired target on device'
});
parser.addArgument([ '-V', '--verbose' ], { required: false, help: 'verbose mode' });
parser.addArgument([ '-U', '--udid' ]
, { required: false, help: 'unique device identifier of the SUT'
});
parser.addArgument([ '-a', '--address' ]
, { defaultValue: '127.0.0.1'
, required: false
, help: 'ip address to listen on'
});
parser.addArgument([ '-p', '--port' ]
, { defaultValue: 4723, required: false, help: 'port to listen on'
});
parser.addArgument([ '-r', '--remove' ]
, { defaultValue: true, required: false, help: 'remove Instruments trace directories'
});
return parser;
};
function parseArgs(providerName) {
let parser = new ArgumentParser({
addHelp: true,
description: pkg.description,
version: pkg.version
});
parser.addArgument(['--username'], {
help: `${providerName} username (ex. user@domain.com)`
});
parser.addArgument(['--password'], {
help: `${providerName} password`
});
parser.addArgument(['--role'], {
help: 'Name of SAML role to assume'
});
parser.addArgument(['--account'], {
defaultValue: config.defaultAccount,
help: 'Name of account to switch to. Defaults to "' + config.defaultAccount + '".',
choices: config.accounts
});
parser.addArgument(['--profile'], {
help: 'Profile name that the AWS credentials should be saved as. Defaults to the name of the account specified.'
});
return parser.parseArgs();
}
/**
* Creates an argument parser with:
* - Description
* - Help argument
* - Port argument
*/
initArgumentParser() {
// Create an argument parser
this.argParser = new ArgumentParser(
{
version: '0.0.1',
addHelp: true,
description: 'Surviving to the offline status NodeJS server.'
}
);
// Define the port argument
this.argParser.addArgument(['-p', '--port'], {
help: 'Port on where to run the server.',
type: 'int',
defaultValue: '8888'
});
// Get the arguments
this.arguments = this.argParser.parseArgs();
}
module.exports = function() {
var parser = new ap({
version: '0.0.1',
addHelp: true,
description: 'A webdriver-compatible server for use with native and hybrid iOS applications.'
});
parser.addArgument([ '--app' ]
, { required: false, help: 'path to simulators .app file or the bundle_id of the desired target on device'
});
parser.addArgument([ '-V', '--verbose' ], { required: false, help: 'verbose mode' });
parser.addArgument([ '-U', '--udid' ]
, { required: false, help: 'unique device identifier of the SUT'
});
parser.addArgument([ '-a', '--address' ]
, { defaultValue: '127.0.0.1'
, required: false
, help: 'ip address to listen on'
});
parser.addArgument([ '-p', '--port' ]
, { defaultValue: 4723, required: false, help: 'port to listen on'
});
parser.addArgument([ '-r', '--remove' ]
, { defaultValue: true, required: false, help: 'remove Instruments trace directories'
});
parser.addArgument([ '-l', '--launch' ]
, { defaultValue: false, required: false, help: 'pre-launch the ios-sim'
});
parser.addArgument([ '-g', '--log' ]
, { defaultValue: null, required: false, help: 'log to a file'
});
parser.addArgument([ '-w', '--warp' ]
, { defaultValue: false, required: false, help: 'use time warp to speed up test execution (WARNING, this modifies system clock, could be bad news bears!)'
});
return parser;
};
function main () {
var parser = new ArgumentParser({
addHelp: true,
description: 'Deploy a new Heroku slug',
epilog: 'Create a source tarball, upload it, build a slug and deploy it on Heroku.'
})
parser.addArgument(
[ '-a', '--app' ],
{
help: 'Heroku app id',
required: true
}
)
parser.addArgument(
[ '-v', '--version' ],
{
help: 'Version to deploy',
required: true
}
)
parser.addArgument(
[ '-d', '--directory' ],
{
defaultValue: 'heroku',
help: 'Name of the directory containing the files for the tarball (default: heroku)'
}
)
parser.addArgument(
[ '-s', '--source' ],
{
defaultValue: 'source.tar.gz',
help: 'File name of source tarball (default: source.tar.gz)'
}
)
parser.addArgument(
[ '-t', '--timeout' ],
{
defaultValue: 120,
help: 'Timeout for build in seconds (default: 120 s)',
type: 'int'
}
)
parser.addArgument(
[ '-i', '--interval' ],
{
defaultValue: 10,
help: 'Interval to check build status in seconds (default: 10 s)',
type: 'int'
}
)
var args = parser.parseArgs()
return slugify(args.app, args.version, args.directory, args.source, args.timeout, args.interval)
}
export default async function(fn) {
let parser = new ArgumentParser();
parser.addArgument(['profile'], {
help: 'Configuration profile to use'
});
try {
let argv = parser.parseArgs();
let config = await loadConfig(process.argv[2]);
let runtime = await createRuntime(config);
await fn(runtime, config);
console.log('<starting>');
} catch (err) {
setTimeout(() => {
throw err;
});
}
}
cmd.setDefaults({action: function () {
if (args.command == null) {
parser.printHelp();
} else {
if (args.command in commands.choices) {
commands.choices[args.command].printHelp();
} else {
console.error("No help entry for " + args.command + ".");
process.exit(1);
}
}
}});
/** Return the options passed by the user to run the script */
function parseCommandLineArguments() {
const parser = new ArgumentParser({
addHelp: true,
description: 'Charge due subscriptions',
});
parser.addArgument(['-v', '--verbose'], {
help: 'Verbose output',
defaultValue: false,
action: 'storeConst',
constant: true,
});
parser.addArgument(['--notdryrun'], {
help: "Pass this flag when you're ready to run the script for real",
defaultValue: false,
action: 'storeConst',
constant: true,
});
parser.addArgument(['-l', '--limit'], {
help: 'total subscriptions to process',
});
parser.addArgument(['-b', '--batch_size'], {
help: 'batch size to fetch at a time',
defaultValue: 10,
});
const args = parser.parseArgs();
return {
dryRun: !args.notdryrun,
verbose: args.verbose,
limit: args.limit,
batchSize: args.batch_size || 100,
};
}
(function () {
"use strict";
var fs = require('fs')
, ArgumentParser = require('argparse').ArgumentParser
, parser = new ArgumentParser({
version: require('../package.json').version
, addHelp: true
, descriptions: require('../package.json').description
})
, args
;
parser.addArgument(
['anonymous']
, {
metavar: "N"
, type: 'string'
, nargs: '*'
, help: "some parameters"
}
);
parser.addArgument(
["-e", "--environment"]
, {
help: "Compile packages for 'browser' (default) or 'node'"
, metavar: "<browser|node>"
, defaultValue: "browser"
}
);
console.log('inputs:');
args = parser.parseArgs();
console.log(typeof args);
console.dir(args);
}());
function main(){
"use strict";
var parser = new argparse.ArgumentParser();
parser.addArgument(['--include'], {"action":'append', 'required':true});
parser.addArgument(['--externs'], {"action":'append', "defaultValue":['./externs/common.js']});
parser.addArgument(['--minify'], {"action":'storeTrue', "defaultValue":false});
parser.addArgument(['--output'], {"defaultValue":'../build/operaextensions.js'});
var args = parser.parseArgs();
var output = args.output;
console.log(' * Building ' + output);
console.dir(args);
var buffer = [];
for (var i = 0;i < args.include.length;i++){
var files = JSON.parse(fs.readFileSync('./includes/' + args.include[i] + '.json', 'utf8'));
for (var file = 0;file < files.length;file++){
buffer.push(fs.readFileSync(files[file], 'utf8'));
}
}
console.log(buffer.length);
var temp = buffer.join("");
if (!args.minify){
fs.writeFileSync(output,temp,'utf8');
} else {
fs.writeFileSync(output,uglify(temp),'utf8');
// An attempt to get the closure minifier working
// var externs = ' --externs ' + args.externs.join();
// console.log(externs);
// var temppath = output + ".tmp";
// fs.writeFileSync(temppath,temp,'utf8');
// var java = spawn("java -jar ./compiler/compiler.jar --warning_level=VERBOSE --jscomp_off=globalThis " + externs + " --jscomp_off=checkTypes --language_in=ECMASCRIPT5_STRICT --js " + temppath + " --js_output_file " + output);
// java.stdout.on('data', function (data) {
// console.log(data);
// });
// java.stderr.on('data', function (data) {
// console.log('java stderr: ' + data);
// });
// java.on('exit', function (code) {
// if (code !== 0) {
// console.log('java process exited with code ' + code);
// }
// });
}
}
module.exports = function() {
var parser = new ap({
version: pkgObj.version,
addHelp: true,
description: 'A webdriver-compatible server for use with native and hybrid iOS and Android applications.'
});
_.each(args, function(arg) {
parser.addArgument(arg[0], arg[1]);
});
parser.rawArgs = args;
return parser;
};
/** Main function for when this module is called directly as a script. */
function main() {
var parser = new ArgumentParser({
version: '0.0.1',
addHelp: true,
description: 'Import admin docs into database from a geojson file.'
});
parser.addArgument(
['-a', '--admin_level'],
{help: 'Admin level 0 through 2'}
);
parser.addArgument(
['-s', '--source'],
{help: 'Shapefile source: gadm2-8 or santiblanko'}
);
parser.addArgument(
['-c', '--country_code'],
{help: 'ISO 3166 alpha-2 two letter code for the country.'}
);
parser.addArgument(
['-g', '--geojson'],
{help: 'Name of admin geojson file to be imported'}
);
parser.addArgument(
['--verbose'],
{help: 'Print debug'}
);
var args = parser.parseArgs();
var geojson = args.geojson ||
'data/geojson/' +
args.source +
'/' + args.country_code +
'/' + args.country_code.toUpperCase() +
'_' + args.admin_level + '.json';
mongoose.connect(config.database, function(err) {
if (err) { throw err; }
import_admins(args.country_code, geojson, args.source)
.then(function() {
return process.exit();
}).catch(function(err) { console.log(err); process.exit();});
});
}