spade-packager 0.1.0

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

@@ -0,0 +1,181 @@
+# Conditionals
+# ------------
+
+# shared identity function
+id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
+
+#### Basic Conditionals
+
+test "basic conditionals", ->
+  if false
+    ok false
+  else if false
+    ok false
+  else
+    ok true
+
+  if true
+    ok true
+  else if true
+    ok false
+  else
+    ok true
+
+  unless true
+    ok false
+  else unless true
+    ok false
+  else
+    ok true
+
+  unless false
+    ok true
+  else unless false
+    ok false
+  else
+    ok true
+
+test "single-line conditional", ->
+  if false then ok false else ok true
+  unless false then ok true else ok false
+
+test "nested conditionals", ->
+  nonce = {}
+  eq nonce, (if true
+    unless false
+      if false then false else
+        if true
+          nonce)
+
+test "nested single-line conditionals", ->
+  nonce = {}
+
+  a = if false then undefined else b = if 0 then undefined else nonce
+  eq nonce, a
+  eq nonce, b
+
+  c = if false then undefined else (if 0 then undefined else nonce)
+  eq nonce, c
+
+  d = if true then id(if false then undefined else nonce)
+  eq nonce, d
+
+test "empty conditional bodies", ->
+  eq undefined, (if false
+  else if false
+  else)
+
+test "conditional bodies containing only comments", ->
+  eq undefined, (if true
+    ###
+    block comment
+    ###
+  else
+    # comment
+  )
+
+  eq undefined, (if false
+    # comment
+  else if true
+    ###
+    block comment
+    ###
+  else)
+
+test "return value of if-else is from the proper body", ->
+  nonce = {}
+  eq nonce, if false then undefined else nonce
+
+test "return value of unless-else is from the proper body", ->
+  nonce = {}
+  eq nonce, unless true then undefined else nonce
+
+
+#### Interactions With Functions
+
+test "single-line function definition with single-line conditional", ->
+  fn = -> if 1 < 0.5 then 1 else -1
+  ok fn() is -1
+
+test "function resturns conditional value with no `else`", ->
+  fn = ->
+    return if false then true
+  eq undefined, fn()
+
+test "function returns a conditional value", ->
+  a = {}
+  fnA = ->
+    return if false then undefined else a
+  eq a, fnA()
+
+  b = {}
+  fnB = ->
+    return unless false then b else undefined
+  eq b, fnB()
+
+test "passing a conditional value to a function", ->
+  nonce = {}
+  eq nonce, id if false then undefined else nonce
+
+test "unmatched `then` should catch implicit calls", ->
+  a = 0
+  trueFn = -> true
+  if trueFn undefined then a += 1
+  eq 1, a
+
+
+#### if-to-ternary
+
+test "if-to-ternary with instanceof requires parentheses", ->
+  nonce = {}
+  eq nonce, (if {} instanceof Object
+    nonce
+  else
+    undefined)
+
+test "if-to-ternary as part of a larger operation requires parentheses", ->
+  ok 2, 1 + if false then 0 else 1
+
+
+#### Odd Formatting
+
+test "if-else indented within an assignment", ->
+  nonce = {}
+  result =
+    if false
+      undefined
+    else
+      nonce
+  eq nonce, result
+
+test "suppressed indentation via assignment", ->
+  nonce = {}
+  result =
+    if      false then undefined
+    else if no    then undefined
+    else if 0     then undefined
+    else if 1 < 0 then undefined
+    else               id(
+         if false then undefined
+         else          nonce
+    )
+  eq nonce, result
+
+test "tight formatting with leading `then`", ->
+  nonce = {}
+  eq nonce,
+  if true
+  then nonce
+  else undefined
+
+test "#738", ->
+  nonce = {}
+  fn = if true then -> nonce
+  eq nonce, fn()
+
+test "#748: trailing reserved identifiers", ->
+  nonce = {}
+  obj = delete: true
+  result = if obj.delete
+    nonce
+  eq nonce, result

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

