const parse = require("minimist");
const get = require("lodash.get");
const nba = require("./");
run(parse(process.argv.slice(2)));
function run (args) {
// console.log(args);
if (args.ls) {
console.log("available methods:");
["stats", "sportVu", "synergy"].forEach(function (namespace) {
Object.keys(nba[namespace]).forEach(function (method) {
if (method === "withTransport") return;
console.log(`${namespace}.${method}`);
});
});
return;
}
const {method} = args;
if (!method) throw new Error("Need a `method`");
const fn = get(nba, method);
if (fn == null) throw new Error(`No function at ${method}`);
if (args.docs) {
if (fn.defaults) {
console.log(`${method} parameters and default values:`);
for (const [ key, value ] of Object.entries(fn.defaults)) {
import minimist from "minimist";
import rc from "rc";
import {name,version} from "../package.json";
// using standard require so rollup doesn't include it
const createApp = require("./");
let argv = minimist(process.argv.slice(2), {
boolean: [ "help", "version" ],
alias: {
h: "help", H: "help",
v: "version", V: "version",
c: "config",
p: "port"
}
});
if (argv.help) {
console.log(`
$ tjme-server [OPTIONS]
-c, --config <file> Set options via a JSON config file, relative to PWD.
-p, --port <port> The HTTP server port.
-h, --help Shows this message.
-v, --version Prints the name and version of this software.
`);
process.exit(0);
}
if (argv.version) {
console.log("%s %s", name, version);
var favicon = require('static-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var chalk = require('chalk');
var parseArgs = require('minimist');
var config = require('./config');
var mongoose = require('mongoose');
var routes = require('./routes');
var analytics = require('./routes/analytics');
mongoose.connect(config.mongodb.connectionString);
var app = express();
var argv = parseArgs(process.argv.slice(2));
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
app.use(favicon());
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded());
app.use(cookieParser());
app.use(require('stylus').middleware(path.join(__dirname, 'public')));
app.use(express.static(path.join(__dirname, 'public')));
// Configure passport
var passport = require('passport');
//parse the command line args
var minimist = require('minimist');
var knownOptions = {
boolean: ['record', 'debug'],
default: {'record': false, 'debug': false}
};
module.exports = minimist(process.argv.slice(2), knownOptions);
* After changing the files it makes a commit and tags it.
* All you have to do is push changes to remote and CI will make a new build.
*/
const fs = require('fs');
const {
cat,
echo,
exec,
exit,
sed,
} = require('shelljs');
const minimist = require('minimist');
let argv = minimist(process.argv.slice(2), {
alias: {remote: 'r'},
default: {remote: 'origin'},
});
// - check we are in release branch, e.g. 0.33-stable
let branch = exec('git symbolic-ref --short HEAD', {silent: true}).stdout.trim();
if (branch.indexOf('-stable') === -1) {
echo('You must be in 0.XX-stable branch to bump a version');
exit(1);
}
// e.g. 0.33
let versionMajor = branch.slice(0, branch.indexOf('-stable'));
// - check that argument version matches branch
// e.g. 0.33.1 or 0.33.0-rc4
// THE SOFTWARE.
'use strict';
var Logger = require('debug-logtron');
var parseArgs = require('minimist');
var util = require('util');
var TChannel = require('../channel');
var setupRawTestService = require('./lib/raw_service');
var argv = parseArgs(process.argv.slice(2), {
alias: {
h: 'host',
p: 'port'
},
default: {
host: '127.0.0.1',
port: 0,
}
});
var chan = TChannel({
logger: Logger('testserver')
});
setupRawTestService(chan);
// TODO: logger?
chan.listen(argv.port, argv.host);
chan.on('listening', function onListening() {
var addr = chan.address();
process.stdout.write(util.format(
npath = require('path'),
sequence = require('run-sequence');
/**
--shopId <Number> Set Shopware Shop ID
--excludeSWtheme If given, Shopware Responsive Theme will be excluded
*/
var cliflags = {
default: {
shopId: process.env.NODE_ENV || 1,
excludeSWtheme: process.env.NODE_ENV || false
}
};
var shopId = minimist(process.argv.slice(2), cliflags).shopId,
file = '../web/cache/config_' + shopId + '.json',
config = require(file),
pathObject = npath.parse(config.lessTarget),
jsFiles = [],
content = '',
excludeSWtheme = minimist(process.argv.slice(2), cliflags).excludeSWtheme,
targetThemeSrc = 'Frontend/Mcustom/frontend/_public/src',
jsSearchPattern = '/js/jquery.**.js';
/**
Some Basic Paths
pathObject returns
{ root: '',
var cookieParser = require('cookie-parser')
var express = require('express');
var session = require('express-session')
var minimist = require('minimist');
var ws = require('ws');
var kurento = require('kurento-client');
var fs = require('fs');
var https = require('https');
kurento.register('kurento-module-pointerdetector');
const PointerDetectorWindowMediaParam = kurento.register.complexTypes.PointerDetectorWindowMediaParam;
const WindowParam = kurento.register.complexTypes.WindowParam;
var argv = minimist(process.argv.slice(2), {
default: {
as_uri: 'https://localhost:8443/',
ws_uri: 'ws://localhost:8888/kurento'
}
});
var options =
{
key: fs.readFileSync('keys/server.key'),
cert: fs.readFileSync('keys/server.crt')
};
var app = express();
/*
* Management of sessions
*/
app.use(cookieParser());
/**
* @file retina screen to common screen
* @author donghualei(1164622039@qq.com)
*/
var fs = require('fs');
var path = require('path');
var parseArgvs = require('minimist');
var Retina2Common = require('./');
var argv = parseArgvs(process.argv.slice(2), {
// 'boolean': ['r', 'recursive', 'f', 'force'],
'alias': {
h: 'help',
v: 'version',
f: 'force'
}
});
var commond = {
help: function () {
console.log(
[
'Usage: retina2common [options] files|directory',
'',
'Description: reduce your image by half',
' the image will be save as XXX@1x.XXX, the old image also exits',
'Options:',
' -o, --output the path to save',
' -h, --help print this help page',
}
}
return result;
};
})();
//#endregion
let app = require('electron').app;
let fs = require('fs');
let path = require('path');
let minimist = require('minimist');
let paths = require('./paths');
let args = minimist(process.argv, {
string: ['user-data-dir', 'locale']
});
function stripComments(content) {
let regexp = /("(?:[^\\\"]*(?:\\.)?)*")|('(?:[^\\\']*(?:\\.)?)*')|(\/\*(?:\r?\n|.)*?\*\/)|(\/{2,}.*?(?:(?:\r?\n)|$))/g;
let result = content.replace(regexp, function (match, m1, m2, m3, m4) {
// Only one of m1, m2, m3, m4 matches
if (m3) {
// A block comment. Replace with nothing
return '';
} else if (m4) {
// A line comment. If it ends in \r?\n then keep it.
let length_1 = m4.length;
if (length_1 > 2 && m4[length_1 - 1] === '\n') {
return m4[length_1 - 2] === '\r' ? '\r\n' : '\n';
}
var argv = minimist(process.argv.slice(2), {
alias: {
p: 'port',
b: 'blocklist',
t: 'subtitles',
l: 'list',
i: 'index',
n: 'no-quit',
r: 'remove',
q: 'quiet',
h: 'help',
v: 'version'
},
boolean: [ // options that are always boolean
'vlc',
'mplayer',
'mpv',
'airplay',
'chromecast',
'xbmc',
'list',
'no-quit',
'remove',
'quiet',
'help',
'version'
],
default: {
port: 9000
}
})
var parse = require('minimist');
var XLS = require('xlsjs');
var XLSX = require('xlsx');
var argOptions = {
alias: {
filename: 'f'
},
"default": {
filename: 'goodtest.xls'
}
};
var argv = parse(process.argv.slice(2), argOptions);
var rows = [];
var Name = argv.filename;
if (Name.match('\.xls$')) {
var wb = XLS.readFile(Name); // XLS.read(data, {type: 'binary'});
} else if (Name.match('\.xlsx$')) {
var wb = XLSX.readFile(Name); // XLSX.read(data, {type: 'binary'});
} else {
console.error('File must have .xls or .xlsx extension.');
};
var name_list = wb.SheetNames;
var sheet = wb.Sheets[name_list[0]];
for (var i = 1; i <= 10; ++i) {
var index = "C" + i.toString();
var cell = sheet[index].v.toString();
rows.push(cell);
}
const path = require('path');
const del = require('del');
const coffee = require('gulp-coffee');
const stream = require('vinyl-source-stream');
const browserify = require('browserify');
const coffeeify = require('coffeeify');
const shim = require('browserify-shim');
const coffeelint = require('gulp-coffeelint');
const { Server: Karma } = require('karma');
const { version, standalone, filename } = require('./package');
const source = './src/**/*.coffee';
const gemSource = './src/brainstem.coffee';
const options = minimist(process.argv.slice(2));
const moduleOutput = './lib';
const gemOutput = './vendor/assets/javascripts';
const styleguide = 'https://raw.githubusercontent.com/mavenlink/coffeescript-style-guide/master';
const lintConfig = 'coffeelint.json';
// Tasks
gulp.task('build-module', () => {
return gulp.src(source)
.pipe(coffee())
.pipe(gulp.dest(moduleOutput))
.on('error', util.log);
const vorpal = require('vorpal')()
, chalk = require('chalk')
, jspm = require('jspm')
, clui = require('clui')
, Spinner = clui.Spinner
, _ = require('lodash')
, parseArgs = require('minimist')
, fs = require('fs')
;
var FASTACK = {
argv: parseArgs(process.argv.slice(2), {
alias: {
'p': 'port'
}
})
};
FASTACK.vorpal = vorpal;
var spinner = new Spinner('Starting Fastack...');
spinner.start();
require('./directory.js')(FASTACK)
.then(() => {
spinner.message('Fetching Fastack API keys...');
return require('./keys.js')(FASTACK)})
.then(() => {
spinner.message('Loading helpers...');
return require('./helpers.js')(FASTACK)})
.then(() => {
import gulpLoadPlugins from 'gulp-load-plugins';
import ls from 'list-directory-contents';
import minimist from 'minimist';
import moment from 'moment';
import ms from 'merge-stream';
import path from 'path';
import replace from 'gulp-replace';
import runSequence from 'run-sequence';
import { stream as wiredep } from 'wiredep';
import util from 'gulp-util';
const knownOptions = {
string: 'env',
default: { env: process.env.NODE_ENV || 'test' }
};
const options = minimist(process.argv.slice(2), knownOptions);
const $ = gulpLoadPlugins();
const test = options.env;
const copyrighted = [
'app/*.html',
'app/scripts.babel/*.js',
'app/scripts.babel/bkg/*.js',
'app/vendor.babel/chrome/*.js',
'app/vendor.babel/firefox/*.js',
'test/features/step_definitions/*.js',
'test/*.js',
'./LICENSE.txt'
]
let version = '';
var minimist = require('minimist')
var fs = require('fs')
var log = require('single-line-log').stdout
var bytes = require('pretty-bytes')
var pkg = require('./package.json')
var torrent = require('./')
var createTorrent = require('create-torrent')
var parseTorrent = require('parse-torrent')
var concat = require('concat-stream')
var humanSize = require('human-format')
var prettySeconds = require('pretty-seconds')
var argv = minimist(process.argv.slice(2), {
alias: { outfile: 'o' }
})
if (argv.version) {
console.log(pkg.version)
process.exit(0)
}
if (argv.help || argv._.length === 0) {
console.log(fs.readFileSync(__dirname + '/usage.txt', 'utf-8'))
process.exit(0)
}
if (argv.quiet) log = function () {}
var source = argv._.shift()
var unlinkCmd = require('../lib/unlink_cmd')
function helpCmd () {
fs.ReadStream(path.join(__dirname, 'USAGE.txt')).pipe(process.stdout)
}
function versionCmd () {
console.log('ied version', require('../package.json').version)
}
var cwd = process.cwd()
var argv = minimist(process.argv.slice(2), {
alias: {
h: 'help',
v: 'version',
S: 'save',
D: 'save-dev',
o: 'only',
r: 'registry'
}
})
if (argv.registry) {
config.registry = argv.registry
}
// This doesn't have to be an IIFE, since Node wraps everything in a function
// anyways, but standard doesn't like return statements here.
(function () {
if (argv.help) {
return helpCmd()
}
var alloc = require('tcp-bind');
var fd = alloc(80);
var kfd = alloc(443);
process.setgid(process.argv[2]);
process.setuid(process.argv[2]);
var http = require('http');
var https = require('https');
var minimist = require('minimist');
var argv = minimist(process.argv.slice(2), {
alias: { p: 'port' }
});
var fs = require('fs');
var path = require('path');
var kfile = path.join(__dirname, '../keyboot-website/keyboot.pfx');
var kpfx = fs.readFileSync(kfile);
var ecstatic = require('ecstatic');
var stdir = ecstatic(__dirname + '/static');
var hyperboot = require('hyperboot');
var boots = {
demo: hyperboot({
dir: __dirname + '/demo/hyperdata',
name: 'hyperboot demo'
}),
keyboot: hyperboot({
dir: __dirname + '/../keyboot/hyperdata',
name: 'keyboot'
var path = require('path');
var _root = __dirname + '/';
var build = require('webpack-build');
var webpackConfig = require('./webpack.config.js');
var minimist = require('minimist');
var log = require('bows')('CLI');
var argv = minimist(process.argv.slice(2));
var script = argv._;
var info = [];
var config = {
config: __dirname + '/webpack.config.js',
watch: true,
argv: argv,
loaders: []
};
if(script){
config['entry'] = script;
}
//Process JSX files with React (uses .babelrc)
var webpackLoaderReact = {
test: /\.jsx?$/,
include: path.join(__dirname, 'scripts'),
exclude: /node_modules/,
loaders: ['react-hot','babel-loader'],
};
//Process JSX files with Inferno (ignores .babelrc)
var webpackLoaderInferno = {
exports = module.exports = function (args) {
// Parse arguments.
args = minimist(args, {
boolean: 'help',
string: 'token user password max-snapshots'.split(' '),
alias: {
help: 'h',
'max-snapshots': 'n',
}
});
if (args.help) {
return exports.help();
}
if (!args._.length) {
fatal('missing <url>\n\n'+ exports.help());
}
var xo = new Xo(args._[0]);
var snapshots;
return Promise.try(function () {
if (args.token) {
return xo.call('session.signInWithToken', {
token: args.token,
});
}
if (!args.user) {
fatal('missing <token> or <user>\n\n'+ exports.help());
}
return new Promise(function (resolve) {
var password = args.password;
if (password) {
return resolve(password);
}
inquirer.prompt([{
type: 'password',
name: 'password',
message: 'Password',
}], function (answers) {
resolve(answers.password);
});
}).then(function (password) {
return xo.call('session.signInWithPassword', {
user: args.user,
password: password,
// Compatibility.
email: args.user,
});
});
}).then(function () {
return xo.call('xo.getAllObjects');
}).then(function (objects) {
snapshots = indexBy(filter(objects, {
type: 'VM-snapshot',
}), 'ref');
return filter(objects, {
type: 'VM',
'power_state': 'Running',
});
}).map(function (vm) {
return xo.call('vm.snapshot', {
id: 'id' in vm ? vm.id : vm.UUID,
name: 'auto-'+ (new Date().toISOString()),
}).then(function () {
log(vm.name_label, 'snapshotted');
if (!args['max-snapshots']) {
return;
}
// Select existing automatic snapshots.
var vmSnapshots = filter(
pick(snapshots, vm.snapshots),
function (snapshot) {
return /^auto-/.test(snapshot.name_label);
}
);
// Take all but the (n - 1) recent ones.
vmSnapshots = vmSnapshots.sort(function (a, b) {
return a.snapshot_time - b.snapshot_time;
}).slice(0, vmSnapshots.length - args['max-snapshots'] + 1);
// Delete them.
return Promise.map(vmSnapshots, function (snapshot) {
return xo.call('vm.delete', {
id: 'id' in snapshot ? snapshot.id : snapshot.UUID,
delete_disks: true,
}).then(function () {
log(vm.name_label, 'old snapshot deleted', snapshot.name_label);
}).catch(function (e) {
error(
vm.name_label,
'old snapshot deletion failed',
snapshot.name_label,
JSON.stringify(e.stack || e, null, 2)
);
});
});
}).catch(function (e) {
error(
vm.name_label,
'snapshot failed',
JSON.stringify(e.stack || e, null, 2)
);
});
}).all().return();
};
(async () => {
const argv = minimist(process.argv.slice(2), {
default: { confirm: false },
});
const projectRoot = path.resolve(__dirname, '..');
const localDir = path.resolve(projectRoot, 'dist');
const oneYear = 31556926;
const oneMinute = 60;
// fn to determine if a filename is revved, i.e. if it matches `**/*.rev-*.*`
const isRevved = name => /.+\.rev-.+/.test(path.basename(name));
// increase socket pool size to improve bandwidth usage
http.globalAgent.maxSockets = 20;
https.globalAgent.maxSockets = 20;
// make an S3 client instance
const client = s3.createClient({
s3Options: {
region: 'eu-west-1',
},
});
// decide where to upload to
const { bucketName, remotePrefix } = await (async () => {
const repository = await Git.Repository.open(projectRoot);
const origin = await repository.getRemote('origin');
const originURL = origin.url();
const { repo, host } = parseGitHubURL(originURL);
if (host !== 'github.com') {
throw new Error(
`Expected git remote "origin" to be a github.com URL, but it was: ${origin}`
);
}
const branchName = (await repository.head()).shorthand();
if (branchName === 'master') {
return {
bucketName: 'callum-ig',
remotePrefix: `v1/${repo}/`,
};
}
return {
bucketName: 'callum-ig-dev',
remotePrefix: `v1/${repo}/${branchName}/`,
};
})();
// tell user what we're going to do
console.log(
cyan(`\nTo sync:\n`) +
` Local directory: ${yellow(path.relative(process.cwd(), localDir))}\n` +
` S3 Bucket: ${yellow(bucketName)}\n` +
` Remote prefix: ${yellow(remotePrefix)}\n`
);
// establish upload parameters
const params = {
localDir,
// deleteRemoved: true, // best not to use this in most cases
// general params
s3Params: {
Bucket: bucketName,
Prefix: remotePrefix,
// you can include here any other options supported by putObject, except Body and ContentLength
// - see http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#putObject-property
},
// per-file params
getS3Params: (localFile, stat, callback) => {
const fileParams = {};
const ext = path.extname(localFile);
// use text/html for extensionless files (similar to gh-pages)
if (ext === '') {
fileParams.ContentType = 'text/html';
}
// set cache headers
{
const ttl = isRevved(localFile) ? oneYear : oneMinute;
fileParams.CacheControl = `max-age=${ttl}`;
}
callback(null, fileParams);
},
};
// await confirmation
if (argv.confirm || await input.confirm('Continue?', { default: false })) {
let uploadCount = 0;
const spinner = ora({
text: 'Uploaded 0 files',
color: 'cyan',
}).start();
const uploader = client.uploadDir(params);
uploader.on('error', error => {
console.error(`${red(figures.tick)} Failed to upload.`);
console.error(error.stack);
process.exit(1);
});
uploader.on('fileUploadEnd', () => {
uploadCount++;
});
uploader.on('progress', () => {
spinner.text = `Uploaded ${uploadCount} files`;
});
uploader.on('end', () => {
spinner.stop();
console.log(`${green(figures.tick)} Uploaded ${uploadCount} files.`);
// NB. this is the only one of about 5 different S3 URL formats that supports automatic index.html resolution
console.log(cyan(`\n http://${bucketName}.s3-website-eu-west-1.amazonaws.com/${remotePrefix}`));
});
}
})();
static asyncAsem(args) {
let argv = minimist(args.slice(2), {
boolean: ['o', 'v'],
default: { v: false, o: false },
alias: {
o: 'omf-51',
v: 'verbose',
i: 'include',
d: 'define'
}
})
let asembin = process.env.ASEM51 || asembin_default;
let file = argv['_'][0];
let options = options_default;
let argopts = [];
argopts.push(options_default);
if (argv['i']) {
options = argopts.push(`-i ${argv['i']}`);
}
if (argv['d']) {
options = argopts.push(`-d ${argv['d']}`);
}
if (argv['v'] == true) {
options = argopts.push('-v');
}
if (argv['o'] == true) {
options = argopts.push('-o');
}
argv['_'].forEach((element) => {
argopts.push(element);
});
return new Promise((resolve, reject) => {
let message = [];
if (file != undefined) {
let asem = spawn(asembin, argopts);
asem.on('error', err => reject(err.toString()));
asem.stdout.on('data', (data) => {
if (data) {
message.push({ 'verbose': data.toString().replace(/[\n\t\r]/g, "") });
}
});
asem.stderr.on('data', (data) => {
message.push(ASEM51.parseError(file, data.toString()));
});
asem.on('close', () => {
resolve(message);
})
} else {
let asem = spawn(asembin);
asem.on('error', err => reject(err.toString()));
asem.stdout.on('data', data => resolve(data.toString()));
asem.stderr.on('data', data => resolve(data.toString()));
}
})
}
if (test.getCreds) {
test.getCreds(extra.oauth_scope, function(err, new_creds) {
assert.ifError(err);
execute(err, grpc.credentials.combineChannelCredentials(
creds, new_creds));
});
} else {
execute(null, creds);
}
}
if (require.main === module) {
var parseArgs = require('minimist');
var argv = parseArgs(process.argv, {
string: ['server_host', 'server_host_override', 'server_port', 'test_case',
'use_tls', 'use_test_ca', 'default_service_account', 'oauth_scope',
'service_account_key_file']
});
var extra_args = {
service_account: argv.default_service_account,
oauth_scope: argv.oauth_scope
};
runTest(argv.server_host + ':' + argv.server_port, argv.server_host_override,
argv.test_case, argv.use_tls === 'true', argv.use_test_ca === 'true',
function () {
console.log('OK:', argv.test_case);
}, extra_args);
}
/**
* See docs for runTest
* where csv is generated from v1 with sql statement like:
*
* \copy (SELECT * FROM oauth_applications) to 'oauth_applications.csv' WITH CSV HEADER;
*/
/* eslint-enable */
'use strict'
const OauthApplication = require('../../app/js/models/OauthApplication')
.OauthApplication
const async = require('async')
const csvParser = require('csv-parser')
const fs = require('fs')
const minimist = require('minimist')
const argv = minimist(process.argv.slice(2))
const records = []
fs.createReadStream(argv._[0])
.pipe(csvParser())
.on('data', data => records.push(data))
.on('end', () => {
async.mapSeries(records, loadRecord, function(err) {
if (err) console.error(err)
process.exit()
})
})
function loadRecord(record, cb) {
const newRecord = {
var path = require('path');
var minimist = require('minimist');
var constants = require('../../tasks/util/constants');
var isCI = !!process.env.CI;
var argv = minimist(process.argv.slice(4), {
string: ['bundleTest', 'width', 'height'],
'boolean': ['info', 'nowatch', 'failFast', 'verbose', 'Chrome', 'Firefox', 'IE11'],
alias: {
'Chrome': 'chrome',
'Firefox': ['firefox', 'FF'],
'IE11': ['ie11'],
'bundleTest': ['bundletest', 'bundle_test'],
'nowatch': 'no-watch',
'failFast': 'fail-fast'
},
'default': {
info: false,
nowatch: isCI,
failFast: false,
verbose: false,
width: '1035',
height: '617'
}
});
if(argv.info) {
console.log([
'plotly.js karma runner for jasmine tests CLI info',
'',
'Examples:',
require('app-module-path').addPath(`${__dirname}'./../`);
import Minimist from 'minimist';
import Mocha from 'mocha';
import Glob from 'glob';
import './utils/dom';
import consoleError from './utils/consoleError';
consoleError();
const argv = Minimist(process.argv.slice(2), {
alias: {
c: 'component',
g: 'grep',
},
});
const types = argv._;
const globPatterns = {
unit: `src/**/${argv.component ? argv.component : '*'}.spec.js`,
integration: `test/integration/**/${argv.component ? argv.component : '*'}.spec.js`,
};
let pattern;
if (types.indexOf('unit') + types.indexOf('integration') === -2) {
pattern = Object.keys(globPatterns).map((n) => globPatterns[n]);
} else {
pattern = types.map((n) => globPatterns[n]);
}
const mocha = new Mocha({
var wikidb = require('../');
var db = require('level')('/tmp/wiki.db');
var minimist = require('minimist');
var argv = minimist(process.argv.slice(2), {
alias: { t: [ 'tag', 'tags' ] }
});
var wdb = wikidb(db, { dir: '/tmp/wiki.blob' });
var opts = {
key: argv._[0],
prev: argv.prev,
tags: argv.tag
};
var w = wdb.createWriteStream(opts, function (err, key) {
console.log(key);
});
process.stdin.pipe(w);
/**
* Created by fritx on 5/8/14.
*/
'use strict'
var path = require('path')
var fs = require('fs')
var parseArgs = require('minimist')
var silent = require('../')
var args = parseArgs(process.argv.slice(2), {
boolean: ['version', 'help', 'force'],
alias: {
version: 'v',
help: 'h',
force: 'f'
}
})
;(function () {
var pkg = require('../package.json')
if (args.version) {
console.log('v' + pkg.version)
return
}
if (args.help) {
console.log('See: ' + pkg.homepage)
var rudp = require('rudp')
var dgram = require('dgram')
var minimist = require('minimist');
var args = minimist(process.argv.slice(2), {
alias: {
h: 'host',
l: 'localport',
r: 'remoteport'
}
})
var noop = function() {}
var DEFAULT_PORT = 25778
var host = args.host || '72.76.47.91';
var localPort = Number(args.localport || DEFAULT_PORT);
var remotePort = Number(args.remoteport || DEFAULT_PORT);
console.log('localPort:', localPort, 'remoteHost:', host, 'remotePort:', remotePort);
var s = dgram.createSocket('udp4')
s.bind(localPort);
var client = new rudp.Client(s, host, remotePort);
client.on('data', function(data, rinfo) {
console.log(arguments)
})
s.on('listening', function() {
client.send(new Buffer('hey there'))
})
var parseArgv = require('minimist');
var args = parseArgv(process.argv);
console.dir(args);