spade 0.0.8.1 → 0.1.0

data/packages/coffee-script/src/scope.coffee

@@ -1,94 +0,0 @@
-# The **Scope** class regulates lexical scoping within CoffeeScript. As you
-# generate code, you create a tree of scopes in the same shape as the nested
-# function bodies. Each scope knows about the variables declared within it,
-# and has a reference to its parent enclosing scope. In this way, we know which
-# variables are new and need to be declared with `var`, and which are shared
-# with the outside.
-
-# Import the helpers we plan to use.
-{extend, last} = require './helpers'
-
-exports.Scope = class Scope
-
-  # The top-level **Scope** object.
-  @root: null
-
-  # Initialize a scope with its parent, for lookups up the chain,
-  # as well as a reference to the **Expressions** node is belongs to, which is
-  # where it should declare its variables, and a reference to the function that
-  # it wraps.
-  constructor:(@parent, @expressions, @method) ->
-    @variables = [{name: 'arguments', type: 'arguments'}]
-    @positions = {}
-    Scope.root = this unless @parent
-
-  # Adds a new variable or overrides an existing one.
-  add: (name, type, immediate) ->
-    return @parent.add name, type, immediate if @shared and not immediate
-    if typeof (pos = @positions[name]) is 'number'
-      @variables[pos].type = type
-    else
-      @positions[name] = @variables.push({name, type}) - 1
-
-  # Look up a variable name in lexical scope, and declare it if it does not
-  # already exist.
-  find: (name, options) ->
-    return yes if @check name, options
-    @add name, 'var'
-    no
-
-  # Reserve a variable name as originating from a function parameter for this
-  # scope. No `var` required for internal references.
-  parameter: (name) ->
-    return if @shared and @parent.check name, yes
-    @add name, 'param'
-
-  # Just check to see if a variable has already been declared, without reserving,
-  # walks up to the root scope.
-  check: (name, immediate) ->
-    found = !!@type(name)
-    return found if found or immediate
-    !!@parent?.check name
-
-  # Generate a temporary variable name at the given index.
-  temporary: (name, index) ->
-    if name.length > 1
-      '_' + name + if index > 1 then index else ''
-    else
-      '_' + (index + parseInt name, 36).toString(36).replace /\d/g, 'a'
-
-  # Gets the type of a variable.
-  type: (name) ->
-    return v.type for v in @variables when v.name is name
-    null
-
-  # If we need to store an intermediate result, find an available name for a
-  # compiler-generated variable. `_var`, `_var2`, and so on...
-  freeVariable: (type) ->
-    index = 0
-    index++ while @check((temp = @temporary type, index), true)
-    @add temp, 'var', yes
-    temp
-
-  # Ensure that an assignment is made at the top of this scope
-  # (or at the top-level scope, if requested).
-  assign: (name, value) ->
-    @add name, value: value, assigned: true
-    @hasAssignments = yes
-
-  # Does this scope have any declared variables?
-  hasDeclarations: ->
-    !!@declaredVariables().length
-
-  # Return the list of variables first declared in this scope.
-  declaredVariables: ->
-    realVars = []
-    tempVars = []
-    for v in @variables when v.type is 'var'
-      (if v.name.charAt(0) is '_' then tempVars else realVars).push v.name
-    realVars.sort().concat tempVars.sort()
-
-  # Return the list of assignments that are supposed to be made at the top
-  # of this scope.
-  assignedVariables: ->
-    "#{v.name} = #{v.type.value}" for v in @variables when v.type.assigned

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

@@ -1,127 +0,0 @@
-# Arguments
-# ---------
-
-# shared identity function
-id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
-
-test "basic argument passing tests", ->
-  a = {}
-  b = {}
-  c = {}
-  eq 1, (id 1)
-  eq 2, (id 1, 2)[1]
-  eq a, (id a)
-  eq c, (id a, b, c)[2]
-
-test "passing arguments on separate lines", ->
-  a = {}
-  b = {}
-  c = {}
-  ok(id(
-    a
-    b
-    c
-  )[1] is b)
-  eq(0, id(
-    0
-    10
-  )[0])
-  eq(a,id(
-    a
-  ))
-  eq b,
-  (id b)
-
-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)
-
-
-#### Parameter List Features
-
-test "splats", ->
-  arrayEq [0, 1, 2], (((splat...) -> splat) 0, 1, 2)
-  arrayEq [2, 3], (((_, _, splat...) -> splat) 0, 1, 2, 3)
-  arrayEq [0, 1], (((splat..., _, _) -> splat) 0, 1, 2, 3)
-  arrayEq [2], (((_, _, splat..., _) -> 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 = (_,_,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,_,_) -> 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,_,_) -> 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)

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