@@ -0,0 +1,90 @@
+# Exceptions
+# ----------
+
+# shared nonce
+nonce = {}
+
+
+#### Throw
+
+test "basic exception throwing", ->
+  throws (-> throw 'error'), 'error'
+
+
+#### Empty Try/Catch/Finally
+
+test "try can exist alone", ->
+  try
+
+test "try/catch with empty try, empty catch", ->
+  try
+    # nothing
+  catch err
+    # nothing
+
+test "single-line try/catch with empty try, empty catch", ->
+  try catch err
+
+test "try/finally with empty try, empty finally", ->
+  try
+    # nothing
+  finally
+    # nothing
+
+test "single-line try/finally with empty try, empty finally", ->
+  try finally
+
+test "try/catch/finally with empty try, empty catch, empty finally", ->
+  try
+  catch err
+  finally
+
+test "single-line try/catch/finally with empty try, empty catch, empty finally", ->
+  try catch err then finally
+
+
+#### Try/Catch/Finally as an Expression
+
+test "return the result of try when no exception is thrown", ->
+  result = try
+    nonce
+  catch err
+    undefined
+  finally
+    undefined
+  eq nonce, result
+
+test "single-line result of try when no exception is thrown", ->
+  result = try nonce catch err then undefined
+  eq nonce, result
+
+test "return the result of catch when an exception is thrown", ->
+  fn = ->
+    try
+      throw ->
+    catch err
+      nonce
+  doesNotThrow fn
+  eq nonce, fn()
+
+test "single-line result of catch when an exception is thrown", ->
+  fn = ->
+    try throw (->) catch err then nonce
+  doesNotThrow fn
+  eq nonce, fn()
+
+test "optional catch", ->
+  fn = ->
+    try throw ->
+    nonce
+  doesNotThrow fn
+  eq nonce, fn()
+
+
+#### Try/Catch/Finally Interaction With Other Constructs
+
+test "try/catch with empty catch as last statement in a function body", ->
+  fn = ->
+    try nonce
+    catch err
+  eq nonce, fn()

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

@@ -0,0 +1,96 @@
+# Helpers
+# -------
+
+# pull the helpers from `CoffeeScript.helpers` into local variables
+{starts, ends, compact, count, merge, extend, flatten, del, last} = CoffeeScript.helpers
+
+
+#### `starts`
+
+test "the `starts` helper tests if a string starts with another string", ->
+  ok     starts('01234', '012')
+  ok not starts('01234', '123')
+
+test "the `starts` helper can take an optional offset", ->
+  ok     starts('01234', '34', 3)
+  ok not starts('01234', '01', 1)
+
+
+#### `ends`
+
+test "the `ends` helper tests if a string ends with another string", ->
+  ok     ends('01234', '234')
+  ok not ends('01234', '012')
+
+test "the `ends` helper can take an optional offset", ->
+  ok     ends('01234', '012', 2)
+  ok not ends('01234', '234', 6)
+
+
+#### `compact`
+
+test "the `compact` helper removes falsey values from an array, preserves truthy ones", ->
+  allValues = [1, 0, false, obj={}, [], '', ' ', -1, null, undefined, true]
+  truthyValues = [1, obj, [], ' ', -1, true]
+  arrayEq truthyValues, compact(allValues)
+
+
+#### `count`
+
+test "the `count` helper counts the number of occurances of a string in another string", ->
+  eq 1/0, count('abc', '')
+  eq 0, count('abc', 'z')
+  eq 1, count('abc', 'a')
+  eq 1, count('abc', 'b')
+  eq 2, count('abcdc', 'c')
+  eq 2, count('abcdabcd','abc')
+
+
+#### `merge`
+
+test "the `merge` helper makes a new object with all properties of the objects given as its arguments", ->
+  ary = [0, 1, 2, 3, 4]
+  obj = {}
+  merged = merge obj, ary
+  ok merged isnt obj
+  ok merged isnt ary
+  for own key, val of ary
+    eq val, merged[key]
+
+
+#### `extend`
+
+test "the `extend` helper performs a shallow copy", ->
+  ary = [0, 1, 2, 3]
+  obj = {}
+  # should return the object being extended
+  eq obj, extend(obj, ary)
+  # should copy the other object's properties as well (obviously)
+  eq 2, obj[2]
+
+
+#### `flatten`
+
+test "the `flatten` helper flattens an array", ->
+  success = yes
+  (success and= typeof n is 'number') for n in flatten [0, [[[1]], 2], 3, [4]]
+  ok success
+
+
+#### `del`
+
+test "the `del` helper deletes a property from an object and returns the deleted value", ->
+  obj = [0, 1, 2]
+  eq 1, del(obj, 1)
+  ok 1 not of obj
+
+
+#### `last`
+
+test "the `last` helper returns the last item of an array-like object", ->
+  ary = [0, 1, 2, 3, 4]
+  eq 4, last(ary)
+
+test "the `last` helper allows one to specify an optional offset", ->
+  ary = [0, 1, 2, 3, 4]
+  eq 2, last(ary, 2)

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

