mobile_template 0.0.1

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

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+var
+    fs = require('fs'),
+    path = require('path');
+
+// TODO: remove this when https://github.com/joyent/node/pull/1312
+//       lands in core.
+//
+// Until then, use console.log from npm (https://gist.github.com/1077544)
+require('../deps/console.log');
+
+require.paths.push(process.cwd());
+var args = process.ARGV.slice(2);
+
+var files = [];
+
+var testrunner,
+    config_file,
+    config_param_found = false,
+    output_param_found = false,
+    reporter_file = 'default',
+    reporter_param_found = false,
+    testspec_param_found = false;
+
+var usage = "Usage: nodeunit [options] testmodule1.js testfolder [...] \n" +
+            "Options:\n\n" +
+            "  --config FILE     the path to a JSON file with options\n" +
+            "  --reporter FILE   optional path to a reporter file to customize the output\n" +
+            "  --list-reporters  list available build-in reporters\n" +
+            "  -t name,          specify a test to run\n" +
+            "  -h, --help        display this help and exit\n" +
+            "  -v, --version     output version information and exit";
+
+
+// load default options
+var content = fs.readFileSync(__dirname + '/nodeunit.json', 'utf8');
+var options = JSON.parse(content);
+
+// a very basic pseudo --options parser
+args.forEach(function (arg) {
+    if (arg.slice(0, 9) === "--config=") {
+        config_file = arg.slice(9);
+    } else if (arg === '--config') {
+        config_param_found = true;
+    } else if (config_param_found) {
+        config_file = arg;
+        config_param_found = false;
+    } else if (arg.slice(0, 9) === "--output=") {
+        options.output = arg.slice(9);
+    } else if (arg === '--output') {
+        output_param_found = true;
+    } else if (output_param_found) {
+        options.output = arg;
+        output_param_found = false;
+    } else if (arg.slice(0, 11) === "--reporter=") {
+        reporter_file = arg.slice(11);
+    } else if (arg === '--reporter') {
+        reporter_param_found = true;
+    } else if (reporter_param_found) {
+        reporter_file = arg;
+        reporter_param_found = false;
+    } else if (arg === '-t') {
+        testspec_param_found = true;
+    } else if (testspec_param_found) {
+        options.testspec = arg;
+        testspec_param_found = false;
+    } else if (arg === '--list-reporters') {
+        var reporters = fs.readdirSync(__dirname + '/../lib/reporters');
+        reporters = reporters.filter(function (reporter_file) {
+            return (/\.js$/).test(reporter_file);
+        }).map(function (reporter_file) {
+            return reporter_file.replace(/\.js$/, '');
+        }).filter(function (reporter_file) {
+            return reporter_file !== 'index';
+        });
+        console.log('Build-in reporters: ');
+        reporters.forEach(function (reporter_file) {
+            var reporter = require('../lib/reporters/' + reporter_file);
+            console.log('  * ' + reporter_file + (reporter.info ? ': ' + reporter.info : ''));
+        });
+        process.exit(0);
+    } else if ((arg === '-v') || (arg === '--version')) {
+        var content = fs.readFileSync(__dirname + '/../package.json', 'utf8');
+        var pkg = JSON.parse(content);
+        console.log(pkg.version);
+        process.exit(0);
+    } else if ((arg === '-h') || (arg === '--help')) {
+        console.log(usage);
+        process.exit(0);
+    } else {
+        files.push(arg);
+    }
+});
+
+if (files.length === 0) {
+    console.log('Files required.');
+    console.log(usage);
+    process.exit(1);
+}
+
+if (config_file) {
+    content = fs.readFileSync(config_file, 'utf8');
+    var custom_options = JSON.parse(content);
+    
+    for (var option in custom_options) {
+        if (typeof option === 'string') {
+            options[option] = custom_options[option];
+        }
+    }
+}
+
+var builtin_reporters = require(__dirname + '/../lib/reporters');
+if (reporter_file in builtin_reporters) {
+    testrunner = builtin_reporters[reporter_file];
+}
+else {
+    testrunner = require(reporter_file);
+}
+testrunner.run(files, options);

data/templates/cordova_android/bin/node_modules/coffee-script/.npmignore

