haml-more 0.4.0.a

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

@@ -0,0 +1,29 @@
+func: ->
+  a: 3
+  b: []
+
+  while a >= 0
+    b.push 'o'
+    a--
+
+  c: {
+    "text": b
+    other: null
+    something_else: (x) -> x + 5
+  }
+
+  c: 'error' unless 42 > 41
+
+  c.text: if false
+    'error'
+  else
+    c.text + '---'
+  d = {
+    text = c.text
+  }
+
+  c.list: l for l in d.text.split('') when l is '-'
+
+  c.single: c.list[1..1][0]
+
+ok func() is '-'

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

@@ -0,0 +1,2 @@
+block: -> (throw 'up')
+throws block, 'up'

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

@@ -0,0 +1,81 @@
+ok(if my_special_variable? then false else true)
+
+my_special_variable: false
+
+ok(if my_special_variable? then true else false)
+
+
+# Existential assignment.
+
+a: 5
+a: null
+a ?= 10
+b ?= 10
+
+ok a is 10 and b is 10
+
+
+# The existential operator.
+
+z: null
+x: z ? "EX"
+
+ok z is null and x is "EX"
+
+
+# Only evaluate once.
+
+counter: 0
+get_next_node: ->
+  throw "up" if counter
+  counter++
+
+ok(if get_next_node()? then true else false)
+
+
+# Existence chains, soaking up undefined properties:
+
+obj: {
+  prop: "hello"
+}
+
+ok obj?.prop is "hello"
+
+ok obj?['prop'] is "hello"
+
+ok obj.prop?.length is 5
+
+ok obj?['prop']?['length'] is 5
+
+ok obj?.prop?.non?.existent?.property is undefined
+
+ok obj?['non']?['existent'].property is undefined
+
+
+# Soaks and caches method calls as well.
+
+arr: ["--", "----"]
+
+ok arr.pop()?.length is 4
+ok arr.pop()?.length is 2
+ok arr.pop()?.length is undefined
+ok arr[0]?.length is undefined
+ok arr.pop()?.length?.non?.existent()?.property is undefined
+
+
+# Soaks method calls safely.
+value: undefined
+result: value?.toString().toLowerCase()
+
+ok result is undefined
+
+value: 10
+result: value?.toString().toLowerCase()
+
+ok result is '10'
+
+
+# Safely existence test on soaks.
+result: not value?.property?
+ok result
+

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

@@ -0,0 +1,30 @@
+# Ensure that we don't wrap Nodes that are "statement_only" in a closure.
+
+items: [1, 2, 3, "bacon", 4, 5]
+
+for item in items
+  break if item is "bacon"
+
+findit: (items) ->
+  for item in items
+    return item if item is "bacon"
+
+ok findit(items) is "bacon"
+
+
+# When when a closure wrapper is generated for expression conversion, make sure
+# that references to "this" within the wrapper are safely converted as well.
+
+obj: {
+  num: 5
+  func: ->
+    this.result: if false
+      10
+    else
+      "a"
+      "b"
+      this.num
+}
+
+ok obj.num is obj.func()
+ok obj.num is obj.result

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

@@ -0,0 +1,26 @@
+a: b: d: true
+c: false
+
+result: if a
+  if b
+    if c then false else
+      if d
+        true
+
+ok result
+
+
+first: if false then false else second: if false then false else true
+
+ok first
+ok second
+
+
+result: if false
+  false
+else if NaN
+  false
+else
+  true
+
+ok result

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

@@ -0,0 +1,80 @@
+x: 1
+y: {}
+y.x: -> 3
+
+ok x is 1
+ok typeof(y.x) is 'function'
+ok y.x instanceof Function
+ok y.x() is 3
+ok y.x.name is 'x'
+
+
+# The empty function should not cause a syntax error.
+->
+() ->
+
+
+obj: {
+  name: "Fred"
+
+  bound: ->
+    (=> ok(this.name is "Fred"))()
+
+  unbound: ->
+    (-> ok(!this.name?))()
+}
+
+obj.unbound()
+obj.bound()
+
+
+# The named function should be cleared out before a call occurs:
+
+# Python decorator style wrapper that memoizes any function
+memoize: (fn) ->
+  cache: {}
+  self: this
+  (args...) ->
+    key: args.toString()
+    return cache[key] if cache[key]
+    cache[key] = fn.apply(self, args)
+
+Math: {
+  Add: (a, b) -> a + b
+  AnonymousAdd: ((a, b) -> a + b)
+  FastAdd: memoize (a, b) -> a + b
+}
+
+ok Math.Add(5, 5) is 10
+ok Math.AnonymousAdd(10, 10) is 20
+ok Math.FastAdd(20, 20) is 40
+
+
+# Parens are optional on simple function calls.
+ok 100 > 1 if 1 > 0
+ok true unless false
+ok true for i in [1..3]
+
+ok_func: (f) -> ok(f())
+ok_func -> true
+
+# Optional parens can be used in a nested fashion.
+call: (func) -> func()
+
+result: call ->
+  inner: call ->
+    Math.Add(5, 5)
+
+ok result is 10
+
+
+# And even with strange things like this:
+
+funcs:  [(x) -> x, (x) -> x * x]
+result: funcs[1] 5
+
+ok result is 25
+
+result: ("hello".slice) 3
+
+ok result is 'lo'

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

