You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by lo...@apache.org on 2013/05/07 17:24:18 UTC
[13/51] [partial] [BlackBerry10] Added support for new platform
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/.bin/jake
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/.bin/jake b/lib/cordova-blackberry/blackberry10/node_modules/.bin/jake
new file mode 120000
index 0000000..3626745
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/.bin/jake
@@ -0,0 +1 @@
+../jake/bin/cli.js
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/.bin/jasmine-node
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/.bin/jasmine-node b/lib/cordova-blackberry/blackberry10/node_modules/.bin/jasmine-node
new file mode 120000
index 0000000..a1c6532
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/.bin/jasmine-node
@@ -0,0 +1 @@
+../jasmine-node/bin/jasmine-node
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/.bin/plugman
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/.bin/plugman b/lib/cordova-blackberry/blackberry10/node_modules/.bin/plugman
new file mode 120000
index 0000000..0c2fecb
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/.bin/plugman
@@ -0,0 +1 @@
+../plugman/plugman.js
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/.bin/xlocalize
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/.bin/xlocalize b/lib/cordova-blackberry/blackberry10/node_modules/.bin/xlocalize
new file mode 120000
index 0000000..34f4a5d
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/.bin/xlocalize
@@ -0,0 +1 @@
+../localize/bin/xlocalize.js
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/.npmignore
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/.npmignore b/lib/cordova-blackberry/blackberry10/node_modules/commander/.npmignore
new file mode 100644
index 0000000..f1250e5
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/.npmignore
@@ -0,0 +1,4 @@
+support
+test
+examples
+*.sock
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/.travis.yml
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/.travis.yml b/lib/cordova-blackberry/blackberry10/node_modules/commander/.travis.yml
new file mode 100644
index 0000000..f1d0f13
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/.travis.yml
@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+ - 0.4
+ - 0.6
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/History.md
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/History.md b/lib/cordova-blackberry/blackberry10/node_modules/commander/History.md
new file mode 100644
index 0000000..4961d2e
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/History.md
@@ -0,0 +1,107 @@
+
+0.6.1 / 2012-06-01
+==================
+
+ * Added: append (yes or no) on confirmation
+ * Added: allow node.js v0.7.x
+
+0.6.0 / 2012-04-10
+==================
+
+ * Added `.prompt(obj, callback)` support. Closes #49
+ * Added default support to .choose(). Closes #41
+ * Fixed the choice example
+
+0.5.1 / 2011-12-20
+==================
+
+ * Fixed `password()` for recent nodes. Closes #36
+
+0.5.0 / 2011-12-04
+==================
+
+ * Added sub-command option support [itay]
+
+0.4.3 / 2011-12-04
+==================
+
+ * Fixed custom help ordering. Closes #32
+
+0.4.2 / 2011-11-24
+==================
+
+ * Added travis support
+ * Fixed: line-buffered input automatically trimmed. Closes #31
+
+0.4.1 / 2011-11-18
+==================
+
+ * Removed listening for "close" on --help
+
+0.4.0 / 2011-11-15
+==================
+
+ * Added support for `--`. Closes #24
+
+0.3.3 / 2011-11-14
+==================
+
+ * Fixed: wait for close event when writing help info [Jerry Hamlet]
+
+0.3.2 / 2011-11-01
+==================
+
+ * Fixed long flag definitions with values [felixge]
+
+0.3.1 / 2011-10-31
+==================
+
+ * Changed `--version` short flag to `-V` from `-v`
+ * Changed `.version()` so it's configurable [felixge]
+
+0.3.0 / 2011-10-31
+==================
+
+ * Added support for long flags only. Closes #18
+
+0.2.1 / 2011-10-24
+==================
+
+ * "node": ">= 0.4.x < 0.7.0". Closes #20
+
+0.2.0 / 2011-09-26
+==================
+
+ * Allow for defaults that are not just boolean. Default peassignment only occurs for --no-*, optional, and required arguments. [Jim Isaacs]
+
+0.1.0 / 2011-08-24
+==================
+
+ * Added support for custom `--help` output
+
+0.0.5 / 2011-08-18
+==================
+
+ * Changed: when the user enters nothing prompt for password again
+ * Fixed issue with passwords beginning with numbers [NuckChorris]
+
+0.0.4 / 2011-08-15
+==================
+
+ * Fixed `Commander#args`
+
+0.0.3 / 2011-08-15
+==================
+
+ * Added default option value support
+
+0.0.2 / 2011-08-15
+==================
+
+ * Added mask support to `Command#password(str[, mask], fn)`
+ * Added `Command#password(str, fn)`
+
+0.0.1 / 2010-01-03
+==================
+
+ * Initial release
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/Makefile
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/Makefile b/lib/cordova-blackberry/blackberry10/node_modules/commander/Makefile
new file mode 100644
index 0000000..0074625
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/Makefile
@@ -0,0 +1,7 @@
+
+TESTS = $(shell find test/test.*.js)
+
+test:
+ @./test/run $(TESTS)
+
+.PHONY: test
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/Readme.md
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/Readme.md b/lib/cordova-blackberry/blackberry10/node_modules/commander/Readme.md
new file mode 100644
index 0000000..b8328c3
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/Readme.md
@@ -0,0 +1,262 @@
+# Commander.js
+
+ The complete solution for [node.js](http://nodejs.org) command-line interfaces, inspired by Ruby's [commander](https://github.com/visionmedia/commander).
+
+ [](http://travis-ci.org/visionmedia/commander.js)
+
+## Installation
+
+ $ npm install commander
+
+## Option parsing
+
+ Options with commander are defined with the `.option()` method, also serving as documentation for the options. The example below parses args and options from `process.argv`, leaving remaining args as the `program.args` array which were not consumed by options.
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('commander');
+
+program
+ .version('0.0.1')
+ .option('-p, --peppers', 'Add peppers')
+ .option('-P, --pineapple', 'Add pineapple')
+ .option('-b, --bbq', 'Add bbq sauce')
+ .option('-c, --cheese [type]', 'Add the specified type of cheese [marble]', 'marble')
+ .parse(process.argv);
+
+console.log('you ordered a pizza with:');
+if (program.peppers) console.log(' - peppers');
+if (program.pineapple) console.log(' - pineappe');
+if (program.bbq) console.log(' - bbq');
+console.log(' - %s cheese', program.cheese);
+```
+
+ Short flags may be passed as a single arg, for example `-abc` is equivalent to `-a -b -c`. Multi-word options such as "--template-engine" are camel-cased, becoming `program.templateEngine` etc.
+
+## Automated --help
+
+ The help information is auto-generated based on the information commander already knows about your program, so the following `--help` info is for free:
+
+```
+ $ ./examples/pizza --help
+
+ Usage: pizza [options]
+
+ Options:
+
+ -V, --version output the version number
+ -p, --peppers Add peppers
+ -P, --pineapple Add pineappe
+ -b, --bbq Add bbq sauce
+ -c, --cheese <type> Add the specified type of cheese [marble]
+ -h, --help output usage information
+
+```
+
+## Coercion
+
+```js
+function range(val) {
+ return val.split('..').map(Number);
+}
+
+function list(val) {
+ return val.split(',');
+}
+
+program
+ .version('0.0.1')
+ .usage('[options] <file ...>')
+ .option('-i, --integer <n>', 'An integer argument', parseInt)
+ .option('-f, --float <n>', 'A float argument', parseFloat)
+ .option('-r, --range <a>..<b>', 'A range', range)
+ .option('-l, --list <items>', 'A list', list)
+ .option('-o, --optional [value]', 'An optional value')
+ .parse(process.argv);
+
+console.log(' int: %j', program.integer);
+console.log(' float: %j', program.float);
+console.log(' optional: %j', program.optional);
+program.range = program.range || [];
+console.log(' range: %j..%j', program.range[0], program.range[1]);
+console.log(' list: %j', program.list);
+console.log(' args: %j', program.args);
+```
+
+## Custom help
+
+ You can display arbitrary `-h, --help` information
+ by listening for "--help". Commander will automatically
+ exit once you are done so that the remainder of your program
+ does not execute causing undesired behaviours, for example
+ in the following executable "stuff" will not output when
+ `--help` is used.
+
+```js
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var program = require('../');
+
+function list(val) {
+ return val.split(',').map(Number);
+}
+
+program
+ .version('0.0.1')
+ .option('-f, --foo', 'enable some foo')
+ .option('-b, --bar', 'enable some bar')
+ .option('-B, --baz', 'enable some baz');
+
+// must be before .parse() since
+// node's emit() is immediate
+
+program.on('--help', function(){
+ console.log(' Examples:');
+ console.log('');
+ console.log(' $ custom-help --help');
+ console.log(' $ custom-help -h');
+ console.log('');
+});
+
+program.parse(process.argv);
+
+console.log('stuff');
+```
+
+yielding the following help output:
+
+```
+
+Usage: custom-help [options]
+
+Options:
+
+ -h, --help output usage information
+ -V, --version output the version number
+ -f, --foo enable some foo
+ -b, --bar enable some bar
+ -B, --baz enable some baz
+
+Examples:
+
+ $ custom-help --help
+ $ custom-help -h
+
+```
+
+## .prompt(msg, fn)
+
+ Single-line prompt:
+
+```js
+program.prompt('name: ', function(name){
+ console.log('hi %s', name);
+});
+```
+
+ Multi-line prompt:
+
+```js
+program.prompt('description:', function(name){
+ console.log('hi %s', name);
+});
+```
+
+ Coercion:
+
+```js
+program.prompt('Age: ', Number, function(age){
+ console.log('age: %j', age);
+});
+```
+
+```js
+program.prompt('Birthdate: ', Date, function(date){
+ console.log('date: %s', date);
+});
+```
+
+## .password(msg[, mask], fn)
+
+Prompt for password without echoing:
+
+```js
+program.password('Password: ', function(pass){
+ console.log('got "%s"', pass);
+ process.stdin.destroy();
+});
+```
+
+Prompt for password with mask char "*":
+
+```js
+program.password('Password: ', '*', function(pass){
+ console.log('got "%s"', pass);
+ process.stdin.destroy();
+});
+```
+
+## .confirm(msg, fn)
+
+ Confirm with the given `msg`:
+
+```js
+program.confirm('continue? ', function(ok){
+ console.log(' got %j', ok);
+});
+```
+
+## .choose(list, fn)
+
+ Let the user choose from a `list`:
+
+```js
+var list = ['tobi', 'loki', 'jane', 'manny', 'luna'];
+
+console.log('Choose the coolest pet:');
+program.choose(list, function(i){
+ console.log('you chose %d "%s"', i, list[i]);
+});
+```
+
+## Links
+
+ - [API documentation](http://visionmedia.github.com/commander.js/)
+ - [ascii tables](https://github.com/LearnBoost/cli-table)
+ - [progress bars](https://github.com/visionmedia/node-progress)
+ - [more progress bars](https://github.com/substack/node-multimeter)
+ - [examples](https://github.com/visionmedia/commander.js/tree/master/examples)
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/index.js
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/index.js b/lib/cordova-blackberry/blackberry10/node_modules/commander/index.js
new file mode 100644
index 0000000..06ec1e4
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/index.js
@@ -0,0 +1,2 @@
+
+module.exports = require('./lib/commander');
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/lib/commander.js
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/lib/commander.js b/lib/cordova-blackberry/blackberry10/node_modules/commander/lib/commander.js
new file mode 100644
index 0000000..5ba87eb
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/lib/commander.js
@@ -0,0 +1,1026 @@
+
+/*!
+ * commander
+ * Copyright(c) 2011 TJ Holowaychuk <tj...@vision-media.ca>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var EventEmitter = require('events').EventEmitter
+ , path = require('path')
+ , tty = require('tty')
+ , basename = path.basename;
+
+/**
+ * Expose the root command.
+ */
+
+exports = module.exports = new Command;
+
+/**
+ * Expose `Command`.
+ */
+
+exports.Command = Command;
+
+/**
+ * Expose `Option`.
+ */
+
+exports.Option = Option;
+
+/**
+ * Initialize a new `Option` with the given `flags` and `description`.
+ *
+ * @param {String} flags
+ * @param {String} description
+ * @api public
+ */
+
+function Option(flags, description) {
+ this.flags = flags;
+ this.required = ~flags.indexOf('<');
+ this.optional = ~flags.indexOf('[');
+ this.bool = !~flags.indexOf('-no-');
+ flags = flags.split(/[ ,|]+/);
+ if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift();
+ this.long = flags.shift();
+ this.description = description;
+}
+
+/**
+ * Return option name.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Option.prototype.name = function(){
+ return this.long
+ .replace('--', '')
+ .replace('no-', '');
+};
+
+/**
+ * Check if `arg` matches the short or long flag.
+ *
+ * @param {String} arg
+ * @return {Boolean}
+ * @api private
+ */
+
+Option.prototype.is = function(arg){
+ return arg == this.short
+ || arg == this.long;
+};
+
+/**
+ * Initialize a new `Command`.
+ *
+ * @param {String} name
+ * @api public
+ */
+
+function Command(name) {
+ this.commands = [];
+ this.options = [];
+ this.args = [];
+ this.name = name;
+}
+
+/**
+ * Inherit from `EventEmitter.prototype`.
+ */
+
+Command.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Add command `name`.
+ *
+ * The `.action()` callback is invoked when the
+ * command `name` is specified via __ARGV__,
+ * and the remaining arguments are applied to the
+ * function for access.
+ *
+ * When the `name` is "*" an un-matched command
+ * will be passed as the first arg, followed by
+ * the rest of __ARGV__ remaining.
+ *
+ * Examples:
+ *
+ * program
+ * .version('0.0.1')
+ * .option('-C, --chdir <path>', 'change the working directory')
+ * .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
+ * .option('-T, --no-tests', 'ignore test hook')
+ *
+ * program
+ * .command('setup')
+ * .description('run remote setup commands')
+ * .action(function(){
+ * console.log('setup');
+ * });
+ *
+ * program
+ * .command('exec <cmd>')
+ * .description('run the given remote command')
+ * .action(function(cmd){
+ * console.log('exec "%s"', cmd);
+ * });
+ *
+ * program
+ * .command('*')
+ * .description('deploy the given env')
+ * .action(function(env){
+ * console.log('deploying "%s"', env);
+ * });
+ *
+ * program.parse(process.argv);
+ *
+ * @param {String} name
+ * @return {Command} the new command
+ * @api public
+ */
+
+Command.prototype.command = function(name){
+ var args = name.split(/ +/);
+ var cmd = new Command(args.shift());
+ this.commands.push(cmd);
+ cmd.parseExpectedArgs(args);
+ cmd.parent = this;
+ return cmd;
+};
+
+/**
+ * Parse expected `args`.
+ *
+ * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
+ *
+ * @param {Array} args
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.parseExpectedArgs = function(args){
+ if (!args.length) return;
+ var self = this;
+ args.forEach(function(arg){
+ switch (arg[0]) {
+ case '<':
+ self.args.push({ required: true, name: arg.slice(1, -1) });
+ break;
+ case '[':
+ self.args.push({ required: false, name: arg.slice(1, -1) });
+ break;
+ }
+ });
+ return this;
+};
+
+/**
+ * Register callback `fn` for the command.
+ *
+ * Examples:
+ *
+ * program
+ * .command('help')
+ * .description('display verbose help')
+ * .action(function(){
+ * // output help here
+ * });
+ *
+ * @param {Function} fn
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.action = function(fn){
+ var self = this;
+ this.parent.on(this.name, function(args, unknown){
+ // Parse any so-far unknown options
+ unknown = unknown || [];
+ var parsed = self.parseOptions(unknown);
+
+ // Output help if necessary
+ outputHelpIfNecessary(self, parsed.unknown);
+
+ // If there are still any unknown options, then we simply
+ // die, unless someone asked for help, in which case we give it
+ // to them, and then we die.
+ if (parsed.unknown.length > 0) {
+ self.unknownOption(parsed.unknown[0]);
+ }
+
+ self.args.forEach(function(arg, i){
+ if (arg.required && null == args[i]) {
+ self.missingArgument(arg.name);
+ }
+ });
+
+ // Always append ourselves to the end of the arguments,
+ // to make sure we match the number of arguments the user
+ // expects
+ if (self.args.length) {
+ args[self.args.length] = self;
+ } else {
+ args.push(self);
+ }
+
+ fn.apply(this, args);
+ });
+ return this;
+};
+
+/**
+ * Define option with `flags`, `description` and optional
+ * coercion `fn`.
+ *
+ * The `flags` string should contain both the short and long flags,
+ * separated by comma, a pipe or space. The following are all valid
+ * all will output this way when `--help` is used.
+ *
+ * "-p, --pepper"
+ * "-p|--pepper"
+ * "-p --pepper"
+ *
+ * Examples:
+ *
+ * // simple boolean defaulting to false
+ * program.option('-p, --pepper', 'add pepper');
+ *
+ * --pepper
+ * program.pepper
+ * // => Boolean
+ *
+ * // simple boolean defaulting to false
+ * program.option('-C, --no-cheese', 'remove cheese');
+ *
+ * program.cheese
+ * // => true
+ *
+ * --no-cheese
+ * program.cheese
+ * // => true
+ *
+ * // required argument
+ * program.option('-C, --chdir <path>', 'change the working directory');
+ *
+ * --chdir /tmp
+ * program.chdir
+ * // => "/tmp"
+ *
+ * // optional argument
+ * program.option('-c, --cheese [type]', 'add cheese [marble]');
+ *
+ * @param {String} flags
+ * @param {String} description
+ * @param {Function|Mixed} fn or default
+ * @param {Mixed} defaultValue
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.option = function(flags, description, fn, defaultValue){
+ var self = this
+ , option = new Option(flags, description)
+ , oname = option.name()
+ , name = camelcase(oname);
+
+ // default as 3rd arg
+ if ('function' != typeof fn) defaultValue = fn, fn = null;
+
+ // preassign default value only for --no-*, [optional], or <required>
+ if (false == option.bool || option.optional || option.required) {
+ // when --no-* we make sure default is true
+ if (false == option.bool) defaultValue = true;
+ // preassign only if we have a default
+ if (undefined !== defaultValue) self[name] = defaultValue;
+ }
+
+ // register the option
+ this.options.push(option);
+
+ // when it's passed assign the value
+ // and conditionally invoke the callback
+ this.on(oname, function(val){
+ // coercion
+ if (null != val && fn) val = fn(val);
+
+ // unassigned or bool
+ if ('boolean' == typeof self[name] || 'undefined' == typeof self[name]) {
+ // if no value, bool true, and we have a default, then use it!
+ if (null == val) {
+ self[name] = option.bool
+ ? defaultValue || true
+ : false;
+ } else {
+ self[name] = val;
+ }
+ } else if (null !== val) {
+ // reassign
+ self[name] = val;
+ }
+ });
+
+ return this;
+};
+
+/**
+ * Parse `argv`, settings options and invoking commands when defined.
+ *
+ * @param {Array} argv
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.parse = function(argv){
+ // store raw args
+ this.rawArgs = argv;
+
+ // guess name
+ if (!this.name) this.name = basename(argv[1]);
+
+ // process argv
+ var parsed = this.parseOptions(this.normalize(argv.slice(2)));
+ this.args = parsed.args;
+ return this.parseArgs(this.args, parsed.unknown);
+};
+
+/**
+ * Normalize `args`, splitting joined short flags. For example
+ * the arg "-abc" is equivalent to "-a -b -c".
+ *
+ * @param {Array} args
+ * @return {Array}
+ * @api private
+ */
+
+Command.prototype.normalize = function(args){
+ var ret = []
+ , arg;
+
+ for (var i = 0, len = args.length; i < len; ++i) {
+ arg = args[i];
+ if (arg.length > 1 && '-' == arg[0] && '-' != arg[1]) {
+ arg.slice(1).split('').forEach(function(c){
+ ret.push('-' + c);
+ });
+ } else {
+ ret.push(arg);
+ }
+ }
+
+ return ret;
+};
+
+/**
+ * Parse command `args`.
+ *
+ * When listener(s) are available those
+ * callbacks are invoked, otherwise the "*"
+ * event is emitted and those actions are invoked.
+ *
+ * @param {Array} args
+ * @return {Command} for chaining
+ * @api private
+ */
+
+Command.prototype.parseArgs = function(args, unknown){
+ var cmds = this.commands
+ , len = cmds.length
+ , name;
+
+ if (args.length) {
+ name = args[0];
+ if (this.listeners(name).length) {
+ this.emit(args.shift(), args, unknown);
+ } else {
+ this.emit('*', args);
+ }
+ } else {
+ outputHelpIfNecessary(this, unknown);
+
+ // If there were no args and we have unknown options,
+ // then they are extraneous and we need to error.
+ if (unknown.length > 0) {
+ this.unknownOption(unknown[0]);
+ }
+ }
+
+ return this;
+};
+
+/**
+ * Return an option matching `arg` if any.
+ *
+ * @param {String} arg
+ * @return {Option}
+ * @api private
+ */
+
+Command.prototype.optionFor = function(arg){
+ for (var i = 0, len = this.options.length; i < len; ++i) {
+ if (this.options[i].is(arg)) {
+ return this.options[i];
+ }
+ }
+};
+
+/**
+ * Parse options from `argv` returning `argv`
+ * void of these options.
+ *
+ * @param {Array} argv
+ * @return {Array}
+ * @api public
+ */
+
+Command.prototype.parseOptions = function(argv){
+ var args = []
+ , len = argv.length
+ , literal
+ , option
+ , arg;
+
+ var unknownOptions = [];
+
+ // parse options
+ for (var i = 0; i < len; ++i) {
+ arg = argv[i];
+
+ // literal args after --
+ if ('--' == arg) {
+ literal = true;
+ continue;
+ }
+
+ if (literal) {
+ args.push(arg);
+ continue;
+ }
+
+ // find matching Option
+ option = this.optionFor(arg);
+
+ // option is defined
+ if (option) {
+ // requires arg
+ if (option.required) {
+ arg = argv[++i];
+ if (null == arg) return this.optionMissingArgument(option);
+ if ('-' == arg[0]) return this.optionMissingArgument(option, arg);
+ this.emit(option.name(), arg);
+ // optional arg
+ } else if (option.optional) {
+ arg = argv[i+1];
+ if (null == arg || '-' == arg[0]) {
+ arg = null;
+ } else {
+ ++i;
+ }
+ this.emit(option.name(), arg);
+ // bool
+ } else {
+ this.emit(option.name());
+ }
+ continue;
+ }
+
+ // looks like an option
+ if (arg.length > 1 && '-' == arg[0]) {
+ unknownOptions.push(arg);
+
+ // If the next argument looks like it might be
+ // an argument for this option, we pass it on.
+ // If it isn't, then it'll simply be ignored
+ if (argv[i+1] && '-' != argv[i+1][0]) {
+ unknownOptions.push(argv[++i]);
+ }
+ continue;
+ }
+
+ // arg
+ args.push(arg);
+ }
+
+ return { args: args, unknown: unknownOptions };
+};
+
+/**
+ * Argument `name` is missing.
+ *
+ * @param {String} name
+ * @api private
+ */
+
+Command.prototype.missingArgument = function(name){
+ console.error();
+ console.error(" error: missing required argument `%s'", name);
+ console.error();
+ process.exit(1);
+};
+
+/**
+ * `Option` is missing an argument, but received `flag` or nothing.
+ *
+ * @param {String} option
+ * @param {String} flag
+ * @api private
+ */
+
+Command.prototype.optionMissingArgument = function(option, flag){
+ console.error();
+ if (flag) {
+ console.error(" error: option `%s' argument missing, got `%s'", option.flags, flag);
+ } else {
+ console.error(" error: option `%s' argument missing", option.flags);
+ }
+ console.error();
+ process.exit(1);
+};
+
+/**
+ * Unknown option `flag`.
+ *
+ * @param {String} flag
+ * @api private
+ */
+
+Command.prototype.unknownOption = function(flag){
+ console.error();
+ console.error(" error: unknown option `%s'", flag);
+ console.error();
+ process.exit(1);
+};
+
+/**
+ * Set the program version to `str`.
+ *
+ * This method auto-registers the "-V, --version" flag
+ * which will print the version number when passed.
+ *
+ * @param {String} str
+ * @param {String} flags
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype.version = function(str, flags){
+ if (0 == arguments.length) return this._version;
+ this._version = str;
+ flags = flags || '-V, --version';
+ this.option(flags, 'output the version number');
+ this.on('version', function(){
+ console.log(str);
+ process.exit(0);
+ });
+ return this;
+};
+
+/**
+ * Set the description `str`.
+ *
+ * @param {String} str
+ * @return {String|Command}
+ * @api public
+ */
+
+Command.prototype.description = function(str){
+ if (0 == arguments.length) return this._description;
+ this._description = str;
+ return this;
+};
+
+/**
+ * Set / get the command usage `str`.
+ *
+ * @param {String} str
+ * @return {String|Command}
+ * @api public
+ */
+
+Command.prototype.usage = function(str){
+ var args = this.args.map(function(arg){
+ return arg.required
+ ? '<' + arg.name + '>'
+ : '[' + arg.name + ']';
+ });
+
+ var usage = '[options'
+ + (this.commands.length ? '] [command' : '')
+ + ']'
+ + (this.args.length ? ' ' + args : '');
+ if (0 == arguments.length) return this._usage || usage;
+ this._usage = str;
+
+ return this;
+};
+
+/**
+ * Return the largest option length.
+ *
+ * @return {Number}
+ * @api private
+ */
+
+Command.prototype.largestOptionLength = function(){
+ return this.options.reduce(function(max, option){
+ return Math.max(max, option.flags.length);
+ }, 0);
+};
+
+/**
+ * Return help for options.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Command.prototype.optionHelp = function(){
+ var width = this.largestOptionLength();
+
+ // Prepend the help information
+ return [pad('-h, --help', width) + ' ' + 'output usage information']
+ .concat(this.options.map(function(option){
+ return pad(option.flags, width)
+ + ' ' + option.description;
+ }))
+ .join('\n');
+};
+
+/**
+ * Return command help documentation.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Command.prototype.commandHelp = function(){
+ if (!this.commands.length) return '';
+ return [
+ ''
+ , ' Commands:'
+ , ''
+ , this.commands.map(function(cmd){
+ var args = cmd.args.map(function(arg){
+ return arg.required
+ ? '<' + arg.name + '>'
+ : '[' + arg.name + ']';
+ }).join(' ');
+
+ return cmd.name
+ + (cmd.options.length
+ ? ' [options]'
+ : '') + ' ' + args
+ + (cmd.description()
+ ? '\n' + cmd.description()
+ : '');
+ }).join('\n\n').replace(/^/gm, ' ')
+ , ''
+ ].join('\n');
+};
+
+/**
+ * Return program help documentation.
+ *
+ * @return {String}
+ * @api private
+ */
+
+Command.prototype.helpInformation = function(){
+ return [
+ ''
+ , ' Usage: ' + this.name + ' ' + this.usage()
+ , '' + this.commandHelp()
+ , ' Options:'
+ , ''
+ , '' + this.optionHelp().replace(/^/gm, ' ')
+ , ''
+ , ''
+ ].join('\n');
+};
+
+/**
+ * Prompt for a `Number`.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptForNumber = function(str, fn){
+ var self = this;
+ this.promptSingleLine(str, function parseNumber(val){
+ val = Number(val);
+ if (isNaN(val)) return self.promptSingleLine(str + '(must be a number) ', parseNumber);
+ fn(val);
+ });
+};
+
+/**
+ * Prompt for a `Date`.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptForDate = function(str, fn){
+ var self = this;
+ this.promptSingleLine(str, function parseDate(val){
+ val = new Date(val);
+ if (isNaN(val.getTime())) return self.promptSingleLine(str + '(must be a date) ', parseDate);
+ fn(val);
+ });
+};
+
+/**
+ * Single-line prompt.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptSingleLine = function(str, fn){
+ if ('function' == typeof arguments[2]) {
+ return this['promptFor' + (fn.name || fn)](str, arguments[2]);
+ }
+
+ process.stdout.write(str);
+ process.stdin.setEncoding('utf8');
+ process.stdin.once('data', function(val){
+ fn(val.trim());
+ }).resume();
+};
+
+/**
+ * Multi-line prompt.
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api private
+ */
+
+Command.prototype.promptMultiLine = function(str, fn){
+ var buf = [];
+ console.log(str);
+ process.stdin.setEncoding('utf8');
+ process.stdin.on('data', function(val){
+ if ('\n' == val || '\r\n' == val) {
+ process.stdin.removeAllListeners('data');
+ fn(buf.join('\n'));
+ } else {
+ buf.push(val.trimRight());
+ }
+ }).resume();
+};
+
+/**
+ * Prompt `str` and callback `fn(val)`
+ *
+ * Commander supports single-line and multi-line prompts.
+ * To issue a single-line prompt simply add white-space
+ * to the end of `str`, something like "name: ", whereas
+ * for a multi-line prompt omit this "description:".
+ *
+ *
+ * Examples:
+ *
+ * program.prompt('Username: ', function(name){
+ * console.log('hi %s', name);
+ * });
+ *
+ * program.prompt('Description:', function(desc){
+ * console.log('description was "%s"', desc.trim());
+ * });
+ *
+ * @param {String|Object} str
+ * @param {Function} fn
+ * @api public
+ */
+
+Command.prototype.prompt = function(str, fn){
+ var self = this;
+
+ if ('string' == typeof str) {
+ if (/ $/.test(str)) return this.promptSingleLine.apply(this, arguments);
+ this.promptMultiLine(str, fn);
+ } else {
+ var keys = Object.keys(str)
+ , obj = {};
+
+ function next() {
+ var key = keys.shift()
+ , label = str[key];
+
+ if (!key) return fn(obj);
+ self.prompt(label, function(val){
+ obj[key] = val;
+ next();
+ });
+ }
+
+ next();
+ }
+};
+
+/**
+ * Prompt for password with `str`, `mask` char and callback `fn(val)`.
+ *
+ * The mask string defaults to '', aka no output is
+ * written while typing, you may want to use "*" etc.
+ *
+ * Examples:
+ *
+ * program.password('Password: ', function(pass){
+ * console.log('got "%s"', pass);
+ * process.stdin.destroy();
+ * });
+ *
+ * program.password('Password: ', '*', function(pass){
+ * console.log('got "%s"', pass);
+ * process.stdin.destroy();
+ * });
+ *
+ * @param {String} str
+ * @param {String} mask
+ * @param {Function} fn
+ * @api public
+ */
+
+Command.prototype.password = function(str, mask, fn){
+ var self = this
+ , buf = '';
+
+ // default mask
+ if ('function' == typeof mask) {
+ fn = mask;
+ mask = '';
+ }
+
+ process.stdin.resume();
+ tty.setRawMode(true);
+ process.stdout.write(str);
+
+ // keypress
+ process.stdin.on('keypress', function(c, key){
+ if (key && 'enter' == key.name) {
+ console.log();
+ process.stdin.removeAllListeners('keypress');
+ tty.setRawMode(false);
+ if (!buf.trim().length) return self.password(str, mask, fn);
+ fn(buf);
+ return;
+ }
+
+ if (key && key.ctrl && 'c' == key.name) {
+ console.log('%s', buf);
+ process.exit();
+ }
+
+ process.stdout.write(mask);
+ buf += c;
+ }).resume();
+};
+
+/**
+ * Confirmation prompt with `str` and callback `fn(bool)`
+ *
+ * Examples:
+ *
+ * program.confirm('continue? ', function(ok){
+ * console.log(' got %j', ok);
+ * process.stdin.destroy();
+ * });
+ *
+ * @param {String} str
+ * @param {Function} fn
+ * @api public
+ */
+
+
+Command.prototype.confirm = function(str, fn, verbose){
+ var self = this;
+ this.prompt(str, function(ok){
+ if (!ok.trim()) {
+ if (!verbose) str += '(yes or no) ';
+ return self.confirm(str, fn, true);
+ }
+ fn(parseBool(ok));
+ });
+};
+
+/**
+ * Choice prompt with `list` of items and callback `fn(index, item)`
+ *
+ * Examples:
+ *
+ * var list = ['tobi', 'loki', 'jane', 'manny', 'luna'];
+ *
+ * console.log('Choose the coolest pet:');
+ * program.choose(list, function(i){
+ * console.log('you chose %d "%s"', i, list[i]);
+ * process.stdin.destroy();
+ * });
+ *
+ * @param {Array} list
+ * @param {Number|Function} index or fn
+ * @param {Function} fn
+ * @api public
+ */
+
+Command.prototype.choose = function(list, index, fn){
+ var self = this
+ , hasDefault = 'number' == typeof index;
+
+ if (!hasDefault) {
+ fn = index;
+ index = null;
+ }
+
+ list.forEach(function(item, i){
+ if (hasDefault && i == index) {
+ console.log('* %d) %s', i + 1, item);
+ } else {
+ console.log(' %d) %s', i + 1, item);
+ }
+ });
+
+ function again() {
+ self.prompt(' : ', function(val){
+ val = parseInt(val, 10) - 1;
+ if (hasDefault && isNaN(val)) val = index;
+
+ if (null == list[val]) {
+ again();
+ } else {
+ fn(val, list[val]);
+ }
+ });
+ }
+
+ again();
+};
+
+/**
+ * Camel-case the given `flag`
+ *
+ * @param {String} flag
+ * @return {String}
+ * @api private
+ */
+
+function camelcase(flag) {
+ return flag.split('-').reduce(function(str, word){
+ return str + word[0].toUpperCase() + word.slice(1);
+ });
+}
+
+/**
+ * Parse a boolean `str`.
+ *
+ * @param {String} str
+ * @return {Boolean}
+ * @api private
+ */
+
+function parseBool(str) {
+ return /^y|yes|ok|true$/i.test(str);
+}
+
+/**
+ * Pad `str` to `width`.
+ *
+ * @param {String} str
+ * @param {Number} width
+ * @return {String}
+ * @api private
+ */
+
+function pad(str, width) {
+ var len = Math.max(0, width - str.length);
+ return str + Array(len + 1).join(' ');
+}
+
+/**
+ * Output help information if necessary
+ *
+ * @param {Command} command to output help for
+ * @param {Array} array of options to search for -h or --help
+ * @api private
+ */
+
+function outputHelpIfNecessary(cmd, options) {
+ options = options || [];
+ for (var i = 0; i < options.length; i++) {
+ if (options[i] == '--help' || options[i] == '-h') {
+ process.stdout.write(cmd.helpInformation());
+ cmd.emit('--help');
+ process.exit(0);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/commander/package.json
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/commander/package.json b/lib/cordova-blackberry/blackberry10/node_modules/commander/package.json
new file mode 100644
index 0000000..f27a374
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/commander/package.json
@@ -0,0 +1,38 @@
+{
+ "name": "commander",
+ "version": "0.5.2",
+ "description": "the complete solution for node.js command-line programs",
+ "keywords": [
+ "command",
+ "option",
+ "parser",
+ "prompt",
+ "stdin"
+ ],
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/visionmedia/commander.js.git"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "should": ">= 0.0.1"
+ },
+ "scripts": {
+ "test": "make test"
+ },
+ "main": "index",
+ "engines": {
+ "node": ">= 0.4.x"
+ },
+ "readme": "# Commander.js\n\n The complete solution for [node.js](http://nodejs.org) command-line interfaces, inspired by Ruby's [commander](https://github.com/visionmedia/commander).\n\n [](http://travis-ci.org/visionmedia/commander.js)\n\n## Installation\n\n $ npm install commander\n\n## Option parsing\n\n Options with commander are defined with the `.option()` method, also serving as documentation for the options. The example below parses args and options from `process.argv`, leaving remaining args as the `program.args` array which were not consumed by options.\n\n```js\n#!/usr/bin/env node\n\n/**\n * Module dependencies.\n */\n\nvar program = require('commander');\n\nprogram\n .version('0.0.1')\n .option('-p, --peppers', 'Add peppers')\n .option('-P, --pineapple', 'Add pineapple')\n .option('-b, --bbq', 'Add bbq sauce')\n .option('-c, --cheese [type]', 'Add the specified type of cheese [marble]'
, 'marble')\n .parse(process.argv);\n\nconsole.log('you ordered a pizza with:');\nif (program.peppers) console.log(' - peppers');\nif (program.pineapple) console.log(' - pineappe');\nif (program.bbq) console.log(' - bbq');\nconsole.log(' - %s cheese', program.cheese);\n```\n\n Short flags may be passed as a single arg, for example `-abc` is equivalent to `-a -b -c`. Multi-word options such as \"--template-engine\" are camel-cased, becoming `program.templateEngine` etc.\n\n## Automated --help\n\n The help information is auto-generated based on the information commander already knows about your program, so the following `--help` info is for free:\n\n``` \n $ ./examples/pizza --help\n\n Usage: pizza [options]\n\n Options:\n\n -V, --version output the version number\n -p, --peppers Add peppers\n -P, --pineapple Add pineappe\n -b, --bbq Add bbq sauce\n -c, --cheese <type> Add the specified type of cheese [marble]\n -h, --he
lp output usage information\n\n```\n\n## Coercion\n\n```js\nfunction range(val) {\n return val.split('..').map(Number);\n}\n\nfunction list(val) {\n return val.split(',');\n}\n\nprogram\n .version('0.0.1')\n .usage('[options] <file ...>')\n .option('-i, --integer <n>', 'An integer argument', parseInt)\n .option('-f, --float <n>', 'A float argument', parseFloat)\n .option('-r, --range <a>..<b>', 'A range', range)\n .option('-l, --list <items>', 'A list', list)\n .option('-o, --optional [value]', 'An optional value')\n .parse(process.argv);\n\nconsole.log(' int: %j', program.integer);\nconsole.log(' float: %j', program.float);\nconsole.log(' optional: %j', program.optional);\nprogram.range = program.range || [];\nconsole.log(' range: %j..%j', program.range[0], program.range[1]);\nconsole.log(' list: %j', program.list);\nconsole.log(' args: %j', program.args);\n```\n\n## Custom help\n\n You can display arbitrary `-h, --help` information\n by listening for \"--help\"
. Commander will automatically\n exit once you are done so that the remainder of your program\n does not execute causing undesired behaviours, for example\n in the following executable \"stuff\" will not output when\n `--help` is used.\n\n```js\n#!/usr/bin/env node\n\n/**\n * Module dependencies.\n */\n\nvar program = require('../');\n\nfunction list(val) {\n return val.split(',').map(Number);\n}\n\nprogram\n .version('0.0.1')\n .option('-f, --foo', 'enable some foo')\n .option('-b, --bar', 'enable some bar')\n .option('-B, --baz', 'enable some baz');\n\n// must be before .parse() since\n// node's emit() is immediate\n\nprogram.on('--help', function(){\n console.log(' Examples:');\n console.log('');\n console.log(' $ custom-help --help');\n console.log(' $ custom-help -h');\n console.log('');\n});\n\nprogram.parse(process.argv);\n\nconsole.log('stuff');\n```\n\nyielding the following help output:\n\n```\n\nUsage: custom-help [options]\n\nOptions:\n\n -h, --help
output usage information\n -V, --version output the version number\n -f, --foo enable some foo\n -b, --bar enable some bar\n -B, --baz enable some baz\n\nExamples:\n\n $ custom-help --help\n $ custom-help -h\n\n```\n\n## .prompt(msg, fn)\n\n Single-line prompt:\n\n```js\nprogram.prompt('name: ', function(name){\n console.log('hi %s', name);\n});\n```\n\n Multi-line prompt:\n\n```js\nprogram.prompt('description:', function(name){\n console.log('hi %s', name);\n});\n```\n\n Coercion:\n\n```js\nprogram.prompt('Age: ', Number, function(age){\n console.log('age: %j', age);\n});\n```\n\n```js\nprogram.prompt('Birthdate: ', Date, function(date){\n console.log('date: %s', date);\n});\n```\n\n## .password(msg[, mask], fn)\n\nPrompt for password without echoing:\n\n```js\nprogram.password('Password: ', function(pass){\n console.log('got \"%s\"', pass);\n process.stdin.destroy();\n});\n```\n\nPrompt for password with mask char \"*\":\n\n```js\nprogram.password('Pas
sword: ', '*', function(pass){\n console.log('got \"%s\"', pass);\n process.stdin.destroy();\n});\n```\n\n## .confirm(msg, fn)\n\n Confirm with the given `msg`:\n\n```js\nprogram.confirm('continue? ', function(ok){\n console.log(' got %j', ok);\n});\n```\n\n## .choose(list, fn)\n\n Let the user choose from a `list`:\n\n```js\nvar list = ['tobi', 'loki', 'jane', 'manny', 'luna'];\n\nconsole.log('Choose the coolest pet:');\nprogram.choose(list, function(i){\n console.log('you chose %d \"%s\"', i, list[i]);\n});\n```\n\n## Links\n\n - [API documentation](http://visionmedia.github.com/commander.js/)\n - [ascii tables](https://github.com/LearnBoost/cli-table)\n - [progress bars](https://github.com/visionmedia/node-progress)\n - [more progress bars](https://github.com/substack/node-multimeter)\n - [examples](https://github.com/visionmedia/commander.js/tree/master/examples)\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>\n\nPermission
is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.",
+ "readmeFilename": "Readme.md",
+ "_id": "commander@0.5.2",
+ "dist": {
+ "shasum": "f270326709a115a126cfed5623852439b8e4a3b5"
+ },
+ "_from": "commander@0.5.2"
+}
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/.npmignore
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/.npmignore b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/.npmignore
new file mode 100644
index 0000000..b4a9d1d
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/.npmignore
@@ -0,0 +1 @@
+.redcar
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/LICENSE
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/LICENSE b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/LICENSE
new file mode 100644
index 0000000..b6cd384
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/LICENSE
@@ -0,0 +1,9 @@
+** Licensed Under **
+
+The MIT License
+http://www.opensource.org/licenses/mit-license.php
+
+Copyright (c) 2010 all contributors:
+
+Gord Tanner
+tinyHippos Inc.
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/README.md
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/README.md b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/README.md
new file mode 100644
index 0000000..8f420b1
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/README.md
@@ -0,0 +1,170 @@
+# jWorkflow
+Dude, where is my workflow?
+
+jWorkflow is a workflow engine for JavaScript that provides the ability to
+create workflows to chain methods together in an easy to understand syntax:
+
+ var fooodOrder = jWorkflow.order(garlicChicken)
+ .andThen(whiteRice)
+ .andThen(wontonSoup)
+ .andThen(cookiesFortune)
+ .andThen(noAndThen)
+ .andThen(noAndThen)
+ .andThen(noAndThen)
+ .andThen(noAndThen);
+
+ fooodOrder.start();
+
+# Install
+
+jWorkflow can be used in node or included in the browser. It can be installed with npm
+
+ npm install jWorkflow
+
+and used
+
+ var jWorkflow = require("jWorkflow");
+
+or just include jWorkflow.js in your webpage and use window.jWorkflow.
+
+# Usage
+
+jWorkflow orders are started with a call to jWorkflow.order:
+
+ function dude() {
+ // some of the best code in the world will live here
+ }
+
+ var order = jWorkflow.order(dude);
+
+ // orders can also be started with no initial function
+ var pizzacoli = jWorkflow.order();
+
+jWorkflow tasks at the root are just functions that will be invoked in the order they are built.
+Any number of tasks can be then appended to the order:
+
+ order.andThen(sweet).andThen(dude).andThen(sweet);
+
+The functions passed into the order will not be invoked until you call:
+
+ order.start();
+
+The context to be used when invoking the functions can be passed in while creating the order:
+
+ order.andThen(transfunctioner.photonAcceleratorAnnihilationBeam, transfunctioner);
+
+An initial value can be passed into the start method to seed the first function:
+
+ order.start({
+ initialValue: 10
+ });
+
+# Passing Values between tasks
+
+jWorkflow tasks can access the return value of the previous task with the previous parameter:
+
+ function meaningOfLife() {
+ //find the meaning of life
+ return 42;
+ }
+
+ function writeBook(previous) {
+ console.log("the meaning of life is " + previous);
+ }
+
+ var guide = jWorkflow.order(meaningOfLife).andThen(writeBook);
+ guide.start();
+
+# Handling Async calls
+
+Sometimes(probably all the time) you will need to do something async when working with
+tasks, jWorkflow provides the ability to control the execution of the workflow via a
+baton that is passed to the task
+
+ function procrastinate(previous, baton) {
+ //take the baton, this means the next task will not run until you pass the baton
+ baton.take();
+
+ window.setTimeout(function() {
+ //do some stuff
+
+ //please be nice and always remember to pass the baton!
+ baton.pass();
+ }, 1000);
+ }
+
+If you want to pass a return value to the next task you can pass it along with the
+baton.
+
+NOTE: if you did take the baton, the return value from your function will NOT be passed to
+the next task:
+
+ function awesometown(previous, baton) {
+ baton.take();
+
+ window.setTimeout(function() {
+
+ //do stuff
+
+ baton.pass(420); //This value will be passed to the next task
+ }, 100);
+
+ return 50; // this will NOT be passed to the next function since you took the baton.
+ }
+
+
+the start method provides a callback to execute when the workflow is finished. The final
+return value is also passed to the callback:
+
+ order.start({
+ callback: function(review) {
+ console.log("dude!, your car is behind that mail truck!");
+ expect(review).toBe("two thumbs up");
+ }
+ });
+
+you can also pass context to use for the callback:
+
+ order.start({
+ callback: function() {
+ //do stuff
+ },
+ context: transfunctioner
+ });
+
+# Waiting between tasks
+
+If you ever need to take a break and reflect on the moment you can add some time(in ms) to chill between tasks:
+
+ jWorkflow.order(seeDoubleRainbow)
+ .chill(1000)
+ .andThen(omg)
+ .andThen(omg)
+ .andThen(omg)
+ .chill(1000)
+ .andThen(freakOut);
+
+# Handling Parallel tasks
+
+If you need to handle some tasks and don't care about when they are done you can pass in an array of functions and / or other workflows to execute
+at the same time.
+
+ jWorkflow.order([man, man, halfMan])
+ .andThen([jWorkflow.order([guy, guy]).andThen(girl), pizzaPlace]);
+
+# Canceling Workflows
+
+To cancel the execution of the workflow you can call the drop method on the baton:
+
+ function (previous, baton) {
+ //the value passed to drop will be passed onto the final callback if it exists
+ baton.drop("I dropped the soap");
+ //this value will NOT be passed to the next workflow step
+ return 10;
+ }
+
+NOTE: This will force the workflow into async mode.
+
+# Contributers:
+
+ Gord Tanner <gt...@gmail.com>
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/Rakefile
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/Rakefile b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/Rakefile
new file mode 100644
index 0000000..eb6b859
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/Rakefile
@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'closure-compiler'
+
+task :default => [:build]
+
+desc "Use the Closure Compiler to compress jWorkflow.js"
+task :build do
+ js = File.open('lib/jWorkflow.js', 'r')
+ min = Closure::Compiler.new.compile(js)
+ File.open('jworkflow-min-0.7.0.js', 'w') {|f| f.write(min) }
+end
+
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/jworkflow-min-0.8.0.js
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/jworkflow-min-0.8.0.js b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/jworkflow-min-0.8.0.js
new file mode 100644
index 0000000..a448d51
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/jworkflow-min-0.8.0.js
@@ -0,0 +1,3 @@
+var jWorkflow=function(){return{order:function(j,k){var f=[],g,h=null,i=function(){var a=false;return{take:function(){a=true},pass:function(b){var c;a=false;g.length?(c=g.shift(),b=c.func.apply(c.context,[b,i]),a||i.pass(b)):h.func&&h.func.apply(h.context,[b])},drop:function(b){a=true;g=[];setTimeout(function(){i.pass(b)},1)}}}(),e={andThen:function(a,b){if(typeof a.andThen==="function"&&typeof a.start==="function"&&typeof a.chill==="function")f.push({func:function(c,d){d.take();a.start({callback:function(a){d.pass(a)},
+context:b,initialValue:c})},context:b});else if(a.map&&a.reduce)f.push({func:function(b,d){d.take();var f=a.length,g=function(){return--f||d.pass()};a.forEach(function(a){jWorkflow.order(a).start(g)})},context:b});else{if(typeof a!=="function")throw"expected function but was "+typeof a;f.push({func:a,context:b})}return e},chill:function(a){return e.andThen(function(b,c){c.take();setTimeout(function(){c.pass(b)},a)})},start:function(a,b){var c,d,e;a&&typeof a==="object"?(c=a.callback,d=a.context,e=
+a.initialValue):(c=a,d=b);h={func:c,context:d};g=f.slice();i.pass(e)}};return j?e.andThen(j,k):e}}}();if(typeof module==="object"&&typeof require==="function")module.exports=jWorkflow;
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/lib/jWorkflow.js
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/lib/jWorkflow.js b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/lib/jWorkflow.js
new file mode 100644
index 0000000..36380d5
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/lib/jWorkflow.js
@@ -0,0 +1,140 @@
+// jWorkflow.js
+// (c) 2010 tinyHippos inc.
+// jWorkflow is freely distributable under the terms of the MIT license.
+// Portions of jWorkflow are inspired by Underscore.js
+var jWorkflow = (function () {
+ function _valid(func) {
+ if (typeof(func) !== 'function') {
+ throw "expected function but was " + typeof(func);
+ }
+ }
+
+ function _isWorkflow(func) {
+ return typeof func.andThen === 'function' &&
+ typeof func.start === 'function' &&
+ typeof func.chill === 'function';
+ }
+
+ function _isArray(func) {
+ return !!func.map && !!func.reduce;
+ }
+
+ var transfunctioner = {
+ order: function (func, context) {
+ var _workflow = [],
+ _tasks,
+ _callback = null,
+ _baton = (function () {
+ var _taken = false;
+ return {
+
+ take: function () {
+ _taken = true;
+ },
+
+ pass: function (result) {
+ var task;
+ _taken = false;
+
+ if (_tasks.length) {
+ task = _tasks.shift();
+ result = task.func.apply(task.context, [result, _baton]);
+
+ if (!_taken) {
+ _baton.pass(result);
+ }
+ }
+ else {
+ if (_callback.func) {
+ _callback.func.apply(_callback.context, [result]);
+ }
+ }
+ },
+
+ drop: function (result) {
+ _taken = true;
+ _tasks = [];
+ setTimeout(function () {
+ _baton.pass(result);
+ }, 1);
+ }
+ };
+ }()),
+ _self = {
+
+ andThen: function (func, context) {
+ if (_isWorkflow(func)) {
+ var f = function (prev, baton) {
+ baton.take();
+ func.start({
+ callback: function (result) {
+ baton.pass(result);
+ },
+ context: context,
+ initialValue: prev
+ });
+ };
+ _workflow.push({func: f, context: context});
+ }
+ else if (_isArray(func)) {
+ var orch = function (prev, baton) {
+ baton.take();
+
+ var l = func.length,
+ join = function () {
+ return --l || baton.pass();
+ };
+
+ func.forEach(function (f) {
+ jWorkflow.order(f).start(join);
+ });
+ };
+ _workflow.push({func: orch, context: context});
+ }
+ else {
+ _valid(func);
+ _workflow.push({func: func, context: context});
+ }
+ return _self;
+ },
+
+ chill: function (time) {
+ return _self.andThen(function (prev, baton) {
+ baton.take();
+ setTimeout(function () {
+ baton.pass(prev);
+ }, time);
+ });
+ },
+
+ start: function () {
+ var callback,
+ context,
+ initialValue;
+
+ if (arguments[0] && typeof arguments[0] === 'object') {
+ callback = arguments[0].callback;
+ context = arguments[0].context;
+ initialValue = arguments[0].initialValue;
+ }
+ else {
+ callback = arguments[0];
+ context = arguments[1];
+ }
+
+ _callback = {func: callback, context: context};
+ _tasks = _workflow.slice();
+ _baton.pass(initialValue);
+ }
+ };
+
+ return func ? _self.andThen(func, context) : _self;
+ }
+ };
+
+ return transfunctioner;
+}());
+
+if (typeof module === "object" && typeof require === "function") {
+ module.exports = jWorkflow;
+}
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/package.json
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/package.json b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/package.json
new file mode 100644
index 0000000..7684baa
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/package.json
@@ -0,0 +1,27 @@
+{
+ "name": "jWorkflow",
+ "version": "0.8.0",
+ "description": "dude, wheres my workflow?",
+ "homepage": "https://github.com/tinyhippos/jWorkflow",
+ "author": {
+ "name": "gtanner"
+ },
+ "contributors": [
+ {
+ "name": "Gord Tanner",
+ "email": "gtanner@gmail.com",
+ "url": "http://github.com/gtanner"
+ }
+ ],
+ "licenses": [
+ {
+ "type": "MIT",
+ "url": ""
+ }
+ ],
+ "main": "./lib/jWorkflow",
+ "readme": "# jWorkflow\nDude, where is my workflow?\n\njWorkflow is a workflow engine for JavaScript that provides the ability to\ncreate workflows to chain methods together in an easy to understand syntax:\n\n var fooodOrder = jWorkflow.order(garlicChicken)\n .andThen(whiteRice)\n .andThen(wontonSoup)\n .andThen(cookiesFortune)\n .andThen(noAndThen)\n .andThen(noAndThen)\n .andThen(noAndThen)\n .andThen(noAndThen);\n\n fooodOrder.start();\n\n# Install\n\njWorkflow can be used in node or included in the browser. It can be installed with npm\n\n npm install jWorkflow\n\nand used\n\n var jWorkflow = require(\"jWorkflow\");\n\nor just include jWorkflow.js in your webpage and use window.jWorkflow.\n\n# Usage\n\njWorkflow orders are started with a call to jWorkflow.order:\n
\n function dude() {\n // some of the best code in the world will live here\n }\n\n var order = jWorkflow.order(dude);\n\n // orders can also be started with no initial function\n var pizzacoli = jWorkflow.order();\n\njWorkflow tasks at the root are just functions that will be invoked in the order they are built.\nAny number of tasks can be then appended to the order:\n\n order.andThen(sweet).andThen(dude).andThen(sweet);\n\nThe functions passed into the order will not be invoked until you call:\n\n order.start();\n\nThe context to be used when invoking the functions can be passed in while creating the order:\n\n order.andThen(transfunctioner.photonAcceleratorAnnihilationBeam, transfunctioner);\n\nAn initial value can be passed into the start method to seed the first function:\n\n order.start({\n initialValue: 10\n });\n\n# Passing Values between tasks\n\njWorkflow tasks can access the return value of the previous task with the previous pa
rameter:\n\n function meaningOfLife() {\n //find the meaning of life\n return 42; \n }\n \n function writeBook(previous) {\n console.log(\"the meaning of life is \" + previous);\n }\n\n var guide = jWorkflow.order(meaningOfLife).andThen(writeBook);\n guide.start();\n\n# Handling Async calls\n\nSometimes(probably all the time) you will need to do something async when working with\ntasks, jWorkflow provides the ability to control the execution of the workflow via a\nbaton that is passed to the task\n\n function procrastinate(previous, baton) {\n //take the baton, this means the next task will not run until you pass the baton\n baton.take();\n\n window.setTimeout(function() {\n //do some stuff\n\n //please be nice and always remember to pass the baton!\n baton.pass();\n }, 1000);\n }\n\nIf you want to pass a return value to the next task you can pass it along with the\nbaton.\n\nNO
TE: if you did take the baton, the return value from your function will NOT be passed to \nthe next task:\n\n function awesometown(previous, baton) {\n baton.take();\n\n window.setTimeout(function() {\n \n //do stuff\n \n baton.pass(420); //This value will be passed to the next task\n }, 100);\n\n return 50; // this will NOT be passed to the next function since you took the baton.\n }\n\n\nthe start method provides a callback to execute when the workflow is finished. The final\nreturn value is also passed to the callback:\n\n order.start({\n callback: function(review) {\n console.log(\"dude!, your car is behind that mail truck!\");\n expect(review).toBe(\"two thumbs up\");\n }\n });\n\nyou can also pass context to use for the callback:\n\n order.start({\n callback: function() {\n //do stuff\n }, \n context: transfunctioner\n })
;\n \n# Waiting between tasks\n\nIf you ever need to take a break and reflect on the moment you can add some time(in ms) to chill between tasks:\n\n jWorkflow.order(seeDoubleRainbow)\n .chill(1000)\n .andThen(omg)\n .andThen(omg)\n .andThen(omg)\n .chill(1000)\n .andThen(freakOut);\n\n# Handling Parallel tasks\n\nIf you need to handle some tasks and don't care about when they are done you can pass in an array of functions and / or other workflows to execute\nat the same time.\n\n jWorkflow.order([man, man, halfMan])\n .andThen([jWorkflow.order([guy, guy]).andThen(girl), pizzaPlace]);\n\n# Canceling Workflows\n\nTo cancel the execution of the workflow you can call the drop method on the baton:\n\n function (previous, baton) {\n //the value passed to drop will be passed onto the final callback if it exists\n baton.drop(\"I dropped the soap\");\n //this value will NOT be
passed to the next workflow step\n return 10;\n }\n\nNOTE: This will force the workflow into async mode.\n\n# Contributers:\n\n Gord Tanner <gt...@gmail.com>\n",
+ "readmeFilename": "README.md",
+ "_id": "jWorkflow@0.8.0",
+ "_from": "jWorkflow@*"
+}
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test.html
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test.html b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test.html
new file mode 100644
index 0000000..75e581b
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test.html
@@ -0,0 +1,17 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>jWorkflow Test Suite</title>
+ <link rel="stylesheet" href="vendor/qunit.css" type="text/css" media="screen" />
+ <script type="text/javascript" src="vendor/jquery.js"></script>
+ <script type="text/javascript" src="vendor/qunit.js"></script>
+ <script type="text/javascript" src="../lib/jWorkflow.js"></script>
+ <script type="text/javascript" src="test_jworkflow.js"></script>
+</head>
+ <body>
+ <h1 id="qunit-header">jWorkflow Test Suite</h1>
+ <h2 id="qunit-banner"></h2>
+ <h2 id="qunit-userAgent"></h2>
+ <ol id="qunit-tests"></ol>
+ </body>
+</html>
http://git-wip-us.apache.org/repos/asf/cordova-cli/blob/6831bed4/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test_jworkflow.js
----------------------------------------------------------------------
diff --git a/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test_jworkflow.js b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test_jworkflow.js
new file mode 100644
index 0000000..afb13a2
--- /dev/null
+++ b/lib/cordova-blackberry/blackberry10/node_modules/jWorkflow/test/test_jworkflow.js
@@ -0,0 +1,521 @@
+$(document).ready(function () {
+ module("jWorkflow ordering and starting workflows");
+
+ test("jWorkflow: we can place an order", function () {
+ expect(1);
+ var order = jWorkflow.order(function () {});
+ ok(order, "we should have an order");
+ });
+
+ test("jWorkflow: order throws an error when not given a function", function () {
+ expect(1);
+ var errored = false;
+ try {
+ jWorkflow.order(42);
+ }
+ catch (ex) {
+ errored = true;
+ }
+
+ ok(errored, "expected an error");
+
+ });
+
+ test("jWorkflow: we can call andThen on the return value of order", function () {
+ expect(2);
+
+ var transfunctioner = function () { },
+ order = jWorkflow.order(transfunctioner);
+
+ ok(order.andThen, "expected to be asked: 'andThen'");
+ equals(typeof(order.andThen), "function", "expected andThen to be a function");
+ });
+
+ test("jWorkflow: andThen throws an error when not given a function", function () {
+ expect(1);
+
+ var errored = false;
+ try {
+ jWorkflow.order(function () {}).andThen(42);
+ }
+ catch (ex) {
+ errored = true;
+ }
+
+ ok(errored, "expected an error");
+
+ });
+
+ test("jWorkflow: we can call andThen on the return value of andThen", function () {
+ expect(2);
+
+ var garlicChicken = function () {},
+ whiteRice = function () {},
+ wontonSoup = function () {},
+ cookiesFortune = function () {},
+ noAndThen = function () {},
+ order = jWorkflow.order(garlicChicken)
+ .andThen(whiteRice)
+ .andThen(wontonSoup)
+ .andThen(cookiesFortune);
+
+ order.andThen(noAndThen).andThen(noAndThen);
+
+ ok(order.andThen, "expected to be asked: 'andThen'");
+ equals(typeof(order.andThen), "function", "expected andThen to be a function");
+
+ });
+
+ test("jWorkflow: it doesnt invoke the order function when start isnt called", function () {
+ var dude = true,
+ sweet = function () {
+ dude = false;
+ },
+ order = jWorkflow.order(sweet);
+
+ ok(dude, "expected sweet to have not been invoked");
+
+ });
+
+ test("jWorkflow: it calls the order function when start is called", function () {
+ var dude = false,
+ sweet = function () {
+ dude = true;
+ },
+ order = jWorkflow.order(sweet);
+
+ order.start();
+
+ ok(dude, "expected sweet to have been invoked");
+ });
+
+ asyncTest("jWorkflow: it can handle multiple orders without mixing them", function () {
+ expect(1);
+ var dude = false,
+ what = false,
+ sweet = function () {
+ dude = true;
+ },
+ whatup = function () {
+ what = true;
+ },
+ order = jWorkflow.order(sweet),
+ order2 = jWorkflow.order(whatup);
+
+
+ order.start(function () {
+ start();
+ ok(what === false, "whatup shouldn't have been called");
+ });
+ });
+
+ test("jWorkflow: it calls the order in the order that it was built", function () {
+ expect(1);
+
+ var result = [],
+ garlicChicken = function () {
+ result.push("garlicChicken");
+ },
+ whiteRice = function () {
+ result.push("whiteRice");
+ },
+ wontonSoup = function () {
+ result.push("wontonSoup");
+ },
+ cookiesFortune = function () {
+ result.push("cookiesFortune");
+ },
+ noAndThen = function () {
+ result.push("noAndThen");
+ },
+ order = jWorkflow.order(garlicChicken)
+ .andThen(whiteRice)
+ .andThen(wontonSoup)
+ .andThen(cookiesFortune);
+
+ order.andThen(noAndThen).andThen(noAndThen);
+
+ order.start();
+
+ same(["garlicChicken", "whiteRice", "wontonSoup", "cookiesFortune", "noAndThen", "noAndThen"], result, "expected functions to be called in order");
+ });
+
+ test("jWorkflow: it get the return value of the previous func", function () {
+
+ var dude = function () {
+ return 42;
+ },
+ sweet = function (previous) {
+ equals(previous, 42, "expected previous to be return value");
+ },
+ order = jWorkflow.order(dude).andThen(sweet);
+
+ order.start();
+
+ });
+
+ test("jWorkflow: we get a baton play with", function () {
+ var order = jWorkflow.order(function (previous, baton) {
+ ok(baton, "expected a baton");
+ ok(baton.take, "expected to be able to take the baton");
+ ok(baton.pass, "expected to be able to pass the baton");
+ });
+
+ order.start();
+
+ });
+
+ test("jWorkflow: when I take the baton, the next methods are not called if I don't pass it", function () {
+ var transfunctioner = true,
+ dude = function () {},
+ sweet = function () {},
+ noAndThen = function (previous, baton) {
+ baton.take();
+ },
+ fortuneCookie = function () {
+ transfunctioner = false;
+ },
+ order = jWorkflow.order(dude).andThen(sweet).andThen(noAndThen).andThen(fortuneCookie);
+
+ order.start();
+
+ ok(transfunctioner, "fortune Cookie should not have been called because we took the baton and didn't pass it");
+ });
+
+ asyncTest("jWorkflow: when I take the baton and pass it async, the next methods are called", function () {
+ expect(1);
+ var transfunctioner = false,
+ dude = function () {},
+ sweet = function () {},
+ noAndThen = function (previous, baton) {
+ baton.take();
+ window.setTimeout(function () {
+ baton.pass();
+ }, 10);
+ },
+ fortuneCookie = function () {
+ transfunctioner = true;
+ },
+ order = jWorkflow.order(dude).andThen(sweet).andThen(noAndThen).andThen(fortuneCookie);
+
+ order.start(function () {
+ start();
+ ok(transfunctioner, "fortune Cookie should have been called because we passed the baton");
+ });
+
+ });
+
+ asyncTest("jWorkflow: it calls the order in the order that it was built, even with Async calls", function () {
+ expect(1);
+
+ var result = [],
+ procrastinate = function (msg, baton) {
+ baton.take();
+ window.setTimeout(function () {
+ result.push(msg);
+ baton.pass();
+ }, 10);
+ },
+ garlicChicken = function (previous, baton) {
+ procrastinate("garlicChicken", baton);
+ },
+ whiteRice = function (previous, baton) {
+ result.push("whiteRice");
+ },
+ wontonSoup = function (previous, baton) {
+ procrastinate("wontonSoup", baton);
+ },
+ cookiesFortune = function (previous, baton) {
+ result.push("cookiesFortune");
+ },
+ noAndThen = function (previous, baton) {
+ procrastinate("noAndThen", baton);
+ },
+ order = jWorkflow.order(garlicChicken)
+ .andThen(whiteRice)
+ .andThen(wontonSoup)
+ .andThen(cookiesFortune);
+
+ order.andThen(noAndThen).andThen(noAndThen);
+
+ order.start(function () {
+ start();
+ same(result, ["garlicChicken", "whiteRice", "wontonSoup", "cookiesFortune", "noAndThen", "noAndThen"], "expected functions to be called in order");
+ });
+ });
+
+ test("jWorkflow: we can give context for the function passed to andThen", function () {
+ expect(1);
+
+ var zoltan = {
+ toMyParentsMinivan: function () {
+ ok(this.getCultMembers, "expected to be able to get the cult members");
+ },
+
+ getCultMembers: function () {
+ return ["Zarnoff", "Zabu", "Zellnor", "Zelbor", "Zelmina", "Jeff"];
+ }
+ },
+ order = jWorkflow.order(zoltan.toMyParentsMinivan, zoltan);
+
+ order.start();
+ });
+
+ test("jWorkflow, we can pass in a different context for each function", function () {
+ expect(2);
+
+ var jesse = {
+ smokeyMcPot: true,
+ test: function () {
+ ok(this.smokeyMcPot, "I should be SmokeyMcPot");
+ }
+ },
+ chester = {
+ johnnyPotsmoker: true,
+ test: function () {
+ ok(this.johnnyPotsmoker, "I should be Johnny Potsmoker");
+ }
+ },
+ order = jWorkflow.order(jesse.test, jesse)
+ .andThen(chester.test, chester);
+
+
+ order.start();
+
+
+ });
+
+ test("jWorkflow: we can pass context into start", function () {
+ expect(1);
+
+ var jesse = {
+ smokeyMcPot: true,
+ test: function () {
+ ok(this.smokeyMcPot, "I should be SmokeyMcPot");
+ }
+ },
+ order = jWorkflow.order();
+
+ order.start(jesse.test, jesse);
+ });
+
+ test("jWorkflow, we can pass null into order", function () {
+ expect(1);
+
+ var order = jWorkflow.order();
+
+ ok(order, "expected to have an order when not passing in an initial function");
+ });
+
+ test("jWorkflow, we can NOT pass null into andThen", function () {
+ expect(1);
+ var errored = false,
+ order = jWorkflow.order();
+
+ try {
+ order.andThen();
+ }
+ catch (ex) {
+ errored = true;
+ }
+
+ ok(errored, "expected an exception when calling andThen with no order");
+ });
+
+ asyncTest("jWorkflow, we can pass a return value from an async function into a sync function via the baton", function () {
+ expect(1);
+
+ var correct,
+ was,
+ order = jWorkflow.order(function (previous, baton) {
+ baton.take();
+ setTimeout(function () {
+ baton.pass(420);
+ }, 10);
+
+ return 11;
+
+ }).andThen(function (answer) {
+ was = answer;
+ correct = answer === 420;
+ });
+
+ order.start(function () {
+ start();
+ ok(correct, "expected it to be 420 but was " + was);
+ });
+ });
+
+ asyncTest("jWorkflow, we can reuse an order", function () {
+ expect(1);
+
+ var sheep_teleported = 0,
+ teleport = function () {
+ sheep_teleported += 1;
+ },
+ order = jWorkflow.order(teleport).andThen(teleport);
+
+
+ order.start(function () {
+ order.start(function () {
+ start();
+ equals(sheep_teleported, 4, "expected to teleport 4 sheep");
+ });
+ });
+ });
+
+ asyncTest("jWorkflow, we can chill for a little bit between tasks", function () {
+ var time = [],
+ inhale = function () {
+ time.push(new Date());
+ },
+ exhale = inhale;
+
+ jWorkflow.order(inhale).chill(100).andThen(exhale).start(function () {
+ start();
+ var chilled = time[1] - time[0];
+ ok(chilled > 50, "expected to chill a little bit between tasks: " + chilled);
+ });
+ });
+
+ test("jWorkflow, it passes the final result to the callback passed to start", function () {
+ expect(1);
+ var plus1 = function (prev) {
+ return prev + 1;
+ };
+
+ jWorkflow.order(function () {
+ return 0;
+ })
+ .andThen(plus1)
+ .andThen(plus1)
+ .start(function (result) {
+ equals(2, result);
+ });
+ });
+
+ test("jWorkflow, we can pass the initial value into start", function () {
+ expect(1);
+
+ jWorkflow.order().andThen(function (prev) {
+ equals(5, prev);
+ }).start({
+ initialValue: 5
+ });
+ });
+
+ asyncTest("jWorkflow, we can pass another workflow into andThen", function () {
+ expect(1);
+
+ var plus1 = function (prev) {
+ return prev + 1;
+ },
+ plus4 = function (prev, baton) {
+ baton.take();
+ setTimeout(function () {
+ baton.pass(prev + 4);
+ }, 10);
+ },
+ addTen = jWorkflow.order(plus4).andThen(plus1).andThen(plus4).andThen(plus1),
+ addFive = jWorkflow.order(plus4).andThen(plus1);
+
+ jWorkflow.order()
+ .andThen(addTen)
+ .andThen(addTen)
+ .andThen(addFive)
+ .start({
+ callback: function (result) {
+ start();
+ equals(result, 25);
+ },
+ initialValue: 0
+ });
+ });
+
+ asyncTest("jWorkflow, we can pass an array of functions into andThen", function () {
+ expect(1);
+
+ var x = "",
+ w = function (letter, delay) {
+ return function (prev, baton) {
+ if (delay) {
+ baton.take();
+ window.setTimeout(function () {
+ x += letter;
+ baton.pass();
+ }, delay);
+ }
+ else {
+ x += letter;
+ }
+ };
+ };
+
+ jWorkflow.order(w("d"))
+ .andThen([w("U", 100), w("u", 10), w("u")])
+ .andThen(w("de"))
+ .start(function () {
+ start();
+ equals(x, "duuUde");
+ });
+
+ });
+
+ asyncTest("jWorkflow, we can pass an array of workflows into andThen", function () {
+ expect(1);
+
+ var x = "",
+ w = function (letter, delay) {
+ return function (prev, baton) {
+ if (delay) {
+ baton.take();
+ window.setTimeout(function () {
+ x += letter;
+ baton.pass();
+ }, delay);
+ }
+ else {
+ x += letter;
+ }
+ };
+ };
+
+ jWorkflow.order(jWorkflow.order(w("s")))
+ .andThen([jWorkflow.order(w("w", 1)).andThen(w("e")), jWorkflow.order(w("e", 30))])
+ .andThen(w("et"))
+ .start(function () {
+ start();
+ equals(x, "sweeet");
+ });
+ });
+
+ asyncTest("jWorkflow, we can stop execution of a workflow with baton.drop", function () {
+ expect(2);
+
+ var inc = function (prev, baton) {
+ if (prev >= 3) {
+ baton.drop(prev);
+ }
+ return ++prev;
+ },
+ protected = false;
+
+ jWorkflow.order(inc)
+ .andThen(inc)
+ .andThen(inc)
+ .andThen(inc)
+ .andThen(inc)
+ .andThen(inc)
+ .andThen(function (prev) {
+ protected = true;
+ return prev;
+ }).start({
+ initialValue: 0,
+ callback: function (result) {
+ start();
+ equals(protected, false);
+ equals(result, 3);
+ }
+ });
+ });
+});