spade 0.0.1

data/packages/coffee-script/lib/spade-format.js

@@ -0,0 +1,45 @@
+var _ref = require('./lexer'), Lexer = _ref.Lexer, RESERVED = _ref.RESERVED;
+var parser = require('./parser').parser, lexer;
+
+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;
+    this.pos = 0;
+    return 0;
+  },
+  upcomingInput: function() {
+    return "";
+  }
+};
+
+parser.yy = require('./nodes');
+
+
+exports.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.compileFormat = function(code) {
+  return exports.compile(code, {});
+};
+

data/packages/coffee-script/package.json

@@ -0,0 +1,26 @@
+{
+    "name":         "coffee-script",
+    "description":  "Unfancy JavaScript",
+    "keywords":     ["javascript", "language", "coffeescript", "compiler"],
+    "author":       "Jeremy Ashkenas",
+    "version":      "1.0.1-pre",
+    "licenses":     [{
+      "type":       "MIT",
+      "url":        "http://github.com/jashkenas/coffee-script/raw/master/LICENSE"
+    }],
+    "engines":      {
+      "node":       ">=0.2.5"
+    },
+    "directories" : {
+      "lib" : "./lib"
+    },
+    "main" : "./lib/coffee-script",
+    "bin":          {
+      "coffee":     "./bin/coffee",
+      "cake":       "./bin/cake"
+    },
+    
+    "plugin:formats": {
+      "coffee": "coffee-script/spade-format"
+    }
+}

data/packages/coffee-script/src/browser.coffee

@@ -0,0 +1,43 @@
+# Override exported methods for non-Node.js engines.
+
+CoffeeScript = require './coffee-script'
+CoffeeScript.require = require
+
+# Use standard JavaScript `eval` to eval code.
+CoffeeScript.eval = (code, options) ->
+  eval CoffeeScript.compile code, options
+
+# Running code does not provide access to this scope.
+CoffeeScript.run = (code, options = {}) ->
+  options.bare = on
+  Function(CoffeeScript.compile code, options)()
+
+# If we're not in a browser environment, we're finished with the public API.
+return unless window?
+
+# Load a remote script from the current domain via XHR.
+CoffeeScript.load = (url, options) ->
+  xhr = new (window.ActiveXObject or XMLHttpRequest)('Microsoft.XMLHTTP')
+  xhr.open 'GET', url, true
+  xhr.overrideMimeType 'text/plain' if 'overrideMimeType' of xhr
+  xhr.onreadystatechange = ->
+    CoffeeScript.run xhr.responseText, options if xhr.readyState is 4
+  xhr.send null
+
+# Activate CoffeeScript in the browser by having it compile and evaluate
+# all script tags with a content-type of `text/coffeescript`.
+# This happens on page load.
+runScripts = ->
+  for script in document.getElementsByTagName 'script'
+    if script.type is 'text/coffeescript'
+      if script.src
+        CoffeeScript.load script.src
+      else
+        CoffeeScript.run script.innerHTML
+  null
+
+# Listen for window load, both in browsers and in IE.
+if window.addEventListener
+  addEventListener 'DOMContentLoaded', runScripts, no
+else
+  attachEvent 'onload', runScripts

data/packages/coffee-script/src/cake.coffee

