haml-more 0.4.0.a

data/vendor/coffee-script/lib/bin/cake

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+process.mixin(require('sys'));
+
+require.paths.unshift('/usr/local/lib/coffee-script/lib');
+
+require('cake').run();

data/vendor/coffee-script/lib/bin/coffee

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+process.mixin(require('sys'));
+
+require.paths.unshift('/usr/local/lib/coffee-script/lib');
+
+require('command_line').run();

data/vendor/coffee-script/lib/cake.js

@@ -0,0 +1,80 @@
+(function(){
+  var coffee, fs, no_such_task, path, print_tasks, tasks;
+  var __hasProp = Object.prototype.hasOwnProperty;
+  // `cake` is a simplified version of Make (Rake, Jake) for CoffeeScript.
+  fs = require('fs');
+  path = require('path');
+  coffee = require('coffee-script');
+  tasks = {};
+  no_such_task = function no_such_task(task) {
+    process.stdio.writeError('No such task: "' + task + '"\n');
+    return process.exit(1);
+  };
+  // Mixin the Cake functionality.
+  process.mixin({
+    // Define a task with a name, a description, and the action itself.
+    task: function task(name, description, action) {
+      return tasks[name] = {
+        name: name,
+        description: description,
+        action: action
+      };
+    },
+    // Invoke another task in the Cakefile.
+    invoke: function invoke(name) {
+      if (!(tasks[name])) {
+        no_such_task(name);
+      }
+      return tasks[name].action();
+    }
+  });
+  // Display the list of Cake tasks.
+  print_tasks = function print_tasks() {
+    var _a, _b, _c, _d, _e, _f, _g, i, name, spaces, task;
+    _a = []; _b = tasks;
+    for (name in _b) { if (__hasProp.call(_b, name)) {
+      task = _b[name];
+      _a.push((function() {
+        spaces = 20 - name.length;
+        spaces = spaces > 0 ? (function() {
+          _c = []; _f = 0; _g = spaces;
+          for (_e = 0, i=_f; (_f <= _g ? i <= _g : i >= _g); (_f <= _g ? i += 1 : i -= 1), _e++) {
+            _c.push(' ');
+          }
+          return _c;
+        }).call(this).join('') : '';
+        return puts("cake " + name + spaces + ' # ' + task.description);
+      }).call(this));
+    }}
+    return _a;
+  };
+  // Running `cake` runs the tasks you pass asynchronously (node-style), or
+  // prints them out, with no arguments.
+  exports.run = function run() {
+    return path.exists('Cakefile', function(exists) {
+      var args;
+      if (!(exists)) {
+        throw new Error('Cakefile not found in ' + process.cwd());
+      }
+      args = process.ARGV.slice(2, process.ARGV.length);
+      return fs.readFile('Cakefile', function(err, source) {
+        var _a, _b, _c, arg;
+        eval(coffee.compile(source));
+        if (!(args.length)) {
+          return print_tasks();
+        }
+        _a = []; _b = args;
+        for (_c = 0; _c < _b.length; _c++) {
+          arg = _b[_c];
+          _a.push((function() {
+            if (!(tasks[arg])) {
+              no_such_task(arg);
+            }
+            return tasks[arg].action();
+          }).call(this));
+        }
+        return _a;
+      });
+    });
+  };
+})();

data/vendor/coffee-script/lib/coffee-script.js

