coffee-script 0.3.2 → 1.0.0

data/lib/coffee_script/repl.js

@@ -1,33 +0,0 @@
-(function(){
-  var coffee, prompt, quit, readline, run;
-  // A CoffeeScript port/version of the Node.js REPL.
-  // Required modules.
-  coffee = require('./coffee-script');
-  process.mixin(require('sys'));
-  // Shortcut variables.
-  prompt = 'coffee> ';
-  quit = function quit() {
-    return process.stdio.close();
-  };
-  // The main REPL function. Called everytime a line of code is entered.
-  readline = function readline(code) {
-    return coffee.compile(code, run);
-  };
-  // Attempt to evaluate the command. If there's an exception, print it.
-  run = function run(js) {
-    var val;
-    try {
-      val = eval(js);
-      if (val !== undefined) {
-        p(val);
-      }
-    } catch (err) {
-      puts(err.stack || err.toString());
-    }
-    return print(prompt);
-  };
-  // Start up the REPL.
-  process.stdio.open();
-  process.stdio.addListener('data', readline);
-  print(prompt);
-})();

data/lib/coffee_script/rewriter.js

@@ -1,377 +0,0 @@
-(function(){
-  var BALANCED_PAIRS, EXPRESSION_CLOSE, EXPRESSION_START, EXPRESSION_TAIL, IMPLICIT_CALL, IMPLICIT_END, IMPLICIT_FUNC, INVERSES, SINGLE_CLOSERS, SINGLE_LINERS, __a, __b, __c, __d, __e, __f, __g, __h, pair, re;
-  var __hasProp = Object.prototype.hasOwnProperty;
-  // In order to keep the grammar simple, the stream of tokens that the Lexer
-  // emits is rewritten by the Rewriter, smoothing out ambiguities, mis-nested
-  // indentation, and single-line flavors of expressions.
-  exports.Rewriter = (re = function re() {  });
-  // Tokens that must be balanced.
-  BALANCED_PAIRS = [['(', ')'], ['[', ']'], ['{', '}'], ['INDENT', 'OUTDENT'], ['PARAM_START', 'PARAM_END'], ['CALL_START', 'CALL_END'], ['INDEX_START', 'INDEX_END']];
-  // Tokens that signal the start of a balanced pair.
-  EXPRESSION_START = (function() {
-    __a = []; __b = BALANCED_PAIRS;
-    for (__c = 0; __c < __b.length; __c++) {
-      pair = __b[__c];
-      __a.push(pair[0]);
-    }
-    return __a;
-  }).call(this);
-  // Tokens that signal the end of a balanced pair.
-  EXPRESSION_TAIL = (function() {
-    __d = []; __e = BALANCED_PAIRS;
-    for (__f = 0; __f < __e.length; __f++) {
-      pair = __e[__f];
-      __d.push(pair[1]);
-    }
-    return __d;
-  }).call(this);
-  // Tokens that indicate the close of a clause of an expression.
-  EXPRESSION_CLOSE = ['CATCH', 'WHEN', 'ELSE', 'FINALLY'].concat(EXPRESSION_TAIL);
-  // Tokens pairs that, in immediate succession, indicate an implicit call.
-  IMPLICIT_FUNC = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END'];
-  IMPLICIT_END = ['IF', 'UNLESS', 'FOR', 'WHILE', 'TERMINATOR', 'OUTDENT'];
-  IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'TRY', 'DELETE', 'TYPEOF', 'SWITCH', 'ARGUMENTS', 'TRUE', 'FALSE', 'YES', 'NO', 'ON', 'OFF', '!', '!!', 'NOT', '->', '=>', '[', '(', '{'];
-  // The inverse mappings of token pairs we're trying to fix up.
-  INVERSES = {
-  };
-  __g = BALANCED_PAIRS;
-  for (__h = 0; __h < __g.length; __h++) {
-    pair = __g[__h];
-    INVERSES[pair[0]] = pair[1];
-    INVERSES[pair[1]] = pair[0];
-  }
-  // 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', 'PARAM_START'];
-  // 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 like this.
-  re.prototype.rewrite = function rewrite(tokens) {
-    this.tokens = tokens;
-    this.adjust_comments();
-    this.remove_leading_newlines();
-    this.remove_mid_expression_newlines();
-    this.move_commas_outside_outdents();
-    this.close_open_calls_and_indexes();
-    this.add_implicit_parentheses();
-    this.add_implicit_indentation();
-    this.ensure_balance(BALANCED_PAIRS);
-    this.rewrite_closing_parens();
-    return this.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 the stream changes length under our feet.
-  re.prototype.scan_tokens = function scan_tokens(block) {
-    var i, move;
-    i = 0;
-    while (true) {
-      if (!(this.tokens[i])) {
-        break;
-      }
-      move = block(this.tokens[i - 1], this.tokens[i], this.tokens[i + 1], i);
-      i += move;
-    }
-    return true;
-  };
-  // Massage newlines and indentations so that comments don't have to be
-  // correctly indented, or appear on their own line.
-  re.prototype.adjust_comments = function adjust_comments() {
-    return this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        var after, before;
-        if (!(token[0] === 'COMMENT')) {
-          return 1;
-        }
-        before = this.tokens[i - 2];
-        after = this.tokens[i + 2];
-        if (before && after && ((before[0] === 'INDENT' && after[0] === 'OUTDENT') || (before[0] === 'OUTDENT' && after[0] === 'INDENT')) && before[1] === after[1]) {
-          this.tokens.splice(i + 2, 1);
-          this.tokens.splice(i - 2, 1);
-          return 0;
-        } else if (prev[0] === 'TERMINATOR' && after[0] === 'INDENT') {
-          this.tokens.splice(i + 2, 1);
-          this.tokens[i - 1] = after;
-          return 1;
-        } else if (prev[0] !== 'TERMINATOR' && prev[0] !== 'INDENT' && prev[0] !== 'OUTDENT') {
-          this.tokens.splice(i, 0, ['TERMINATOR', "\n", prev[2]]);
-          return 2;
-        } else {
-          return 1;
-        }
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-  };
-  // Leading newlines would introduce an ambiguity in the grammar, so we
-  // dispatch them here.
-  re.prototype.remove_leading_newlines = function remove_leading_newlines() {
-    if (this.tokens[0][0] === 'TERMINATOR') {
-      return this.tokens.shift();
-    }
-  };
-  // Some blocks occur in the middle of expressions -- when we're expecting
-  // this, remove their trailing newlines.
-  re.prototype.remove_mid_expression_newlines = function remove_mid_expression_newlines() {
-    return this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        if (!(post && EXPRESSION_CLOSE.indexOf(post[0]) >= 0 && token[0] === 'TERMINATOR')) {
-          return 1;
-        }
-        this.tokens.splice(i, 1);
-        return 0;
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-  };
-  // Make sure that we don't accidentally break trailing commas, which need
-  // to go on the outside of expression closers.
-  re.prototype.move_commas_outside_outdents = function move_commas_outside_outdents() {
-    return this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        if (token[0] === 'OUTDENT' && prev[0] === ',') {
-          this.tokens.splice(i, 1, token);
-        }
-        return 1;
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-  };
-  // We've tagged the opening parenthesis of a method call, and the opening
-  // bracket of an indexing operation. Match them with their close.
-  re.prototype.close_open_calls_and_indexes = function close_open_calls_and_indexes() {
-    var brackets, parens;
-    parens = [0];
-    brackets = [0];
-    return this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        if (token[0] === 'CALL_START') {
-          parens.push(0);
-        } else if (token[0] === 'INDEX_START') {
-          brackets.push(0);
-        } else if (token[0] === '(') {
-          parens[parens.length - 1] += 1;
-        } else if (token[0] === '[') {
-          brackets[brackets.length - 1] += 1;
-        } else if (token[0] === ')') {
-          if (parens[parens.length - 1] === 0) {
-            parens.pop();
-            token[0] = 'CALL_END';
-          } else {
-            parens[parens.length - 1] -= 1;
-          }
-        } else if (token[0] === ']') {
-          if (brackets[brackets.length - 1] === 0) {
-            brackets.pop();
-            token[0] = 'INDEX_END';
-          } else {
-            brackets[brackets.length - 1] -= 1;
-          }
-        }
-        return 1;
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-  };
-  // 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.
-  re.prototype.add_implicit_parentheses = function add_implicit_parentheses() {
-    var stack;
-    stack = [0];
-    return this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        var __i, __j, __k, __l, idx, last, size, tmp;
-        if (token[0] === 'INDENT') {
-          stack.push(0);
-        }
-        if (token[0] === 'OUTDENT') {
-          last = stack.pop();
-          stack[stack.length - 1] += last;
-        }
-        if (stack[stack.length - 1] > 0 && (IMPLICIT_END.indexOf(token[0]) >= 0 || (typeof !post !== "undefined" && !post !== null))) {
-          idx = token[0] === 'OUTDENT' ? i + 1 : i;
-          __k = 0; __l = stack[stack.length - 1];
-          for (__j=0, tmp=__k; (__k <= __l ? tmp < __l : tmp > __l); (__k <= __l ? tmp += 1 : tmp -= 1), __j++) {
-            this.tokens.splice(idx, 0, ['CALL_END', ')']);
-          }
-          size = stack[stack.length - 1] + 1;
-          stack[stack.length - 1] = 0;
-          return size;
-        }
-        if (!(prev && IMPLICIT_FUNC.indexOf(prev[0]) >= 0 && IMPLICIT_CALL.indexOf(token[0]) >= 0)) {
-          return 1;
-        }
-        this.tokens.splice(i, 0, ['CALL_START', '(']);
-        stack[stack.length - 1] += 1;
-        return 2;
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-  };
-  // Because our grammar is LALR(1), it can't handle some single-line
-  // expressions that lack ending delimiters. Use the lexer to add the implicit
-  // blocks, so it doesn't need to.
-  // ')' can close a single-line block, but we need to make sure it's balanced.
-  re.prototype.add_implicit_indentation = function add_implicit_indentation() {
-    return this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        var idx, insertion, parens, starter, tok;
-        if (!(SINGLE_LINERS.indexOf(token[0]) >= 0 && post[0] !== 'INDENT' && !(token[0] === 'ELSE' && post[0] === 'IF'))) {
-          return 1;
-        }
-        starter = token[0];
-        this.tokens.splice(i + 1, 0, ['INDENT', 2]);
-        idx = i + 1;
-        parens = 0;
-        while (true) {
-          idx += 1;
-          tok = this.tokens[idx];
-          if ((!tok || SINGLE_CLOSERS.indexOf(tok[0]) >= 0 || (tok[0] === ')' && parens === 0)) && !(starter === 'ELSE' && tok[0] === 'ELSE')) {
-            insertion = this.tokens[idx - 1][0] === "," ? idx - 1 : idx;
-            this.tokens.splice(insertion, 0, ['OUTDENT', 2]);
-            break;
-          }
-          if (tok[0] === '(') {
-            parens += 1;
-          }
-          if (tok[0] === ')') {
-            parens -= 1;
-          }
-        }
-        if (!(token[0] === 'THEN')) {
-          return 1;
-        }
-        this.tokens.splice(i, 1);
-        return 0;
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-  };
-  // Ensure that all listed pairs of tokens are correctly balanced throughout
-  // the course of the token stream.
-  re.prototype.ensure_balance = function ensure_balance(pairs) {
-    var __i, __j, key, levels, unclosed, value;
-    levels = {
-    };
-    this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        var __i, __j, __k, close, open;
-        __i = pairs;
-        for (__j = 0; __j < __i.length; __j++) {
-          pair = __i[__j];
-          __k = pair;
-          open = __k[0];
-          close = __k[1];
-          levels[open] = levels[open] || 0;
-          if (token[0] === open) {
-            levels[open] += 1;
-          }
-          if (token[0] === close) {
-            levels[open] -= 1;
-          }
-          if (levels[open] < 0) {
-            throw "too many " + token[1];
-          }
-        }
-        return 1;
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-    unclosed = (function() {
-      __i = []; __j = levels;
-      for (key in __j) {
-        value = __j[key];
-        if (__hasProp.call(__j, key)) {
-          if (value > 0) {
-            __i.push(key);
-          }
-        }
-      }
-      return __i;
-    }).call(this);
-    if (unclosed.length) {
-      throw "unclosed " + unclosed[0];
-    }
-  };
-  // 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 '(' or INDENT, add it
-  //    to the stack. If you see an ')' or OUTDENT, pop the stack and replace
-  //    it with the inverse of what we've just popped.
-  // 3. Keep track of "debt" for tokens that we fake, to make sure we end
-  //    up balanced in the end.
-  re.prototype.rewrite_closing_parens = function rewrite_closing_parens() {
-    var __i, debt, key, stack, val;
-    stack = [];
-    debt = {
-    };
-    __i = INVERSES;
-    for (key in __i) {
-      val = __i[key];
-      if (__hasProp.call(__i, key)) {
-        ((debt[key] = 0));
-      }
-    }
-    return this.scan_tokens((function(__this) {
-      var __func = function(prev, token, post, i) {
-        var inv, match, mtag, tag;
-        tag = token[0];
-        inv = INVERSES[token[0]];
-        // Push openers onto the stack.
-        if (EXPRESSION_START.indexOf(tag) >= 0) {
-          stack.push(token);
-          return 1;
-          // The end of an expression, check stack and debt for a pair.
-        } else if (EXPRESSION_TAIL.indexOf(tag) >= 0) {
-          // If the tag is already in our debt, swallow it.
-          if (debt[inv] > 0) {
-            debt[inv] -= 1;
-            this.tokens.splice(i, 1);
-            return 0;
-          } else {
-            // Pop the stack of open delimiters.
-            match = stack.pop();
-            mtag = match[0];
-            // Continue onwards if it's the expected tag.
-            if (tag === INVERSES[mtag]) {
-              return 1;
-            } else {
-              // Unexpected close, insert correct close, adding to the debt.
-              debt[mtag] += 1;
-              val = mtag === 'INDENT' ? match[1] : INVERSES[mtag];
-              this.tokens.splice(i, 0, [INVERSES[mtag], val]);
-              return 1;
-            }
-          }
-        } else {
-          return 1;
-        }
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
-  };
-})();

data/lib/coffee_script/rewriter.rb

@@ -1,289 +0,0 @@
-module CoffeeScript
-
-  # In order to keep the grammar simple, the stream of tokens that the Lexer
-  # emits is rewritten by the Rewriter, smoothing out ambiguities, mis-nested
-  # indentation, and single-line flavors of expressions.
-  class Rewriter
-
-    # Tokens that must be balanced.
-    BALANCED_PAIRS = [['(', ')'], ['[', ']'], ['{', '}'], [:INDENT, :OUTDENT],
-      [:PARAM_START, :PARAM_END], [:CALL_START, :CALL_END], [:INDEX_START, :INDEX_END]]
-
-    # Tokens that signal the start of a balanced pair.
-    EXPRESSION_START = BALANCED_PAIRS.map {|pair| pair.first }
-
-    # Tokens that signal the end of a balanced pair.
-    EXPRESSION_TAIL  = BALANCED_PAIRS.map {|pair| pair.last }
-
-    # Tokens that indicate the close of a clause of an expression.
-    EXPRESSION_CLOSE = [:CATCH, :WHEN, :ELSE, :FINALLY] + EXPRESSION_TAIL
-
-    # Tokens pairs that, in immediate succession, indicate an implicit call.
-    IMPLICIT_FUNC = [:IDENTIFIER, :SUPER, ')', :CALL_END, ']', :INDEX_END]
-    IMPLICIT_END  = [:IF, :UNLESS, :FOR, :WHILE, "\n", :OUTDENT]
-    IMPLICIT_CALL = [:IDENTIFIER, :NUMBER, :STRING, :JS, :REGEX, :NEW, :PARAM_START,
-                     :TRY, :DELETE, :TYPEOF, :SWITCH,
-                     :TRUE, :FALSE, :YES, :NO, :ON, :OFF, '!', '!!', :NOT,
-                     '@', '->', '=>', '[', '(', '{']
-
-    # The inverse mappings of token pairs we're trying to fix up.
-    INVERSES = BALANCED_PAIRS.inject({}) do |memo, pair|
-      memo[pair.first] = pair.last
-      memo[pair.last]  = pair.first
-      memo
-    end
-
-    # 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 = ["\n", :CATCH, :FINALLY, :ELSE, :OUTDENT, :LEADING_WHEN, :PARAM_START]
-
-    # 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 like this.
-    def rewrite(tokens)
-      @tokens = tokens
-      adjust_comments
-      remove_leading_newlines
-      remove_mid_expression_newlines
-      move_commas_outside_outdents
-      close_open_calls_and_indexes
-      add_implicit_parentheses
-      add_implicit_indentation
-      ensure_balance(*BALANCED_PAIRS)
-      rewrite_closing_parens
-      @tokens
-    end
-
-    # 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 the stream changes length under our feet.
-    def scan_tokens
-      i = 0
-      loop do
-        break unless @tokens[i]
-        move = yield(@tokens[i - 1], @tokens[i], @tokens[i + 1], i)
-        i += move
-      end
-    end
-
-    # Massage newlines and indentations so that comments don't have to be
-    # correctly indented, or appear on their own line.
-    def adjust_comments
-      scan_tokens do |prev, token, post, i|
-        next 1 unless token[0] == :COMMENT
-        before, after = @tokens[i - 2], @tokens[i + 2]
-        if before && after &&
-            ((before[0] == :INDENT && after[0] == :OUTDENT) ||
-            (before[0] == :OUTDENT && after[0] == :INDENT)) &&
-            before[1] == after[1]
-          @tokens.delete_at(i + 2)
-          @tokens.delete_at(i - 2)
-          next 0
-        elsif prev[0] == "\n" && [:INDENT].include?(after[0])
-          @tokens.delete_at(i + 2)
-          @tokens[i - 1] = after
-          next 1
-        elsif !["\n", :INDENT, :OUTDENT].include?(prev[0])
-          @tokens.insert(i, ["\n", Value.new("\n", token[1].line)])
-          next 2
-        else
-          next 1
-        end
-      end
-    end
-
-    # Leading newlines would introduce an ambiguity in the grammar, so we
-    # dispatch them here.
-    def remove_leading_newlines
-      @tokens.shift if @tokens[0][0] == "\n"
-    end
-
-    # Some blocks occur in the middle of expressions -- when we're expecting
-    # this, remove their trailing newlines.
-    def remove_mid_expression_newlines
-      scan_tokens do |prev, token, post, i|
-        next 1 unless post && EXPRESSION_CLOSE.include?(post[0]) && token[0] == "\n"
-        @tokens.delete_at(i)
-        next 0
-      end
-    end
-
-    # Make sure that we don't accidentally break trailing commas, which need
-    # to go on the outside of expression closers.
-    def move_commas_outside_outdents
-      scan_tokens do |prev, token, post, i|
-        if token[0] == :OUTDENT && prev[0] == ','
-          @tokens.delete_at(i)
-          @tokens.insert(i - 1, token)
-        end
-        next 1
-      end
-    end
-
-    # We've tagged the opening parenthesis of a method call, and the opening
-    # bracket of an indexing operation. Match them with their close.
-    def close_open_calls_and_indexes
-      parens, brackets = [0], [0]
-      scan_tokens do |prev, token, post, i|
-        case token[0]
-        when :CALL_START  then parens.push(0)
-        when :INDEX_START then brackets.push(0)
-        when '('          then parens[-1] += 1
-        when '['          then brackets[-1] += 1
-        when ')'
-          if parens.last == 0
-            parens.pop
-            token[0] = :CALL_END
-          else
-            parens[-1] -= 1
-          end
-        when ']'
-          if brackets.last == 0
-            brackets.pop
-            token[0] = :INDEX_END
-          else
-            brackets[-1] -= 1
-          end
-        end
-        next 1
-      end
-    end
-
-    # 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.
-    def add_implicit_parentheses
-      stack = [0]
-      scan_tokens do |prev, token, post, i|
-        stack.push(0) if token[0] == :INDENT
-        if token[0] == :OUTDENT
-          last = stack.pop
-          stack[-1] += last
-        end
-        if stack.last > 0 && (IMPLICIT_END.include?(token[0]) || post.nil?)
-          idx = token[0] == :OUTDENT ? i + 1 : i
-          stack.last.times { @tokens.insert(idx, [:CALL_END, Value.new(')', token[1].line)]) }
-          size, stack[-1] = stack[-1] + 1, 0
-          next size
-        end
-        next 1 unless IMPLICIT_FUNC.include?(prev[0]) && IMPLICIT_CALL.include?(token[0])
-        @tokens.insert(i, [:CALL_START, Value.new('(', token[1].line)])
-        stack[-1] += 1
-        next 2
-      end
-    end
-
-    # Because our grammar is LALR(1), it can't handle some single-line
-    # expressions that lack ending delimiters. Use the lexer to add the implicit
-    # blocks, so it doesn't need to.
-    # ')' can close a single-line block, but we need to make sure it's balanced.
-    def add_implicit_indentation
-      scan_tokens do |prev, token, post, i|
-        next 1 unless SINGLE_LINERS.include?(token[0]) && post[0] != :INDENT &&
-          !(token[0] == :ELSE && post[0] == :IF) # Elsifs shouldn't get blocks.
-        starter = token[0]
-        line = token[1].line
-        @tokens.insert(i + 1, [:INDENT, Value.new(2, line)])
-        idx = i + 1
-        parens = 0
-        loop do
-          idx += 1
-          tok = @tokens[idx]
-          if (!tok || SINGLE_CLOSERS.include?(tok[0]) ||
-              (tok[0] == ')' && parens == 0)) &&
-              !(starter == :ELSE && tok[0] == :ELSE)
-            insertion = @tokens[idx - 1][0] == "," ? idx - 1 : idx
-            @tokens.insert(insertion, [:OUTDENT, Value.new(2, line)])
-            break
-          end
-          parens += 1 if tok[0] == '('
-          parens -= 1 if tok[0] == ')'
-        end
-        next 1 unless token[0] == :THEN
-        @tokens.delete_at(i)
-        next 0
-      end
-    end
-
-    # Ensure that all listed pairs of tokens are correctly balanced throughout
-    # the course of the token stream.
-    def ensure_balance(*pairs)
-      puts "\nbefore ensure_balance: #{@tokens.inspect}" if ENV['VERBOSE']
-      levels, lines = Hash.new(0), Hash.new
-      scan_tokens do |prev, token, post, i|
-        pairs.each do |pair|
-          open, close = *pair
-          levels[open] += 1 if token[0] == open
-          levels[open] -= 1 if token[0] == close
-          lines[token[0]] = token[1].line
-          raise ParseError.new(token[0], token[1], nil) if levels[open] < 0
-        end
-        next 1
-      end
-      unclosed = levels.detect {|k, v| v > 0 }
-      sym = unclosed && unclosed[0]
-      raise ParseError.new(sym, Value.new(sym, lines[sym]), nil, "unclosed '#{sym}'") if unclosed
-    end
-
-    # 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 '(' or INDENT, add it
-    #    to the stack. If you see an ')' or OUTDENT, pop the stack and replace
-    #    it with the inverse of what we've just popped.
-    # 3. Keep track of "debt" for tokens that we fake, to make sure we end
-    #    up balanced in the end.
-    #
-    def rewrite_closing_parens
-      verbose = ENV['VERBOSE']
-      stack, debt = [], Hash.new(0)
-      stack_stats = lambda { "stack: #{stack.inspect} debt: #{debt.inspect}\n\n" }
-      puts "rewrite_closing_original: #{@tokens.inspect}" if verbose
-      scan_tokens do |prev, token, post, i|
-        tag, inv = token[0], INVERSES[token[0]]
-        # Push openers onto the stack.
-        if EXPRESSION_START.include?(tag)
-          stack.push(token)
-          puts "pushing #{tag} #{stack_stats[]}" if verbose
-          next 1
-        # The end of an expression, check stack and debt for a pair.
-        elsif EXPRESSION_TAIL.include?(tag)
-          puts @tokens[i..-1].inspect if verbose
-          # If the tag is already in our debt, swallow it.
-          if debt[inv] > 0
-            debt[inv] -= 1
-            @tokens.delete_at(i)
-            puts "tag in debt #{tag} #{stack_stats[]}" if verbose
-            next 0
-          else
-            # Pop the stack of open delimiters.
-            match = stack.pop
-            mtag  = match[0]
-            # Continue onwards if it's the expected tag.
-            if tag == INVERSES[mtag]
-              puts "expected tag #{tag} #{stack_stats[]}" if verbose
-              next 1
-            else
-              # Unexpected close, insert correct close, adding to the debt.
-              debt[mtag] += 1
-              puts "unexpected #{tag}, replacing with #{INVERSES[mtag]} #{stack_stats[]}" if verbose
-              val = mtag == :INDENT ? match[1] : INVERSES[mtag]
-              @tokens.insert(i, [INVERSES[mtag], Value.new(val, token[1].line)])
-              next 1
-            end
-          end
-        else
-          # Uninteresting token:
-          next 1
-        end
-      end
-    end
-
-  end
-end