coffee-script 0.1.6 → 0.2.0

data/lib/coffee-script.rb

@@ -4,12 +4,13 @@ require "coffee_script/parser"
 require "coffee_script/nodes"
 require "coffee_script/value"
 require "coffee_script/scope"
+require "coffee_script/rewriter"
 require "coffee_script/parse_error"
 
 # Namespace for all CoffeeScript internal classes.
 module CoffeeScript
 
-  VERSION = '0.1.6'   # Keep in sync with the gemspec.
+  VERSION = '0.2.0'   # Keep in sync with the gemspec.
 
   # Compile a script (String or IO) to JavaScript.
   def self.compile(script, options={})

data/lib/coffee_script/CoffeeScript.tmbundle/Syntaxes/CoffeeScript.tmLanguage

@@ -39,7 +39,7 @@
 			<key>comment</key>
 			<string>match stuff like: funcName: =&gt; … </string>
 			<key>match</key>
-			<string>([a-zA-Z_?.$]*)\s*(=|:)\s*([\w,\s]*?)\s*(=&gt;)</string>
+			<string>([a-zA-Z0-9_?.$*]*)\s*(=|:)\s*([\w,\s]*?)\s*(=&gt;)</string>
 			<key>name</key>
 			<string>meta.function.coffee</string>
 		</dict>
@@ -60,7 +60,7 @@
 			<key>comment</key>
 			<string>match stuff like: a =&gt; … </string>
 			<key>match</key>
-			<string>([a-zA-Z_?., $]*)\s*(=&gt;)</string>
+			<string>([a-zA-Z0-9_?., $*]*)\s*(=&gt;)</string>
 			<key>name</key>
 			<string>meta.inline.function.coffee</string>
 		</dict>
@@ -204,10 +204,29 @@
 		</dict>
 		<dict>
 			<key>match</key>
-			<string>\b(break|when|catch|continue|else|finally|for|if|return|switch|then|throw|try|unless|while)\b</string>
+			<string>\b(break|by|catch|continue|else|finally|for|if|return|switch|then|throw|try|unless|when|while)\b</string>
 			<key>name</key>
 			<string>keyword.control.coffee</string>
 		</dict>
+		<dict>
+			<key>match</key>
+			<string>\b([a-zA-Z$_]\w*)(\:)\s</string>
+			<key>name</key>
+			<string>variable.assignment.coffee</string>
+			<key>captures</key>
+			<dict>
+				<key>1</key>
+				<dict>
+					<key>name</key>
+					<string>entity.name.function.coffee</string>
+				</dict>
+				<key>2</key>
+				<dict>
+					<key>name</key>
+					<string>keyword.operator.coffee</string>
+				</dict>
+			</dict>
+		</dict>
 		<dict>
 			<key>match</key>
 			<string>\b(true|on|yes)\b</string>
@@ -240,7 +259,7 @@
 		</dict>
 		<dict>
 			<key>match</key>
