spade 0.0.8.1 → 0.1.0

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

@@ -1,99 +0,0 @@
-# A simple **OptionParser** class to parse option flags from the command-line.
-# Use it like so:
-#
-#     parser  = new OptionParser switches, helpBanner
-#     options = parser.parse process.argv
-#
-# The first non-option is considered to be the start of the file (and file
-# option) list, and all subsequent arguments are left unparsed.
-exports.OptionParser = class OptionParser
-
-  # Initialize with a list of valid options, in the form:
-  #
-  #     [short-flag, long-flag, description]
-  #
-  # Along with an an optional banner for the usage help.
-  constructor: (rules, @banner) ->
-    @rules = buildRules rules
-
-  # Parse the list of arguments, populating an `options` object with all of the
-  # specified options, and returning it. `options.arguments` will be an array
-  # containing the remaining non-option arguments. `options.literals` will be
-  # an array of options that are meant to be passed through directly to the
-  # executing script. This is a simpler API than many option parsers that allow
-  # you to attach callback actions for every flag. Instead, you're responsible
-  # for interpreting the options object.
-  parse: (args) ->
-    options = arguments: [], literals: []
-    args    = normalizeArguments args
-    for arg, i in args
-      if arg is '--'
-        options.literals = args[(i + 1)..]
-        break
-      isOption = !!(arg.match(LONG_FLAG) or arg.match(SHORT_FLAG))
-      matchedRule = no
-      for rule in @rules
-        if rule.shortFlag is arg or rule.longFlag is arg
-          value = if rule.hasArgument then args[i += 1] else true
-          options[rule.name] = if rule.isList then (options[rule.name] or []).concat value else value
-          matchedRule = yes
-          break
-      throw new Error "unrecognized option: #{arg}" if isOption and not matchedRule
-      if not isOption
-        options.arguments = args.slice i
-        break
-    options
-
-  # Return the help text for this **OptionParser**, listing and describing all
-  # of the valid options, for `--help` and such.
-  help: ->
-    lines = ['Available options:']
-    lines.unshift "#{@banner}\n" if @banner
-    for rule in @rules
-      spaces  = 15 - rule.longFlag.length
-      spaces  = if spaces > 0 then Array(spaces + 1).join(' ') else ''
-      letPart = if rule.shortFlag then rule.shortFlag + ', ' else '    '
-      lines.push '  ' + letPart + rule.longFlag + spaces + rule.description
-    "\n#{ lines.join('\n') }\n"
-
-# Helpers
-# -------
-
-# Regex matchers for option flags.
-LONG_FLAG  = /^(--\w[\w\-]+)/
-SHORT_FLAG = /^(-\w)/
-MULTI_FLAG = /^-(\w{2,})/
-OPTIONAL   = /\[(\w+(\*?))\]/
-
-# Build and return the list of option rules. If the optional *short-flag* is
-# unspecified, leave it out by padding with `null`.
-buildRules = (rules) ->
-  for tuple in rules
-    tuple.unshift null if tuple.length < 3
-    buildRule tuple...
-
-# Build a rule from a `-o` short flag, a `--output [DIR]` long flag, and the
-# description of what the option does.
-buildRule = (shortFlag, longFlag, description, options = {}) ->
-  match     = longFlag.match(OPTIONAL)
-  longFlag  = longFlag.match(LONG_FLAG)[1]
-  {
-    name:         longFlag.substr 2
-    shortFlag:    shortFlag
-    longFlag:     longFlag
-    description:  description
-    hasArgument:  !!(match and match[1])
-    isList:       !!(match and match[2])
-  }
-
-# Normalize arguments by expanding merged flags into multiple flags. This allows
-# you to have `-wl` be the same as `--watch --lint`.
-normalizeArguments = (args) ->
-  args = args.slice 0
-  result = []
-  for arg in args
-    if match = arg.match MULTI_FLAG
-      result.push '-' + l for l in match[1].split ''
-    else
-      result.push arg
-  result

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

