guard-mthaml 0.1.0

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

@@ -0,0 +1,188 @@
+# Function Literals
+# -----------------
+
+# TODO: add indexing and method invocation tests: (->)[0], (->).call()
+
+# * Function Definition
+# * Bound Function Definition
+# * Parameter List Features
+#   * Splat Parameters
+#   * Context (@) Parameters
+#   * Parameter Destructuring
+#   * Default Parameters
+
+# Function Definition
+
+x = 1
+y = {}
+y.x = -> 3
+ok x is 1
+ok typeof(y.x) is 'function'
+ok y.x instanceof Function
+ok y.x() is 3
+
+# The empty function should not cause a syntax error.
+->
+() ->
+
+# Multiple nested function declarations mixed with implicit calls should not
+# cause a syntax error.
+(one) -> (two) -> three four, (five) -> six seven, eight, (nine) ->
+
+# with multiple single-line functions on the same line.
+func = (x) -> (x) -> (x) -> x
+ok func(1)(2)(3) is 3
+
+# Make incorrect indentation safe.
+func = ->
+  obj = {
+          key: 10
+        }
+  obj.key - 5
+eq func(), 5
+
+# Ensure that functions with the same name don't clash with helper functions.
+del = -> 5
+ok del() is 5
+
+
+# Bound Function Definition
+
+obj =
+  bound: ->
+    (=> this)()
+  unbound: ->
+    (-> this)()
+  nested: ->
+    (=>
+      (=>
+        (=> this)()
+      )()
+    )()
+eq obj, obj.bound()
+ok obj isnt obj.unbound()
+eq obj, obj.nested()
+
+
+test "even more fancy bound functions", ->
+  obj =
+    one: ->
+      do =>
+        return this.two()
+    two: ->
+      do =>
+        do =>
+          do =>
+            return this.three
+    three: 3
+
+  eq obj.one(), 3
+
+
+test "self-referencing functions", ->
+  changeMe = ->
+    changeMe = 2
+
+  changeMe()
+  eq changeMe, 2
+
+
+# Parameter List Features
+
+test "splats", ->
+  arrayEq [0, 1, 2], (((splat...) -> splat) 0, 1, 2)
+  arrayEq [2, 3], (((_, _1, splat...) -> splat) 0, 1, 2, 3)
+  arrayEq [0, 1], (((splat..., _, _1) -> splat) 0, 1, 2, 3)
+  arrayEq [2], (((_, _1, splat..., _2) -> splat) 0, 1, 2, 3)
+
+test "@-parameters: automatically assign an argument's value to a property of the context", ->
+  nonce = {}
+
+  ((@prop) ->).call context = {}, nonce
+  eq nonce, context.prop
+
+  # allow splats along side the special argument
+  ((splat..., @prop) ->).apply context = {}, [0, 0, nonce]
+  eq nonce, context.prop
+
+  # allow the argument itself to be a splat
+  ((@prop...) ->).call context = {}, 0, nonce, 0
+  eq nonce, context.prop[1]
+
+  # the argument should still be able to be referenced normally
+  eq nonce, (((@prop) -> prop).call {}, nonce)
+
+test "@-parameters and splats with constructors", ->
+  a = {}
+  b = {}
+  class Klass
+    constructor: (@first, splat..., @last) ->
+
+  obj = new Klass a, 0, 0, b
+  eq a, obj.first
+  eq b, obj.last
+
+test "destructuring in function definition", ->
+  (([{a: [b], c}]...) ->
+    eq 1, b
+    eq 2, c
+  ) {a: [1], c: 2}
+
+test "default values", ->
+  nonceA = {}
+  nonceB = {}
+  a = (_,_1,arg=nonceA) -> arg
+  eq nonceA, a()
+  eq nonceA, a(0)
+  eq nonceB, a(0,0,nonceB)
+  eq nonceA, a(0,0,undefined)
+  eq nonceA, a(0,0,null)
+  eq false , a(0,0,false)
+  eq nonceB, a(undefined,undefined,nonceB,undefined)
+  b = (_,arg=nonceA,_1,_2) -> arg
+  eq nonceA, b()
+  eq nonceA, b(0)
+  eq nonceB, b(0,nonceB)
+  eq nonceA, b(0,undefined)
+  eq nonceA, b(0,null)
+  eq false , b(0,false)
+  eq nonceB, b(undefined,nonceB,undefined)
+  c = (arg=nonceA,_,_1) -> arg
+  eq nonceA, c()
+  eq      0, c(0)
+  eq nonceB, c(nonceB)
+  eq nonceA, c(undefined)
+  eq nonceA, c(null)
+  eq false , c(false)
+  eq nonceB, c(nonceB,undefined,undefined)
+
+test "default values with @-parameters", ->
+  a = {}
+  b = {}
+  obj = f: (q = a, @p = b) -> q
+  eq a, obj.f()
+  eq b, obj.p
+
+test "default values with splatted arguments", ->
+  withSplats = (a = 2, b..., c = 3, d = 5) -> a * (b.length + 1) * c * d
+  eq 30, withSplats()
+  eq 15, withSplats(1)
+  eq  5, withSplats(1,1)
+  eq  1, withSplats(1,1,1)
+  eq  2, withSplats(1,1,1,1)
+
+test "default values with function calls", ->
+  doesNotThrow -> CoffeeScript.compile "(x = f()) ->"
+
+test "arguments vs parameters", ->
+  doesNotThrow -> CoffeeScript.compile "f(x) ->"
+  f = (g) -> g()
+  eq 5, f (x) -> 5
+
+test "#1844: bound functions in nested comprehensions causing empty var statements", ->
+  a = ((=>) for a in [0] for b in [0])
+  eq 1, a.length
+
+test "#1859: inline function bodies shouldn't modify prior postfix ifs", ->
+  list = [1, 2, 3]
+  ok true if list.some (x) -> x is 2

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