-			<string>!|\$|%|&amp;|\*|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|&lt;=|&gt;=|&lt;&lt;=|&gt;&gt;=|&gt;&gt;&gt;=|&lt;&gt;|&lt;|&gt;|!|&amp;&amp;|\?|\|\||\:|\*=|(?&lt;!\()/=|%=|\+=|\-=|&amp;=|\^=|\b(in|instanceof|new|delete|typeof|and|or|is|isnt|not)\b</string>
+			<string>!|\$|%|&amp;|\*|\/|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|&lt;=|&gt;=|&lt;&lt;=|&gt;&gt;=|&gt;&gt;&gt;=|&lt;&gt;|&lt;|&gt;|!|&amp;&amp;|\?|\|\||\:|\*=|(?&lt;!\()/=|%=|\+=|\-=|&amp;=|\^=|\b(in|instanceof|new|delete|typeof|and|or|is|isnt|not)\b</string>
 			<key>name</key>
 			<string>keyword.operator.coffee</string>
 		</dict>

data/lib/coffee_script/command_line.rb

@@ -19,8 +19,9 @@ Usage:
     # Seconds to pause between checks for changed source files.
     WATCH_INTERVAL = 0.5
 
-    # Path to the Narwhal Launcher:
-    LAUNCHER = File.expand_path(File.dirname(__FILE__)) + '/narwhal/js/launcher.js'
+    # Command to execute in Narwhal
+    PACKAGE = File.expand_path(File.dirname(__FILE__) + '/../..')
+    LAUNCHER = "narwhal -p #{PACKAGE} -e 'require(\"coffee-script\").run(system.args);'"
 
     # Run the CommandLine off the contents of ARGV.
     def initialize
@@ -107,7 +108,7 @@ Usage:
 
     # Use Narwhal to run an interactive CoffeeScript session.
     def launch_repl
-      exec "narwhal #{LAUNCHER}"
+      exec "#{LAUNCHER}"
     rescue Errno::ENOENT
       puts "Error: Narwhal must be installed to use the interactive REPL."
       exit(1)
@@ -116,7 +117,7 @@ Usage:
     # Use Narwhal to compile and execute CoffeeScripts.
     def run_scripts
       sources = @sources.join(' ')
-      exec "narwhal #{LAUNCHER} #{sources}"
+      exec "#{LAUNCHER} #{sources}"
     rescue Errno::ENOENT
       puts "Error: Narwhal must be installed in order to execute CoffeeScripts."
       exit(1)

data/lib/coffee_script/grammar.y

@@ -1,24 +1,26 @@
 class Parser
 
 # Declare tokens produced by the lexer
-token IF ELSE THEN UNLESS
+token IF ELSE UNLESS
 token NUMBER STRING REGEX
 token TRUE FALSE YES NO ON OFF
 token IDENTIFIER PROPERTY_ACCESS
-token CODE PARAM NEW RETURN
+token CODE PARAM PARAM_SPLAT NEW RETURN
 token TRY CATCH FINALLY THROW
 token BREAK CONTINUE
-token FOR IN WHILE
-token SWITCH WHEN
+token FOR IN BY WHEN WHILE
+token SWITCH LEADING_WHEN
 token DELETE INSTANCEOF TYPEOF
 token SUPER EXTENDS
 token NEWLINE
 token COMMENT
 token JS
+token INDENT OUTDENT
 
 # Declare order of operations.
 prechigh
-  nonassoc UMINUS NOT '!' '!!' '~' '++' '--'
+  left     '?'
+  nonassoc UMINUS PARAM_SPLAT SPLAT NOT '!' '!!' '~' '++' '--'
   left     '*' '/' '%'
   left     '+' '-'
   left     '<<' '>>' '>>>'
@@ -29,51 +31,40 @@ prechigh
   right    '-=' '+=' '/=' '*=' '%='
   right    DELETE INSTANCEOF TYPEOF
   left     '.'
-  right    THROW FOR IN WHILE NEW SUPER
-  left     UNLESS IF ELSE EXTENDS
+  right    INDENT
+  left     OUTDENT
+  right    WHEN LEADING_WHEN IN BY
+  right    THROW FOR NEW SUPER
+  left     EXTENDS
   left     ASSIGN '||=' '&&='
-  right    RETURN
+  right    RETURN '=>' UNLESS IF ELSE WHILE
 preclow
 
-# We expect 3 shift/reduce errors for optional syntax.
-# There used to be 252 -- greatly improved.
-expect 3
-
 rule
 
   # All parsing will end in this rule, being the trunk of the AST.
   Root:
-    /* nothing */                     { result = Expressions.new([]) }
-  | Terminator                        { result = Expressions.new([]) }
+    /* nothing */                     { result = Expressions.new }
+  | Terminator                        { result = Expressions.new }
   | Expressions                       { result = val[0] }
+  | Block Terminator                  { result = val[0] }
   ;
 
   # Any list of expressions or method body, seperated by line breaks or semis.
   Expressions:
-    Expression                        { result = Expressions.new(val) }
+    Expression                        { result = Expressions.wrap(val) }
   | Expressions Terminator Expression { result = val[0] << val[2] }
   | Expressions Terminator            { result = val[0] }
-  | Terminator Expressions            { result = val[1] }
   ;
 
   # All types of expressions in our language.
   Expression:
-    PureExpression
-  | Statement
-  ;
-
-  # The parts that are natural JavaScript expressions.
-  PureExpression:
     Value
   | Call
   | Code
   | Operation
   | Range
-  ;
-
-  # We have to take extra care to convert these statements into expressions.
-  Statement:
-    Assign
+  | Assign
   | If
   | Try
   | Throw
@@ -82,21 +73,22 @@ rule
   | For
   | Switch
   | Extends
+  | Splat
+  | Existence
   | Comment
   ;
 
+  Block:
+    INDENT Expressions OUTDENT        { result = val[1] }
+  | INDENT OUTDENT                    { result = Expressions.new }
+  ;
+
   # All tokens that can terminate an expression.
   Terminator:
     "\n"
   | ";"
   ;
 
-  # All tokens that can serve to begin the second block of a multi-part expression.
-  Then:
-    THEN
-  | Terminator
-  ;
-
   # All hard-coded values.
   Literal:
     NUMBER                            { result = LiteralNode.new(val[0]) }
@@ -115,13 +107,13 @@ rule
 
   # Assignment to a variable.
   Assign:
-    Value ASSIGN Expression         { result = AssignNode.new(val[0], val[2]) }
+    Value ASSIGN Expression           { result = AssignNode.new(val[0], val[2]) }
   ;
 
   # Assignment within an object literal.
   AssignObj:
-    IDENTIFIER ASSIGN Expression    { result = AssignNode.new(ValueNode.new(val[0]), val[2], :object) }
-  | STRING ASSIGN Expression        { result = AssignNode.new(ValueNode.new(LiteralNode.new(val[0])), val[2], :object) }
+    IDENTIFIER ASSIGN Expression      { result = AssignNode.new(ValueNode.new(val[0]), val[2], :object) }
+  | STRING ASSIGN Expression          { result = AssignNode.new(ValueNode.new(LiteralNode.new(val[0])), val[2], :object) }
   | Comment                           { result = val[0] }
   ;
 
@@ -146,6 +138,8 @@ rule
   | '~' Expression                    { result = OpNode.new(val[0], val[1]) }
   | '--' Expression                   { result = OpNode.new(val[0], val[1]) }
   | '++' Expression                   { result = OpNode.new(val[0], val[1]) }
+  | DELETE Expression                 { result = OpNode.new(val[0], val[1]) }
+  | TYPEOF Expression                 { result = OpNode.new(val[0], val[1]) }
   | Expression '--'                   { result = OpNode.new(val[1], val[0], nil, true) }
   | Expression '++'                   { result = OpNode.new(val[1], val[0], nil, true) }
 
@@ -187,27 +181,32 @@ rule
   | Expression '||=' Expression       { result = OpNode.new(val[1], val[0], val[2]) }
   | Expression '&&=' Expression       { result = OpNode.new(val[1], val[0], val[2]) }
 
-  | DELETE Expression                 { result = OpNode.new(val[0], val[1]) }
-  | TYPEOF Expression                 { result = OpNode.new(val[0], val[1]) }
   | Expression INSTANCEOF Expression  { result = OpNode.new(val[1], val[0], val[2]) }
   ;
 
-  # Function definition.
-  Code:
-    ParamList "=>" CodeBody "."       { result = CodeNode.new(val[0], val[2]) }
-  | "=>" CodeBody "."                 { result = CodeNode.new([], val[1]) }
+  Existence:
+    Expression '?'                    { result = ExistenceNode.new(val[0]) }
   ;
 
-  # The body of a function.
-  CodeBody:
-    /* nothing */                     { result = Expressions.new([]) }
-  | Expressions                       { result = val[0] }
+  # Function definition.
+  Code:
+    ParamList "=>" Block              { result = CodeNode.new(val[0], val[2]) }
+  | "=>" Block                        { result = CodeNode.new([], val[1]) }
   ;
 
   # The parameters to a function definition.
   ParamList:
-    PARAM                             { result = val }
-  | ParamList "," PARAM               { result = val[0] << val[2] }
+    Param                             { result = val }
+  | ParamList "," Param               { result = val[0] << val[2] }
+  ;
+
+  Param:
+    PARAM
+  | PARAM_SPLAT PARAM                 { result = ParamSplatNode.new(val[1]) }
+  ;
+
+  Splat:
+    '*' Value = SPLAT                 { result = ArgSplatNode.new(val[1]) }
   ;
 
   # Expressions that can be treated as values.
@@ -240,10 +239,13 @@ rule
 
   # Assignment within an object literal (comma or newline separated).
   AssignList:
-    /* nothing */                     { result = []}
+    /* nothing */                     { result = [] }
   | AssignObj                         { result = val }
   | AssignList "," AssignObj          { result = val[0] << val[2] }
   | AssignList Terminator AssignObj   { result = val[0] << val[2] }
+  | AssignList ","
+      Terminator AssignObj            { result = val[0] << val[3] }
+  | INDENT AssignList OUTDENT         { result = val[1] }
   ;
 
   # All flavors of function call (instantiation, super, and regular).
@@ -260,8 +262,14 @@ rule
 
   # A generic function invocation.
   Invocation:
-    Value "(" ArgList ")"             { result = CallNode.new(val[0], val[2]) }
-  | Invocation "(" ArgList ")"        { result = CallNode.new(val[0], val[2]) }
+    Value Arguments                   { result = CallNode.new(val[0], val[1]) }
+  | Invocation Arguments              { result = CallNode.new(val[0], val[1]) }
+  # | Invocation Code                   { result = val[0] << val[1] }
+  ;
+
+  Arguments:
+    "(" ArgList ")"                   { result = val[1] }
+  | "(" ArgList ")" Code              { result = val[1] << val[3] }
   ;
 
   # Calling super.
@@ -271,8 +279,10 @@ rule
 
   # The range literal.
   Range:
-    "[" Value "." "." Value "]"       { result = RangeNode.new(val[1], val[4]) }
-  | "[" Value "." "." "." Value "]"   { result = RangeNode.new(val[1], val[5], true) }
+    "[" Expression
+      "." "." Expression "]"          { result = RangeNode.new(val[1], val[4]) }
+  | "[" Expression
+      "." "." "." Expression "]"      { result = RangeNode.new(val[1], val[5], true) }
   ;
 
   # The array literal.
@@ -284,21 +294,25 @@ rule
   ArgList:
     /* nothing */                     { result = [] }
   | Expression                        { result = val }
+  | INDENT Expression                 { result = [val[1]] }
   | ArgList "," Expression            { result = val[0] << val[2] }
   | ArgList Terminator Expression     { result = val[0] << val[2] }
+  | ArgList "," Terminator Expression { result = val[0] << val[3] }
+  | ArgList "," INDENT Expression     { result = val[0] << val[3] }
+  | ArgList OUTDENT                   { result = val[0] }
   ;
 
   # Try/catch/finally exception handling blocks.
   Try:
-    TRY Expressions Catch "."         { result = TryNode.new(val[1], val[2][0], val[2][1]) }
-  | TRY Expressions Catch
-    FINALLY Expressions "."           { result = TryNode.new(val[1], val[2][0], val[2][1], val[4]) }
+    TRY Block Catch                   { result = TryNode.new(val[1], val[2][0], val[2][1]) }
+  | TRY Block FINALLY Block           { result = TryNode.new(val[1], nil, nil, val[3]) }
+  | TRY Block Catch
+      FINALLY Block                   { result = TryNode.new(val[1], val[2][0], val[2][1], val[4]) }
   ;
 
   # A catch clause.
   Catch:
-    /* nothing */                     { result = [nil, nil] }
-  | CATCH IDENTIFIER Expressions      { result = [val[1], val[2]] }
+    CATCH IDENTIFIER Block            { result = [val[1], val[2]] }
   ;
 
   # Throw an exception.
@@ -308,20 +322,20 @@ rule
 
   # Parenthetical expressions.
   Parenthetical:
-    "(" Expressions ")"               { result = ParentheticalNode.new(val[1]) }
+    "(" Expression ")"                { result = ParentheticalNode.new(val[1], val[0].line) }
   ;
 
   # The while loop. (there is no do..while).
   While:
-    WHILE Expression Then
-      Expressions "."                 { result = WhileNode.new(val[1], val[3]) }
+    WHILE Expression Block            { result = WhileNode.new(val[1], val[2]) }
   ;
 
   # Array comprehensions, including guard and current index.
   # Looks a little confusing, check nodes.rb for the arguments to ForNode.
   For:
     Expression FOR
-      ForVariables ForSource          { result = ForNode.new(val[0], val[3][0], val[2][0], val[3][1], val[2][1]) }
+      ForVariables ForSource          { result = ForNode.new(val[0], val[3], val[2][0], val[2][1]) }
+  | FOR ForVariables ForSource Block  { result = ForNode.new(val[3], val[2], val[1][0], val[1][1]) }
   ;
 
   # An array comprehension has variables for the current element and index.
@@ -332,17 +346,19 @@ rule
 
   # The source of the array comprehension can optionally be filtered.
   ForSource:
-    IN PureExpression "."             { result = [val[1]] }
-  | IN PureExpression
-    IF Expression "."                 { result = [val[1], val[3]] }
+    IN Expression                     { result = {:source => val[1]} }
+  | ForSource
+    WHEN Expression                   { result = val[0].merge(:filter => val[2]) }
+  | ForSource
+    BY Expression                     { result = val[0].merge(:step => val[2]) }
   ;
 
   # Switch/When blocks.
   Switch:
-    SWITCH Expression Then
-      Whens "."                       { result = val[3].rewrite_condition(val[1]) }
-  | SWITCH Expression Then
-      Whens ELSE Expressions "."      { result = val[3].rewrite_condition(val[1]).add_else(val[5]) }
+    SWITCH Expression INDENT
+      Whens OUTDENT                   { result = val[3].rewrite_condition(val[1]) }
+  | SWITCH Expression INDENT
+      Whens ELSE Block OUTDENT        { result = val[3].rewrite_condition(val[1]).add_else(val[5]) }
   ;
 
   # The inner list of whens.
@@ -353,16 +369,22 @@ rule
 
   # An individual when.
   When:
-    WHEN Expression Then Expressions  { result = IfNode.new(val[1], val[3]) }
+    LEADING_WHEN Expression Block     { result = IfNode.new(val[1], val[2], nil, {:statement => true}) }
+  | LEADING_WHEN Expression Block
+      Terminator                      { result = IfNode.new(val[1], val[2], nil, {:statement => true}) }
+  | Comment
   ;
 
   # All of the following nutso if-else destructuring is to make the
   # grammar expand unambiguously.
 
+  IfBlock:
+    IF Expression Block               { result = IfNode.new(val[1], val[2]) }
+  ;
+
   # An elsif portion of an if-else block.
   ElsIf:
-    ELSE IF Expression
-      Then Expressions                { result = IfNode.new(val[2], val[4]) }
+    ELSE IfBlock                      { result = val[1].force_statement }
   ;
 
   # Multiple elsifs can be chained together.
@@ -373,8 +395,8 @@ rule
 
   # Terminating else bodies are strictly optional.
   ElseBody
-    "."                               { result = nil }
-  | ELSE Expressions "."              { result = val[1] }
+    /* nothing */                     { result = nil }
+  | ELSE Block                        { result = val[1] }
   ;
 
   # All the alternatives for ending an if-else block.
@@ -385,10 +407,9 @@ rule
 
   # The full complement of if blocks, including postfix one-liner ifs and unlesses.
   If:
-    IF Expression
-      Then Expressions IfEnd          { result = IfNode.new(val[1], val[3], val[4]) }
-  | Expression IF Expression          { result = IfNode.new(val[2], Expressions.new([val[0]]), nil, {:statement => true}) }
-  | Expression UNLESS Expression      { result = IfNode.new(val[2], Expressions.new([val[0]]), nil, {:statement => true, :invert => true}) }
+    IfBlock IfEnd                     { result = val[0].add_else(val[1]) }
+  | Expression IF Expression          { result = IfNode.new(val[2], Expressions.wrap(val[0]), nil, {:statement => true}) }
+  | Expression UNLESS Expression      { result = IfNode.new(val[2], Expressions.wrap(val[0]), nil, {:statement => true, :invert => true}) }
   ;
 
 end