@@ -0,0 +1,25 @@
+  # comment
+func: ->
+# comment
+  false
+  false   # comment
+  false
+# comment
+  true
+
+switch 'string'
+  # comment
+  when false then something()
+  # comment
+  when null
+    something_else()
+
+->
+  code()
+  # comment
+
+ok func()
+
+func
+func
+# Line3

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

@@ -0,0 +1,46 @@
+a: """
+   basic heredoc
+   on two lines
+   """
+
+ok a is "basic heredoc\non two lines"
+
+
+a: '''
+   a
+     "b
+   c
+   '''
+
+ok a is "a\n  \"b\nc"
+
+
+a: '''one-liner'''
+
+ok a is 'one-liner'
+
+
+a: """
+      out
+      here
+"""
+
+ok a is "out\nhere"
+
+
+a: '''
+      a
+    b
+  c
+   '''
+
+ok a is "    a\n  b\nc"
+
+a: '''
+a
+
+
+b c
+'''
+
+ok a is "a\n\n\nb c"

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

@@ -0,0 +1,10 @@
+num: 1 + 2 + (a: 3)
+
+ok num is 6
+
+
+result: if true
+  false
+  other: "result"
+
+ok result is "result" and other is "result"

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

@@ -0,0 +1,56 @@
+a: [(x) -> x, (x) -> x * x]
+
+ok a.length is 2
+
+
+regex: /match/i
+words: "I think there is a match in here."
+
+ok !!words.match(regex)
+
+
+neg: (3 -4)
+
+ok neg is -1
+
+
+func: ->
+  return if true
+
+ok func() is null
+
+
+str: "\\"
+reg: /\\/
+
+ok reg(str) and str is '\\'
+
+
+money$: 'dollars'
+
+ok money$ is 'dollars'
+
+
+ok {a: (num) -> num is 10 }.a 10
+
+
+bob: {
+  name:  'Bob'
+  greet: (salutation) ->
+    salutation + " " + @name
+  hello: ->
+    @['greet'] "Hello"
+  10: 'number'
+}
+
+ok bob.hello() is "Hello Bob"
+ok bob[10] is 'number'
+
+
+obj: {
+  'is':  -> yes
+  'not': -> no
+}
+
+ok obj.is()
+ok not obj.not()

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

@@ -0,0 +1,11 @@
+multi_liner:
+  for x in [3..5]
+    for y in [3..5]
+      [x, y]
+
+single_liner:
+  [x, y] for y in [3..5] for x in [3..5]
+
+ok multi_liner.length is single_liner.length
+ok 5 is multi_liner[2][2][1]
+ok 5 is single_liner[2][2][1]

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

@@ -0,0 +1,6 @@
+six:
+  1 +
+  2 +
+  3
+
+ok six is 6

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

@@ -0,0 +1,18 @@
+# CoffeeScript's operations should be chainable, like Python's.
+
+ok 500 > 50 > 5 > -5
+
+ok true is not false is true is not false
+
+ok 10 < 20 > 10
+
+ok 50 > 10 > 5 is parseInt('5', 10)
+
+
+# Make sure that each argument is only evaluated once, even if used
+# more than once.
+
+i: 0
+func: -> i++
+
+ok 1 > func() < 1

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

@@ -0,0 +1,20 @@
+nums: i * 3 for i in [1..3]
+
+negs: x for x in [-20..-5*2]
+negs: negs[0..2]
+
+result: nums.concat(negs).join(', ')
+
+ok result is '3, 6, 9, -20, -19, -18'
+
+# Ensure that ranges are safe. This used to infinite loop:
+j = 5
+result: for j in [j..(j+3)]
+  j
+
+ok result.join(' ') is '5 6 7 8'
+
+# With range comprehensions, you can loop in steps.
+results: x for x in [0..25] by 5
+
+ok results.join(' ') is '0 5 10 15 20 25'

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

