mobile_template 0.0.1

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

@@ -0,0 +1,82 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var async = require('../deps/async'),
+    types = require('./types'),
+    utils = require('./utils'),
+    core = require('./core'),
+    reporters = require('./reporters'),
+    assert = require('./assert'),
+    path = require('path');
+
+
+/**
+ * Export sub-modules.
+ */
+
+exports.types = types;
+exports.utils = utils;
+exports.reporters = reporters;
+exports.assert = assert;
+
+// backwards compatibility
+exports.testrunner = {
+    run: function () {
+        console.log(
+            'WARNING: nodeunit.testrunner is going to be deprecated, please ' +
+            'use nodeunit.reporters.default instead!'
+        );
+        return reporters['default'].run.apply(this, arguments);
+    }
+};
+
+
+/**
+ * Export all core functions
+ */
+
+for (var k in core) {
+    exports[k] = core[k];
+};
+
+
+/**
+ * Load modules from paths array and run all exported tests in series. If a path
+ * is a directory, load all supported file types inside it as modules. This only
+ * reads 1 level deep in the directory and does not recurse through
+ * sub-directories.
+ *
+ * @param {Array} paths
+ * @param {Object} opt
+ * @api public
+ */
+
+exports.runFiles = function (paths, opt) {
+    var all_assertions = [];
+    var options = types.options(opt);
+    var start = new Date().getTime();
+
+    if (!paths.length) {
+        return options.done(types.assertionList(all_assertions));
+    }
+
+    utils.modulePaths(paths, function (err, files) {
+        if (err) throw err;
+        async.concatSeries(files, function (file, cb) {
+            var name = path.basename(file);
+            exports.runModule(name, require(file), options, cb);
+        },
+        function (err, all_assertions) {
+            var end = new Date().getTime();
+            options.done(types.assertionList(all_assertions, end - start));
+        });
+    });
+
+};

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

@@ -0,0 +1,119 @@
+/*!
+ * 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
+ */
+
+
+/**
+ * NOTE: this test runner is not listed in index.js because it cannot be
+ * used with the command-line tool, only inside the browser.
+ */
+
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "Browser-based test reporter";
+
+
+/**
+ * Run all tests within each module, reporting the results
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (modules, options) {
+    var start = new Date().getTime();
+
+    function setText(el, txt) {
+        if ('innerText' in el) {
+            el.innerText = txt;
+        }
+        else if ('textContent' in el){
+            el.textContent = txt;
+        }
+    }
+
+    function getOrCreate(tag, id) {
+        var el = document.getElementById(id);
+        if (!el) {
+            el = document.createElement(tag);
+            el.id = id;
+            document.body.appendChild(el);
+        }
+        return el;
+    };
+
+    var header = getOrCreate('h1', 'nodeunit-header');
+    var banner = getOrCreate('h2', 'nodeunit-banner');
+    var userAgent = getOrCreate('h2', 'nodeunit-userAgent');
+    var tests = getOrCreate('ol', 'nodeunit-tests');
+    var result = getOrCreate('p', 'nodeunit-testresult');
+
+    setText(userAgent, navigator.userAgent);
+
+    nodeunit.runModules(modules, {
+        moduleStart: function (name) {
+            /*var mheading = document.createElement('h2');
+            mheading.innerText = name;
+            results.appendChild(mheading);
+            module = document.createElement('ol');
+            results.appendChild(module);*/
+        },
+        testDone: function (name, assertions) {
+            var test = document.createElement('li');
+            var strong = document.createElement('strong');
+            strong.innerHTML = name + ' <b style="color: black;">(' +
+                '<b class="fail">' + assertions.failures() + '</b>, ' +
+                '<b class="pass">' + assertions.passes() + '</b>, ' +
+                assertions.length +
+            ')</b>';
+            test.className = assertions.failures() ? 'fail': 'pass';
+            test.appendChild(strong);
+
+            var aList = document.createElement('ol');
+            aList.style.display = 'none';
+            test.onclick = function () {
+                var d = aList.style.display;
+                aList.style.display = (d == 'none') ? 'block': 'none';
+            };
+            for (var i=0; i<assertions.length; i++) {
+                var li = document.createElement('li');
+                var a = assertions[i];
+                if (a.failed()) {
+                    li.innerHTML = (a.message || a.method || 'no message') +
+                        '<pre>' + (a.error.stack || a.error) + '</pre>';
+                    li.className = 'fail';
+                }
+                else {
+                    li.innerHTML = a.message || a.method || 'no message';
+                    li.className = 'pass';
+                }
+                aList.appendChild(li);
+            }
+            test.appendChild(aList);
+            tests.appendChild(test);
+        },
+        done: function (assertions) {
+            var end = new Date().getTime();
+            var duration = end - start;
+
+            var failures = assertions.failures();
+            banner.className = failures ? 'fail': 'pass';
+
+            result.innerHTML = 'Tests completed in ' + duration +
+                ' milliseconds.<br/><span class="passed">' +
+                assertions.passes() + '</span> assertions of ' +
+                '<span class="all">' + assertions.length + '<span> passed, ' +
+                assertions.failures() + ' failed.';
+        }
+    });
+};

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

