spade-packager 0.1.0

data/packages/coffee-script/test/test_compilation.coffee

@@ -0,0 +1,26 @@
+# Ensure that carriage returns don't break compilation on Windows.
+eq CoffeeScript.compile('one\r\ntwo', bare: on), 'one;\ntwo;'
+
+# `globals: on` removes `var`s
+eq CoffeeScript.compile('x = y', bare: on, globals: on), 'x = y;'
+
+ok 'passed' is CoffeeScript.eval '"passed"', bare: on, fileName: 'test'
+
+#750
+try ok not CoffeeScript.nodes 'f(->'
+catch e then eq e.message, 'unclosed CALL_START on line 1'
+
+eq CoffeeScript.compile('for k of o then', bare: on, globals: on),
+   'for (k in o) {}'
+
+# Compilations that should fail.
+cantCompile = (code) ->
+  throws -> CoffeeScript.compile code
+
+cantCompile 'a = (break)'
+
+cantCompile 'a = (return 5 for item in list)'
+
+cantCompile 'a = (return 5 while condition)'
+
+cantCompile 'a = for x in y\n  return 5'

data/packages/coffee-script/test/test_comprehensions.coffee

@@ -0,0 +1,318 @@
+# Basic array comprehensions.
+nums    = (n * n for n in [1, 2, 3] when n & 1)
+results = (n * 2 for n in nums)
+
+ok results.join(',') is '2,18'
+
+
+# Basic object comprehensions.
+obj   = {one: 1, two: 2, three: 3}
+names = (prop + '!' for prop of obj)
+odds  = (prop + '!' for prop, value of obj when value & 1)
+
+ok names.join(' ') is "one! two! three!"
+ok odds.join(' ')  is "one! three!"
+
+
+# Basic range comprehensions.
+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'
+
+
+# With range comprehensions, you can loop in steps.
+results = (x for x in [0...15] by 5)
+ok results.join(' ') is '0 5 10'
+
+results = (x for x in [0..100] by 10)
+ok results.join(' ') is '0 10 20 30 40 50 60 70 80 90 100'
+
+
+# And can loop downwards, with a negative step.
+results = (x for x in [5..1])
+
+ok results.join(' ') is '5 4 3 2 1'
+ok results.join(' ') is [(10-5)..(-2+3)].join(' ')
+
+results = (x for x in [10..1])
+ok results.join(' ') is [10..1].join(' ')
+
+results = (x for x in [10...0] by -2)
+ok results.join(' ') is [10, 8, 6, 4, 2].join(' ')
+
+
+# Range comprehension gymnastics.
+eq "#{i for i in [5..1]}", '5,4,3,2,1'
+eq "#{i for i in [5..-5] by -5}", '5,0,-5'
+
+a = 6
+b = 0
+c = -2
+
+eq "#{i for i in [a..b]}", '6,5,4,3,2,1,0'
+eq "#{i for i in [a..b] by c}", '6,4,2,0'
+
+
+# Multiline array comprehension with filter.
+evens = for num in [1, 2, 3, 4, 5, 6] when not (num & 1)
+           num *= -1
+           num -= 2
+           num * -1
+eq evens + '', '4,6,8'
+
+
+# The in operator still works, standalone.
+ok 2 of evens
+
+# all isn't reserved.
+all = 1
+
+
+# Ensure that the closure wrapper preserves local variables.
+obj = {}
+
+for method in ['one', 'two', 'three'] then do (method) ->
+  obj[method] = ->
+    "I'm " + method
+
+ok obj.one()   is "I'm one"
+ok obj.two()   is "I'm two"
+ok obj.three() is "I'm three"
+
+
+# Index values at the end of a loop.
+i = 0
+for i in [1..3]
+  -> 'func'
+  break if false
+ok i is 4
+
+
+# Ensure that local variables are closed over for range comprehensions.
+funcs = for i in [1..3]
+  do (i) ->
+    -> -i
+
+eq (func() for func in funcs).join(' '), '-1 -2 -3'
+ok i is 4
+
+
+# Even when referenced in the filter.
+list = ['one', 'two', 'three']
+
+methods = for num, i in list when num isnt 'two' and i isnt 1
+  do (num, i) ->
+    -> num + ' ' + i
+
+ok methods.length is 2
+ok methods[0]() is 'one 0'
+ok methods[1]() is 'three 2'
+
+
+# Even a convoluted one.
+funcs = []
+
+for i in [1..3]
+  do (i) ->
+    x = i * 2
+    ((z)->
+      funcs.push -> z + ' ' + i
+    )(x)
+
+ok (func() for func in funcs).join(', ') is '2 1, 4 2, 6 3'
+
+funcs = []
+
+results = for i in [1..3]
+  do (i) ->
+    z = (x * 3 for x in [1..i])
+    ((a, b, c) -> [a, b, c].join(' ')).apply this, z
+
+ok results.join(', ') is '3  , 3 6 , 3 6 9'
+
+
+# Naked ranges are expanded into arrays.
+array = [0..10]
+ok(num % 2 is 0 for num in array by 2)
+
+
+# Nested shared scopes.
+foo = ->
+  for i in [0..7]
+    do (i) ->
+      for j in [0..7]
+        do (j) ->
+          -> i + j
+
+eq foo()[3][4](), 7
+
+
+# Scoped loop pattern matching.
+a = [[0], [1]]
+funcs = []
+
+for [v] in a
+  do (v) ->
+    funcs.push -> v
+
+eq funcs[0](), 0
+eq funcs[1](), 1
+
+
+# Nested comprehensions.
+multiLiner =
+  for x in [3..5]
+    for y in [3..5]
+      [x, y]
+
+singleLiner =
+  (([x, y] for y in [3..5]) for x in [3..5])
+
+ok multiLiner.length is singleLiner.length
+ok 5 is multiLiner[2][2][1]
+ok 5 is singleLiner[2][2][1]
+
+
+# Comprehensions within parentheses.
+result = null
+store = (obj) -> result = obj
+store (x * 2 for x in [3, 2, 1])
+
+ok result.join(' ') is '6 4 2'
+
+
+# Closure-wrapped comprehensions that refer to the "arguments" object.
+expr = ->
+  result = (item * item for item in arguments)
+
+ok expr(2, 4, 8).join(' ') is '4 16 64'
+
+
+# Fast object comprehensions over all properties, including prototypal ones.
+class Cat
+  constructor: -> @name = 'Whiskers'
+  breed: 'tabby'
+  hair:  'cream'
+
+whiskers = new Cat
+own = (value for own key, value of whiskers)
+all = (value for key, value of whiskers)
+
+ok own.join(' ') is 'Whiskers'
+ok all.sort().join(' ') is 'Whiskers cream tabby'
+
+
+# Optimized range comprehensions.
+exxes = ('x' for [0...10])
+ok exxes.join(' ') is 'x x x x x x x x x x'
+
+
+# Comprehensions safely redeclare parameters if they're not present in closest
+# scope.
+rule = (x) -> x
+
+learn = ->
+  rule for rule in [1, 2, 3]
+
+ok learn().join(' ') is '1 2 3'
+
+ok rule(101) is 101
+
+f = -> [-> ok no, 'should cache source']
+ok yes for k of [f] = f()
+
+
+# Lenient on pure statements not trying to reach out of the closure
+val = for i in [1]
+  for j in [] then break
+  i
+ok val[0] is i
+
+
+# Comprehensions only wrap their last line in a closure, allowing other lines
+# to have pure expressions in them.
+func = -> for i in [1]
+  break if i is 2
+  j for j in [1]
+
+ok func()[0][0] is 1
+
+i = 6
+odds = while i--
+  continue unless i & 1
+  i
+
+ok odds.join(', ') is '5, 3, 1'
+
+
+# Issue #897: Ensure that plucked function variables aren't leaked.
+facets = {}
+list = ['one', 'two']
+
+(->
+  for entity in list
+    facets[entity] = -> entity
+)()
+
+eq typeof entity, 'undefined'
+eq facets['two'](), 'two'
+
+
+# Issue #905. Soaks as the for loop subject.
+a = {b: {c: [1, 2, 3]}}
+for d in a.b?.c
+  e = d
+
+eq e, 3
+
+
+# Issue #948. Capturing loop variables.
+funcs = []
+list  = ->
+  [1, 2, 3]
+
+for y in list()
+  do (y) ->
+    z = y
+    funcs.push -> "y is #{y} and z is #{z}"
+
+eq funcs[1](), "y is 2 and z is 2"
+
+
+# Cancel the comprehension if there's a jump inside the loop.
+result = try
+  for i in [0...10]
+    continue if i < 5
+  i
+
+eq result, 10
+
+
+# Comprehensions over break.
+arrayEq (break for [1..10]), []
+
+# Comprehensions over continue.
+arrayEq (break for [1..10]), []
+
+
+# Comprehensions over function literals.
+a = 0
+for f in [-> a = 1]
+  do (f) ->
+    do f
+
+eq a, 1
+
+
+# Comprehensions that mention arguments.
+list = [arguments: 10]
+args = for f in list
+  do (f) ->
+    f.arguments
+
+eq args[0], 10

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

