guard-mthaml 0.1.0

data/vendor/coffeescript/coffeescript/tests/cases/option_parser.coffee

@@ -0,0 +1,43 @@
+# Option Parser
+# -------------
+
+# TODO: refactor option parser tests
+
+# Ensure that the OptionParser handles arguments correctly.
+return unless require?
+{OptionParser} = require './../lib/coffee-script/optparse'
+
+opt = new OptionParser [
+  ['-r', '--required [DIR]',  'desc required']
+  ['-o', '--optional',        'desc optional']
+  ['-l', '--list [FILES*]',   'desc list']
+]
+
+test "basic arguments", ->
+  args = ['one', 'two', 'three', '-r', 'dir']
+  result = opt.parse args
+  arrayEq args, result.arguments
+  eq undefined, result.required
+
+test "boolean and parameterised options", ->
+  result = opt.parse ['--optional', '-r', 'folder', 'one', 'two']
+  ok result.optional
+  eq 'folder', result.required
+  arrayEq ['one', 'two'], result.arguments
+
+test "list options", ->
+  result = opt.parse ['-l', 'one.txt', '-l', 'two.txt', 'three']
+  arrayEq ['one.txt', 'two.txt'], result.list
+  arrayEq ['three'], result.arguments
+
+test "-- and interesting combinations", ->
+  result = opt.parse ['-o','-r','a','-r','b','-o','--','-a','b','--c','d']
+  arrayEq ['-a', 'b', '--c', 'd'], result.arguments
+  ok result.optional
+  eq 'b', result.required
+
+  args = ['--','-o','a','-r','c','-o','--','-a','arg0','-b','arg1']
+  result = opt.parse args
+  eq undefined, result.optional
+  eq undefined, result.required
+  arrayEq args[1..], result.arguments

data/vendor/coffeescript/coffeescript/tests/cases/ranges.coffee

@@ -0,0 +1,88 @@
+# Range Literals
+# --------------
+
+# TODO: add indexing and method invocation tests: [1..4][0] is 1, [0...3].toString()
+
+# shared array
+shared = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+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]
+
+test "#1012 slices with arguments object", ->
+  expected = [0..9]
+  argsAtStart = (-> [arguments[0]..9]) 0
+  arrayEq expected, argsAtStart
+  argsAtEnd = (-> [0..arguments[0]]) 9
+  arrayEq expected, argsAtEnd
+  argsAtBoth = (-> [arguments[0]..arguments[1]]) 0, 9
+  arrayEq expected, argsAtBoth
+
+test "#1409: creating large ranges outside of a function body", ->
+  CoffeeScript.eval '[0..100]'

data/vendor/coffeescript/coffeescript/tests/cases/regexps.coffee

@@ -0,0 +1,63 @@
+# Regular Expression Literals
+# ---------------------------
+
+# TODO: add method invocation tests: /regex/.toString()
+
+# * Regexen
+# * Heregexen
+
+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
+
+  a = 10
+  b = a /= 4 / 2
+  eq a, 5
+
+  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 "#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'
+
+test "#1724: regular expressions beginning with `*`", ->
+  throws -> CoffeeScript.compile '/*/'
+
+
+# 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 "an empty heregex will compile to an empty, non-capturing group", ->
+  eq /(?:)/ + '', ///  /// + ''
+
+test "#1724: regular expressions beginning with `*`", ->
+  throws -> CoffeeScript.compile '/// * ///'
+
+test "empty regular expressions with flags", ->
+  fn = (x) -> x
+  a = "" + //i
+  fn ""
+  eq '/(?:)/i', a

data/vendor/coffeescript/coffeescript/tests/cases/scope.coffee

@@ -0,0 +1,43 @@
+# Scope
+# -----
+
+# * Variable Safety
+# * Variable Shadowing
+# * Auto-closure (`do`)
+# * Global Scope Leaks
+
+test "reference `arguments` inside of functions", ->
+  sumOfArgs = ->
+    sum = (a,b) -> a + b
+    sum = 0
+    sum += num for num in arguments
+    sum
+  eq 10, sumOfArgs(0, 1, 2, 3, 4)
+
+test "assignment to an Object.prototype-named variable should not leak to outer scope", ->
+  # FIXME: fails on IE
+  (->
+    constructor = 'word'
+  )()
+  ok constructor isnt 'word'
+
+test "siblings of splat parameters shouldn't leak to surrounding scope", ->
+  x = 10
+  oops = (x, args...) ->
+  oops(20, 1, 2, 3)
+  eq x, 10
+
+test "catch statements should introduce their argument to scope", ->
+  try throw ''
+  catch e
+    do -> e = 5
+    eq 5, e
+
+class Array then slice: fail # needs to be global
+class Object then hasOwnProperty: fail
+test "#1973: redefining Array/Object constructors shouldn't confuse __X helpers", ->
+  arr = [1..4]
+  arrayEq [3, 4], arr[2..]
+  obj = {arr}
+  for own k of obj
+    eq arr, obj[k]

data/vendor/coffeescript/coffeescript/tests/cases/slicing_and_splicing.coffee

