haml-more 0.4.0.a

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

@@ -0,0 +1,79 @@
+# Create an OptionParser with a list of valid options.
+op: exports.OptionParser: (rules) ->
+  @banner:        'Usage: [Options]'
+  @options_title: 'Available options:'
+  @rules:         build_rules(rules)
+  @actions:       {}
+  this
+
+# Add a callback to fire when a particular option is encountered.
+op::add: (value, callback) ->
+  @actions[value]: callback
+
+# Parse the argument array, calling defined callbacks, returning the remaining non-option arguments.
+op::parse: (args) ->
+  results: []
+  args:   args.concat []
+  while (arg: args.shift())
+    is_option: false
+    for rule in @rules
+      if rule.letter is arg or rule.flag is arg
+        callback: @actions[rule.name]
+        value: rule.argument and args.shift()
+        callback(value) if callback
+        is_option: true
+        break
+    results.push arg unless is_option
+  results
+
+# Return the help text for this OptionParser, for --help and such.
+op::help: ->
+  longest: 0
+  has_shorts: false
+  lines: [@banner, '', @options_title]
+  for rule in @rules
+    has_shorts: true if rule.letter
+    longest: rule.flag.length if rule.flag.length > longest
+  for rule in @rules
+    if has_shorts
+      text: if rule.letter then spaces(2) + rule.letter + ', ' else spaces(6)
+    text += spaces(longest, rule.flag) + spaces(3)
+    text += rule.description
+    lines.push text
+  lines.join('\n')
+
+# Private:
+
+# Regex matchers for option flags.
+LONG_FLAG:  /^(--[\w\-]+)/
+SHORT_FLAG: /^(-\w+)/
+OPTIONAL:   /\[(.+)\]/
+
+# Build rules from a list of valid switch tuples in the form:
+# [letter-flag, long-flag, help], or [long-flag, help].
+build_rules: (rules) ->
+  for tuple in rules
+    tuple.unshift(null) if tuple.length < 3
+    build_rule(tuple...)
+
+# Build a rule from a short-letter-flag, long-form-flag, and help text.
+build_rule: (letter, flag, description) ->
+  match: flag.match(OPTIONAL)
+  flag:  flag.match(LONG_FLAG)[1]
+  {
+    name:         flag.substr(2)
+    letter:       letter
+    flag:         flag
+    description:  description
+    argument:     !!(match and match[1])
+  }
+
+# Space-pad a string with the specified number of characters.
+spaces: (num, text) ->
+  builder: []
+  if text
+    return text if text.length >= num
+    num -= text.length
+    builder.push text
+  while num -= 1 then builder.push ' '
+  builder.join ''

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

@@ -0,0 +1,23 @@
+# A CoffeeScript port/version of the Node.js REPL.
+
+# Required modules.
+coffee: require 'coffee-script'
+
+# Shortcut variables.
+prompt: 'coffee> '
+quit:   -> process.exit(0)
+
+# The main REPL function. Called everytime a line of code is entered.
+# Attempt to evaluate the command. If there's an exception, print it.
+readline: (code) ->
+  try
+    val: eval coffee.compile code, {no_wrap: true, globals: true}
+    p val if val isnt undefined
+  catch err
+    puts err.stack or err.toString()
+  print prompt
+
+# Start up the REPL.
+process.stdio.addListener 'data', readline
+process.stdio.open()
+print prompt

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

