spade-packager 0.1.0

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

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

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

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

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

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