@@ -0,0 +1,69 @@
+# `cake` is a simplified version of [Make](http://www.gnu.org/software/make/)
+# ([Rake](http://rake.rubyforge.org/), [Jake](http://github.com/280north/jake))
+# for CoffeeScript. You define tasks with names and descriptions in a Cakefile,
+# and can call them from the command line, or invoke them from other tasks.
+#
+# Running `cake` with no arguments will print out a list of all the tasks in the
+# current directory's Cakefile.
+
+# External dependencies.
+fs           = require 'fs'
+path         = require 'path'
+helpers      = require './helpers'
+optparse     = require './optparse'
+CoffeeScript = require './coffee-script'
+
+# Keep track of the list of defined tasks, the accepted options, and so on.
+tasks     = {}
+options   = {}
+switches  = []
+oparse    = null
+
+# Mixin the top-level Cake functions for Cakefiles to use directly.
+helpers.extend global,
+
+  # Define a Cake task with a short name, an optional sentence description,
+  # and the function to run as the action itself.
+  task: (name, description, action) ->
+    [action, description] = [description, action] unless action
+    tasks[name] = {name, description, action}
+
+  # Define an option that the Cakefile accepts. The parsed options hash,
+  # containing all of the command-line options passed, will be made available
+  # as the first argument to the action.
+  option: (letter, flag, description) ->
+    switches.push [letter, flag, description]
+
+  # Invoke another task in the current Cakefile.
+  invoke: (name) ->
+    missingTask name unless tasks[name]
+    tasks[name].action options
+
+
+# Run `cake`. Executes all of the tasks you pass, in order. Note that Node's
+# asynchrony may cause tasks to execute in a different order than you'd expect.
+# If no tasks are passed, print the help screen.
+exports.run = ->
+  path.exists 'Cakefile', (exists) ->
+    throw new Error("Cakefile not found in #{process.cwd()}") unless exists
+    args = process.argv.slice 2
+    CoffeeScript.run fs.readFileSync('Cakefile').toString(), fileName: 'Cakefile'
+    oparse = new optparse.OptionParser switches
+    return printTasks() unless args.length
+    options = oparse.parse(args)
+    invoke arg for arg in options.arguments
+
+# Display the list of Cake tasks in a format similar to `rake -T`
+printTasks = ->
+  console.log ''
+  for name, task of tasks
+    spaces = 20 - name.length
+    spaces = if spaces > 0 then Array(spaces + 1).join(' ') else ''
+    desc   = if task.description then "# #{task.description}" else ''
+    console.log "cake #{name}#{spaces} #{desc}"
+  console.log oparse.help() if switches.length
+
+# Print an error and exit when attempting to all an undefined task.
+missingTask = (task) ->
+  console.log "No such task: \"#{task}\""
+  process.exit 1

data/packages/coffee-script/src/coffee-script.coffee

@@ -0,0 +1,92 @@
+# CoffeeScript can be used both on the server, as a command-line compiler based
+# on Node.js/V8, or to run CoffeeScripts directly in the browser. This module
+# contains the main entry functions for tokenizing, parsing, and compiling
+# source CoffeeScript into JavaScript.
+#
+# If included on a webpage, it will automatically sniff out, compile, and
+# execute all scripts present in `text/coffeescript` tags.
+
+fs               = require 'fs'
+path             = require 'path'
+{Lexer,RESERVED} = require './lexer'
+{parser}         = require './parser'
+
+# TODO: Remove registerExtension when fully deprecated.
+if require.extensions
+  require.extensions['.coffee'] = (module, filename) ->
+    content = compile fs.readFileSync filename, 'utf8'
+    module._compile content, filename
+else if require.registerExtension
+  require.registerExtension '.coffee', (content) -> compile content
+
+# The current CoffeeScript version number.
+exports.VERSION = '1.0.1-pre'
+
+# Words that cannot be used as identifiers in CoffeeScript code
+exports.RESERVED = RESERVED
+
+# Expose helpers for testing.
+exports.helpers = require './helpers'
+
+# Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
+# compiler.
+exports.compile = compile = (code, options = {}) ->
+  try
+    (parser.parse lexer.tokenize code).compile options
+  catch err
+    err.message = "In #{options.fileName}, #{err.message}" if options.fileName
+    throw err
+
+# Tokenize a string of CoffeeScript code, and return the array of tokens.
+exports.tokens = (code, options) ->
+  lexer.tokenize code, options
+
+# Parse a string of CoffeeScript code or an array of lexed tokens, and
+# return the AST. You can then compile it by calling `.compile()` on the root,
+# or traverse it by using `.traverse()` with a callback.
+exports.nodes = (source, options) ->
+  if typeof source is 'string'
+    parser.parse lexer.tokenize source, options
+  else
+    parser.parse source
+
+# Compile and execute a string of CoffeeScript (on the server), correctly
+# setting `__filename`, `__dirname`, and relative `require()`.
+exports.run = (code, options) ->
+  # We want the root module.
+  root = module
+  while root.parent
+    root = root.parent
+  # Set the filename.
+  root.filename = fs.realpathSync options.fileName or '.'
+  # Clear the module cache.
+  root.moduleCache = {} if root.moduleCache
+  # Compile.
+  if path.extname(root.filename) isnt '.coffee' or require.extensions
+    root._compile compile(code, options), root.filename
+  else
+    root._compile code, root.filename
+
+# Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
+# The CoffeeScript REPL uses this to run the input.
+exports.eval = (code, options) ->
+  __filename = options.fileName
+  __dirname  = path.dirname __filename
+  eval compile code, options
+
+# Instantiate a Lexer for our use here.
+lexer = new Lexer
+
+# The real Lexer produces a generic stream of tokens. This object provides a
+# thin wrapper around it, compatible with the Jison API. We can then pass it
+# directly as a "Jison lexer".
+parser.lexer =
+  lex: ->
+    [tag, @yytext, @yylineno] = @tokens[@pos++] or ['']
+    tag
+  setInput: (@tokens) ->
+    @pos = 0
+  upcomingInput: ->
+    ""
+
+parser.yy = require './nodes'