@@ -1,98 +0,0 @@
-# Assignment
-# ----------
-
-test "context property assignment (using @)", ->
-  nonce = {}
-  addMethod = ->
-    @method = -> nonce
-    this
-  eq nonce, addMethod.call({}).method()
-
-test "unassignable values", ->
-  nonce = {}
-  for nonref in ['', '""', '0', 'f()'].concat CoffeeScript.RESERVED
-    eq nonce, (try CoffeeScript.compile "#{nonref} = v" catch e then nonce)
-
-test "compound assignments should not declare", ->
-  # TODO: make description more clear
-  # TODO: remove reference to Math
-  eq Math, (-> Math or= 0)()
-
-
-#### Statements as Expressions
-
-test "assign the result of a try/catch block", ->
-  # multiline
-  result = try
-    nonexistent * missing
-  catch error
-    true
-  eq true, result
-
-  # single line
-  result = try nonexistent * missing catch error then true
-  eq true, result
-
-test "conditionals", ->
-  # assign inside the condition of a conditional statement
-  nonce = {}
-  if a = nonce then 1
-  eq nonce, a
-  1 if b = nonce
-  eq nonce, b
-
-  # assign the result of a conditional statement
-  c = if true then nonce
-  eq nonce, c
-
-test "assign inside the condition of a `while` loop", ->
-  nonce = {}
-  count = 1
-  a = nonce while count--
-  eq nonce, a
-  count = 1
-  while count--
-    b = nonce
-  eq nonce, b
-
-
-#### Compound Assignment
-
-test "compound assignment (math operators)", ->
-  num = 10
-  num -= 5
-  eq 5, num
-
-  num *= 10
-  eq 50, num
-
-  num /= 10
-  eq 5, num
-
-  num %= 3
-  eq 2, num
-
-test "more compound assignment", ->
-  a = {}
-  val = undefined
-  val ||= a
-  val ||= true
-  eq a, val
-
-  b = {}
-  val &&= true
-  eq val, true
-  val &&= b
-  eq b, val
-
-  c = {}
-  val = null
-  val ?= c
-  val ?= true
-  eq c, val
-
-
-#### Destructuring Assignment
-
-# NO TESTS?!
-# TODO: make tests for destructuring assignment

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

@@ -1,18 +0,0 @@
-# Break
-# -----
-
-test "break at the top level", ->
-  for i in [1,2,3]
-    result = i
-    if i == 2
-      break
-  eq 2, result
-
-test "break *not* at the top level", ->
-  someFunc = () ->
-    i = 0
-    while ++i < 3
-      result = i
-      break if i > 1
-    result
-  eq 2, someFunc()

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

@@ -1,201 +0,0 @@
-# Comments
-# --------
-
-# Note: awkward spacing seen in some tests is likely intentional.
-
-test "comments in objects", ->
-  obj1 = {
-  # comment
-    # comment
-      # comment
-    one: 1
-  # comment
-    two: 2
-      # comment
-  }
-
-  ok Object::hasOwnProperty.call(obj1,'one')
-  eq obj1.one, 1
-  ok Object::hasOwnProperty.call(obj1,'two')
-  eq obj1.two, 2
-
-test "comments in YAML-style objects", ->
-  obj2 =
-  # comment
-    # comment
-      # comment
-    three: 3
-  # comment
-    four: 4
-      # comment
-
-  ok Object::hasOwnProperty.call(obj2,'three')
-  eq obj2.three, 3
-  ok Object::hasOwnProperty.call(obj2,'four')
-  eq obj2.four, 4
-
-test "comments following operators that continue lines", ->
-  sum =
-    1 +
-    1 + # comment
-    1
-  eq 3, sum
-
-test "comments in functions", ->
-  fn = ->
-  # comment
-    false
-    false   # comment
-    false
-    # comment
-
-  # comment
-    true
-
-  ok fn()
-
-  fn2 = -> #comment
-    fn()
-    # comment
-
-  ok fn2()
-
-test "trailing comment before an outdent", ->
-  nonce = {}
-  fn3 = ->
-    if true
-      undefined # comment
-    nonce
-
-  eq nonce, fn3()
-
-test "comments in a switch", ->
-  nonce = {}
-  result = switch nonce #comment
-    # comment
-    when false then undefined
-    # comment
-    when null #comment
-      undefined
-    else nonce # comment
-
-  eq nonce, result
-
-test "comment with conditional statements", ->
-  nonce = {}
-  result = if false # comment
-    undefined
-  #comment
-  else # comment
-    nonce
-    # comment
-  eq nonce, result
-
-test "spaced comments with conditional statements", ->
-  nonce = {}
-  result = if false
-    undefined
-
-  # comment
-  else if false
-    undefined
-
-  # comment
-  else
-    nonce
-
-  eq nonce, result
-
-
-#### Block Comments
-
-###
-  This is a here-comment.
-  Kind of like a heredoc.
-###
-
-test "block comments in objects", ->
-  a = {}
-  b = {}
-  obj = {
-    a: a
-    ###
-    comment
-    ###
-    b: b
-  }
-
-  eq a, obj.a
-  eq b, obj.b
-
-test "block comments in YAML-style", ->
-  a = {}
-  b = {}
-  obj =
-    a: a
-    ###
-    comment
-    ###
-    b: b
-
-  eq a, obj.a
-  eq b, obj.b
-
-
-test "block comments in functions", ->
-  nonce = {}
-
-  fn1 = ->
-    true
-    ###
-    false
-    ###
-
-  ok fn1()
-
-  fn2 =  ->
-    ###
-    block comment
-    ###
-    nonce
-
-  eq nonce, fn2()
-
-  fn3 = ->
-    nonce
-  ###
-  block comment
-  ###
-
-  eq nonce, fn3()
-
-  fn4 = ->
-    one = ->
-      ###
-        block comment
-      ###
-      two = ->
-        three = ->
-          nonce
-
-  eq nonce, fn4()()()()
-
-test "block comments inside class bodies", ->
-  class A
-    a: ->
-
-    ###
-    Comment
-    ###
-    b: ->
-
-  ok A.prototype.b instanceof Function
-
-  class B
-    ###
-    Comment
-    ###
-    a: ->
-    b: ->
-
-  ok B.prototype.a instanceof Function