spade-packager 0.1.0

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

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

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

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