@@ -0,0 +1,61 @@
+(function(){
+  var lexer, parser, path;
+  // Set up for both the browser and the server.
+  if ((typeof process !== "undefined" && process !== null)) {
+    process.mixin(require('nodes'));
+    path = require('path');
+    lexer = new (require('lexer').Lexer)();
+    parser = require('parser').parser;
+  } else {
+    lexer = new Lexer();
+    parser = exports.parser;
+    this.exports = (this.CoffeeScript = {});
+  }
+  // Thin wrapper for Jison compatibility around the real lexer.
+  parser.lexer = {
+    lex: function lex() {
+      var token;
+      token = this.tokens[this.pos] || [""];
+      this.pos += 1;
+      this.yylineno = token[2];
+      this.yytext = token[1];
+      return token[0];
+    },
+    setInput: function setInput(tokens) {
+      this.tokens = tokens;
+      return this.pos = 0;
+    },
+    upcomingInput: function upcomingInput() {
+      return "";
+    },
+    showPosition: function showPosition() {
+      return this.pos;
+    }
+  };
+  exports.VERSION = '0.5.1';
+  // Compile CoffeeScript to JavaScript, using the Coffee/Jison compiler.
+  exports.compile = function compile(code, options) {
+    return (parser.parse(lexer.tokenize(code))).compile(options);
+  };
+  // Just the tokens.
+  exports.tokenize = function tokenize(code) {
+    return lexer.tokenize(code);
+  };
+  // Just the nodes.
+  exports.tree = function tree(code) {
+    return parser.parse(lexer.tokenize(code));
+  };
+  // Pretty-print a token stream.
+  exports.print_tokens = function print_tokens(tokens) {
+    var _a, _b, _c, strings, token;
+    strings = (function() {
+      _a = []; _b = tokens;
+      for (_c = 0; _c < _b.length; _c++) {
+        token = _b[_c];
+        _a.push('[' + token[0] + ' ' + token[1].toString().replace(/\n/, '\\n') + ']');
+      }
+      return _a;
+    }).call(this);
+    return puts(strings.join(' '));
+  };
+})();

data/vendor/coffee-script/lib/command_line.js