data/packages/coffee-script/src/command.coffee

@@ -0,0 +1,214 @@
+# The `coffee` utility. Handles command-line compilation of CoffeeScript
+# into various forms: saved into `.js` files or printed to stdout, piped to
+# [JSLint](http://javascriptlint.com/) or recompiled every time the source is
+# saved, printed as a token stream or as the syntax tree, or launch an
+# interactive REPL.
+
+# External dependencies.
+fs             = require 'fs'
+path           = require 'path'
+util           = require 'util'
+helpers        = require './helpers'
+optparse       = require './optparse'
+CoffeeScript   = require './coffee-script'
+{spawn, exec}  = require 'child_process'
+{EventEmitter} = require 'events'
+
+# Allow CoffeeScript to emit Node.js events.
+helpers.extend CoffeeScript, new EventEmitter
+
+printLine = (line) -> process.stdout.write line + '\n'
+printWarn = (line) -> process.binding('stdio').writeError line + '\n'
+
+# The help banner that is printed when `coffee` is called without arguments.
+BANNER = '''
+  Usage: coffee [options] path/to/script.coffee
+         '''
+
+# The list of all the valid option flags that `coffee` knows how to handle.
+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']
+]
+
+# Top-level objects shared by all the functions.
+opts         = {}
+sources      = []
+contents     = []
+optionParser = null
+
+# Run `coffee` by parsing passed options and determining what action to take.
+# Many flags cause us to divert before compiling anything. Flags passed after
+# `--` will be passed verbatim to your script as arguments in `process.argv`
+exports.run = ->
+  parseOptions()
+  return forkNode()                      if opts.nodejs
+  return usage()                         if opts.help
+  return version()                       if opts.version
+  return require './repl'                if opts.interactive
+  return compileStdio()                  if opts.stdio
+  return compileScript null, sources[0]  if opts.eval
+  return require './repl'                unless sources.length
+  if opts.run
+    opts.literals = sources.splice(1).concat opts.literals
+  process.ARGV = process.argv = process.argv.slice(0, 2).concat opts.literals
+  compileScripts()
+
+# Asynchronously read in each CoffeeScript in a list of source files and
+# compile them. If a directory is passed, recursively compile all
+# '.coffee' extension source files in it and all subdirectories.
+compileScripts = ->
+  for source in sources
+    base = path.join(source)
+    compile = (source, topLevel) ->
+      path.exists source, (exists) ->
+        throw new Error "File not found: #{source}" unless exists
+        fs.stat source, (err, stats) ->
+          if stats.isDirectory()
+            fs.readdir source, (err, files) ->
+              for file in files
+                compile path.join(source, file)
+          else if topLevel or path.extname(source) is '.coffee'
+            fs.readFile source, (err, code) ->
+              if opts.join
+                contents[sources.indexOf source] = code.toString()
+                compileJoin() if helpers.compact(contents).length is sources.length
+              else
+                compileScript(source, code.toString(), base)
+            watch source, base if opts.watch and not opts.join
+    compile source, true
+
+# Compile a single source script, containing the given code, according to the
+# requested options. If evaluating the script directly sets `__filename`,
+# `__dirname` and `module.filename` to be correct relative to the script's path.
+compileScript = (file, input, base) ->
+  o = opts
+  options = compileOptions file
+  if o.require
+    require(if helpers.starts(req, '.') then fs.realpathSync(req) else req) for req in o.require
+  try
+    t = task = {file, input, options}
+    CoffeeScript.emit 'compile', task
+    if      o.tokens      then printTokens CoffeeScript.tokens t.input
+    else if o.nodes       then printLine CoffeeScript.nodes(t.input).toString().trim()
+    else if o.run         then CoffeeScript.run t.input, t.options
+    else
+      t.output = CoffeeScript.compile t.input, t.options
+      CoffeeScript.emit 'success', task
+      if o.print          then printLine t.output.trim()
+      else if o.compile   then writeJs t.file, t.output, base
+      else if o.lint      then lint t.file, t.output
+  catch err
+    CoffeeScript.emit 'failure', err, task
+    return if CoffeeScript.listeners('failure').length
+    return printLine err.message if o.watch
+    printWarn err.stack
+    process.exit 1
+
+# Attach the appropriate listeners to compile scripts incoming over **stdin**,
+# and write them back to **stdout**.
+compileStdio = ->
+  code = ''
+  stdin = process.openStdin()
+  stdin.on 'data', (buffer) ->
+    code += buffer.toString() if buffer
+  stdin.on 'end', ->
+    compileScript null, code
+
+# After all of the source files are done being read, concatenate and compile
+# them together.
+compileJoin = ->
+  code = contents.join '\n'
+  compileScript "concatenation", code, "concatenation"
+
+# Watch a source CoffeeScript file using `fs.watchFile`, recompiling it every
+# time the file is updated. May be used in combination with other options,
+# such as `--lint` or `--print`.
+watch = (source, base) ->
+  fs.watchFile source, {persistent: true, interval: 500}, (curr, prev) ->
+    return if curr.size is prev.size and curr.mtime.getTime() is prev.mtime.getTime()
+    fs.readFile source, (err, code) ->
+      throw err if err
+      compileScript(source, code.toString(), base)
+
+# Write out a JavaScript source file with the compiled code. By default, files
+# are written out in `cwd` as `.js` files with the same name, but the output
+# directory can be customized with `--output`.
+writeJs = (source, js, base) ->
+  filename  = path.basename(source, path.extname(source)) + '.js'
+  srcDir    = path.dirname source
+  baseDir   = if base is '.' then srcDir else srcDir.substring base.length
+  dir       = if opts.output then path.join opts.output, baseDir else srcDir
+  jsPath    = path.join dir, filename
+  compile   = ->
+    js = ' ' if js.length <= 0
+    fs.writeFile jsPath, js, (err) ->
+      if err then printLine err.message
+      else if opts.compile and opts.watch then util.log "compiled #{source}"
+  path.exists dir, (exists) ->
+    if exists then compile() else exec "mkdir -p #{dir}", compile
+
+# Pipe compiled JS through JSLint (requires a working `jsl` command), printing
+# any errors or warnings that arise.
+lint = (file, js) ->
+  printIt = (buffer) -> 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
+  jsl.stdin.end()
+
+# Pretty-print a stream of tokens.
+printTokens = (tokens) ->
+  strings = for token in tokens
+    [tag, value] = [token[0], token[1].toString().replace(/\n/, '\\n')]
+    "[#{tag} #{value}]"
+  printLine strings.join(' ')
+
+# Use the [OptionParser module](optparse.html) to extract all options from
+# `process.argv` that are specified in `SWITCHES`.
+parseOptions = ->
+  optionParser  = new optparse.OptionParser SWITCHES, BANNER
+  o = opts      = optionParser.parse process.argv.slice 2
+  o.compile     or=  !!o.output
+  o.run         = not (o.compile or o.print or o.lint)
+  o.print       = !!  (o.print or (o.eval or o.stdio and o.compile))
+  sources       = o.arguments
+
+# The compile-time options to pass to the CoffeeScript compiler.
+compileOptions = (fileName) -> {fileName, bare: opts.bare}
+
+# Start up a new Node.js instance with the arguments in `--nodejs` passed to
+# the `node` binary, preserving the other options.
+forkNode = ->
+  nodeArgs = opts.nodejs.split /\s+/
+  args     = process.argv[1..]
+  args.splice args.indexOf('--nodejs'), 2
+  spawn process.execPath, nodeArgs.concat(args),
+    cwd:        process.cwd()
+    env:        process.env
+    customFds:  [0, 1, 2]
+
+# Print the `--help` usage message and exit. Deprecated switches are not
+# shown.
+usage = ->
+  printLine (new optparse.OptionParser SWITCHES, BANNER).help()
+
+# Print the `--version` message and exit.
+version = ->
+  printLine "CoffeeScript version #{CoffeeScript.VERSION}"