guard-mthaml 0.1.0

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

@@ -0,0 +1,76 @@
+# Number Literals
+# ---------------
+
+# * Decimal Integer Literals
+# * Octal Integer Literals
+# * Hexadecimal Integer Literals
+# * Scientific Notation Integer Literals
+# * Scientific Notation Non-Integer Literals
+# * Non-Integer Literals
+# * Binary Integer Literals
+
+
+# Binary Integer Literals
+# Binary notation is understood as would be decimal notation.
+
+test "Parser recognises binary numbers", ->
+  eq 4, 0b100
+
+# Decimal Integer Literals
+
+test "call methods directly on numbers", ->
+  eq 4, 4.valueOf()
+  eq '11', 4.toString 3
+
+eq -1, 3 -4
+
+#764: Numbers should be indexable
+eq Number::toString, 42['toString']
+
+eq Number::toString, 42.toString
+
+
+# Non-Integer Literals
+
+# Decimal number literals.
+value = .25 + .75
+ok value is 1
+value = 0.0 + -.25 - -.75 + 0.0
+ok value is 0.5
+
+#764: Numbers should be indexable
+eq Number::toString,   4['toString']
+eq Number::toString, 4.2['toString']
+eq Number::toString, .42['toString']
+eq Number::toString, (4)['toString']
+
+eq Number::toString,   4.toString
+eq Number::toString, 4.2.toString
+eq Number::toString, .42.toString
+eq Number::toString, (4).toString
+
+test '#1168: leading floating point suppresses newline', ->
+  eq 1, do ->
+    1
+    .5 + 0.5
+
+test "Python-style octal literal notation '0o777'", ->
+  eq 511, 0o777
+  eq 1, 0o1
+  eq 1, 0o00001
+  eq parseInt('0777', 8), 0o777
+  eq '777', 0o777.toString 8
+  eq 4, 0o4.valueOf()
+  eq Number::toString, 0o777['toString']
+  eq Number::toString, 0o777.toString
+
+test "#2060: Disallow uppercase radix prefixes and exponential notation", ->
+  for char in ['b', 'o', 'x', 'e']
+    program = "0#{char}0"
+    doesNotThrow -> CoffeeScript.compile program, bare: yes
+    throws -> CoffeeScript.compile program.toUpperCase(), bare: yes
+
+test "#2224: hex literals with 0b or B or E", ->
+  eq 176, 0x0b0
+  eq 177, 0x0B1
+  eq 225, 0xE1

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

@@ -0,0 +1,271 @@
+# Object Literals
+# ---------------
+
+# TODO: refactor object literal tests
+# TODO: add indexing and method invocation tests: {a}['a'] is a, {a}.a()
+
+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. ###
+
+# Object literals should be able to include keywords.
+obj = {class: 'höt'}
+obj.function = 'dog'
+ok obj.class + obj.function is 'hötdog'
+
+# Implicit objects as part of chained calls.
+pluck = (x) -> x.a
+eq 100, pluck pluck pluck a: a: a: 100
+
+
+test "YAML-style object literals", ->
+  obj =
+    a: 1
+    b: 2
+  eq 1, obj.a
+  eq 2, obj.b
+
+  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
+
+# Implicit objects nesting.
+obj =
+  options:
+    value: yes
+  fn: ->
+    {}
+    null
+ok obj.options.value is yes
+ok obj.fn() is null
+
+# 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 ',,,'
+
+#542: Objects leading expression statement should be parenthesized.
+{f: -> ok yes }.f() + 1
+
+# String-keyed objects shouldn't suppress newlines.
+one =
+  '>!': 3
+six: -> 10
+ok not one.six
+
+# 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]
+
+third = (a, b, c) -> c
+obj =
+  one: 'one'
+  two: third 'one', 'two', 'three'
+ok obj.one is 'one'
+ok obj.two is 'three'
+
+test "invoking functions with implicit object literals", ->
+  generateGetter = (prop) -> (obj) -> obj[prop]
+  getA = generateGetter 'a'
+  getArgs = -> arguments
+  a = b = 30
+
+  result = getA
+    a: 10
+  eq 10, result
+
+  result = getA
+    "a": 20
+  eq 20, result
+
+  result = getA a,
+    b:1
+  eq undefined, result
+
+  result = getA b:1,
+  a:43
+  eq 43, result
+
+  result = getA b:1,
+    a:62
+  eq undefined, result
+
+  result = getA
+    b:1
+    a
+  eq undefined, result
+
+  result = getA
+    a:
+      b:2
+    b:1
+  eq 2, result.b
+
+  result = getArgs
+    a:1
+    b
+    c:1
+  ok result.length is 3
+  ok result[2].c is 1
+
+  result = getA b: 13, a: 42, 2
+  eq 42, result
+
+  result = getArgs a:1, (1 + 1)
+  ok result[1] is 2
+
+  result = getArgs a:1, b
+  ok result.length is 2
+  ok result[1] is 30
+
+  result = getArgs a:1, b, b:1, a
+  ok result.length is 4
+  ok result[2].b is 1
+
+  throws -> CoffeeScript.compile "a = b:1, c"
+
+test "some weird indentation in YAML-style object literals", ->
+  two = (a, b) -> b
+  obj = then two 1,
+    1: 1
+    a:
+      b: ->
+        fn c,
+          d: e
+    f: 1
+  eq 1, obj[1]
+
+test "#1274: `{} = a()` compiles to `false` instead of `a()`", ->
+  a = false
+  fn = -> a = true
+  {} = fn()
+  ok a
+
+test "#1436: `for` etc. work as normal property names", ->
+  obj = {}
+  eq no, obj.hasOwnProperty 'for'
+  obj.for = 'foo' of obj
+  eq yes, obj.hasOwnProperty 'for'
+
+test "#1322: implicit call against implicit object with block comments", ->
+  ((obj, arg) ->
+    eq obj.x * obj.y, 6
+    ok not arg
+  )
+    ###
+    x
+    ###
+    x: 2
+    ### y ###
+    y: 3
+
+test "#1513: Top level bare objs need to be wrapped in parens for unary and existence ops", ->
+  doesNotThrow -> CoffeeScript.run "{}?", bare: true
+  doesNotThrow -> CoffeeScript.run "{}.a++", bare: true
+
+test "#1871: Special case for IMPLICIT_END in the middle of an implicit object", ->
+  result = 'result'
+  ident = (x) -> x
+
+  result = ident one: 1 if false
+
+  eq result, 'result'
+
+  result = ident
+    one: 1
+    two: 2 for i in [1..3]
+
+  eq result.two.join(' '), '2 2 2'
+
+test "#1961, #1974, regression with compound assigning to an implicit object", ->
+
+  obj = null
+
+  obj ?=
+    one: 1
+    two: 2
+
+  eq obj.two, 2
+
+  obj = null
+
+  obj or=
+    three: 3
+    four: 4
+
+  eq obj.four, 4

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