@@ -0,0 +1,143 @@
+# Slicing and Splicing
+# --------------------
+
+# * Slicing
+# * Splicing
+
+# shared array
+shared = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+# Slicing
+
+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]
+
+  arrayEq [1, 2, 3], [1, 2, 3][..]
+
+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"
+
+test "#1722: operator precedence in unbounded slice compilation", ->
+  list = [0..9]
+  n = 2 # some truthy number in `list`
+  arrayEq [0..n], list[..n]
+  arrayEq [0..n], list[..n or 0]
+  arrayEq [0..n], list[..if n then n else 0]
+
+
+# Splicing
+
+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
+
+  ary[..] = [1, 2, 3]
+  arrayEq [1, 2, 3], 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]
+
+test "#1723: operator precedence in unbounded splice compilation", ->
+  n = 4 # some truthy number in `list`
+
+  list = [0..9]
+  list[..n] = n
+  arrayEq [n..9], list
+
+  list = [0..9]
+  list[..n or 0] = n
+  arrayEq [n..9], list
+
+  list = [0..9]
+  list[..if n then n else 0] = n
+  arrayEq [n..9], list

data/vendor/coffeescript/coffeescript/tests/cases/soaks.coffee

@@ -0,0 +1,134 @@
+# Soaks
+# -----
+
+# * Soaked Property Access
+# * Soaked Method Invocation
+# * Soaked Function Invocation
+
+
+# Soaked Property Access
+
+test "soaked property access", ->
+  nonce = {}
+  obj = a: b: nonce
+  eq nonce    , obj?.a.b
+  eq nonce    , obj?['a'].b
+  eq nonce    , obj.a?.b
+  eq nonce    , obj?.a?['b']
+  eq undefined, obj?.a?.non?.existent?.property
+
+test "soaked property access caches method calls", ->
+  nonce ={}
+  obj = fn: -> a: nonce
+  eq nonce    , obj.fn()?.a
+  eq undefined, obj.fn()?.b
+
+test "soaked property access chaching", ->
+  nonce = {}
+  counter = 0
+  fn = ->
+    counter++
+    'self'
+  obj =
+    self: -> @
+    prop: nonce
+  eq nonce, obj[fn()]()[fn()]()[fn()]()?.prop
+  eq 3, counter
+
+test "method calls on soaked methods", ->
+  nonce = {}
+  obj = null
+  eq undefined, obj?.a().b()
+  obj = a: -> b: -> nonce
+  eq nonce    , obj?.a().b()
+
+test "postfix existential operator mixes well with soaked property accesses", ->
+  eq false, nonexistent?.property?
+
+test "function invocation with soaked property access", ->
+  id = (_) -> _
+  eq undefined, id nonexistent?.method()
+
+test "if-to-ternary should safely parenthesize soaked property accesses", ->
+  ok (if nonexistent?.property then false else true)
+
+test "#726", ->
+  # TODO: check this test, looks like it's not really testing anything
+  eq undefined, nonexistent?[Date()]
+
+test "#756", ->
+  # TODO: improve this test
+  a = null
+  ok isNaN      a?.b.c +  1
+  eq undefined, a?.b.c += 1
+  eq undefined, ++a?.b.c
+  eq undefined, delete a?.b.c
+
+test "operations on soaked properties", ->
+  # TODO: improve this test
+  a = b: {c: 0}
+  eq 1,   a?.b.c +  1
+  eq 1,   a?.b.c += 1
+  eq 2,   ++a?.b.c
+  eq yes, delete a?.b.c
+
+
+# Soaked Method Invocation
+
+test "soaked method invocation", ->
+  nonce = {}
+  counter = 0
+  obj =
+    self: -> @
+    increment: -> counter++; @
+  eq obj      , obj.self?()
+  eq undefined, obj.method?()
+  eq nonce    , obj.self?().property = nonce
+  eq undefined, obj.method?().property = nonce
+  eq obj      , obj.increment().increment().self?()
+  eq 2        , counter
+
+test "#733", ->
+  a = b: {c: null}
+  eq a.b?.c?(), undefined
+  a.b?.c or= (it) -> it
+  eq a.b?.c?(1), 1
+  eq a.b?.c?([2, 3]...), 2
+
+
+# Soaked Function Invocation
+
+test "soaked function invocation", ->
+  nonce = {}
+  id = (_) -> _
+  eq nonce    , id?(nonce)
+  eq nonce    , (id? nonce)
+  eq undefined, nonexistent?(nonce)
+  eq undefined, (nonexistent? nonce)
+
+test "soaked function invocation with generated functions", ->
+  nonce = {}
+  id = (_) -> _
+  maybe = (fn, arg) -> if typeof fn is 'function' then () -> fn(arg)
+  eq maybe(id, nonce)?(), nonce
+  eq (maybe id, nonce)?(), nonce
+  eq (maybe false, nonce)?(), undefined
+
+test "soaked constructor invocation", ->
+  eq 42       , +new Number? 42
+  eq undefined,  new Other?  42
+
+test "soaked constructor invocations with caching and property access", ->
+  semaphore = 0
+  nonce = {}
+  class C
+    constructor: ->
+      ok false if semaphore
+      semaphore++
+    prop: nonce
+  eq nonce, (new C())?.prop
+  eq 1, semaphore
+
+test "soaked function invocation safe on non-functions", ->
+  eq undefined, 0?(1)
+  eq undefined, 0? 1, 2