export default function cli (argv = process.argv.slice(2)) {
let options = docopt(doc, { version: pkg.version, argv: argv })
if (!options['-'] && !options['<src>'].length) {
// Trigger help display.
docopt(doc, { version: pkg.version, argv: ['--help'] })
}
let logger = new Logger(options['--verbose'], options['--debug'] || process.env.SASSDOC_DEBUG)
let env = new Environment(logger, options['--verbose'], options['--strict'])
logger.debug('argv:', () => JSON.stringify(argv))
env.on('error', (error) => {
if (error instanceof errors.Warning) {
process.exit(2)
}
process.exit(1)
})
env.load(options['--config'])
// Ensure CLI options.
ensure(env, options, {
dest: '--dest',
theme: '--theme',
noUpdateNotifier: '--no-update-notifier'
})
env.postProcess()
// Run update notifier if not explicitely disabled.
if (!env.noUpdateNotifier) {
require('./notifier').default(pkg, logger)
}
let handler, cb
// Whether to parse only or to documentize.
if (!options['--parse']) {
handler = sassdoc
cb = () => {}
} else {
handler = parse
cb = data => console.log(JSON.stringify(data, null, 2))
}
if (options['-']) {
return process.stdin
.pipe(source())
.pipe(handler(env))
.on('data', cb)
}
handler(options['<src>'], env).then(cb)
}
function main(argv, stdout, env, time, fs, mkAccount) {
const cli = docopt.docopt(doc, {argv: argv.slice(2)});
const creds = {
login: () => Q(env.SIMPLE_USERNAME),
password: () => Q(env.SIMPLE_PASSWORD),
challenge: q => { throw q; }
};
if (cli.download) {
const d = driver();
const now = time.clock();
const start = 0;
d.download({ account: mkAccount }, creds, start, now)
.then(exported => stdout.write(JSON.stringify(exported)))
.catch(oops => {
console.error('failed to download:', oops);
})
.done();
} else if (cli.json2ofx) {
const input = fs.createReadStream(cli.JSON);
const write = content => fs.createWriteStream(cli.OFX).write(content);
let buf = '';
input.on('data', (chunk) => {
buf += chunk;
});
input.on('end', () => {
const exported = JSON.parse(buf);
const s = statement(exported.transactions);
write(OFX.OFX(time.clock, s));
});
}
}
module.exports = function(stdin, stdout, stderr, env, argv, callback) {
var options;
try {
options = docopt.docopt(usage, {
argv: argv,
help: false,
exit: false
});
} catch (error) {
stderr.write(error.message);
callback(1);
return;
}
if (options['--version'] || options['-v']) {
stdout.write(meta.name + ' ' + meta.version + '\n');
callback(0);
} else if (options['--help'] || options['-h']) {
stdout.write(usage + '\n');
callback(0);
} else {
var version = options.VERSION || '*';
check(options.PACKAGE, version, function(error, problems) {
if (error) {
console.error(error);
} else {
if (problems.length > 0) {
problems.forEach(function(problem) {
process.stdout.write(problem.message + '\n');
});
process.exit(1);
}
}
});
}
};
module.exports = function(stdin, stdout, stderr, env, argv, callback) {
var options;
try {
options = docopt.docopt(usage, {
argv: argv,
help: false,
exit: false
});
} catch (error) {
stderr.write(error.message + '\n');
callback(1);
return;
}
if (options['--version'] || options['-v']) {
stdout.write(versionString + '\n');
callback(0);
} else if (options['--help'] || options['-h']) {
stdout.write(usage + '\n');
callback(0);
} else {
var url = options['<database>'];
var port = options['--port'];
var level = levelup(url, {db: sqldown});
bole.output({level: 'debug', stream: process.stdout});
var logger = bole(versionString);
http.createServer(serve(logger, level))
.on('listening', function() {
logger.info({port: this.address().port});
logger.info({data: url});
})
.listen(port);
}
};
function main(argv, time, proc, fs, net) {
'use strict';
const cli = docopt(usage, { argv: argv.slice(2) });
if (cli['download']) {
download(cli, time.clock(), net, fs,
freedesktop.makeSecretTool(proc.spawn));
} else if (cli['convert']) {
convert(cli.CSV, cli.OFX, cli['--login'], time, fs);
}
}
module.exports.main = function main(argv, cb) {
// Parse command-line arguments.
// This will detect unrecognized options and handle --help.
// XXX TODO: stop it from exiting the program itself.
var options = docopt.docopt(USAGE, {argv: argv});
// Print version info and exit, if requested.
if(options['--version']) {
console.log('awsboxen', module.exports.version || 'DEV');
return cb(0);
}
// Find the target command from the docopt output.
var command = null;
for (var k in options) {
if (options.hasOwnProperty(k) && options[k]) {
if (k && k.charAt(0) !== '-' && k.charAt(0) !== '<') {
command = k;
break;
}
}
}
// That should have produced a usable command name. Error out if not.
if (!command) {
console.log('Error processing options!');
return cb(1);
}
// Process the rest of the docopt output into an options hash.
opts.getOptions(options, process.env, function(err, opts) {
if (err) {
console.log(err);
return cb(1);
}
// Now we can run the command.
module.exports.commands[command](opts, function(err) {
if (err) {
console.error(err);
return cb(1);
}
return cb(0);
});
});
};
exports.parse = function() {
var opt = docopt(doc, { version: '1.0' });
var opts = {
css: opt["<css-url-or-file>"],
out: opt["--out"],
fontOut: opt["--font-out"] == 'same folder as CSS' ? path.dirname(opt["--out"]) : opt["--font-out"],
cssRel: opt["--css-rel"] == "./" ? "" : (opt["--css-rel"] + "/"),
debug: Boolean(opt["-d"]),
modes: {
woff1: opt["--woff1"],
woff2: opt["--woff2"],
svg: opt["--svg"],
ttf: opt["--ttf"],
eot: opt["--eot"]
}
};
return opts;
};
password123 (-h | --help | --version)
Version:
0.1.0
Description:
Arguments:
<password>... The password(s) to test.
Options:
--s, --secure should an interactive input be used to enter a password?
--version .
-h, --hash should input passwords be compared to hashed versions of the 10,000 most
common passwords, in addition to a plain text check?
`
const docopt = require('docopt').docopt
const password123 = require('../app/password123')
const args = docopt(doc)
password123(args)
const {docopt} = require('docopt')
const PeerNetwork = require('peer-network')
const network = new PeerNetwork()
const usage = `
Usage:
peercat listen [-qv] <name>
peercat connect [-qv] <name>
Options:
-q --quiet Print less
-v --verbose Print more
`
const options = docopt(usage, {version: require('./package.json').version})
const name = options['<name>']
const verbose = options['--verbose'] || options['-v']
const quiet = options['--quiet'] || options['-q']
if (options.listen && name) {
const server = network.createServer()
server.on('connection', stream => {
const id = (Date.now() + Math.random() * 1000 | 0).toString(16).slice(-8)
verbose && console.error(`connected ${id}`)
stream.pipe(process.stdout)
stream.on('close', () => verbose && console.error(`disconnected ${id}`))
})
server.on('listening', () => quiet || console.error(`listening at "${name}"`))
server.on('error', error => console.error(error.message))
server.listen(name)
process.on('exit', () => server.close())
var doc = [
"Usage:",
" marklogic-syslog-server.js [<port>] [--delay <milliseconds>] [--length <messages>] [--host <host:port>] [--user <user:password>] [(--digest | --basic)] [--help | -h]",
"",
"Options:",
" -h, --help Help",
" --delay <milliseconds> Log buffer flush delay for writes [default: 1000]",
" --length <messages> Maximum buffer length before flushing [default: 200]",
" --host <host:port> The MarkLogic host to write to [default: localhost:8000]",
" --database <name> The MarkLogic database to write to [default: Logs]",
" --user <user:password> MarkLogic authentication [default: admin:********]",
" --digest HTTP digest authentication",
" --basic HTTP basic authentication",
].join("\n");
var opts = docopt(doc);
if(!opts['<port>']) {opts['<port>'] = 514; } // No way to default arguments in docopt
else { opts['<port>'] = parseInt(opts['<port>'], 10);}
if(opts['-h'] || opts['--help']) {
console.log(doc);
process.exit(0);
}
var host = opts['--host'].split(':');
var auth = opts['--user'].split(':');
var conn = {
host: host[0],
port: parseInt(host[1], 10),
database: opts['--database'],
kafka-sonic latency <rate> [options]
kafka-sonic -h | --help | --version
Arguments:
rate Producer rate (Max is 1000)
Options:
-k, --kafka=<addr> Kafka address [default: localhost:9092]
-z, --zookeeper=<addr> Zookeeper address [default: localhost:2181]
-s, --sonicd=<addr> Sonicd ws address [default: localhost:9111]
-p, --message=<file> JSON file to push as message
--no-parser Disable Sonicd JSON parsing
--verbose Turn on debug log level
`;
const options = docopt(DOC, { version: version });
log.level = options['--verbose'] ? 'debug' : 'info';
log.cli();
log.debug('log level set to %s', log.level);
log.debug('parsed options', options);
const kurl = options['--kafka'];
const zurl = options['--zookeeper'];
const surl = options['--sonicd'];
const disableParsing = options['--no-parser'];
// const GROUP_ID = `sonicd_latency_group_${microtime.now()}`;
const GROUP_ID = 'sonicd_latency_group';
const TOPIC = 'sonicd_latency';
Options:
--port <port> Set the port of the server. [default: 8080]
--start Start the server, if the server is not already running.
--stop Stop the server.
--run-with <browser> Specify browser executable.
<file> The file to open, if provided.
--help Show help message.
--version Show version number.`;
var docopt = require("docopt"),
mkdirp = require("mkdirp"),
process = require("process"),
fs = require("fs"),
args = docopt.docopt(doc, {version: "0.3.1"}),
path = require("path-extra"),
appDir = path.datadir("comic-viewer"),
lock = path.join(appDir, "lock"),
server = {
pid: null,
isLocked: null
},
createCV = require("../lib/comic-viewer");
function launchFile() {
if (!args["<file>"]) {
return;
}
#!/usr/bin/env node
'use strict';
// This is the file that gets executed when you run `dapple`. It uses `docopt`
// to parse the arguments passed in.
// Usage first.
var fs = require('fs');
var docopt = require('docopt');
var doc = fs.readFileSync(__dirname + '/docopt.txt').toString();
var packageSpec = require('../package.json');
var cli = docopt.docopt(doc, {
version: packageSpec.version
});
// These requires take a lot of time to import.
var req = require('lazreq')({
DappleRCPrompter: '../lib/dapplerc_prompter.js',
deasync: 'deasync',
Installer: '../lib/installer.js',
inquirer: 'inquirer',
path: 'path',
pipelines: '../lib/pipelines.js',
userHome: 'user-home',
vinyl: 'vinyl-fs'
});
var Workspace = require('../lib/workspace');
var VMTest = require('../lib/vmtest');
var rc = Workspace.getDappleRC();
+ 'Options: \n'
+ ' -p <PRIORITY> Add the job with priority <PRIORITY> \n'
+ ' -o <OUTPUT> How to treat the job\'s output: \n'
+ ' "s" (DEFAULT) sends it to stdout/stderr \n'
+ ' "-" completely suppresses it \n'
+ ' -w Do not start the scheduler immediately \n'
+ ' but wait an explicit "start" command \n'
+ ' \n'
+ ' -h --help Show this help \n'
+ ' -v --version Print eracle version and then exit \n'
+ ' \n'
+ 'Priorities: \n'
+ ' Jobs can have a specific priority ranging from 0 (lowest) to 9 (highest). \n'
+ ' When not specified a job has a default priority of "4". \n'
const cmd = docopt(options, {version: "0.0.0"})
if (cmd)
{
if (cmd['add'])
{
const command = cmd['<JOB_COMMAND>']
const envelope = job.envelope(command).using(
{
priority: cmd['-p'] || job.PRIORITIES.DEFAULT
})
envelope.output().to(cmd['-o'])
jobs.add(envelope)
// set process title
process.title = 'obvious';
// parse command line options
var docopt = require('docopt').docopt;
var fs = require('fs');
var USAGE = fs.readFileSync(__dirname + '/../USAGE', 'utf-8');
var options = docopt(USAGE, {
help: true,
version: require('../package.json').version
});
// initialize
var obvious = require('./');
obvious({
screen: options['--screen'],
interval: Number(options['--interval'])
});
#!/usr/bin/env node
'use strict';
// This is the file that gets executed when you run `dapple`. It uses `docopt`
// to parse the arguments passed in.
// Usage first.
var fs = require('fs');
var docopt = require('docopt');
var cliSpec = require('../specs/cli.json');
var packageSpec = require('../package.json');
var clc = require('cli-color-tty')(true);
var _ = require('lodash');
var cli = docopt.docopt(getUsage(cliSpec), {
version: packageSpec.version,
help: false
});
// Builds the docopt usage from the spec
function getUsage (cliSpec) {
const usage =
' ' +
cliSpec.commands
.map(c => `dapple ${c.name} ${c.options.map(o => o.name).join(' ')}`)
.join('\n ');
const options =
' ' +
cliSpec.options
.map(o => o.name)
.join('\n ');
return `Usage:\n${usage}\n\nOptions:\n${options}`;
prefix.push((colc = ++colc % opts.col) === 0 ? '\n' + time(bp[1].time) + ' ' : legend.separator)
}
} else { // Or if it's hour grouped.
if (!bp[0]) {
prefix.push(time(bp[1].time) + ' ' + '\n')
} else if (bp[0].time.getHours() !== bp[1].time.getHours()) {
prefix.push('\n' + time(bp[1].time) + ' ' + '\n')
}
}
return most.from(prefix.concat(bp[1].viz))
})
})
}
const DOC = `
Usage: clogc.js [options] [<host>]
Options:
-c --col <col> Colums to display. [default: 1]
`
if (require.main === module) {
let opts = docopt(DOC)
opts = {
host: opts['<host>'] || '8.8.8.8',
col: Number.parseInt(opts['--col'], 10)
}
clogc(opts)
.forEach((log) => process.stdout.write(log))
}
" koraki <source> [--asm] [--pass=<pass>] [--debug] [--ast]",
" koraki -h | --help",
" koraki --version",
"",
"",
"Options:",
" --asm Print assembly output in human readable form.",
" --pass=<pass> Print AST before and after given pass.",
" --debug Print vm state after every instruction.",
" --ast Print AST after every pass.",
"",
" -h --help Show this screen.",
" --version Show version.",
].join('\n');
var options = docopt.docopt(doc, {version: '0.1.0'});
// console.log('CLI options object: ', options);
var source = readFile(options['<source>']);
if(options['--asm']) {
console.log('');
console.log(genAssembly(compile(source).assembly));
}
compileAndRun(source);
#!/usr/bin/env node
'use strict'
var fs = require('fs-extra')
var path = require('path')
var docopt = require('docopt').docopt
var tty = require('tty')
var pkg = require('../package.json')
var less = require('../')
var definitions = fs.readFileSync(path.resolve(__dirname, 'docopt'), 'utf-8')
var options = docopt(definitions, {version: pkg.version})
if (options['-'] || !tty.isatty(process.stdin.fd)) {
less(process.stdin).pipe(process.stdout)
} else if (options['<src>'].length > 0) {
var dest = options['--out'] || '.'
console.log(options['<src>'])
options['<src>'].forEach(function (f) {
var input = fs.createReadStream(f)
var destFile = path.resolve(dest, f)
fs.ensureFile(destFile, function (err) {
if (err) throw err
var output = fs.createWriteStream(destFile)
less(input).pipe(output)
})
})
}
var async = require('async')
var fs = require('fs')
var docopt = require('docopt').docopt
var version = require('../package.json').version
var nrs = require('./index.js')
var args = docopt(fs.readFileSync(__dirname + '/usage.txt', 'utf-8'),
{ version: version })
if (args.test) {
nrs.run({
uri: args['<url>'],
statusCode: parseInt(args['--status'], 10)
}, function (err, res) {
console.log('LOG: testing site', args['<url>'])
console.error('ERR:', err)
console.log('RES:', res)
return
})
}
if (args.speed) {
nrs.netspeed(function (err, data) {
console.log('ERR:', err)
console.log('RES:', data)
return
})
}
if (args.check) {
+ " -l --language=LANG Forces use of language for all files.\n"
+ " -d --doconly Omits code sections from the output.\n"
+ "\n"
var fs = require('fs')
var path = require('path')
var pkg = require('../package')
var docopt = require('docopt').docopt
var sug = require('../')
var cli = require('../cli')
var λ = require('prelude-ls')
var read = fs.readFileSync
var write = fs.writeFileSync
var args = docopt(doc, { version: pkg.version })
args.languages? listLanguages()
: args.convert? convertFiles(args['<files>'], args['--output']
, args['--language']
, args['--doconly'])
: /* otherwise */ printHelp()
function listLanguages() {
var langs = λ.values(sug.languages)
var largestName = λ.maximum(langs.map(function(a){ return a.name.length })) + 6
console.log('Available languages:\n')
console.log(langs.map(function(a){
public: args['-p'] ? 'public ' : '',
class: args['-c'],
body: function(chunk, context, bodies, params) {
var namespace = context.get('namespace');
return {
space: namespace ? ' ' : ''
};
}
};
dust.renderSource(res.templateSrc, data, next);
}],
output: ['generate', function(next, res) {
process.stdout.write(res.generate);
}],
}, function(err, res) {
if (err) {
process.stderr.write("Error: " + JSON.stringify(err) + "\n");
process.exit(1);
}
});
}
if (require.main === module) {
var kwargs = {
name: "csharp-mixin-generator",
version: "csharp-mixin-generator 0.1.2"
};
var args = docopt.docopt(doc, kwargs);
main(args);
}
docopt(opts = {}) {
opts.version = opts.version || this.version;
return Docopt.docopt(this.usage_doc, opts);
}
};
}
function values(obj) {
var entries = [];
for (let key in obj) {
entries.push(obj[key]);
}
return entries;
}
////////////////////////////////////////////////////////////////////////////////
// Main
////////////////////////////////////////////////////////////////////////////////
var options = docopt(USAGE);
let data = fs.readFileSync(options['--lockfile'], 'utf8')
let json = lockfile.parse(data)
if (json.type != "success") {
throw new Error("yarn.lock parse error")
}
// Check fore missing hashes in the yarn.lock and patch if necessary
var pkgs = values(json.object);
Promise.all(pkgs.map(updateResolvedSha1)).then(() => {
let newData = lockfile.stringify(json.object);
if (newData != data) {
console.error("found changes in the lockfile", options["--lockfile"]);
var parse = require('csv-parse');
var transform = require('stream-transform');
var csv2md = require('./csv2md');
var fs = require('fs');
var helpText = fs.readFileSync(__dirname+'/help.txt').toString();
var docopt = require('docopt').docopt;
var argOptions = docopt(helpText);
var isFirstLine = true;
csv2md.setOptions({
pretty: argOptions['--pretty'],
stream: argOptions['--stream'],
tableDelimiter: argOptions['--tableDelimiter'],
firstLineMarker: argOptions['--firstLineMarker'],
cellPadding: argOptions['--cellPadding'],
delimiterOnBegin: argOptions['--delimiterOnBegin'],
delimiterOnEnd: argOptions['--delimiterOnEnd'],
csvComment: argOptions['--csvComment'],
csvDelimiter: argOptions['--csvDelimiter'],
csvQuote: argOptions['--csvQuote'],
csvEscape: argOptions['--csvEscape']
});
var parser = parse({
comment: argOptions['--csvComment'],
delimiter: argOptions['--csvDelimiter'],
quote: argOptions['--csvQuote'],
escape: argOptions['--csvEscape'],
});
var transformer = transform(function(record, callback){
}
return sizes;
}
function validateArgs(args) {
if (args['--replace'].length != args['--with'].length) {
console.error('--replace flags must be paired with --with flags.');
process.exit(1);
}
}
if (require.main === module) {
var args = docopt(doc, {version: '1.3.3'});
validateArgs(args);
var data = loadSourceMap(args['<script.js>'], args['<script.js.map>']);
if (!data) {
process.exit(1);
}
var mapConsumer = data.mapConsumer,
jsData = data.jsData;
var sizes = computeGeneratedFileSizes(mapConsumer, jsData);
if (_.size(sizes) == 1) {
console.error('Your source map only contains one source (',
_.keys(sizes)[0], ')');
console.error("This typically means that your source map doesn't map all the way back to the original sources.");
console.error("This can happen if you use browserify+uglifyjs, for example, and don't set the --in-source-map flag to uglify.");
#!/usr/bin/env node
/* eslint-disable global-require, import/newline-after-import, import/no-dynamic-require */
require('loud-rejection/register');
var docopt = require('docopt').docopt;
var resolveModule = require('resolve').sync;
var resolvePath = require('path').resolve;
var glob = require('glob');
var doc = [
'Usage:',
' run-tests [--require=<module>...] <file>...',
'',
'Options:',
' -r <module>, --require=<module> Require a given module',
].join('\n');
var args = docopt(doc, { version: require('./package.json').version });
var cwd = process.cwd();
args['--require'].forEach(function (module) {
require(resolveModule(module, { basedir: cwd }));
});
args['<file>'].forEach(function (arg) {
glob(arg, function (err, files) {
files.forEach(function (file) {
require(resolvePath(cwd, file));
});
});
});
var doc = "\
akabei, a phantomjs cluster manager \n\
Usage: \n\
akabei [-v -l <log_file>] [<config_file>] \n\
akabei -h | --help \n\
\n\
Options: \n\
-v, --verbose will output debug info \n\
-l, --log path to a file to log output to \n\
";
var docopt = require('docopt');
var logger = require('./lib/logger');
var winston = require('winston');
var args = docopt.docopt(doc),
config_file = args['<config_file>'] || './config.js',
loggingLevel = args['-v'] ? 'debug' : 'info';
logger.transports.console.level = loggingLevel;
if (args['--log']) {
logger.add(winston.transports.File, {
filename: args['<log_file>'],
level: loggingLevel
});
}
console.log('loading config file from ' + config_file + '...');
var config = require(config_file);
' --version Show jsfmt version',
' -d --diff Show diff against original file',
' -l --list List the files which differ from jsfmt output',
' -v --validate Validate the input file(s)',
' --no-format Do not format the input file(s)',
' -w --write Overwrite the original file with jsfmt output',
' -j --json Tell jsfmt that the file being parsed is json',
' -a --ast Tell jsfmt that the file being parsed is in JSON AST',
' --save-ast Output the resulting js in JSON AST format',
' -r=PATTERN --rewrite PATTERN Rewrite rule (e.g., \'a.slice(b, len(a) -> a.slice(b)\')',
' -s=PATTERN --search PATTERN Search rule (e.g., \'a.slice\')',
].join("\r\n");
var info = require('../package.json');
var argv = docopt.docopt(doc, {
help: true,
version: 'jsfmt ' + info.version,
});
if (argv['--json'] && (argv['--rewrite'] || argv['--search'])) {
console.error('Rewriting/Searching is not supported for JSON');
process.exit(-1);
}
function diff(pathA, pathB, callback) {
child_process.exec([
'git', 'diff', '--ignore-space-at-eol', '--no-index', '--', pathA, pathB
].join(' '), callback);
}
function handleDiff(fullPath, originalJavascript, formattedJavascript) {
if (fullPath == 'stdin') {
// parse arguments
var doc = '' +
'Usage:\n' +
' server.js [options]\n\n' +
'Options:\n' +
' --data=<filename> read data from a file\n' +
' --socket=<socket> select socket implementation [default: ws]\n' +
' --speed=<speed> change output speed [default: 1]\n' +
' --port=<port> set socket port [default: 3000]\n' +
' --stream=<stream> enable or disable live streaming [default: true]\n' +
' --dump=<filename> dump output to filename\n' +
' --help show this help and exit\n' +
' --version show version and exit\n';
var options = docopt(doc, {version: '0.3'});
REPLAY_SPEED = Math.max(options['--speed'], 1);
// hand check data
var hand_check_data = "hello world!"
process.stdout.write('\nStart server\n');
// define socket implementation
var io = null;
if (options['--socket'] == 'socket.io') {
process.stdout.write('\nUsing Socket.io implementation for WebSocket.\n'.underline);
io = require('socket.io').listen(options['--port']).sockets;
_.extend(io, {
broadcast: function (data) {
this.send(data);