spade-packager 0.1.0

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

@@ -0,0 +1,186 @@
+# Ranges, Slices, and Splices
+# ---------------------------
+
+# shared array
+shared = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+
+#### Ranges
+
+test "basic inclusive ranges", ->
+  arrayEq [1, 2, 3] , [1..3]
+  arrayEq [0, 1, 2] , [0..2]
+  arrayEq [0, 1]    , [0..1]
+  arrayEq [0]       , [0..0]
+  arrayEq [-1]      , [-1..-1]
+  arrayEq [-1, 0]   , [-1..0]
+  arrayEq [-1, 0, 1], [-1..1]
+
+test "basic exclusive ranges", ->
+  arrayEq [1, 2, 3] , [1...4]
+  arrayEq [0, 1, 2] , [0...3]
+  arrayEq [0, 1]    , [0...2]
+  arrayEq [0]       , [0...1]
+  arrayEq [-1]      , [-1...0]
+  arrayEq [-1, 0]   , [-1...1]
+  arrayEq [-1, 0, 1], [-1...2]
+
+  arrayEq [], [1...1]
+  arrayEq [], [0...0]
+  arrayEq [], [-1...-1]
+
+test "downward ranges", ->
+  arrayEq shared, [9..0].reverse()
+  arrayEq [5, 4, 3, 2] , [5..2]
+  arrayEq [2, 1, 0, -1], [2..-1]
+
+  arrayEq [3, 2, 1]  , [3..1]
+  arrayEq [2, 1, 0]  , [2..0]
+  arrayEq [1, 0]     , [1..0]
+  arrayEq [0]        , [0..0]
+  arrayEq [-1]       , [-1..-1]
+  arrayEq [0, -1]    , [0..-1]
+  arrayEq [1, 0, -1] , [1..-1]
+  arrayEq [0, -1, -2], [0..-2]
+
+  arrayEq [4, 3, 2], [4...1]
+  arrayEq [3, 2, 1], [3...0]
+  arrayEq [2, 1]   , [2...0]
+  arrayEq [1]      , [1...0]
+  arrayEq []       , [0...0]
+  arrayEq []       , [-1...-1]
+  arrayEq [0]      , [0...-1]
+  arrayEq [0, -1]  , [0...-2]
+  arrayEq [1, 0]   , [1...-1]
+  arrayEq [2, 1, 0], [2...-1]
+
+test "ranges with variables as enpoints", ->
+  [a, b] = [1, 3]
+  arrayEq [1, 2, 3], [a..b]
+  arrayEq [1, 2]   , [a...b]
+  b = -2
+  arrayEq [1, 0, -1, -2], [a..b]
+  arrayEq [1, 0, -1]    , [a...b]
+
+test "ranges with expressions as endpoints", ->
+  [a, b] = [1, 3]
+  arrayEq [2, 3, 4, 5, 6], [(a+1)..2*b]
+  arrayEq [2, 3, 4, 5]   , [(a+1)...2*b]
+
+test "large ranges are generated with looping constructs", ->
+  down = [99..0]
+  eq 100, (len = down.length)
+  eq   0, down[len - 1]
+
+  up = [0...100]
+  eq 100, (len = up.length)
+  eq  99, up[len - 1]
+
+
+#### Slices
+
+test "basic slicing", ->
+  arrayEq [7, 8, 9]   , shared[7..9]
+  arrayEq [2, 3]      , shared[2...4]
+  arrayEq [2, 3, 4, 5], shared[2...6]
+
+test "slicing with variables as endpoints", ->
+  [a, b] = [1, 4]
+  arrayEq [1, 2, 3, 4], shared[a..b]
+  arrayEq [1, 2, 3]   , shared[a...b]
+
+test "slicing with expressions as endpoints", ->
+  [a, b] = [1, 3]
+  arrayEq [2, 3, 4, 5, 6], shared[(a+1)..2*b]
+  arrayEq [2, 3, 4, 5]   , shared[a+1...(2*b)]
+
+test "unbounded slicing", ->
+  arrayEq [7, 8, 9]   , shared[7..]
+  arrayEq [8, 9]      , shared[-2..]
+  arrayEq [9]         , shared[-1...]
+  arrayEq [0, 1, 2]   , shared[...3]
+  arrayEq [0, 1, 2, 3], shared[..-7]
+
+  arrayEq shared      , shared[..-1]
+  arrayEq shared[0..8], shared[...-1]
+
+  for a in [-shared.length..shared.length]
+    arrayEq shared[a..] , shared[a...]
+  for a in [-shared.length+1...shared.length]
+    arrayEq shared[..a][...-1] , shared[...a]
+
+test "#930, #835, #831, #746 #624: inclusive slices to -1 should slice to end", ->
+  arrayEq shared, shared[0..-1]
+  arrayEq shared, shared[..-1]
+  arrayEq shared.slice(1,shared.length), shared[1..-1]
+
+test "string slicing", ->
+  str = "abcdefghijklmnopqrstuvwxyz"
+  ok str[1...1] is ""
+  ok str[1..1] is "b"
+  ok str[1...5] is "bcde"
+  ok str[0..4] is "abcde"
+  ok str[-5..] is "vwxyz"
+
+
+#### Splices
+
+test "basic splicing", ->
+  ary = [0..9]
+  ary[5..9] = [0, 0, 0]
+  arrayEq [0, 1, 2, 3, 4, 0, 0, 0], ary
+
+  ary = [0..9]
+  ary[2...8] = []
+  arrayEq [0, 1, 8, 9], ary
+
+test "unbounded splicing", ->
+  ary = [0..9]
+  ary[3..] = [9, 8, 7]
+  arrayEq [0, 1, 2, 9, 8, 7]. ary
+
+  ary[...3] = [7, 8, 9]
+  arrayEq [7, 8, 9, 9, 8, 7], ary
+
+test "splicing with variables as endpoints", ->
+  [a, b] = [1, 8]
+
+  ary = [0..9]
+  ary[a..b] = [2, 3]
+  arrayEq [0, 2, 3, 9], ary
+
+  ary = [0..9]
+  ary[a...b] = [5]
+  arrayEq [0, 5, 8, 9], ary
+
+test "splicing with expressions as endpoints", ->
+  [a, b] = [1, 3]
+
+  ary = [0..9]
+  ary[ a+1 .. 2*b+1 ] = [4]
+  arrayEq [0, 1, 4, 8, 9], ary
+
+  ary = [0..9]
+  ary[a+1...2*b+1] = [4]
+  arrayEq [0, 1, 4, 7, 8, 9], ary
+
+test "splicing to the end, against a one-time function", ->
+  ary = null
+  fn = ->
+    if ary
+      throw 'err'
+    else
+      ary = [1, 2, 3]
+
+  fn()[0..] = 1
+
+  arrayEq ary, [1]
+
+test "the return value of a splice literal should be the RHS", ->
+  ary = [0, 0, 0]
+  eq (ary[0..1] = 2), 2
+
+  ary = [0, 0, 0]
+  eq (ary[0..] = 3), 3
+
+  arrayEq [ary[0..0] = 0], [0]

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