@@ -0,0 +1,96 @@
+# Helpers
+# -------
+
+# pull the helpers from `CoffeeScript.helpers` into local variables
+{starts, ends, compact, count, merge, extend, flatten, del, last} = CoffeeScript.helpers
+
+
+# `starts`
+
+test "the `starts` helper tests if a string starts with another string", ->
+  ok     starts('01234', '012')
+  ok not starts('01234', '123')
+
+test "the `starts` helper can take an optional offset", ->
+  ok     starts('01234', '34', 3)
+  ok not starts('01234', '01', 1)
+
+
+# `ends`
+
+test "the `ends` helper tests if a string ends with another string", ->
+  ok     ends('01234', '234')
+  ok not ends('01234', '012')
+
+test "the `ends` helper can take an optional offset", ->
+  ok     ends('01234', '012', 2)
+  ok not ends('01234', '234', 6)
+
+
+# `compact`
+
+test "the `compact` helper removes falsey values from an array, preserves truthy ones", ->
+  allValues = [1, 0, false, obj={}, [], '', ' ', -1, null, undefined, true]
+  truthyValues = [1, obj, [], ' ', -1, true]
+  arrayEq truthyValues, compact(allValues)
+
+
+# `count`
+
+test "the `count` helper counts the number of occurances of a string in another string", ->
+  eq 1/0, count('abc', '')
+  eq 0, count('abc', 'z')
+  eq 1, count('abc', 'a')
+  eq 1, count('abc', 'b')
+  eq 2, count('abcdc', 'c')
+  eq 2, count('abcdabcd','abc')
+
+
+# `merge`
+
+test "the `merge` helper makes a new object with all properties of the objects given as its arguments", ->
+  ary = [0, 1, 2, 3, 4]
+  obj = {}
+  merged = merge obj, ary
+  ok merged isnt obj
+  ok merged isnt ary
+  for own key, val of ary
+    eq val, merged[key]
+
+
+# `extend`
+
+test "the `extend` helper performs a shallow copy", ->
+  ary = [0, 1, 2, 3]
+  obj = {}
+  # should return the object being extended
+  eq obj, extend(obj, ary)
+  # should copy the other object's properties as well (obviously)
+  eq 2, obj[2]
+
+
+# `flatten`
+
+test "the `flatten` helper flattens an array", ->
+  success = yes
+  (success and= typeof n is 'number') for n in flatten [0, [[[1]], 2], 3, [4]]
+  ok success
+
+
+# `del`
+
+test "the `del` helper deletes a property from an object and returns the deleted value", ->
+  obj = [0, 1, 2]
+  eq 1, del(obj, 1)
+  ok 1 not of obj
+
+
+# `last`
+
+test "the `last` helper returns the last item of an array-like object", ->
+  ary = [0, 1, 2, 3, 4]
+  eq 4, last(ary)
+
+test "the `last` helper allows one to specify an optional offset", ->
+  ary = [0, 1, 2, 3, 4]
+  eq 2, last(ary, 2)

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

@@ -0,0 +1,18 @@
+# Importing
+# ---------
+
+unless window? or testingBrowser?
+  test "coffeescript modules can be imported and executed", ->
+
+    magicKey = __filename
+    magicValue = 0xFFFF
+
+    if global[magicKey]?
+      if exports?
+        local = magicValue
+        exports.method = -> local
+    else
+      global[magicKey] = {}
+      if require?.extensions? or require?.registerExtension?
+        ok require(__filename).method() is magicValue
+      delete global[magicKey]

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