@@ -0,0 +1,11 @@
+*.coffee
+*.html
+.DS_Store
+.git*
+Cakefile
+documentation/
+examples/
+extras/coffee-script.js
+raw/
+src/
+test/

data/templates/cordova_android/bin/node_modules/coffee-script/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Jeremy Ashkenas
+
+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.

data/templates/cordova_android/bin/node_modules/coffee-script/README

@@ -0,0 +1,48 @@
+=
+            {
+         }   }   {
+        {   {  }  }
+         }   }{  {
+        {  }{  }  }                    _____       __  __
+       ( }{ }{  { )                   / ____|     / _|/ _|
+     .- { { }  { }} -.               | |     ___ | |_| |_ ___  ___
+    (  ( } { } { } }  )              | |    / _ \|  _|  _/ _ \/ _ \
+    |`-..________ ..-'|              | |___| (_) | | | ||  __/  __/
+    |                 |               \_____\___/|_| |_| \___|\___|
+    |                 ;--.
+    |                (__  \            _____           _       _
+    |                 | )  )          / ____|         (_)     | |
+    |                 |/  /          | (___   ___ _ __ _ _ __ | |_
+    |                 (  /            \___ \ / __| '__| | '_ \| __|
+    |                 |/              ____) | (__| |  | | |_) | |_
+    |                 |              |_____/ \___|_|  |_| .__/ \__|
+     `-.._________..-'                                  | |
+                                                        |_|
+
+
+  CoffeeScript is a little language that compiles into JavaScript.
+
+  Install Node.js, and then the CoffeeScript compiler:
+  sudo bin/cake install
+
+  Or, if you have the Node Package Manager installed:
+  npm install -g coffee-script
+  (Leave off the -g if you don't wish to install globally.)
+
+  Compile a script:
+  coffee /path/to/script.coffee
+
+  For documentation, usage, and examples, see:
+  http://coffeescript.org/
+
+  To suggest a feature, report a bug, or general discussion:
+  http://github.com/jashkenas/coffee-script/issues/
+
+  If you'd like to chat, drop by #coffeescript on Freenode IRC,
+  or on webchat.freenode.net.
+
+  The source repository:
+  git://github.com/jashkenas/coffee-script.git
+
+  All contributors are listed here:
+  http://github.com/jashkenas/coffee-script/contributors

data/templates/cordova_android/bin/node_modules/coffee-script/Rakefile

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'erb'
+require 'fileutils'
+require 'rake/testtask'
+require 'json'
+
+desc "Build the documentation page"
+task :doc do
+  source = 'documentation/index.html.erb'
+  child = fork { exec "bin/coffee -bcw -o documentation/js documentation/coffee/*.coffee" }
+  at_exit { Process.kill("INT", child) }
+  Signal.trap("INT") { exit }
+  loop do
+    mtime = File.stat(source).mtime
+    if !@mtime || mtime > @mtime
+      rendered = ERB.new(File.read(source)).result(binding)
+      File.open('index.html', 'w+') {|f| f.write(rendered) }
+    end
+    @mtime = mtime
+    sleep 1
+  end
+end
+
+desc "Build coffee-script-source gem"
+task :gem do
+  require 'rubygems'
+  require 'rubygems/package'
+
+  gemspec = Gem::Specification.new do |s|
+    s.name      = 'coffee-script-source'
+    s.version   = JSON.parse(File.read('package.json'))["version"]
+    s.date      = Time.now.strftime("%Y-%m-%d")
+
+    s.homepage    = "http://jashkenas.github.com/coffee-script/"
+    s.summary     = "The CoffeeScript Compiler"
+    s.description = <<-EOS
+      CoffeeScript is a little language that compiles into JavaScript.
+      Underneath all of those embarrassing braces and semicolons,
+      JavaScript has always had a gorgeous object model at its heart.
+      CoffeeScript is an attempt to expose the good parts of JavaScript
+      in a simple way.
+    EOS
+
+    s.files = [
+      'lib/coffee_script/coffee-script.js',
+      'lib/coffee_script/source.rb'
+    ]
+
+    s.authors           = ['Jeremy Ashkenas']
+    s.email             = 'jashkenas@gmail.com'
+    s.rubyforge_project = 'coffee-script-source'
+  end
+
+  file = File.open("coffee-script-source.gem", "w")
+  Gem::Package.open(file, 'w') do |pkg|
+    pkg.metadata = gemspec.to_yaml
+
+    path = "lib/coffee_script/source.rb"
+    contents = <<-ERUBY
+module CoffeeScript
+  module Source
+    def self.bundled_path
+      File.expand_path("../coffee-script.js", __FILE__)
+    end
+  end
+end
+    ERUBY
+    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
+      tar_io.write(contents)
+    end
+
+    contents = File.read("extras/coffee-script.js")
+    path = "lib/coffee_script/coffee-script.js"
+    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
+      tar_io.write(contents)
+    end
+  end
+end

data/templates/cordova_android/bin/node_modules/coffee-script/bin/cake

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/cake').run();

data/templates/cordova_android/bin/node_modules/coffee-script/bin/coffee

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/command').run();

data/templates/cordova_android/bin/node_modules/coffee-script/extras/jsl.conf

@@ -0,0 +1,44 @@
+# JavaScriptLint configuration file for CoffeeScript.
+
++no_return_value              # function {0} does not always return a value
++duplicate_formal             # duplicate formal argument {0}
+-equal_as_assign              # test for equality (==) mistyped as assignment (=)?{0}
++var_hides_arg                # variable {0} hides argument
++redeclared_var               # redeclaration of {0} {1}
+-anon_no_return_value         # anonymous function does not always return a value
++missing_semicolon            # missing semicolon
++meaningless_block            # meaningless block; curly braces have no impact
+-comma_separated_stmts        # multiple statements separated by commas (use semicolons?)
++unreachable_code             # unreachable code
++missing_break                # missing break statement
+-missing_break_for_last_case  # missing break statement for last case in switch
+-comparison_type_conv         # comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)
+-inc_dec_within_stmt          # increment (++) and decrement (--) operators used as part of greater statement
+-useless_void                 # use of the void type may be unnecessary (void is always undefined)
++multiple_plus_minus          # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs
++use_of_label                 # use of label
+-block_without_braces         # block statement without curly braces
++leading_decimal_point        # leading decimal point may indicate a number or an object member
++trailing_decimal_point       # trailing decimal point may indicate a number or an object member
++octal_number                 # leading zeros make an octal number
++nested_comment               # nested comment
++misplaced_regex              # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
++ambiguous_newline            # unexpected end of line; it is ambiguous whether these lines are part of the same statement
++empty_statement              # empty statement or extra semicolon
+-missing_option_explicit      # the "option explicit" control comment is missing
++partial_option_explicit      # the "option explicit" control comment, if used, must be in the first script tag
++dup_option_explicit          # duplicate "option explicit" control comment
++useless_assign               # useless assignment
++ambiguous_nested_stmt        # block statements containing block statements should use curly braces to resolve ambiguity
++ambiguous_else_stmt          # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent)
+-missing_default_case         # missing default case in switch statement
++duplicate_case_in_switch     # duplicate case in switch statements
++default_not_at_end           # the default case is not at the end of the switch statement
++legacy_cc_not_understood     # couldn't understand control comment using /*@keyword@*/ syntax
++jsl_cc_not_understood        # couldn't understand control comment using /*jsl:keyword*/ syntax
++useless_comparison           # useless comparison; comparing identical expressions
++with_statement               # with statement hides undeclared variables; use temporary variable instead
++trailing_comma_in_array      # extra comma is not recommended in array initializers
++assign_to_function_call      # assignment to a function call
++parseint_missing_radix       # parseInt missing radix parameter
++lambda_assign_requires_semicolon

data/templates/cordova_android/bin/node_modules/coffee-script/lib/browser.js

@@ -0,0 +1,75 @@
+(function() {
+  var CoffeeScript, runScripts;
+  CoffeeScript = require('./coffee-script');
+  CoffeeScript.require = require;
+  CoffeeScript.eval = function(code, options) {
+    return eval(CoffeeScript.compile(code, options));
+  };
+  CoffeeScript.run = function(code, options) {
+    if (options == null) {
+      options = {};
+    }
+    options.bare = true;
+    return Function(CoffeeScript.compile(code, options))();
+  };
+  if (typeof window === "undefined" || window === null) {
+    return;
+  }
+  CoffeeScript.load = function(url, callback) {
+    var xhr;
+    xhr = new (window.ActiveXObject || XMLHttpRequest)('Microsoft.XMLHTTP');
+    xhr.open('GET', url, true);
+    if ('overrideMimeType' in xhr) {
+      xhr.overrideMimeType('text/plain');
+    }
+    xhr.onreadystatechange = function() {
+      var _ref;
+      if (xhr.readyState === 4) {
+        if ((_ref = xhr.status) === 0 || _ref === 200) {
+          CoffeeScript.run(xhr.responseText);
+        } else {
+          throw new Error("Could not load " + url);
+        }
+        if (callback) {
+          return callback();
+        }
+      }
+    };
+    return xhr.send(null);
+  };
+  runScripts = function() {
+    var coffees, execute, index, length, s, scripts;
+    scripts = document.getElementsByTagName('script');
+    coffees = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = scripts.length; _i < _len; _i++) {
+        s = scripts[_i];
+        if (s.type === 'text/coffeescript') {
+          _results.push(s);
+        }
+      }
+      return _results;
+    })();
+    index = 0;
+    length = coffees.length;
+    (execute = function() {
+      var script;
+      script = coffees[index++];
+      if ((script != null ? script.type : void 0) === 'text/coffeescript') {
+        if (script.src) {
+          return CoffeeScript.load(script.src, execute);
+        } else {
+          CoffeeScript.run(script.innerHTML);
+          return execute();
+        }
+      }
+    })();
+    return null;
+  };
+  if (window.addEventListener) {
+    addEventListener('DOMContentLoaded', runScripts, false);
+  } else {
+    attachEvent('onload', runScripts);
+  }
+}).call(this);