@@ -0,0 +1,56 @@
+# Regular Expressions
+# -------------------
+#TODO: add some rigorous regex interpolation tests
+
+test "basic regular expression literals", ->
+  ok 'a'.match(/a/)
+  ok 'a'.match /a/
+  ok 'a'.match(/a/g)
+  ok 'a'.match /a/g
+
+test "division is not confused for a regular expression", ->
+  eq 2, 4 / 2 / 1
+
+  a = 4
+  b = 2
+  g = 1
+  eq 2, a / b/g
+
+  obj = method: -> 2
+  two = 2
+  eq 2, (obj.method()/two + obj.method()/two)
+
+  i = 1
+  eq 2, (4)/2/i
+  eq 1, i/i/i
+
+test "backslash escapes", ->
+  eq "\\/\\\\", /\/\\/.source
+
+test "#764: regular expressions should be indexable", ->
+  eq /0/['source'], ///#{0}///['source']
+
+test "#584: slashes are allowed unescaped in character classes", ->
+  ok /^a\/[/]b$/.test 'a//b'
+
+
+#### Heregexe(n|s)
+
+test "a heregex will ignore whitespace and comments", ->
+  eq /^I'm\x20+[a]\s+Heregex?\/\/\//gim + '', ///
+    ^ I'm \x20+ [a] \s+
+    Heregex? / // # or not
+  ///gim + ''
+
+test "heregex interpolation", ->
+  eq /\\#{}\\\"/ + '', ///
+   #{
+     "#{ '\\' }" # normal comment
+   }
+   # regex comment
+   \#{}
+   \\ \"
+  /// + ''
+
+test "an empty heregex will compile to an empty, non-capturing group", ->
+  eq /(?:)/ + '', ///  /// + ''

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