@@ -0,0 +1,138 @@
+# Interpolation
+# -------------
+
+# * String Interpolation
+# * Regular Expression Interpolation
+
+# String Interpolation
+
+# TODO: refactor string interpolation tests
+
+eq 'multiline nested "interpolations" work', """multiline #{
+  "nested #{
+    ok true
+    "\"interpolations\""
+  }"
+} work"""
+
+# Issue #923: Tricky interpolation.
+eq "#{ "{" }", "{"
+eq "#{ '#{}}' } }", '#{}} }'
+eq "#{"'#{ ({a: "b#{1}"}['a']) }'"}", "'b1'"
+
+# Issue #1150: String interpolation regression
+eq "#{'"/'}",                '"/'
+eq "#{"/'"}",                "/'"
+eq "#{/'"/}",                '/\'"/'
+eq "#{"'/" + '/"' + /"'/}",  '\'//"/"\'/'
+eq "#{"'/"}#{'/"'}#{/"'/}",  '\'//"/"\'/'
+eq "#{6 / 2}",               '3'
+eq "#{6 / 2}#{6 / 2}",       '33' # parsed as division
+eq "#{6 + /2}#{6/ + 2}",     '6/2}#{6/2' # parsed as a regex
+eq "#{6/2}
+    #{6/2}",                 '3    3' # newline cannot be part of a regex, so it's division
+eq "#{/// "'/'"/" ///}",     '/"\'\\/\'"\\/"/' # heregex, stuffed with spicy characters
+eq "#{/\\'/}",               "/\\\\'/"
+
+hello = 'Hello'
+world = 'World'
+ok '#{hello} #{world}!' is '#{hello} #{world}!'
+ok "#{hello} #{world}!" is 'Hello World!'
+ok "[#{hello}#{world}]" is '[HelloWorld]'
+ok "#{hello}##{world}" is 'Hello#World'
+ok "Hello #{ 1 + 2 } World" is 'Hello 3 World'
+ok "#{hello} #{ 1 + 2 } #{world}" is "Hello 3 World"
+
+[s, t, r, i, n, g] = ['s', 't', 'r', 'i', 'n', 'g']
+ok "#{s}#{t}#{r}#{i}#{n}#{g}" is 'string'
+ok "\#{s}\#{t}\#{r}\#{i}\#{n}\#{g}" is '#{s}#{t}#{r}#{i}#{n}#{g}'
+ok "\#{string}" is '#{string}'
+
+ok "\#{Escaping} first" is '#{Escaping} first'
+ok "Escaping \#{in} middle" is 'Escaping #{in} middle'
+ok "Escaping \#{last}" is 'Escaping #{last}'
+
+ok "##" is '##'
+ok "#{}" is ''
+ok "#{}A#{} #{} #{}B#{}" is 'A  B'
+ok "\\\#{}" is '\\#{}'
+
+ok "I won ##{20} last night." is 'I won #20 last night.'
+ok "I won ##{'#20'} last night." is 'I won ##20 last night.'
+
+ok "#{hello + world}" is 'HelloWorld'
+ok "#{hello + ' ' + world + '!'}" is 'Hello World!'
+
+list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ok "values: #{list.join(', ')}, length: #{list.length}." is 'values: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, length: 10.'
+ok "values: #{list.join ' '}" is 'values: 0 1 2 3 4 5 6 7 8 9'
+
+obj = {
+  name: 'Joe'
+  hi: -> "Hello #{@name}."
+  cya: -> "Hello #{@name}.".replace('Hello','Goodbye')
+}
+ok obj.hi() is "Hello Joe."
+ok obj.cya() is "Goodbye Joe."
+
+ok "With #{"quotes"}" is 'With quotes'
+ok 'With #{"quotes"}' is 'With #{"quotes"}'
+
+ok "Where is #{obj["name"] + '?'}" is 'Where is Joe?'
+
+ok "Where is #{"the nested #{obj["name"]}"}?" is 'Where is the nested Joe?'
+ok "Hello #{world ? "#{hello}"}" is 'Hello World'
+
+ok "Hello #{"#{"#{obj["name"]}" + '!'}"}" is 'Hello Joe!'
+
+a = """
+    Hello #{ "Joe" }
+    """
+ok a is "Hello Joe"
+
+a = 1
+b = 2
+c = 3
+ok "#{a}#{b}#{c}" is '123'
+
+result = null
+stash = (str) -> result = str
+stash "a #{ ('aa').replace /a/g, 'b' } c"
+ok result is 'a bb c'
+
+foo = "hello"
+ok "#{foo.replace("\"", "")}" is 'hello'
+
+val = 10
+a = """
+    basic heredoc #{val}
+    on two lines
+    """
+b = '''
+    basic heredoc #{val}
+    on two lines
+    '''
+ok a is "basic heredoc 10\non two lines"
+ok b is "basic heredoc \#{val}\non two lines"
+
+eq 'multiline nested "interpolations" work', """multiline #{
+  "nested #{(->
+    ok yes
+    "\"interpolations\""
+  )()}"
+} work"""
+
+
+# Regular Expression Interpolation
+
+# TODO: improve heregex interpolation tests
+
+test "heregex interpolation", ->
+  eq /\\#{}\\\"/ + '', ///
+   #{
+     "#{ '\\' }" # normal comment
+   }
+   # regex comment
+   \#{}
+   \\ \"
+  /// + ''

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

@@ -0,0 +1,10 @@
+# Javascript Literals
+# -------------------
+
+# TODO: refactor javascript literal tests
+# TODO: add indexing and method invocation tests: `[1]`[0] is 1, `function(){}`.call()
+
+eq '\\`', `
+  // Inline JS
+  "\\\`"
+`