coffeescript-router 0.0.1

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

@@ -0,0 +1,107 @@
+(function() {
+  var Lexer, RESERVED, compile, fs, lexer, parser, path, vm, _ref;
+  fs = require('fs');
+  path = require('path');
+  vm = require('vm');
+  _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.0';
+  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, root;
+    root = module;
+    while (root.parent) {
+      root = root.parent;
+    }
+    root.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
+    if (root.moduleCache) {
+      root.moduleCache = {};
+    }
+    if (process.binding('natives').module) {
+      Module = require('module').Module;
+      root.paths = Module._nodeModulePaths(path.dirname(options.filename));
+    }
+    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 g, js, sandbox;
+    if (options == null) {
+      options = {};
+    }
+    sandbox = options.sandbox;
+    if (!sandbox) {
+      sandbox = {
+        require: require,
+        module: {
+          exports: {}
+        }
+      };
+      for (g in global) {
+        sandbox[g] = global[g];
+      }
+      sandbox.global = sandbox;
+      sandbox.global.global = sandbox.global.root = sandbox.global.GLOBAL = sandbox;
+    }
+    sandbox.__filename = options.filename || 'eval';
+    sandbox.__dirname = path.dirname(sandbox.__filename);
+    js = compile("_=(" + (code.trim()) + ")", options);
+    return vm.runInNewContext(js, sandbox, sandbox.__filename);
+  };
+  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);

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

@@ -0,0 +1,274 @@
+(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 [FILE]', '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);
+    process.argv[0] = 'coffee';
+    process.execPath = process.mainModule.filename;
+    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 (err) {
+              throw err;
+            }
+            if (stats.isDirectory()) {
+              return fs.readdir(source, function(err, files) {
+                var file, _j, _len2, _results2;
+                _results2 = [];
+                for (_j = 0, _len2 = files.length; _j < _len2; _j++) {
+                  file = files[_j];
+                  _results2.push(compile(path.join(source, file)));
+                }
+                return _results2;
+              });
+            } 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 > 0) {
+                    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(opts.join, code, opts.join);
+  };
+  loadRequires = function() {
+    var realFilename, req, _i, _len, _ref2;
+    realFilename = module.filename;
+    module.filename = '.';
+    _ref2 = opts.require;
+    for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+      req = _ref2[_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).toLocaleTimeString()) + " - 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, _ref2, _results;
+      _results = [];
+      for (_i = 0, _len = tokens.length; _i < _len; _i++) {
+        token = tokens[_i];
+        _ref2 = [token[0], token[1].toString().replace(/\n/, '\\n')], tag = _ref2[0], value = _ref2[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);