@@ -1,42 +0,0 @@
-# A very simple Read-Eval-Print-Loop. Compiles one line at a time to JavaScript
-# and evaluates it. Good for simple tests, or poking around the **Node.js** API.
-# Using it looks like this:
-#
-#     coffee> console.log "#{num} bottles of beer" for num in [99..1]
-
-# Require the **coffee-script** module to get access to the compiler.
-CoffeeScript = require './coffee-script'
-helpers      = require './helpers'
-readline     = require 'readline'
-
-# Start by opening up **stdio**.
-stdio = process.openStdin()
-
-# Log an error.
-error = (err) ->
-  stdio.write (err.stack or err.toString()) + '\n\n'
-
-# Quick alias for quitting the REPL.
-helpers.extend global, quit: -> process.exit(0)
-
-# The main REPL function. **run** is called every time a line of code is entered.
-# Attempt to evaluate the command. If there's an exception, print it out instead
-# of exiting.
-run = (buffer) ->
-  try
-    val = CoffeeScript.eval buffer.toString(), bare: on, globals: on, fileName: 'repl'
-    console.log val if val isnt undefined
-  catch err
-    error err
-  repl.prompt()
-
-# Make sure that uncaught exceptions don't kill the REPL.
-process.on 'uncaughtException', error
-
-# Create the REPL by listening to **stdin**.
-repl = readline.createInterface stdio
-repl.setPrompt 'coffee> '
-stdio.on 'data',   (buffer) -> repl.write buffer
-repl.on  'close',  -> stdio.destroy()
-repl.on  'line',   run
-repl.prompt()

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