@@ -0,0 +1,16 @@
+array: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+a: array[7..9]
+b: array[2...4]
+
+result: a.concat(b).join(' ')
+
+ok result is "7 8 9 2 3"
+
+
+countdown: [10..1].join(' ')
+ok countdown is "10 9 8 7 6 5 4 3 2 1"
+
+
+array: [(1+5)..1+9]
+ok array.join(' ') is "6 7 8 9 10"

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

@@ -0,0 +1,47 @@
+func: (first, second, rest...) ->
+  rest.join ' '
+
+result: func 1, 2, 3, 4, 5
+
+ok result is "3 4 5"
+
+
+gold: silver: bronze: the_field: null
+
+medalists: (first, second, third, rest...) ->
+  gold:       first
+  silver:     second
+  bronze:     third
+  the_field:  rest
+
+contenders: [
+  "Michael Phelps"
+  "Liu Xiang"
+  "Yao Ming"
+  "Allyson Felix"
+  "Shawn Johnson"
+  "Roman Sebrle"
+  "Guo Jingjing"
+  "Tyson Gay"
+  "Asafa Powell"
+  "Usain Bolt"
+]
+
+medalists "Mighty Mouse", contenders...
+
+ok gold is "Mighty Mouse"
+ok silver is "Michael Phelps"
+ok bronze is "Liu Xiang"
+ok the_field.length is 8
+
+
+obj: {
+  name: 'bob'
+  accessor: (args...) ->
+    [@name].concat(args).join(' ')
+  getNames: ->
+    args: ['jane', 'ted']
+    @accessor(args...)
+}
+
+ok obj.getNames() is 'bob jane ted'

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

@@ -0,0 +1,5 @@
+array: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+array[5..10]: [0, 0, 0]
+
+ok array.join(' ') is '0 1 2 3 4 0 0 0'

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

@@ -0,0 +1,64 @@
+num: 10
+
+result: switch num
+  when 5 then false
+  when 'a'
+    true
+    true
+    false
+  when 10 then true
+
+
+  # Mid-switch comment with whitespace
+  # and multi line
+  when 11 then false
+  else false
+
+ok result
+
+
+func: (num) ->
+  switch num
+    when 2, 4, 6
+      true
+    when 1, 3, 5
+      false
+    else false
+
+ok func(2)
+ok func(6)
+ok !func(3)
+ok !func(8)
+
+
+# Should cache the switch value, if anything fancier than a literal.
+num: 5
+result: switch num += 5
+  when 5 then false
+  when 15 then false
+  when 10 then true
+  else false
+
+ok result
+
+
+# Ensure that trailing switch elses don't get rewritten.
+result: false
+switch "word"
+  when "one thing"
+    do_something()
+  else
+    result: true unless false
+
+ok result
+
+result: false
+switch "word"
+  when "one thing"
+    do_something()
+  when "other thing"
+    do_something()
+  else
+    result: true unless false
+
+ok result

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

@@ -0,0 +1,30 @@
+i: 5
+list: while i -= 1
+  i * 2
+
+ok list.join(' ') is "8 6 4 2"
+
+
+i: 5
+list: (i * 3 while i -= 1)
+
+ok list.join(' ') is "12 9 6 3"
+
+
+i: 5
+func:   (num) -> i -= num
+assert: -> ok i < 5 > 0
+
+results: while func 1
+  assert()
+  i
+
+ok results.join(' ') is '4 3 2 1'
+
+
+i: 10
+results: while i -= 1 when i % 2 is 0
+  i * 2
+
+ok results.join(' ') is '16 12 8 4'
+

data/vendor/coffee-script/vendor/jison/Jakefile

@@ -0,0 +1,31 @@
+#!/usr/bin/env narwhal
+ 
+var FILE = require("file"),
+    OS = require("os"),
+    jake = require("jake");
+
+jake.task("build", ["build:bnf", "build:lex"]);
+
+jake.task("build:bnf", function () {
+    OS.system(['./bin/jison', 'src/bnf.jison', 'src/bnf.jisonlex']);
+    OS.system(['mv', 'bnf.js', 'lib/jison/util/bnf-parser.js']);
+});
+
+jake.task("build:lex", function () {
+    OS.system(['./bin/jison', 'src/jisonlex.jison', 'src/jisonlex.jisonlex']);
+    OS.system(['mv', 'jisonlex.js', 'lib/jison/util/lex-parser.js']);
+});
+
+
+jake.task("test", function () {
+    OS.system(['narwhal', 'tests/all-tests.js']);
+});
+jake.task("test:parser", function () {
+    OS.system(['narwhal', 'tests/parser/parser-tests.js']);
+});
+jake.task("test:lexer", function () {
+    OS.system(['narwhal', 'tests/lexer/lexer-tests.js']);
+});
+jake.task("test:grammar", function () {
+    OS.system(['narwhal', 'tests/grammar/grammar-tests.js']);
+});