spade 0.0.8.1 → 0.1.0

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

@@ -1,45 +0,0 @@
-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

@@ -1,26 +0,0 @@
-{
-    "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

@@ -1,43 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-# `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

@@ -1,92 +0,0 @@
-# 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

@@ -1,214 +0,0 @@
-# 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}"