spade 0.0.8.1 → 0.1.0

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

@@ -1,270 +0,0 @@
-a = [((x) -> x), ((x) -> x * x)]
-
-ok a.length is 2
-
-
-neg = (3 -4)
-
-ok neg is -1
-
-
-# Decimal number literals.
-value = .25 + .75
-ok value is 1
-value = 0.0 + -.25 - -.75 + 0.0
-ok value is 0.5
-
-
-# Can call methods directly on numbers.
-4.valueOf() is 4
-
-
-func = ->
-  return if true
-
-ok func() is undefined
-
-
-trailingComma = [1, 2, 3,]
-ok (trailingComma[0] is 1) and (trailingComma[2] is 3) and (trailingComma.length is 3)
-
-trailingComma = [
-  1, 2, 3,
-  4, 5, 6
-  7, 8, 9,
-]
-(sum = (sum or 0) + n) for n in trailingComma
-
-trailingComma = {k1: "v1", k2: 4, k3: (-> true),}
-ok trailingComma.k3() and (trailingComma.k2 is 4) and (trailingComma.k1 is "v1")
-
-
-ok {a: (num) -> num is 10 }.a 10
-
-
-moe = {
-  name:  'Moe'
-  greet: (salutation) ->
-    salutation + " " + @name
-  hello: ->
-    @['greet'] "Hello"
-  10: 'number'
-}
-
-ok moe.hello() is "Hello Moe"
-ok moe[10] is 'number'
-
-moe.hello = ->
-  this['greet'] "Hello"
-
-ok moe.hello() is 'Hello Moe'
-
-
-obj = {
-  is:     -> yes,
-  'not':  -> no,
-}
-
-ok obj.is()
-ok not obj.not()
-
-
-### Top-level object literal... ###
-obj: 1
-### ...doesn't break things. ###
-
-# Funky indentation within non-comma-seperated arrays.
-result = [['a']
- {b: 'c'}]
-
-ok result[0][0] is 'a'
-ok result[1]['b'] is 'c'
-
-
-# Object literals should be able to include keywords.
-obj = {class: 'höt'}
-obj.function = 'dog'
-
-ok obj.class + obj.function is 'hötdog'
-
-
-# But keyword assignment should be smart enough not to stringify variables.
-func = ->
-  this == 'this'
-
-ok func() is false
-
-
-# New fancy implicit objects:
-config =
-  development:
-    server: 'localhost'
-    timeout: 10
-
-  production:
-    server: 'dreamboat'
-    timeout: 1000
-
-ok config.development.server  is 'localhost'
-ok config.production.server   is 'dreamboat'
-ok config.development.timeout is 10
-ok config.production.timeout  is 1000
-
-obj =
-  a: 1
-  b: 2
-
-ok obj.a is 1
-ok obj.b is 2
-
-obj =
-  a: 1,
-  b: 2,
-
-ok obj.a is 1
-ok obj.b is 2
-
-
-# Implicit objects nesting.
-obj =
-  options:
-    value: yes
-
-  fn: ->
-    {}
-    null
-
-ok obj.options.value is yes
-ok obj.fn() is null
-
-
-# Implicit arguments to function calls:
-func = (obj) -> obj.a
-func2 = -> arguments
-
-result = func
-  a: 10
-
-ok result is 10
-
-result = func
-  "a": 20
-
-ok result is 20
-
-third = (a, b, c) -> c
-obj =
-  one: 'one'
-  two: third 'one', 'two', 'three'
-
-ok obj.one is 'one'
-ok obj.two is 'three'
-
-a = b = undefined
-
-result = func
-    b:1
-    a
-
-ok result is undefined
-
-result = func
-    a:
-        b:2
-    b:1
-ok result.b is 2
-
-result = func2
-    a:1
-    b
-    c:1
-
-ok result.length is 3
-ok result[2].c is 1
-
-# Implicit objects with wacky indentation:
-obj =
-  'reverse': (obj) ->
-    Array.prototype.reverse.call obj
-  abc: ->
-    @reverse(
-      @reverse @reverse ['a', 'b', 'c'].reverse()
-    )
-  one: [1, 2,
-    a: 'b'
-  3, 4]
-  red:
-    orange:
-          yellow:
-                  green: 'blue'
-    indigo: 'violet'
-  misdent: [[],
-  [],
-                  [],
-      []]
-
-ok obj.abc().join(' ') is 'a b c'
-ok obj.one.length is 5
-ok obj.one[4] is 4
-ok obj.one[2].a is 'b'
-ok (key for key of obj.red).length is 2
-ok obj.red.orange.yellow.green is 'blue'
-ok obj.red.indigo is 'violet'
-ok obj.misdent.toString() is ',,,'
-
-second = (x, y) -> y
-obj = then second 'the',
-  1: 1
-  two:
-    three: ->
-      four five,
-        six: seven
-  three: 3
-
-ok obj[1] is 1
-ok obj.three is 3
-
-
-# Implicit objects as part of chained calls.
-pluck = (x) -> x.a
-eq 100, pluck pluck pluck a: a: a: 100
-
-
-eq '\\`', `
-  // Inline JS
-  "\\\`"
-`
-
-
-# Shorthand objects with property references.
-obj =
-  ### comment one ###
-  ### comment two ###
-  one: 1
-  two: 2
-  object: -> {@one, @two}
-  list:   -> [@one, @two]
-
-
-result = obj.object()
-eq result.one, 1
-eq result.two, 2
-eq result.two, obj.list()[1]
-
-
-#542: Objects leading expression statement should be parenthesized.
-{f: -> ok yes }.f() + 1
-
-
-#764: Boolean/Number should be indexable.
-ok 42['toString']
-ok on['toString']
-
-
-# String-keyed objects shouldn't suppress newlines.
-one =
-  '>!': 3
-six: -> 10
-
-ok not one.six
-

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

