coffeecake 0.0.1

data/node_modules/jasmine-runner/node_modules/coffee-script/.npmignore

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

data/node_modules/jasmine-runner/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/node_modules/jasmine-runner/node_modules/coffee-script/README

@@ -0,0 +1,47 @@
+=
+            {
+         }   }   {
+        {   {  }  }
+         }   }{  {
+        {  }{  }  }                    _____       __  __
+       ( }{ }{  { )                   / ____|     / _|/ _|
+     .- { { }  { }} -.               | |     ___ | |_| |_ ___  ___
+    (  ( } { } { } }  )              | |    / _ \|  _|  _/ _ \/ _ \
+    |`-..________ ..-'|              | |___| (_) | | | ||  __/  __/
+    |                 |               \_____\___/|_| |_| \___|\___|
+    |                 ;--.
+    |                (__  \            _____           _       _
+    |                 | )  )          / ____|         (_)     | |
+    |                 |/  /          | (___   ___ _ __ _ _ __ | |_
+    |                 (  /            \___ \ / __| '__| | '_ \| __|
+    |                 |/              ____) | (__| |  | | |_) | |_
+    |                 |              |_____/ \___|_|  |_| .__/ \__|
+     `-.._________..-'                                  | |
+                                                        |_|
+
+
+  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 coffee-script
+
+  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/node_modules/jasmine-runner/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/node_modules/jasmine-runner/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/node_modules/jasmine-runner/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/node_modules/jasmine-runner/node_modules/coffee-script/lib/browser.js

@@ -0,0 +1,52 @@
+(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, options) {
+    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() {
+      if (xhr.readyState === 4) {
+        return CoffeeScript.run(xhr.responseText, options);
+      }
+    };
+    return xhr.send(null);
+  };
+  runScripts = function() {
+    var script, _i, _len, _ref;
+    _ref = document.getElementsByTagName('script');
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      script = _ref[_i];
+      if (script.type === 'text/coffeescript') {
+        if (script.src) {
+          CoffeeScript.load(script.src);
+        } else {
+          CoffeeScript.run(script.innerHTML);
+        }
+      }
+    }
+    return null;
+  };
+  if (window.addEventListener) {
+    addEventListener('DOMContentLoaded', runScripts, false);
+  } else {
+    attachEvent('onload', runScripts);
+  }
+}).call(this);

data/node_modules/jasmine-runner/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/node_modules/jasmine-runner/node_modules/coffee-script/lib/coffee-script.js

@@ -0,0 +1,82 @@
+(function() {
+  var Lexer, RESERVED, compile, fs, lexer, parser, path, _ref;
+  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'));
+      return module._compile(content, filename);
+    };
+  } else if (require.registerExtension) {
+    require.registerExtension('.coffee', function(content) {
+      return compile(content);
+    });
+  }
+  exports.VERSION = '1.0.1';
+  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 root;
+    root = module;
+    while (root.parent) {
+      root = root.parent;
+    }
+    root.filename = options.filename ? fs.realpathSync(options.filename) : '.';
+    if (root.moduleCache) {
+      root.moduleCache = {};
+    }
+    if (path.extname(root.filename) !== '.coffee' || require.extensions) {
+      return root._compile(compile(code, options), root.filename);
+    } else {
+      return root._compile(code, root.filename);
+    }
+  };
+  exports.eval = function(code, options) {
+    var __dirname, __filename;
+    __filename = module.filename = options.filename;
+    __dirname = path.dirname(__filename);
+    return eval(compile(code, options));
+  };
+  lexer = new Lexer;
+  parser.lexer = {
+    lex: function() {
+      var tag, _ref;
+      _ref = this.tokens[this.pos++] || [''], tag = _ref[0], this.yytext = _ref[1], this.yylineno = _ref[2];
+      return tag;
+    },
+    setInput: function(tokens) {
+      this.tokens = tokens;
+      return this.pos = 0;
+    },
+    upcomingInput: function() {
+      return "";
+    }
+  };
+  parser.yy = require('./nodes');
+}).call(this);

data/node_modules/jasmine-runner/node_modules/coffee-script/lib/command.js

