remove node modules
This commit is contained in:
Craig Condon
-21
@@ -1,21 +0,0 @@
|
||||
Copyright 2010 James Halliday (mail@substack.net)
|
||||
|
||||
This project is free software released under the MIT/X11 license:
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
-487
@@ -1,487 +0,0 @@
|
||||
optimist
|
||||
========
|
||||
|
||||
Optimist is a node.js library for option parsing for people who hate option
|
||||
parsing. More specifically, this module is for people who like all the --bells
|
||||
and -whistlz of program usage but think optstrings are a waste of time.
|
||||
|
||||
With optimist, option parsing doesn't have to suck (as much).
|
||||
|
||||
[](http://travis-ci.org/substack/node-optimist)
|
||||
|
||||
examples
|
||||
========
|
||||
|
||||
With Optimist, the options are just a hash! No optstrings attached.
|
||||
-------------------------------------------------------------------
|
||||
|
||||
xup.js:
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist').argv;
|
||||
|
||||
if (argv.rif - 5 * argv.xup > 7.138) {
|
||||
console.log('Buy more riffiwobbles');
|
||||
}
|
||||
else {
|
||||
console.log('Sell the xupptumblers');
|
||||
}
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./xup.js --rif=55 --xup=9.52
|
||||
Buy more riffiwobbles
|
||||
|
||||
$ ./xup.js --rif 12 --xup 8.1
|
||||
Sell the xupptumblers
|
||||
|
||||
|
||||
|
||||
But wait! There's more! You can do short options:
|
||||
-------------------------------------------------
|
||||
|
||||
short.js:
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist').argv;
|
||||
console.log('(%d,%d)', argv.x, argv.y);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./short.js -x 10 -y 21
|
||||
(10,21)
|
||||
|
||||
And booleans, both long and short (and grouped):
|
||||
----------------------------------
|
||||
|
||||
bool.js:
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var util = require('util');
|
||||
var argv = require('optimist').argv;
|
||||
|
||||
if (argv.s) {
|
||||
util.print(argv.fr ? 'Le chat dit: ' : 'The cat says: ');
|
||||
}
|
||||
console.log(
|
||||
(argv.fr ? 'miaou' : 'meow') + (argv.p ? '.' : '')
|
||||
);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./bool.js -s
|
||||
The cat says: meow
|
||||
|
||||
$ ./bool.js -sp
|
||||
The cat says: meow.
|
||||
|
||||
$ ./bool.js -sp --fr
|
||||
Le chat dit: miaou.
|
||||
|
||||
And non-hypenated options too! Just use `argv._`!
|
||||
-------------------------------------------------
|
||||
|
||||
nonopt.js:
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist').argv;
|
||||
console.log('(%d,%d)', argv.x, argv.y);
|
||||
console.log(argv._);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./nonopt.js -x 6.82 -y 3.35 moo
|
||||
(6.82,3.35)
|
||||
[ 'moo' ]
|
||||
|
||||
$ ./nonopt.js foo -x 0.54 bar -y 1.12 baz
|
||||
(0.54,1.12)
|
||||
[ 'foo', 'bar', 'baz' ]
|
||||
|
||||
Plus, Optimist comes with .usage() and .demand()!
|
||||
-------------------------------------------------
|
||||
|
||||
divide.js:
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist')
|
||||
.usage('Usage: $0 -x [num] -y [num]')
|
||||
.demand(['x','y'])
|
||||
.argv;
|
||||
|
||||
console.log(argv.x / argv.y);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./divide.js -x 55 -y 11
|
||||
5
|
||||
|
||||
$ node ./divide.js -x 4.91 -z 2.51
|
||||
Usage: node ./divide.js -x [num] -y [num]
|
||||
|
||||
Options:
|
||||
-x [required]
|
||||
-y [required]
|
||||
|
||||
Missing required arguments: y
|
||||
|
||||
EVEN MORE HOLY COW
|
||||
------------------
|
||||
|
||||
default_singles.js:
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist')
|
||||
.default('x', 10)
|
||||
.default('y', 10)
|
||||
.argv
|
||||
;
|
||||
console.log(argv.x + argv.y);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./default_singles.js -x 5
|
||||
15
|
||||
|
||||
default_hash.js:
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist')
|
||||
.default({ x : 10, y : 10 })
|
||||
.argv
|
||||
;
|
||||
console.log(argv.x + argv.y);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./default_hash.js -y 7
|
||||
17
|
||||
|
||||
And if you really want to get all descriptive about it...
|
||||
---------------------------------------------------------
|
||||
|
||||
boolean_single.js
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist')
|
||||
.boolean('v')
|
||||
.argv
|
||||
;
|
||||
console.dir(argv);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./boolean_single.js -v foo bar baz
|
||||
true
|
||||
[ 'bar', 'baz', 'foo' ]
|
||||
|
||||
boolean_double.js
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist')
|
||||
.boolean(['x','y','z'])
|
||||
.argv
|
||||
;
|
||||
console.dir([ argv.x, argv.y, argv.z ]);
|
||||
console.dir(argv._);
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ ./boolean_double.js -x -z one two three
|
||||
[ true, false, true ]
|
||||
[ 'one', 'two', 'three' ]
|
||||
|
||||
Optimist is here to help...
|
||||
---------------------------
|
||||
|
||||
You can describe parameters for help messages and set aliases. Optimist figures
|
||||
out how to format a handy help string automatically.
|
||||
|
||||
line_count.js
|
||||
|
||||
````javascript
|
||||
#!/usr/bin/env node
|
||||
var argv = require('optimist')
|
||||
.usage('Count the lines in a file.\nUsage: $0')
|
||||
.demand('f')
|
||||
.alias('f', 'file')
|
||||
.describe('f', 'Load a file')
|
||||
.argv
|
||||
;
|
||||
|
||||
var fs = require('fs');
|
||||
var s = fs.createReadStream(argv.file);
|
||||
|
||||
var lines = 0;
|
||||
s.on('data', function (buf) {
|
||||
lines += buf.toString().match(/\n/g).length;
|
||||
});
|
||||
|
||||
s.on('end', function () {
|
||||
console.log(lines);
|
||||
});
|
||||
````
|
||||
|
||||
***
|
||||
|
||||
$ node line_count.js
|
||||
Count the lines in a file.
|
||||
Usage: node ./line_count.js
|
||||
|
||||
Options:
|
||||
-f, --file Load a file [required]
|
||||
|
||||
Missing required arguments: f
|
||||
|
||||
$ node line_count.js --file line_count.js
|
||||
20
|
||||
|
||||
$ node line_count.js -f line_count.js
|
||||
20
|
||||
|
||||
methods
|
||||
=======
|
||||
|
||||
By itself,
|
||||
|
||||
````javascript
|
||||
require('optimist').argv
|
||||
`````
|
||||
|
||||
will use `process.argv` array to construct the `argv` object.
|
||||
|
||||
You can pass in the `process.argv` yourself:
|
||||
|
||||
````javascript
|
||||
require('optimist')([ '-x', '1', '-y', '2' ]).argv
|
||||
````
|
||||
|
||||
or use .parse() to do the same thing:
|
||||
|
||||
````javascript
|
||||
require('optimist').parse([ '-x', '1', '-y', '2' ])
|
||||
````
|
||||
|
||||
The rest of these methods below come in just before the terminating `.argv`.
|
||||
|
||||
.alias(key, alias)
|
||||
------------------
|
||||
|
||||
Set key names as equivalent such that updates to a key will propagate to aliases
|
||||
and vice-versa.
|
||||
|
||||
Optionally `.alias()` can take an object that maps keys to aliases.
|
||||
|
||||
.default(key, value)
|
||||
--------------------
|
||||
|
||||
Set `argv[key]` to `value` if no option was specified on `process.argv`.
|
||||
|
||||
Optionally `.default()` can take an object that maps keys to default values.
|
||||
|
||||
.demand(key)
|
||||
------------
|
||||
|
||||
If `key` is a string, show the usage information and exit if `key` wasn't
|
||||
specified in `process.argv`.
|
||||
|
||||
If `key` is a number, demand at least as many non-option arguments, which show
|
||||
up in `argv._`.
|
||||
|
||||
If `key` is an Array, demand each element.
|
||||
|
||||
.describe(key, desc)
|
||||
--------------------
|
||||
|
||||
Describe a `key` for the generated usage information.
|
||||
|
||||
Optionally `.describe()` can take an object that maps keys to descriptions.
|
||||
|
||||
.options(key, opt)
|
||||
------------------
|
||||
|
||||
Instead of chaining together `.alias().demand().default()`, you can specify
|
||||
keys in `opt` for each of the chainable methods.
|
||||
|
||||
For example:
|
||||
|
||||
````javascript
|
||||
var argv = require('optimist')
|
||||
.options('f', {
|
||||
alias : 'file',
|
||||
default : '/etc/passwd',
|
||||
})
|
||||
.argv
|
||||
;
|
||||
````
|
||||
|
||||
is the same as
|
||||
|
||||
````javascript
|
||||
var argv = require('optimist')
|
||||
.alias('f', 'file')
|
||||
.default('f', '/etc/passwd')
|
||||
.argv
|
||||
;
|
||||
````
|
||||
|
||||
Optionally `.options()` can take an object that maps keys to `opt` parameters.
|
||||
|
||||
.usage(message)
|
||||
---------------
|
||||
|
||||
Set a usage message to show which commands to use. Inside `message`, the string
|
||||
`$0` will get interpolated to the current script name or node command for the
|
||||
present script similar to how `$0` works in bash or perl.
|
||||
|
||||
.check(fn)
|
||||
----------
|
||||
|
||||
Check that certain conditions are met in the provided arguments.
|
||||
|
||||
If `fn` throws or returns `false`, show the thrown error, usage information, and
|
||||
exit.
|
||||
|
||||
.boolean(key)
|
||||
-------------
|
||||
|
||||
Interpret `key` as a boolean. If a non-flag option follows `key` in
|
||||
`process.argv`, that string won't get set as the value of `key`.
|
||||
|
||||
If `key` never shows up as a flag in `process.arguments`, `argv[key]` will be
|
||||
`false`.
|
||||
|
||||
If `key` is an Array, interpret all the elements as booleans.
|
||||
|
||||
.string(key)
|
||||
------------
|
||||
|
||||
Tell the parser logic not to interpret `key` as a number or boolean.
|
||||
This can be useful if you need to preserve leading zeros in an input.
|
||||
|
||||
If `key` is an Array, interpret all the elements as strings.
|
||||
|
||||
.wrap(columns)
|
||||
--------------
|
||||
|
||||
Format usage output to wrap at `columns` many columns.
|
||||
|
||||
.help()
|
||||
-------
|
||||
|
||||
Return the generated usage string.
|
||||
|
||||
.showHelp(fn=console.error)
|
||||
---------------------------
|
||||
|
||||
Print the usage data using `fn` for printing.
|
||||
|
||||
.parse(args)
|
||||
------------
|
||||
|
||||
Parse `args` instead of `process.argv`. Returns the `argv` object.
|
||||
|
||||
.argv
|
||||
-----
|
||||
|
||||
Get the arguments as a plain old object.
|
||||
|
||||
Arguments without a corresponding flag show up in the `argv._` array.
|
||||
|
||||
The script name or node command is available at `argv.$0` similarly to how `$0`
|
||||
works in bash or perl.
|
||||
|
||||
parsing tricks
|
||||
==============
|
||||
|
||||
stop parsing
|
||||
------------
|
||||
|
||||
Use `--` to stop parsing flags and stuff the remainder into `argv._`.
|
||||
|
||||
$ node examples/reflect.js -a 1 -b 2 -- -c 3 -d 4
|
||||
{ _: [ '-c', '3', '-d', '4' ],
|
||||
'$0': 'node ./examples/reflect.js',
|
||||
a: 1,
|
||||
b: 2 }
|
||||
|
||||
negate fields
|
||||
-------------
|
||||
|
||||
If you want to explicity set a field to false instead of just leaving it
|
||||
undefined or to override a default you can do `--no-key`.
|
||||
|
||||
$ node examples/reflect.js -a --no-b
|
||||
{ _: [],
|
||||
'$0': 'node ./examples/reflect.js',
|
||||
a: true,
|
||||
b: false }
|
||||
|
||||
numbers
|
||||
-------
|
||||
|
||||
Every argument that looks like a number (`!isNaN(Number(arg))`) is converted to
|
||||
one. This way you can just `net.createConnection(argv.port)` and you can add
|
||||
numbers out of `argv` with `+` without having that mean concatenation,
|
||||
which is super frustrating.
|
||||
|
||||
duplicates
|
||||
----------
|
||||
|
||||
If you specify a flag multiple times it will get turned into an array containing
|
||||
all the values in order.
|
||||
|
||||
$ node examples/reflect.js -x 5 -x 8 -x 0
|
||||
{ _: [],
|
||||
'$0': 'node ./examples/reflect.js',
|
||||
x: [ 5, 8, 0 ] }
|
||||
|
||||
dot notation
|
||||
------------
|
||||
|
||||
When you use dots (`.`s) in argument names, an implicit object path is assumed.
|
||||
This lets you organize arguments into nested objects.
|
||||
|
||||
$ node examples/reflect.js --foo.bar.baz=33 --foo.quux=5
|
||||
{ _: [],
|
||||
'$0': 'node ./examples/reflect.js',
|
||||
foo: { bar: { baz: 33 }, quux: 5 } }
|
||||
|
||||
installation
|
||||
============
|
||||
|
||||
With [npm](http://github.com/isaacs/npm), just do:
|
||||
npm install optimist
|
||||
|
||||
or clone this project on github:
|
||||
|
||||
git clone http://github.com/substack/node-optimist.git
|
||||
|
||||
To run the tests with [expresso](http://github.com/visionmedia/expresso),
|
||||
just do:
|
||||
|
||||
expresso
|
||||
|
||||
inspired By
|
||||
===========
|
||||
|
||||
This module is loosely inspired by Perl's
|
||||
[Getopt::Casual](http://search.cpan.org/~photo/Getopt-Casual-0.13.1/Casual.pm).
|
||||
-475
@@ -1,475 +0,0 @@
|
||||
var path = require('path');
|
||||
var wordwrap = require('wordwrap');
|
||||
|
||||
/* Hack an instance of Argv with process.argv into Argv
|
||||
so people can do
|
||||
require('optimist')(['--beeble=1','-z','zizzle']).argv
|
||||
to parse a list of args and
|
||||
require('optimist').argv
|
||||
to get a parsed version of process.argv.
|
||||
*/
|
||||
|
||||
var inst = Argv(process.argv.slice(2));
|
||||
Object.keys(inst).forEach(function (key) {
|
||||
Argv[key] = typeof inst[key] == 'function'
|
||||
? inst[key].bind(inst)
|
||||
: inst[key];
|
||||
});
|
||||
|
||||
var exports = module.exports = Argv;
|
||||
function Argv (args, cwd) {
|
||||
var self = {};
|
||||
if (!cwd) cwd = process.cwd();
|
||||
|
||||
self.$0 = process.argv
|
||||
.slice(0,2)
|
||||
.map(function (x) {
|
||||
var b = rebase(cwd, x);
|
||||
return x.match(/^\//) && b.length < x.length
|
||||
? b : x
|
||||
})
|
||||
.join(' ')
|
||||
;
|
||||
|
||||
if (process.argv[1] == process.env._) {
|
||||
self.$0 = process.env._.replace(
|
||||
path.dirname(process.execPath) + '/', ''
|
||||
);
|
||||
}
|
||||
|
||||
var flags = { bools : {}, strings : {} };
|
||||
|
||||
self.boolean = function (bools) {
|
||||
if (!Array.isArray(bools)) {
|
||||
bools = [].slice.call(arguments);
|
||||
}
|
||||
|
||||
bools.forEach(function (name) {
|
||||
flags.bools[name] = true;
|
||||
});
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
self.string = function (strings) {
|
||||
if (!Array.isArray(strings)) {
|
||||
strings = [].slice.call(arguments);
|
||||
}
|
||||
|
||||
strings.forEach(function (name) {
|
||||
flags.strings[name] = true;
|
||||
});
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
var aliases = {};
|
||||
self.alias = function (x, y) {
|
||||
if (typeof x === 'object') {
|
||||
Object.keys(x).forEach(function (key) {
|
||||
self.alias(key, x[key]);
|
||||
});
|
||||
}
|
||||
else if (Array.isArray(y)) {
|
||||
y.forEach(function (yy) {
|
||||
self.alias(x, yy);
|
||||
});
|
||||
}
|
||||
else {
|
||||
var zs = (aliases[x] || []).concat(aliases[y] || []).concat(x, y);
|
||||
aliases[x] = zs.filter(function (z) { return z != x });
|
||||
aliases[y] = zs.filter(function (z) { return z != y });
|
||||
}
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
var demanded = {};
|
||||
self.demand = function (keys) {
|
||||
if (typeof keys == 'number') {
|
||||
if (!demanded._) demanded._ = 0;
|
||||
demanded._ += keys;
|
||||
}
|
||||
else if (Array.isArray(keys)) {
|
||||
keys.forEach(function (key) {
|
||||
self.demand(key);
|
||||
});
|
||||
}
|
||||
else {
|
||||
demanded[keys] = true;
|
||||
}
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
var usage;
|
||||
self.usage = function (msg, opts) {
|
||||
if (!opts && typeof msg === 'object') {
|
||||
opts = msg;
|
||||
msg = null;
|
||||
}
|
||||
|
||||
usage = msg;
|
||||
|
||||
if (opts) self.options(opts);
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
function fail (msg) {
|
||||
self.showHelp();
|
||||
if (msg) console.error(msg);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
var checks = [];
|
||||
self.check = function (f) {
|
||||
checks.push(f);
|
||||
return self;
|
||||
};
|
||||
|
||||
var defaults = {};
|
||||
self.default = function (key, value) {
|
||||
if (typeof key === 'object') {
|
||||
Object.keys(key).forEach(function (k) {
|
||||
self.default(k, key[k]);
|
||||
});
|
||||
}
|
||||
else {
|
||||
defaults[key] = value;
|
||||
}
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
var descriptions = {};
|
||||
self.describe = function (key, desc) {
|
||||
if (typeof key === 'object') {
|
||||
Object.keys(key).forEach(function (k) {
|
||||
self.describe(k, key[k]);
|
||||
});
|
||||
}
|
||||
else {
|
||||
descriptions[key] = desc;
|
||||
}
|
||||
return self;
|
||||
};
|
||||
|
||||
self.parse = function (args) {
|
||||
return Argv(args).argv;
|
||||
};
|
||||
|
||||
self.option = self.options = function (key, opt) {
|
||||
if (typeof key === 'object') {
|
||||
Object.keys(key).forEach(function (k) {
|
||||
self.options(k, key[k]);
|
||||
});
|
||||
}
|
||||
else {
|
||||
if (opt.alias) self.alias(key, opt.alias);
|
||||
if (opt.demand) self.demand(key);
|
||||
if (typeof opt.default !== 'undefined') {
|
||||
self.default(key, opt.default);
|
||||
}
|
||||
|
||||
if (opt.boolean || opt.type === 'boolean') {
|
||||
self.boolean(key);
|
||||
}
|
||||
if (opt.string || opt.type === 'string') {
|
||||
self.string(key);
|
||||
}
|
||||
|
||||
var desc = opt.describe || opt.description || opt.desc;
|
||||
if (desc) {
|
||||
self.describe(key, desc);
|
||||
}
|
||||
}
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
var wrap = null;
|
||||
self.wrap = function (cols) {
|
||||
wrap = cols;
|
||||
return self;
|
||||
};
|
||||
|
||||
self.showHelp = function (fn) {
|
||||
if (!fn) fn = console.error;
|
||||
fn(self.help());
|
||||
};
|
||||
|
||||
self.help = function () {
|
||||
var keys = Object.keys(
|
||||
Object.keys(descriptions)
|
||||
.concat(Object.keys(demanded))
|
||||
.concat(Object.keys(defaults))
|
||||
.reduce(function (acc, key) {
|
||||
if (key !== '_') acc[key] = true;
|
||||
return acc;
|
||||
}, {})
|
||||
);
|
||||
|
||||
var help = keys.length ? [ 'Options:' ] : [];
|
||||
|
||||
if (usage) {
|
||||
help.unshift(usage.replace(/\$0/g, self.$0), '');
|
||||
}
|
||||
|
||||
var switches = keys.reduce(function (acc, key) {
|
||||
acc[key] = [ key ].concat(aliases[key] || [])
|
||||
.map(function (sw) {
|
||||
return (sw.length > 1 ? '--' : '-') + sw
|
||||
})
|
||||
.join(', ')
|
||||
;
|
||||
return acc;
|
||||
}, {});
|
||||
|
||||
var switchlen = longest(Object.keys(switches).map(function (s) {
|
||||
return switches[s] || '';
|
||||
}));
|
||||
|
||||
var desclen = longest(Object.keys(descriptions).map(function (d) {
|
||||
return descriptions[d] || '';
|
||||
}));
|
||||
|
||||
keys.forEach(function (key) {
|
||||
var kswitch = switches[key];
|
||||
var desc = descriptions[key] || '';
|
||||
|
||||
if (wrap) {
|
||||
desc = wordwrap(switchlen + 4, wrap)(desc)
|
||||
.slice(switchlen + 4)
|
||||
;
|
||||
}
|
||||
|
||||
var spadding = new Array(
|
||||
Math.max(switchlen - kswitch.length + 3, 0)
|
||||
).join(' ');
|
||||
|
||||
var dpadding = new Array(
|
||||
Math.max(desclen - desc.length + 1, 0)
|
||||
).join(' ');
|
||||
|
||||
var type = null;
|
||||
|
||||
if (flags.bools[key]) type = '[boolean]';
|
||||
if (flags.strings[key]) type = '[string]';
|
||||
|
||||
if (!wrap && dpadding.length > 0) {
|
||||
desc += dpadding;
|
||||
}
|
||||
|
||||
var prelude = ' ' + kswitch + spadding;
|
||||
var extra = [
|
||||
type,
|
||||
demanded[key]
|
||||
? '[required]'
|
||||
: null
|
||||
,
|
||||
defaults[key] !== undefined
|
||||
? '[default: ' + JSON.stringify(defaults[key]) + ']'
|
||||
: null
|
||||
,
|
||||
].filter(Boolean).join(' ');
|
||||
|
||||
var body = [ desc, extra ].filter(Boolean).join(' ');
|
||||
|
||||
if (wrap) {
|
||||
var dlines = desc.split('\n');
|
||||
var dlen = dlines.slice(-1)[0].length
|
||||
+ (dlines.length === 1 ? prelude.length : 0)
|
||||
|
||||
body = desc + (dlen + extra.length > wrap - 2
|
||||
? '\n'
|
||||
+ new Array(wrap - extra.length + 1).join(' ')
|
||||
+ extra
|
||||
: new Array(wrap - extra.length - dlen + 1).join(' ')
|
||||
+ extra
|
||||
);
|
||||
}
|
||||
|
||||
help.push(prelude + body);
|
||||
});
|
||||
|
||||
help.push('');
|
||||
return help.join('\n');
|
||||
};
|
||||
|
||||
Object.defineProperty(self, 'argv', {
|
||||
get : parseArgs,
|
||||
enumerable : true,
|
||||
});
|
||||
|
||||
function parseArgs () {
|
||||
var argv = { _ : [], $0 : self.$0 };
|
||||
Object.keys(flags.bools).forEach(function (key) {
|
||||
setArg(key, defaults[key] || false);
|
||||
});
|
||||
|
||||
function setArg (key, val) {
|
||||
var num = Number(val);
|
||||
var value = typeof val !== 'string' || isNaN(num) ? val : num;
|
||||
if (flags.strings[key]) value = val;
|
||||
|
||||
setKey(argv, key.split('.'), value);
|
||||
|
||||
(aliases[key] || []).forEach(function (x) {
|
||||
argv[x] = argv[key];
|
||||
});
|
||||
}
|
||||
|
||||
for (var i = 0; i < args.length; i++) {
|
||||
var arg = args[i];
|
||||
|
||||
if (arg === '--') {
|
||||
argv._.push.apply(argv._, args.slice(i + 1));
|
||||
break;
|
||||
}
|
||||
else if (arg.match(/^--.+=/)) {
|
||||
var m = arg.match(/^--([^=]+)=(.*)/);
|
||||
setArg(m[1], m[2]);
|
||||
}
|
||||
else if (arg.match(/^--no-.+/)) {
|
||||
var key = arg.match(/^--no-(.+)/)[1];
|
||||
setArg(key, false);
|
||||
}
|
||||
else if (arg.match(/^--.+/)) {
|
||||
var key = arg.match(/^--(.+)/)[1];
|
||||
var next = args[i + 1];
|
||||
if (next !== undefined && !next.match(/^-/)
|
||||
&& !flags.bools[key]
|
||||
&& (aliases[key] ? !flags.bools[aliases[key]] : true)) {
|
||||
setArg(key, next);
|
||||
i++;
|
||||
}
|
||||
else if (/^(true|false)$/.test(next)) {
|
||||
setArg(key, next === 'true');
|
||||
i++;
|
||||
}
|
||||
else {
|
||||
setArg(key, true);
|
||||
}
|
||||
}
|
||||
else if (arg.match(/^-[^-]+/)) {
|
||||
var letters = arg.slice(1,-1).split('');
|
||||
|
||||
var broken = false;
|
||||
for (var j = 0; j < letters.length; j++) {
|
||||
if (letters[j+1] && letters[j+1].match(/\W/)) {
|
||||
setArg(letters[j], arg.slice(j+2));
|
||||
broken = true;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
setArg(letters[j], true);
|
||||
}
|
||||
}
|
||||
|
||||
if (!broken) {
|
||||
var key = arg.slice(-1)[0];
|
||||
|
||||
if (args[i+1] && !args[i+1].match(/^-/)
|
||||
&& !flags.bools[key]
|
||||
&& (aliases[key] ? !flags.bools[aliases[key]] : true)) {
|
||||
setArg(key, args[i+1]);
|
||||
i++;
|
||||
}
|
||||
else if (args[i+1] && /true|false/.test(args[i+1])) {
|
||||
setArg(key, args[i+1] === 'true');
|
||||
i++;
|
||||
}
|
||||
else {
|
||||
setArg(key, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
var n = Number(arg);
|
||||
argv._.push(flags.strings['_'] || isNaN(n) ? arg : n);
|
||||
}
|
||||
}
|
||||
|
||||
Object.keys(defaults).forEach(function (key) {
|
||||
if (!(key in argv)) {
|
||||
argv[key] = defaults[key];
|
||||
if (key in aliases) {
|
||||
argv[aliases[key]] = defaults[key];
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if (demanded._ && argv._.length < demanded._) {
|
||||
fail('Not enough non-option arguments: got '
|
||||
+ argv._.length + ', need at least ' + demanded._
|
||||
);
|
||||
}
|
||||
|
||||
var missing = [];
|
||||
Object.keys(demanded).forEach(function (key) {
|
||||
if (!argv[key]) missing.push(key);
|
||||
});
|
||||
|
||||
if (missing.length) {
|
||||
fail('Missing required arguments: ' + missing.join(', '));
|
||||
}
|
||||
|
||||
checks.forEach(function (f) {
|
||||
try {
|
||||
if (f(argv) === false) {
|
||||
fail('Argument check failed: ' + f.toString());
|
||||
}
|
||||
}
|
||||
catch (err) {
|
||||
fail(err)
|
||||
}
|
||||
});
|
||||
|
||||
return argv;
|
||||
}
|
||||
|
||||
function longest (xs) {
|
||||
return Math.max.apply(
|
||||
null,
|
||||
xs.map(function (x) { return x.length })
|
||||
);
|
||||
}
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
// rebase an absolute path to a relative one with respect to a base directory
|
||||
// exported for tests
|
||||
exports.rebase = rebase;
|
||||
function rebase (base, dir) {
|
||||
var ds = path.normalize(dir).split('/').slice(1);
|
||||
var bs = path.normalize(base).split('/').slice(1);
|
||||
|
||||
for (var i = 0; ds[i] && ds[i] == bs[i]; i++);
|
||||
ds.splice(0, i); bs.splice(0, i);
|
||||
|
||||
var p = path.normalize(
|
||||
bs.map(function () { return '..' }).concat(ds).join('/')
|
||||
).replace(/\/$/,'').replace(/^$/, '.');
|
||||
return p.match(/^[.\/]/) ? p : './' + p;
|
||||
};
|
||||
|
||||
function setKey (obj, keys, value) {
|
||||
var o = obj;
|
||||
keys.slice(0,-1).forEach(function (key) {
|
||||
if (o[key] === undefined) o[key] = {};
|
||||
o = o[key];
|
||||
});
|
||||
|
||||
var key = keys[keys.length - 1];
|
||||
if (o[key] === undefined || typeof o[key] === 'boolean') {
|
||||
o[key] = value;
|
||||
}
|
||||
else if (Array.isArray(o[key])) {
|
||||
o[key].push(value);
|
||||
}
|
||||
else {
|
||||
o[key] = [ o[key], value ];
|
||||
}
|
||||
}
|
||||
-47
File diff suppressed because one or more lines are too long
-71
@@ -1,71 +0,0 @@
|
||||
var spawn = require('child_process').spawn;
|
||||
var test = require('tap').test;
|
||||
|
||||
test('dotSlashEmpty', testCmd('./bin.js', []));
|
||||
|
||||
test('dotSlashArgs', testCmd('./bin.js', [ 'a', 'b', 'c' ]));
|
||||
|
||||
test('nodeEmpty', testCmd('node bin.js', []));
|
||||
|
||||
test('nodeArgs', testCmd('node bin.js', [ 'x', 'y', 'z' ]));
|
||||
|
||||
test('whichNodeEmpty', function (t) {
|
||||
var which = spawn('which', ['node']);
|
||||
|
||||
which.stdout.on('data', function (buf) {
|
||||
t.test(
|
||||
testCmd(buf.toString().trim() + ' bin.js', [])
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
which.stderr.on('data', function (err) {
|
||||
assert.error(err);
|
||||
t.end();
|
||||
});
|
||||
});
|
||||
|
||||
test('whichNodeArgs', function (t) {
|
||||
var which = spawn('which', ['node']);
|
||||
|
||||
which.stdout.on('data', function (buf) {
|
||||
t.test(
|
||||
testCmd(buf.toString().trim() + ' bin.js', [ 'q', 'r' ])
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
which.stderr.on('data', function (err) {
|
||||
t.error(err);
|
||||
t.end();
|
||||
});
|
||||
});
|
||||
|
||||
function testCmd (cmd, args) {
|
||||
|
||||
return function (t) {
|
||||
var to = setTimeout(function () {
|
||||
assert.fail('Never got stdout data.')
|
||||
}, 5000);
|
||||
|
||||
var oldDir = process.cwd();
|
||||
process.chdir(__dirname + '/_');
|
||||
|
||||
var cmds = cmd.split(' ');
|
||||
|
||||
var bin = spawn(cmds[0], cmds.slice(1).concat(args.map(String)));
|
||||
process.chdir(oldDir);
|
||||
|
||||
bin.stderr.on('data', function (err) {
|
||||
t.error(err);
|
||||
t.end();
|
||||
});
|
||||
|
||||
bin.stdout.on('data', function (buf) {
|
||||
clearTimeout(to);
|
||||
var _ = JSON.parse(buf.toString());
|
||||
t.same(_.map(String), args.map(String));
|
||||
t.end();
|
||||
});
|
||||
};
|
||||
}
|
||||
-2
@@ -1,2 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
console.log(JSON.stringify(process.argv));
|
||||
-3
@@ -1,3 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
var argv = require('../../index').argv
|
||||
console.log(JSON.stringify(argv._));
|
||||
-433
@@ -1,433 +0,0 @@
|
||||
var optimist = require('../index');
|
||||
var path = require('path');
|
||||
var test = require('tap').test;
|
||||
|
||||
var $0 = 'node ./' + path.relative(process.cwd(), __filename);
|
||||
|
||||
test('short boolean', function (t) {
|
||||
var parse = optimist.parse([ '-b' ]);
|
||||
t.same(parse, { b : true, _ : [], $0 : $0 });
|
||||
t.same(typeof parse.b, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('long boolean', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '--bool' ]),
|
||||
{ bool : true, _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('bare', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ 'foo', 'bar', 'baz' ]),
|
||||
{ _ : [ 'foo', 'bar', 'baz' ], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('short group', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-cats' ]),
|
||||
{ c : true, a : true, t : true, s : true, _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('short group next', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-cats', 'meow' ]),
|
||||
{ c : true, a : true, t : true, s : 'meow', _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('short capture', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-h', 'localhost' ]),
|
||||
{ h : 'localhost', _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('short captures', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-h', 'localhost', '-p', '555' ]),
|
||||
{ h : 'localhost', p : 555, _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('long capture sp', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '--pow', 'xixxle' ]),
|
||||
{ pow : 'xixxle', _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('long capture eq', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '--pow=xixxle' ]),
|
||||
{ pow : 'xixxle', _ : [], $0 : $0 }
|
||||
);
|
||||
t.end()
|
||||
});
|
||||
|
||||
test('long captures sp', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '--host', 'localhost', '--port', '555' ]),
|
||||
{ host : 'localhost', port : 555, _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('long captures eq', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '--host=localhost', '--port=555' ]),
|
||||
{ host : 'localhost', port : 555, _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('mixed short bool and capture', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
|
||||
{
|
||||
f : true, p : 555, h : 'localhost',
|
||||
_ : [ 'script.js' ], $0 : $0,
|
||||
}
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('short and long', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
|
||||
{
|
||||
f : true, p : 555, h : 'localhost',
|
||||
_ : [ 'script.js' ], $0 : $0,
|
||||
}
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('no', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '--no-moo' ]),
|
||||
{ moo : false, _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('multi', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]),
|
||||
{ v : ['a','b','c'], _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('comprehensive', function (t) {
|
||||
t.same(
|
||||
optimist.parse([
|
||||
'--name=meowmers', 'bare', '-cats', 'woo',
|
||||
'-h', 'awesome', '--multi=quux',
|
||||
'--key', 'value',
|
||||
'-b', '--bool', '--no-meep', '--multi=baz',
|
||||
'--', '--not-a-flag', 'eek'
|
||||
]),
|
||||
{
|
||||
c : true,
|
||||
a : true,
|
||||
t : true,
|
||||
s : 'woo',
|
||||
h : 'awesome',
|
||||
b : true,
|
||||
bool : true,
|
||||
key : 'value',
|
||||
multi : [ 'quux', 'baz' ],
|
||||
meep : false,
|
||||
name : 'meowmers',
|
||||
_ : [ 'bare', '--not-a-flag', 'eek' ],
|
||||
$0 : $0
|
||||
}
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('nums', function (t) {
|
||||
var argv = optimist.parse([
|
||||
'-x', '1234',
|
||||
'-y', '5.67',
|
||||
'-z', '1e7',
|
||||
'-w', '10f',
|
||||
'--hex', '0xdeadbeef',
|
||||
'789',
|
||||
]);
|
||||
t.same(argv, {
|
||||
x : 1234,
|
||||
y : 5.67,
|
||||
z : 1e7,
|
||||
w : '10f',
|
||||
hex : 0xdeadbeef,
|
||||
_ : [ 789 ],
|
||||
$0 : $0
|
||||
});
|
||||
t.same(typeof argv.x, 'number');
|
||||
t.same(typeof argv.y, 'number');
|
||||
t.same(typeof argv.z, 'number');
|
||||
t.same(typeof argv.w, 'string');
|
||||
t.same(typeof argv.hex, 'number');
|
||||
t.same(typeof argv._[0], 'number');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('flag boolean', function (t) {
|
||||
var parse = optimist([ '-t', 'moo' ]).boolean(['t']).argv;
|
||||
t.same(parse, { t : true, _ : [ 'moo' ], $0 : $0 });
|
||||
t.same(typeof parse.t, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('flag boolean value', function (t) {
|
||||
var parse = optimist(['--verbose', 'false', 'moo', '-t', 'true'])
|
||||
.boolean(['t', 'verbose']).default('verbose', true).argv;
|
||||
|
||||
t.same(parse, {
|
||||
verbose: false,
|
||||
t: true,
|
||||
_: ['moo'],
|
||||
$0 : $0
|
||||
});
|
||||
|
||||
t.same(typeof parse.verbose, 'boolean');
|
||||
t.same(typeof parse.t, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('flag boolean default false', function (t) {
|
||||
var parse = optimist(['moo'])
|
||||
.boolean(['t', 'verbose'])
|
||||
.default('verbose', false)
|
||||
.default('t', false).argv;
|
||||
|
||||
t.same(parse, {
|
||||
verbose: false,
|
||||
t: false,
|
||||
_: ['moo'],
|
||||
$0 : $0
|
||||
});
|
||||
|
||||
t.same(typeof parse.verbose, 'boolean');
|
||||
t.same(typeof parse.t, 'boolean');
|
||||
t.end();
|
||||
|
||||
});
|
||||
|
||||
test('boolean groups', function (t) {
|
||||
var parse = optimist([ '-x', '-z', 'one', 'two', 'three' ])
|
||||
.boolean(['x','y','z']).argv;
|
||||
|
||||
t.same(parse, {
|
||||
x : true,
|
||||
y : false,
|
||||
z : true,
|
||||
_ : [ 'one', 'two', 'three' ],
|
||||
$0 : $0
|
||||
});
|
||||
|
||||
t.same(typeof parse.x, 'boolean');
|
||||
t.same(typeof parse.y, 'boolean');
|
||||
t.same(typeof parse.z, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('strings' , function (t) {
|
||||
var s = optimist([ '-s', '0001234' ]).string('s').argv.s;
|
||||
t.same(s, '0001234');
|
||||
t.same(typeof s, 'string');
|
||||
|
||||
var x = optimist([ '-x', '56' ]).string('x').argv.x;
|
||||
t.same(x, '56');
|
||||
t.same(typeof x, 'string');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('stringArgs', function (t) {
|
||||
var s = optimist([ ' ', ' ' ]).string('_').argv._;
|
||||
t.same(s.length, 2);
|
||||
t.same(typeof s[0], 'string');
|
||||
t.same(s[0], ' ');
|
||||
t.same(typeof s[1], 'string');
|
||||
t.same(s[1], ' ');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('slashBreak', function (t) {
|
||||
t.same(
|
||||
optimist.parse([ '-I/foo/bar/baz' ]),
|
||||
{ I : '/foo/bar/baz', _ : [], $0 : $0 }
|
||||
);
|
||||
t.same(
|
||||
optimist.parse([ '-xyz/foo/bar/baz' ]),
|
||||
{ x : true, y : true, z : '/foo/bar/baz', _ : [], $0 : $0 }
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('alias', function (t) {
|
||||
var argv = optimist([ '-f', '11', '--zoom', '55' ])
|
||||
.alias('z', 'zoom')
|
||||
.argv
|
||||
;
|
||||
t.equal(argv.zoom, 55);
|
||||
t.equal(argv.z, argv.zoom);
|
||||
t.equal(argv.f, 11);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('multiAlias', function (t) {
|
||||
var argv = optimist([ '-f', '11', '--zoom', '55' ])
|
||||
.alias('z', [ 'zm', 'zoom' ])
|
||||
.argv
|
||||
;
|
||||
t.equal(argv.zoom, 55);
|
||||
t.equal(argv.z, argv.zoom);
|
||||
t.equal(argv.z, argv.zm);
|
||||
t.equal(argv.f, 11);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('boolean default true', function (t) {
|
||||
var argv = optimist.options({
|
||||
sometrue: {
|
||||
boolean: true,
|
||||
default: true
|
||||
}
|
||||
}).argv;
|
||||
|
||||
t.equal(argv.sometrue, true);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('boolean default false', function (t) {
|
||||
var argv = optimist.options({
|
||||
somefalse: {
|
||||
boolean: true,
|
||||
default: false
|
||||
}
|
||||
}).argv;
|
||||
|
||||
t.equal(argv.somefalse, false);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('nested dotted objects', function (t) {
|
||||
var argv = optimist([
|
||||
'--foo.bar', '3', '--foo.baz', '4',
|
||||
'--foo.quux.quibble', '5', '--foo.quux.o_O',
|
||||
'--beep.boop'
|
||||
]).argv;
|
||||
|
||||
t.same(argv.foo, {
|
||||
bar : 3,
|
||||
baz : 4,
|
||||
quux : {
|
||||
quibble : 5,
|
||||
o_O : true
|
||||
},
|
||||
});
|
||||
t.same(argv.beep, { boop : true });
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('boolean and alias with chainable api', function (t) {
|
||||
var aliased = [ '-h', 'derp' ];
|
||||
var regular = [ '--herp', 'derp' ];
|
||||
var opts = {
|
||||
herp: { alias: 'h', boolean: true }
|
||||
};
|
||||
var aliasedArgv = optimist(aliased)
|
||||
.boolean('herp')
|
||||
.alias('h', 'herp')
|
||||
.argv;
|
||||
var propertyArgv = optimist(regular)
|
||||
.boolean('herp')
|
||||
.alias('h', 'herp')
|
||||
.argv;
|
||||
var expected = {
|
||||
herp: true,
|
||||
h: true,
|
||||
'_': [ 'derp' ],
|
||||
'$0': $0,
|
||||
};
|
||||
|
||||
t.same(aliasedArgv, expected);
|
||||
t.same(propertyArgv, expected);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('boolean and alias with options hash', function (t) {
|
||||
var aliased = [ '-h', 'derp' ];
|
||||
var regular = [ '--herp', 'derp' ];
|
||||
var opts = {
|
||||
herp: { alias: 'h', boolean: true }
|
||||
};
|
||||
var aliasedArgv = optimist(aliased)
|
||||
.options(opts)
|
||||
.argv;
|
||||
var propertyArgv = optimist(regular).options(opts).argv;
|
||||
var expected = {
|
||||
herp: true,
|
||||
h: true,
|
||||
'_': [ 'derp' ],
|
||||
'$0': $0,
|
||||
};
|
||||
|
||||
t.same(aliasedArgv, expected);
|
||||
t.same(propertyArgv, expected);
|
||||
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('boolean and alias using explicit true', function (t) {
|
||||
var aliased = [ '-h', 'true' ];
|
||||
var regular = [ '--herp', 'true' ];
|
||||
var opts = {
|
||||
herp: { alias: 'h', boolean: true }
|
||||
};
|
||||
var aliasedArgv = optimist(aliased)
|
||||
.boolean('h')
|
||||
.alias('h', 'herp')
|
||||
.argv;
|
||||
var propertyArgv = optimist(regular)
|
||||
.boolean('h')
|
||||
.alias('h', 'herp')
|
||||
.argv;
|
||||
var expected = {
|
||||
herp: true,
|
||||
h: true,
|
||||
'_': [ ],
|
||||
'$0': $0,
|
||||
};
|
||||
|
||||
t.same(aliasedArgv, expected);
|
||||
t.same(propertyArgv, expected);
|
||||
t.end();
|
||||
});
|
||||
|
||||
// regression, see https://github.com/substack/node-optimist/issues/71
|
||||
test('boolean and --x=true', function(t) {
|
||||
var parsed = optimist(['--boool', '--other=true']).boolean('boool').argv;
|
||||
|
||||
t.same(parsed.boool, true);
|
||||
t.same(parsed.other, 'true');
|
||||
|
||||
parsed = optimist(['--boool', '--other=false']).boolean('boool').argv;
|
||||
|
||||
t.same(parsed.boool, true);
|
||||
t.same(parsed.other, 'false');
|
||||
t.end();
|
||||
});
|
||||
-292
@@ -1,292 +0,0 @@
|
||||
var Hash = require('hashish');
|
||||
var optimist = require('../index');
|
||||
var test = require('tap').test;
|
||||
|
||||
test('usageFail', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('-x 10 -z 20'.split(' '))
|
||||
.usage('Usage: $0 -x NUM -y NUM')
|
||||
.demand(['x','y'])
|
||||
.argv;
|
||||
});
|
||||
t.same(
|
||||
r.result,
|
||||
{ x : 10, z : 20, _ : [], $0 : './usage' }
|
||||
);
|
||||
|
||||
t.same(
|
||||
r.errors.join('\n').split(/\n+/),
|
||||
[
|
||||
'Usage: ./usage -x NUM -y NUM',
|
||||
'Options:',
|
||||
' -x [required]',
|
||||
' -y [required]',
|
||||
'Missing required arguments: y',
|
||||
]
|
||||
);
|
||||
t.same(r.logs, []);
|
||||
t.ok(r.exit);
|
||||
t.end();
|
||||
});
|
||||
|
||||
|
||||
test('usagePass', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('-x 10 -y 20'.split(' '))
|
||||
.usage('Usage: $0 -x NUM -y NUM')
|
||||
.demand(['x','y'])
|
||||
.argv;
|
||||
});
|
||||
t.same(r, {
|
||||
result : { x : 10, y : 20, _ : [], $0 : './usage' },
|
||||
errors : [],
|
||||
logs : [],
|
||||
exit : false,
|
||||
});
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('checkPass', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('-x 10 -y 20'.split(' '))
|
||||
.usage('Usage: $0 -x NUM -y NUM')
|
||||
.check(function (argv) {
|
||||
if (!('x' in argv)) throw 'You forgot about -x';
|
||||
if (!('y' in argv)) throw 'You forgot about -y';
|
||||
})
|
||||
.argv;
|
||||
});
|
||||
t.same(r, {
|
||||
result : { x : 10, y : 20, _ : [], $0 : './usage' },
|
||||
errors : [],
|
||||
logs : [],
|
||||
exit : false,
|
||||
});
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('checkFail', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('-x 10 -z 20'.split(' '))
|
||||
.usage('Usage: $0 -x NUM -y NUM')
|
||||
.check(function (argv) {
|
||||
if (!('x' in argv)) throw 'You forgot about -x';
|
||||
if (!('y' in argv)) throw 'You forgot about -y';
|
||||
})
|
||||
.argv;
|
||||
});
|
||||
|
||||
t.same(
|
||||
r.result,
|
||||
{ x : 10, z : 20, _ : [], $0 : './usage' }
|
||||
);
|
||||
|
||||
t.same(
|
||||
r.errors.join('\n').split(/\n+/),
|
||||
[
|
||||
'Usage: ./usage -x NUM -y NUM',
|
||||
'You forgot about -y'
|
||||
]
|
||||
);
|
||||
|
||||
t.same(r.logs, []);
|
||||
t.ok(r.exit);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('checkCondPass', function (t) {
|
||||
function checker (argv) {
|
||||
return 'x' in argv && 'y' in argv;
|
||||
}
|
||||
|
||||
var r = checkUsage(function () {
|
||||
return optimist('-x 10 -y 20'.split(' '))
|
||||
.usage('Usage: $0 -x NUM -y NUM')
|
||||
.check(checker)
|
||||
.argv;
|
||||
});
|
||||
t.same(r, {
|
||||
result : { x : 10, y : 20, _ : [], $0 : './usage' },
|
||||
errors : [],
|
||||
logs : [],
|
||||
exit : false,
|
||||
});
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('checkCondFail', function (t) {
|
||||
function checker (argv) {
|
||||
return 'x' in argv && 'y' in argv;
|
||||
}
|
||||
|
||||
var r = checkUsage(function () {
|
||||
return optimist('-x 10 -z 20'.split(' '))
|
||||
.usage('Usage: $0 -x NUM -y NUM')
|
||||
.check(checker)
|
||||
.argv;
|
||||
});
|
||||
|
||||
t.same(
|
||||
r.result,
|
||||
{ x : 10, z : 20, _ : [], $0 : './usage' }
|
||||
);
|
||||
|
||||
t.same(
|
||||
r.errors.join('\n').split(/\n+/).join('\n'),
|
||||
'Usage: ./usage -x NUM -y NUM\n'
|
||||
+ 'Argument check failed: ' + checker.toString()
|
||||
);
|
||||
|
||||
t.same(r.logs, []);
|
||||
t.ok(r.exit);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('countPass', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('1 2 3 --moo'.split(' '))
|
||||
.usage('Usage: $0 [x] [y] [z] {OPTIONS}')
|
||||
.demand(3)
|
||||
.argv;
|
||||
});
|
||||
t.same(r, {
|
||||
result : { _ : [ '1', '2', '3' ], moo : true, $0 : './usage' },
|
||||
errors : [],
|
||||
logs : [],
|
||||
exit : false,
|
||||
});
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('countFail', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('1 2 --moo'.split(' '))
|
||||
.usage('Usage: $0 [x] [y] [z] {OPTIONS}')
|
||||
.demand(3)
|
||||
.argv;
|
||||
});
|
||||
t.same(
|
||||
r.result,
|
||||
{ _ : [ '1', '2' ], moo : true, $0 : './usage' }
|
||||
);
|
||||
|
||||
t.same(
|
||||
r.errors.join('\n').split(/\n+/),
|
||||
[
|
||||
'Usage: ./usage [x] [y] [z] {OPTIONS}',
|
||||
'Not enough non-option arguments: got 2, need at least 3',
|
||||
]
|
||||
);
|
||||
|
||||
t.same(r.logs, []);
|
||||
t.ok(r.exit);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('defaultSingles', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('--foo 50 --baz 70 --powsy'.split(' '))
|
||||
.default('foo', 5)
|
||||
.default('bar', 6)
|
||||
.default('baz', 7)
|
||||
.argv
|
||||
;
|
||||
});
|
||||
t.same(r.result, {
|
||||
foo : '50',
|
||||
bar : 6,
|
||||
baz : '70',
|
||||
powsy : true,
|
||||
_ : [],
|
||||
$0 : './usage',
|
||||
});
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('defaultAliases', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('')
|
||||
.alias('f', 'foo')
|
||||
.default('f', 5)
|
||||
.argv
|
||||
;
|
||||
});
|
||||
t.same(r.result, {
|
||||
f : '5',
|
||||
foo : '5',
|
||||
_ : [],
|
||||
$0 : './usage',
|
||||
});
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('defaultHash', function (t) {
|
||||
var r = checkUsage(function () {
|
||||
return optimist('--foo 50 --baz 70'.split(' '))
|
||||
.default({ foo : 10, bar : 20, quux : 30 })
|
||||
.argv
|
||||
;
|
||||
});
|
||||
t.same(r.result, {
|
||||
_ : [],
|
||||
$0 : './usage',
|
||||
foo : 50,
|
||||
baz : 70,
|
||||
bar : 20,
|
||||
quux : 30,
|
||||
});
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('rebase', function (t) {
|
||||
t.equal(
|
||||
optimist.rebase('/home/substack', '/home/substack/foo/bar/baz'),
|
||||
'./foo/bar/baz'
|
||||
);
|
||||
t.equal(
|
||||
optimist.rebase('/home/substack/foo/bar/baz', '/home/substack'),
|
||||
'../../..'
|
||||
);
|
||||
t.equal(
|
||||
optimist.rebase('/home/substack/foo', '/home/substack/pow/zoom.txt'),
|
||||
'../pow/zoom.txt'
|
||||
);
|
||||
t.end();
|
||||
});
|
||||
|
||||
function checkUsage (f) {
|
||||
|
||||
var exit = false;
|
||||
|
||||
process._exit = process.exit;
|
||||
process._env = process.env;
|
||||
process._argv = process.argv;
|
||||
|
||||
process.exit = function (t) { exit = true };
|
||||
process.env = Hash.merge(process.env, { _ : 'node' });
|
||||
process.argv = [ './usage' ];
|
||||
|
||||
var errors = [];
|
||||
var logs = [];
|
||||
|
||||
console._error = console.error;
|
||||
console.error = function (msg) { errors.push(msg) };
|
||||
console._log = console.log;
|
||||
console.log = function (msg) { logs.push(msg) };
|
||||
|
||||
var result = f();
|
||||
|
||||
process.exit = process._exit;
|
||||
process.env = process._env;
|
||||
process.argv = process._argv;
|
||||
|
||||
console.error = console._error;
|
||||
console.log = console._log;
|
||||
|
||||
return {
|
||||
errors : errors,
|
||||
logs : logs,
|
||||
exit : exit,
|
||||
result : result,
|
||||
};
|
||||
};
|
||||
-55
@@ -1,55 +0,0 @@
|
||||
Apache License
|
||||
|
||||
Version 2.0, January 2004
|
||||
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
|
||||
|
||||
You must give any other recipients of the Work or Derivative Works a copy of this License; and
|
||||
|
||||
You must cause any modified files to carry prominent notices stating that You changed the files; and
|
||||
|
||||
You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
|
||||
|
||||
If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
-310
@@ -1,310 +0,0 @@
|
||||
# Request -- Simplified HTTP request method
|
||||
|
||||
## Install
|
||||
|
||||
<pre>
|
||||
npm install request
|
||||
</pre>
|
||||
|
||||
Or from source:
|
||||
|
||||
<pre>
|
||||
git clone git://github.com/mikeal/request.git
|
||||
cd request
|
||||
npm link
|
||||
</pre>
|
||||
|
||||
## Super simple to use
|
||||
|
||||
Request is designed to be the simplest way possible to make http calls. It supports HTTPS and follows redirects by default.
|
||||
|
||||
```javascript
|
||||
var request = require('request');
|
||||
request('http://www.google.com', function (error, response, body) {
|
||||
if (!error && response.statusCode == 200) {
|
||||
console.log(body) // Print the google web page.
|
||||
}
|
||||
})
|
||||
```
|
||||
|
||||
## Streaming
|
||||
|
||||
You can stream any response to a file stream.
|
||||
|
||||
```javascript
|
||||
request('http://google.com/doodle.png').pipe(fs.createWriteStream('doodle.png'))
|
||||
```
|
||||
|
||||
You can also stream a file to a PUT or POST request. This method will also check the file extension against a mapping of file extensions to content-types, in this case `application/json`, and use the proper content-type in the PUT request if one is not already provided in the headers.
|
||||
|
||||
```javascript
|
||||
fs.createReadStream('file.json').pipe(request.put('http://mysite.com/obj.json'))
|
||||
```
|
||||
|
||||
Request can also pipe to itself. When doing so the content-type and content-length will be preserved in the PUT headers.
|
||||
|
||||
```javascript
|
||||
request.get('http://google.com/img.png').pipe(request.put('http://mysite.com/img.png'))
|
||||
```
|
||||
|
||||
Now let's get fancy.
|
||||
|
||||
```javascript
|
||||
http.createServer(function (req, resp) {
|
||||
if (req.url === '/doodle.png') {
|
||||
if (req.method === 'PUT') {
|
||||
req.pipe(request.put('http://mysite.com/doodle.png'))
|
||||
} else if (req.method === 'GET' || req.method === 'HEAD') {
|
||||
request.get('http://mysite.com/doodle.png').pipe(resp)
|
||||
}
|
||||
}
|
||||
})
|
||||
```
|
||||
|
||||
You can also pipe() from a http.ServerRequest instance and to a http.ServerResponse instance. The HTTP method and headers will be sent as well as the entity-body data. Which means that, if you don't really care about security, you can do:
|
||||
|
||||
```javascript
|
||||
http.createServer(function (req, resp) {
|
||||
if (req.url === '/doodle.png') {
|
||||
var x = request('http://mysite.com/doodle.png')
|
||||
req.pipe(x)
|
||||
x.pipe(resp)
|
||||
}
|
||||
})
|
||||
```
|
||||
|
||||
And since pipe() returns the destination stream in node 0.5.x you can do one line proxying :)
|
||||
|
||||
```javascript
|
||||
req.pipe(request('http://mysite.com/doodle.png')).pipe(resp)
|
||||
```
|
||||
|
||||
Also, none of this new functionality conflicts with requests previous features, it just expands them.
|
||||
|
||||
```javascript
|
||||
var r = request.defaults({'proxy':'http://localproxy.com'})
|
||||
|
||||
http.createServer(function (req, resp) {
|
||||
if (req.url === '/doodle.png') {
|
||||
r.get('http://google.com/doodle.png').pipe(resp)
|
||||
}
|
||||
})
|
||||
```
|
||||
You can still use intermediate proxies, the requests will still follow HTTP forwards, etc.
|
||||
|
||||
## Forms
|
||||
|
||||
`request` supports `application/x-www-form-urlencoded` and `multipart/form-data` form uploads. For `multipart/related` refer to the `multipart` API.
|
||||
|
||||
Url encoded forms are simple
|
||||
|
||||
```javascript
|
||||
request.post('http://service.com/upload', {form:{key:'value'}})
|
||||
// or
|
||||
request.post('http://service.com/upload').form({key:'value'})
|
||||
```
|
||||
|
||||
For `multipart/form-data` we use the [form-data](https://github.com/felixge/node-form-data) library by [@felixge](https://github.com/felixge). You don't need to worry about piping the form object or setting the headers, `request` will handle that for you.
|
||||
|
||||
```javascript
|
||||
var r = request.post('http://service.com/upload')
|
||||
var form = r.form()
|
||||
form.append('my_field', 'my_value')
|
||||
form.append('my_buffer', new Buffer([1, 2, 3]))
|
||||
form.append('my_file', fs.createReadStream(path.join(__dirname, 'doodle.png'))
|
||||
form.append('remote_file', request('http://google.com/doodle.png'))
|
||||
```
|
||||
|
||||
## OAuth Signing
|
||||
|
||||
```javascript
|
||||
// Twitter OAuth
|
||||
var qs = require('querystring')
|
||||
, oauth =
|
||||
{ callback: 'http://mysite.com/callback/'
|
||||
, consumer_key: CONSUMER_KEY
|
||||
, consumer_secret: CONSUMER_SECRET
|
||||
}
|
||||
, url = 'https://api.twitter.com/oauth/request_token'
|
||||
;
|
||||
request.post({url:url, oauth:oauth}, function (e, r, body) {
|
||||
// Assume by some stretch of magic you aquired the verifier
|
||||
var access_token = qs.parse(body)
|
||||
, oauth =
|
||||
{ consumer_key: CONSUMER_KEY
|
||||
, consumer_secret: CONSUMER_SECRET
|
||||
, token: access_token.oauth_token
|
||||
, verifier: VERIFIER
|
||||
, token_secret: access_token.oauth_token_secret
|
||||
}
|
||||
, url = 'https://api.twitter.com/oauth/access_token'
|
||||
;
|
||||
request.post({url:url, oauth:oauth}, function (e, r, body) {
|
||||
var perm_token = qs.parse(body)
|
||||
, oauth =
|
||||
{ consumer_key: CONSUMER_KEY
|
||||
, consumer_secret: CONSUMER_SECRET
|
||||
, token: perm_token.oauth_token
|
||||
, token_secret: perm_token.oauth_token_secret
|
||||
}
|
||||
, url = 'https://api.twitter.com/1/users/show.json?'
|
||||
, params =
|
||||
{ screen_name: perm_token.screen_name
|
||||
, user_id: perm_token.user_id
|
||||
}
|
||||
;
|
||||
url += qs.stringify(params)
|
||||
request.get({url:url, oauth:oauth, json:true}, function (e, r, user) {
|
||||
console.log(user)
|
||||
})
|
||||
})
|
||||
})
|
||||
```
|
||||
|
||||
|
||||
|
||||
### request(options, callback)
|
||||
|
||||
The first argument can be either a url or an options object. The only required option is uri, all others are optional.
|
||||
|
||||
* `uri` || `url` - fully qualified uri or a parsed url object from url.parse()
|
||||
* `qs` - object containing querystring values to be appended to the uri
|
||||
* `method` - http method, defaults to GET
|
||||
* `headers` - http headers, defaults to {}
|
||||
* `body` - entity body for POST and PUT requests. Must be buffer or string.
|
||||
* `form` - when passed an object this will set `body` but to a querystring representation of value and adds `Content-type: application/x-www-form-urlencoded; charset=utf-8` header. When passed no option a FormData instance is returned that will be piped to request.
|
||||
* `json` - sets `body` but to JSON representation of value and adds `Content-type: application/json` header. Additionally, parses the response body as json.
|
||||
* `multipart` - (experimental) array of objects which contains their own headers and `body` attribute. Sends `multipart/related` request. See example below.
|
||||
* `followRedirect` - follow HTTP 3xx responses as redirects. defaults to true.
|
||||
* `followAllRedirects` - follow non-GET HTTP 3xx responses as redirects. defaults to false.
|
||||
* `maxRedirects` - the maximum number of redirects to follow, defaults to 10.
|
||||
* `encoding` - Encoding to be used on `setEncoding` of response data. If set to `null`, the body is returned as a Buffer.
|
||||
* `pool` - A hash object containing the agents for these requests. If omitted this request will use the global pool which is set to node's default maxSockets.
|
||||
* `pool.maxSockets` - Integer containing the maximum amount of sockets in the pool.
|
||||
* `timeout` - Integer containing the number of milliseconds to wait for a request to respond before aborting the request
|
||||
* `proxy` - An HTTP proxy to be used. Support proxy Auth with Basic Auth the same way it's supported with the `url` parameter by embedding the auth info in the uri.
|
||||
* `oauth` - Options for OAuth HMAC-SHA1 signing, see documentation above.
|
||||
* `strictSSL` - Set to `true` to require that SSL certificates be valid. Note: to use your own certificate authority, you need to specify an agent that was created with that ca as an option.
|
||||
* `jar` - Set to `false` if you don't want cookies to be remembered for future use or define your custom cookie jar (see examples section)
|
||||
* `aws` - object containing aws signing information, should have the properties `key` and `secret` as well as `bucket` unless you're specifying your bucket as part of the path, or you are making a request that doesn't use a bucket (i.e. GET Services)
|
||||
|
||||
|
||||
The callback argument gets 3 arguments. The first is an error when applicable (usually from the http.Client option not the http.ClientRequest object). The second in an http.ClientResponse object. The third is the response body String or Buffer.
|
||||
|
||||
## Convenience methods
|
||||
|
||||
There are also shorthand methods for different HTTP METHODs and some other conveniences.
|
||||
|
||||
### request.defaults(options)
|
||||
|
||||
This method returns a wrapper around the normal request API that defaults to whatever options you pass in to it.
|
||||
|
||||
### request.put
|
||||
|
||||
Same as request() but defaults to `method: "PUT"`.
|
||||
|
||||
```javascript
|
||||
request.put(url)
|
||||
```
|
||||
|
||||
### request.post
|
||||
|
||||
Same as request() but defaults to `method: "POST"`.
|
||||
|
||||
```javascript
|
||||
request.post(url)
|
||||
```
|
||||
|
||||
### request.head
|
||||
|
||||
Same as request() but defaults to `method: "HEAD"`.
|
||||
|
||||
```javascript
|
||||
request.head(url)
|
||||
```
|
||||
|
||||
### request.del
|
||||
|
||||
Same as request() but defaults to `method: "DELETE"`.
|
||||
|
||||
```javascript
|
||||
request.del(url)
|
||||
```
|
||||
|
||||
### request.get
|
||||
|
||||
Alias to normal request method for uniformity.
|
||||
|
||||
```javascript
|
||||
request.get(url)
|
||||
```
|
||||
### request.cookie
|
||||
|
||||
Function that creates a new cookie.
|
||||
|
||||
```javascript
|
||||
request.cookie('cookie_string_here')
|
||||
```
|
||||
### request.jar
|
||||
|
||||
Function that creates a new cookie jar.
|
||||
|
||||
```javascript
|
||||
request.jar()
|
||||
```
|
||||
|
||||
|
||||
## Examples:
|
||||
|
||||
```javascript
|
||||
var request = require('request')
|
||||
, rand = Math.floor(Math.random()*100000000).toString()
|
||||
;
|
||||
request(
|
||||
{ method: 'PUT'
|
||||
, uri: 'http://mikeal.iriscouch.com/testjs/' + rand
|
||||
, multipart:
|
||||
[ { 'content-type': 'application/json'
|
||||
, body: JSON.stringify({foo: 'bar', _attachments: {'message.txt': {follows: true, length: 18, 'content_type': 'text/plain' }}})
|
||||
}
|
||||
, { body: 'I am an attachment' }
|
||||
]
|
||||
}
|
||||
, function (error, response, body) {
|
||||
if(response.statusCode == 201){
|
||||
console.log('document saved as: http://mikeal.iriscouch.com/testjs/'+ rand)
|
||||
} else {
|
||||
console.log('error: '+ response.statusCode)
|
||||
console.log(body)
|
||||
}
|
||||
}
|
||||
)
|
||||
```
|
||||
Cookies are enabled by default (so they can be used in subsequent requests). To disable cookies set jar to false (either in defaults or in the options sent).
|
||||
|
||||
```javascript
|
||||
var request = request.defaults({jar: false})
|
||||
request('http://www.google.com', function () {
|
||||
request('http://images.google.com')
|
||||
})
|
||||
```
|
||||
|
||||
If you to use a custom cookie jar (instead of letting request use its own global cookie jar) you do so by setting the jar default or by specifying it as an option:
|
||||
|
||||
```javascript
|
||||
var j = request.jar()
|
||||
var request = request.defaults({jar:j})
|
||||
request('http://www.google.com', function () {
|
||||
request('http://images.google.com')
|
||||
})
|
||||
```
|
||||
OR
|
||||
|
||||
```javascript
|
||||
var j = request.jar()
|
||||
var cookie = request.cookie('your_cookie_here')
|
||||
j.add(cookie)
|
||||
request({url: 'http://www.google.com', jar: j}, function () {
|
||||
request('http://images.google.com')
|
||||
})
|
||||
```
|
||||
-1123
File diff suppressed because it is too large
Load Diff
-43
@@ -1,43 +0,0 @@
|
||||
var crypto = require('crypto')
|
||||
, qs = require('querystring')
|
||||
;
|
||||
|
||||
function sha1 (key, body) {
|
||||
return crypto.createHmac('sha1', key).update(body).digest('base64')
|
||||
}
|
||||
|
||||
function rfc3986 (str) {
|
||||
return encodeURIComponent(str)
|
||||
.replace(/!/g,'%21')
|
||||
.replace(/\*/g,'%2A')
|
||||
.replace(/\(/g,'%28')
|
||||
.replace(/\)/g,'%29')
|
||||
.replace(/'/g,'%27')
|
||||
;
|
||||
}
|
||||
|
||||
function hmacsign (httpMethod, base_uri, params, consumer_secret, token_secret) {
|
||||
// adapted from https://dev.twitter.com/docs/auth/oauth and
|
||||
// https://dev.twitter.com/docs/auth/creating-signature
|
||||
|
||||
var querystring = Object.keys(params).sort().map(function(key){
|
||||
// big WTF here with the escape + encoding but it's what twitter wants
|
||||
return escape(rfc3986(key)) + "%3D" + escape(rfc3986(params[key]))
|
||||
}).join('%26')
|
||||
|
||||
var base = [
|
||||
httpMethod ? httpMethod.toUpperCase() : 'GET',
|
||||
rfc3986(base_uri),
|
||||
querystring
|
||||
].join('&')
|
||||
|
||||
var key = [
|
||||
consumer_secret,
|
||||
token_secret || ''
|
||||
].map(rfc3986).join('&')
|
||||
|
||||
return sha1(key, base)
|
||||
}
|
||||
|
||||
exports.hmacsign = hmacsign
|
||||
exports.rfc3986 = rfc3986
|
||||
-41
File diff suppressed because one or more lines are too long
BIN
Binary file not shown.
|
Before Width: | Height: | Size: 38 KiB |
-90
@@ -1,90 +0,0 @@
|
||||
var fs = require('fs')
|
||||
, http = require('http')
|
||||
, path = require('path')
|
||||
, https = require('https')
|
||||
, events = require('events')
|
||||
, stream = require('stream')
|
||||
, assert = require('assert')
|
||||
;
|
||||
|
||||
exports.createServer = function (port) {
|
||||
port = port || 6767
|
||||
var s = http.createServer(function (req, resp) {
|
||||
s.emit(req.url, req, resp);
|
||||
})
|
||||
s.port = port
|
||||
s.url = 'http://localhost:'+port
|
||||
return s;
|
||||
}
|
||||
|
||||
exports.createSSLServer = function(port, opts) {
|
||||
port = port || 16767
|
||||
|
||||
var options = { 'key' : path.join(__dirname, 'ssl', 'test.key')
|
||||
, 'cert': path.join(__dirname, 'ssl', 'test.crt')
|
||||
}
|
||||
if (opts) {
|
||||
for (var i in opts) options[i] = opts[i]
|
||||
}
|
||||
|
||||
for (var i in options) {
|
||||
options[i] = fs.readFileSync(options[i])
|
||||
}
|
||||
|
||||
var s = https.createServer(options, function (req, resp) {
|
||||
s.emit(req.url, req, resp);
|
||||
})
|
||||
s.port = port
|
||||
s.url = 'https://localhost:'+port
|
||||
return s;
|
||||
}
|
||||
|
||||
exports.createPostStream = function (text) {
|
||||
var postStream = new stream.Stream();
|
||||
postStream.writeable = true;
|
||||
postStream.readable = true;
|
||||
setTimeout(function () {postStream.emit('data', new Buffer(text)); postStream.emit('end')}, 0);
|
||||
return postStream;
|
||||
}
|
||||
exports.createPostValidator = function (text, reqContentType) {
|
||||
var l = function (req, resp) {
|
||||
var r = '';
|
||||
req.on('data', function (chunk) {r += chunk})
|
||||
req.on('end', function () {
|
||||
if (req.headers['content-type'] && req.headers['content-type'].indexOf('boundary=') >= 0) {
|
||||
var boundary = req.headers['content-type'].split('boundary=')[1];
|
||||
text = text.replace(/__BOUNDARY__/g, boundary);
|
||||
}
|
||||
if (r !== text) console.log(r, text);
|
||||
assert.equal(r, text)
|
||||
if (reqContentType) {
|
||||
assert.ok(req.headers['content-type'])
|
||||
assert.ok(~req.headers['content-type'].indexOf(reqContentType))
|
||||
}
|
||||
resp.writeHead(200, {'content-type':'text/plain'})
|
||||
resp.write('OK')
|
||||
resp.end()
|
||||
})
|
||||
}
|
||||
return l;
|
||||
}
|
||||
exports.createGetResponse = function (text, contentType) {
|
||||
var l = function (req, resp) {
|
||||
contentType = contentType || 'text/plain'
|
||||
resp.writeHead(200, {'content-type':contentType})
|
||||
resp.write(text)
|
||||
resp.end()
|
||||
}
|
||||
return l;
|
||||
}
|
||||
exports.createChunkResponse = function (chunks, contentType) {
|
||||
var l = function (req, resp) {
|
||||
contentType = contentType || 'text/plain'
|
||||
resp.writeHead(200, {'content-type':contentType})
|
||||
chunks.forEach(function (chunk) {
|
||||
resp.write(chunk)
|
||||
})
|
||||
resp.end()
|
||||
}
|
||||
return l;
|
||||
}
|
||||
-117
@@ -1,117 +0,0 @@
|
||||
var server = require('./server')
|
||||
, events = require('events')
|
||||
, stream = require('stream')
|
||||
, assert = require('assert')
|
||||
, request = require('../main.js')
|
||||
;
|
||||
|
||||
var s = server.createServer();
|
||||
|
||||
var tests =
|
||||
{ testGet :
|
||||
{ resp : server.createGetResponse("TESTING!")
|
||||
, expectBody: "TESTING!"
|
||||
}
|
||||
, testGetChunkBreak :
|
||||
{ resp : server.createChunkResponse(
|
||||
[ new Buffer([239])
|
||||
, new Buffer([163])
|
||||
, new Buffer([191])
|
||||
, new Buffer([206])
|
||||
, new Buffer([169])
|
||||
, new Buffer([226])
|
||||
, new Buffer([152])
|
||||
, new Buffer([131])
|
||||
])
|
||||
, expectBody: "Ω☃"
|
||||
}
|
||||
, testGetBuffer :
|
||||
{ resp : server.createGetResponse(new Buffer("TESTING!"))
|
||||
, encoding: null
|
||||
, expectBody: new Buffer("TESTING!")
|
||||
}
|
||||
, testGetEncoding :
|
||||
{ resp : server.createGetResponse(new Buffer('efa3bfcea9e29883', 'hex'))
|
||||
, encoding: 'hex'
|
||||
, expectBody: "efa3bfcea9e29883"
|
||||
}
|
||||
, testGetJSON :
|
||||
{ resp : server.createGetResponse('{"test":true}', 'application/json')
|
||||
, json : true
|
||||
, expectBody: {"test":true}
|
||||
}
|
||||
, testPutString :
|
||||
{ resp : server.createPostValidator("PUTTINGDATA")
|
||||
, method : "PUT"
|
||||
, body : "PUTTINGDATA"
|
||||
}
|
||||
, testPutBuffer :
|
||||
{ resp : server.createPostValidator("PUTTINGDATA")
|
||||
, method : "PUT"
|
||||
, body : new Buffer("PUTTINGDATA")
|
||||
}
|
||||
, testPutJSON :
|
||||
{ resp : server.createPostValidator(JSON.stringify({foo: 'bar'}))
|
||||
, method: "PUT"
|
||||
, json: {foo: 'bar'}
|
||||
}
|
||||
, testPutMultipart :
|
||||
{ resp: server.createPostValidator(
|
||||
'--__BOUNDARY__\r\n' +
|
||||
'content-type: text/html\r\n' +
|
||||
'\r\n' +
|
||||
'<html><body>Oh hi.</body></html>' +
|
||||
'\r\n--__BOUNDARY__\r\n\r\n' +
|
||||
'Oh hi.' +
|
||||
'\r\n--__BOUNDARY__--'
|
||||
)
|
||||
, method: "PUT"
|
||||
, multipart:
|
||||
[ {'content-type': 'text/html', 'body': '<html><body>Oh hi.</body></html>'}
|
||||
, {'body': 'Oh hi.'}
|
||||
]
|
||||
}
|
||||
, testPutMultipartPreambleCRLF :
|
||||
{ resp: server.createPostValidator(
|
||||
'\r\n--__BOUNDARY__\r\n' +
|
||||
'content-type: text/html\r\n' +
|
||||
'\r\n' +
|
||||
'<html><body>Oh hi.</body></html>' +
|
||||
'\r\n--__BOUNDARY__\r\n\r\n' +
|
||||
'Oh hi.' +
|
||||
'\r\n--__BOUNDARY__--'
|
||||
)
|
||||
, method: "PUT"
|
||||
, preambleCRLF: true
|
||||
, multipart:
|
||||
[ {'content-type': 'text/html', 'body': '<html><body>Oh hi.</body></html>'}
|
||||
, {'body': 'Oh hi.'}
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
s.listen(s.port, function () {
|
||||
|
||||
var counter = 0
|
||||
|
||||
for (i in tests) {
|
||||
(function () {
|
||||
var test = tests[i]
|
||||
s.on('/'+i, test.resp)
|
||||
test.uri = s.url + '/' + i
|
||||
request(test, function (err, resp, body) {
|
||||
if (err) throw err
|
||||
if (test.expectBody) {
|
||||
assert.deepEqual(test.expectBody, body)
|
||||
}
|
||||
counter = counter - 1;
|
||||
if (counter === 0) {
|
||||
console.log(Object.keys(tests).length+" tests passed.")
|
||||
s.close()
|
||||
}
|
||||
})
|
||||
counter++
|
||||
})()
|
||||
}
|
||||
})
|
||||
|
||||
-29
@@ -1,29 +0,0 @@
|
||||
var Cookie = require('../vendor/cookie')
|
||||
, assert = require('assert');
|
||||
|
||||
var str = 'Sid="s543qactge.wKE61E01Bs%2BKhzmxrwrnug="; Path=/; httpOnly; Expires=Sat, 04 Dec 2010 23:27:28 GMT';
|
||||
var cookie = new Cookie(str);
|
||||
|
||||
// test .toString()
|
||||
assert.equal(cookie.toString(), str);
|
||||
|
||||
// test .path
|
||||
assert.equal(cookie.path, '/');
|
||||
|
||||
// test .httpOnly
|
||||
assert.equal(cookie.httpOnly, true);
|
||||
|
||||
// test .name
|
||||
assert.equal(cookie.name, 'Sid');
|
||||
|
||||
// test .value
|
||||
assert.equal(cookie.value, '"s543qactge.wKE61E01Bs%2BKhzmxrwrnug="');
|
||||
|
||||
// test .expires
|
||||
assert.equal(cookie.expires instanceof Date, true);
|
||||
|
||||
// test .path default
|
||||
var cookie = new Cookie('foo=bar', { url: 'http://foo.com/bar' });
|
||||
assert.equal(cookie.path, '/bar');
|
||||
|
||||
console.log('All tests passed');
|
||||
-90
@@ -1,90 +0,0 @@
|
||||
var Cookie = require('../vendor/cookie')
|
||||
, Jar = require('../vendor/cookie/jar')
|
||||
, assert = require('assert');
|
||||
|
||||
function expires(ms) {
|
||||
return new Date(Date.now() + ms).toUTCString();
|
||||
}
|
||||
|
||||
// test .get() expiration
|
||||
(function() {
|
||||
var jar = new Jar;
|
||||
var cookie = new Cookie('sid=1234; path=/; expires=' + expires(1000));
|
||||
jar.add(cookie);
|
||||
setTimeout(function(){
|
||||
var cookies = jar.get({ url: 'http://foo.com/foo' });
|
||||
assert.equal(cookies.length, 1);
|
||||
assert.equal(cookies[0], cookie);
|
||||
setTimeout(function(){
|
||||
var cookies = jar.get({ url: 'http://foo.com/foo' });
|
||||
assert.equal(cookies.length, 0);
|
||||
}, 1000);
|
||||
}, 5);
|
||||
})();
|
||||
|
||||
// test .get() path support
|
||||
(function() {
|
||||
var jar = new Jar;
|
||||
var a = new Cookie('sid=1234; path=/');
|
||||
var b = new Cookie('sid=1111; path=/foo/bar');
|
||||
var c = new Cookie('sid=2222; path=/');
|
||||
jar.add(a);
|
||||
jar.add(b);
|
||||
jar.add(c);
|
||||
|
||||
// should remove the duplicates
|
||||
assert.equal(jar.cookies.length, 2);
|
||||
|
||||
// same name, same path, latter prevails
|
||||
var cookies = jar.get({ url: 'http://foo.com/' });
|
||||
assert.equal(cookies.length, 1);
|
||||
assert.equal(cookies[0], c);
|
||||
|
||||
// same name, diff path, path specifity prevails, latter prevails
|
||||
var cookies = jar.get({ url: 'http://foo.com/foo/bar' });
|
||||
assert.equal(cookies.length, 1);
|
||||
assert.equal(cookies[0], b);
|
||||
|
||||
var jar = new Jar;
|
||||
var a = new Cookie('sid=1111; path=/foo/bar');
|
||||
var b = new Cookie('sid=1234; path=/');
|
||||
jar.add(a);
|
||||
jar.add(b);
|
||||
|
||||
var cookies = jar.get({ url: 'http://foo.com/foo/bar' });
|
||||
assert.equal(cookies.length, 1);
|
||||
assert.equal(cookies[0], a);
|
||||
|
||||
var cookies = jar.get({ url: 'http://foo.com/' });
|
||||
assert.equal(cookies.length, 1);
|
||||
assert.equal(cookies[0], b);
|
||||
|
||||
var jar = new Jar;
|
||||
var a = new Cookie('sid=1111; path=/foo/bar');
|
||||
var b = new Cookie('sid=3333; path=/foo/bar');
|
||||
var c = new Cookie('pid=3333; path=/foo/bar');
|
||||
var d = new Cookie('sid=2222; path=/foo/');
|
||||
var e = new Cookie('sid=1234; path=/');
|
||||
jar.add(a);
|
||||
jar.add(b);
|
||||
jar.add(c);
|
||||
jar.add(d);
|
||||
jar.add(e);
|
||||
|
||||
var cookies = jar.get({ url: 'http://foo.com/foo/bar' });
|
||||
assert.equal(cookies.length, 2);
|
||||
assert.equal(cookies[0], b);
|
||||
assert.equal(cookies[1], c);
|
||||
|
||||
var cookies = jar.get({ url: 'http://foo.com/foo/' });
|
||||
assert.equal(cookies.length, 1);
|
||||
assert.equal(cookies[0], d);
|
||||
|
||||
var cookies = jar.get({ url: 'http://foo.com/' });
|
||||
assert.equal(cookies.length, 1);
|
||||
assert.equal(cookies[0], e);
|
||||
})();
|
||||
|
||||
setTimeout(function() {
|
||||
console.log('All tests passed');
|
||||
}, 1200);
|
||||
-37
@@ -1,37 +0,0 @@
|
||||
var server = require('./server')
|
||||
, events = require('events')
|
||||
, assert = require('assert')
|
||||
, request = require('../main.js')
|
||||
;
|
||||
|
||||
var local = 'http://localhost:8888/asdf'
|
||||
|
||||
try {
|
||||
request({uri:local, body:{}})
|
||||
assert.fail("Should have throw")
|
||||
} catch(e) {
|
||||
assert.equal(e.message, 'Argument error, options.body.')
|
||||
}
|
||||
|
||||
try {
|
||||
request({uri:local, multipart: 'foo'})
|
||||
assert.fail("Should have throw")
|
||||
} catch(e) {
|
||||
assert.equal(e.message, 'Argument error, options.multipart.')
|
||||
}
|
||||
|
||||
try {
|
||||
request({uri:local, multipart: [{}]})
|
||||
assert.fail("Should have throw")
|
||||
} catch(e) {
|
||||
assert.equal(e.message, 'Body attribute missing in multipart.')
|
||||
}
|
||||
|
||||
try {
|
||||
request(local, {multipart: [{}]})
|
||||
assert.fail("Should have throw")
|
||||
} catch(e) {
|
||||
assert.equal(e.message, 'Body attribute missing in multipart.')
|
||||
}
|
||||
|
||||
console.log("All tests passed.")
|
||||
-117
@@ -1,117 +0,0 @@
|
||||
var hmacsign = require('../oauth').hmacsign
|
||||
, assert = require('assert')
|
||||
, qs = require('querystring')
|
||||
, request = require('../main')
|
||||
;
|
||||
|
||||
function getsignature (r) {
|
||||
var sign
|
||||
r.headers.Authorization.slice('OAuth '.length).replace(/,\ /g, ',').split(',').forEach(function (v) {
|
||||
if (v.slice(0, 'oauth_signature="'.length) === 'oauth_signature="') sign = v.slice('oauth_signature="'.length, -1)
|
||||
})
|
||||
return decodeURIComponent(sign)
|
||||
}
|
||||
|
||||
// Tests from Twitter documentation https://dev.twitter.com/docs/auth/oauth
|
||||
|
||||
var reqsign = hmacsign('POST', 'https://api.twitter.com/oauth/request_token',
|
||||
{ oauth_callback: 'http://localhost:3005/the_dance/process_callback?service_provider_id=11'
|
||||
, oauth_consumer_key: 'GDdmIQH6jhtmLUypg82g'
|
||||
, oauth_nonce: 'QP70eNmVz8jvdPevU3oJD2AfF7R7odC2XJcn4XlZJqk'
|
||||
, oauth_signature_method: 'HMAC-SHA1'
|
||||
, oauth_timestamp: '1272323042'
|
||||
, oauth_version: '1.0'
|
||||
}, "MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98")
|
||||
|
||||
console.log(reqsign)
|
||||
console.log('8wUi7m5HFQy76nowoCThusfgB+Q=')
|
||||
assert.equal(reqsign, '8wUi7m5HFQy76nowoCThusfgB+Q=')
|
||||
|
||||
var accsign = hmacsign('POST', 'https://api.twitter.com/oauth/access_token',
|
||||
{ oauth_consumer_key: 'GDdmIQH6jhtmLUypg82g'
|
||||
, oauth_nonce: '9zWH6qe0qG7Lc1telCn7FhUbLyVdjEaL3MO5uHxn8'
|
||||
, oauth_signature_method: 'HMAC-SHA1'
|
||||
, oauth_token: '8ldIZyxQeVrFZXFOZH5tAwj6vzJYuLQpl0WUEYtWc'
|
||||
, oauth_timestamp: '1272323047'
|
||||
, oauth_verifier: 'pDNg57prOHapMbhv25RNf75lVRd6JDsni1AJJIDYoTY'
|
||||
, oauth_version: '1.0'
|
||||
}, "MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98", "x6qpRnlEmW9JbQn4PQVVeVG8ZLPEx6A0TOebgwcuA")
|
||||
|
||||
console.log(accsign)
|
||||
console.log('PUw/dHA4fnlJYM6RhXk5IU/0fCc=')
|
||||
assert.equal(accsign, 'PUw/dHA4fnlJYM6RhXk5IU/0fCc=')
|
||||
|
||||
var upsign = hmacsign('POST', 'http://api.twitter.com/1/statuses/update.json',
|
||||
{ oauth_consumer_key: "GDdmIQH6jhtmLUypg82g"
|
||||
, oauth_nonce: "oElnnMTQIZvqvlfXM56aBLAf5noGD0AQR3Fmi7Q6Y"
|
||||
, oauth_signature_method: "HMAC-SHA1"
|
||||
, oauth_token: "819797-Jxq8aYUDRmykzVKrgoLhXSq67TEa5ruc4GJC2rWimw"
|
||||
, oauth_timestamp: "1272325550"
|
||||
, oauth_version: "1.0"
|
||||
, status: 'setting up my twitter 私のさえずりを設定する'
|
||||
}, "MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98", "J6zix3FfA9LofH0awS24M3HcBYXO5nI1iYe8EfBA")
|
||||
|
||||
console.log(upsign)
|
||||
console.log('yOahq5m0YjDDjfjxHaXEsW9D+X0=')
|
||||
assert.equal(upsign, 'yOahq5m0YjDDjfjxHaXEsW9D+X0=')
|
||||
|
||||
|
||||
var rsign = request.post(
|
||||
{ url: 'https://api.twitter.com/oauth/request_token'
|
||||
, oauth:
|
||||
{ callback: 'http://localhost:3005/the_dance/process_callback?service_provider_id=11'
|
||||
, consumer_key: 'GDdmIQH6jhtmLUypg82g'
|
||||
, nonce: 'QP70eNmVz8jvdPevU3oJD2AfF7R7odC2XJcn4XlZJqk'
|
||||
, timestamp: '1272323042'
|
||||
, version: '1.0'
|
||||
, consumer_secret: "MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98"
|
||||
}
|
||||
})
|
||||
|
||||
setTimeout(function () {
|
||||
console.log(getsignature(rsign))
|
||||
assert.equal(reqsign, getsignature(rsign))
|
||||
})
|
||||
|
||||
var raccsign = request.post(
|
||||
{ url: 'https://api.twitter.com/oauth/access_token'
|
||||
, oauth:
|
||||
{ consumer_key: 'GDdmIQH6jhtmLUypg82g'
|
||||
, nonce: '9zWH6qe0qG7Lc1telCn7FhUbLyVdjEaL3MO5uHxn8'
|
||||
, signature_method: 'HMAC-SHA1'
|
||||
, token: '8ldIZyxQeVrFZXFOZH5tAwj6vzJYuLQpl0WUEYtWc'
|
||||
, timestamp: '1272323047'
|
||||
, verifier: 'pDNg57prOHapMbhv25RNf75lVRd6JDsni1AJJIDYoTY'
|
||||
, version: '1.0'
|
||||
, consumer_secret: "MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98"
|
||||
, token_secret: "x6qpRnlEmW9JbQn4PQVVeVG8ZLPEx6A0TOebgwcuA"
|
||||
}
|
||||
})
|
||||
|
||||
setTimeout(function () {
|
||||
console.log(getsignature(raccsign))
|
||||
assert.equal(accsign, getsignature(raccsign))
|
||||
}, 1)
|
||||
|
||||
var rupsign = request.post(
|
||||
{ url: 'http://api.twitter.com/1/statuses/update.json'
|
||||
, oauth:
|
||||
{ consumer_key: "GDdmIQH6jhtmLUypg82g"
|
||||
, nonce: "oElnnMTQIZvqvlfXM56aBLAf5noGD0AQR3Fmi7Q6Y"
|
||||
, signature_method: "HMAC-SHA1"
|
||||
, token: "819797-Jxq8aYUDRmykzVKrgoLhXSq67TEa5ruc4GJC2rWimw"
|
||||
, timestamp: "1272325550"
|
||||
, version: "1.0"
|
||||
, consumer_secret: "MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98"
|
||||
, token_secret: "J6zix3FfA9LofH0awS24M3HcBYXO5nI1iYe8EfBA"
|
||||
}
|
||||
, form: {status: 'setting up my twitter 私のさえずりを設定する'}
|
||||
})
|
||||
setTimeout(function () {
|
||||
console.log(getsignature(rupsign))
|
||||
assert.equal(upsign, getsignature(rupsign))
|
||||
}, 1)
|
||||
|
||||
|
||||
|
||||
|
||||
-216
@@ -1,216 +0,0 @@
|
||||
var server = require('./server')
|
||||
, events = require('events')
|
||||
, stream = require('stream')
|
||||
, assert = require('assert')
|
||||
, fs = require('fs')
|
||||
, request = require('../main.js')
|
||||
, path = require('path')
|
||||
, util = require('util')
|
||||
;
|
||||
|
||||
var s = server.createServer(3453);
|
||||
|
||||
function ValidationStream(str) {
|
||||
this.str = str
|
||||
this.buf = ''
|
||||
this.on('data', function (data) {
|
||||
this.buf += data
|
||||
})
|
||||
this.on('end', function () {
|
||||
assert.equal(this.str, this.buf)
|
||||
})
|
||||
this.writable = true
|
||||
}
|
||||
util.inherits(ValidationStream, stream.Stream)
|
||||
ValidationStream.prototype.write = function (chunk) {
|
||||
this.emit('data', chunk)
|
||||
}
|
||||
ValidationStream.prototype.end = function (chunk) {
|
||||
if (chunk) emit('data', chunk)
|
||||
this.emit('end')
|
||||
}
|
||||
|
||||
s.listen(s.port, function () {
|
||||
counter = 0;
|
||||
|
||||
var check = function () {
|
||||
counter = counter - 1
|
||||
if (counter === 0) {
|
||||
console.log('All tests passed.')
|
||||
setTimeout(function () {
|
||||
process.exit();
|
||||
}, 500)
|
||||
}
|
||||
}
|
||||
|
||||
// Test pipeing to a request object
|
||||
s.once('/push', server.createPostValidator("mydata"));
|
||||
|
||||
var mydata = new stream.Stream();
|
||||
mydata.readable = true
|
||||
|
||||
counter++
|
||||
var r1 = request.put({url:'http://localhost:3453/push'}, function () {
|
||||
check();
|
||||
})
|
||||
mydata.pipe(r1)
|
||||
|
||||
mydata.emit('data', 'mydata');
|
||||
mydata.emit('end');
|
||||
|
||||
// Test pipeing to a request object with a json body
|
||||
s.once('/push-json', server.createPostValidator("{\"foo\":\"bar\"}", "application/json"));
|
||||
|
||||
var mybodydata = new stream.Stream();
|
||||
mybodydata.readable = true
|
||||
|
||||
counter++
|
||||
var r2 = request.put({url:'http://localhost:3453/push-json',json:true}, function () {
|
||||
check();
|
||||
})
|
||||
mybodydata.pipe(r2)
|
||||
|
||||
mybodydata.emit('data', JSON.stringify({foo:"bar"}));
|
||||
mybodydata.emit('end');
|
||||
|
||||
// Test pipeing from a request object.
|
||||
s.once('/pull', server.createGetResponse("mypulldata"));
|
||||
|
||||
var mypulldata = new stream.Stream();
|
||||
mypulldata.writable = true
|
||||
|
||||
counter++
|
||||
request({url:'http://localhost:3453/pull'}).pipe(mypulldata)
|
||||
|
||||
var d = '';
|
||||
|
||||
mypulldata.write = function (chunk) {
|
||||
d += chunk;
|
||||
}
|
||||
mypulldata.end = function () {
|
||||
assert.equal(d, 'mypulldata');
|
||||
check();
|
||||
};
|
||||
|
||||
|
||||
s.on('/cat', function (req, resp) {
|
||||
if (req.method === "GET") {
|
||||
resp.writeHead(200, {'content-type':'text/plain-test', 'content-length':4});
|
||||
resp.end('asdf')
|
||||
} else if (req.method === "PUT") {
|
||||
assert.equal(req.headers['content-type'], 'text/plain-test');
|
||||
assert.equal(req.headers['content-length'], 4)
|
||||
var validate = '';
|
||||
|
||||
req.on('data', function (chunk) {validate += chunk})
|
||||
req.on('end', function () {
|
||||
resp.writeHead(201);
|
||||
resp.end();
|
||||
assert.equal(validate, 'asdf');
|
||||
check();
|
||||
})
|
||||
}
|
||||
})
|
||||
s.on('/pushjs', function (req, resp) {
|
||||
if (req.method === "PUT") {
|
||||
assert.equal(req.headers['content-type'], 'application/javascript');
|
||||
check();
|
||||
}
|
||||
})
|
||||
s.on('/catresp', function (req, resp) {
|
||||
request.get('http://localhost:3453/cat').pipe(resp)
|
||||
})
|
||||
s.on('/doodle', function (req, resp) {
|
||||
if (req.headers['x-oneline-proxy']) {
|
||||
resp.setHeader('x-oneline-proxy', 'yup')
|
||||
}
|
||||
resp.writeHead('200', {'content-type':'image/png'})
|
||||
fs.createReadStream(path.join(__dirname, 'googledoodle.png')).pipe(resp)
|
||||
})
|
||||
s.on('/onelineproxy', function (req, resp) {
|
||||
var x = request('http://localhost:3453/doodle')
|
||||
req.pipe(x)
|
||||
x.pipe(resp)
|
||||
})
|
||||
|
||||
counter++
|
||||
fs.createReadStream(__filename).pipe(request.put('http://localhost:3453/pushjs'))
|
||||
|
||||
counter++
|
||||
request.get('http://localhost:3453/cat').pipe(request.put('http://localhost:3453/cat'))
|
||||
|
||||
counter++
|
||||
request.get('http://localhost:3453/catresp', function (e, resp, body) {
|
||||
assert.equal(resp.headers['content-type'], 'text/plain-test');
|
||||
assert.equal(resp.headers['content-length'], 4)
|
||||
check();
|
||||
})
|
||||
|
||||
var doodleWrite = fs.createWriteStream(path.join(__dirname, 'test.png'))
|
||||
|
||||
counter++
|
||||
request.get('http://localhost:3453/doodle').pipe(doodleWrite)
|
||||
|
||||
doodleWrite.on('close', function () {
|
||||
assert.deepEqual(fs.readFileSync(path.join(__dirname, 'googledoodle.png')), fs.readFileSync(path.join(__dirname, 'test.png')))
|
||||
check()
|
||||
})
|
||||
|
||||
process.on('exit', function () {
|
||||
fs.unlinkSync(path.join(__dirname, 'test.png'))
|
||||
})
|
||||
|
||||
counter++
|
||||
request.get({uri:'http://localhost:3453/onelineproxy', headers:{'x-oneline-proxy':'nope'}}, function (err, resp, body) {
|
||||
assert.equal(resp.headers['x-oneline-proxy'], 'yup')
|
||||
check()
|
||||
})
|
||||
|
||||
s.on('/afterresponse', function (req, resp) {
|
||||
resp.write('d')
|
||||
resp.end()
|
||||
})
|
||||
|
||||
counter++
|
||||
var afterresp = request.post('http://localhost:3453/afterresponse').on('response', function () {
|
||||
var v = new ValidationStream('d')
|
||||
afterresp.pipe(v)
|
||||
v.on('end', check)
|
||||
})
|
||||
|
||||
s.on('/forward1', function (req, resp) {
|
||||
resp.writeHead(302, {location:'/forward2'})
|
||||
resp.end()
|
||||
})
|
||||
s.on('/forward2', function (req, resp) {
|
||||
resp.writeHead('200', {'content-type':'image/png'})
|
||||
resp.write('d')
|
||||
resp.end()
|
||||
})
|
||||
|
||||
counter++
|
||||
var validateForward = new ValidationStream('d')
|
||||
validateForward.on('end', check)
|
||||
request.get('http://localhost:3453/forward1').pipe(validateForward)
|
||||
|
||||
// Test pipe options
|
||||
s.once('/opts', server.createGetResponse('opts response'));
|
||||
|
||||
var optsStream = new stream.Stream();
|
||||
optsStream.writable = true
|
||||
|
||||
var optsData = '';
|
||||
optsStream.write = function (buf) {
|
||||
optsData += buf;
|
||||
if (optsData === 'opts response') {
|
||||
setTimeout(check, 10);
|
||||
}
|
||||
}
|
||||
|
||||
optsStream.end = function () {
|
||||
assert.fail('end called')
|
||||
};
|
||||
|
||||
counter++
|
||||
request({url:'http://localhost:3453/opts'}).pipe(optsStream, { end : false })
|
||||
})
|
||||
-39
@@ -1,39 +0,0 @@
|
||||
var server = require('./server')
|
||||
, events = require('events')
|
||||
, stream = require('stream')
|
||||
, assert = require('assert')
|
||||
, fs = require('fs')
|
||||
, request = require('../main.js')
|
||||
, path = require('path')
|
||||
, util = require('util')
|
||||
;
|
||||
|
||||
var port = 6768
|
||||
, called = false
|
||||
, proxiedHost = 'google.com'
|
||||
;
|
||||
|
||||
var s = server.createServer(port)
|
||||
s.listen(port, function () {
|
||||
s.on('http://google.com/', function (req, res) {
|
||||
called = true
|
||||
assert.equal(req.headers.host, proxiedHost)
|
||||
res.writeHeader(200)
|
||||
res.end()
|
||||
})
|
||||
request ({
|
||||
url: 'http://'+proxiedHost,
|
||||
proxy: 'http://localhost:'+port
|
||||
/*
|
||||
//should behave as if these arguments where passed:
|
||||
url: 'http://localhost:'+port,
|
||||
headers: {host: proxiedHost}
|
||||
//*/
|
||||
}, function (err, res, body) {
|
||||
s.close()
|
||||
})
|
||||
})
|
||||
|
||||
process.on('exit', function () {
|
||||
assert.ok(called, 'the request must be made to the proxy server')
|
||||
})
|
||||
-87
@@ -1,87 +0,0 @@
|
||||
var server = require('./server')
|
||||
, events = require('events')
|
||||
, stream = require('stream')
|
||||
, assert = require('assert')
|
||||
, request = require('../main.js')
|
||||
;
|
||||
|
||||
var s = server.createServer();
|
||||
var expectedBody = "waited";
|
||||
var remainingTests = 5;
|
||||
|
||||
s.listen(s.port, function () {
|
||||
// Request that waits for 200ms
|
||||
s.on('/timeout', function (req, resp) {
|
||||
setTimeout(function(){
|
||||
resp.writeHead(200, {'content-type':'text/plain'})
|
||||
resp.write(expectedBody)
|
||||
resp.end()
|
||||
}, 200);
|
||||
});
|
||||
|
||||
// Scenario that should timeout
|
||||
var shouldTimeout = {
|
||||
url: s.url + "/timeout",
|
||||
timeout:100
|
||||
}
|
||||
|
||||
|
||||
request(shouldTimeout, function (err, resp, body) {
|
||||
assert.equal(err.code, "ETIMEDOUT");
|
||||
checkDone();
|
||||
})
|
||||
|
||||
|
||||
// Scenario that shouldn't timeout
|
||||
var shouldntTimeout = {
|
||||
url: s.url + "/timeout",
|
||||
timeout:300
|
||||
}
|
||||
|
||||
request(shouldntTimeout, function (err, resp, body) {
|
||||
assert.equal(err, null);
|
||||
assert.equal(expectedBody, body)
|
||||
checkDone();
|
||||
})
|
||||
|
||||
// Scenario with no timeout set, so shouldn't timeout
|
||||
var noTimeout = {
|
||||
url: s.url + "/timeout"
|
||||
}
|
||||
|
||||
request(noTimeout, function (err, resp, body) {
|
||||
assert.equal(err);
|
||||
assert.equal(expectedBody, body)
|
||||
checkDone();
|
||||
})
|
||||
|
||||
// Scenario with a negative timeout value, should be treated a zero or the minimum delay
|
||||
var negativeTimeout = {
|
||||
url: s.url + "/timeout",
|
||||
timeout:-1000
|
||||
}
|
||||
|
||||
request(negativeTimeout, function (err, resp, body) {
|
||||
assert.equal(err.code, "ETIMEDOUT");
|
||||
checkDone();
|
||||
})
|
||||
|
||||
// Scenario with a float timeout value, should be rounded by setTimeout anyway
|
||||
var floatTimeout = {
|
||||
url: s.url + "/timeout",
|
||||
timeout: 100.76
|
||||
}
|
||||
|
||||
request(floatTimeout, function (err, resp, body) {
|
||||
assert.equal(err.code, "ETIMEDOUT");
|
||||
checkDone();
|
||||
})
|
||||
|
||||
function checkDone() {
|
||||
if(--remainingTests == 0) {
|
||||
s.close();
|
||||
console.log("All tests passed.");
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
-19
@@ -1,19 +0,0 @@
|
||||
module.exports = function () {
|
||||
var s = [], itoh = '0123456789ABCDEF'
|
||||
|
||||
// Make array of random hex digits. The UUID only has 32 digits in it, but we
|
||||
// allocate an extra items to make room for the '-'s we'll be inserting.
|
||||
for (var i = 0; i <36; i++) s[i] = Math.floor(Math.random()*0x10)
|
||||
|
||||
// Conform to RFC-4122, section 4.4
|
||||
s[14] = 4; // Set 4 high bits of time_high field to version
|
||||
s[19] = (s[19] & 0x3) | 0x8 // Specify 2 high bits of clock sequence
|
||||
|
||||
// Convert to hex chars
|
||||
for (var i = 0; i <36; i++) s[i] = itoh[s[i]]
|
||||
|
||||
// Insert '-'s
|
||||
s[8] = s[13] = s[18] = s[23] = '-'
|
||||
|
||||
return s.join('')
|
||||
}
|
||||
-65
@@ -1,65 +0,0 @@
|
||||
/*!
|
||||
* Tobi - Cookie
|
||||
* Copyright(c) 2010 LearnBoost <dev@learnboost.com>
|
||||
* MIT Licensed
|
||||
*/
|
||||
|
||||
/**
|
||||
* Module dependencies.
|
||||
*/
|
||||
|
||||
var url = require('url');
|
||||
|
||||
/**
|
||||
* Initialize a new `Cookie` with the given cookie `str` and `req`.
|
||||
*
|
||||
* @param {String} str
|
||||
* @param {IncomingRequest} req
|
||||
* @api private
|
||||
*/
|
||||
|
||||
var Cookie = exports = module.exports = function Cookie(str, req) {
|
||||
this.str = str;
|
||||
|
||||
// Map the key/val pairs
|
||||
str.split(/ *; */).reduce(function(obj, pair){
|
||||
var p = pair.indexOf('=');
|
||||
var key = p > 0 ? pair.substring(0, p).trim() : pair.trim();
|
||||
var lowerCasedKey = key.toLowerCase();
|
||||
var value = p > 0 ? pair.substring(p + 1).trim() : true;
|
||||
|
||||
if (!obj.name) {
|
||||
// First key is the name
|
||||
obj.name = key;
|
||||
obj.value = value;
|
||||
}
|
||||
else if (lowerCasedKey === 'httponly') {
|
||||
obj.httpOnly = value;
|
||||
}
|
||||
else {
|
||||
obj[lowerCasedKey] = value;
|
||||
}
|
||||
return obj;
|
||||
}, this);
|
||||
|
||||
// Expires
|
||||
this.expires = this.expires
|
||||
? new Date(this.expires)
|
||||
: Infinity;
|
||||
|
||||
// Default or trim path
|
||||
this.path = this.path
|
||||
? this.path.trim(): req
|
||||
? url.parse(req.url).pathname: '/';
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the original cookie string.
|
||||
*
|
||||
* @return {String}
|
||||
* @api public
|
||||
*/
|
||||
|
||||
Cookie.prototype.toString = function(){
|
||||
return this.str;
|
||||
};
|
||||
-72
@@ -1,72 +0,0 @@
|
||||
/*!
|
||||
* Tobi - CookieJar
|
||||
* Copyright(c) 2010 LearnBoost <dev@learnboost.com>
|
||||
* MIT Licensed
|
||||
*/
|
||||
|
||||
/**
|
||||
* Module dependencies.
|
||||
*/
|
||||
|
||||
var url = require('url');
|
||||
|
||||
/**
|
||||
* Initialize a new `CookieJar`.
|
||||
*
|
||||
* @api private
|
||||
*/
|
||||
|
||||
var CookieJar = exports = module.exports = function CookieJar() {
|
||||
this.cookies = [];
|
||||
};
|
||||
|
||||
/**
|
||||
* Add the given `cookie` to the jar.
|
||||
*
|
||||
* @param {Cookie} cookie
|
||||
* @api private
|
||||
*/
|
||||
|
||||
CookieJar.prototype.add = function(cookie){
|
||||
this.cookies = this.cookies.filter(function(c){
|
||||
// Avoid duplication (same path, same name)
|
||||
return !(c.name == cookie.name && c.path == cookie.path);
|
||||
});
|
||||
this.cookies.push(cookie);
|
||||
};
|
||||
|
||||
/**
|
||||
* Get cookies for the given `req`.
|
||||
*
|
||||
* @param {IncomingRequest} req
|
||||
* @return {Array}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
CookieJar.prototype.get = function(req){
|
||||
var path = url.parse(req.url).pathname
|
||||
, now = new Date
|
||||
, specificity = {};
|
||||
return this.cookies.filter(function(cookie){
|
||||
if (0 == path.indexOf(cookie.path) && now < cookie.expires
|
||||
&& cookie.path.length > (specificity[cookie.name] || 0))
|
||||
return specificity[cookie.name] = cookie.path.length;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Return Cookie string for the given `req`.
|
||||
*
|
||||
* @param {IncomingRequest} req
|
||||
* @return {String}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
CookieJar.prototype.cookieString = function(req){
|
||||
var cookies = this.get(req);
|
||||
if (cookies.length) {
|
||||
return cookies.map(function(cookie){
|
||||
return cookie.name + '=' + cookie.value;
|
||||
}).join('; ');
|
||||
}
|
||||
};
|
||||
Reference in New Issue
Block a user