@@ -1,27 +0,0 @@
-# Ensure that the OptionParser handles arguments correctly.
-return unless require?
-{OptionParser} = require './../lib/optparse'
-
-opt = new OptionParser [
-  ['-r', '--required [DIR]',  'desc required']
-  ['-o', '--optional',        'desc optional']
-  ['-l', '--list [FILES*]',   'desc list']
-]
-
-result = opt.parse ['one', 'two', 'three', '-r', 'dir']
-
-ok result.arguments.length is 5
-ok result.arguments[3] is '-r'
-
-result = opt.parse ['--optional', '-r', 'folder', 'one', 'two']
-
-ok result.optional is true
-ok result.required is 'folder'
-ok result.arguments.join(' ') is 'one two'
-
-result = opt.parse ['-l', 'one.txt', '-l', 'two.txt', 'three']
-
-ok result.list instanceof Array
-ok result.list.join(' ') is 'one.txt two.txt'
-ok result.arguments.join(' ') is 'three'
-

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

@@ -1,162 +0,0 @@
-# Simple variable swapping.
-a = -1
-b = -2
-
-[a, b] = [b, a]
-
-eq a, -2
-eq b, -1
-
-func = ->
-  [a, b] = [b, a]
-
-eq func().join(' '), '-1 -2'
-eq a, -1
-eq b, -2
-
-#713
-eq (onetwo = [1, 2]), [a, b] = [c, d] = onetwo
-ok a is c is 1 and b is d is 2
-
-
-# Array destructuring, including splats.
-[x,y...,z] = [1,2,3,4,5]
-
-ok x is 1
-ok y.length is 3
-ok z is 5
-
-[x, [y, mids..., last], z..., end] = [1, [10, 20, 30, 40], 2,3,4, 5]
-
-ok x is 1
-ok y is 10
-ok mids.length is 2 and mids[1] is 30
-ok last is 40
-ok z.length is 3 and z[2] is 4
-ok end is 5
-
-
-# Object destructuring.
-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: "Moe"
-  family: {
-    'elder-brother': {
-      addresses: [
-        "first"
-        {
-          street: "101 Deercreek Ln."
-          city:   "Moquasset NY, 10021"
-        }
-      ]
-    }
-  }
-}
-
-{name: a, family: {'elder-brother': {addresses: [one, {city: b}]}}} = person
-
-ok a is "Moe"
-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"
-
-
-# Pattern matching against an expression.
-[a, b] = if true then [2, 1] else [1, 2]
-
-ok a is 2
-ok b is 1
-
-
-# Pattern matching with object shorthand.
-
-person = {
-  name: "Bob"
-  age:  26
-  dogs: ["Prince", "Bowie"]
-}
-
-{name, age, dogs: [first, second]} = person
-
-ok name   is "Bob"
-ok age    is 26
-ok first  is "Prince"
-ok second is "Bowie"
-
-# Pattern matching within for..loops.
-
-persons = {
-  George: { name: "Bob" },
-  Bob: { name: "Alice" }
-  Christopher: { name: "Stan" }
-}
-
-join1 = ("#{key}: #{name}" for key, { name } of persons)
-
-eq join1.join(' / '), "George: Bob / Bob: Alice / Christopher: Stan"
-
-persons = [
-  { name: "Bob", parent: { name: "George" } },
-  { name: "Alice", parent: { name: "Bob" } },
-  { name: "Stan", parent: { name: "Christopher" } }
-]
-
-join2 = ("#{parent}: #{name}" for { name, parent: { name: parent } } in persons)
-
-eq join1.join(' '), join2.join(' ')
-
-persons = [['Bob', ['George']], ['Alice', ['Bob']], ['Stan', ['Christopher']]]
-join3 = ("#{parent}: #{name}" for [name, [parent]] in persons)
-
-eq join2.join(' '), join3.join(' ')
-
-
-# Pattern matching doesn't clash with implicit block objects.
-obj = a: 101
-func = -> true
-
-if func func
-  {a} = obj
-
-ok a is 101
-
-[x] = {0: y} = {'0': z} = [Math.random()]
-ok x is y is z, 'destructuring in multiple'
-
-
-# Destructuring into an object.
-obj =
-  func: (list, object) ->
-    [@one, @two] = list
-    {@a, @b} = object
-    {@a} = object
-    null
-
-{} = [] = ok yes, 'empty assignment is allowed'
-
-obj.func [1, 2], a: 'a', b: 'b'
-
-eq obj.one, 1
-eq obj.two, 2
-eq obj.a, 'a'
-eq obj.b, 'b'