@@ -0,0 +1,165 @@
+ok(if mySpecialVariable? then false else true)
+
+mySpecialVariable = false
+
+ok(if mySpecialVariable? 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"
+
+i = 9
+func = -> i += 1
+result = func() ? 101
+ok result is 10
+
+# Only evaluate once.
+counter = 0
+getNextNode = ->
+  throw "up" if counter
+  counter++
+
+ok(if getNextNode()? then true else false)
+
+
+# Existence chains, soaking up undefined properties:
+obj =
+  prop: "hello"
+
+eq obj?.prop, "hello"
+eq obj?['prop'], "hello"
+eq obj.prop?.length, 5
+eq obj?.prop?['length'], 5
+eq obj?.prop?.non?.existent?.property, undefined
+
+
+# Soaks and caches method calls as well.
+arr = ["--", "----"]
+
+eq arr.pop()?.length, 4
+eq arr.pop()?.length, 2
+eq arr.pop()?.length, undefined
+eq arr.pop()?.length?.non?.existent()?.property, undefined
+
+
+# Soaks method calls safely.
+value = null
+eq value?.toString().toLowerCase(), undefined
+
+value = 10
+eq value?.toString().toLowerCase(), '10'
+
+eq 0.nothing?.property() or 101, 101
+
+counter = 0
+func = ->
+  counter += 1
+  'prop'
+obj =
+  prop: -> this
+  value: 25
+
+ok obj[func()]()[func()]()[func()]()?.value is 25
+ok counter is 3
+
+
+ident = (obj) -> obj
+eq ident(non?.existent().method()), undefined, 'soaks inner values'
+
+
+# Soaks constructor invocations.
+a = 0
+class Foo
+  constructor: -> a += 1
+  bar: "bat"
+
+ok (new Foo())?.bar is 'bat'
+ok a is 1
+
+
+ok not value?.property?, 'safely checks existence on soaks'
+
+
+eq nothing?.value, undefined, 'safely calls values off of non-existent variables'
+eq !nothing?.value and 1, 1,  'corresponding operators work as expected'
+
+
+# Assign to the result of an exsitential operation with a minus.
+x = null ? - 1
+ok x is - 1
+
+
+# Things that compile to ternaries should force parentheses, like operators do.
+duration = if options?.animated then 150 else 0
+ok duration is 0
+
+
+# Function soaks.
+plus1 = (x) -> x + 1
+count = 0
+obj = {
+  counter: -> count += 1; this
+  returnThis: -> this
+}
+
+eq plus1?(41), 42
+eq (plus1? 41), 42
+eq plus2?(41), undefined
+eq (plus2? 41), undefined
+eq obj.returnThis?(), obj
+eq obj.returnSelf?(), undefined
+eq obj.returnThis?().flag = on, on
+eq obj.returnSelf?().flag = on, undefined
+eq obj.counter().counter().returnThis?(), obj
+eq count, 2
+
+maybe_close = (f, arg) -> if typeof f is 'function' then () -> f(arg) else -1
+
+eq maybe_close(plus1, 41)?(), 42
+eq (maybe_close plus1, 41)?(), 42
+eq (maybe_close 'string', 41)?(), undefined
+
+eq 2?(3), undefined
+eq new Number?(42) | 0, 42
+eq new Bumper?(42) | 0, 0
+
+
+#726
+eq calendar?[Date()], undefined
+
+
+#733
+a = b: {c: null}
+eq a.b?.c?(), undefined
+
+a.b?.c or= (it) -> it
+eq a.b?.c?(1), 1
+eq a.b?.c?([2, 3]...), 2
+
+
+#756
+a = null
+ok isNaN      a?.b.c +  1
+eq undefined, a?.b.c += 1
+eq undefined, ++a?.b.c
+eq undefined, delete a?.b.c
+
+a = b: {c: 0}
+eq 1,   a?.b.c +  1
+eq 1,   a?.b.c += 1
+eq 2,   ++a?.b.c
+eq yes, delete a?.b.c
+
+
+eq (1 or 0)?, true, 'postfix `?` should unwrap correctly'