@@ -0,0 +1,18 @@
+# Importing
+# ---------
+
+unless window? or testingBrowser?
+  test "coffeescript modules can be imported and executed", ->
+
+    magicKey = __filename
+    magicValue = 0xFFFF
+
+    if global[magicKey]?
+      if exports?
+        local = magicValue
+        exports.method = -> local
+    else
+      global[magicKey] = {}
+      if require?.extensions? or require?.registerExtension?
+        ok require(__filename).method() is magicValue
+      delete global[magicKey]

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

@@ -0,0 +1,225 @@
+# Operators
+# ---------
+
+test "binary (2-ary) math operators do not require spaces", ->
+  a = 1
+  b = -1
+  eq +1, a*-b
+  eq -1, a*+b
+  eq +1, a/-b
+  eq -1, a/+b
+
+test "operators should respect new lines as spaced", ->
+  a = 123 +
+  456
+  eq 579, a
+
+  b = "1#{2}3" +
+  "456"
+  eq '123456', b
+
+test "multiple operators should space themselves", ->
+  eq (+ +1), (- -1)
+
+test "bitwise operators", ->
+  eq  2, (10 &   3)
+  eq 11, (10 |   3)
+  eq  9, (10 ^   3)
+  eq 80, (10 <<  3)
+  eq  1, (10 >>  3)
+  eq  1, (10 >>> 3)
+  num = 10; eq  2, (num &=   3)
+  num = 10; eq 11, (num |=   3)
+  num = 10; eq  9, (num ^=   3)
+  num = 10; eq 80, (num <<=  3)
+  num = 10; eq  1, (num >>=  3)
+  num = 10; eq  1, (num >>>= 3)
+
+test "`instanceof`", ->
+  ok new String instanceof String
+  ok new Boolean instanceof Boolean
+  # `instanceof` supports negation by prefixing the operator with `not`
+  ok new Number not instanceof String
+  ok new Array not instanceof Boolean
+
+
+#### Compound Assignment Operators
+
+test "boolean operators", ->
+  nonce = {}
+
+  a  = 0
+  a or= nonce
+  eq nonce, a
+
+  b  = 1
+  b or= nonce
+  eq 1, b
+
+  c = 0
+  c and= nonce
+  eq 0, c
+
+  d = 1
+  d and= nonce
+  eq nonce, d
+
+  # ensure that RHS is treated as a group
+  e = f = false
+  e and= f or true
+  eq false, e
+
+test "compound assignment as a sub expression", ->
+  [a, b, c] = [1, 2, 3]
+  eq 6, (a + b += c)
+  eq 1, a
+  eq 5, b
+  eq 3, c
+
+# *note: this test could still use refactoring*
+test "compound assignment should be careful about caching variables", ->
+  count = 0
+  list = []
+
+  list[++count] or= 1
+  eq 1, list[1]
+  eq 1, count
+
+  list[++count] ?= 2
+  eq 2, list[2]
+  eq 2, count
+
+  list[count++] and= 6
+  eq 6, list[2]
+  eq 3, count
+
+  base = ->
+    ++count
+    base
+
+  base().four or= 4
+  eq 4, base.four
+  eq 4, count
+
+  base().five ?= 5
+  eq 5, base.five
+  eq 5, count
+
+test "compound assignment with implicit objects", ->
+  obj = undefined
+  obj ?=
+    one: 1
+
+  eq 1, obj.one
+
+  obj and=
+    two: 2
+
+  eq undefined, obj.one
+  eq         2, obj.two
+
+
+#### `is`,`isnt`,`==`,`!=`
+
+test "`==` and `is` should be interchangeable", ->
+  a = b = 1
+  ok a is 1 and b == 1
+  ok a == b
+  ok a is b
+
+test "`!=` and `isnt` should be interchangeable", ->
+  a = 0
+  b = 1
+  ok a isnt 1 and b != 0
+  ok a != b
+  ok a isnt b
+
+
+#### `in`, `of`
+
+# - `in` should check if an array contains a value using `indexOf`
+# - `of` should check if a property is defined on an object using `in`
+test "in, of", ->
+  arr = [1]
+  ok 0 of arr
+  ok 1 in arr
+  # prefixing `not` to `in and `of` should negate them
+  ok 1 not of arr
+  ok 0 not in arr
+
+test "`in` should be able to operate on an array literal", ->
+  ok 2 in [0, 1, 2, 3]
+  ok 4 not in [0, 1, 2, 3]
+  arr = [0, 1, 2, 3]
+  ok 2 in arr
+  ok 4 not in arr
+  # should cache the value used to test the array
+  arr = [0]
+  val = 0
+  ok val++ in arr
+  ok val++ not in arr
+  val = 0
+  ok val++ of arr
+  ok val++ not of arr
+
+test "`of` and `in` should be able to operate on instance variables", ->
+  obj = {
+    list: [2,3]
+    in_list: (value) -> value in @list
+    not_in_list: (value) -> value not in @list
+    of_list: (value) -> value of @list
+    not_of_list: (value) -> value not of @list
+  }
+  ok obj.in_list 3
+  ok obj.not_in_list 1
+  ok obj.of_list 0
+  ok obj.not_of_list 2
+
+test "#???: `in` with cache and `__indexOf` should work in argument lists", ->
+  eq 1, [Object() in Array()].length
+
+test "#737: `in` should have higher precedence than logical operators", ->
+  eq 1, 1 in [1] and 1
+
+test "#768: `in` should preserve evaluation order", ->
+  share = 0
+  a = -> share++ if share is 0
+  b = -> share++ if share is 1
+  c = -> share++ if share is 2
+  ok a() not in [b(),c()]
+  eq 3, share
+
+
+#### Chainable Operators
+
+test "chainable operators", ->
+  ok 100 > 10 > 1 > 0 > -1
+  ok -1 < 0 < 1 < 10 < 100
+
+test "`is` and `isnt` may be chained", ->
+  ok true is not false is true is not false
+  ok 0 is 0 isnt 1 is 1
+
+test "different comparison operators (`>`,`<`,`is`,etc.) may be combined", ->
+  ok 1 < 2 > 1
+  ok 10 < 20 > 2+3 is 5
+
+test "some chainable operators can be negated by `unless`", ->
+  ok (true unless 0==10!=100)
+
+test "operator precedence: `|` lower than `<`", ->
+  eq 1, 1 | 2 < 3 < 4
+
+test "preserve references", ->
+  a = b = c = 1
+  # `a == b <= c` should become `a === b && b <= c`
+  # (this test does not seem to test for this)
+  ok a == b <= c
+
+test "chained operations should evaluate each value only once", ->
+  a = 0
+  ok 1 > a++ < 1
+
+test "#891: incorrect inversion of chained comparisons", ->
+  ok (true unless 0 > 1 > 2)
+  ok (true unless (NaN = 0/0) < 0/0 < NaN)