@@ -0,0 +1,253 @@
+this.exports: this unless process?
+
+# 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: ->
+
+# Tokens that must be balanced.
+BALANCED_PAIRS: [['(', ')'], ['[', ']'], ['{', '}'], ['INDENT', 'OUTDENT'],
+  ['PARAM_START', 'PARAM_END'], ['CALL_START', 'CALL_END'],
+  ['INDEX_START', 'INDEX_END'], ['SOAKED_INDEX_START', 'SOAKED_INDEX_END']]
+
+# Tokens that signal the start of a balanced pair.
+EXPRESSION_START: pair[0] for pair in BALANCED_PAIRS
+
+# Tokens that signal the end of a balanced pair.
+EXPRESSION_TAIL: pair[1] for pair in BALANCED_PAIRS
+
+# 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_BLOCK:['->', '=>', '{', '[', ',']
+IMPLICIT_END:  ['IF', 'UNLESS', 'FOR', 'WHILE', 'TERMINATOR', 'INDENT', '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: {}
+for pair in BALANCED_PAIRS
+  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::rewrite: (tokens) ->
+  @tokens: tokens
+  @adjust_comments()
+  @remove_leading_newlines()
+  @remove_mid_expression_newlines()
+  @move_commas_outside_outdents()
+  @close_open_calls_and_indexes()
+  @add_implicit_indentation()
+  @add_implicit_parentheses()
+  @ensure_balance(BALANCED_PAIRS)
+  @rewrite_closing_parens()
+  @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::scan_tokens: (block) ->
+  i: 0
+  while true
+    break unless @tokens[i]
+    move: block(@tokens[i - 1], @tokens[i], @tokens[i + 1], i)
+    i += move
+  true
+
+# Massage newlines and indentations so that comments don't have to be
+# correctly indented, or appear on their own line.
+re::adjust_comments: ->
+  @scan_tokens (prev, token, post, i) =>
+    return 1 unless token[0] is 'COMMENT'
+    before: @tokens[i - 2]
+    after:  @tokens[i + 2]
+    if before and after and
+        ((before[0] is 'INDENT' and after[0] is 'OUTDENT') or
+        (before[0] is 'OUTDENT' and after[0] is 'INDENT')) and
+        before[1] is after[1]
+      @tokens.splice(i + 2, 1)
+      @tokens.splice(i - 2, 1)
+      return 0
+    else if prev and prev[0] is 'TERMINATOR' and after and after[0] is 'INDENT'
+      @tokens.splice(i + 2, 1)
+      @tokens[i - 1]: after
+      return 1
+    else if prev and prev[0] isnt 'TERMINATOR' and prev[0] isnt 'INDENT' and prev[0] isnt 'OUTDENT'
+      @tokens.splice(i, 0, ['TERMINATOR', "\n", prev[2]])
+      return 2
+    else
+      return 1
+
+# Leading newlines would introduce an ambiguity in the grammar, so we
+# dispatch them here.
+re::remove_leading_newlines: ->
+  @tokens.shift() if @tokens[0][0] is 'TERMINATOR'
+
+# Some blocks occur in the middle of expressions -- when we're expecting
+# this, remove their trailing newlines.
+re::remove_mid_expression_newlines: ->
+  @scan_tokens (prev, token, post, i) =>
+    return 1 unless post and EXPRESSION_CLOSE.indexOf(post[0]) >= 0 and token[0] is 'TERMINATOR'
+    @tokens.splice(i, 1)
+    return 0
+
+# Make sure that we don't accidentally break trailing commas, which need
+# to go on the outside of expression closers.
+re::move_commas_outside_outdents: ->
+  @scan_tokens (prev, token, post, i) =>
+    @tokens.splice(i, 1, token) if token[0] is 'OUTDENT' and prev[0] is ','
+    return 1
+
+# We've tagged the opening parenthesis of a method call, and the opening
+# bracket of an indexing operation. Match them with their close.
+re::close_open_calls_and_indexes: ->
+  parens:   [0]
+  brackets: [0]
+  @scan_tokens (prev, token, post, i) =>
+    switch token[0]
+      when 'CALL_START'  then parens.push(0)
+      when 'INDEX_START' then brackets.push(0)
+      when '('           then parens[parens.length - 1] += 1
+      when '['           then brackets[brackets.length - 1] += 1
+      when ')'
+        if parens[parens.length - 1] is 0
+          parens.pop()
+          token[0]: 'CALL_END'
+        else
+          parens[parens.length - 1] -= 1
+      when ']'
+        if brackets[brackets.length - 1] == 0
+          brackets.pop()
+          token[0]: 'INDEX_END'
+        else
+          brackets[brackets.length - 1] -= 1
+    return 1
+
+# 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::add_implicit_parentheses: ->
+  stack: [0]
+  @scan_tokens (prev, token, post, i) =>
+    tag: token[0]
+    stack.push(0) if tag is 'INDENT'
+    if tag is 'OUTDENT'
+      last: stack.pop()
+      stack[stack.length - 1] += last
+    if IMPLICIT_END.indexOf(tag) >= 0 or !post?
+      return 1 if tag is 'INDENT' and prev and IMPLICIT_BLOCK.indexOf(prev[0]) >= 0
+      if stack[stack.length - 1] > 0 or tag is 'INDENT'
+        idx: if tag is 'OUTDENT' then i + 1 else i
+        stack_pointer: if tag is 'INDENT' then 2 else 1
+        for tmp in [0...stack[stack.length - stack_pointer]]
+          @tokens.splice(idx, 0, ['CALL_END', ')', token[2]])
+        size: stack[stack.length - stack_pointer] + 1
+        stack[stack.length - stack_pointer]: 0
+        return size
+    return 1 unless prev and IMPLICIT_FUNC.indexOf(prev[0]) >= 0 and IMPLICIT_CALL.indexOf(tag) >= 0
+    @tokens.splice(i, 0, ['CALL_START', '(', token[2]])
+    stack[stack.length - 1] += 1
+    return 2
+
+# 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::add_implicit_indentation: ->
+  @scan_tokens (prev, token, post, i) =>
+    return 1 unless SINGLE_LINERS.indexOf(token[0]) >= 0 and post[0] isnt 'INDENT' and
+      not (token[0] is 'ELSE' and post[0] is 'IF')
+    starter: token[0]
+    @tokens.splice(i + 1, 0, ['INDENT', 2, token[2]])
+    idx: i + 1
+    parens: 0
+    while true
+      idx += 1
+      tok: @tokens[idx]
+      if (not tok or
+          (SINGLE_CLOSERS.indexOf(tok[0]) >= 0 and tok[1] isnt ';') or
+          (tok[0] is ')' && parens is 0)) and
+          not (starter is 'ELSE' and tok[0] is 'ELSE')
+        insertion: if @tokens[idx - 1][0] is "," then idx - 1 else idx
+        @tokens.splice(insertion, 0, ['OUTDENT', 2, token[2]])
+        break
+      parens += 1 if tok[0] is '('
+      parens -= 1 if tok[0] is ')'
+    return 1 unless token[0] is 'THEN'
+    @tokens.splice(i, 1)
+    return 0
+
+# Ensure that all listed pairs of tokens are correctly balanced throughout
+# the course of the token stream.
+re::ensure_balance: (pairs) ->
+  levels: {}
+  @scan_tokens (prev, token, post, i) =>
+    for pair in pairs
+      [open, close]: pair
+      levels[open] ||= 0
+      levels[open] += 1 if token[0] is open
+      levels[open] -= 1 if token[0] is close
+      throw new Error("too many " + token[1]) if levels[open] < 0
+    return 1
+  unclosed: key for key, value of levels when value > 0
+  throw new Error("unclosed " + unclosed[0]) if unclosed.length
+
+# 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::rewrite_closing_parens: ->
+  stack: []
+  debt:  {}
+  (debt[key]: 0) for key, val of INVERSES
+  @scan_tokens (prev, token, post, i) =>
+    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
+        @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 is INVERSES[mtag]
+          return 1
+        else
+          # Unexpected close, insert correct close, adding to the debt.
+          debt[mtag] += 1
+          val: if mtag is 'INDENT' then match[1] else INVERSES[mtag]
+          @tokens.splice(i, 0, [INVERSES[mtag], val])
+          return 1
+    else
+      return 1

data/vendor/coffee-script/src/scope.coffee

@@ -0,0 +1,75 @@
+this.exports: this unless process?
+
+# Scope objects form a tree corresponding to the shape of the function
+# definitions present in the script. They provide lexical scope, to determine
+# whether a variable has been seen before or if it needs to be declared.
+#
+# Initialize a scope with its parent, for lookups up the chain,
+# as well as the Expressions body where it should declare its variables,
+# and the function that it wraps.
+Scope: exports.Scope: (parent, expressions, method) ->
+  [@parent, @expressions, @method]: [parent, expressions, method]
+  @variables: {}
+  @temp_var: if @parent then @parent.temp_var else '_a'
+  this
+
+# Look up a variable in lexical scope, or declare it if not found.
+Scope::find: (name) ->
+  return true if @check name
+  @variables[name]: 'var'
+  false
+
+# Define a local variable as originating from a parameter in current scope
+# -- no var required.
+Scope::parameter: (name) ->
+  @variables[name]: 'param'
+
+# Just check to see if a variable has already been declared.
+Scope::check: (name) ->
+  return true if @variables[name]
+  !!(@parent and @parent.check(name))
+
+# You can reset a found variable on the immediate scope.
+Scope::reset: (name) ->
+  delete @variables[name]
+
+# Find an available, short, name for a compiler-generated variable.
+Scope::free_variable: ->
+  while @check @temp_var
+    ordinal: 1 + parseInt @temp_var.substr(1), 36
+    @temp_var: '_' + ordinal.toString(36).replace(/\d/g, 'a')
+  @variables[@temp_var]: 'var'
+  @temp_var
+
+# Ensure that an assignment is made at the top of scope (or top-level
+# scope, if requested).
+Scope::assign: (name, value, top_level) ->
+  return @parent.assign(name, value, top_level) if top_level and @parent
+  @variables[name]: {value: value, assigned: true}
+
+# Does this scope reference any variables that need to be declared in the
+# given function body?
+Scope::has_declarations: (body) ->
+  body is @expressions and @declared_variables().length
+
+# Does this scope reference any assignments that need to be declared at the
+# top of the given function body?
+Scope::has_assignments: (body) ->
+  body is @expressions and @assigned_variables().length
+
+# Return the list of variables first declared in current scope.
+Scope::declared_variables: ->
+  (key for key, val of @variables when val is 'var').sort()
+
+# Return the list of variables that are supposed to be assigned at the top
+# of scope.
+Scope::assigned_variables: ->
+  key + ' = ' + val.value for key, val of @variables when val.assigned
+
+# Compile the string representing all of the declared variables for this scope.
+Scope::compiled_declarations: ->
+  @declared_variables().join ', '
+
+# Compile the string performing all of the variable assignments for this scope.
+Scope::compiled_assignments: ->
+  @assigned_variables().join ', '

data/vendor/coffee-script/test/test_arguments.coffee

@@ -0,0 +1,34 @@
+area: (x, y, x1, y1) ->
+  (x - x1) * (x - y1)
+
+x:  y:  10
+x1: y1: 20
+
+ok area(x, y, x1, y1) is 100, 'basic arguments'
+
+ok(area(x, y,
+           x1, y1) is 100, 'arguments on split lines')
+
+ok(area(
+  x
+  y
+  x1
+  y1
+) is 100, 'newline delimited arguments')
+
+
+curried: ->
+  ok area.apply(this, arguments.concat(20, 20)) is 100, 'arguments converted into an array'
+
+curried 10, 10
+
+
+func: ->
+  arguments: 25
+  arguments
+
+ok func(100) is 25, 'arguments as a regular identifier'
+
+
+this.arguments: 10
+ok @arguments is 10, 'arguments accessed as a property'

data/vendor/coffee-script/test/test_array_comprehension.coffee

@@ -0,0 +1,42 @@
+nums:    n * n for n in [1, 2, 3] when n % 2 isnt 0
+results: n * 2 for n in nums
+
+ok results.join(',') is '2,18', 'basic array comprehension'
+
+
+obj:   {one: 1, two: 2, three: 3}
+names: prop + '!' for prop of obj
+odds:  prop + '!' for prop, value of obj when value % 2 isnt 0
+
+ok names.join(' ') is "one! two! three!", 'basic object comprehension'
+ok odds.join(' ')  is "one! three!", 'object comprehension with a filter'
+
+
+evens: for num in [1, 2, 3, 4, 5, 6] when num % 2 is 0
+           num *= -1
+           num -= 2
+           num * -1
+
+ok evens.join(', ') is '4, 6, 8', 'multiline array comprehension with filter'
+
+
+ok 2 in evens, 'the in operator still works, standalone'
+
+
+# Ensure that the closure wrapper preserves local variables.
+obj: {}
+
+methods: ['one', 'two', 'three']
+
+for method in methods
+  name: method
+  obj[name]: ->
+    "I'm " + name
+
+ok obj.one()   is "I'm one"
+ok obj.two()   is "I'm two"
+ok obj.three() is "I'm three"
+
+
+array: [0..10]
+ok(num % 2 is 0 for num in array by 2, 'naked ranges are expanded into arrays')

data/vendor/coffee-script/test/test_assignment.coffee

@@ -0,0 +1,26 @@
+result: try
+  nonexistent * missing
+catch error
+  true
+
+result2: try nonexistent * missing catch error then true
+
+ok result is true and result2 is true, 'can assign the result of a try/catch block'
+
+
+get_x: -> 10
+
+if x: get_x() then 100
+
+ok x is 10, 'can assign a conditional statement'
+
+x: if get_x() then 100
+
+ok x is 100, 'can assign a conditional statement'
+
+
+tester: ->
+  @example: -> puts 'example function'
+  this
+
+ok tester().example.name is 'example'

data/vendor/coffee-script/test/test_blocks.coffee

@@ -0,0 +1,4 @@
+results: [1, 2, 3].map (x) ->
+  x * x
+
+ok results.join(' ') is '1 4 9', 'basic block syntax'

data/vendor/coffee-script/test/test_calling_super.coffee

@@ -0,0 +1,42 @@
+Base: ->
+Base::func: (string) ->
+  'zero/' + string
+
+FirstChild: ->
+FirstChild extends Base
+FirstChild::func: (string) ->
+  super('one/') + string
+
+SecondChild: ->
+SecondChild extends FirstChild
+SecondChild::func: (string) ->
+  super('two/') + string
+
+ThirdChild: ->
+  @array: [1, 2, 3]
+  this
+ThirdChild extends SecondChild
+ThirdChild::func: (string) ->
+  super('three/') + string
+
+result: (new ThirdChild()).func 'four'
+
+ok result is 'zero/one/two/three/four', 'successfully set up and called a four-level inheritance chain'
+
+
+TopClass: (arg) ->
+  @prop: 'top-' + arg
+  this
+
+SuperClass: (arg) ->
+  super 'super-' + arg
+  this
+
+SubClass: ->
+  super 'sub'
+  this
+
+SuperClass extends TopClass
+SubClass extends SuperClass
+
+ok (new SubClass()).prop is 'top-super-sub', 'inheritance'

data/vendor/coffee-script/test/test_chained_calls.coffee

@@ -0,0 +1,25 @@
+identity_wrap: (x) ->
+  -> x
+
+result: identity_wrap(identity_wrap(true))()()
+
+ok result, 'basic chained function calls'
+
+
+str: 'god'
+
+result: str.
+  split('').
+  reverse().
+  reverse().
+  reverse()
+
+ok result.join('') is 'dog', 'chained accesses split on period/newline'
+
+result: str
+  .split('')
+  .reverse()
+  .reverse()
+  .reverse()
+
+ok result.join('') is 'dog', 'chained accesses split on newline/period'

data/vendor/coffee-script/test/test_destructuring_assignment.coffee

@@ -0,0 +1,62 @@
+a: -1
+b: -2
+
+[a, b]: [b, a]
+
+ok a is -2
+ok b is -1
+
+
+arr: [1, 2, 3]
+
+[a, b, c]: arr
+
+ok a is 1
+ok b is 2
+ok c is 3
+
+
+obj: {x: 10, y: 20, z: 30}
+
+{x: a, y: b, z: c}: obj
+
+ok a is 10
+ok b is 20
+ok c is 30
+
+
+person: {
+  name: "Bob"
+  family: {
+    brother: {
+      addresses: [
+        "first"
+        {
+          street: "101 Deercreek Ln."
+          city:   "Moquasset NY, 10021"
+        }
+      ]
+    }
+  }
+}
+
+{name: a, family: {brother: {addresses: [one, {city: b}]}}}: person
+
+ok a is "Bob"
+ok b is "Moquasset NY, 10021"
+
+
+test: {
+  person: {
+    address: [
+      "------"
+      "Street 101"
+      "Apt 101"
+      "City 101"
+    ]
+  }
+}
+
+{person: {address: [ignore, addr...]}}: test
+
+ok addr.join(', ') is "Street 101, Apt 101, City 101"