mobile_template 0.0.1

data/templates/cordova_android/bin/node_modules/nodeunit/lib/reporters/minimal.js

@@ -0,0 +1,112 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var nodeunit = require('../nodeunit'),
+    utils = require('../utils'),
+    fs = require('fs'),
+    path = require('path'),
+    AssertionError = require('assert').AssertionError;
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "Pretty minimal output";
+
+/**
+ * Run all tests within each module, reporting the results to the command-line.
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (files, options) {
+
+    if (!options) {
+        // load default options
+        var content = fs.readFileSync(
+            __dirname + '/../../bin/nodeunit.json', 'utf8'
+        );
+        options = JSON.parse(content);
+    }
+
+    var red   = function (str) {
+        return options.error_prefix + str + options.error_suffix;
+    };
+    var green = function (str) {
+        return options.ok_prefix + str + options.ok_suffix;
+    };
+    var magenta = function (str) {
+        return options.assertion_prefix + str + options.assertion_suffix;
+    };
+    var bold  = function (str) {
+        return options.bold_prefix + str + options.bold_suffix;
+    };
+
+    var start = new Date().getTime();
+    var paths = files.map(function (p) {
+        return path.join(process.cwd(), p);
+    });
+
+    nodeunit.runFiles(paths, {
+        testspec: options.testspec,
+        moduleStart: function (name) {
+            process.stdout.write(bold(name) + ': ');
+        },
+        moduleDone: function (name, assertions) {
+            console.log('');
+            if (assertions.failures()) {
+                assertions.forEach(function (a) {
+                    if (a.failed()) {
+                        a = utils.betterErrors(a);
+                        if (a.error instanceof AssertionError && a.message) {
+                            console.log(
+                                'Assertion in test ' + bold(a.testname) + ': ' +
+                                magenta(a.message)
+                            );
+                        }
+                        console.log(a.error.stack + '\n');
+                    }
+                });
+            }
+
+        },
+        testStart: function () {
+        },
+        testDone: function (name, assertions) {
+            if (!assertions.failures()) {
+                process.stdout.write('.');
+            }
+            else {
+                process.stdout.write(red('F'));
+                assertions.forEach(function (assertion) {
+                    assertion.testname = name;
+                });
+            }
+        },
+        done: function (assertions) {
+            var end = new Date().getTime();
+            var duration = end - start;
+            if (assertions.failures()) {
+                console.log(
+                    '\n' + bold(red('FAILURES: ')) + assertions.failures() +
+                    '/' + assertions.length + ' assertions failed (' +
+                    assertions.duration + 'ms)'
+                );
+            }
+            else {
+                console.log(
+                    '\n' + bold(green('OK: ')) + assertions.length +
+                    ' assertions (' + assertions.duration + 'ms)'
+                );
+            }
+        }
+    });
+};

data/templates/cordova_android/bin/node_modules/nodeunit/lib/reporters/skip_passed.js

@@ -0,0 +1,105 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var nodeunit = require('../nodeunit'),
+    utils = require('../utils'),
+    fs = require('fs'),
+    path = require('path'),
+    AssertionError = require('assert').AssertionError;
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "Skip passed tests output";
+
+/**
+ * Run all tests within each module, reporting the results to the command-line.
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (files, options) {
+
+    if (!options) {
+        // load default options
+        var content = fs.readFileSync(
+            __dirname + '/../../bin/nodeunit.json', 'utf8'
+        );
+        options = JSON.parse(content);
+    }
+
+    var error = function (str) {
+        return options.error_prefix + str + options.error_suffix;
+    };
+    var ok    = function (str) {
+        return options.ok_prefix + str + options.ok_suffix;
+    };
+    var bold  = function (str) {
+        return options.bold_prefix + str + options.bold_suffix;
+    };
+    var assertion_message = function (str) {
+        return options.assertion_prefix + str + options.assertion_suffix;
+    };
+
+    var start = new Date().getTime();
+    var paths = files.map(function (p) {
+        return path.join(process.cwd(), p);
+    });
+
+    nodeunit.runFiles(paths, {
+        testspec: options.testspec,
+        moduleStart: function (name) {
+            console.log('\n' + bold(name));
+        },
+        testDone: function (name, assertions) {
+            if (assertions.failures()) {
+                console.log(error('✖ ' + name) + '\n');
+                assertions.forEach(function (a) {
+                    if (a.failed()) {
+                        a = utils.betterErrors(a);
+                        if (a.error instanceof AssertionError && a.message) {
+                            console.log(
+                                'Assertion Message: ' + assertion_message(a.message)
+                            );
+                        }
+                        console.log(a.error.stack + '\n');
+                    }
+                });
+            }
+        },
+        moduleDone: function (name, assertions) {
+            if (!assertions.failures()) {
+                console.log('✔ all tests passed');
+            }
+            else {
+                console.log(error('✖ some tests failed'));
+            }
+        },
+        done: function (assertions) {
+            var end = new Date().getTime();
+            var duration = end - start;
+            if (assertions.failures()) {
+                console.log(
+                    '\n' + bold(error('FAILURES: ')) + assertions.failures() +
+                    '/' + assertions.length + ' assertions failed (' +
+                    assertions.duration + 'ms)'
+                );
+            }
+            else {
+                console.log(
+                    '\n' + bold(ok('OK: ')) + assertions.length +
+                    ' assertions (' + assertions.duration + 'ms)'
+                );
+            }
+        }
+    });
+};

data/templates/cordova_android/bin/node_modules/nodeunit/lib/track.js

@@ -0,0 +1,48 @@
+/*!
+ * Simple util module to track tests. Adds a process.exit hook to print
+ * the undone tests.
+ */
+
+
+exports.createTracker = function (on_exit) {
+    var names = {};
+    var tracker = {
+        names: function () {
+            var arr = [];
+            for (var k in names) {
+                if (names.hasOwnProperty(k)) {
+                    arr.push(k);
+                }
+            }
+            return arr;
+        },
+        unfinished: function () {
+            return tracker.names().length;
+        },
+        put: function (testname) {
+            names[testname] = testname;
+        },
+        remove: function (testname) {
+            delete names[testname];
+        }
+    };
+
+    process.on('exit', function() {
+        on_exit = on_exit || exports.default_on_exit;
+        on_exit(tracker);
+    });
+
+    return tracker;
+};
+
+exports.default_on_exit = function (tracker) {
+    if (tracker.unfinished()) {
+        console.log('');
+        console.log('Undone tests (or their setups/teardowns): ');
+        var names = tracker.names();
+        for (var i = 0; i < names.length; i += 1) {
+            console.log(names[i]);
+        }
+        process.reallyExit(tracker.unfinished());
+    }
+};