@@ -0,0 +1,123 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+  <title>CoffeeScript Test Suite</title>
+  <script src="../extras/coffee-script.js"></script>
+  <style>
+    body {
+      margin: 30px;
+      font-family: Menlo, Monaco, monospace;
+    }
+    h1 {
+      font-size: 20px;
+    }
+    #stdout {
+    }
+  </style>
+</head>
+<body>
+
+  <h1>CoffeeScript Test Suite</h1>
+  <pre id="stdout"></pre>
+
+  <script type="text/coffeescript">
+
+  stdout  = document.getElementById 'stdout'
+  start   = new Date
+  success = total = done = failed = 0
+
+  say = (msg, yay) ->
+    div = document.createElement 'div'
+    div.appendChild document.createTextNode msg
+    div.style.color = if yay then 'green' else 'red'
+    stdout.appendChild div
+    msg
+
+  @test = (desc, fn) ->
+    fn()
+
+  @ok = (good, msg) ->
+    ++total
+    if good then ++success else throw Error say msg
+
+  @eq = (x, y, msg) -> ok x is y, msg ? x + ' !== ' + y
+
+  arrayEqual = (a, b) ->
+    if a is b
+      # 0 isnt -0
+      a isnt 0 or 1/a is 1/b
+    else if a instanceof Array and b instanceof Array
+      return no unless a.length is b.length
+      return no for el, idx in a when not arrayEq el, b[idx]
+      yes
+    else
+      # NaN is NaN
+      a isnt a and b isnt b
+
+  @doesNotThrow = (fn) ->
+    fn()
+    ok true
+
+  @arrayEq = (a, b, msg) -> ok arrayEqual(a,b), msg
+
+  @throws = (fun, err, msg) ->
+    try
+      fun()
+    catch e
+      if err
+        eq e, err
+      else
+        ok yes
+      return
+    ok no
+
+
+  CoffeeScript.run = (code, cb) ->
+    try Function(CoffeeScript.compile code, wrap: no)()
+    catch e then cb(); throw e
+    cb yes
+
+  run = (name) ->
+    CoffeeScript.load "#{name}.coffee", (yay) ->
+      say "#{ if yay then '\u2714' else '\u3000' } #{name}", yay
+      ++failed unless yay
+      fin() if ++done is names.length
+
+  fin = ->
+    yay = success is total and not failed
+    sec = (new Date - start) / 1000
+    msg = "passed #{success} tests in #{ sec.toFixed 2 } seconds"
+    msg = "failed #{ total - success } tests and #{msg}" unless yay
+    say msg, yay
+
+  run name for name in names = [
+    'arguments'
+    'assignment'
+    'break'
+    'comments'
+    'exception_handling'
+    'helpers'
+    'operators'
+    'regular_expressions'
+    'test_chaining'
+    'test_classes'
+    'test_compilation'
+    'test_comprehensions'
+    'test_existence'
+    'test_functions'
+    'test_heredocs'
+    'conditionals'
+    'test_literals'
+    'test_pattern_matching'
+    'ranges_slices_and_splices'
+    'test_returns'
+    'test_splats'
+    'test_strings'
+    'test_switch'
+    'test_while'
+  ]
+  </script>
+
+</body>
+</html>

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

@@ -0,0 +1,77 @@
+# Chaining
+# --------
+
+# shared identity function
+id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
+
+
+
+# Basic chained function calls.
+identityWrap = (x) ->
+  -> x
+
+result = identityWrap(identityWrap(true))()()
+
+ok result
+
+
+# Should be able to look at prototypes on keywords.
+obj =
+  withAt:   -> @::prop
+  withThis: -> this::prop
+  proto:
+    prop: 100
+obj.prototype = obj.proto
+eq obj.withAt()  , 100
+eq obj.withThis(), 100
+
+
+# Chained accesses split on period/newline, backwards and forwards.
+str = 'god'
+
+result = str.
+  split('').
+  reverse().
+  reverse().
+  reverse()
+
+ok result.join('') is 'dog'
+
+result = str
+  .split('')
+  .reverse()
+  .reverse()
+  .reverse()
+
+ok result.join('') is 'dog'
+
+
+# Newline suppression for operators.
+six =
+  1 +
+  2 +
+  3
+
+ok six is 6
+
+
+# Ensure that indented array literals don't trigger whitespace rewriting.
+func = () ->
+  ok arguments.length is 1
+
+func(
+  [[[[[],
+                []],
+              [[]]]],
+    []])
+
+greeting = id(
+              """
+              Hello
+              """)
+
+ok greeting is "Hello"
+
+ok not Date
+::
+?.foo, '`?.` and `::` should also continue lines'

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