data/templates/cordova_android/bin/node_modules/coffee-script/lib/cake.js

@@ -0,0 +1,76 @@
+(function() {
+  var CoffeeScript, fs, helpers, missingTask, oparse, options, optparse, path, printTasks, switches, tasks;
+  fs = require('fs');
+  path = require('path');
+  helpers = require('./helpers');
+  optparse = require('./optparse');
+  CoffeeScript = require('./coffee-script');
+  tasks = {};
+  options = {};
+  switches = [];
+  oparse = null;
+  helpers.extend(global, {
+    task: function(name, description, action) {
+      var _ref;
+      if (!action) {
+        _ref = [description, action], action = _ref[0], description = _ref[1];
+      }
+      return tasks[name] = {
+        name: name,
+        description: description,
+        action: action
+      };
+    },
+    option: function(letter, flag, description) {
+      return switches.push([letter, flag, description]);
+    },
+    invoke: function(name) {
+      if (!tasks[name]) {
+        missingTask(name);
+      }
+      return tasks[name].action(options);
+    }
+  });
+  exports.run = function() {
+    return path.exists('Cakefile', function(exists) {
+      var arg, args, _i, _len, _ref, _results;
+      if (!exists) {
+        throw new Error("Cakefile not found in " + (process.cwd()));
+      }
+      args = process.argv.slice(2);
+      CoffeeScript.run(fs.readFileSync('Cakefile').toString(), {
+        filename: 'Cakefile'
+      });
+      oparse = new optparse.OptionParser(switches);
+      if (!args.length) {
+        return printTasks();
+      }
+      options = oparse.parse(args);
+      _ref = options.arguments;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        arg = _ref[_i];
+        _results.push(invoke(arg));
+      }
+      return _results;
+    });
+  };
+  printTasks = function() {
+    var desc, name, spaces, task;
+    console.log('');
+    for (name in tasks) {
+      task = tasks[name];
+      spaces = 20 - name.length;
+      spaces = spaces > 0 ? Array(spaces + 1).join(' ') : '';
+      desc = task.description ? "# " + task.description : '';
+      console.log("cake " + name + spaces + " " + desc);
+    }
+    if (switches.length) {
+      return console.log(oparse.help());
+    }
+  };
+  missingTask = function(task) {
+    console.log("No such task: \"" + task + "\"");
+    return process.exit(1);
+  };
+}).call(this);