@@ -0,0 +1,277 @@
+# Operators
+# ---------
+
+# * Operators
+# * Existential Operator (Binary)
+# * Existential Operator (Unary)
+# * Aliased Operators
+# * [not] in/of
+# * Chained Comparison
+
+test "binary (2-ary) math operators do not require spaces", ->
+  a = 1
+  b = -1
+  eq +1, a*-b
+  eq -1, a*+b
+  eq +1, a/-b
+  eq -1, a/+b
+
+test "operators should respect new lines as spaced", ->
+  a = 123 +
+  456
+  eq 579, a
+
+  b = "1#{2}3" +
+  "456"
+  eq '123456', b
+
+test "multiple operators should space themselves", ->
+  eq (+ +1), (- -1)
+
+test "bitwise operators", ->
+  eq  2, (10 &   3)
+  eq 11, (10 |   3)
+  eq  9, (10 ^   3)
+  eq 80, (10 <<  3)
+  eq  1, (10 >>  3)
+  eq  1, (10 >>> 3)
+  num = 10; eq  2, (num &=   3)
+  num = 10; eq 11, (num |=   3)
+  num = 10; eq  9, (num ^=   3)
+  num = 10; eq 80, (num <<=  3)
+  num = 10; eq  1, (num >>=  3)
+  num = 10; eq  1, (num >>>= 3)
+
+test "`instanceof`", ->
+  ok new String instanceof String
+  ok new Boolean instanceof Boolean
+  # `instanceof` supports negation by prefixing the operator with `not`
+  ok new Number not instanceof String
+  ok new Array not instanceof Boolean
+
+test "use `::` operator on keywords `this` and `@`", ->
+  nonce = {}
+  obj =
+    withAt:   -> @::prop
+    withThis: -> this::prop
+  obj.prototype = prop: nonce
+  eq nonce, obj.withAt()
+  eq nonce, obj.withThis()
+
+
+# Existential Operator (Binary)
+
+test "binary existential operator", ->
+  nonce = {}
+
+  b = a ? nonce
+  eq nonce, b
+
+  a = null
+  b = undefined
+  b = a ? nonce
+  eq nonce, b
+
+  a = false
+  b = a ? nonce
+  eq false, b
+
+  a = 0
+  b = a ? nonce
+  eq 0, b
+
+test "binary existential operator conditionally evaluates second operand", ->
+  i = 1
+  func = -> i -= 1
+  result = func() ? func()
+  eq result, 0
+
+test "binary existential operator with negative number", ->
+  a = null ? - 1
+  eq -1, a
+
+
+# Existential Operator (Unary)
+
+test "postfix existential operator", ->
+  ok (if nonexistent? then false else true)
+  defined = true
+  ok defined?
+  defined = false
+  ok defined?
+
+test "postfix existential operator only evaluates its operand once", ->
+  semaphore = 0
+  fn = ->
+    ok false if semaphore
+    ++semaphore
+  ok(if fn()? then true else false)
+
+test "negated postfix existential operator", ->
+  ok !nothing?.value
+
+test "postfix existential operator on expressions", ->
+  eq true, (1 or 0)?, true
+
+
+# `is`,`isnt`,`==`,`!=`
+
+test "`==` and `is` should be interchangeable", ->
+  a = b = 1
+  ok a is 1 and b == 1
+  ok a == b
+  ok a is b
+
+test "`!=` and `isnt` should be interchangeable", ->
+  a = 0
+  b = 1
+  ok a isnt 1 and b != 0
+  ok a != b
+  ok a isnt b
+
+
+# [not] in/of
+
+# - `in` should check if an array contains a value using `indexOf`
+# - `of` should check if a property is defined on an object using `in`
+test "in, of", ->
+  arr = [1]
+  ok 0 of arr
+  ok 1 in arr
+  # prefixing `not` to `in and `of` should negate them
+  ok 1 not of arr
+  ok 0 not in arr
+
+test "`in` should be able to operate on an array literal", ->
+  ok 2 in [0, 1, 2, 3]
+  ok 4 not in [0, 1, 2, 3]
+  arr = [0, 1, 2, 3]
+  ok 2 in arr
+  ok 4 not in arr
+  # should cache the value used to test the array
+  arr = [0]
+  val = 0
+  ok val++ in arr
+  ok val++ not in arr
+  val = 0
+  ok val++ of arr
+  ok val++ not of arr
+
+test "`of` and `in` should be able to operate on instance variables", ->
+  obj = {
+    list: [2,3]
+    in_list: (value) -> value in @list
+    not_in_list: (value) -> value not in @list
+    of_list: (value) -> value of @list
+    not_of_list: (value) -> value not of @list
+  }
+  ok obj.in_list 3
+  ok obj.not_in_list 1
+  ok obj.of_list 0
+  ok obj.not_of_list 2
+
+test "#???: `in` with cache and `__indexOf` should work in argument lists", ->
+  eq 1, [Object() in Array()].length
+
+test "#737: `in` should have higher precedence than logical operators", ->
+  eq 1, 1 in [1] and 1
+
+test "#768: `in` should preserve evaluation order", ->
+  share = 0
+  a = -> share++ if share is 0
+  b = -> share++ if share is 1
+  c = -> share++ if share is 2
+  ok a() not in [b(),c()]
+  eq 3, share
+
+test "#1099: empty array after `in` should compile to `false`", ->
+  eq 1, [5 in []].length
+  eq false, do -> return 0 in []
+
+test "#1354: optimized `in` checks should not happen when splats are present", ->
+  a = [6, 9]
+  eq 9 in [3, a...], true
+
+test "#1100: precedence in or-test compilation of `in`", ->
+  ok 0 in [1 and 0]
+  ok 0 in [1, 1 and 0]
+  ok not (0 in [1, 0 or 1])
+
+test "#1630: `in` should check `hasOwnProperty`", ->
+  ok undefined not in length: 1
+
+test "#1714: lexer bug with raw range `for` followed by `in`", ->
+  0 for [1..2]
+  ok not ('a' in ['b'])
+
+  0 for [1..2]; ok not ('a' in ['b'])
+
+  0 for [1..10] # comment ending
+  ok not ('a' in ['b'])
+
+test "#1099: statically determined `not in []` reporting incorrect result", ->
+  ok 0 not in []
+
+
+# Chained Comparison
+
+test "chainable operators", ->
+  ok 100 > 10 > 1 > 0 > -1
+  ok -1 < 0 < 1 < 10 < 100
+
+test "`is` and `isnt` may be chained", ->
+  ok true is not false is true is not false
+  ok 0 is 0 isnt 1 is 1
+
+test "different comparison operators (`>`,`<`,`is`,etc.) may be combined", ->
+  ok 1 < 2 > 1
+  ok 10 < 20 > 2+3 is 5
+
+test "some chainable operators can be negated by `unless`", ->
+  ok (true unless 0==10!=100)
+
+test "operator precedence: `|` lower than `<`", ->
+  eq 1, 1 | 2 < 3 < 4
+
+test "preserve references", ->
+  a = b = c = 1
+  # `a == b <= c` should become `a === b && b <= c`
+  # (this test does not seem to test for this)
+  ok a == b <= c
+
+test "chained operations should evaluate each value only once", ->
+  a = 0
+  ok 1 > a++ < 1
+
+test "#891: incorrect inversion of chained comparisons", ->
+  ok (true unless 0 > 1 > 2)
+  ok (true unless (NaN = 0/0) < 0/0 < NaN)
+
+test "#1234: Applying a splat to :: applies the splat to the wrong object", ->
+  nonce = {}
+  class C
+    method: -> @nonce
+    nonce: nonce
+
+  arr = []
+  eq nonce, C::method arr... # should be applied to `C::`
+
+test "#1102: String literal prevents line continuation", ->
+  eq "': '", '' +
+     "': '"
+
+test "#1703, ---x is invalid JS", ->
+  x = 2
+  eq (- --x), -1
+
+test "Regression with implicit calls against an indented assignment", ->
+  eq 1, a =
+    1
+
+  eq a, 1
+
+test "#2155 ... conditional assignment to a closure", ->
+  x = null
+  func = -> x ?= (-> if true then 'hi')
+  func()
+  eq x(), 'hi'