spade 0.0.8.1 → 0.1.0

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

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

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

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

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

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