spade 0.0.8.1 → 0.1.0

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

@@ -1,181 +0,0 @@
-# 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

@@ -1,90 +0,0 @@
-# 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

@@ -1,96 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,225 +0,0 @@
-# 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)