data/templates/cordova_android/bin/node_modules/coffee-script/lib/coffee-script.js

@@ -0,0 +1,135 @@
+(function() {
+  var Lexer, RESERVED, compile, fs, lexer, parser, path, _ref;
+  var __hasProp = Object.prototype.hasOwnProperty;
+  fs = require('fs');
+  path = require('path');
+  _ref = require('./lexer'), Lexer = _ref.Lexer, RESERVED = _ref.RESERVED;
+  parser = require('./parser').parser;
+  if (require.extensions) {
+    require.extensions['.coffee'] = function(module, filename) {
+      var content;
+      content = compile(fs.readFileSync(filename, 'utf8'), {
+        filename: filename
+      });
+      return module._compile(content, filename);
+    };
+  } else if (require.registerExtension) {
+    require.registerExtension('.coffee', function(content) {
+      return compile(content);
+    });
+  }
+  exports.VERSION = '1.1.2';
+  exports.RESERVED = RESERVED;
+  exports.helpers = require('./helpers');
+  exports.compile = compile = function(code, options) {
+    if (options == null) {
+      options = {};
+    }
+    try {
+      return (parser.parse(lexer.tokenize(code))).compile(options);
+    } catch (err) {
+      if (options.filename) {
+        err.message = "In " + options.filename + ", " + err.message;
+      }
+      throw err;
+    }
+  };
+  exports.tokens = function(code, options) {
+    return lexer.tokenize(code, options);
+  };
+  exports.nodes = function(source, options) {
+    if (typeof source === 'string') {
+      return parser.parse(lexer.tokenize(source, options));
+    } else {
+      return parser.parse(source);
+    }
+  };
+  exports.run = function(code, options) {
+    var Module, mainModule;
+    mainModule = require.main;
+    mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
+    mainModule.moduleCache && (mainModule.moduleCache = {});
+    if (process.binding('natives').module) {
+      Module = require('module').Module;
+      mainModule.paths = Module._nodeModulePaths(path.dirname(options.filename));
+    }
+    if (path.extname(mainModule.filename) !== '.coffee' || require.extensions) {
+      return mainModule._compile(compile(code, options), mainModule.filename);
+    } else {
+      return mainModule._compile(code, mainModule.filename);
+    }
+  };
+  exports.eval = function(code, options) {
+    var Module, Script, js, k, o, r, sandbox, v, _i, _len, _module, _ref2, _ref3, _ref4, _require;
+    if (options == null) {
+      options = {};
+    }
+    if (!(code = code.trim())) {
+      return;
+    }
+    if (_ref2 = require('vm'), Script = _ref2.Script, _ref2) {
+      sandbox = Script.createContext();
+      sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
+      if (options.sandbox != null) {
+        if (options.sandbox instanceof sandbox.constructor) {
+          sandbox = options.sandbox;
+        } else {
+          _ref3 = options.sandbox;
+          for (k in _ref3) {
+            if (!__hasProp.call(_ref3, k)) continue;
+            v = _ref3[k];
+            sandbox[k] = v;
+          }
+        }
+      }
+      sandbox.__filename = options.filename || 'eval';
+      sandbox.__dirname = path.dirname(sandbox.__filename);
+      if (!(sandbox.module || sandbox.require)) {
+        Module = require('module');
+        sandbox.module = _module = new Module(options.modulename || 'eval');
+        sandbox.require = _require = function(path) {
+          return Module._load(path, _module);
+        };
+        _module.filename = sandbox.__filename;
+        _ref4 = Object.getOwnPropertyNames(require);
+        for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
+          r = _ref4[_i];
+          _require[r] = require[r];
+        }
+        _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
+        _require.resolve = function(request) {
+          return Module._resolveFilename(request, _module);
+        };
+      }
+    }
+    o = {};
+    for (k in options) {
+      if (!__hasProp.call(options, k)) continue;
+      v = options[k];
+      o[k] = v;
+    }
+    o.bare = true;
+    js = compile(code, o);
+    if (Script) {
+      return Script.runInContext(js, sandbox);
+    } else {
+      return eval(js);
+    }
+  };
+  lexer = new Lexer;
+  parser.lexer = {
+    lex: function() {
+      var tag, _ref2;
+      _ref2 = this.tokens[this.pos++] || [''], tag = _ref2[0], this.yytext = _ref2[1], this.yylineno = _ref2[2];
+      return tag;
+    },
+    setInput: function(tokens) {
+      this.tokens = tokens;
+      return this.pos = 0;
+    },
+    upcomingInput: function() {
+      return "";
+    }
+  };
+  parser.yy = require('./nodes');
+}).call(this);