@@ -0,0 +1,372 @@
+# Test classes with a four-level inheritance chain.
+class Base
+  func: (string) ->
+    "zero/#{string}"
+
+  @static: (string) ->
+    "static/#{string}"
+
+class FirstChild extends Base
+  func: (string) ->
+    super('one/') + string
+
+SecondChild = class extends FirstChild
+  func: (string) ->
+    super('two/') + string
+
+thirdCtor = ->
+  @array = [1, 2, 3]
+
+class ThirdChild extends SecondChild
+  constructor: -> thirdCtor.call this
+
+  # Gratuitous comment for testing.
+  func: (string) ->
+    super('three/') + string
+
+result = (new ThirdChild).func 'four'
+
+ok result is 'zero/one/two/three/four'
+ok Base.static('word') is 'static/word'
+
+FirstChild::func = (string) ->
+  super('one/').length + string
+
+result = (new ThirdChild).func 'four'
+
+ok result is '9two/three/four'
+
+ok (new ThirdChild).array.join(' ') is '1 2 3'
+
+
+identity = (f) -> f
+
+class TopClass
+  constructor: (arg) ->
+    @prop = 'top-' + arg
+
+class SuperClass extends TopClass
+  constructor: (arg) ->
+    identity super 'super-' + arg
+
+class SubClass extends SuperClass
+  constructor: ->
+    identity super 'sub'
+
+ok (new SubClass).prop is 'top-super-sub'
+
+
+class OneClass
+  @new: 'new'
+  function: 'function'
+  constructor: (name) -> @name = name
+
+class TwoClass extends OneClass
+delete TwoClass.new
+
+Function.prototype.new = -> new this arguments...
+
+ok (TwoClass.new('three')).name is 'three'
+ok (new OneClass).function is 'function'
+ok OneClass.new is 'new'
+
+delete Function.prototype.new
+
+
+# And now the same tests, but written in the manual style:
+Base = ->
+Base::func = (string) ->
+  'zero/' + string
+Base::['func-func'] = (string) ->
+  "dynamic-#{string}"
+
+FirstChild = ->
+SecondChild = ->
+ThirdChild = ->
+  @array = [1, 2, 3]
+  this
+
+ThirdChild extends SecondChild extends FirstChild extends Base
+
+FirstChild::func = (string) ->
+  super('one/') + string
+
+SecondChild::func = (string) ->
+  super('two/') + string
+
+ThirdChild::func = (string) ->
+  super('three/') + string
+
+result = (new ThirdChild).func 'four'
+
+ok result is 'zero/one/two/three/four'
+
+ok (new ThirdChild)['func-func']('thing') is 'dynamic-thing'
+
+
+TopClass = (arg) ->
+  @prop = 'top-' + arg
+  this
+
+SuperClass = (arg) ->
+  super 'super-' + arg
+  this
+
+SubClass = ->
+  super 'sub'
+  this
+
+SuperClass extends TopClass
+SubClass extends SuperClass
+
+ok (new SubClass).prop is 'top-super-sub'
+
+
+# '@' referring to the current instance, and not being coerced into a call.
+class ClassName
+  amI: ->
+    @ instanceof ClassName
+
+obj = new ClassName
+ok obj.amI()
+
+
+# super() calls in constructors of classes that are defined as object properties.
+class Hive
+  constructor: (name) -> @name = name
+
+class Hive.Bee extends Hive
+  constructor: (name) -> super
+
+maya = new Hive.Bee 'Maya'
+ok maya.name is 'Maya'
+
+
+# Class with JS-keyword properties.
+class Class
+  class: 'class'
+  name: -> @class
+
+instance = new Class
+ok instance.class is 'class'
+ok instance.name() is 'class'
+
+
+# Classes with methods that are pre-bound to the instance.
+# ... or statically, to the class.
+class Dog
+
+  constructor: (name) ->
+    @name = name
+
+  bark: =>
+    "#{@name} woofs!"
+
+  @static = =>
+    new this('Dog')
+
+spark = new Dog('Spark')
+fido  = new Dog('Fido')
+fido.bark = spark.bark
+
+ok fido.bark() is 'Spark woofs!'
+
+obj = func: Dog.static
+
+ok obj.func().name is 'Dog'
+
+
+# Testing a bound function in a bound function.
+class Mini
+  num: 10
+  generate: =>
+    for i in [1..3]
+      =>
+        @num
+
+m = new Mini
+eq (func() for func in m.generate()).join(' '), '10 10 10'
+
+
+# Testing a contructor called with varargs.
+class Connection
+  constructor: (one, two, three) ->
+    [@one, @two, @three] = [one, two, three]
+
+  out: ->
+    "#{@one}-#{@two}-#{@three}"
+
+list = [3, 2, 1]
+conn = new Connection list...
+ok conn instanceof Connection
+ok conn.out() is '3-2-1'
+
+
+# Test calling super and passing along all arguments.
+class Parent
+  method: (args...) -> @args = args
+
+class Child extends Parent
+  method: -> super
+
+c = new Child
+c.method 1, 2, 3, 4
+ok c.args.join(' ') is '1 2 3 4'
+
+
+# Test classes wrapped in decorators.
+func = (klass) ->
+  klass::prop = 'value'
+  klass
+
+func class Test
+  prop2: 'value2'
+
+ok (new Test).prop  is 'value'
+ok (new Test).prop2 is 'value2'
+
+
+# Test anonymous classes.
+obj =
+  klass: class
+    method: -> 'value'
+
+instance = new obj.klass
+ok instance.method() is 'value'
+
+
+# Implicit objects as static properties.
+class Static
+  @static =
+    one: 1
+    two: 2
+
+ok Static.static.one is 1
+ok Static.static.two is 2
+
+
+# Nothing classes.
+c = class
+ok c instanceof Function
+
+
+# Classes with value'd constructors.
+counter = 0
+classMaker = ->
+  counter += 1
+  inner = counter
+  ->
+    @value = inner
+
+class One
+  constructor: classMaker()
+
+class Two
+  constructor: classMaker()
+
+ok (new One).value is 1
+ok (new Two).value is 2
+ok (new One).value is 1
+ok (new Two).value is 2
+
+
+# Exectuable class bodies.
+class A
+  if true
+    b: 'b'
+  else
+    c: 'c'
+
+a = new A
+
+eq a.b, 'b'
+eq a.c, undefined
+
+
+# Light metaprogramming.
+class Base
+  @attr: (name) ->
+    @::[name] = (val) ->
+      if arguments.length > 0
+        @["_#{name}"] = val
+      else
+        @["_#{name}"]
+
+class Robot extends Base
+  @attr 'power'
+  @attr 'speed'
+
+robby = new Robot
+
+ok robby.power() is undefined
+
+robby.power 11
+robby.speed Infinity
+
+eq robby.power(), 11
+eq robby.speed(), Infinity
+
+
+# Namespaced classes do not reserve their function name in outside scope.
+one = {}
+two = {}
+
+class one.Klass
+  @label = "one"
+
+class two.Klass
+  @label = "two"
+
+eq typeof Klass, 'undefined'
+eq one.Klass.label, 'one'
+eq two.Klass.label, 'two'
+
+
+# Nested classes.
+class Outer
+  constructor: ->
+    @label = 'outer'
+
+  class @Inner
+    constructor: ->
+      @label = 'inner'
+
+eq (new Outer).label, 'outer'
+eq (new Outer.Inner).label, 'inner'
+
+
+# Variables in constructor bodies are correctly scoped.
+class A
+  x = 1
+  constructor: ->
+    x = 10
+    y = 20
+  y = 2
+  captured: ->
+    {x, y}
+
+a = new A
+eq a.captured().x, 10
+eq a.captured().y, 2
+
+
+# Issue #924: Static methods in nested classes.
+class A
+  @B: class
+    @c = -> 5
+
+eq A.B.c(), 5
+
+
+# `class extends this` ...
+class A
+  func: -> 'A'
+
+B = null
+makeClass = ->
+  B = class extends this
+    func: -> super + ' B'
+
+makeClass.call A
+
+eq (new B()).func(), 'A B'