@@ -0,0 +1,201 @@
+(function(){
+  var BANNER, SWITCHES, coffee, compile_script, compile_scripts, fs, lint, option_parser, options, optparse, parse_options, path, sources, usage, version, watch_scripts, write_js;
+  fs = require('fs');
+  path = require('path');
+  coffee = require('coffee-script');
+  optparse = require('optparse');
+  BANNER = "coffee compiles CoffeeScript source files into JavaScript.\n\nUsage:\n  coffee path/to/script.coffee";
+  SWITCHES = [['-i', '--interactive', 'run an interactive CoffeeScript REPL'], ['-r', '--run', 'compile and run a CoffeeScript'], ['-o', '--output [DIR]', 'set the directory for compiled JavaScript'], ['-w', '--watch', 'watch scripts for changes, and recompile'], ['-p', '--print', 'print the compiled JavaScript to stdout'], ['-l', '--lint', 'pipe the compiled JavaScript through JSLint'], ['-e', '--eval', 'compile a string from the command line'], ['-t', '--tokens', 'print the tokens that the lexer produces'], ['-tr', '--tree', 'print the parse tree that Jison produces'], ['-n', '--no-wrap', 'compile without the top-level function wrapper'], ['-v', '--version', 'display CoffeeScript version'], ['-h', '--help', 'display this help message']];
+  options = {};
+  sources = [];
+  option_parser = null;
+  // The CommandLine handles all of the functionality of the `coffee` utility.
+  exports.run = function run() {
+    var flags, separator;
+    parse_options();
+    if (options.interactive) {
+      return require('repl');
+    }
+    if (options.eval) {
+      return compile_script('terminal', sources[0]);
+    }
+    if (!(sources.length)) {
+      usage();
+    }
+    separator = sources.indexOf('--');
+    flags = [];
+    if (separator >= 0) {
+      flags = sources.slice((separator + 1), sources.length);
+      sources = sources.slice(0, separator);
+    }
+    process.ARGV = flags;
+    if (options.watch) {
+      watch_scripts();
+    }
+    compile_scripts();
+    return this;
+  };
+  // The "--help" usage message.
+  usage = function usage() {
+    puts('\n' + option_parser.help() + '\n');
+    return process.exit(0);
+  };
+  // The "--version" message.
+  version = function version() {
+    puts("CoffeeScript version " + coffee.VERSION);
+    return process.exit(0);
+  };
+  // Compiles the source CoffeeScript, returning the desired JavaScript, tokens,
+  // or JSLint results.
+  compile_scripts = function compile_scripts() {
+    var _a, _b, _c, compile, source;
+    compile = function compile(source) {
+      return fs.readFile(source, function(err, code) {
+        return compile_script(source, code);
+      });
+    };
+    _a = []; _b = sources;
+    for (_c = 0; _c < _b.length; _c++) {
+      source = _b[_c];
+      _a.push(compile(source));
+    }
+    return _a;
+  };
+  // Compile a single source script, containing the given code, according to the
+  // requested options. Both compile_scripts and watch_scripts share this method.
+  compile_script = function compile_script(source, code) {
+    var js, o, opts;
+    opts = options;
+    o = opts.no_wrap ? {
+      no_wrap: true
+    } : {};
+    try {
+      if (opts.tokens) {
+        return coffee.print_tokens(coffee.tokenize(code));
+      } else if (opts.tree) {
+        return puts(coffee.tree(code).toString());
+      } else {
+        js = coffee.compile(code, o);
+        if (opts.run) {
+          return eval(js);
+        } else if (opts.lint) {
+          return lint(js);
+        } else if (opts.print || opts.eval) {
+          return puts(js);
+        } else {
+          return write_js(source, js);
+        }
+      }
+    } catch (err) {
+      if (opts.watch) {
+        return puts(err.message);
+      } else {
+        throw err;
+      }
+    }
+  };
+  // Watch a list of source CoffeeScript files, recompiling them every time the
+  // files are updated.
+  watch_scripts = function watch_scripts() {
+    var _a, _b, _c, source, watch;
+    watch = function watch(source) {
+      return process.watchFile(source, {
+        persistent: true,
+        interval: 500
+      }, function(curr, prev) {
+        if (curr.mtime.getTime() === prev.mtime.getTime()) {
+          return null;
+        }
+        return fs.readFile(source, function(err, code) {
+          return compile_script(source, code);
+        });
+      });
+    };
+    _a = []; _b = sources;
+    for (_c = 0; _c < _b.length; _c++) {
+      source = _b[_c];
+      _a.push(watch(source));
+    }
+    return _a;
+  };
+  // Write out a JavaScript source file with the compiled code.
+  write_js = function write_js(source, js) {
+    var dir, filename, js_path;
+    filename = path.basename(source, path.extname(source)) + '.js';
+    dir = options.output || path.dirname(source);
+    js_path = path.join(dir, filename);
+    return fs.writeFile(js_path, js);
+  };
+  // Pipe compiled JS through JSLint (requires a working 'jsl' command).
+  lint = function lint(js) {
+    var jsl;
+    jsl = process.createChildProcess('jsl', ['-nologo', '-stdin']);
+    jsl.addListener('output', function(result) {
+      if (result) {
+        return puts(result.replace(/\n/g, ''));
+      }
+    });
+    jsl.addListener('error', function(result) {
+      if (result) {
+        return puts(result);
+      }
+    });
+    jsl.write(js);
+    return jsl.close();
+  };
+  // Use OptionParser for all the options.
+  parse_options = function parse_options() {
+    var oparser, opts, paths;
+    opts = (options = {});
+    oparser = (option_parser = new optparse.OptionParser(SWITCHES));
+    oparser.banner = BANNER;
+    oparser.add('interactive', function() {
+      return opts.interactive = true;
+    });
+    oparser.add('run', function() {
+      return opts.run = true;
+    });
+    oparser.add('output', function(dir) {
+      return opts.output = dir;
+    });
+    oparser.add('watch', function() {
+      return opts.watch = true;
+    });
+    oparser.add('print', function() {
+      return opts.print = true;
+    });
+    oparser.add('lint', function() {
+      return opts.lint = true;
+    });
+    oparser.add('eval', function() {
+      return opts.eval = true;
+    });
+    oparser.add('tokens', function() {
+      return opts.tokens = true;
+    });
+    oparser.add('tree', function() {
+      return opts.tree = true;
+    });
+    oparser.add('no-wrap', function() {
+      return opts.no_wrap = true;
+    });
+    oparser.add('help', (function(__this) {
+      var __func = function() {
+        return usage();
+      };
+      return (function() {
+        return __func.apply(__this, arguments);
+      });
+    })(this));
+    oparser.add('version', (function(__this) {
+      var __func = function() {
+        return version();
+      };
+      return (function() {
+        return __func.apply(__this, arguments);
+      });
+    })(this));
+    paths = oparser.parse(process.ARGV);
+    return sources = paths.slice(2, paths.length);
+  };
+})();