data/templates/cordova_android/bin/node_modules/nodeunit/lib/types.js

@@ -0,0 +1,187 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ *
+ * THIS FILE SHOULD BE BROWSER-COMPATIBLE JS!
+ * You can use @REMOVE_LINE_FOR_BROWSER to remove code from the browser build.
+ * Only code on that line will be removed, its mostly to avoid requiring code
+ * that is node specific
+ */
+
+/**
+ * Module dependencies
+ */
+
+var assert = require('./assert'),     //@REMOVE_LINE_FOR_BROWSER
+    async = require('../deps/async'); //@REMOVE_LINE_FOR_BROWSER
+
+
+/**
+ * Creates assertion objects representing the result of an assert call.
+ * Accepts an object or AssertionError as its argument.
+ *
+ * @param {object} obj
+ * @api public
+ */
+
+exports.assertion = function (obj) {
+    return {
+        method: obj.method || '',
+        message: obj.message || (obj.error && obj.error.message) || '',
+        error: obj.error,
+        passed: function () {
+            return !this.error;
+        },
+        failed: function () {
+            return Boolean(this.error);
+        }
+    };
+};
+
+/**
+ * Creates an assertion list object representing a group of assertions.
+ * Accepts an array of assertion objects.
+ *
+ * @param {Array} arr
+ * @param {Number} duration
+ * @api public
+ */
+
+exports.assertionList = function (arr, duration) {
+    var that = arr || [];
+    that.failures = function () {
+        var failures = 0;
+        for (var i=0; i<this.length; i++) {
+            if (this[i].failed()) failures++;
+        }
+        return failures;
+    };
+    that.passes = function () {
+        return that.length - that.failures();
+    };
+    that.duration = duration || 0;
+    return that;
+};
+
+/**
+ * Create a wrapper function for assert module methods. Executes a callback
+ * after the it's complete with an assertion object representing the result.
+ *
+ * @param {Function} callback
+ * @api private
+ */
+
+var assertWrapper = function (callback) {
+    return function (new_method, assert_method, arity) {
+        return function () {
+            var message = arguments[arity-1];
+            var a = exports.assertion({method: new_method, message: message});
+            try {
+                assert[assert_method].apply(null, arguments);
+            }
+            catch (e) {
+                a.error = e;
+            }
+            callback(a);
+        };
+    };
+};
+
+/**
+ * Creates the 'test' object that gets passed to every test function.
+ * Accepts the name of the test function as its first argument, followed by
+ * the start time in ms, the options object and a callback function.
+ *
+ * @param {String} name
+ * @param {Number} start
+ * @param {Object} options
+ * @param {Function} callback
+ * @api public
+ */
+
+exports.test = function (name, start, options, callback) {
+    var expecting;
+    var a_list = [];
+
+    var wrapAssert = assertWrapper(function (a) {
+        a_list.push(a);
+        if (options.log) {
+            async.nextTick(function () {
+                options.log(a);
+            });
+        }
+    });
+
+    var test = {
+        done: function (err) {
+            if (expecting !== undefined && expecting !== a_list.length) {
+                var e = new Error(
+                    'Expected ' + expecting + ' assertions, ' +
+                    a_list.length + ' ran'
+                );
+                var a1 = exports.assertion({method: 'expect', error: e});
+                a_list.push(a1);
+                if (options.log) {
+                    async.nextTick(function () {
+                        options.log(a1);
+                    });
+                }
+            }
+            if (err) {
+                var a2 = exports.assertion({error: err});
+                a_list.push(a2);
+                if (options.log) {
+                    async.nextTick(function () {
+                        options.log(a2);
+                    });
+                }
+            }
+            var end = new Date().getTime();
+            async.nextTick(function () {
+                var assertion_list = exports.assertionList(a_list, end - start);
+                options.testDone(name, assertion_list);
+                callback(null, a_list);
+            });
+        },
+        ok: wrapAssert('ok', 'ok', 2),
+        same: wrapAssert('same', 'deepEqual', 3),
+        equals: wrapAssert('equals', 'equal', 3),
+        expect: function (num) {
+            expecting = num;
+        },
+        _assertion_list: a_list
+    };
+    // add all functions from the assert module
+    for (var k in assert) {
+        if (assert.hasOwnProperty(k)) {
+            test[k] = wrapAssert(k, k, assert[k].length);
+        }
+    }
+    return test;
+};
+
+/**
+ * Ensures an options object has all callbacks, adding empty callback functions
+ * if any are missing.
+ *
+ * @param {Object} opt
+ * @return {Object}
+ * @api public
+ */
+
+exports.options = function (opt) {
+    var optionalCallback = function (name) {
+        opt[name] = opt[name] || function () {};
+    };
+
+    optionalCallback('moduleStart');
+    optionalCallback('moduleDone');
+    optionalCallback('testStart');
+    optionalCallback('testDone');
+    //optionalCallback('log');
+
+    // 'done' callback is not optional.
+
+    return opt;
+};