@@ -0,0 +1,123 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var nodeunit = require('../nodeunit'),
+    utils = require('../utils'),
+    fs = require('fs'),
+    track = require('../track'),
+    path = require('path');
+    AssertionError = require('../assert').AssertionError;
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "Default tests reporter";
+
+
+/**
+ * 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);
+    });
+    var tracker = track.createTracker(function (tracker) {
+        if (tracker.unfinished()) {
+            console.log('');
+            console.log(error(bold(
+                'FAILURES: Undone tests (or their setups/teardowns): '
+            )));
+            var names = tracker.names();
+            for (var i = 0; i < names.length; i += 1) {
+                console.log('- ' + names[i]);
+            }
+            console.log('');
+            console.log('To fix this, make sure all tests call test.done()');
+            process.reallyExit(tracker.unfinished());
+        }
+    });
+
+    nodeunit.runFiles(paths, {
+        testspec: options.testspec,
+        moduleStart: function (name) {
+            console.log('\n' + bold(name));
+        },
+        testDone: function (name, assertions) {
+            tracker.remove(name);
+
+            if (!assertions.failures()) {
+                console.log('✔ ' + name);
+            }
+            else {
+                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');
+                    }
+                });
+            }
+        },
+        done: function (assertions, end) {
+            var end = 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)'
+                );
+            }
+        },
+        testStart: function(name) {
+            tracker.put(name);
+        }
+    });
+};

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

@@ -0,0 +1,107 @@
+/*!
+ * 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 = "Report tests result as HTML";
+
+/**
+ * Run all tests within each module, reporting the results to the command-line.
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (files, options) {
+
+    var start = new Date().getTime();
+    var paths = files.map(function (p) {
+        return path.join(process.cwd(), p);
+    });
+
+    console.log('<html>');
+    console.log('<head>');
+    console.log('<title></title>');
+    console.log('<style type="text/css">');
+    console.log('body { font: 12px Helvetica Neue }');
+    console.log('h2 { margin:0 ; padding:0 }');
+    console.log('pre { font: 11px Andale Mono; margin-left: 1em; padding-left: 1em; margin-top:0; font-size:smaller;}');
+    console.log('.assertion_message { margin-left: 1em; }');
+    console.log('  ol {' +
+    '	list-style: none;' +
+    '	margin-left: 1em;' +
+    '	padding-left: 1em;' +
+    '	text-indent: -1em;' +
+    '}');
+    console.log('  ol li.pass:before { content: "\\2714 \\0020"; }');
+    console.log('  ol li.fail:before { content: "\\2716 \\0020"; }');
+    console.log('</style>');
+    console.log('</head>');
+    console.log('<body>');
+    nodeunit.runFiles(paths, {
+        testspec: options.testspec,
+        moduleStart: function (name) {
+            console.log('<h2>' + name + '</h2>');
+            console.log('<ol>');
+        },
+        testDone: function (name, assertions) {
+            if (!assertions.failures()) {
+                console.log('<li class="pass">' + name + '</li>');
+            }
+            else {
+                console.log('<li class="fail">' + name);
+                assertions.forEach(function (a) {
+                    if (a.failed()) {
+                        a = utils.betterErrors(a);
+                        if (a.error instanceof AssertionError && a.message) {
+                            console.log('<div class="assertion_message">' +
+                                'Assertion Message: ' + a.message +
+                            '</div>');
+                        }
+                        console.log('<pre>');
+                        console.log(a.error.stack);
+                        console.log('</pre>');
+                    }
+                });
+                console.log('</li>');
+            }
+        },
+        moduleDone: function () {
+            console.log('</ol>');
+        },
+        done: function (assertions) {
+            var end = new Date().getTime();
+            var duration = end - start;
+            if (assertions.failures()) {
+                console.log(
+                    '<h3>FAILURES: '  + assertions.failures() +
+                    '/' + assertions.length + ' assertions failed (' +
+                    assertions.duration + 'ms)</h3>'
+                );
+            }
+            else {
+                console.log(
+                    '<h3>OK: ' + assertions.length +
+                    ' assertions (' + assertions.duration + 'ms)</h3>'
+                );
+            }
+            console.log('</body>');
+        }
+    });
+
+};

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

@@ -0,0 +1,9 @@
+module.exports = {
+    'junit': require('./junit'),
+    'default': require('./default'),
+    'skip_passed': require('./skip_passed'),
+    'minimal': require('./minimal'),
+    'html': require('./html')
+    // browser test reporter is not listed because it cannot be used
+    // with the command line tool, only inside a browser.
+};

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

@@ -0,0 +1,183 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var nodeunit = require('../nodeunit'),
+    utils = require('../utils'),
+    fs = require('fs'),
+    path = require('path'),
+    async = require('../../deps/async'),
+    AssertionError = require('assert').AssertionError,
+    child_process = require('child_process'),
+    ejs = require('../../deps/ejs');
+
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "jUnit XML test reports";
+
+
+/**
+ * Ensures a directory exists using mkdir -p.
+ *
+ * @param {String} path
+ * @param {Function} callback
+ * @api private
+ */
+
+var ensureDir = function (path, callback) {
+    var mkdir = child_process.spawn('mkdir', ['-p', path]);
+    mkdir.on('error', function (err) {
+        callback(err);
+        callback = function(){};
+    });
+    mkdir.on('exit', function (code) {
+        if (code === 0) callback();
+        else callback(new Error('mkdir exited with code: ' + code));
+    });
+};
+
+
+/**
+ * Returns absolute version of a path. Relative paths are interpreted
+ * relative to process.cwd() or the cwd parameter. Paths that are already
+ * absolute are returned unaltered.
+ *
+ * @param {String} p
+ * @param {String} cwd
+ * @return {String}
+ * @api public
+ */
+
+var abspath = function (p, /*optional*/cwd) {
+    if (p[0] === '/') return p;
+    cwd = cwd || process.cwd();
+    return path.normalize(path.join(cwd, p));
+};
+
+
+/**
+ * Run all tests within each module, reporting the results to the command-line,
+ * then writes out junit-compatible xml documents.
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (files, opts, callback) {
+    if (!opts.output) {
+        console.error(
+            'Error: No output directory defined.\n' +
+            '\tEither add an "output" property to your nodeunit.json config ' +
+            'file, or\n\tuse the --output command line option.'
+        );
+        return;
+    }
+    opts.output = abspath(opts.output);
+    var error = function (str) {
+        return opts.error_prefix + str + opts.error_suffix;
+    };
+    var ok    = function (str) {
+        return opts.ok_prefix + str + opts.ok_suffix;
+    };
+    var bold  = function (str) {
+        return opts.bold_prefix + str + opts.bold_suffix;
+    };
+
+    var start = new Date().getTime();
+    var paths = files.map(function (p) {
+        return path.join(process.cwd(), p);
+    });
+
+    var modules = {}
+    var curModule;
+
+    nodeunit.runFiles(paths, {
+        testspec: opts.testspec,
+        moduleStart: function (name) {
+            curModule = {
+                errorCount: 0,
+                failureCount: 0,
+                tests: 0,
+                testcases: [],
+                name: name
+            };
+            modules[name] = curModule;
+        },
+        testDone: function (name, assertions) {
+            var testcase = {name: name};
+            for (var i=0; i<assertions.length; i++) {
+                var a = assertions[i];
+                if (a.failed()) {
+                    a = utils.betterErrors(a);
+                    testcase.failure = {
+                        message: a.message,
+                        backtrace: a.error.stack
+                    };
+
+                    if (a.error instanceof AssertionError) {
+                        curModule.failureCount++;
+                    }
+                    else {
+                        curModule.errorCount++;
+                    }
+                    break;
+                }
+            }
+            curModule.tests++;
+            curModule.testcases.push(testcase);
+        },
+        done: function (assertions) {
+            var end = new Date().getTime();
+            var duration = end - start;
+
+            ensureDir(opts.output, function (err) {
+                var tmpl = __dirname + "/../../share/junit.xml.ejs";
+                fs.readFile(tmpl, function (err, data) {
+                    if (err) throw err;
+                    var tmpl = data.toString();
+
+                    async.forEach(Object.keys(modules), function (k, cb) {
+                        var module = modules[k];
+                        var rendered = ejs.render(tmpl, {
+                            locals: {suites: [module]}
+                        });
+                        var filename = path.join(
+                            opts.output,
+                            module.name + '.xml'
+                        );
+                        console.log('Writing ' + filename);
+                        fs.writeFile(filename, rendered, cb);
+                    },
+                    function (err) {
+                        if (err) throw err;
+                        else 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)'
+                            );
+                        }
+                    });
+
+                });
+            });
+
+        }
+    });
+}