@@ -1,326 +0,0 @@
-# The CoffeeScript language has a good deal of optional syntax, implicit syntax,
-# and shorthand syntax. This can greatly complicate a grammar and bloat
-# the resulting parse table. Instead of making the parser handle it all, we take
-# a series of passes over the token stream, using this **Rewriter** to convert
-# shorthand into the unambiguous long form, add implicit indentation and
-# parentheses, balance incorrect nestings, and generally clean things up.
-
-# The **Rewriter** class is used by the [Lexer](lexer.html), directly against
-# its internal array of tokens.
-class exports.Rewriter
-
-  # Helpful snippet for debugging:
-  #     console.log (t[0] + '/' + t[1] for t in @tokens).join ' '
-
-  # Rewrite the token stream in multiple passes, one logical filter at
-  # a time. This could certainly be changed into a single pass through the
-  # stream, with a big ol' efficient switch, but it's much nicer to work with
-  # like this. The order of these passes matters -- indentation must be
-  # corrected before implicit parentheses can be wrapped around blocks of code.
-  rewrite: (@tokens) ->
-    @removeLeadingNewlines()
-    @removeMidExpressionNewlines()
-    @closeOpenCalls()
-    @closeOpenIndexes()
-    @addImplicitIndentation()
-    @tagPostfixConditionals()
-    @addImplicitBraces()
-    @addImplicitParentheses()
-    @ensureBalance BALANCED_PAIRS
-    @rewriteClosingParens()
-    @tokens
-
-  # Rewrite the token stream, looking one token ahead and behind.
-  # Allow the return value of the block to tell us how many tokens to move
-  # forwards (or backwards) in the stream, to make sure we don't miss anything
-  # as tokens are inserted and removed, and the stream changes length under
-  # our feet.
-  scanTokens: (block) ->
-    {tokens} = this
-    i = 0
-    i += block.call this, token, i, tokens while token = tokens[i]
-    true
-
-  detectEnd: (i, condition, action) ->
-    {tokens} = this
-    levels = 0
-    while token = tokens[i]
-      return action.call this, token, i     if levels is 0 and condition.call this, token, i
-      return action.call this, token, i - 1 if not token or levels < 0
-      if token[0] in EXPRESSION_START
-        levels += 1
-      else if token[0] in EXPRESSION_END
-        levels -= 1
-      i += 1
-    i - 1
-
-  # Leading newlines would introduce an ambiguity in the grammar, so we
-  # dispatch them here.
-  removeLeadingNewlines: ->
-    break for [tag], i in @tokens when tag isnt 'TERMINATOR'
-    @tokens.splice 0, i if i
-
-  # Some blocks occur in the middle of expressions -- when we're expecting
-  # this, remove their trailing newlines.
-  removeMidExpressionNewlines: ->
-    @scanTokens (token, i, tokens) ->
-      return 1 unless token[0] is 'TERMINATOR' and @tag(i + 1) in EXPRESSION_CLOSE
-      tokens.splice i, 1
-      0
-
-  # The lexer has tagged the opening parenthesis of a method call. Match it with
-  # its paired close. We have the mis-nested outdent case included here for
-  # calls that close on the same line, just before their outdent.
-  closeOpenCalls: ->
-    condition = (token, i) ->
-      token[0] in [')', 'CALL_END'] or
-      token[0] is 'OUTDENT' and @tag(i - 1) is ')'
-    action = (token, i) ->
-      @tokens[if token[0] is 'OUTDENT' then i - 1 else i][0] = 'CALL_END'
-    @scanTokens (token, i) ->
-      @detectEnd i + 1, condition, action if token[0] is 'CALL_START'
-      1
-
-  # The lexer has tagged the opening parenthesis of an indexing operation call.
-  # Match it with its paired close.
-  closeOpenIndexes: ->
-    condition = (token, i) -> token[0] in [']', 'INDEX_END']
-    action    = (token, i) -> token[0] = 'INDEX_END'
-    @scanTokens (token, i) ->
-      @detectEnd i + 1, condition, action if token[0] is 'INDEX_START'
-      1
-
-  # Object literals may be written with implicit braces, for simple cases.
-  # Insert the missing braces here, so that the parser doesn't have to.
-  addImplicitBraces: ->
-    stack       = []
-    start       = null
-    startIndent = 0
-    condition = (token, i) ->
-      [one, two, three] = @tokens[i + 1 .. i + 3]
-      return false if 'HERECOMMENT' is one?[0]
-      [tag] = token
-      (tag in ['TERMINATOR', 'OUTDENT'] and
-        not (two?[0] is ':' or one?[0] is '@' and three?[0] is ':')) or
-        (tag is ',' and one and
-          one[0] not in ['IDENTIFIER', 'NUMBER', 'STRING', '@', 'TERMINATOR', 'OUTDENT'])
-    action = (token, i) -> @tokens.splice i, 0, ['}', '}', token[2]]
-    @scanTokens (token, i, tokens) ->
-      if (tag = token[0]) in EXPRESSION_START
-        stack.push [(if tag is 'INDENT' and @tag(i - 1) is '{' then '{' else tag), i]
-        return 1
-      if tag in EXPRESSION_END
-        start = stack.pop()
-        return 1
-      return 1 unless tag is ':' and
-        ((ago = @tag i - 2) is ':' or stack[stack.length - 1]?[0] isnt '{')
-      stack.push ['{']
-      idx =  if ago is '@' then i - 2 else i - 1
-      idx -= 2 while @tag(idx - 2) is 'HERECOMMENT'
-      value = new String('{')
-      value.generated = yes
-      tok = ['{', value, token[2]]
-      tok.generated = yes
-      tokens.splice idx, 0, tok
-      @detectEnd i + 2, condition, action
-      2
-
-  # Methods may be optionally called without parentheses, for simple cases.
-  # Insert the implicit parentheses here, so that the parser doesn't have to
-  # deal with them.
-  addImplicitParentheses: ->
-    noCall = no
-    action = (token, i) ->
-      idx = if token[0] is 'OUTDENT' then i + 1 else i
-      @tokens.splice idx, 0, ['CALL_END', ')', token[2]]
-    @scanTokens (token, i, tokens) ->
-      tag     = token[0]
-      noCall  = yes if tag in ['CLASS', 'IF']
-      [prev, current, next] = tokens[i - 1 .. i + 1]
-      callObject = not noCall and tag is 'INDENT' and
-                   next and next.generated and next[0] is '{' and
-                   prev and prev[0] in IMPLICIT_FUNC
-      seenSingle = no
-      noCall     = no if tag in LINEBREAKS
-      token.call = yes if prev and not prev.spaced and tag is '?'
-      return 1 unless callObject or
-        prev?.spaced and (prev.call or prev[0] in IMPLICIT_FUNC) and
-        (tag in IMPLICIT_CALL or not (token.spaced or token.newLine) and tag in IMPLICIT_UNSPACED_CALL)
-      tokens.splice i, 0, ['CALL_START', '(', token[2]]
-      @detectEnd i + 1, (token, i) ->
-        [tag] = token
-        return yes if not seenSingle and token.fromThen
-        seenSingle = yes if tag in ['IF', 'ELSE', '->', '=>']
-        return yes if tag in ['.', '?.', '::'] and @tag(i - 1) is 'OUTDENT'
-        not token.generated and @tag(i - 1) isnt ',' and tag in IMPLICIT_END and
-        (tag isnt 'INDENT' or
-         (@tag(i - 2) isnt 'CLASS' and @tag(i - 1) not in IMPLICIT_BLOCK and
-          not ((post = @tokens[i + 1]) and post.generated and post[0] is '{')))
-      , action
-      prev[0] = 'FUNC_EXIST' if prev[0] is '?'
-      2
-
-  # Because our grammar is LALR(1), it can't handle some single-line
-  # expressions that lack ending delimiters. The **Rewriter** adds the implicit
-  # blocks, so it doesn't need to. ')' can close a single-line block,
-  # but we need to make sure it's balanced.
-  addImplicitIndentation: ->
-    @scanTokens (token, i, tokens) ->
-      [tag] = token
-      if tag is 'TERMINATOR' and @tag(i + 1) is 'THEN'
-        tokens.splice i, 1
-        return 0
-      if tag is 'ELSE' and @tag(i - 1) isnt 'OUTDENT'
-        tokens.splice i, 0, @indentation(token)...
-        return 2
-      if tag is 'CATCH' and @tag(i + 2) in ['OUTDENT', 'TERMINATOR', 'FINALLY']
-        tokens.splice i + 2, 0, @indentation(token)...
-        return 4
-      if tag in SINGLE_LINERS and @tag(i + 1) isnt 'INDENT' and
-         not (tag is 'ELSE' and @tag(i + 1) is 'IF')
-        starter = tag
-        [indent, outdent] = @indentation token
-        indent.fromThen   = true if starter is 'THEN'
-        indent.generated  = outdent.generated = true
-        tokens.splice i + 1, 0, indent
-        condition = (token, i) ->
-          token[1] isnt ';' and token[0] in SINGLE_CLOSERS and
-          not (token[0] is 'ELSE' and starter not in ['IF', 'THEN'])
-        action = (token, i) ->
-          @tokens.splice (if @tag(i - 1) is ',' then i - 1 else i), 0, outdent
-        @detectEnd i + 2, condition, action
-        tokens.splice i, 1 if tag is 'THEN'
-        return 1
-      return 1
-
-  # Tag postfix conditionals as such, so that we can parse them with a
-  # different precedence.
-  tagPostfixConditionals: ->
-    condition = (token, i) -> token[0] in ['TERMINATOR', 'INDENT']
-    @scanTokens (token, i) ->
-      return 1 unless token[0] is 'IF'
-      original = token
-      @detectEnd i + 1, condition, (token, i) ->
-        original[0] = 'POST_' + original[0] if token[0] isnt 'INDENT'
-      1
-
-  # Ensure that all listed pairs of tokens are correctly balanced throughout
-  # the course of the token stream.
-  ensureBalance: (pairs) ->
-    levels   = {}
-    openLine = {}
-    for token in @tokens
-      [tag] = token
-      for [open, close] in pairs
-        levels[open] |= 0
-        if tag is open
-          openLine[open] = token[2] if levels[open]++ is 0
-        else if tag is close and --levels[open] < 0
-          throw Error "too many #{token[1]} on line #{token[2] + 1}"
-    for open, level of levels when level > 0
-      throw Error "unclosed #{ open } on line #{openLine[open] + 1}"
-    this
-
-  # We'd like to support syntax like this:
-  #
-  #     el.click((event) ->
-  #       el.hide())
-  #
-  # In order to accomplish this, move outdents that follow closing parens
-  # inwards, safely. The steps to accomplish this are:
-  #
-  # 1. Check that all paired tokens are balanced and in order.
-  # 2. Rewrite the stream with a stack: if you see an `EXPRESSION_START`, add it
-  #    to the stack. If you see an `EXPRESSION_END`, pop the stack and replace
-  #    it with the inverse of what we've just popped.
-  # 3. Keep track of "debt" for tokens that we manufacture, to make sure we end
-  #    up balanced in the end.
-  # 4. Be careful not to alter array or parentheses delimiters with overzealous
-  #    rewriting.
-  rewriteClosingParens: ->
-    stack = []
-    debt  = {}
-    debt[key] = 0 for key of INVERSES
-    @scanTokens (token, i, tokens) ->
-      if (tag = token[0]) in EXPRESSION_START
-        stack.push token
-        return 1
-      return 1 unless tag in EXPRESSION_END
-      if debt[inv = INVERSES[tag]] > 0
-        debt[inv] -= 1
-        tokens.splice i, 1
-        return 0
-      match = stack.pop()
-      mtag  = match[0]
-      oppos = INVERSES[mtag]
-      return 1 if tag is oppos
-      debt[mtag] += 1
-      val = [oppos, if mtag is 'INDENT' then match[1] else oppos]
-      if @tag(i + 2) is mtag
-        tokens.splice i + 3, 0, val
-        stack.push match
-      else
-        tokens.splice i, 0, val
-      1
-
-  # Generate the indentation tokens, based on another token on the same line.
-  indentation: (token) ->
-    [['INDENT', 2, token[2]], ['OUTDENT', 2, token[2]]]
-
-  # Look up a tag by token index.
-  tag: (i) -> @tokens[i]?[0]
-
-# Constants
-# ---------
-
-# List of the token pairs that must be balanced.
-BALANCED_PAIRS = [
-  ['(', ')']
-  ['[', ']']
-  ['{', '}']
-  ['INDENT', 'OUTDENT'],
-  ['CALL_START', 'CALL_END']
-  ['PARAM_START', 'PARAM_END']
-  ['INDEX_START', 'INDEX_END']
-]
-
-# The inverse mappings of `BALANCED_PAIRS` we're trying to fix up, so we can
-# look things up from either end.
-INVERSES = {}
-
-# The tokens that signal the start/end of a balanced pair.
-EXPRESSION_START = []
-EXPRESSION_END   = []
-
-for [left, rite] in BALANCED_PAIRS
-  EXPRESSION_START.push INVERSES[rite] = left
-  EXPRESSION_END  .push INVERSES[left] = rite
-
-# Tokens that indicate the close of a clause of an expression.
-EXPRESSION_CLOSE = ['CATCH', 'WHEN', 'ELSE', 'FINALLY'].concat EXPRESSION_END
-
-# Tokens that, if followed by an `IMPLICIT_CALL`, indicate a function invocation.
-IMPLICIT_FUNC    = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '@', 'THIS']
-
-# If preceded by an `IMPLICIT_FUNC`, indicates a function invocation.
-IMPLICIT_CALL    = [
-  'IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS'
-  'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'UNARY', 'SUPER'
-  '@', '->', '=>', '[', '(', '{', '--', '++'
-]
-
-IMPLICIT_UNSPACED_CALL = ['+', '-']
-
-# Tokens indicating that the implicit call must enclose a block of expressions.
-IMPLICIT_BLOCK   = ['->', '=>', '{', '[', ',']
-
-# Tokens that always mark the end of an implicit call for single-liners.
-IMPLICIT_END     = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR', 'INDENT']
-
-# Single-line flavors of block expressions that have unclosed endings.
-# The grammar can't disambiguate them, so we insert the implicit indentation.
-SINGLE_LINERS    = ['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN']
-SINGLE_CLOSERS   = ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN']
-
-# Tokens that end a line.
-LINEBREAKS       = ['TERMINATOR', 'INDENT', 'OUTDENT']