data/templates/cordova_android/bin/node_modules/nodeunit/lib/utils.js

@@ -0,0 +1,209 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var async = require('../deps/async'),
+    fs = require('fs'),
+    util = require('util'),
+    Script = process.binding('evals').Script,
+    http = require('http');
+
+
+/**
+ * Detect if coffee-script is available and search for .coffee as an
+ * extension in modulePaths if it is.
+ */
+
+var extensionPattern;
+try {
+    require('coffee-script');
+    extensionPattern = /\.(?:js|coffee)$/;
+}
+catch (e) {
+    extensionPattern = /\.js$/;
+}
+
+
+/**
+ * Finds all modules at each path in an array, If a path is a directory, it
+ * returns all supported file types inside it. This only reads 1 level deep in
+ * the directory and does not recurse through sub-directories.
+ *
+ * The extension (.js, .coffee etc) is stripped from the filenames so they can
+ * simply be require()'ed.
+ *
+ * @param {Array} paths
+ * @param {Function} callback
+ * @api public
+ */
+
+exports.modulePaths = function (paths, callback) {
+    async.concat(paths, function (p, cb) {
+        fs.stat(p, function (err, stats) {
+            if (err) {
+                return cb(err);
+            }
+            if (stats.isFile()) {
+                return cb(null, [p]);
+            }
+            if (stats.isDirectory()) {
+                fs.readdir(p, function (err, files) {
+                    if (err) {
+                        return cb(err);
+                    }
+
+                    // filter out any filenames with unsupported extensions
+                    var modules = files.filter(function (filename) {
+                        return extensionPattern.exec(filename);
+                    });
+
+                    // remove extension from module name and prepend the
+                    // directory path
+                    var fullpaths = modules.map(function (filename) {
+                        var mod_name = filename.replace(extensionPattern, '');
+                        return [p, mod_name].join('/');
+                    });
+
+                    // sort filenames here, because Array.map changes order
+                    fullpaths.sort();
+
+                    cb(null, fullpaths);
+                });
+            }
+        });
+    }, callback);
+};
+
+/**
+ * Evaluates JavaScript files in a sandbox, returning the context. The first
+ * argument can either be a single filename or an array of filenames. If
+ * multiple filenames are given their contents are concatenated before
+ * evalution. The second argument is an optional context to use for the sandbox.
+ *
+ * @param files
+ * @param {Object} sandbox
+ * @return {Object}
+ * @api public
+ */
+
+exports.sandbox = function (files, /*optional*/sandbox) {
+    var source, script, result;
+    if (!(files instanceof Array)) {
+        files = [files];
+    }
+    source = files.map(function (file) {
+        return fs.readFileSync(file, 'utf8');
+    }).join('');
+
+    if (!sandbox) {
+        sandbox = {};
+    }
+    script = new Script(source);
+    result = script.runInNewContext(sandbox);
+    return sandbox;
+};
+
+/**
+ * Provides a http request, response testing environment.
+ *
+ * Example:
+ *
+ *  var httputil = require('nodeunit').utils.httputil
+ *  exports.testSomething = function(test) {
+ *    httputil(function (req, resp) {
+ *        resp.writeHead(200, {});
+ *        resp.end('test data');
+ *      },
+ *      function(server, client) {
+ *        client.fetch('GET', '/', {}, function(resp) {
+ *          test.equal('test data', resp.body);
+ *          server.close();
+ *          test.done();
+ *        })
+ *      });
+ *  };
+ *
+ * @param {Function} cgi
+ * @param {Function} envReady
+ * @api public
+ */
+exports.httputil = function (cgi, envReady) {
+    var hostname = process.env.HOSTNAME || 'localhost';
+    var port = process.env.PORT || 3000;
+
+    var server = http.createServer(cgi);
+    server.listen(port, hostname);
+
+    var client = http.createClient(port, hostname);
+    client.fetch = function (method, path, headers, respReady) {
+        var request = this.request(method, path, headers);
+        request.end();
+        request.on('response', function (response) {
+            response.setEncoding('utf8');
+            response.on('data', function (chunk) {
+                if (response.body) {
+                    response.body += chunk;
+                } else {
+                    response.body = chunk;
+                }
+            });
+            response.on('end', function () {
+                if (response.headers['content-type'] === 'application/json') {
+                    response.bodyAsObject = JSON.parse(response.body);
+                }
+                respReady(response);
+            });
+        });
+    };
+
+    process.nextTick(function () {
+        if (envReady && typeof envReady === 'function') {
+            envReady(server, client);
+        }
+    });
+};
+
+
+/**
+ * Improves formatting of AssertionError messages to make deepEqual etc more
+ * readable.
+ *
+ * @param {Object} assertion
+ * @return {Object}
+ * @api public
+ */
+
+exports.betterErrors = function (assertion) {
+    if (!assertion.error) return;
+
+    var e = assertion.error;
+    // deepEqual error message is a bit sucky, lets improve it!
+    // e.actual and e.expected could be null or undefined, so
+    // using getOwnPropertyDescriptor to see if they exist:
+    if (Object.getOwnPropertyDescriptor(e, 'actual') &&
+        Object.getOwnPropertyDescriptor(e, 'expected')) {
+
+        // alexgorbatchev 2010-10-22 :: Added a bit of depth to inspection
+        var actual = util.inspect(e.actual, false, 10).replace(/\n$/, '');
+        var expected = util.inspect(e.expected, false, 10).replace(/\n$/, '');
+        var multiline = (
+            actual.indexOf('\n') !== -1 ||
+            expected.indexOf('\n') !== -1
+        );
+        var spacing = (multiline ? '\n' : ' ');
+        e._message = e.message;
+        e.stack = (
+            e.name + ':' + spacing +
+            actual + spacing + e.operator + spacing +
+            expected + '\n' +
+            e.stack.split('\n').slice(1).join('\n')
+        );
+    }
+    return assertion;
+};