@@ -0,0 +1,269 @@
+(function() {
+  var BANNER, CoffeeScript, EventEmitter, SWITCHES, compileJoin, compileOptions, compileScript, compileScripts, compileStdio, contents, exec, forkNode, fs, helpers, lint, loadRequires, optionParser, optparse, opts, parseOptions, path, printLine, printTokens, printWarn, sources, spawn, usage, version, watch, writeJs, _ref;
+  fs = require('fs');
+  path = require('path');
+  helpers = require('./helpers');
+  optparse = require('./optparse');
+  CoffeeScript = require('./coffee-script');
+  _ref = require('child_process'), spawn = _ref.spawn, exec = _ref.exec;
+  EventEmitter = require('events').EventEmitter;
+  helpers.extend(CoffeeScript, new EventEmitter);
+  printLine = function(line) {
+    return process.stdout.write(line + '\n');
+  };
+  printWarn = function(line) {
+    return process.binding('stdio').writeError(line + '\n');
+  };
+  BANNER = 'Usage: coffee [options] path/to/script.coffee';
+  SWITCHES = [['-c', '--compile', 'compile to JavaScript and save as .js files'], ['-i', '--interactive', 'run an interactive CoffeeScript REPL'], ['-o', '--output [DIR]', 'set the directory for compiled JavaScript'], ['-j', '--join', 'concatenate the scripts before compiling'], ['-w', '--watch', 'watch scripts for changes, and recompile'], ['-p', '--print', 'print the compiled JavaScript to stdout'], ['-l', '--lint', 'pipe the compiled JavaScript through JSLint'], ['-s', '--stdio', 'listen for and compile scripts over stdio'], ['-e', '--eval', 'compile a string from the command line'], ['-r', '--require [FILE*]', 'require a library before executing your script'], ['-b', '--bare', 'compile without the top-level function wrapper'], ['-t', '--tokens', 'print the tokens that the lexer produces'], ['-n', '--nodes', 'print the parse tree that Jison produces'], ['--nodejs [ARGS]', 'pass options through to the "node" binary'], ['-v', '--version', 'display CoffeeScript version'], ['-h', '--help', 'display this help message']];
+  opts = {};
+  sources = [];
+  contents = [];
+  optionParser = null;
+  exports.run = function() {
+    parseOptions();
+    if (opts.nodejs) {
+      return forkNode();
+    }
+    if (opts.help) {
+      return usage();
+    }
+    if (opts.version) {
+      return version();
+    }
+    if (opts.require) {
+      loadRequires();
+    }
+    if (opts.interactive) {
+      return require('./repl');
+    }
+    if (opts.stdio) {
+      return compileStdio();
+    }
+    if (opts.eval) {
+      return compileScript(null, sources[0]);
+    }
+    if (!sources.length) {
+      return require('./repl');
+    }
+    if (opts.run) {
+      opts.literals = sources.splice(1).concat(opts.literals);
+    }
+    process.ARGV = process.argv = process.argv.slice(0, 2).concat(opts.literals);
+    return compileScripts();
+  };
+  compileScripts = function() {
+    var base, compile, source, _i, _len, _results;
+    _results = [];
+    for (_i = 0, _len = sources.length; _i < _len; _i++) {
+      source = sources[_i];
+      base = path.join(source);
+      compile = function(source, topLevel) {
+        return path.exists(source, function(exists) {
+          if (topLevel && !exists) {
+            throw new Error("File not found: " + source);
+          }
+          return fs.stat(source, function(err, stats) {
+            if (stats.isDirectory()) {
+              return fs.readdir(source, function(err, files) {
+                var file, _i, _len, _results;
+                _results = [];
+                for (_i = 0, _len = files.length; _i < _len; _i++) {
+                  file = files[_i];
+                  _results.push(compile(path.join(source, file)));
+                }
+                return _results;
+              });
+            } else if (topLevel || path.extname(source) === '.coffee') {
+              fs.readFile(source, function(err, code) {
+                if (opts.join) {
+                  contents[sources.indexOf(source)] = code.toString();
+                  if (helpers.compact(contents).length === sources.length) {
+                    return compileJoin();
+                  }
+                } else {
+                  return compileScript(source, code.toString(), base);
+                }
+              });
+              if (opts.watch && !opts.join) {
+                return watch(source, base);
+              }
+            }
+          });
+        });
+      };
+      _results.push(compile(source, true));
+    }
+    return _results;
+  };
+  compileScript = function(file, input, base) {
+    var o, options, t, task;
+    o = opts;
+    options = compileOptions(file);
+    try {
+      t = task = {
+        file: file,
+        input: input,
+        options: options
+      };
+      CoffeeScript.emit('compile', task);
+      if (o.tokens) {
+        return printTokens(CoffeeScript.tokens(t.input));
+      } else if (o.nodes) {
+        return printLine(CoffeeScript.nodes(t.input).toString().trim());
+      } else if (o.run) {
+        return CoffeeScript.run(t.input, t.options);
+      } else {
+        t.output = CoffeeScript.compile(t.input, t.options);
+        CoffeeScript.emit('success', task);
+        if (o.print) {
+          return printLine(t.output.trim());
+        } else if (o.compile) {
+          return writeJs(t.file, t.output, base);
+        } else if (o.lint) {
+          return lint(t.file, t.output);
+        }
+      }
+    } catch (err) {
+      CoffeeScript.emit('failure', err, task);
+      if (CoffeeScript.listeners('failure').length) {
+        return;
+      }
+      if (o.watch) {
+        return printLine(err.message);
+      }
+      printWarn(err.stack);
+      return process.exit(1);
+    }
+  };
+  compileStdio = function() {
+    var code, stdin;
+    code = '';
+    stdin = process.openStdin();
+    stdin.on('data', function(buffer) {
+      if (buffer) {
+        return code += buffer.toString();
+      }
+    });
+    return stdin.on('end', function() {
+      return compileScript(null, code);
+    });
+  };
+  compileJoin = function() {
+    var code;
+    code = contents.join('\n');
+    return compileScript("concatenation", code, "concatenation");
+  };
+  loadRequires = function() {
+    var realFilename, req, _i, _len, _ref;
+    realFilename = module.filename;
+    module.filename = '.';
+    _ref = opts.require;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      req = _ref[_i];
+      require(req);
+    }
+    return module.filename = realFilename;
+  };
+  watch = function(source, base) {
+    return fs.watchFile(source, {
+      persistent: true,
+      interval: 500
+    }, function(curr, prev) {
+      if (curr.size === prev.size && curr.mtime.getTime() === prev.mtime.getTime()) {
+        return;
+      }
+      return fs.readFile(source, function(err, code) {
+        if (err) {
+          throw err;
+        }
+        return compileScript(source, code.toString(), base);
+      });
+    });
+  };
+  writeJs = function(source, js, base) {
+    var baseDir, compile, dir, filename, jsPath, srcDir;
+    filename = path.basename(source, path.extname(source)) + '.js';
+    srcDir = path.dirname(source);
+    baseDir = base === '.' ? srcDir : srcDir.substring(base.length);
+    dir = opts.output ? path.join(opts.output, baseDir) : srcDir;
+    jsPath = path.join(dir, filename);
+    compile = function() {
+      if (js.length <= 0) {
+        js = ' ';
+      }
+      return fs.writeFile(jsPath, js, function(err) {
+        if (err) {
+          return printLine(err.message);
+        } else if (opts.compile && opts.watch) {
+          return console.log("" + ((new Date).toTimeString()) + " - compiled " + source);
+        }
+      });
+    };
+    return path.exists(dir, function(exists) {
+      if (exists) {
+        return compile();
+      } else {
+        return exec("mkdir -p " + dir, compile);
+      }
+    });
+  };
+  lint = function(file, js) {
+    var conf, jsl, printIt;
+    printIt = function(buffer) {
+      return printLine(file + ':\t' + buffer.toString().trim());
+    };
+    conf = __dirname + '/../extras/jsl.conf';
+    jsl = spawn('jsl', ['-nologo', '-stdin', '-conf', conf]);
+    jsl.stdout.on('data', printIt);
+    jsl.stderr.on('data', printIt);
+    jsl.stdin.write(js);
+    return jsl.stdin.end();
+  };
+  printTokens = function(tokens) {
+    var strings, tag, token, value;
+    strings = (function() {
+      var _i, _len, _ref, _results;
+      _results = [];
+      for (_i = 0, _len = tokens.length; _i < _len; _i++) {
+        token = tokens[_i];
+        _ref = [token[0], token[1].toString().replace(/\n/, '\\n')], tag = _ref[0], value = _ref[1];
+        _results.push("[" + tag + " " + value + "]");
+      }
+      return _results;
+    })();
+    return printLine(strings.join(' '));
+  };
+  parseOptions = function() {
+    var o;
+    optionParser = new optparse.OptionParser(SWITCHES, BANNER);
+    o = opts = optionParser.parse(process.argv.slice(2));
+    o.compile || (o.compile = !!o.output);
+    o.run = !(o.compile || o.print || o.lint);
+    o.print = !!(o.print || (o.eval || o.stdio && o.compile));
+    return sources = o.arguments;
+  };
+  compileOptions = function(filename) {
+    return {
+      filename: filename,
+      bare: opts.bare
+    };
+  };
+  forkNode = function() {
+    var args, nodeArgs;
+    nodeArgs = opts.nodejs.split(/\s+/);
+    args = process.argv.slice(1);
+    args.splice(args.indexOf('--nodejs'), 2);
+    return spawn(process.execPath, nodeArgs.concat(args), {
+      cwd: process.cwd(),
+      env: process.env,
+      customFds: [0, 1, 2]
+    });
+  };
+  usage = function() {
+    return printLine((new optparse.OptionParser(SWITCHES, BANNER)).help());
+  };
+  version = function() {
+    return printLine("CoffeeScript version " + CoffeeScript.VERSION);
+  };
+}).call(this);