coffeescript 0.1.5, just for kicks

.gitignore

@@ -1,6 +1,2 @@
-presentation
-test.coffee
 parser.output
-lib/coffee_script/parser.rb
-test/fixtures/underscore
 *.gem

README

@@ -36,6 +36,3 @@
 
   The source repository:
   git://github.com/jashkenas/coffee-script.git
-  
-  To build CoffeeScript from source, install the "racc" gem and
-  run "rake build:parser". Then bin/coffee will work.

Rakefile

@@ -19,19 +19,7 @@ namespace :build do
 
   desc "Compile the Narwhal interface for --interactive and --run"
   task :narwhal do
-    sh "bin/coffee lib/coffee_script/narwhal/*.coffee -o lib/coffee_script/narwhal/lib/coffee-script"
-    sh "mv lib/coffee_script/narwhal/lib/coffee-script/coffee-script.js lib/coffee_script/narwhal/lib/coffee-script.js"
-  end
-
-  desc "Compile and install the Ultraviolet syntax highlighter"
-  task :ultraviolet do
-    sh "plist2syntax lib/coffee_script/CoffeeScript.tmbundle/Syntaxes/CoffeeScript.tmLanguage"
-    sh "sudo mv coffeescript.yaml /usr/local/lib/ruby/gems/1.8/gems/ultraviolet-0.10.2/syntax/coffeescript.syntax"
-  end
-
-  desc "Rebuild the Underscore.coffee documentation page"
-  task :underscore do
-    sh "uv -s coffeescript -t idle -h examples/underscore.coffee > documentation/underscore.html"
+    sh "bin/coffee lib/coffee_script/narwhal/*.coffee -o lib/coffee_script/narwhal/js"
   end
 
 end
@@ -42,7 +30,6 @@ task :doc do
   child = fork { exec "bin/coffee documentation/coffee/*.coffee -o documentation/js -w" }
   at_exit { Process.kill("INT", child) }
   Signal.trap("INT") { exit }
-  # `uv -t idle -s coffeescript -h examples/underscore.coffee > documentation/underscore.html`
   loop do
     mtime = File.stat(source).mtime
     if !@mtime || mtime > @mtime

coffee-script.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name      = 'coffee-script'
-  s.version   = '0.2.2'         # Keep version in sync with coffee-script.rb
-  s.date      = '2010-1-10'
+  s.version   = '0.1.5'         # Keep version in sync with coffee-script.rb
+  s.date      = '2009-12-26'
 
   s.homepage    = "http://jashkenas.github.com/coffee-script/"
   s.summary     = "The CoffeeScript Compiler"
@@ -22,5 +22,5 @@ Gem::Specification.new do |s|
   s.require_paths     = ['lib']
   s.executables       = ['coffee']
 
-  s.files = Dir['bin/*', 'examples/*', 'lib/**/*', 'coffee-script.gemspec', 'LICENSE', 'README', 'package.json']
+  s.files = Dir['bin/*', 'examples/*', 'lib/**/*', 'coffee-script.gemspec', 'LICENSE', 'README']
 end

documentation/coffee/aliases.coffee

@@ -4,4 +4,4 @@ volume: 10 if band isnt spinal_tap
 
 let_the_wild_rumpus_begin() unless answer is no
 
-if car.speed < speed_limit then accelerate()
+if car.speed < speed_limit then accelerate().

documentation/coffee/arguments.coffee

@@ -1,4 +0,0 @@
-backwards: =>
-  alert(arguments.reverse())
-
-backwards("stairway", "to", "heaven")

documentation/coffee/array_comprehensions.coffee

@@ -1,7 +1,5 @@
 # Eat lunch.
-lunch: eat(food) for food in ['toast', 'cheese', 'wine']
+lunch: food.eat() for food in ['toast', 'cheese', 'wine'].
 
-# Naive collision detection.
-for roid in asteroids
-  for roid2 in asteroids when roid isnt roid2
-    roid.explode() if roid.overlaps(roid2)
+# Zebra-stripe a table.
+highlight(row) for row, i in table if i % 2 is 0.

documentation/coffee/blocks.coffee

@@ -1,4 +0,0 @@
-$('table.list').each() table =>
-  $('tr.account', table).each() row =>
-    row.show()
-    row.highlight()

documentation/coffee/conditionals.coffee

@@ -2,8 +2,8 @@ mood: greatly_improved if singing
 
 if happy and knows_it
   claps_hands()
-  cha_cha_cha()
+  cha_cha_cha().
 
-date: if friday then sue else jill
+date: if friday then sue else jill.
 
 expensive ||= do_the_math()

documentation/coffee/existence.coffee

@@ -1 +0,0 @@
-solipsism: true if mind? and not world?

documentation/coffee/expressions.coffee

@@ -2,8 +2,8 @@ grade: student =>
   if student.excellent_work
     "A+"
   else if student.okay_stuff
-    if student.tried_hard then "B" else "B-"
+    if student.tried_hard then "B" else "B-".
   else
-    "C"
+    "C"..
 
-eldest: if 24 > 21 then "Liz" else "Ike"
+eldest: if 24 > 21 then "Liz" else "Ike".

documentation/coffee/expressions_comprehension.coffee

@@ -1,3 +0,0 @@
-# The first ten global properties.
-
-globals: (name for name ino window)[0...10]

documentation/coffee/expressions_try.coffee

@@ -1,6 +0,0 @@
-alert(
-  try
-    nonexistent / undefined
-  catch error
-    "Caught an error: " + error
-)

documentation/coffee/functions.coffee

@@ -1,2 +1,2 @@
-square: x => x * x
-cube:   x => square(x) * x
+square: x => x * x.
+cube:   x => square(x) * x.

documentation/coffee/object_comprehensions.coffee

@@ -1,3 +0,0 @@
-years_old: {max: 10, ida: 9, tim: 11}
-
-ages: child + " is " + age for child, age ino years_old

documentation/coffee/objects_and_arrays.coffee

@@ -1,13 +1,6 @@
 song: ["do", "re", "mi", "fa", "so"]
-
 ages: {
   max: 10
   ida: 9
   tim: 11
-}
-
-matrix: [
-  1, 0, 1
-  0, 0, 1
-  1, 1, 0
-]
+}

documentation/coffee/overview.coffee

@@ -6,7 +6,7 @@ opposite_day: true
 number: -42 if opposite_day
 
 # Functions:
-square: x => x * x
+square: x => x * x.
 
 # Arrays:
 list: [1, 2, 3, 4, 5]
@@ -15,15 +15,8 @@ list: [1, 2, 3, 4, 5]
 math: {
   root:   Math.sqrt
   square: square
-  cube:   x => x * square(x)
+  cube:   x => x * square(x).
 }
 
-# Splats:
-race: winner, runners... =>
-  print(winner, runners)
-
-# Existence:
-alert("I knew it!") if elvis?
-
 # Array comprehensions:
-cubed_list: math.cube(num) for num in list
+cubed_list: math.cube(num) for num in list.

documentation/coffee/range_comprehensions.coffee

@@ -1,6 +0,0 @@
-countdown: num for num in [10..1]
-
-egg_delivery: =>
-  for i in [0...eggs.length] by 12
-    dozen_eggs: eggs[i...i+12]
-    deliver(new egg_carton(dozen))

documentation/coffee/scope.coffee

@@ -1,5 +1,5 @@
 num: 1
 change_numbers: =>
-  new_num: -1
-  num: 10
+  num: 2
+  new_num: 3.
 new_num: change_numbers()

documentation/coffee/splats.coffee

@@ -1,25 +0,0 @@
-gold: silver: the_field: "unknown"
-
-medalists: first, second, rest... =>
-  gold:       first
-  silver:     second
-  the_field:  rest
-
-contenders: [
-  "Michael Phelps"
-  "Liu Xiang"
-  "Yao Ming"
-  "Allyson Felix"
-  "Shawn Johnson"
-  "Roman Sebrle"
-  "Guo Jingjing"
-  "Tyson Gay"
-  "Asafa Powell"
-  "Usain Bolt"
-]
-
-medalists(contenders...)
-
-alert("Gold: " + gold)
-alert("Silver: " + silver)
-alert("The Field: " + the_field)

documentation/coffee/splices.coffee

@@ -1,5 +0,0 @@
-numbers: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-numbers[3..6]: [-3, -4, -5, -6]
-
-

documentation/coffee/super.coffee

@@ -1,18 +1,18 @@
-Animal: =>
-Animal::move: meters =>
-  alert(this.name + " moved " + meters + "m.")
+Animal: => .
+Animal.prototype.move: meters =>
+  alert(this.name + " moved " + meters + "m.").
 
-Snake: name => this.name: name
+Snake: name => this.name: name.
 Snake extends Animal
-Snake::move: =>
+Snake.prototype.move: =>
   alert("Slithering...")
-  super(5)
+  super(5).
 
-Horse: name => this.name: name
+Horse: name => this.name: name.
 Horse extends Animal
-Horse::move: =>
+Horse.prototype.move: =>
   alert("Galloping...")
-  super(45)
+  super(45).
 
 sam: new Snake("Sammy the Python")
 tom: new Horse("Tommy the Palomino")

documentation/coffee/switch.coffee

@@ -1,9 +1,9 @@
 switch day
-  when "Tuesday"   then eat_breakfast()
-  when "Wednesday" then go_to_the_park()
-  when "Saturday"
-    if day is bingo_day
-      go_to_bingo()
-      go_dancing()
-  when "Sunday"    then go_to_church()
-  else go_to_work()
+when "Tuesday"   then eat_breakfast()
+when "Wednesday" then go_to_the_park()
+when "Saturday"
+  if day is bingo_day
+    go_to_bingo()
+    go_dancing().
+when "Sunday"    then go_to_church()
+else go_to_work().

documentation/coffee/try.coffee

@@ -4,4 +4,4 @@ try
 catch error
   print(error)
 finally
-  clean_up()
+  clean_up().

documentation/coffee/while.coffee

@@ -1,5 +1,5 @@
 while demand > supply
   sell()
-  restock()
+  restock().
 
-while supply > demand then buy()
+while supply > demand then buy().

documentation/index.html.erb

@@ -40,8 +40,8 @@
     <p>
       <b>Disclaimer:</b>
       CoffeeScript is just for fun and seriously alpha. I'm sure that there are still
-      plenty of holes in the walls and leaks in the roof. <i>There are no guarantees
-      that the syntax won't change between versions.</i> That said,
+      plenty of holes in the lexer and leaks in the syntax. <i>There is no guarantee,
+      explicit or implied, of its suitability for any purpose.</i> That said,
       it compiles into clean JavaScript (the good parts) that can use existing
       JavaScript libraries seamlessly, and passes through
       <a href="http://www.jslint.com/">JSLint</a> without warnings. The compiled
@@ -49,32 +49,23 @@
       preserved intact.
     </p>
 
-    <p>
-      <b>Latest Version:</b>
-      <a href="http://gemcutter.org/gems/coffee-script">0.2.2</a>
-    </p>
-
     <h2>Table of Contents</h2>
 
     <p>
       <a href="#overview">Mini Overview</a><br />
       <a href="#installation">Installation and Usage</a><br />
-      <a href="#whitespace">Significant Whitespace</a><br />
+      <a href="#punctuation">Punctuation Primer</a><br />
       <a href="#functions">Functions and Invocation</a><br />
       <a href="#assignment">Assignment</a><br />
       <a href="#objects_and_arrays">Objects and Arrays</a><br />
       <a href="#lexical_scope">Lexical Scoping and Variable Safety</a><br />
       <a href="#conditionals">Conditionals, Ternaries, and Conditional Assignment</a><br />
-      <a href="#existence">The Existence Operator</a><br />
-      <a href="#aliases">Aliases</a><br />
-      <a href="#splats">Splats...</a><br />
-      <a href="#arguments">Arguments are Arrays</a><br />
-      <a href="#while">While Loops</a><br />
-      <a href="#comprehensions">Comprehensions (Arrays, Objects, and Ranges)</a><br />
-      <a href="#slice_splice">Array Slicing and Splicing with Ranges</a><br />
       <a href="#expressions">Everything is an Expression</a><br />
+      <a href="#aliases">Aliases</a><br />
+      <a href="#while">While Loops</a><br />
+      <a href="#array_comprehensions">Array Comprehensions</a><br />
+      <a href="#slice">Slicing Arrays with Ranges</a><br />
       <a href="#inheritance">Inheritance, and Calling Super from a Subclass</a><br />
-      <a href="#blocks">Blocks</a><br />
       <a href="#embedded">Embedded JavaScript</a><br />
       <a href="#switch">Switch/When/Else</a><br />
       <a href="#try">Try/Catch/Finally</a><br />
@@ -83,26 +74,13 @@
       <a href="#contributing">Contributing</a><br />
       <a href="#change_log">Change Log</a><br />
     </p>
-
+    
     <h2 id="overview">Mini Overview</h2>
 
     <p><i>CoffeeScript on the left, compiled JavaScript output on the right.</i></p>
 
     <%= code_for('overview', 'cubed_list') %>
 
-    <p>
-      For a longer CoffeeScript example, check out
-      <a href="documentation/underscore.html">Underscore.coffee</a>, a port
-      of the <a href="http://documentcloud.github.com/underscore/">Underscore.js</a>
-      library of helper functions. Underscore.coffee can pass the entire Underscore.js
-      test suite. The CoffeeScript version is faster than the original for a number 
-      of methods (in general, due to the speed of CoffeeScript's array comprehensions), and
-      after being minified and gzipped, is only 241 bytes larger than the original
-      JavaScript version.
-      Additional examples are included in the source repository, inside the
-      <a href="http://github.com/jashkenas/coffee-script/tree/master/examples/">examples</a> folder.
-    </p>
-
     <h2 id="installation">Installation and Usage</h2>
 
     <p>
@@ -135,7 +113,7 @@ gem install coffee-script</pre>
       <tr>
         <td><code>-r, --run</code></td>
         <td>
-          Compile and execute scripts without saving the intermediate
+          Compile and execute the CoffeeScripts without saving the intermediate
           JavaScript. Requires <a href="http://narwhaljs.org/">Narwhal</a>.
         </td>
       </tr>
@@ -171,7 +149,7 @@ gem install coffee-script</pre>
         <td><code>-e, --eval</code></td>
         <td>
           Compile and print a little snippet of CoffeeScript directly from the
-          command line (or from <b>stdin</b>). For example:<br /><tt>coffee -e "square: x => x * x"</tt>
+          command line (or from <b>stdin</b>). For example:<br /><tt>coffee -e "square: x => x * x."</tt>
         </td>
       </tr>
       <tr>
@@ -192,15 +170,9 @@ gem install coffee-script</pre>
       <tr>
         <td><code>-n, --no-wrap</code></td>
         <td>
-          Compile the JavaScript without the top-level function safety wrapper.
-          (Used for CoffeeScript as a Narwhal module.)
-        </td>
-      </tr>
-      <tr>
-        <td><code>-g, --globals</code></td>
-        <td>
-          Suppress all variable declarations at the top-level, effectively adding
-          those variables to the global scope. (Used by the REPL.)
+          Compile the JavaScript without the top-level function safety wrapper
+          or var declarations, for situations where you want to add every
+          variable to global scope.
         </td>
       </tr>
       <tr>
@@ -233,30 +205,22 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       </i>
     </p>
 
-    <p id="whitespace">
-      <b class="header">Significant Whitespace</b>
-      CoffeeScript uses Python-style significant whitespace: You don't need to
-      use semicolons <tt>;</tt> to terminate expressions, ending
-      the line will do just as well. Semicolons can still be used to fit
-      multiple expressions onto a single line. Instead of using curly braces
-      <tt>{ }</tt> to delimit blocks of code (like <a href="#functions">functions</a>,
+    <p id="punctuation">
+      <b class="header">Punctuation Primer</b>
+      You don't need to use semicolons <tt>;</tt> to terminate expressions, ending
+      the line will do just as well. All other whitespace is
+      not significant. Instead of using curly braces <tt>{ }</tt>
+      to delimit a block of code, use a period <tt>.</tt> to mark the end of a
+      block, for
+      <a href="#functions">functions</a>,
       <a href="#conditionals">if-statements</a>,
-      <a href="#switch">switch</a>, and <a href="#try">try/catch</a>),
-      use indentation.
-    </p>
-
-    <p>
-      You can use newlines to break up your expression into smaller pieces,
-      as long as CoffeeScript can tell that the line hasn't finished
-      (similar to how Ruby handles it). For example,
-      if the line ends in an operator, dot, or keyword.
+      <a href="#switch">switch</a>, and <a href="#try">try/catch</a>.
     </p>
 
     <p id="functions">
       <b class="header">Functions and Invocation</b>
       Functions are defined by a list of parameters, an arrow, and the
-      function body. The empty function looks like this: <tt>=></tt>. All
-      functions in CoffeeScript are named, for the benefit of debug messages.
+      function body. The empty function looks like this: <tt>=>.</tt>
     </p>
     <%= code_for('functions', 'cube(5)') %>
 
@@ -268,8 +232,8 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('assignment', 'greeting') %>
     <p>
-      Declarations of new variables are pushed up to the top of the nearest
-      lexical scope, so that assignment may always be performed within expressions.
+      Declarations of new variables are pushed up to the top of the current scope,
+      so that assignments may always be used within expressions.
     </p>
 
     <p id="objects_and_arrays">
@@ -277,8 +241,7 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       Object and Array literals look very similar to their JavaScript cousins.
       When you spread out each assignment on a separate line, the commas are
       optional. In this way, assigning object properties looks the same as
-      assigning local variables, and can be moved around freely. You can mix
-      and match the two styles.
+      assigning local variables.
     </p>
     <%= code_for('objects_and_arrays', 'song.join(",")') %>
 
@@ -290,29 +253,25 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('scope', 'new_num') %>
     <p>
-      Notice how the all of the variable declarations have been pushed up to
-      the top of the closest scope, the first time they appear.
-      <b>num</b> is not redeclared within the inner function, because it's
-      already in scope; the <b>new_num</b> within the function, on the other hand,
-      should not be able to change the value of the external variable of the same name, and
-      therefore has a declaration of its own.
+      Notice how the variables are declared with <tt>var</tt> the first time
+      they appear. The second reference of <b>num</b>, within the function,
+      is not redeclared because <b>num</b> is still in scope. As opposed
+      to the second occurrence of <b>new_num</b>, in the last line.
     </p>
     <p>
       Although suppressed within this documentation for clarity, all
       CoffeeScript output is wrapped in an anonymous function:
       <tt>(function(){ ... })();</tt> This safety wrapper, combined with the
       automatic generation of the <tt>var</tt> keyword, make it exceedingly difficult
-      to pollute the global namespace by accident. If you'd like to create
-      global variables, attach them as properties on <b>window</b>,
-      or on the <b>exports</b> object in CommonJS.
+      to pollute the global namespace by accident.
     </p>
 
     <p id="conditionals">
       <b class="header">Conditionals, Ternaries, and Conditional Assignment</b>
-      <b>If/else</b> statements can be written without the use of parentheses and
-      curly brackets. As with functions and other block expressions,
-      multi-line conditionals are delimited by indentation. There's also a handy
-      postfix form, with the <tt>if</tt> or <tt>unless</tt> at the end.
+      <b>If/else</b> statements can be written without the use of parenthesis and
+      curly brackets. As with functions and other block expressions, conditionals
+      are closed with periods. No period is necessary when using the single-line
+      postfix form, with the <tt>if</tt> at the end.
     </p>
     <p>
       CoffeeScript will compile <b>if</b> statements using the ternary operator
@@ -320,21 +279,31 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('conditionals') %>
     <p>
-      The conditional assignment operators are included: <tt>||=</tt>,
+      The conditional assignment operators are available: <tt>||=</tt>,
       which only assigns a value to a variable if the variable's current value
       is falsy, and <tt>&amp;&amp;=</tt>, which only replaces the value of
       truthy variables.
     </p>
 
-    <p id="existence">
-      <b class="header">The Existence Operator</b>
-      It's a little difficult to check for the existence of a variable in
-      JavaScript. <tt>if (variable) ...</tt> comes close, but fails for zero,
-      the empty string, and false. The existence operator <tt>?</tt> returns true unless
-      a variable is <b>null</b> or <b>undefined</b>, which makes it analogous
-      to Ruby's <tt>nil?</tt>
+    <p id="expressions">
+      <b class="header">Everything is an Expression (at least, as much as possible)</b>
+      You might have noticed how even though we don't add return statements
+      to CoffeeScript functions, they nonetheless return their final value.
+      The CoffeeScript compiler tries to make sure that all statements in the
+      language can be used as expressions. Watch how the <tt>return</tt> gets
+      pushed down into each possible branch of execution, in the function
+      below.
     </p>
-    <%= code_for('existence') %>
+    <%= code_for('expressions', 'eldest') %>
+    <p>
+      The same mechanism is used to push down assignment through <b>switch</b>
+      statements, and <b>if-elses</b> (although the ternary operator is preferred).
+      Another part of manipulating assignment statements is
+      CoffeeScript's declaration of new variables at the top of the
+      current scope. This allows assignment to be used as a piece of an
+      expression.
+    </p>
+    <%= code_for('expressions_assignment', 'six') %>
 
     <p id="aliases">
       <b class="header">Aliases</b>
@@ -366,24 +335,6 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('aliases') %>
 
-    <p id="splats">
-      <b class="header">Splats...</b>
-      The JavaScript <b>arguments object</b> is a useful way to work with
-      functions that accept variable numbers of arguments. CoffeeScript provides
-      splats <tt>...</tt>, both for function definition as well as invocation,
-      making variable arguments a little bit more palatable.
-    </p>
-    <%= code_for('splats', true) %>
-
-    <p id="arguments">
-      <b class="header">Arguments are Arrays</b>
-      If you reference the <b>arguments object</b> directly, it will be converted
-      into a real Array, making all of the
-      <a href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array">Array methods</a>
-      available.
-    </p>
-    <%= code_for('arguments', true) %>
-
     <p id="while">
       <b class="header">While Loops</b>
       The only low-level loop that CoffeeScript provides is the while loop.
@@ -396,8 +347,8 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       <b>each</b> (<b>forEach</b>) style iterators, or...
     </p>
 
-    <p id="comprehensions">
-      <b class="header">Comprehensions (Arrays, Objects, and Ranges)</b>
+    <p id="array_comprehensions">
+      <b class="header">Array Comprehensions</b>
       For your looping needs, CoffeeScript provides array comprehensions
       similar to Python's. They replace (and compile into) <b>for</b> loops, with
       optional guard clauses and the value of the current array index.
@@ -407,21 +358,13 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('array_comprehensions') %>
     <p>
-      If you know the start and end of your loop, or would like to step through
-      in fixed-size increments, you can use a range to specify the start and
-      end of your comprehension. (The long line-breaking "for" definitions in
-      the compiled JS below allow ranges to count downwards, as well as upwards).
+      If you're not iterating over an actual array, you can use a range to 
+      specify the start and end of an array comprehension: 
+      <tt>coundown(i) for i in [10..1].</tt>
     </p>
-    <%= code_for('range_comprehensions', 'countdown') %>
-    <p>
-      Comprehensions can also be used to iterate over the keys and values in
-      an object. Use <tt>ino</tt> to signal comprehension over an object instead
-      of an array.
-    </p>
-    <%= code_for('object_comprehensions', 'ages.join(", ")') %>
 
-    <p id="slice_splice">
-      <b class="header">Array Slicing and Splicing with Ranges</b>
+    <p id="slice">
+      <b class="header">Slicing Arrays with Ranges</b>
       CoffeeScript borrows Ruby's
       <a href="http://ruby-doc.org/core/classes/Range.html">range syntax</a>
       for extracting slices of arrays. With two dots (<tt>3..5</tt>), the range
@@ -430,44 +373,6 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       a range that excludes the end.
     </p>
     <%= code_for('slices', 'numbers_copy') %>
-    <p>
-      The same syntax can be used with assignment to replace a segment of an
-      array with new values (to splice it).
-    </p>
-    <%= code_for('splices', 'numbers') %>
-
-    <p id="expressions">
-      <b class="header">Everything is an Expression (at least, as much as possible)</b>
-      You might have noticed how even though we don't add return statements
-      to CoffeeScript functions, they nonetheless return their final value.
-      The CoffeeScript compiler tries to make sure that all statements in the
-      language can be used as expressions. Watch how the <tt>return</tt> gets
-      pushed down into each possible branch of execution, in the function
-      below.
-    </p>
-    <%= code_for('expressions', 'eldest') %>
-    <p>
-      Even though functions will always return their final value, it's both possible
-      and encouraged to return early from a function body writing out the explicit
-      return (<tt>return value</tt>), when you know that you're done.
-    </p>
-    <p>
-      Because variable declarations occur at the top of scope, assignment can
-      be used within expressions, even for variables that haven't been seen before:
-    </p>
-    <%= code_for('expressions_assignment', 'six') %>
-    <p>
-      Things that would otherwise be statements in JavaScript, when used
-      as part of an expression in CoffeeScript, are converted into expressions
-      by wrapping them in a closure. This lets you do useful things, like assign
-      the result of a comprehension to a variable:
-    </p>
-    <%= code_for('expressions_comprehension', 'globals') %>
-    <p>
-      As well as silly things, like passing a <b>try/catch</b> statement directly
-      into a function call:
-    </p>
-    <%= code_for('expressions_try', true) %>
 
     <p id="inheritance">
       <b class="header">Inheritance, and Calling Super from a Subclass</b>
@@ -481,25 +386,13 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       be completely usable if it weren't for a couple of small exceptions:
       it's awkward to call <b>super</b> (the prototype object's
       implementation of the current function), and it's awkward to correctly
-      set the prototype chain. 
-    </p>
-    <p>
-      CoffeeScript provides <tt>extends</tt>
-      to help with prototype setup, <tt>::</tt> for quick access to an
-      object's prototype, and converts <tt>super()</tt> into a call against 
-      the immediate ancestor's method of the same name.
+      set the prototype chain. CoffeeScript provides <tt>extends</tt>
+      to help with prototype setup, and converts
+      <tt>super()</tt> calls into calls against the immediate ancestor's
+      method of the same name.
     </p>
     <%= code_for('super', true) %>
 
-    <p id="blocks">
-      <b class="header">Blocks</b>
-      Many common looping functions (in Prototype, jQuery, and Underscore,
-      for example) take a single function as their final argument. To make
-      final functions easier to pass, CoffeeScript includes block syntax,
-      so you don't have to close the parentheses on the other side.
-    </p>
-    <%= code_for('blocks') %>
-
     <p id="embedded">
       <b class="header">Embedded JavaScript</b>
       If you ever need to interpolate literal JavaScript snippets, you can
@@ -526,47 +419,35 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('try') %>
 
-    <p id="strings">
+    <p id="try">
       <b class="header">Multiline Strings</b>
       Multiline strings are allowed in CoffeeScript.
     </p>
     <%= code_for('strings', 'moby_dick') %>
-
+    
     <h2 id="resources">Resources</h2>
-
-    <ul>
-      <li>
-        <a href="http://github.com/jashkenas/coffee-script/">Source Code</a><br />
-        After checking out the source, make sure to run <tt>rake build:parser</tt>
-        to generate an up-to-date version of the Racc parser.
-        Use <tt>bin/coffee</tt> to test your changes, 
-        <tt>rake test</tt> to run the test suite,
-        and <tt>rake gem:install</tt> to
-        create and install a custom version of the gem.
-      </li>
-      <li>
-        <a href="http://github.com/jashkenas/coffee-script/issues">Bugs, Feature Requests, and General Discussion</a>
-      </li>
-      <li>
-        <a href="http://github.com/jnicklas/bistro_car">BistroCar</a><br />
-        A Rails plugin by
-        <a href="http://github.com/jnicklas">Jonas Nicklas</a>
-        that includes CoffeeScript helpers,
-        bundling and minification.
-      </li>
-    </ul>
+    
+    <p>
+      <a href="http://github.com/jashkenas/coffee-script/">Source Code</a><br />
+      <a href="http://github.com/jashkenas/coffee-script/issues">Bugs and Feature Requests</a><br />
+    </p>
 
     <h2 id="contributing">Contributing</h2>
 
     <p>
-      Here's a wish list of things that would be wonderful to have contributed:
+      Here's a wish list of things that would be wonderful to have in
+      CoffeeScript:
     </p>
 
     <ul>
       <li>
-        <a href="http://github.com/jashkenas/coffee-script/issues#issue/8">
-          A CoffeeScript version of the compiler.
-        </a>
+        A JavaScript version of the compiler, perhaps using Alessandro Warth's
+        <a href="http://tinlizzie.org/ometa/">OMeta</a>.
+      </li>
+      <li>
+        Ideas for alternate syntax to end blocks of expressions &mdash; the periods
+        can look a little weird with deeply nested structure. (There's now a
+        'whitespace' branch &mdash; help add significant whitespace over there.)
       </li>
       <li>
         Test cases for any syntax errors you encounter that you think CoffeeScript
@@ -588,55 +469,12 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </ul>
 
     <h2 id="change_log">Change Log</h2>
-
-    <p>
-      <b class="header" style="margin-top: 20px;">0.2.2</b>
-      When performing a comprehension over an object, use <tt>ino</tt>, instead
-      of <tt>in</tt>, which helps us generate smaller, more efficient code at
-      compile time.
-      <br />
-      Added <tt>::</tt> as a shorthand for saying <tt>.prototype.</tt>
-      <br />
-      The "splat" symbol has been changed from a prefix asterisk <tt>*</tt>, to
-      a postfix ellipsis <tt>...</tt>
-      <br />
-      Added JavaScript's <tt>in</tt> operator,
-      empty <tt>return</tt> statements, and empty <tt>while</tt> loops.
-      <br />
-      Constructor functions that start with capital letters now include a
-      safety check to make sure that the new instance of the object is returned.
-      <br />
-      The <tt>extends</tt> keyword now functions identically to <tt>goog.inherits</tt>
-      in Google's Closure Library.
-    </p>
-
-    <p>
-      <b class="header" style="margin-top: 20px;">0.2.1</b>
-      Arguments objects are now converted into real arrays when referenced.
-    </p>
-
-    <p>
-      <b class="header" style="margin-top: 20px;">0.2.0</b>
-      Major release. Significant whitespace. Better statement-to-expression
-      conversion. Splats. Splice literals. Object comprehensions. Blocks.
-      The existence operator. Many thanks to all the folks who posted issues,
-      with special thanks to
-      <a href="http://github.com/kamatsu">Liam O'Connor-Davis</a> for whitespace
-      and expression help.
-    </p>
-
-    <p>
-      <b class="header" style="margin-top: 20px;">0.1.6</b>
-      Bugfix for running <tt>coffee --interactive</tt> and <tt>--run</tt>
-      from outside of the CoffeeScript directory. Bugfix for nested
-      function/if-statements.
-    </p>
-
+    
     <p>
       <b class="header" style="margin-top: 20px;">0.1.5</b>
       Array slice literals and array comprehensions can now both take Ruby-style
-      ranges to specify the start and end. JavaScript variable declaration is
-      now pushed up to the top of the scope, making all assignment statements into
+      ranges to specify the start and end. JavaScript variable declaration is 
+      now pushed up to the top of the scope, making all assignment statements into 
       expressions. You can use <tt>\</tt> to escape newlines.
       The <tt>coffee-script</tt> command is now called <tt>coffee</tt>.
     </p>

documentation/js/arguments.js

@@ -1,7 +0,0 @@
-(function(){
-  var backwards;
-  backwards = function backwards() {
-    return alert(Array.prototype.slice.call(arguments, 0).reverse());
-  };
-  backwards("stairway", "to", "heaven");
-})();

documentation/js/array_comprehensions.js

@@ -1,26 +1,20 @@
 (function(){
-  var __a, __b, __c, __d, __e, __f, __g, food, lunch, roid, roid2;
+  var __a, __b, __c, __d, __e, __f, __g, __h, food, i, lunch, row;
   // Eat lunch.
-  lunch = (function() {
-    __c = []; __a = ['toast', 'cheese', 'wine'];
-    for (__b=0; __b<__a.length; __b++) {
-      food = __a[__b];
-      __c.push(eat(food));
-    }
-    return __c;
-  })();
-  // Naive collision detection.
-  __d = asteroids;
-  for (__e=0; __e<__d.length; __e++) {
-    roid = __d[__e];
-    __f = asteroids;
-    for (__g=0; __g<__f.length; __g++) {
-      roid2 = __f[__g];
-      if (roid !== roid2) {
-        if (roid.overlaps(roid2)) {
-          roid.explode();
-        }
-      }
-    }
+  __a = ['toast', 'cheese', 'wine'];
+  __d = [];
+  for (__b=0, __c=__a.length; __b<__c; __b++) {
+    food = __a[__b];
+    __d[__b] = food.eat();
   }
+  lunch = __d;
+  // Zebra-stripe a table.
+  __e = table;
+  __h = [];
+  for (__f=0, __g=__e.length; __f<__g; __f++) {
+    row = __e[__f];
+    i = __f;
+    __h[__f] = i % 2 === 0 ? highlight(row) : null;
+  }
+  __h;
 })();

documentation/js/blocks.js

@@ -1,8 +0,0 @@
-(function(){
-  $('table.list').each(function(table) {
-    return $('tr.account', table).each(function(row) {
-      row.show();
-      return row.highlight();
-    });
-  });
-})();

documentation/js/existence.js

@@ -1,6 +0,0 @@
-(function(){
-  var solipsism;
-  if ((typeof mind !== "undefined" && mind !== null) && !(typeof world !== "undefined" && world !== null)) {
-    solipsism = true;
-  }
-})();

documentation/js/expressions.js

@@ -1,6 +1,6 @@
 (function(){
   var eldest, grade;
-  grade = function grade(student) {
+  grade = function(student) {
     if (student.excellent_work) {
       return "A+";
     } else if (student.okay_stuff) {

documentation/js/expressions_comprehension.js

@@ -1,13 +0,0 @@
-(function(){
-  var __a, __b, globals, name;
-  // The first ten global properties.
-  globals = ((function() {
-    __b = []; __a = window;
-    for (name in __a) {
-      if (__a.hasOwnProperty(name)) {
-        __b.push(name);
-      }
-    }
-    return __b;
-  })()).slice(0, 10);
-})();

documentation/js/expressions_try.js

@@ -1,9 +0,0 @@
-(function(){
-  alert((function() {
-    try {
-      return nonexistent / undefined;
-    } catch (error) {
-      return "Caught an error: " + error;
-    }
-  })());
-})();

documentation/js/functions.js

@@ -1,9 +1,9 @@
 (function(){
   var cube, square;
-  square = function square(x) {
+  square = function(x) {
     return x * x;
   };
-  cube = function cube(x) {
+  cube = function(x) {
     return square(x) * x;
   };
 })();

documentation/js/object_comprehensions.js

@@ -1,18 +0,0 @@
-(function(){
-  var __a, __b, age, ages, child, years_old;
-  years_old = {
-    max: 10,
-    ida: 9,
-    tim: 11
-  };
-  ages = (function() {
-    __b = []; __a = years_old;
-    for (child in __a) {
-      age = __a[child];
-      if (__a.hasOwnProperty(child)) {
-        __b.push(child + " is " + age);
-      }
-    }
-    return __b;
-  })();
-})();

documentation/js/objects_and_arrays.js

@@ -1,10 +1,9 @@
 (function(){
-  var ages, matrix, song;
+  var ages, song;
   song = ["do", "re", "mi", "fa", "so"];
   ages = {
     max: 10,
     ida: 9,
     tim: 11
   };
-  matrix = [1, 0, 1, 0, 0, 1, 1, 1, 0];
 })();

documentation/js/overview.js

@@ -1,5 +1,5 @@
 (function(){
-  var __a, __b, __c, cubed_list, list, math, num, number, opposite_day, race, square;
+  var __a, __b, __c, __d, cubed_list, list, math, num, number, opposite_day, square;
   // Assignment:
   number = 42;
   opposite_day = true;
@@ -8,7 +8,7 @@
     number = -42;
   }
   // Functions:
-  square = function square(x) {
+  square = function(x) {
     return x * x;
   };
   // Arrays:
@@ -17,27 +17,16 @@
   math = {
     root: Math.sqrt,
     square: square,
-    cube: function cube(x) {
+    cube: function(x) {
       return x * square(x);
     }
   };
-  // Splats:
-  race = function race(winner) {
-    var runners;
-    runners = Array.prototype.slice.call(arguments, 1);
-    return print(winner, runners);
-  };
-  // Existence:
-  if ((typeof elvis !== "undefined" && elvis !== null)) {
-    alert("I knew it!");
-  }
   // Array comprehensions:
-  cubed_list = (function() {
-    __c = []; __a = list;
-    for (__b=0; __b<__a.length; __b++) {
-      num = __a[__b];
-      __c.push(math.cube(num));
-    }
-    return __c;
-  })();
+  __a = list;
+  __d = [];
+  for (__b=0, __c=__a.length; __b<__c; __b++) {
+    num = __a[__b];
+    __d[__b] = math.cube(num);
+  }
+  cubed_list = __d;
 })();

documentation/js/range_comprehensions.js

@@ -1,21 +0,0 @@
-(function(){
-  var __a, __b, __c, __d, __e, countdown, egg_delivery, num;
-  countdown = (function() {
-    __b = []; __d = 10; __e = 1;
-    for (__c=0, num=__d; (__d <= __e ? num <= __e : num >= __e); (__d <= __e ? num += 1 : num -= 1), __c++) {
-      __b.push(num);
-    }
-    return __b;
-  })();
-  egg_delivery = function egg_delivery() {
-    var __f, __g, __h, __i, __j, dozen_eggs, i;
-    __g = []; __i = 0; __j = eggs.length;
-    for (__h=0, i=__i; (__i <= __j ? i < __j : i > __j); (__i <= __j ? i += 12 : i -= 12), __h++) {
-      __g.push((function() {
-        dozen_eggs = eggs.slice(i, i + 12);
-        return deliver(new egg_carton(dozen));
-      })());
-    }
-    return __g;
-  };
-})();

documentation/js/scope.js

@@ -1,10 +1,11 @@
 (function(){
   var change_numbers, new_num, num;
   num = 1;
-  change_numbers = function change_numbers() {
+  change_numbers = function() {
     var new_num;
-    new_num = -1;
-    return num = 10;
+    num = 2;
+    new_num = 3;
+    return new_num;
   };
   new_num = change_numbers();
 })();

documentation/js/splats.js

@@ -1,16 +0,0 @@
-(function(){
-  var contenders, gold, medalists, silver, the_field;
-  gold = silver = the_field = "unknown";
-  medalists = function medalists(first, second) {
-    var rest;
-    rest = Array.prototype.slice.call(arguments, 2);
-    gold = first;
-    silver = second;
-    return the_field = rest;
-  };
-  contenders = ["Michael Phelps", "Liu Xiang", "Yao Ming", "Allyson Felix", "Shawn Johnson", "Roman Sebrle", "Guo Jingjing", "Tyson Gay", "Asafa Powell", "Usain Bolt"];
-  medalists.apply(this, contenders);
-  alert("Gold: " + gold);
-  alert("Silver: " + silver);
-  alert("The Field: " + the_field);
-})();

documentation/js/splices.js

@@ -1,5 +0,0 @@
-(function(){
-  var numbers;
-  numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-  numbers.splice.apply(numbers, [3, 6 - 3 + 1].concat([-3, -4, -5, -6]));
-})();

documentation/js/super.js

@@ -1,35 +1,29 @@
 (function(){
-  var Animal, Horse, Snake, __a, __b, sam, tom;
-  Animal = function Animal() {
+  var Animal, Horse, Snake, sam, tom;
+  Animal = function() {
   };
-  Animal.prototype.move = function move(meters) {
+  Animal.prototype.move = function(meters) {
     return alert(this.name + " moved " + meters + "m.");
   };
-  Snake = function Snake(name) {
-    var __a;
-    __a = this.name = name;
-    return Snake === this.constructor ? this : __a;
+  Snake = function(name) {
+    this.name = name;
+    return this.name;
   };
-  __a = function(){};
-  __a.prototype = Animal.prototype;
   Snake.__superClass__ = Animal.prototype;
-  Snake.prototype = new __a();
+  Snake.prototype = new Animal();
   Snake.prototype.constructor = Snake;
-  Snake.prototype.move = function move() {
+  Snake.prototype.move = function() {
     alert("Slithering...");
     return Snake.__superClass__.move.call(this, 5);
   };
-  Horse = function Horse(name) {
-    var __b;
-    __b = this.name = name;
-    return Horse === this.constructor ? this : __b;
+  Horse = function(name) {
+    this.name = name;
+    return this.name;
   };
-  __b = function(){};
-  __b.prototype = Animal.prototype;
   Horse.__superClass__ = Animal.prototype;
-  Horse.prototype = new __b();
+  Horse.prototype = new Animal();
   Horse.prototype.constructor = Horse;
-  Horse.prototype.move = function move() {
+  Horse.prototype.move = function() {
     alert("Galloping...");
     return Horse.__superClass__.move.call(this, 45);
   };

documentation/speed.html

@@ -1,77 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
-  <title>Quickie CoffeeScript Speed Tests</title>
-  <script type="text/javascript" src="http://www.broofa.com/Tools/JSLitmus/JSLitmus.js"></script>
-</head>
-<body>
-
-  <h1>Quickie CoffeeScript Speed Tests</h1>
-
-  <script type="text/javascript">
-    var num = 1000;
-    var arr = [];
-    while (num--) arr.push(num);
-
-    JSLitmus.test('current comprehensions', function() {
-      __a = arr;
-      __c = [];
-      for (__b in __a) {
-        if (__a.hasOwnProperty(__b)) {
-          num = __a[__b];
-          __d = num;
-          __c.push(num);
-        }
-      }
-    });
-
-    JSLitmus.test('raw for loop (best we can do)', function() {
-      __a = arr;
-      __c = new Array(__a.length);
-      for (__b=0; __b < __a.length; __b++) {
-        __c[__b] = __a[__b];
-      }
-    });
-
-    JSLitmus.test('current without hasOwnProperty check', function() {
-      __a = arr;
-      __c = [];
-      for (__b in __a) {
-        num = __a[__b];
-        __d = num;
-        __c.push(num);
-      }
-    });
-
-    JSLitmus.test('raw for..in loop', function() {
-      __a = arr;
-      __c = new Array(__a.length);
-      for (__b in __a) {
-        __c[__b] = __a[__b];
-      }
-    });
-
-    JSLitmus.test('weepy\'s comprehensions', function() {
-      __c = []; __a = arr;
-      __d = function(num, __b) {
-        __c.push(num);
-      };
-      if (__a instanceof Array) {
-        for (__b=0; __b<__a.length; __b++) __d(__a[__b], __b);
-      } else {
-        for (__b in __a) { if (__a.hasOwnProperty(__b)) __d(__a[__b], __b); }
-      }
-    });
-
-    JSLitmus.test('CoffeeScript 0.2.2 comprehensions', function() {
-      __c = []; __a = arr;
-      for (__b=0; __b<__a.length; __b++) {
-        num = __a[__b];
-        __c.push(num);
-      }
-    });
-  </script>
-
-</body>
-</html>

documentation/underscore.html

@@ -1,627 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
-
-<head>
-  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
-  <link rel="stylesheet" type="text/css" media="screen,projection,print" href="css/idle.css" />
-  <title>Underscore.coffee</title>
-  <style type="text/css">
-    body {
-      margin: 0; padding: 0;
-    }
-    pre.idle {
-      font-family: "Monaco", "Consolas", monospace;
-      font-size: 12px;
-    }
-  </style>
-</head>
-
-<body>
-<pre class="idle"><span class="line-numbers">   1 </span>
-<span class="line-numbers">   2 </span>   <span class="Comment"><span class="Comment">#</span> Underscore.coffee</span>
-<span class="line-numbers">   3 </span>   <span class="Comment"><span class="Comment">#</span> (c) 2009 Jeremy Ashkenas, DocumentCloud Inc.</span>
-<span class="line-numbers">   4 </span>   <span class="Comment"><span class="Comment">#</span> Underscore is freely distributable under the terms of the MIT license.</span>
-<span class="line-numbers">   5 </span>   <span class="Comment"><span class="Comment">#</span> Portions of Underscore are inspired by or borrowed from Prototype.js,</span>
-<span class="line-numbers">   6 </span>   <span class="Comment"><span class="Comment">#</span> Oliver Steele's Functional, and John Resig's Micro-Templating.</span>
-<span class="line-numbers">   7 </span>   <span class="Comment"><span class="Comment">#</span> For all details and documentation:</span>
-<span class="line-numbers">   8 </span>   <span class="Comment"><span class="Comment">#</span> http://documentcloud.github.com/underscore/</span>
-<span class="line-numbers">   9 </span>
-<span class="line-numbers">  10 </span>
-<span class="line-numbers">  11 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------- Baseline setup ---------------------------------</span>
-<span class="line-numbers">  12 </span>
-<span class="line-numbers">  13 </span>   <span class="Comment"><span class="Comment">#</span> Establish the root object, &quot;window&quot; in the browser, or &quot;global&quot; on the server.</span>
-<span class="line-numbers">  14 </span>   <span class="FunctionName">root</span><span class="Keyword">:</span> <span class="Variable">this</span>
-<span class="line-numbers">  15 </span>
-<span class="line-numbers">  16 </span>
-<span class="line-numbers">  17 </span>   <span class="Comment"><span class="Comment">#</span> Save the previous value of the &quot;_&quot; variable.</span>
-<span class="line-numbers">  18 </span>   <span class="FunctionName">previousUnderscore</span><span class="Keyword">:</span> root._
-<span class="line-numbers">  19 </span>
-<span class="line-numbers">  20 </span>
-<span class="line-numbers">  21 </span>   <span class="Comment"><span class="Comment">#</span> If Underscore is called as a function, it returns a wrapped object that</span>
-<span class="line-numbers">  22 </span>   <span class="Comment"><span class="Comment">#</span> can be used OO-style. This wrapper holds altered versions of all the</span>
-<span class="line-numbers">  23 </span>   <span class="Comment"><span class="Comment">#</span> underscore functions. Wrapped objects may be chained.</span>
-<span class="line-numbers">  24 </span> <span class="FunctionArgument">  wrapper: obj </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  25 </span>     <span class="Variable">this</span>.<span class="FunctionName">_wrapped</span><span class="Keyword">:</span> obj
-<span class="line-numbers">  26 </span>     <span class="Variable">this</span>
-<span class="line-numbers">  27 </span>
-<span class="line-numbers">  28 </span>
-<span class="line-numbers">  29 </span>   <span class="Comment"><span class="Comment">#</span> Establish the object that gets thrown to break out of a loop iteration.</span>
-<span class="line-numbers">  30 </span>   <span class="FunctionName">breaker</span><span class="Keyword">:</span> <span class="Keyword">if</span> <span class="Keyword">typeof</span>(StopIteration) <span class="Keyword">is</span> <span class="String"><span class="String">'</span>undefined<span class="String">'</span></span> <span class="Keyword">then</span> <span class="String"><span class="String">'</span>__break__<span class="String">'</span></span> <span class="Keyword">else</span> StopIteration
-<span class="line-numbers">  31 </span>
-<span class="line-numbers">  32 </span>
-<span class="line-numbers">  33 </span>   <span class="Comment"><span class="Comment">#</span> Create a safe reference to the Underscore object forreference below.</span>
-<span class="line-numbers">  34 </span> <span class="FunctionArgument">  _: root._: obj </span><span class="Storage">=&gt;</span> <span class="Keyword">new</span> <span class="TypeName">wrapper</span>(obj)
-<span class="line-numbers">  35 </span>
-<span class="line-numbers">  36 </span>
-<span class="line-numbers">  37 </span>   <span class="Comment"><span class="Comment">#</span> Export the Underscore object for CommonJS.</span>
-<span class="line-numbers">  38 </span>   <span class="Keyword">if</span> <span class="Keyword">typeof</span>(exports) <span class="Keyword">!</span><span class="Keyword">=</span> <span class="String"><span class="String">'</span>undefined<span class="String">'</span></span> <span class="Keyword">then</span> exports.<span class="FunctionName">_</span><span class="Keyword">:</span> _
-<span class="line-numbers">  39 </span>
-<span class="line-numbers">  40 </span>
-<span class="line-numbers">  41 </span>   <span class="Comment"><span class="Comment">#</span> Create quick reference variables for speed access to core prototypes.</span>
-<span class="line-numbers">  42 </span>   <span class="FunctionName">slice</span><span class="Keyword">:</span>                Array<span class="Keyword">:</span><span class="Keyword">:</span>slice
-<span class="line-numbers">  43 </span>   <span class="FunctionName">unshift</span><span class="Keyword">:</span>              Array<span class="Keyword">:</span><span class="Keyword">:</span>unshift
-<span class="line-numbers">  44 </span>   <span class="FunctionName">toString</span><span class="Keyword">:</span>             Object<span class="Keyword">:</span><span class="Keyword">:</span>toString
-<span class="line-numbers">  45 </span>   <span class="FunctionName">hasOwnProperty</span><span class="Keyword">:</span>       Object<span class="Keyword">:</span><span class="Keyword">:</span>hasOwnProperty
-<span class="line-numbers">  46 </span>   <span class="FunctionName">propertyIsEnumerable</span><span class="Keyword">:</span> Object<span class="Keyword">:</span><span class="Keyword">:</span>propertyIsEnumerable
-<span class="line-numbers">  47 </span>
-<span class="line-numbers">  48 </span>
-<span class="line-numbers">  49 </span>   <span class="Comment"><span class="Comment">#</span> Current version.</span>
-<span class="line-numbers">  50 </span>   _.<span class="FunctionName">VERSION</span><span class="Keyword">:</span> <span class="String"><span class="String">'</span>0.5.5<span class="String">'</span></span>
-<span class="line-numbers">  51 </span>
-<span class="line-numbers">  52 </span>
-<span class="line-numbers">  53 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------ Collection Functions: ---------------------------</span>
-<span class="line-numbers">  54 </span>
-<span class="line-numbers">  55 </span>   <span class="Comment"><span class="Comment">#</span> The cornerstone, an each implementation.</span>
-<span class="line-numbers">  56 </span>   <span class="Comment"><span class="Comment">#</span> Handles objects implementing forEach, arrays, and raw objects.</span>
-<span class="line-numbers">  57 </span> <span class="FunctionArgument">  _.each: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  58 </span>     <span class="FunctionName">index</span><span class="Keyword">:</span> <span class="Number">0</span>
-<span class="line-numbers">  59 </span>     <span class="Keyword">try</span>
-<span class="line-numbers">  60 </span>       <span class="Keyword">return</span> obj.forEach(iterator, context) <span class="Keyword">if</span> obj.forEach
-<span class="line-numbers">  61 </span>       <span class="Keyword">if</span> _.isArray(obj) <span class="Keyword">or</span> _.isArguments(obj)
-<span class="line-numbers">  62 </span>         <span class="Keyword">return</span> iterator.call(context, obj[i], i, obj) <span class="Keyword">for</span> i <span class="Keyword">in</span> [<span class="Number">0</span>...obj.length]
-<span class="line-numbers">  63 </span>       iterator.call(context, val, key, obj) <span class="Keyword">for</span> key, val <span class="Keyword">ino</span> obj
-<span class="line-numbers">  64 </span>     <span class="Keyword">catch</span> e
-<span class="line-numbers">  65 </span>       <span class="Keyword">throw</span> e <span class="Keyword">if</span> e <span class="Keyword">isnt</span> breaker
-<span class="line-numbers">  66 </span>     obj
-<span class="line-numbers">  67 </span>
-<span class="line-numbers">  68 </span>
-<span class="line-numbers">  69 </span>   <span class="Comment"><span class="Comment">#</span> Return the results of applying the iterator to each element. Use JavaScript</span>
-<span class="line-numbers">  70 </span>   <span class="Comment"><span class="Comment">#</span> 1.6's version of map, if possible.</span>
-<span class="line-numbers">  71 </span> <span class="FunctionArgument">  _.map: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  72 </span>     <span class="Keyword">return</span> obj.map(iterator, context) <span class="Keyword">if</span> (obj <span class="Keyword">and</span> _.isFunction(obj.map))
-<span class="line-numbers">  73 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span> []
-<span class="line-numbers">  74 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  75 </span>       results.push(iterator.call(context, value, index, list))
-<span class="line-numbers">  76 </span>     results
-<span class="line-numbers">  77 </span>
-<span class="line-numbers">  78 </span>
-<span class="line-numbers">  79 </span>   <span class="Comment"><span class="Comment">#</span> Reduce builds up a single result from a list of values. Also known as</span>
-<span class="line-numbers">  80 </span>   <span class="Comment"><span class="Comment">#</span> inject, or foldl. Uses JavaScript 1.8's version of reduce, if possible.</span>
-<span class="line-numbers">  81 </span> <span class="FunctionArgument">  _.reduce: obj, memo, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  82 </span>     <span class="Keyword">return</span> obj.reduce(_.bind(iterator, context), memo) <span class="Keyword">if</span> (obj <span class="Keyword">and</span> _.isFunction(obj.reduce))
-<span class="line-numbers">  83 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  84 </span>       <span class="FunctionName">memo</span><span class="Keyword">:</span> iterator.call(context, memo, value, index, list)
-<span class="line-numbers">  85 </span>     memo
-<span class="line-numbers">  86 </span>
-<span class="line-numbers">  87 </span>
-<span class="line-numbers">  88 </span>   <span class="Comment"><span class="Comment">#</span> The right-associative version of reduce, also known as foldr. Uses</span>
-<span class="line-numbers">  89 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript 1.8's version of reduceRight, if available.</span>
-<span class="line-numbers">  90 </span> <span class="FunctionArgument">  _.reduceRight: obj, memo, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  91 </span>     <span class="Keyword">return</span> obj.reduceRight(_.bind(iterator, context), memo) <span class="Keyword">if</span> (obj <span class="Keyword">and</span> _.isFunction(obj.reduceRight))
-<span class="line-numbers">  92 </span>     _.each(_.clone(_.toArray(obj)).reverse())<span class="FunctionArgument"> value, index </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  93 </span>       <span class="FunctionName">memo</span><span class="Keyword">:</span> iterator.call(context, memo, value, index, obj)
-<span class="line-numbers">  94 </span>     memo
-<span class="line-numbers">  95 </span>
-<span class="line-numbers">  96 </span>
-<span class="line-numbers">  97 </span>   <span class="Comment"><span class="Comment">#</span> Return the first value which passes a truth test.</span>
-<span class="line-numbers">  98 </span> <span class="FunctionArgument">  _.detect: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers">  99 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> <span class="BuiltInConstant">null</span>
-<span class="line-numbers"> 100 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 101 </span>       <span class="Keyword">if</span> iterator.call(context, value, index, list)
-<span class="line-numbers"> 102 </span>         <span class="FunctionName">result</span><span class="Keyword">:</span> value
-<span class="line-numbers"> 103 </span>         _.breakLoop()
-<span class="line-numbers"> 104 </span>     result
-<span class="line-numbers"> 105 </span>
-<span class="line-numbers"> 106 </span>
-<span class="line-numbers"> 107 </span>   <span class="Comment"><span class="Comment">#</span> Return all the elements that pass a truth test. Use JavaScript 1.6's</span>
-<span class="line-numbers"> 108 </span>   <span class="Comment"><span class="Comment">#</span> filter(), if it exists.</span>
-<span class="line-numbers"> 109 </span> <span class="FunctionArgument">  _.select: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 110 </span>     <span class="Keyword">if</span> obj <span class="Keyword">and</span> _.isFunction(obj.filter) <span class="Keyword">then</span> <span class="Keyword">return</span> obj.filter(iterator, context)
-<span class="line-numbers"> 111 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span> []
-<span class="line-numbers"> 112 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 113 </span>       results.push(value) <span class="Keyword">if</span> iterator.call(context, value, index, list)
-<span class="line-numbers"> 114 </span>     results
-<span class="line-numbers"> 115 </span>
-<span class="line-numbers"> 116 </span>
-<span class="line-numbers"> 117 </span>   <span class="Comment"><span class="Comment">#</span> Return all the elements for which a truth test fails.</span>
-<span class="line-numbers"> 118 </span> <span class="FunctionArgument">  _.reject: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 119 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span> []
-<span class="line-numbers"> 120 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 121 </span>       results.push(value) <span class="Keyword">if</span> <span class="Keyword">not</span> iterator.call(context, value, index, list)
-<span class="line-numbers"> 122 </span>     results
-<span class="line-numbers"> 123 </span>
-<span class="line-numbers"> 124 </span>
-<span class="line-numbers"> 125 </span>   <span class="Comment"><span class="Comment">#</span> Determine whether all of the elements match a truth test. Delegate to</span>
-<span class="line-numbers"> 126 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript 1.6's every(), if it is present.</span>
-<span class="line-numbers"> 127 </span> <span class="FunctionArgument">  _.all: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 128 </span>     iterator <span class="Keyword">||</span><span class="Keyword">=</span> _.identity
-<span class="line-numbers"> 129 </span>     <span class="Keyword">return</span> obj.every(iterator, context) <span class="Keyword">if</span> obj <span class="Keyword">and</span> _.isFunction(obj.every)
-<span class="line-numbers"> 130 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 131 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 132 </span>       _.breakLoop() <span class="Keyword">unless</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> result <span class="Keyword">and</span> iterator.call(context, value, index, list))
-<span class="line-numbers"> 133 </span>     result
-<span class="line-numbers"> 134 </span>
-<span class="line-numbers"> 135 </span>
-<span class="line-numbers"> 136 </span>   <span class="Comment"><span class="Comment">#</span> Determine if at least one element in the object matches a truth test. Use</span>
-<span class="line-numbers"> 137 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript 1.6's some(), if it exists.</span>
-<span class="line-numbers"> 138 </span> <span class="FunctionArgument">  _.any: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 139 </span>     iterator <span class="Keyword">||</span><span class="Keyword">=</span> _.identity
-<span class="line-numbers"> 140 </span>     <span class="Keyword">return</span> obj.some(iterator, context) <span class="Keyword">if</span> obj <span class="Keyword">and</span> _.isFunction(obj.some)
-<span class="line-numbers"> 141 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> <span class="BuiltInConstant">false</span>
-<span class="line-numbers"> 142 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 143 </span>       _.breakLoop() <span class="Keyword">if</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> iterator.call(context, value, index, list))
-<span class="line-numbers"> 144 </span>     result
-<span class="line-numbers"> 145 </span>
-<span class="line-numbers"> 146 </span>
-<span class="line-numbers"> 147 </span>   <span class="Comment"><span class="Comment">#</span> Determine if a given value is included in the array or object,</span>
-<span class="line-numbers"> 148 </span>   <span class="Comment"><span class="Comment">#</span> based on '==='.</span>
-<span class="line-numbers"> 149 </span> <span class="FunctionArgument">  _.include: obj, target </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 150 </span>     <span class="Keyword">return</span> _.indexOf(obj, target) <span class="Keyword">isnt</span> <span class="Keyword">-</span><span class="Number">1</span> <span class="Keyword">if</span> _.isArray(obj)
-<span class="line-numbers"> 151 </span>     <span class="Keyword">for</span> key, val <span class="Keyword">ino</span> obj
-<span class="line-numbers"> 152 </span>       <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> val <span class="Keyword">is</span> target
-<span class="line-numbers"> 153 </span>     <span class="BuiltInConstant">false</span>
-<span class="line-numbers"> 154 </span>
-<span class="line-numbers"> 155 </span>
-<span class="line-numbers"> 156 </span>   <span class="Comment"><span class="Comment">#</span> Invoke a method with arguments on every item in a collection.</span>
-<span class="line-numbers"> 157 </span> <span class="FunctionArgument">  _.invoke: obj, method </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 158 </span>     <span class="FunctionName">args</span><span class="Keyword">:</span> _.rest(arguments, <span class="Number">2</span>)
-<span class="line-numbers"> 159 </span>     (<span class="Keyword">if</span> method <span class="Keyword">then</span> val[method] <span class="Keyword">else</span> val).apply(val, args) <span class="Keyword">for</span> val <span class="Keyword">in</span> obj
-<span class="line-numbers"> 160 </span>
-<span class="line-numbers"> 161 </span>
-<span class="line-numbers"> 162 </span>   <span class="Comment"><span class="Comment">#</span> Convenience version of a common use case of map: fetching a property.</span>
-<span class="line-numbers"> 163 </span> <span class="FunctionArgument">  _.pluck: obj, key </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 164 </span>     _.map(obj, (<span class="FunctionArgument">val </span><span class="Storage">=&gt;</span> val[key]))
-<span class="line-numbers"> 165 </span>
-<span class="line-numbers"> 166 </span>
-<span class="line-numbers"> 167 </span>   <span class="Comment"><span class="Comment">#</span> Return the maximum item or (item-based computation).</span>
-<span class="line-numbers"> 168 </span> <span class="FunctionArgument">  _.max: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 169 </span>     <span class="Keyword">return</span> Math.max.apply(Math, obj) <span class="Keyword">if</span> <span class="Keyword">not</span> iterator <span class="Keyword">and</span> _.isArray(obj)
-<span class="line-numbers"> 170 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="Keyword">-</span><span class="BuiltInConstant">Infinity</span>}
-<span class="line-numbers"> 171 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 172 </span>       <span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="Keyword">if</span> iterator <span class="Keyword">then</span> iterator.call(context, value, index, list) <span class="Keyword">else</span> value
-<span class="line-numbers"> 173 </span>       computed <span class="Keyword">&gt;=</span> result.computed <span class="Keyword">and</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">value</span><span class="Keyword">:</span> value, <span class="FunctionName">computed</span><span class="Keyword">:</span> computed})
-<span class="line-numbers"> 174 </span>     result.value
-<span class="line-numbers"> 175 </span>
-<span class="line-numbers"> 176 </span>
-<span class="line-numbers"> 177 </span>   <span class="Comment"><span class="Comment">#</span> Return the minimum element (or element-based computation).</span>
-<span class="line-numbers"> 178 </span> <span class="FunctionArgument">  _.min: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 179 </span>     <span class="Keyword">return</span> Math.min.apply(Math, obj) <span class="Keyword">if</span> <span class="Keyword">not</span> iterator <span class="Keyword">and</span> _.isArray(obj)
-<span class="line-numbers"> 180 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="BuiltInConstant">Infinity</span>}
-<span class="line-numbers"> 181 </span>     _.each(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 182 </span>       <span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="Keyword">if</span> iterator <span class="Keyword">then</span> iterator.call(context, value, index, list) <span class="Keyword">else</span> value
-<span class="line-numbers"> 183 </span>       computed <span class="Keyword">&lt;</span> result.computed <span class="Keyword">and</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">value</span><span class="Keyword">:</span> value, <span class="FunctionName">computed</span><span class="Keyword">:</span> computed})
-<span class="line-numbers"> 184 </span>     result.value
-<span class="line-numbers"> 185 </span>
-<span class="line-numbers"> 186 </span>
-<span class="line-numbers"> 187 </span>   <span class="Comment"><span class="Comment">#</span> Sort the object's values by a criteria produced by an iterator.</span>
-<span class="line-numbers"> 188 </span> <span class="FunctionArgument">  _.sortBy: obj, iterator, context </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 189 </span>     _.pluck(((_.map(obj)<span class="FunctionArgument"> value, index, list </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 190 </span>       {<span class="FunctionName">value</span><span class="Keyword">:</span> value, <span class="FunctionName">criteria</span><span class="Keyword">:</span> iterator.call(context, value, index, list)}
-<span class="line-numbers"> 191 </span>     ).sort()<span class="FunctionArgument"> left, right </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 192 </span>       <span class="FunctionName">a</span><span class="Keyword">:</span> left.criteria; <span class="FunctionName">b</span><span class="Keyword">:</span> right.criteria
-<span class="line-numbers"> 193 </span>       <span class="Keyword">if</span> a <span class="Keyword">&lt;</span> b <span class="Keyword">then</span> <span class="Keyword">-</span><span class="Number">1</span> <span class="Keyword">else</span> <span class="Keyword">if</span> a <span class="Keyword">&gt;</span> b <span class="Keyword">then</span> <span class="Number">1</span> <span class="Keyword">else</span> <span class="Number">0</span>
-<span class="line-numbers"> 194 </span>     ), <span class="String"><span class="String">'</span>value<span class="String">'</span></span>)
-<span class="line-numbers"> 195 </span>
-<span class="line-numbers"> 196 </span>
-<span class="line-numbers"> 197 </span>   <span class="Comment"><span class="Comment">#</span> Use a comparator function to figure out at what index an object should</span>
-<span class="line-numbers"> 198 </span>   <span class="Comment"><span class="Comment">#</span> be inserted so as to maintain order. Uses binary search.</span>
-<span class="line-numbers"> 199 </span> <span class="FunctionArgument">  _.sortedIndex: array, obj, iterator </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 200 </span>     iterator <span class="Keyword">||</span><span class="Keyword">=</span> _.identity
-<span class="line-numbers"> 201 </span>     <span class="FunctionName">low</span><span class="Keyword">:</span> <span class="Number">0</span>; <span class="FunctionName">high</span><span class="Keyword">:</span> array.length
-<span class="line-numbers"> 202 </span>     <span class="Keyword">while</span> low <span class="Keyword">&lt;</span> high
-<span class="line-numbers"> 203 </span>       <span class="FunctionName">mid</span><span class="Keyword">:</span> (low <span class="Keyword">+</span> high) <span class="Keyword">&gt;</span><span class="Keyword">&gt;</span> <span class="Number">1</span>
-<span class="line-numbers"> 204 </span>       <span class="Keyword">if</span> iterator(array[mid]) <span class="Keyword">&lt;</span> iterator(obj) <span class="Keyword">then</span> <span class="FunctionName">low</span><span class="Keyword">:</span> mid <span class="Keyword">+</span> <span class="Number">1</span> <span class="Keyword">else</span> <span class="FunctionName">high</span><span class="Keyword">:</span> mid
-<span class="line-numbers"> 205 </span>     low
-<span class="line-numbers"> 206 </span>
-<span class="line-numbers"> 207 </span>
-<span class="line-numbers"> 208 </span>   <span class="Comment"><span class="Comment">#</span> Convert anything iterable into a real, live array.</span>
-<span class="line-numbers"> 209 </span> <span class="FunctionArgument">  _.toArray: iterable </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 210 </span>     <span class="Keyword">return</span> []                   <span class="Keyword">if</span> (<span class="Keyword">!</span>iterable)
-<span class="line-numbers"> 211 </span>     <span class="Keyword">return</span> iterable.toArray()   <span class="Keyword">if</span> (iterable.toArray)
-<span class="line-numbers"> 212 </span>     <span class="Keyword">return</span> iterable             <span class="Keyword">if</span> (_.isArray(iterable))
-<span class="line-numbers"> 213 </span>     <span class="Keyword">return</span> slice.call(iterable) <span class="Keyword">if</span> (_.isArguments(iterable))
-<span class="line-numbers"> 214 </span>     _.values(iterable)
-<span class="line-numbers"> 215 </span>
-<span class="line-numbers"> 216 </span>
-<span class="line-numbers"> 217 </span>   <span class="Comment"><span class="Comment">#</span> Return the number of elements in an object.</span>
-<span class="line-numbers"> 218 </span> <span class="FunctionArgument">  _.size: obj </span><span class="Storage">=&gt;</span> _.toArray(obj).length
-<span class="line-numbers"> 219 </span>
-<span class="line-numbers"> 220 </span>
-<span class="line-numbers"> 221 </span>   <span class="Comment"><span class="Comment">#</span> -------------------------- Array Functions: ------------------------------</span>
-<span class="line-numbers"> 222 </span>
-<span class="line-numbers"> 223 </span>   <span class="Comment"><span class="Comment">#</span> Get the first element of an array. Passing &quot;n&quot; will return the first N</span>
-<span class="line-numbers"> 224 </span>   <span class="Comment"><span class="Comment">#</span> values in the array. Aliased as &quot;head&quot;. The &quot;guard&quot; check allows it to work</span>
-<span class="line-numbers"> 225 </span>   <span class="Comment"><span class="Comment">#</span> with _.map.</span>
-<span class="line-numbers"> 226 </span> <span class="FunctionArgument">  _.first: array, n, guard </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 227 </span>     <span class="Keyword">if</span> n <span class="Keyword">and</span> <span class="Keyword">not</span> guard <span class="Keyword">then</span> slice.call(array, <span class="Number">0</span>, n) <span class="Keyword">else</span> array[<span class="Number">0</span>]
-<span class="line-numbers"> 228 </span>
-<span class="line-numbers"> 229 </span>
-<span class="line-numbers"> 230 </span>   <span class="Comment"><span class="Comment">#</span> Returns everything but the first entry of the array. Aliased as &quot;tail&quot;.</span>
-<span class="line-numbers"> 231 </span>   <span class="Comment"><span class="Comment">#</span> Especially useful on the arguments object. Passing an &quot;index&quot; will return</span>
-<span class="line-numbers"> 232 </span>   <span class="Comment"><span class="Comment">#</span> the rest of the values in the array from that index onward. The &quot;guard&quot;</span>
-<span class="line-numbers"> 233 </span>   <span class="Comment"><span class="Comment">#</span> check allows it to work with _.map.</span>
-<span class="line-numbers"> 234 </span> <span class="FunctionArgument">  _.rest: array, index, guard </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 235 </span>     slice.call(array, <span class="Keyword">if</span> _.isUndefined(index) <span class="Keyword">or</span> guard <span class="Keyword">then</span> <span class="Number">1</span> <span class="Keyword">else</span> index)
-<span class="line-numbers"> 236 </span>
-<span class="line-numbers"> 237 </span>
-<span class="line-numbers"> 238 </span>   <span class="Comment"><span class="Comment">#</span> Get the last element of an array.</span>
-<span class="line-numbers"> 239 </span> <span class="FunctionArgument">  _.last: array </span><span class="Storage">=&gt;</span> array[array.length <span class="Keyword">-</span> <span class="Number">1</span>]
-<span class="line-numbers"> 240 </span>
-<span class="line-numbers"> 241 </span>
-<span class="line-numbers"> 242 </span>   <span class="Comment"><span class="Comment">#</span> Trim out all falsy values from an array.</span>
-<span class="line-numbers"> 243 </span> <span class="FunctionArgument">  _.compact: array </span><span class="Storage">=&gt;</span> array[i] <span class="Keyword">for</span> i <span class="Keyword">in</span> [<span class="Number">0</span>...array.length] <span class="Keyword">when</span> array[i]
-<span class="line-numbers"> 244 </span>
-<span class="line-numbers"> 245 </span>
-<span class="line-numbers"> 246 </span>   <span class="Comment"><span class="Comment">#</span> Return a completely flattened version of an array.</span>
-<span class="line-numbers"> 247 </span> <span class="FunctionArgument">  _.flatten: array </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 248 </span>     _.reduce(array, [])<span class="FunctionArgument"> memo, value </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 249 </span>       <span class="Keyword">return</span> memo.concat(_.flatten(value)) <span class="Keyword">if</span> _.isArray(value)
-<span class="line-numbers"> 250 </span>       memo.push(value)
-<span class="line-numbers"> 251 </span>       memo
-<span class="line-numbers"> 252 </span>
-<span class="line-numbers"> 253 </span>
-<span class="line-numbers"> 254 </span>   <span class="Comment"><span class="Comment">#</span> Return a version of the array that does not contain the specified value(s).</span>
-<span class="line-numbers"> 255 </span> <span class="FunctionArgument">  _.without: array </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 256 </span>     <span class="FunctionName">values</span><span class="Keyword">:</span> _.rest(arguments)
-<span class="line-numbers"> 257 </span>     val <span class="Keyword">for</span> val <span class="Keyword">in</span> _.toArray(array) <span class="Keyword">when</span> <span class="Keyword">not</span> _.include(values, val)
-<span class="line-numbers"> 258 </span>
-<span class="line-numbers"> 259 </span>
-<span class="line-numbers"> 260 </span>   <span class="Comment"><span class="Comment">#</span> Produce a duplicate-free version of the array. If the array has already</span>
-<span class="line-numbers"> 261 </span>   <span class="Comment"><span class="Comment">#</span> been sorted, you have the option of using a faster algorithm.</span>
-<span class="line-numbers"> 262 </span> <span class="FunctionArgument">  _.uniq: array, isSorted </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 263 </span>     <span class="FunctionName">memo</span><span class="Keyword">:</span> []
-<span class="line-numbers"> 264 </span>     <span class="Keyword">for</span> el, i <span class="Keyword">in</span> _.toArray(array)
-<span class="line-numbers"> 265 </span>       memo.push(el) <span class="Keyword">if</span> i <span class="Keyword">is</span> <span class="Number">0</span> <span class="Keyword">||</span> (<span class="Keyword">if</span> isSorted <span class="Keyword">is</span> <span class="BuiltInConstant">true</span> <span class="Keyword">then</span> _.last(memo) <span class="Keyword">isnt</span> el <span class="Keyword">else</span> <span class="Keyword">not</span> _.include(memo, el))
-<span class="line-numbers"> 266 </span>     memo
-<span class="line-numbers"> 267 </span>
-<span class="line-numbers"> 268 </span>
-<span class="line-numbers"> 269 </span>   <span class="Comment"><span class="Comment">#</span> Produce an array that contains every item shared between all the</span>
-<span class="line-numbers"> 270 </span>   <span class="Comment"><span class="Comment">#</span> passed-in arrays.</span>
-<span class="line-numbers"> 271 </span> <span class="FunctionArgument">  _.intersect: array </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 272 </span>     <span class="FunctionName">rest</span><span class="Keyword">:</span> _.rest(arguments)
-<span class="line-numbers"> 273 </span>     _.select(_.uniq(array))<span class="FunctionArgument"> item </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 274 </span>       _.all(rest)<span class="FunctionArgument"> other </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 275 </span>         _.indexOf(other, item) <span class="Keyword">&gt;=</span> <span class="Number">0</span>
-<span class="line-numbers"> 276 </span>
-<span class="line-numbers"> 277 </span>
-<span class="line-numbers"> 278 </span>   <span class="Comment"><span class="Comment">#</span> Zip together multiple lists into a single array -- elements that share</span>
-<span class="line-numbers"> 279 </span>   <span class="Comment"><span class="Comment">#</span> an index go together.</span>
-<span class="line-numbers"> 280 </span> <span class="FunctionArgument">  _.zip: </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 281 </span>     <span class="FunctionName">args</span><span class="Keyword">:</span>       _.toArray(arguments)
-<span class="line-numbers"> 282 </span>     <span class="FunctionName">length</span><span class="Keyword">:</span>     _.max(_.pluck(args, <span class="String"><span class="String">'</span>length<span class="String">'</span></span>))
-<span class="line-numbers"> 283 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span>    <span class="Keyword">new</span> <span class="TypeName">Array</span>(length)
-<span class="line-numbers"> 284 </span>     <span class="Keyword">for</span> i <span class="Keyword">in</span> [<span class="Number">0</span>...length]
-<span class="line-numbers"> 285 </span>       results[i]<span class="Keyword">:</span> _.pluck(args, String(i))
-<span class="line-numbers"> 286 </span>     results
-<span class="line-numbers"> 287 </span>
-<span class="line-numbers"> 288 </span>
-<span class="line-numbers"> 289 </span>   <span class="Comment"><span class="Comment">#</span> If the browser doesn't supply us with indexOf (I'm looking at you, MSIE),</span>
-<span class="line-numbers"> 290 </span>   <span class="Comment"><span class="Comment">#</span> we need this function. Return the position of the first occurence of an</span>
-<span class="line-numbers"> 291 </span>   <span class="Comment"><span class="Comment">#</span> item in an array, or -1 if the item is not included in the array.</span>
-<span class="line-numbers"> 292 </span> <span class="FunctionArgument">  _.indexOf: array, item </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 293 </span>     <span class="Keyword">return</span> array.indexOf(item) <span class="Keyword">if</span> array.indexOf
-<span class="line-numbers"> 294 </span>     <span class="FunctionName">i</span><span class="Keyword">:</span> <span class="Number">0</span>; <span class="FunctionName">l</span><span class="Keyword">:</span> array.length
-<span class="line-numbers"> 295 </span>     <span class="Keyword">while</span> l <span class="Keyword">-</span> i
-<span class="line-numbers"> 296 </span>       <span class="Keyword">if</span> array[i] <span class="Keyword">is</span> item <span class="Keyword">then</span> <span class="Keyword">return</span> i <span class="Keyword">else</span> i<span class="Keyword">++</span>
-<span class="line-numbers"> 297 </span>     <span class="Keyword">-</span><span class="Number">1</span>
-<span class="line-numbers"> 298 </span>
-<span class="line-numbers"> 299 </span>
-<span class="line-numbers"> 300 </span>   <span class="Comment"><span class="Comment">#</span> Provide JavaScript 1.6's lastIndexOf, delegating to the native function,</span>
-<span class="line-numbers"> 301 </span>   <span class="Comment"><span class="Comment">#</span> if possible.</span>
-<span class="line-numbers"> 302 </span> <span class="FunctionArgument">  _.lastIndexOf: array, item </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 303 </span>     <span class="Keyword">return</span> array.lastIndexOf(item) <span class="Keyword">if</span> array.lastIndexOf
-<span class="line-numbers"> 304 </span>     <span class="FunctionName">i</span><span class="Keyword">:</span> array.length
-<span class="line-numbers"> 305 </span>     <span class="Keyword">while</span> i
-<span class="line-numbers"> 306 </span>       <span class="Keyword">if</span> array[i] <span class="Keyword">is</span> item <span class="Keyword">then</span> <span class="Keyword">return</span> i <span class="Keyword">else</span> i<span class="Keyword">--</span>
-<span class="line-numbers"> 307 </span>     <span class="Keyword">-</span><span class="Number">1</span>
-<span class="line-numbers"> 308 </span>
-<span class="line-numbers"> 309 </span>
-<span class="line-numbers"> 310 </span>   <span class="Comment"><span class="Comment">#</span> Generate an integer Array containing an arithmetic progression. A port of</span>
-<span class="line-numbers"> 311 </span>   <span class="Comment"><span class="Comment">#</span> the native Python range() function. See:</span>
-<span class="line-numbers"> 312 </span>   <span class="Comment"><span class="Comment">#</span> http://docs.python.org/library/functions.html#range</span>
-<span class="line-numbers"> 313 </span> <span class="FunctionArgument">  _.range: start, stop, step </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 314 </span>     <span class="FunctionName">a</span><span class="Keyword">:</span>        _.toArray(arguments)
-<span class="line-numbers"> 315 </span>     <span class="FunctionName">solo</span><span class="Keyword">:</span>     a.length <span class="Keyword">&lt;=</span> <span class="Number">1</span>
-<span class="line-numbers"> 316 </span>     <span class="FunctionName">i</span><span class="Keyword">:</span> <span class="FunctionName">start</span><span class="Keyword">:</span> <span class="Keyword">if</span> solo <span class="Keyword">then</span> <span class="Number">0</span> <span class="Keyword">else</span> a[<span class="Number">0</span>];
-<span class="line-numbers"> 317 </span>     <span class="FunctionName">stop</span><span class="Keyword">:</span>     <span class="Keyword">if</span> solo <span class="Keyword">then</span> a[<span class="Number">0</span>] <span class="Keyword">else</span> a[<span class="Number">1</span>];
-<span class="line-numbers"> 318 </span>     <span class="FunctionName">step</span><span class="Keyword">:</span>     a[<span class="Number">2</span>] <span class="Keyword">or</span> <span class="Number">1</span>
-<span class="line-numbers"> 319 </span>     <span class="FunctionName">len</span><span class="Keyword">:</span>      Math.ceil((stop <span class="Keyword">-</span> start) <span class="Keyword">/</span> step)
-<span class="line-numbers"> 320 </span>     <span class="Keyword">return</span> [] <span class="Keyword">if</span> len <span class="Keyword">&lt;=</span> <span class="Number">0</span>
-<span class="line-numbers"> 321 </span>     <span class="FunctionName">range</span><span class="Keyword">:</span>    <span class="Keyword">new</span> <span class="TypeName">Array</span>(len)
-<span class="line-numbers"> 322 </span>     <span class="FunctionName">idx</span><span class="Keyword">:</span>      <span class="Number">0</span>
-<span class="line-numbers"> 323 </span>     <span class="Keyword">while</span> <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 324 </span>       <span class="Keyword">return</span> range <span class="Keyword">if</span> (<span class="Keyword">if</span> step <span class="Keyword">&gt;</span> <span class="Number">0</span> <span class="Keyword">then</span> i <span class="Keyword">-</span> stop <span class="Keyword">else</span> stop <span class="Keyword">-</span> i) <span class="Keyword">&gt;=</span> <span class="Number">0</span>
-<span class="line-numbers"> 325 </span>       range[idx]<span class="Keyword">:</span> i
-<span class="line-numbers"> 326 </span>       idx<span class="Keyword">++</span>
-<span class="line-numbers"> 327 </span>       i<span class="Keyword">+</span><span class="Keyword">=</span> step
-<span class="line-numbers"> 328 </span>
-<span class="line-numbers"> 329 </span>
-<span class="line-numbers"> 330 </span>   <span class="Comment"><span class="Comment">#</span> ----------------------- Function Functions: -----------------------------</span>
-<span class="line-numbers"> 331 </span>
-<span class="line-numbers"> 332 </span>   <span class="Comment"><span class="Comment">#</span> Create a function bound to a given object (assigning 'this', and arguments,</span>
-<span class="line-numbers"> 333 </span>   <span class="Comment"><span class="Comment">#</span> optionally). Binding with arguments is also known as 'curry'.</span>
-<span class="line-numbers"> 334 </span> <span class="FunctionArgument">  _.bind: func, obj </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 335 </span>     <span class="FunctionName">args</span><span class="Keyword">:</span> _.rest(arguments, <span class="Number">2</span>)
-<span class="line-numbers"> 336 </span> <span class="FunctionArgument">    </span><span class="Storage">=&gt;</span> func.apply(obj <span class="Keyword">or</span> root, args.concat(_.toArray(arguments)))
-<span class="line-numbers"> 337 </span>
-<span class="line-numbers"> 338 </span>
-<span class="line-numbers"> 339 </span>   <span class="Comment"><span class="Comment">#</span> Bind all of an object's methods to that object. Useful for ensuring that</span>
-<span class="line-numbers"> 340 </span>   <span class="Comment"><span class="Comment">#</span> all callbacks defined on an object belong to it.</span>
-<span class="line-numbers"> 341 </span> <span class="FunctionArgument">  _.bindAll: obj </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 342 </span>     <span class="FunctionName">funcs</span><span class="Keyword">:</span> <span class="Keyword">if</span> arguments.length <span class="Keyword">&gt;</span> <span class="Number">1</span> <span class="Keyword">then</span> _.rest(arguments) <span class="Keyword">else</span> _.functions(obj)
-<span class="line-numbers"> 343 </span>     _.each(funcs, (<span class="FunctionArgument">f </span><span class="Storage">=&gt;</span> obj[f]<span class="Keyword">:</span> _.bind(obj[f], obj)))
-<span class="line-numbers"> 344 </span>     obj
-<span class="line-numbers"> 345 </span>
-<span class="line-numbers"> 346 </span>
-<span class="line-numbers"> 347 </span>   <span class="Comment"><span class="Comment">#</span> Delays a function for the given number of milliseconds, and then calls</span>
-<span class="line-numbers"> 348 </span>   <span class="Comment"><span class="Comment">#</span> it with the arguments supplied.</span>
-<span class="line-numbers"> 349 </span> <span class="FunctionArgument">  _.delay: func, wait </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 350 </span>     <span class="FunctionName">args</span><span class="Keyword">:</span> _.rest(arguments, <span class="Number">2</span>)
-<span class="line-numbers"> 351 </span>     setTimeout((<span class="Storage">=&gt;</span> func.apply(func, args)), wait)
-<span class="line-numbers"> 352 </span>
-<span class="line-numbers"> 353 </span>
-<span class="line-numbers"> 354 </span>   <span class="Comment"><span class="Comment">#</span> Defers a function, scheduling it to run after the current call stack has</span>
-<span class="line-numbers"> 355 </span>   <span class="Comment"><span class="Comment">#</span> cleared.</span>
-<span class="line-numbers"> 356 </span> <span class="FunctionArgument">  _.defer: func </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 357 </span>     _.delay.apply(_, [func, <span class="Number">1</span>].concat(_.rest(arguments)))
-<span class="line-numbers"> 358 </span>
-<span class="line-numbers"> 359 </span>
-<span class="line-numbers"> 360 </span>   <span class="Comment"><span class="Comment">#</span> Returns the first function passed as an argument to the second,</span>
-<span class="line-numbers"> 361 </span>   <span class="Comment"><span class="Comment">#</span> allowing you to adjust arguments, run code before and after, and</span>
-<span class="line-numbers"> 362 </span>   <span class="Comment"><span class="Comment">#</span> conditionally execute the original function.</span>
-<span class="line-numbers"> 363 </span> <span class="FunctionArgument">  _.wrap: func, wrapper </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 364 </span> <span class="FunctionArgument">    </span><span class="Storage">=&gt;</span> wrapper.apply(wrapper, [func].concat(_.toArray(arguments)))
-<span class="line-numbers"> 365 </span>
-<span class="line-numbers"> 366 </span>
-<span class="line-numbers"> 367 </span>   <span class="Comment"><span class="Comment">#</span> Returns a function that is the composition of a list of functions, each</span>
-<span class="line-numbers"> 368 </span>   <span class="Comment"><span class="Comment">#</span> consuming the return value of the function that follows.</span>
-<span class="line-numbers"> 369 </span> <span class="FunctionArgument">  _.compose: </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 370 </span>     <span class="FunctionName">funcs</span><span class="Keyword">:</span> _.toArray(arguments)
-<span class="line-numbers"> 371 </span> <span class="FunctionArgument">    </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 372 </span>       <span class="FunctionName">args</span><span class="Keyword">:</span> _.toArray(arguments)
-<span class="line-numbers"> 373 </span>       <span class="Keyword">for</span> i <span class="Keyword">in</span> [(funcs.length <span class="Keyword">-</span> <span class="Number">1</span>)..<span class="Number">0</span>]
-<span class="line-numbers"> 374 </span>         <span class="FunctionName">args</span><span class="Keyword">:</span> [funcs[i].apply(<span class="Variable">this</span>, args)]
-<span class="line-numbers"> 375 </span>       args[<span class="Number">0</span>]
-<span class="line-numbers"> 376 </span>
-<span class="line-numbers"> 377 </span>
-<span class="line-numbers"> 378 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------- Object Functions: ----------------------------</span>
-<span class="line-numbers"> 379 </span>
-<span class="line-numbers"> 380 </span>   <span class="Comment"><span class="Comment">#</span> Retrieve the names of an object's properties.</span>
-<span class="line-numbers"> 381 </span> <span class="FunctionArgument">  _.keys: obj </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 382 </span>     <span class="Keyword">return</span> _.range(<span class="Number">0</span>, obj.length) <span class="Keyword">if</span> _.isArray(obj)
-<span class="line-numbers"> 383 </span>     key <span class="Keyword">for</span> key, val <span class="Keyword">ino</span> obj
-<span class="line-numbers"> 384 </span>
-<span class="line-numbers"> 385 </span>
-<span class="line-numbers"> 386 </span>   <span class="Comment"><span class="Comment">#</span> Retrieve the values of an object's properties.</span>
-<span class="line-numbers"> 387 </span> <span class="FunctionArgument">  _.values: obj </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 388 </span>     _.map(obj, _.identity)
-<span class="line-numbers"> 389 </span>
-<span class="line-numbers"> 390 </span>
-<span class="line-numbers"> 391 </span>   <span class="Comment"><span class="Comment">#</span> Return a sorted list of the function names available in Underscore.</span>
-<span class="line-numbers"> 392 </span> <span class="FunctionArgument">  _.functions: obj </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 393 </span>     _.select(_.keys(obj)<span class="FunctionArgument">, key </span><span class="Storage">=&gt;</span> _.isFunction(obj[key])).sort()
-<span class="line-numbers"> 394 </span>
-<span class="line-numbers"> 395 </span>
-<span class="line-numbers"> 396 </span>   <span class="Comment"><span class="Comment">#</span> Extend a given object with all of the properties in a source object.</span>
-<span class="line-numbers"> 397 </span> <span class="FunctionArgument">  _.extend: destination, source </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 398 </span>     <span class="Keyword">for</span> key, val <span class="Keyword">ino</span> source
-<span class="line-numbers"> 399 </span>       destination[key]<span class="Keyword">:</span> val
-<span class="line-numbers"> 400 </span>     destination
-<span class="line-numbers"> 401 </span>
-<span class="line-numbers"> 402 </span>
-<span class="line-numbers"> 403 </span>   <span class="Comment"><span class="Comment">#</span> Create a (shallow-cloned) duplicate of an object.</span>
-<span class="line-numbers"> 404 </span> <span class="FunctionArgument">  _.clone: obj </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 405 </span>     <span class="Keyword">return</span> obj.slice(<span class="Number">0</span>) <span class="Keyword">if</span> _.isArray(obj)
-<span class="line-numbers"> 406 </span>     _.extend({}, obj)
-<span class="line-numbers"> 407 </span>
-<span class="line-numbers"> 408 </span>
-<span class="line-numbers"> 409 </span>   <span class="Comment"><span class="Comment">#</span> Invokes interceptor with the obj, and then returns obj.</span>
-<span class="line-numbers"> 410 </span>   <span class="Comment"><span class="Comment">#</span> The primary purpose of this method is to &quot;tap into&quot; a method chain, in order to perform operations on intermediate results within the chain.</span>
-<span class="line-numbers"> 411 </span> <span class="FunctionArgument">  _.tap: obj, interceptor </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 412 </span>     interceptor(obj)
-<span class="line-numbers"> 413 </span>     obj
-<span class="line-numbers"> 414 </span>
-<span class="line-numbers"> 415 </span>
-<span class="line-numbers"> 416 </span>   <span class="Comment"><span class="Comment">#</span> Perform a deep comparison to check if two objects are equal.</span>
-<span class="line-numbers"> 417 </span> <span class="FunctionArgument">  _.isEqual: a, b </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 418 </span>     <span class="Comment"><span class="Comment">#</span> Check object identity.</span>
-<span class="line-numbers"> 419 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> a <span class="Keyword">is</span> b
-<span class="line-numbers"> 420 </span>     <span class="Comment"><span class="Comment">#</span> Different types?</span>
-<span class="line-numbers"> 421 </span>     <span class="FunctionName">atype</span><span class="Keyword">:</span> <span class="Keyword">typeof</span>(a); <span class="FunctionName">btype</span><span class="Keyword">:</span> <span class="Keyword">typeof</span>(b)
-<span class="line-numbers"> 422 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> atype <span class="Keyword">isnt</span> btype
-<span class="line-numbers"> 423 </span>     <span class="Comment"><span class="Comment">#</span> Basic equality test (watch out for coercions).</span>
-<span class="line-numbers"> 424 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> <span class="String"><span class="String">`</span>a == b<span class="String">`</span></span>
-<span class="line-numbers"> 425 </span>     <span class="Comment"><span class="Comment">#</span> One is falsy and the other truthy.</span>
-<span class="line-numbers"> 426 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> (<span class="Keyword">!</span>a <span class="Keyword">and</span> b) <span class="Keyword">or</span> (a <span class="Keyword">and</span> <span class="Keyword">!</span>b)
-<span class="line-numbers"> 427 </span>     <span class="Comment"><span class="Comment">#</span> One of them implements an isEqual()?</span>
-<span class="line-numbers"> 428 </span>     <span class="Keyword">return</span> a.isEqual(b) <span class="Keyword">if</span> a.isEqual
-<span class="line-numbers"> 429 </span>     <span class="Comment"><span class="Comment">#</span> Check dates' integer values.</span>
-<span class="line-numbers"> 430 </span>     <span class="Keyword">return</span> a.getTime() <span class="Keyword">is</span> b.getTime() <span class="Keyword">if</span> _.isDate(a) <span class="Keyword">and</span> _.isDate(b)
-<span class="line-numbers"> 431 </span>     <span class="Comment"><span class="Comment">#</span> Both are NaN?</span>
-<span class="line-numbers"> 432 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> _.isNaN(a) <span class="Keyword">and</span> _.isNaN(b)
-<span class="line-numbers"> 433 </span>     <span class="Comment"><span class="Comment">#</span> Compare regular expressions.</span>
-<span class="line-numbers"> 434 </span>     <span class="Keyword">if</span> _.isRegExp(a) <span class="Keyword">and</span> _.isRegExp(b)
-<span class="line-numbers"> 435 </span>       <span class="Keyword">return</span> a.source     <span class="Keyword">is</span> b.source <span class="Keyword">and</span>
-<span class="line-numbers"> 436 </span>              a.global     <span class="Keyword">is</span> b.global <span class="Keyword">and</span>
-<span class="line-numbers"> 437 </span>              a.ignoreCase <span class="Keyword">is</span> b.ignoreCase <span class="Keyword">and</span>
-<span class="line-numbers"> 438 </span>              a.multiline  <span class="Keyword">is</span> b.multiline
-<span class="line-numbers"> 439 </span>     <span class="Comment"><span class="Comment">#</span> If a is not an object by this point, we can't handle it.</span>
-<span class="line-numbers"> 440 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> atype <span class="Keyword">isnt</span> <span class="String"><span class="String">'</span>object<span class="String">'</span></span>
-<span class="line-numbers"> 441 </span>     <span class="Comment"><span class="Comment">#</span> Check for different array lengths before comparing contents.</span>
-<span class="line-numbers"> 442 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> a.length <span class="Keyword">and</span> (a.length <span class="Keyword">isnt</span> b.length)
-<span class="line-numbers"> 443 </span>     <span class="Comment"><span class="Comment">#</span> Nothing else worked, deep compare the contents.</span>
-<span class="line-numbers"> 444 </span>     <span class="FunctionName">aKeys</span><span class="Keyword">:</span> _.keys(a); <span class="FunctionName">bKeys</span><span class="Keyword">:</span> _.keys(b)
-<span class="line-numbers"> 445 </span>     <span class="Comment"><span class="Comment">#</span> Different object sizes?</span>
-<span class="line-numbers"> 446 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> aKeys.length <span class="Keyword">isnt</span> bKeys.length
-<span class="line-numbers"> 447 </span>     <span class="Comment"><span class="Comment">#</span> Recursive comparison of contents.</span>
-<span class="line-numbers"> 448 </span>     <span class="Comment"><span class="Comment">#</span> for (var key in a) if (!_.isEqual(a[key], b[key])) return false;</span>
-<span class="line-numbers"> 449 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 450 </span>
-<span class="line-numbers"> 451 </span>
-<span class="line-numbers"> 452 </span>   <span class="Comment"><span class="Comment">#</span> Is a given array or object empty?</span>
-<span class="line-numbers"> 453 </span> <span class="FunctionArgument">  _.isEmpty:      obj </span><span class="Storage">=&gt;</span> _.keys(obj).length <span class="Keyword">is</span> <span class="Number">0</span>
-<span class="line-numbers"> 454 </span>
-<span class="line-numbers"> 455 </span>
-<span class="line-numbers"> 456 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value a DOM element?</span>
-<span class="line-numbers"> 457 </span> <span class="FunctionArgument">  _.isElement:    obj </span><span class="Storage">=&gt;</span> obj <span class="Keyword">and</span> obj.nodeType <span class="Keyword">is</span> <span class="Number">1</span>
-<span class="line-numbers"> 458 </span>
-<span class="line-numbers"> 459 </span>
-<span class="line-numbers"> 460 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value an array?</span>
-<span class="line-numbers"> 461 </span> <span class="FunctionArgument">  _.isArray:      obj </span><span class="Storage">=&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.concat <span class="Keyword">and</span> obj.unshift)
-<span class="line-numbers"> 462 </span>
-<span class="line-numbers"> 463 </span>
-<span class="line-numbers"> 464 </span>   <span class="Comment"><span class="Comment">#</span> Is a given variable an arguments object?</span>
-<span class="line-numbers"> 465 </span> <span class="FunctionArgument">  _.isArguments:  obj </span><span class="Storage">=&gt;</span> obj <span class="Keyword">and</span> _.isNumber(obj.length) <span class="Keyword">and</span> <span class="Keyword">!</span>_.isArray(obj) <span class="Keyword">and</span> <span class="Keyword">!</span>propertyIsEnumerable.call(obj, <span class="String"><span class="String">'</span>length<span class="String">'</span></span>)
-<span class="line-numbers"> 466 </span>
-<span class="line-numbers"> 467 </span>
-<span class="line-numbers"> 468 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value a function?</span>
-<span class="line-numbers"> 469 </span> <span class="FunctionArgument">  _.isFunction:   obj </span><span class="Storage">=&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.constructor <span class="Keyword">and</span> obj.call <span class="Keyword">and</span> obj.apply)
-<span class="line-numbers"> 470 </span>
-<span class="line-numbers"> 471 </span>
-<span class="line-numbers"> 472 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value a string?</span>
-<span class="line-numbers"> 473 </span> <span class="FunctionArgument">  _.isString:     obj </span><span class="Storage">=&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">is</span> <span class="String"><span class="String">'</span><span class="String">'</span></span> <span class="Keyword">or</span> (obj <span class="Keyword">and</span> obj.charCodeAt <span class="Keyword">and</span> obj.substr))
-<span class="line-numbers"> 474 </span>
-<span class="line-numbers"> 475 </span>
-<span class="line-numbers"> 476 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value a number?</span>
-<span class="line-numbers"> 477 </span> <span class="FunctionArgument">  _.isNumber:     obj </span><span class="Storage">=&gt;</span> toString.call(obj) <span class="Keyword">is</span> <span class="String"><span class="String">'</span>[object Number]<span class="String">'</span></span>
-<span class="line-numbers"> 478 </span>
-<span class="line-numbers"> 479 </span>
-<span class="line-numbers"> 480 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value a Date?</span>
-<span class="line-numbers"> 481 </span> <span class="FunctionArgument">  _.isDate:       obj </span><span class="Storage">=&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.getTimezoneOffset <span class="Keyword">and</span> obj.setUTCFullYear)
-<span class="line-numbers"> 482 </span>
-<span class="line-numbers"> 483 </span>
-<span class="line-numbers"> 484 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value a regular expression?</span>
-<span class="line-numbers"> 485 </span> <span class="FunctionArgument">  _.isRegExp:     obj </span><span class="Storage">=&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.exec <span class="Keyword">and</span> (obj.ignoreCase <span class="Keyword">or</span> obj.ignoreCase <span class="Keyword">is</span> <span class="BuiltInConstant">false</span>))
-<span class="line-numbers"> 486 </span>
-<span class="line-numbers"> 487 </span>
-<span class="line-numbers"> 488 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value NaN -- this one is interesting. NaN != NaN, and</span>
-<span class="line-numbers"> 489 </span>   <span class="Comment"><span class="Comment">#</span> isNaN(undefined) == true, so we make sure it's a number first.</span>
-<span class="line-numbers"> 490 </span> <span class="FunctionArgument">  _.isNaN:        obj </span><span class="Storage">=&gt;</span> _.isNumber(obj) <span class="Keyword">and</span> window.isNaN(obj)
-<span class="line-numbers"> 491 </span>
-<span class="line-numbers"> 492 </span>
-<span class="line-numbers"> 493 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value equal to null?</span>
-<span class="line-numbers"> 494 </span> <span class="FunctionArgument">  _.isNull:       obj </span><span class="Storage">=&gt;</span> obj <span class="Keyword">is</span> <span class="BuiltInConstant">null</span>
-<span class="line-numbers"> 495 </span>
-<span class="line-numbers"> 496 </span>
-<span class="line-numbers"> 497 </span>   <span class="Comment"><span class="Comment">#</span> Is a given variable undefined?</span>
-<span class="line-numbers"> 498 </span> <span class="FunctionArgument">  _.isUndefined:  obj </span><span class="Storage">=&gt;</span> <span class="Keyword">typeof</span> obj <span class="Keyword">is</span> <span class="String"><span class="String">'</span>undefined<span class="String">'</span></span>
-<span class="line-numbers"> 499 </span>
-<span class="line-numbers"> 500 </span>
-<span class="line-numbers"> 501 </span>   <span class="Comment"><span class="Comment">#</span> -------------------------- Utility Functions: --------------------------</span>
-<span class="line-numbers"> 502 </span>
-<span class="line-numbers"> 503 </span>   <span class="Comment"><span class="Comment">#</span> Run Underscore.js in noConflict mode, returning the '_' variable to its</span>
-<span class="line-numbers"> 504 </span>   <span class="Comment"><span class="Comment">#</span> previous owner. Returns a reference to the Underscore object.</span>
-<span class="line-numbers"> 505 </span> <span class="FunctionArgument">  _.noConflict: </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 506 </span>     root.<span class="FunctionName">_</span><span class="Keyword">:</span> previousUnderscore
-<span class="line-numbers"> 507 </span>     <span class="Variable">this</span>
-<span class="line-numbers"> 508 </span>
-<span class="line-numbers"> 509 </span>
-<span class="line-numbers"> 510 </span>   <span class="Comment"><span class="Comment">#</span> Keep the identity function around for default iterators.</span>
-<span class="line-numbers"> 511 </span> <span class="FunctionArgument">  _.identity: value </span><span class="Storage">=&gt;</span> value
-<span class="line-numbers"> 512 </span>
-<span class="line-numbers"> 513 </span>
-<span class="line-numbers"> 514 </span>   <span class="Comment"><span class="Comment">#</span> Break out of the middle of an iteration.</span>
-<span class="line-numbers"> 515 </span> <span class="FunctionArgument">  _.breakLoop: </span><span class="Storage">=&gt;</span> <span class="Keyword">throw</span> breaker
-<span class="line-numbers"> 516 </span>
-<span class="line-numbers"> 517 </span>
-<span class="line-numbers"> 518 </span>   <span class="Comment"><span class="Comment">#</span> Generate a unique integer id (unique within the entire client session).</span>
-<span class="line-numbers"> 519 </span>   <span class="Comment"><span class="Comment">#</span> Useful for temporary DOM ids.</span>
-<span class="line-numbers"> 520 </span>   <span class="FunctionName">idCounter</span><span class="Keyword">:</span> <span class="Number">0</span>
-<span class="line-numbers"> 521 </span> <span class="FunctionArgument">  _.uniqueId: prefix </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 522 </span>     (prefix <span class="Keyword">or</span> <span class="String"><span class="String">'</span><span class="String">'</span></span>) <span class="Keyword">+</span> idCounter<span class="Keyword">++</span>
-<span class="line-numbers"> 523 </span>
-<span class="line-numbers"> 524 </span>
-<span class="line-numbers"> 525 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript templating a-la ERB, pilfered from John Resig's</span>
-<span class="line-numbers"> 526 </span>   <span class="Comment"><span class="Comment">#</span> &quot;Secrets of the JavaScript Ninja&quot;, page 83.</span>
-<span class="line-numbers"> 527 </span> <span class="FunctionArgument">  _.template: str, data </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 528 </span>     <span class="String"><span class="String">`</span>var fn = new Function('obj',</span>
-<span class="line-numbers"> 529 </span> <span class="String">      'var p=[],print=function(){p.push.apply(p,arguments);};' +</span>
-<span class="line-numbers"> 530 </span> <span class="String">      'with(obj){p.push(<span class="UserDefinedConstant">\'</span>' +</span>
-<span class="line-numbers"> 531 </span> <span class="String">      str.</span>
-<span class="line-numbers"> 532 </span> <span class="String">        replace(/[<span class="UserDefinedConstant">\r</span><span class="UserDefinedConstant">\t</span><span class="UserDefinedConstant">\n</span>]/g, &quot; &quot;).</span>
-<span class="line-numbers"> 533 </span> <span class="String">        split(&quot;&lt;%&quot;).join(&quot;<span class="UserDefinedConstant">\t</span>&quot;).</span>
-<span class="line-numbers"> 534 </span> <span class="String">        replace(/((^|%&gt;)[^<span class="UserDefinedConstant">\t</span>]*)'/g, &quot;$1<span class="UserDefinedConstant">\r</span>&quot;).</span>
-<span class="line-numbers"> 535 </span> <span class="String">        replace(/<span class="UserDefinedConstant">\t</span>=(.*?)%&gt;/g, &quot;',$1,'&quot;).</span>
-<span class="line-numbers"> 536 </span> <span class="String">        split(&quot;<span class="UserDefinedConstant">\t</span>&quot;).join(&quot;');&quot;).</span>
-<span class="line-numbers"> 537 </span> <span class="String">        split(&quot;%&gt;&quot;).join(&quot;p.push('&quot;).</span>
-<span class="line-numbers"> 538 </span> <span class="String">        split(&quot;<span class="UserDefinedConstant">\r</span>&quot;).join(&quot;<span class="UserDefinedConstant">\\</span>'&quot;) +</span>
-<span class="line-numbers"> 539 </span> <span class="String">      &quot;');}return p.join('');&quot;)<span class="String">`</span></span>
-<span class="line-numbers"> 540 </span>     <span class="Keyword">if</span> data <span class="Keyword">then</span> fn(data) <span class="Keyword">else</span> fn
-<span class="line-numbers"> 541 </span>
-<span class="line-numbers"> 542 </span>
-<span class="line-numbers"> 543 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------------- Aliases ----------------------------------</span>
-<span class="line-numbers"> 544 </span>
-<span class="line-numbers"> 545 </span>   _.<span class="FunctionName">forEach</span><span class="Keyword">:</span> _.each
-<span class="line-numbers"> 546 </span>   _.<span class="FunctionName">foldl</span><span class="Keyword">:</span>   _.<span class="FunctionName">inject</span><span class="Keyword">:</span>      _.reduce
-<span class="line-numbers"> 547 </span>   _.<span class="FunctionName">foldr</span><span class="Keyword">:</span>   _.reduceRight
-<span class="line-numbers"> 548 </span>   _.<span class="FunctionName">filter</span><span class="Keyword">:</span>  _.select
-<span class="line-numbers"> 549 </span>   _.<span class="FunctionName">every</span><span class="Keyword">:</span>   _.all
-<span class="line-numbers"> 550 </span>   _.<span class="FunctionName">some</span><span class="Keyword">:</span>    _.any
-<span class="line-numbers"> 551 </span>   _.<span class="FunctionName">head</span><span class="Keyword">:</span>    _.first
-<span class="line-numbers"> 552 </span>   _.<span class="FunctionName">tail</span><span class="Keyword">:</span>    _.rest
-<span class="line-numbers"> 553 </span>   _.<span class="FunctionName">methods</span><span class="Keyword">:</span> _.functions
-<span class="line-numbers"> 554 </span>
-<span class="line-numbers"> 555 </span>
-<span class="line-numbers"> 556 </span>   <span class="Comment"><span class="Comment">#</span>   /*------------------------ Setup the OOP Wrapper: --------------------------*/</span>
-<span class="line-numbers"> 557 </span>
-<span class="line-numbers"> 558 </span>   <span class="Comment"><span class="Comment">#</span> Helper function to continue chaining intermediate results.</span>
-<span class="line-numbers"> 559 </span> <span class="FunctionArgument">  result: obj, chain </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 560 </span>     <span class="Keyword">if</span> chain <span class="Keyword">then</span> _(obj).chain() <span class="Keyword">else</span> obj
-<span class="line-numbers"> 561 </span>
-<span class="line-numbers"> 562 </span>
-<span class="line-numbers"> 563 </span>   <span class="Comment"><span class="Comment">#</span> Add all of the Underscore functions to the wrapper object.</span>
-<span class="line-numbers"> 564 </span>   _.each(_.functions(_))<span class="FunctionArgument"> name </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 565 </span>     <span class="FunctionName">method</span><span class="Keyword">:</span> _[name]
-<span class="line-numbers"> 566 </span>     wrapper.prototype[name]<span class="Keyword">:</span> <span class="Storage">=&gt;</span>
-<span class="line-numbers"> 567 </span>       <span class="FunctionName">args</span><span class="Keyword">:</span> _.toArray(arguments)
-<span class="line-numbers"> 568 </span>       unshift.call(args, <span class="Variable">this</span>._wrapped)
-<span class="line-numbers"> 569 </span>       result(method.apply(_, args), <span class="Variable">this</span>._chain)
-<span class="line-numbers"> 570 </span>
-<span class="line-numbers"> 571 </span>
-<span class="line-numbers"> 572 </span>   <span class="Comment"><span class="Comment">#</span> Add all mutator Array functions to the wrapper.</span>
-<span class="line-numbers"> 573 </span>   _.each([<span class="String"><span class="String">'</span>pop<span class="String">'</span></span>, <span class="String"><span class="String">'</span>push<span class="String">'</span></span>, <span class="String"><span class="String">'</span>reverse<span class="String">'</span></span>, <span class="String"><span class="String">'</span>shift<span class="String">'</span></span>, <span class="String"><span class="String">'</span>sort<span class="String">'</span></span>, <span class="String"><span class="String">'</span>splice<span class="String">'</span></span>, <span class="String"><span class="String">'</span>unshift<span class="String">'</span></span>])<span class="FunctionArgument"> name </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 574 </span>     <span class="FunctionName">method</span><span class="Keyword">:</span> Array.prototype[name]
-<span class="line-numbers"> 575 </span>     wrapper.prototype[name]<span class="Keyword">:</span> <span class="Storage">=&gt;</span>
-<span class="line-numbers"> 576 </span>       method.apply(<span class="Variable">this</span>._wrapped, arguments)
-<span class="line-numbers"> 577 </span>       result(<span class="Variable">this</span>._wrapped, <span class="Variable">this</span>._chain)
-<span class="line-numbers"> 578 </span>
-<span class="line-numbers"> 579 </span>
-<span class="line-numbers"> 580 </span>   <span class="Comment"><span class="Comment">#</span> Add all accessor Array functions to the wrapper.</span>
-<span class="line-numbers"> 581 </span>   _.each([<span class="String"><span class="String">'</span>concat<span class="String">'</span></span>, <span class="String"><span class="String">'</span>join<span class="String">'</span></span>, <span class="String"><span class="String">'</span>slice<span class="String">'</span></span>])<span class="FunctionArgument"> name </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 582 </span>     <span class="FunctionName">method</span><span class="Keyword">:</span> Array.prototype[name]
-<span class="line-numbers"> 583 </span>     wrapper.prototype[name]<span class="Keyword">:</span> <span class="Storage">=&gt;</span>
-<span class="line-numbers"> 584 </span>       result(method.apply(<span class="Variable">this</span>._wrapped, arguments), <span class="Variable">this</span>._chain)
-<span class="line-numbers"> 585 </span>
-<span class="line-numbers"> 586 </span>
-<span class="line-numbers"> 587 </span>   <span class="Comment"><span class="Comment">#</span> Start chaining a wrapped Underscore object.</span>
-<span class="line-numbers"> 588 </span> <span class="FunctionArgument">  wrapper::chain: </span><span class="Storage">=&gt;</span>
-<span class="line-numbers"> 589 </span>     <span class="Variable">this</span>.<span class="FunctionName">_chain</span><span class="Keyword">:</span> <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 590 </span>     <span class="Variable">this</span>
-<span class="line-numbers"> 591 </span>
-<span class="line-numbers"> 592 </span>
-<span class="line-numbers"> 593 </span>   <span class="Comment"><span class="Comment">#</span> Extracts the result from a wrapped and chained object.</span>
-<span class="line-numbers"> 594 </span> <span class="FunctionArgument">  wrapper::value: </span><span class="Storage">=&gt;</span> <span class="Variable">this</span>._wrapped
-</pre>  <p>
-    <a href="http://validator.w3.org/check?uri=referer">
-      <img style="border:0"
-           src="http://www.w3.org/Icons/valid-xhtml10"
-           alt="Valid XHTML 1.0 Strict" height="31" width="88" />
-    </a>
-    <a href="http://jigsaw.w3.org/css-validator/check?uri=referer">
-      <img style="border:0;width:88px;height:31px"
-           src="http://jigsaw.w3.org/css-validator/images/vcss"
-           alt="Valid CSS!" />
-    </a>
-  </p>
-</body>
-</html>

examples/code.coffee

@@ -1,16 +1,16 @@
 # Functions:
-square: x => x * x
+square: x => x * x.
 
-sum: x, y => x + y
+sum: x, y => x + y.
 
-odd: x => x % 2 is 0
+odd: x => x % 2 is 0.
 
-even: x => x % 2 isnt 0
+even: x => x % 2 isnt 0.
 
 run_loop: =>
-  fire_events(e => e.stopPropagation())
+  fire_events( e => e.stopPropagation(). )
   listen()
-  wait()
+  wait().
 
 # Objects:
 dense_object_literal: {one: 1, two: 2, three: 3}
@@ -22,14 +22,14 @@ spaced_out_multiline_object: {
   three: new Idea()
 
   inner_obj: {
-    freedom: => _.freedom()
+    freedom: => _.freedom().
   }
 }
 
 # Arrays:
-stooges: [{moe: 45}, {curly: 43}, {larry: 46}]
+stooges : [{moe: 45}, {curly: 43}, {larry: 46}]
 
-exponents: [(x => x), (x => x * x), (x => x * x * x)]
+exponents : [x => x., x => x * x., x => x * x * x.]
 
 empty: []
 
@@ -45,9 +45,9 @@ if submarine.shields_up
 else if submarine.sinking
   abandon_ship()
 else
-  run_away()
+  run_away().
 
-eldest: if 25 > 21 then liz else marge
+eldest: if 25 > 21 then liz else marge.
 
 decoration: medal_of_honor if war_hero
 
@@ -58,8 +58,8 @@ race: =>
   run()
   walk()
   crawl()
-  if tired then return sleep()
-  race()
+  if tired then return sleep().
+  race().
 
 # Conditional assignment:
 good ||= evil
@@ -81,54 +81,54 @@ try
   dogs_and_cats_living_together()
   throw "up"
 catch error
-  print(error)
+  print( error )
 finally
-  clean_up()
+  clean_up().
 
-try all_hell_breaks_loose() catch error then print(error) finally clean_up()
+try all_hell_breaks_loose() catch error print(error) finally clean_up().
 
 # While loops, break and continue.
 while demand > supply
   sell()
-  restock()
+  restock().
 
-while supply > demand then buy()
+while supply > demand then buy().
 
 while true
   break if broken
-  continue if continuing
+  continue if continuing.
 
 # Unary operators.
 !!true
 
 # Lexical scoping.
-v_1: 5
+a: 5
 change_a_and_set_b: =>
-  v_1: 10
-  v_2: 15
-v_2: 20
+  a: 10
+  b: 15.
+b: 20
 
 # Array comprehensions.
-supper: food.capitalize() for food in ['toast', 'cheese', 'wine']
+supper: food.capitalize() for food in ['toast', 'cheese', 'wine'].
 
-drink(bottle) for bottle, i in ['soda', 'wine', 'lemonade'] when even(i)
+drink(bottle) for bottle, i in ['soda', 'wine', 'lemonade'] if even(i).
 
 # Switch statements ("else" serves as a default).
 activity: switch day
-  when "Tuesday"   then eat_breakfast()
-  when "Sunday"    then go_to_church()
-  when "Saturday"  then go_to_the_park()
-  when "Wednesday"
-    if day is bingo_day
-      go_to_bingo()
-    else
-      eat_breakfast()
-      go_to_work()
-      eat_dinner()
-  else go_to_work()
+when "Tuesday"   then eat_breakfast()
+when "Sunday"    then go_to_church()
+when "Saturday"  then go_to_the_park()
+when "Wednesday"
+  if day is bingo_day
+    go_to_bingo()
+  else
+    eat_breakfast()
+    go_to_work()
+    eat_dinner().
+else go_to_work().
 
 # Semicolons can optionally be used instead of newlines.
-wednesday: => eat_breakfast(); go_to_work(); eat_dinner()
+wednesday: => eat_breakfast(); go_to_work(); eat_dinner(); .
 
 # Array slice literals.
 zero_to_nine: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
@@ -140,21 +140,21 @@ sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna
 aliquam erat volutpat. Ut wisi enim ad."
 
 # Inheritance and calling super.
-Animal: =>
-Animal::move: meters =>
-  alert(this.name + " moved " + meters + "m.")
+Animal: => .
+Animal.prototype.move: meters =>
+  alert(this.name + " moved " + meters + "m.").
 
-Snake: name => this.name: name
+Snake: name => this.name: name.
 Snake extends Animal
-Snake::move: =>
+Snake.prototype.move: =>
   alert('Slithering...')
-  super(5)
+  super(5).
 
-Horse: name => this.name: name
+Horse: name => this.name: name.
 Horse extends Animal
-Horse::move: =>
+Horse.prototype.move: =>
   alert('Galloping...')
-  super(45)
+  super(45).
 
 sam: new Snake("Sammy the Snake")
 tom: new Horse("Tommy the Horse")

examples/documents.coffee

@@ -1,7 +1,7 @@
 # Document Model
 dc.model.Document: dc.Model.extend({
 
-  constructor: attributes => this.base(attributes)
+  constructor: attributes => this.base(attributes).
 
   # For display, show either the highlighted search results, or the summary,
   # if no highlights are available.
@@ -9,22 +9,22 @@ dc.model.Document: dc.Model.extend({
   # version of the summary has all runs of whitespace squeezed out.
   displaySummary: =>
     text: this.get('highlight') or this.get('summary') or ''
-    text and text.replace(/\s+/g, ' ')
+    text and text.replace(/\s+/g, ' ').
 
   # Return a list of the document's metadata. Think about caching this on the
   # document by binding to Metadata, instead of on-the-fly.
   metadata: =>
     docId: this.id
-    _.select(Metadata.models(), (meta => 
-      _.any(meta.get('instances'), instance => 
-        instance.document_id is docId)))
+    _.select(Metadata.models()
+      meta => _.any(meta.get('instances')
+        instance => instance.document_id is docId.).).
 
   bookmark: pageNumber =>
     bookmark: new dc.model.Bookmark({title: this.get('title'), page_number: pageNumber, document_id: this.id})
-    Bookmarks.create(bookmark)
+    Bookmarks.create(bookmark).
 
   # Inspect.
-  toString: => 'Document ' + this.id + ' "' + this.get('title') + '"'
+  toString: => 'Document ' + this.id + ' "' + this.get('title') + '"'.
 
 })
 
@@ -37,31 +37,31 @@ dc.model.DocumentSet: dc.model.RESTfulSet.extend({
 
   constructor: options =>
     this.base(options)
-    _.bindAll(this, 'downloadSelectedViewers', 'downloadSelectedPDF', 'downloadSelectedFullText')
+    _.bindAll(this, 'downloadSelectedViewers', 'downloadSelectedPDF', 'downloadSelectedFullText').
 
-  selected: => _.select(this.models(), m => m.get('selected'))
+  selected: => _.select(this.models(), m => m.get('selected').).
 
-  selectedIds: => _.pluck(this.selected(), 'id')
+  selectedIds: => _.pluck(this.selected(), 'id').
 
-  countSelected: => this.selected().length
+  countSelected: => this.selected().length.
 
   downloadSelectedViewers: =>
-    dc.app.download('/download/' + this.selectedIds().join('/') + '/document_viewer.zip')
+    dc.app.download('/download/' + this.selectedIds().join('/') + '/document_viewer.zip').
 
   downloadSelectedPDF: =>
-    if this.countSelected() <= 1 then return window.open(this.selected()[0].get('pdf_url'))
-    dc.app.download('/download/' + this.selectedIds().join('/') + '/document_pdfs.zip')
+    if this.countSelected() <= 1 then return window.open(this.selected()[0].get('pdf_url')).
+    dc.app.download('/download/' + this.selectedIds().join('/') + '/document_pdfs.zip').
 
   downloadSelectedFullText: =>
-    if this.countSelected() <= 1 then return window.open(this.selected()[0].get('full_text_url'))
-    dc.app.download('/download/' + this.selectedIds().join('/') + '/document_text.zip')
+    if this.countSelected() <= 1 then return window.open(this.selected()[0].get('full_text_url')).
+    dc.app.download('/download/' + this.selectedIds().join('/') + '/document_text.zip').
 
   # We override "_onModelEvent" to fire selection changed events when documents
   # change their selected state.
   _onModelEvent: e, model =>
     this.base(e, model)
     fire: e == dc.Model.CHANGED and model.hasChanged('selected')
-    if fire then _.defer(_(this.fire).bind(this, this.SELECTION_CHANGED, this))
+    if fire then _.defer(_(this.fire).bind(this, this.SELECTION_CHANGED, this))..
 
 })
 

examples/poignant.coffee

@@ -2,7 +2,7 @@
 
 # ['toast', 'cheese', 'wine'].each { |food| print food.capitalize }
 
-['toast', 'wine', 'cheese'].each(food => print(food.capitalize()))
+['toast', 'wine', 'cheese'].each( food => print(food.capitalize()). )
 
 
 
@@ -14,10 +14,10 @@
 # end
 
 LotteryTicket: {
-  get_picks:           => this.picks
-  set_picks:      nums => this.picks: nums
-  get_purchase:        => this.purchase
-  set_purchase: amount => this.purchase: amount
+  get_picks:    => this.picks.
+  set_picks:    nums => this.picks: nums.
+  get_purchase: => this.purchase.
+  set_purchase: amount => this.purchase: amount.
 }
 
 
@@ -33,8 +33,8 @@ LotteryTicket: {
 
 WishScanner: {
   scan_for_a_wish: =>
-    wish: this.read().detect(thought => thought.index('wish: ') is 0)
-    wish.replace('wish: ', '')
+    wish: this.read().detect( thought => thought.index('wish: ') is 0. )
+    wish.replace('wish: ', '').
 }
 
 
@@ -79,28 +79,28 @@ Creature : {
 
   # This method applies a hit taken during a fight.
   hit: damage =>
-    p_up: Math.rand(this.charisma)
+    p_up: Math.rand( this.charisma )
     if p_up % 9 is 7
       this.life += p_up / 4
-      puts("[" + this.name + " magick powers up " + p_up + "!]")
+      puts( "[" + this.name + " magick powers up " + p_up + "!]" ).
     this.life -= damage
-    if this.life <= 0 then puts("[" + this.name + " has died.]")
+    if this.life <= 0 then puts( "[" + this.name + " has died.]" )..
 
   # This method takes one turn in a fight.
   fight: enemy, weapon =>
-    if this.life <= 0 then return puts("[" + this.name + "is too dead to fight!]")
+    if this.life <= 0 then return puts( "[" + this.name + "is too dead to fight!]" ).
 
     # Attack the opponent.
-    your_hit: Math.rand(this.strength + weapon)
-    puts("[You hit with " + your_hit + "points of damage!]")
-    enemy.hit(your_hit)
+    your_hit: Math.rand( this.strength + weapon )
+    puts( "[You hit with " + your_hit + "points of damage!]" )
+    enemy.hit( your_hit )
 
     # Retaliation.
-    puts(enemy)
+    puts( enemy )
     if enemy.life > 0
-      enemy_hit: Math.rand(enemy.strength + enemy.weapon)
-      puts("[Your enemy hit with " + enemy_hit + "points of damage!]")
-      this.hit(enemy_hit)
+      enemy_hit: Math.rand( enemy.strength + enemy.weapon )
+      puts( "[Your enemy hit with " + enemy_hit + "points of damage!]" )
+      this.hit( enemy_hit )..
 
 }
 
@@ -123,12 +123,12 @@ Creature : {
 # Get evil idea and swap in code words
 print("Enter your new idea: ")
 idea: gets()
-code_words.each(real, code => idea.replace(real, code))
+code_words.each( real, code => idea.replace(real, code). )
 
 # Save the jibberish to a new file
 print("File encoded. Please enter a name for this idea: ")
 idea_name: gets().strip()
-File.open("idea-" + idea_name + '.txt', 'w', file => file.write(idea))
+File.open("idea-" + idea_name + '.txt', 'w', file => file.write(idea). )
 
 
 
@@ -149,5 +149,5 @@ wipe_mutterings_from: sentence =>
   while sentence.indexOf('(') >= 0
     open:     sentence.indexOf('(') - 1
     close:    sentence.indexOf(')') + 1
-    sentence: sentence[0..open] + sentence[close..sentence.length]
-    sentence
+    sentence: sentence[0..open] + sentence[close..sentence.length].
+    sentence.

lib/coffee-script.rb

@@ -4,13 +4,12 @@ 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.2.2'   # Keep in sync with the gemspec.
+  VERSION = '0.1.5'   # Keep in sync with the gemspec.
 
   # Compile a script (String or IO) to JavaScript.
   def self.compile(script, options={})

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

@@ -10,10 +10,6 @@
 	</array>
 	<key>name</key>
 	<string>CoffeeScript</string>
-	<key>foldingStartMarker</key>
-	<string>^.*[:=] \{[^\}]*$</string>
-	<key>foldingStopMarker</key>
-	<string>\s*\}</string>
 	<key>patterns</key>
 	<array>
 		<dict>
@@ -43,7 +39,7 @@
 			<key>comment</key>
 			<string>match stuff like: funcName: =&gt; … </string>
 			<key>match</key>
-			<string>([a-zA-Z0-9_?.$:*]*)\s*(=|:)\s*([\w,\s]*?)\s*(=&gt;)</string>
+			<string>([a-zA-Z_?.$]*)\s*(=|:)\s*([\w,\s]*?)\s*(=&gt;)</string>
 			<key>name</key>
 			<string>meta.function.coffee</string>
 		</dict>
@@ -64,7 +60,7 @@
 			<key>comment</key>
 			<string>match stuff like: a =&gt; … </string>
 			<key>match</key>
-			<string>([a-zA-Z0-9_?., $:*]*)\s*(=&gt;)</string>
+			<string>([a-zA-Z_?., $]*)\s*(=&gt;)</string>
 			<key>name</key>
 			<string>meta.inline.function.coffee</string>
 		</dict>
@@ -208,29 +204,10 @@
 		</dict>
 		<dict>
 			<key>match</key>
-			<string>\b(break|by|catch|continue|else|finally|for|if|return|switch|then|throw|try|unless|when|while)\b</string>
+			<string>\b(break|when|catch|continue|else|finally|for|if|return|switch|then|throw|try|unless|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>3</key>
-				<dict>
-					<key>name</key>
-					<string>keyword.operator.coffee</string>
-				</dict>
-			</dict>
-		</dict>
 		<dict>
 			<key>match</key>
 			<string>\b(true|on|yes)\b</string>
@@ -263,7 +240,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|ino|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>

lib/coffee_script/command_line.rb

@@ -1,13 +1,7 @@
 require 'optparse'
 require 'fileutils'
 require 'open3'
-begin
-  require File.expand_path(File.dirname(__FILE__) + '/../coffee-script')
-rescue LoadError => e
-  puts(e.message)
-  puts("use \"rake build:parser\" to regenerate parser.rb")
-  exit(1)
-end
+require File.expand_path(File.dirname(__FILE__) + '/../coffee-script')
 
 module CoffeeScript
 
@@ -25,10 +19,6 @@ Usage:
     # Seconds to pause between checks for changed source files.
     WATCH_INTERVAL = 0.5
 
-    # 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
       @mtimes = {}
@@ -114,7 +104,7 @@ Usage:
 
     # Use Narwhal to run an interactive CoffeeScript session.
     def launch_repl
-      exec "#{LAUNCHER}"
+      exec "narwhal lib/coffee_script/narwhal/js/launcher.js"
     rescue Errno::ENOENT
       puts "Error: Narwhal must be installed to use the interactive REPL."
       exit(1)
@@ -123,7 +113,7 @@ Usage:
     # Use Narwhal to compile and execute CoffeeScripts.
     def run_scripts
       sources = @sources.join(' ')
-      exec "#{LAUNCHER} #{sources}"
+      exec "narwhal lib/coffee_script/narwhal/js/launcher.js #{sources}"
     rescue Errno::ENOENT
       puts "Error: Narwhal must be installed in order to execute CoffeeScripts."
       exit(1)
@@ -139,7 +129,6 @@ Usage:
       begin
         options = {}
         options[:no_wrap] = true if @options[:no_wrap]
-        options[:globals] = true if @options[:globals]
         CoffeeScript.compile(script, options)
       rescue CoffeeScript::ParseError, SyntaxError => e
         STDERR.puts "#{source}: #{e.message}"
@@ -194,12 +183,9 @@ Usage:
         opts.on('-v', '--verbose', 'print at every step of code generation') do |v|
           ENV['VERBOSE'] = 'true'
         end
-        opts.on('-n', '--no-wrap', 'raw output, no function safety wrapper') do |n|
+        opts.on('-n', '--no-wrap', 'raw output, no safety wrapper or vars') do |n|
           @options[:no_wrap] = true
         end
-        opts.on('-g', '--globals', 'attach all top-level variable as globals') do |n|
-          @options[:globals] = true
-        end
         opts.on_tail('--install-bundle', 'install the CoffeeScript TextMate bundle') do |i|
           install_bundle
           exit

lib/coffee_script/grammar.y

@@ -1,26 +1,23 @@
 class Parser
 
-# Declare terminal tokens produced by the lexer.
-token IF ELSE UNLESS
+# Declare tokens produced by the lexer
+token IF ELSE THEN UNLESS
 token NUMBER STRING REGEX
 token TRUE FALSE YES NO ON OFF
-token IDENTIFIER PROPERTY_ACCESS PROTOTYPE_ACCESS
+token IDENTIFIER PROPERTY_ACCESS
 token CODE PARAM NEW RETURN
 token TRY CATCH FINALLY THROW
 token BREAK CONTINUE
-token FOR IN INO BY WHEN WHILE
-token SWITCH LEADING_WHEN
+token FOR IN WHILE
+token SWITCH WHEN
 token DELETE INSTANCEOF TYPEOF
 token SUPER EXTENDS
-token ARGUMENTS
 token NEWLINE
 token COMMENT
 token JS
-token INDENT OUTDENT
 
 # Declare order of operations.
 prechigh
-  left     '?'
   nonassoc UMINUS NOT '!' '!!' '~' '++' '--'
   left     '*' '/' '%'
   left     '+' '-'
@@ -32,41 +29,51 @@ prechigh
   right    '-=' '+=' '/=' '*=' '%='
   right    DELETE INSTANCEOF TYPEOF
   left     '.'
-  right    INDENT
-  left     OUTDENT
-  right    WHEN LEADING_WHEN IN INO BY
-  right    THROW FOR NEW SUPER
-  left     EXTENDS
+  right    THROW FOR IN WHILE NEW SUPER
+  left     UNLESS IF ELSE EXTENDS
   left     ASSIGN '||=' '&&='
   right    RETURN
-  right    '=>' 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.wrap(val) }
+    Expression                        { result = Expressions.new(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. The basic unit of CoffeeScript
-  # is the expression.
+  # All types of expressions in our language.
   Expression:
+    PureExpression
+  | Statement
+  ;
+
+  # The parts that are natural JavaScript expressions.
+  PureExpression:
     Value
   | Call
   | Code
   | Operation
-  | Assign
+  | Range
+  ;
+
+  # We have to take extra care to convert these statements into expressions.
+  Statement:
+    Assign
   | If
   | Try
   | Throw
@@ -75,25 +82,22 @@ rule
   | For
   | Switch
   | Extends
-  | Splat
-  | Existence
   | Comment
   ;
 
-  # A block of expressions. Note that the Rewriter will convert some postfix
-  # forms into blocks for us, by altering the token stream.
-  Block:
-    INDENT Expressions OUTDENT        { result = val[1] }
-  | INDENT OUTDENT                    { result = Expressions.new }
-  ;
-
-  # Tokens that can terminate an expression.
+  # All tokens that can terminate an expression.
   Terminator:
     "\n"
   | ";"
   ;
 
-  # All hard-coded values. These can be printed straight to JavaScript.
+  # 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]) }
   | STRING                            { result = LiteralNode.new(val[0]) }
@@ -101,7 +105,6 @@ rule
   | REGEX                             { result = LiteralNode.new(val[0]) }
   | BREAK                             { result = LiteralNode.new(val[0]) }
   | CONTINUE                          { result = LiteralNode.new(val[0]) }
-  | ARGUMENTS                         { result = LiteralNode.new(val[0]) }
   | TRUE                              { result = LiteralNode.new(true) }
   | FALSE                             { result = LiteralNode.new(false) }
   | YES                               { result = LiteralNode.new(true) }
@@ -110,22 +113,21 @@ rule
   | OFF                               { result = LiteralNode.new(false) }
   ;
 
-  # Assignment to a variable (or index).
+  # 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 (can be quoted).
+  # 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] }
   ;
 
   # A return statement.
   Return:
     RETURN Expression                 { result = ReturnNode.new(val[1]) }
-  | RETURN                            { result = ReturnNode.new(ValueNode.new(Value.new('null'))) }
   ;
 
   # A comment.
@@ -144,8 +146,6 @@ 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,36 +187,27 @@ 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]) }
-  | Expression IN Expression          { result = OpNode.new(val[1], val[0], val[2]) }
-  ;
-
-  # The existence operator.
-  Existence:
-    Expression '?'                    { result = ExistenceNode.new(val[0]) }
   ;
 
   # Function definition.
   Code:
-    ParamList "=>" Block              { result = CodeNode.new(val[0], val[2]) }
-  | "=>" Block                        { result = CodeNode.new([], val[1]) }
+    ParamList "=>" CodeBody "."       { result = CodeNode.new(val[0], val[2]) }
+  | "=>" CodeBody "."                 { result = CodeNode.new([], val[1]) }
+  ;
+
+  # The body of a function.
+  CodeBody:
+    /* nothing */                     { result = Expressions.new([]) }
+  | Expressions                       { result = val[0] }
   ;
 
   # The parameters to a function definition.
   ParamList:
-    Param                             { result = val }
-  | ParamList "," Param               { result = val[0] << val[2] }
-  ;
-
-  # A Parameter (or ParamSplat) in a function definition.
-  Param:
-    PARAM
-  | PARAM "." "." "."                 { result = ParamSplatNode.new(val[0]) }
-  ;
-
-  # A regular splat.
-  Splat:
-    Expression "." "." "."            { result = ArgSplatNode.new(val[0])}
+    PARAM                             { result = val }
+  | ParamList "," PARAM               { result = val[0] << val[2] }
   ;
 
   # Expressions that can be treated as values.
@@ -226,7 +217,6 @@ rule
   | Array                             { result = ValueNode.new(val[0]) }
   | Object                            { result = ValueNode.new(val[0]) }
   | Parenthetical                     { result = ValueNode.new(val[0]) }
-  | Range                             { result = ValueNode.new(val[0]) }
   | Value Accessor                    { result = val[0] << val[1] }
   | Invocation Accessor               { result = ValueNode.new(val[0], [val[1]]) }
   ;
@@ -234,7 +224,6 @@ rule
   # Accessing into an object or array, through dot or index notation.
   Accessor:
     PROPERTY_ACCESS IDENTIFIER        { result = AccessorNode.new(val[1]) }
-  | PROTOTYPE_ACCESS IDENTIFIER       { result = AccessorNode.new(val[1], true) }
   | Index                             { result = val[0] }
   | Range                             { result = SliceNode.new(val[0]) }
   ;
@@ -251,13 +240,10 @@ 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).
@@ -274,15 +260,8 @@ rule
 
   # A generic function invocation.
   Invocation:
-    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] }
-  ;
-
-  # The list of arguments to a function invocation.
-  Arguments:
-    "(" ArgList ")"                   { result = val[1] }
-  | "(" ArgList ")" Code              { result = val[1] << val[3] }
+    Value "(" ArgList ")"             { result = CallNode.new(val[0], val[2]) }
+  | Invocation "(" ArgList ")"        { result = CallNode.new(val[0], val[2]) }
   ;
 
   # Calling super.
@@ -292,10 +271,8 @@ rule
 
   # The range literal.
   Range:
-    "[" Expression
-      "." "." Expression "]"          { result = RangeNode.new(val[1], val[4]) }
-  | "[" Expression
-      "." "." "." Expression "]"      { result = RangeNode.new(val[1], val[5], true) }
+    "[" Value "." "." Value "]"       { result = RangeNode.new(val[1], val[4]) }
+  | "[" Value "." "." "." Value "]"   { result = RangeNode.new(val[1], val[5], true) }
   ;
 
   # The array literal.
@@ -307,25 +284,21 @@ 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 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]) }
+    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]) }
   ;
 
   # A catch clause.
   Catch:
-    CATCH IDENTIFIER Block            { result = [val[1], val[2]] }
+    /* nothing */                     { result = [nil, nil] }
+  | CATCH IDENTIFIER Expressions      { result = [val[1], val[2]] }
   ;
 
   # Throw an exception.
@@ -335,21 +308,20 @@ rule
 
   # Parenthetical expressions.
   Parenthetical:
-    "(" Expression ")"                { result = ParentheticalNode.new(val[1], val[0].line) }
+    "(" Expressions ")"               { result = ParentheticalNode.new(val[1]) }
   ;
 
   # The while loop. (there is no do..while).
   While:
-    WHILE Expression Block            { result = WhileNode.new(val[1], val[2]) }
-  | WHILE Expression                  { result = WhileNode.new(val[1], nil) }
+    WHILE Expression Then
+      Expressions "."                 { result = WhileNode.new(val[1], val[3]) }
   ;
 
   # 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], val[2][0], val[2][1]) }
-  | FOR ForVariables ForSource Block  { result = ForNode.new(val[3], val[2], val[1][0], val[1][1]) }
+      ForVariables ForSource          { result = ForNode.new(val[0], val[3][0], val[2][0], val[3][1], val[2][1]) }
   ;
 
   # An array comprehension has variables for the current element and index.
@@ -360,20 +332,17 @@ rule
 
   # The source of the array comprehension can optionally be filtered.
   ForSource:
-    IN Expression                     { result = {:source => val[1]} }
-  | INO Expression                    { result = {:source => val[1], :object => true} }
-  | ForSource
-    WHEN Expression                   { result = val[0].merge(:filter => val[2]) }
-  | ForSource
-    BY Expression                     { result = val[0].merge(:step => val[2]) }
+    IN PureExpression "."             { result = [val[1]] }
+  | IN PureExpression
+    IF Expression "."                 { result = [val[1], val[3]] }
   ;
 
   # Switch/When blocks.
   Switch:
-    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]) }
+    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]) }
   ;
 
   # The inner list of whens.
@@ -384,20 +353,16 @@ rule
 
   # An individual when.
   When:
-    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 Terminator When           { result = val[2].add_comment(val[0]) }
+    WHEN Expression Then Expressions  { result = IfNode.new(val[1], val[3]) }
   ;
 
-  # The most basic form of "if".
-  IfBlock:
-    IF Expression Block               { result = IfNode.new(val[1], val[2]) }
-  ;
+  # All of the following nutso if-else destructuring is to make the
+  # grammar expand unambiguously.
 
   # An elsif portion of an if-else block.
   ElsIf:
-    ELSE IfBlock                      { result = val[1].force_statement }
+    ELSE IF Expression
+      Then Expressions                { result = IfNode.new(val[2], val[4]) }
   ;
 
   # Multiple elsifs can be chained together.
@@ -408,8 +373,8 @@ rule
 
   # Terminating else bodies are strictly optional.
   ElseBody
-    /* nothing */                     { result = nil }
-  | ELSE Block                        { result = val[1] }
+    "."                               { result = nil }
+  | ELSE Expressions "."              { result = val[1] }
   ;
 
   # All the alternatives for ending an if-else block.
@@ -420,9 +385,10 @@ rule
 
   # The full complement of if blocks, including postfix one-liner ifs and unlesses.
   If:
-    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}) }
+    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}) }
   ;
 
 end

lib/coffee_script/lexer.rb

@@ -12,83 +12,70 @@ module CoffeeScript
                   "new", "return",
                   "try", "catch", "finally", "throw",
                   "break", "continue",
-                  "for", "in", "ino", "by", "where", "while",
+                  "for", "in", "while",
                   "switch", "when",
                   "super", "extends",
-                  "arguments",
                   "delete", "instanceof", "typeof"]
 
     # Token matching regexes.
-    IDENTIFIER = /\A([a-zA-Z$_](\w|\$)*)/
-    NUMBER     = /\A(\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i
-    STRING     = /\A(""|''|"(.*?)([^\\]|\\\\)"|'(.*?)([^\\]|\\\\)')/m
-    JS         = /\A(``|`(.*?)([^\\]|\\\\)`)/m
+    IDENTIFIER = /\A([a-zA-Z$_]\w*)/
+    NUMBER     = /\A((\b|-)((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i
+    STRING     = /\A(""|''|"(.*?)[^\\]"|'(.*?)[^\\]')/m
+    JS         = /\A(``|`(.*?)[^\\]`)/m
     OPERATOR   = /\A([+\*&|\/\-%=<>:!]+)/
-    WHITESPACE = /\A([ \t]+)/
-    COMMENT    = /\A(((\n?[ \t]*)?#.*$)+)/
+    WHITESPACE = /\A([ \t\r]+)/
+    NEWLINE    = /\A(\n+)/
+    COMMENT    = /\A((#[^\n]*\s*)+)/m
     CODE       = /\A(=>)/
-    REGEX      = /\A(\/(.*?)([^\\]|\\\\)\/[imgy]{0,4})/
-    MULTI_DENT = /\A((\n([ \t]*))+)(\.)?/
-    LAST_DENT  = /\n([ \t]*)/
-    ASSIGNMENT = /\A(:|=)\Z/
+    REGEX      = /\A(\/(.*?)[^\\]\/[imgy]{0,4})/
 
     # Token cleaning regexes.
     JS_CLEANER = /(\A`|`\Z)/
     MULTILINER = /\n/
     COMMENT_CLEANER = /(^\s*#|\n\s*$)/
-    NO_NEWLINE = /\A([+\*&|\/\-%=<>:!.\\][<>=&|]*|and|or|is|isnt|not|delete|typeof|instanceof)\Z/
 
-    # Tokens which a regular expression will never immediately follow, but which
-    # a division operator might.
-    # See: http://www.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions
-    NOT_REGEX  = [
-      :IDENTIFIER, :NUMBER, :REGEX, :STRING,
-      ')', '++', '--', ']', '}',
-      :FALSE, :NULL, :THIS, :TRUE
-    ]
+    # Tokens that always constitute the start of an expression.
+    EXP_START  = ['{', '(', '[']
+
+    # Tokens that always constitute the end of an expression.
+    EXP_END    = ['}', ')', ']']
+
+    # Assignment tokens.
+    ASSIGN     = [':', '=']
 
     # Scan by attempting to match tokens one character at a time. Slow and steady.
     def tokenize(code)
       @code = code.chomp  # Cleanup code by remove extra line breaks
       @i = 0              # Current character position we're parsing
       @line = 1           # The current line.
-      @indent = 0         # The current indent level.
-      @indents = []       # The stack of all indent levels we are currently within.
       @tokens = []        # Collection of all parsed tokens in the form [:TOKEN_TYPE, value]
       while @i < @code.length
         @chunk = @code[@i..-1]
         extract_next_token
       end
-      puts "original stream: #{@tokens.inspect}" if ENV['VERBOSE']
-      close_indentation
-      Rewriter.new.rewrite(@tokens)
+      @tokens
     end
 
-    # At every position, run through this list of attempted matches,
-    # short-circuiting if any of them succeed.
+    # At every position, run this list of match attempts, short-circuiting if
+    # any of them succeed.
     def extract_next_token
       return if identifier_token
       return if number_token
       return if string_token
       return if js_token
       return if regex_token
-      return if indent_token
       return if comment_token
       return if whitespace_token
       return    literal_token
     end
 
-    # Tokenizers ==========================================================
-
     # Matches identifying literals: variables, keywords, method names, etc.
     def identifier_token
       return false unless identifier = @chunk[IDENTIFIER, 1]
-      # Keywords are special identifiers tagged with their own name,
-      # 'if' will result in an [:IF, "if"] token.
+      # Keywords are special identifiers tagged with their own name, 'if' will result
+      # in an [:IF, "if"] token
       tag = KEYWORDS.include?(identifier) ? identifier.upcase.to_sym : :IDENTIFIER
-      tag = :LEADING_WHEN if tag == :WHEN && [:OUTDENT, :INDENT, "\n"].include?(last_tag)
       @tokens[-1][0] = :PROPERTY_ACCESS if tag == :IDENTIFIER && last_value == '.' && !(@tokens[-2][1] == '.')
-      @tokens[-1][0] = :PROTOTYPE_ACCESS if tag == :IDENTIFIER && last_value == '::'
       token(tag, identifier)
       @i += identifier.length
     end
@@ -121,7 +108,6 @@ module CoffeeScript
     # Matches regular expression literals.
     def regex_token
       return false unless regex = @chunk[REGEX, 1]
-      return false if NOT_REGEX.include?(last_tag)
       token(:REGEX, regex)
       @i += regex.length
     end
@@ -135,106 +121,73 @@ module CoffeeScript
       @i += comment.length
     end
 
-    # Record tokens for indentation differing from the previous line.
-    def indent_token
-      return false unless indent = @chunk[MULTI_DENT, 1]
-      @line += indent.scan(MULTILINER).size
-      @i += indent.size
-      next_character = @chunk[MULTI_DENT, 4]
-      no_newlines = next_character == '.' || (last_value.to_s.match(NO_NEWLINE) && last_value != "=>")
-      return suppress_newlines(indent) if no_newlines
-      size = indent.scan(LAST_DENT).last.last.length
-      return newline_token(indent) if size == @indent
-      if size > @indent
-        token(:INDENT, size - @indent)
-        @indents << (size - @indent)
-      else
-        outdent_token(@indent - size)
-      end
-      @indent = size
-    end
-
-    # Record an oudent token or tokens, if we're moving back inwards past
-    # multiple recorded indents.
-    def outdent_token(move_out)
-      while move_out > 0 && !@indents.empty?
-        last_indent = @indents.pop
-        token(:OUTDENT, last_indent)
-        move_out -= last_indent
-      end
-      token("\n", "\n")
-    end
-
     # Matches and consumes non-meaningful whitespace.
     def whitespace_token
       return false unless whitespace = @chunk[WHITESPACE, 1]
       @i += whitespace.length
     end
 
-    # Multiple newlines get merged together.
-    # Use a trailing \ to escape newlines.
-    def newline_token(newlines)
-      token("\n", "\n") unless last_value == "\n"
-      true
-    end
-
-    # Tokens to explicitly escape newlines are removed once their job is done.
-    def suppress_newlines(newlines)
-      @tokens.pop if last_value == "\\"
-      true
-    end
-
     # We treat all other single characters as a token. Eg.: ( ) , . !
     # Multi-character operators are also literal tokens, so that Racc can assign
-    # the proper order of operations.
+    # the proper order of operations. Multiple newlines get merged together.
+    # Use a trailing \ to escape newlines.
     def literal_token
+      value = @chunk[NEWLINE, 1]
+      if value
+        @line += value.length
+        token("\n", "\n") unless ["\n", "\\"].include?(last_value)
+        @tokens.pop if last_value == "\\"
+        return @i += value.length
+      end
       value = @chunk[OPERATOR, 1]
       tag_parameters if value && value.match(CODE)
       value ||= @chunk[0,1]
-      tag = value.match(ASSIGNMENT) ? :ASSIGN : value
+      skip_following_newlines if EXP_START.include?(value)
+      remove_leading_newlines if EXP_END.include?(value)
+      tag = ASSIGN.include?(value) ? :ASSIGN : value
       token(tag, value)
       @i += value.length
     end
 
-    # Helpers ==========================================================
-
     # Add a token to the results, taking note of the line number, and
     # immediately-preceding comment.
     def token(tag, value)
       @tokens << [tag, Value.new(value, @line)]
     end
 
-    # Peek at the previous token's value.
+    # Peek at the previous token.
     def last_value
       @tokens.last && @tokens.last[1]
     end
 
-    # Peek at the previous token's tag.
-    def last_tag
-      @tokens.last && @tokens.last[0]
-    end
-
     # A source of ambiguity in our grammar was parameter lists in function
     # definitions (as opposed to argument lists in function calls). Tag
-    # parameter identifiers in order to avoid this. Also, parameter lists can
-    # make use of splats.
+    # parameter identifiers in order to avoid this.
     def tag_parameters
-      i = 0
+      index = 0
       loop do
-        i -= 1
-        tok = @tokens[i]
+        tok = @tokens[index -= 1]
         return if !tok
-        next if ['.', ','].include?(tok[0])
+        next if tok[0] == ','
         return if tok[0] != :IDENTIFIER
         tok[0] = :PARAM
       end
     end
 
-    # Close up all remaining open blocks. IF the first token is an indent,
-    # axe it.
-    def close_indentation
-      outdent_token(@indent)
+    # Consume and ignore newlines immediately after this point.
+    def skip_following_newlines
+      newlines = @code[(@i+1)..-1][NEWLINE, 1]
+      if newlines
+        @line += newlines.length
+        @i += newlines.length
+      end
+    end
+
+    # Discard newlines immediately before this point.
+    def remove_leading_newlines
+      @tokens.pop if last_value == "\n"
     end
 
   end
+
 end

lib/coffee_script/narwhal/coffee-script.coffee

@@ -15,48 +15,45 @@ coffeePath: File.path(module.path).dirname().dirname().dirname().dirname().dirna
 checkForErrors: coffeeProcess =>
   return true if coffeeProcess.wait() is 0
   system.stderr.print(coffeeProcess.stderr.read())
-  throw new Error("CoffeeScript compile error")
+  throw new Error("CoffeeScript compile error").
 
 # Run a simple REPL, round-tripping to the CoffeeScript compiler for every
 # command.
 exports.run: args =>
-  if args.length
-    for path, i in args
-      exports.evalCS(File.read(path))
-      delete args[i]
-    return true
+  args.shift()
+  return require(File.absolute(args[0])) if args.length
 
   while true
     try
       system.stdout.write('coffee> ').flush()
-      result: exports.evalCS(Readline.readline(), ['--globals'])
+      result: exports.evalCS(Readline.readline())
       print(result) if result isnt undefined
     catch e
-      print(e)
+      print(e)...
 
 # Compile a given CoffeeScript file into JavaScript.
 exports.compileFile: path =>
   coffee: OS.popen([coffeePath, "--print", "--no-wrap", path])
   checkForErrors(coffee)
-  coffee.stdout.read()
+  coffee.stdout.read().
 
 # Compile a string of CoffeeScript into JavaScript.
-exports.compile: source, flags =>
-  coffee: OS.popen([coffeePath, "--eval", "--no-wrap"].concat(flags or []))
+exports.compile: source =>
+  coffee: OS.popen([coffeePath, "--eval", "--no-wrap"])
   coffee.stdin.write(source).flush().close()
   checkForErrors(coffee)
-  coffee.stdout.read()
+  coffee.stdout.read().
 
 # Evaluating a string of CoffeeScript first compiles it externally.
-exports.evalCS: source, flags =>
-  eval(exports.compile(source, flags))
+exports.evalCS: source =>
+  eval(exports.compile(source)).
 
 # Make a factory for the CoffeeScript environment.
 exports.makeNarwhalFactory: path =>
-  code: exports.compileFile(path)
-  factoryText: "function(require,exports,module,system,print){" + code + "/**/\n}"
-  if system.engine is "rhino"
-    Packages.org.mozilla.javascript.Context.getCurrentContext().compileFunction(global, factoryText, path, 0, null)
-  else
-    # eval requires parentheses, but parentheses break compileFunction.
-    eval("(" + factoryText + ")")
+    code: exports.compileFile(path)
+    factoryText: "function(require,exports,module,system,print){" + code + "/**/\n}"
+    if system.engine is "rhino"
+      Packages.org.mozilla.javascript.Context.getCurrentContext().compileFunction(global, factoryText, path, 0, null)
+    else
+      # eval requires parenthesis, but parenthesis break compileFunction.
+      eval("(" + factoryText + ")")..

lib/coffee_script/narwhal/js/coffee-script.js

@@ -1,16 +1,14 @@
 (function(){
   var File, OS, Readline, checkForErrors, coffeePath;
-  // This (javascript) file is generated from lib/coffee_script/narwhal/coffee-script.coffee
-  // Executes the `coffee` Ruby program to convert from CoffeeScript
-  // to Javascript. Eventually this will hopefully happen entirely within JS.
-  // Require external dependencies.
+  // This (javascript) file is generated from lib/coffee_script/narwhal/coffee-script.coffee Executes the `coffee` Ruby program to convert from CoffeeScript
+  // to Javascript. Eventually this will hopefully happen entirely within JS. Require external dependencies.
   OS = require('os');
   File = require('file');
   Readline = require('readline');
   // The path to the CoffeeScript Compiler.
   coffeePath = File.path(module.path).dirname().dirname().dirname().dirname().dirname().join('bin', 'coffee');
   // Our general-purpose error handler.
-  checkForErrors = function checkForErrors(coffeeProcess) {
+  checkForErrors = function(coffeeProcess) {
     if (coffeeProcess.wait() === 0) {
       return true;
     }
@@ -19,25 +17,16 @@
   };
   // Run a simple REPL, round-tripping to the CoffeeScript compiler for every
   // command.
-  exports.run = function run(args) {
-    var __a, __b, i, result;
+  exports.run = function(args) {
+    var result;
+    args.shift();
     if (args.length) {
-      __a = args;
-      __b = function(path, i) {
-        exports.evalCS(File.read(path));
-        delete args[i];
-      };
-      if (__a instanceof Array) {
-        for (i=0; i<__a.length; i++) __b(__a[i], i);
-      } else {
-        for (i in __a) { if (__a.hasOwnProperty(i)) __b(__a[i], i); }
-      }
-      return true;
+      return require(File.absolute(args[0]));
     }
     while (true) {
       try {
         system.stdout.write('coffee> ').flush();
-        result = exports.evalCS(Readline.readline(), ['--globals']);
+        result = exports.evalCS(Readline.readline());
         if (result !== undefined) {
           print(result);
         }
@@ -45,36 +34,35 @@
         print(e);
       }
     }
-    return null;
   };
   // Compile a given CoffeeScript file into JavaScript.
-  exports.compileFile = function compileFile(path) {
+  exports.compileFile = function(path) {
     var coffee;
     coffee = OS.popen([coffeePath, "--print", "--no-wrap", path]);
     checkForErrors(coffee);
     return coffee.stdout.read();
   };
   // Compile a string of CoffeeScript into JavaScript.
-  exports.compile = function compile(source, flags) {
+  exports.compile = function(source) {
     var coffee;
-    coffee = OS.popen([coffeePath, "--eval", "--no-wrap"].concat(flags || []));
+    coffee = OS.popen([coffeePath, "--eval", "--no-wrap"]);
     coffee.stdin.write(source).flush().close();
     checkForErrors(coffee);
     return coffee.stdout.read();
   };
   // Evaluating a string of CoffeeScript first compiles it externally.
-  exports.evalCS = function evalCS(source, flags) {
-    return eval(exports.compile(source, flags));
+  exports.evalCS = function(source) {
+    return eval(exports.compile(source));
   };
   // Make a factory for the CoffeeScript environment.
-  exports.makeNarwhalFactory = function makeNarwhalFactory(path) {
+  exports.makeNarwhalFactory = function(path) {
     var code, factoryText;
     code = exports.compileFile(path);
     factoryText = "function(require,exports,module,system,print){" + code + "/**/\n}";
     if (system.engine === "rhino") {
       return Packages.org.mozilla.javascript.Context.getCurrentContext().compileFunction(global, factoryText, path, 0, null);
     } else {
-      // eval requires parentheses, but parentheses break compileFunction.
+      // eval requires parenthesis, but parenthesis break compileFunction.
       return eval("(" + factoryText + ")");
     }
   };

lib/coffee_script/narwhal/js/launcher.js

@@ -0,0 +1,3 @@
+(function(){
+  require("coffee-script").run(system.args);
+})();

lib/coffee_script/narwhal/js/loader.js

@@ -6,14 +6,13 @@
   };
   loader = {
     // Reload the coffee-script environment from source.
-    reload: function reload(topId, path) {
+    reload: function(topId, path) {
       coffeescript = coffeescript || require('coffee-script');
-      return factories[topId] = function() {
-        return coffeescript.makeNarwhalFactory(path);
-      };
+      factories[topId] = coffeescript.makeNarwhalFactory(path);
+      return factories[topId];
     },
     // Ensure that the coffee-script environment is loaded.
-    load: function load(topId, path) {
+    load: function(topId, path) {
       return factories[topId] = factories[topId] || this.reload(topId, path);
     }
   };

lib/coffee_script/narwhal/launcher.coffee

@@ -0,0 +1 @@
+require("coffee-script").run(system.args)

lib/coffee_script/narwhal/loader.coffee

@@ -8,11 +8,11 @@ loader: {
   # Reload the coffee-script environment from source.
   reload: topId, path =>
     coffeescript ||= require('coffee-script')
-    factories[topId]: => coffeescript.makeNarwhalFactory(path)
+    factories[topId]: coffeescript.makeNarwhalFactory(path).
 
   # Ensure that the coffee-script environment is loaded.
   load: topId, path =>
-    factories[topId] ||= this.reload(topId, path)
+    factories[topId] ||= this.reload(topId, path).
 
 }
 

lib/coffee_script/nodes.rb

@@ -11,11 +11,17 @@ module CoffeeScript
       class_eval "def statement?; true; end"
     end
 
-    # Tag this node as a statement that cannot be transformed into an expression.
-    # (break, continue, etc.) It doesn't make sense to try to transform it.
-    def self.statement_only
-      statement
-      class_eval "def statement_only?; true; end"
+    # Tag this node as having a custom return, meaning that instead of returning
+    # it from the outside, you ask it to return itself, and it obliges.
+    def self.custom_return
+      class_eval "def custom_return?; true; end"
+    end
+
+    # Tag this node as having a custom assignment, meaning that instead of
+    # assigning it to a variable name from the outside, you pass it the variable
+    # name and let it take care of it.
+    def self.custom_assign
+      class_eval "def custom_assign?; true; end"
     end
 
     def write(code)
@@ -23,33 +29,16 @@ module CoffeeScript
       code
     end
 
-    # This is extremely important -- we convert JS statements into expressions
-    # by wrapping them in a closure, only if it's possible, and we're not at
-    # the top level of a block (which would be unnecessary), and we haven't
-    # already been asked to return the result.
     def compile(o={})
       @options = o.dup
-      @indent  = o[:indent]
-      top = self.is_a?(ForNode) ? @options[:top] : @options.delete(:top)
-      closure = statement? && !statement_only? && !top && !@options[:return]
-      closure ? compile_closure(@options) : compile_node(@options)
-    end
-
-    def compile_closure(o={})
-      indent = o[:indent]
-      @indent = (o[:indent] = idt(1))
-      "(function() {\n#{compile_node(o.merge(:return => true))}\n#{indent}})()"
-    end
-
-    # Quick method for the current indentation level, plus tabs out.
-    def idt(tabs=0)
-      @indent + (TAB * tabs)
     end
 
     # Default implementations of the common node methods.
-    def unwrap;           self;   end
-    def statement?;       false;  end
-    def statement_only?;  false;  end
+    def unwrap;                                 self;   end
+    def line_ending;                            ';';    end
+    def statement?;                             false;  end
+    def custom_return?;                         false;  end
+    def custom_assign?;                         false;  end
   end
 
   # A collection of nodes, each one representing an expression.
@@ -60,13 +49,12 @@ module CoffeeScript
     STRIP_TRAILING_WHITESPACE = /\s+$/
 
     # Wrap up a node as an Expressions, unless it already is.
-    def self.wrap(*nodes)
-      return nodes[0] if nodes.length == 1 && nodes[0].is_a?(Expressions)
-      Expressions.new(*nodes)
+    def self.wrap(node)
+      node.is_a?(Expressions) ? node : Expressions.new([node])
     end
 
-    def initialize(*nodes)
-      @expressions = nodes.flatten
+    def initialize(nodes)
+      @expressions = nodes
     end
 
     # Tack an expression onto the end of this node.
@@ -75,11 +63,6 @@ module CoffeeScript
       self
     end
 
-    def unshift(node)
-      @expressions.unshift(node)
-      self
-    end
-
     # If this Expressions consists of a single node, pull it back out.
     def unwrap
       @expressions.length == 1 ? @expressions.first : self
@@ -91,55 +74,46 @@ module CoffeeScript
       node == @expressions[@last_index]
     end
 
-    def compile(o={})
-      o[:scope] ? super(o) : compile_root(o)
-    end
-
-    # The extra fancy is to handle pushing down returns to the final lines of
-    # inner statements. Variables first defined within the Expressions body
-    # have their declarations pushed up top of the closest scope.
-    def compile_node(options={})
-      compiled = @expressions.map do |node|
-        o = options.dup
-        @indent = o[:indent]
-        returns = o.delete(:return)
-        if last?(node) && returns && !node.statement_only?
-          if node.statement?
-            node.compile(o.merge(:return => true))
-          else
-            if o[:top] && o[:last_assign] && o[:last_assign][0..0][/[A-Z]/]
-              temp = o[:scope].free_variable
-              "#{idt}#{temp} = #{node.compile(o)};\n#{idt}return #{o[:last_assign]} === this.constructor ? this : #{temp};"
-            else
-              "#{idt}return #{node.compile(o)};"
-            end
-          end
-        else
-          ending = node.statement? ? '' : ';'
-          indent = node.statement? ? '' : idt
-          "#{indent}#{node.compile(o.merge(:top => true))}#{ending}"
-        end
-      end
-      write(compiled.join("\n"))
-    end
-
     # If this is the top-level Expressions, wrap everything in a safety closure.
-    def compile_root(o={})
+    def root_compile(o={})
       indent = o[:no_wrap] ? '' : TAB
-      @indent = indent
-      o.merge!(:indent => indent, :scope => Scope.new(nil, self))
-      code = o[:globals] ? compile_node(o) : compile_with_declarations(o)
+      code = compile(o.merge(:indent => indent, :scope => Scope.new), o[:no_wrap] ? nil : :code)
       code.gsub!(STRIP_TRAILING_WHITESPACE, '')
       o[:no_wrap] ? code : "(function(){\n#{code}\n})();"
     end
 
-    def compile_with_declarations(o={})
-      code  = compile_node(o)
-      decls = ''
-      decls = "#{idt}var #{o[:scope].declared_variables.join(', ')};\n" if o[:scope].declarations?(self)
-      decls + code
+    # The extra fancy is to handle pushing down returns and assignments
+    # recursively to the final lines of inner statements.
+    # Variables first defined within the Expressions body have their
+    # declarations pushed up to the top scope.
+    def compile(options={}, parent=nil)
+      return root_compile(options) unless options[:scope]
+      compiled = @expressions.map do |node|
+        o = super(options)
+        if last?(node) && (o[:return] || o[:assign])
+          if o[:return]
+            if node.statement? || node.custom_return?
+              "#{o[:indent]}#{node.compile(o)}#{node.line_ending}"
+            else
+              "#{o[:indent]}return #{node.compile(o)}#{node.line_ending}"
+            end
+          elsif o[:assign]
+            if node.statement? || node.custom_assign?
+              "#{o[:indent]}#{node.compile(o)}#{node.line_ending}"
+            else
+              "#{o[:indent]}#{AssignNode.new(o[:assign], node).compile(o)};"
+            end
+          end
+        else
+          o.delete(:return) and o.delete(:assign)
+          "#{o[:indent]}#{node.compile(o)}#{node.line_ending}"
+        end
+      end
+      scope = options[:scope]
+      declarations = scope.any_declared? && parent == :code ? "#{options[:indent]}var #{scope.declared_variables.join(', ')};\n" : ''
+      code = declarations + compiled.join("\n")
+      write(code)
     end
-
   end
 
   # Literals are static values that have a Ruby representation, eg.: a string, a number,
@@ -147,16 +121,8 @@ module CoffeeScript
   class LiteralNode < Node
     STATEMENTS = ['break', 'continue']
 
-    CONVERSIONS = {
-      'arguments' => 'Array.prototype.slice.call(arguments, 0)'
-    }
-
     attr_reader :value
 
-    def self.wrap(string)
-      self.new(Value.new(string))
-    end
-
     def initialize(value)
       @value = value
     end
@@ -164,19 +130,21 @@ module CoffeeScript
     def statement?
       STATEMENTS.include?(@value.to_s)
     end
-    alias_method :statement_only?, :statement?
 
-    def compile_node(o)
-      val    = CONVERSIONS[@value.to_s] || @value.to_s
-      indent = statement? ? idt : ''
-      ending = statement? ? ';' : ''
-      write("#{indent}#{val}#{ending}")
+    def line_ending
+      @value.to_s[-1..-1] == ';' ? '' : ';'
+    end
+
+    def compile(o={})
+      o = super(o)
+      write(@value.to_s)
     end
   end
 
   # Try to return your expression, or tell it to return itself.
   class ReturnNode < Node
-    statement_only
+    statement
+    custom_return
 
     attr_reader :expression
 
@@ -184,24 +152,33 @@ module CoffeeScript
       @expression = expression
     end
 
-    def compile_node(o)
-      return write(@expression.compile(o.merge(:return => true))) if @expression.statement?
+    def line_ending
+      @expression.custom_return? ? '' : ';'
+    end
+
+    def compile(o={})
+      o = super(o)
+      return write(@expression.compile(o.merge(:return => true))) if @expression.custom_return?
       compiled = @expression.compile(o)
-      write(@expression.statement? ? "#{compiled}\n#{idt}return null;" : "#{idt}return #{compiled};")
+      write(@expression.statement? ? "#{compiled}\n#{indent}return null" : "return #{compiled}")
     end
   end
 
   # Pass through CoffeeScript comments into JavaScript comments at the
   # same position.
   class CommentNode < Node
-    statement_only
+    statement
 
     def initialize(lines)
       @lines = lines.value
     end
 
-    def compile_node(o={})
-      delimiter = "\n#{idt}//"
+    def line_ending
+      ''
+    end
+
+    def compile(o={})
+      delimiter = "\n#{o[:indent]}//"
       comment   = "#{delimiter}#{@lines.join(delimiter)}"
       write(comment)
     end
@@ -211,6 +188,8 @@ module CoffeeScript
   # Node for a function invocation. Takes care of converting super() calls into
   # calls against the prototype's function of the same name.
   class CallNode < Node
+    LEADING_DOT = /\A\./
+
     attr_reader :variable, :arguments
 
     def initialize(variable, arguments=[])
@@ -226,70 +205,42 @@ module CoffeeScript
       @variable == :super
     end
 
-    def prefix
-      @new ? "new " : ''
-    end
-
-    def splat?
-      @arguments.any? {|a| a.is_a?(ArgSplatNode) }
-    end
-
-    def <<(argument)
-      @arguments << argument
-    end
-
-    def compile_node(o)
-      return write(compile_splat(o)) if splat?
+    def compile(o={})
+      o = super(o)
       args = @arguments.map{|a| a.compile(o) }.join(', ')
       return write(compile_super(args, o)) if super?
+      prefix = @new ? "new " : ''
       write("#{prefix}#{@variable.compile(o)}(#{args})")
     end
 
     def compile_super(args, o)
-      methname = o[:last_assign]
+      methname = o[:last_assign].sub(LEADING_DOT, '')
       arg_part = args.empty? ? '' : ", #{args}"
-      meth     = o[:proto_assign] ? "#{o[:proto_assign]}.__superClass__.#{methname}" :
-                                    "#{methname}.__superClass__.constructor"
-      "#{meth}.call(this#{arg_part})"
-    end
-
-    def compile_splat(o)
-      meth = @variable.compile(o)
-      obj  = @variable.source || 'this'
-      args = @arguments.map do |arg|
-        code = arg.compile(o)
-        code = arg.is_a?(ArgSplatNode) ? code : "[#{code}]"
-        arg.equal?(@arguments.first) ? code : ".concat(#{code})"
-      end
-      "#{prefix}#{meth}.apply(#{obj}, #{args.join('')})"
+      "#{o[:proto_assign]}.__superClass__.#{methname}.call(this#{arg_part})"
     end
   end
 
   # Node to extend an object's prototype with an ancestor object.
   # After goog.inherits from the Closure Library.
   class ExtendsNode < Node
-    statement
     attr_reader :sub_object, :super_object
 
     def initialize(sub_object, super_object)
       @sub_object, @super_object = sub_object, super_object
     end
 
-    def compile_node(o={})
-      constructor = o[:scope].free_variable
+    def compile(o={})
       sub, sup = @sub_object.compile(o), @super_object.compile(o)
-      "#{idt}#{constructor} = function(){};\n#{idt}" +
-      "#{constructor}.prototype = #{sup}.prototype;\n#{idt}" +
-      "#{sub}.__superClass__ = #{sup}.prototype;\n#{idt}" +
-      "#{sub}.prototype = new #{constructor}();\n#{idt}" +
-      "#{sub}.prototype.constructor = #{sub};"
+      "#{sub}.__superClass__ = #{sup}.prototype;\n#{o[:indent]}" +
+      "#{sub}.prototype = new #{sup}();\n#{o[:indent]}" +
+      "#{sub}.prototype.constructor = #{sub}"
     end
 
   end
 
   # A value, indexed or dotted into, or vanilla.
   class ValueNode < Node
-    attr_reader :literal, :properties, :last, :source
+    attr_reader :literal, :properties, :last
 
     def initialize(literal, properties=[])
       @literal, @properties = literal, properties
@@ -308,14 +259,20 @@ module CoffeeScript
       @literal.is_a?(Node) && @literal.statement? && !properties?
     end
 
-    def compile_node(o)
-      only  = o.delete(:only_first)
-      props = only ? @properties[0...-1] : @properties
-      parts = [@literal, props].flatten.map do |val|
+    def custom_assign?
+      @literal.is_a?(Node) && @literal.custom_assign? && !properties?
+    end
+
+    def custom_return?
+      @literal.is_a?(Node) && @literal.custom_return? && !properties?
+    end
+
+    def compile(o={})
+      o = super(o)
+      parts = [@literal, @properties].flatten.map do |val|
         val.respond_to?(:compile) ? val.compile(o) : val.to_s
       end
       @last = parts.last
-      @source = parts.length > 1 ? parts[0...-1].join('') : nil
       write(parts.join(''))
     end
   end
@@ -324,13 +281,13 @@ module CoffeeScript
   class AccessorNode < Node
     attr_reader :name
 
-    def initialize(name, prototype=false)
-      @name, @prototype = name, prototype
+    def initialize(name)
+      @name = name
     end
 
-    def compile_node(o)
-      proto = @prototype ? "prototype." : ''
-      write(".#{proto}#{@name}")
+    def compile(o={})
+      o = super(o)
+      write(".#{@name}")
     end
   end
 
@@ -342,14 +299,15 @@ module CoffeeScript
       @index = index
     end
 
-    def compile_node(o)
+    def compile(o={})
+      o = super(o)
       write("[#{@index.compile(o)}]")
     end
   end
 
   # A range literal. Ranges can be used to extract portions (slices) of arrays,
   # or to specify a range for array comprehensions.
-  class RangeNode < Node
+  class RangeNode
     attr_reader :from, :to
 
     def initialize(from, to, exclusive=false)
@@ -368,30 +326,12 @@ module CoffeeScript
       @exclusive ? '>' : '>='
     end
 
-    def compile_variables(o)
-      @indent = o[:indent]
-      @from_var, @to_var = o[:scope].free_variable, o[:scope].free_variable
-      from_val,  to_val  = @from.compile(o), @to.compile(o)
-      write("#{@from_var} = #{from_val}; #{@to_var} = #{to_val};\n#{idt}")
-    end
-
-    def compile_node(o)
-      idx, step = o.delete(:index), o.delete(:step)
-      return compile_array(o) unless idx
-      vars     = "#{idx}=#{@from_var}"
-      step     = step ? step.compile(o) : '1'
-      compare  = "(#{@from_var} <= #{@to_var} ? #{idx} #{less_operator} #{@to_var} : #{idx} #{greater_operator} #{@to_var})"
-      incr     = "(#{@from_var} <= #{@to_var} ? #{idx} += #{step} : #{idx} -= #{step})"
-      write("#{vars}; #{compare}; #{incr}")
-    end
-
-    # Expand the range into the equivalent array, if it's not being used as
-    # part of a comprehension, slice, or splice.
-    # TODO: This generates pretty ugly code ... shrink it.
-    def compile_array(o)
-      body = Expressions.wrap(LiteralNode.wrap('i'))
-      arr  = Expressions.wrap(ForNode.new(body, {:source => ValueNode.new(self)}, Value.new('i')))
-      ParentheticalNode.new(CallNode.new(CodeNode.new([], arr))).compile(o)
+    def compile(o, fv, tv)
+      fvv, tvv = @from.compile(o), @to.compile(o)
+      vars     = "#{fv}=#{fvv}, #{tv}=#{tvv}"
+      compare  = "(#{fvv} <= #{tvv} ? #{fv} #{less_operator} #{tv} : #{fv} #{greater_operator} #{tv})"
+      incr     = "(#{fvv} <= #{tvv} ? #{fv} += 1 : #{fv} -= 1)"
+      "#{vars}; #{compare}; #{incr}"
     end
 
   end
@@ -406,7 +346,8 @@ module CoffeeScript
       @range = range
     end
 
-    def compile_node(o)
+    def compile(o={})
+      o         = super(o)
       from      = @range.from.compile(o)
       to        = @range.to.compile(o)
       plus_part = @range.exclusive? ? '' : ' + 1'
@@ -417,7 +358,8 @@ module CoffeeScript
   # Setting the value of a local variable, or the value of an object property.
   class AssignNode < Node
     PROTO_ASSIGN = /\A(\S+)\.prototype/
-    LEADING_DOT = /\A\.(prototype\.)?/
+
+    custom_return
 
     attr_reader :variable, :value, :context
 
@@ -425,26 +367,22 @@ module CoffeeScript
       @variable, @value, @context = variable, value, context
     end
 
-    def compile_node(o)
-      return compile_splice(o) if @variable.properties.last.is_a?(SliceNode)
-      name      = @variable.compile(o)
-      last      = @variable.last.to_s.sub(LEADING_DOT, '')
-      proto     = name[PROTO_ASSIGN, 1]
-      o         = o.merge(:last_assign => last, :proto_assign => proto)
-      o[:immediate_assign] = last if @value.is_a?(CodeNode) && last.match(Lexer::IDENTIFIER)
-      return write("#{name}: #{@value.compile(o)}") if @context == :object
-      o[:scope].find(name) unless @variable.properties?
-      val = "#{name} = #{@value.compile(o)}"
-      write(o[:return] ? "#{idt}return (#{val})" : val)
+    def line_ending
+      @value.custom_assign? ? '' : ';'
     end
 
-    def compile_splice(o)
-      var   = @variable.compile(o.merge(:only_first => true))
-      range = @variable.properties.last.range
-      plus  = range.exclusive? ? '' : ' + 1'
-      from  = range.from.compile(o)
-      to    = "#{range.to.compile(o)} - #{from}#{plus}"
-      write("#{var}.splice.apply(#{var}, [#{from}, #{to}].concat(#{@value.compile(o)}))")
+    def compile(o={})
+      o = super(o)
+      name      = @variable.compile(o)
+      last      = @variable.last.to_s
+      proto     = name[PROTO_ASSIGN, 1]
+      o         = o.merge(:assign => @variable, :last_assign => last, :proto_assign => proto)
+      postfix   = o[:return] ? ";\n#{o[:indent]}return #{name}" : ''
+      return write("#{name}: #{@value.compile(o)}") if @context == :object
+      return write("#{name} = #{@value.compile(o)}#{postfix}") if @variable.properties? && !@value.custom_assign?
+      o[:scope].find(name) unless @variable.properties?
+      return write(@value.compile(o)) if @value.custom_assign?
+      write("#{name} = #{@value.compile(o)}#{postfix}")
     end
   end
 
@@ -452,30 +390,31 @@ module CoffeeScript
   # CoffeeScript operations into their JavaScript equivalents.
   class OpNode < Node
     CONVERSIONS = {
-      :==     => "===",
-      :'!='   => "!==",
-      :and    => '&&',
-      :or     => '||',
-      :is     => '===',
-      :isnt   => "!==",
-      :not    => '!'
+      "=="    => "===",
+      "!="    => "!==",
+      'and'   => '&&',
+      'or'    => '||',
+      'is'    => '===',
+      "isnt"  => "!==",
+      'not'   => '!'
     }
-    CONDITIONALS     = [:'||=', :'&&=']
-    PREFIX_OPERATORS = [:typeof, :delete]
+    CONDITIONALS     = ['||=', '&&=']
+    PREFIX_OPERATORS = ['typeof', 'delete']
 
     attr_reader :operator, :first, :second
 
     def initialize(operator, first, second=nil, flip=false)
       @first, @second, @flip = first, second, flip
-      @operator = CONVERSIONS[operator.to_sym] || operator
+      @operator = CONVERSIONS[operator] || operator
     end
 
     def unary?
       @second.nil?
     end
 
-    def compile_node(o)
-      return write(compile_conditional(o)) if CONDITIONALS.include?(@operator.to_sym)
+    def compile(o={})
+      o = super(o)
+      return write(compile_conditional(o)) if CONDITIONALS.include?(@operator)
       return write(compile_unary(o)) if unary?
       write("#{@first.compile(o)} #{@operator} #{@second.compile(o)}")
     end
@@ -487,7 +426,7 @@ module CoffeeScript
     end
 
     def compile_unary(o)
-      space = PREFIX_OPERATORS.include?(@operator.to_sym) ? ' ' : ''
+      space = PREFIX_OPERATORS.include?(@operator.to_s) ? ' ' : ''
       parts = [@operator.to_s, space, @first.compile(o)]
       parts.reverse! if @flip
       parts.join('')
@@ -503,55 +442,20 @@ module CoffeeScript
       @body = body
     end
 
-    def compile_node(o)
-      shared_scope = o.delete(:shared_scope)
-      o[:scope]    = shared_scope || Scope.new(o[:scope], @body)
-      o[:return]   = true
-      o[:top]      = true
-      o[:indent]   = idt(1)
+    def compile(o={})
+      o = super(o)
+      o[:scope] = Scope.new(o[:scope])
+      o[:return] = true
+      indent = o[:indent]
+      o[:indent] += TAB
+      o.delete(:assign)
       o.delete(:no_wrap)
-      o.delete(:globals)
-      name = o.delete(:immediate_assign)
-      if @params.last.is_a?(ParamSplatNode)
-        splat = @params.pop
-        splat.index = @params.length
-        @body.unshift(splat)
-      end
       @params.each {|id| o[:scope].parameter(id.to_s) }
-      code = @body.compile_with_declarations(o)
-      name_part = name ? " #{name}" : ''
-      write("function#{name_part}(#{@params.join(', ')}) {\n#{code}\n#{idt}}")
+      code = @body.compile(o, :code)
+      write("function(#{@params.join(', ')}) {\n#{code}\n#{indent}}")
     end
   end
 
-  # A parameter splat in a function definition.
-  class ParamSplatNode < Node
-    attr_accessor :index
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
-    end
-
-    def compile_node(o={})
-      o[:scope].find(@name)
-      write("#{@name} = Array.prototype.slice.call(arguments, #{@index})")
-    end
-  end
-
-  class ArgSplatNode < Node
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    def compile_node(o={})
-      write(@value.compile(o))
-    end
-
-  end
-
   # An object literal.
   class ObjectNode < Node
     attr_reader :properties
@@ -560,21 +464,15 @@ module CoffeeScript
       @properties = properties
     end
 
-    # All the mucking about with commas is to make sure that CommentNodes and
-    # AssignNodes get interleaved correctly, with no trailing commas or
-    # commas affixed to comments. TODO: Extract this and add it to ArrayNode.
-    def compile_node(o)
-      o[:indent] = idt(1)
-      joins = Hash.new("\n")
-      non_comments = @properties.select {|p| !p.is_a?(CommentNode) }
-      non_comments.each {|p| joins[p] = p == non_comments.last ? "\n" : ",\n" }
-      props  = @properties.map { |prop|
-        join = joins[prop]
-        join = '' if prop == @properties.last
-        indent = prop.is_a?(CommentNode) ? '' : idt(1)
-        "#{indent}#{prop.compile(o)}#{join}"
+    def compile(o={})
+      o = super(o)
+      indent = o[:indent]
+      o[:indent] += TAB
+      props = @properties.map { |prop|
+        joiner = prop == @properties.last ? '' : prop.is_a?(CommentNode) ? "\n" : ",\n"
+        o[:indent] + prop.compile(o) + joiner
       }.join('')
-      write("{\n#{props}\n#{idt}}")
+      write("{\n#{props}\n#{indent}}")
     end
   end
 
@@ -586,14 +484,13 @@ module CoffeeScript
       @objects = objects
     end
 
-    def compile_node(o)
-      o[:indent] = idt(1)
+    def compile(o={})
+      o = super(o)
       objects = @objects.map { |obj|
-        code = obj.compile(o)
-        obj.is_a?(CommentNode) ? "\n#{code}\n#{o[:indent]}" :
-        obj == @objects.last   ? code : "#{code}, "
+        joiner = obj.is_a?(CommentNode) ? "\n#{o[:indent] + TAB}" : obj == @objects.last ? '' : ', '
+        obj.compile(o.merge(:indent => o[:indent] + TAB)) + joiner
       }.join('')
-      ending = objects.include?("\n") ? "\n#{idt}]" : ']'
+      ending = objects.include?("\n") ? "\n#{o[:indent]}]" : ']'
       write("[#{objects}#{ending}")
     end
   end
@@ -609,14 +506,16 @@ module CoffeeScript
       @condition, @body = condition, body
     end
 
-    def compile_node(o)
-      returns     = o.delete(:return)
-      o[:indent]  = idt(1)
-      o[:top]     = true
-      cond        = @condition.compile(o)
-      post        = returns ? "\n#{idt}return null;" : ''
-      return write("#{idt}while (#{cond}) null;#{post}") if @body.nil?
-      write("#{idt}while (#{cond}) {\n#{@body.compile(o)}\n#{idt}}#{post}")
+    def line_ending
+      ''
+    end
+
+    def compile(o={})
+      o = super(o)
+      o.delete(:return)
+      indent = o[:indent] + TAB
+      cond = @condition.compile(o)
+      write("while (#{cond}) {\n#{@body.compile(o.merge(:indent => indent))}\n#{o[:indent]}}")
     end
   end
 
@@ -626,77 +525,74 @@ module CoffeeScript
   # the current index of the loop as a second parameter.
   class ForNode < Node
     statement
+    custom_return
+    custom_assign
 
-    attr_reader :body, :source, :name, :index, :filter, :step
+    attr_reader :body, :source, :name, :filter, :index
 
-    def initialize(body, source, name, index=nil)
-      @body, @name, @index = body, name, index
-      @source = source[:source]
-      @filter = source[:filter]
-      @step   = source[:step]
-      @object = !!source[:object]
-      @name, @index = @index, @name if @object
+    def initialize(body, source, name, filter, index=nil)
+      @body, @source, @name, @filter, @index = body, source, name, filter, index
     end
 
-    def compile_node(o)
-      top_level     = o.delete(:top) && !o[:return]
-      range         = @source.is_a?(ValueNode) && @source.literal.is_a?(RangeNode) && @source.properties.empty?
-      source        = range ? @source.literal : @source
+    def line_ending
+      ''
+    end
+
+    def compile(o={})
+      o = super(o)
+      range         = @source.is_a?(RangeNode)
       scope         = o[:scope]
-      name_found    = @name  && scope.find(@name)
+      name_found    = scope.find(@name)
       index_found   = @index && scope.find(@index)
-      body_dent     = idt(1)
       svar          = scope.free_variable
-      ivar          = range ? name : @index ? @index : scope.free_variable
-      rvar          = scope.free_variable unless top_level
+      ivar          = range ? name : scope.free_variable
+      lvar          = scope.free_variable
+      rvar          = scope.free_variable
+      index_name    = @index ? @index : nil
       if range
-        index_var   = scope.free_variable
-        source_part = source.compile_variables(o)
-        for_part    = "#{index_var}=0, #{source.compile(o.merge(:index => ivar, :step => @step))}, #{index_var}++"
+        source_part = ''
         var_part    = ''
+        index_part  = ''
+        index_var   = scope.free_variable
+        for_part    = "#{index_var}=0, #{@source.compile(o, ivar, lvar)}, #{index_var}++"
       else
         index_var   = nil
-        source_part = "#{svar} = #{source.compile(o)};\n#{idt}"
-        for_part    = "#{ivar}=0; #{ivar}<#{svar}.length; #{ivar}++"
-        for_part    = "#{ivar} in #{svar}" if @object
-        var_part    = @name ? "#{body_dent}#{@name} = #{svar}[#{ivar}];\n" : ''
+        source_part = "#{svar} = #{@source.compile(o)};\n#{o[:indent]}"
+        for_part    = "#{ivar}=0, #{lvar}=#{svar}.length; #{ivar}<#{lvar}; #{ivar}++"
+        var_part    = "\n#{o[:indent] + TAB}#{@name} = #{svar}[#{ivar}];"
+        index_part  = @index ? "\n#{o[:indent] + TAB}#{index_name} = #{ivar};" : ''
       end
       body          = @body
-      set_result    = rvar ? "#{idt}#{rvar} = []; " : idt
-      return_result = rvar || ''
-      if top_level
-        body = Expressions.wrap(body)
-      else
-        body = Expressions.wrap(CallNode.new(
-          ValueNode.new(LiteralNode.new(rvar), [AccessorNode.new('push')]), [body.unwrap]
-        ))
-      end
-      if o[:return]
+      suffix        = ';'
+      set_result    = "#{rvar} = [];\n#{o[:indent]}"
+      save_result   = "#{rvar}[#{index_var || ivar}] = "
+      return_result = rvar
+
+      if o[:return] || o[:assign]
+        return_result = "#{o[:assign].compile(o)} = #{return_result}" if o[:assign]
         return_result = "return #{return_result}" if o[:return]
-        o.delete(:return)
-        body = IfNode.new(@filter, body, nil, :statement => true) if @filter
+        if @filter
+          body = CallNode.new(ValueNode.new(LiteralNode.new(rvar), [AccessorNode.new('push')]), [@body])
+          body = IfNode.new(@filter, body, nil, :statement => true)
+          save_result = ''
+          suffix = ''
+        end
       elsif @filter
-        body = Expressions.wrap(IfNode.new(@filter, body))
-      end
-      if @object
-        body = Expressions.wrap(IfNode.new(
-          CallNode.new(ValueNode.new(LiteralNode.wrap(svar), [AccessorNode.new(Value.new('hasOwnProperty'))]), [LiteralNode.wrap(ivar)]),
-          Expressions.wrap(body),
-          nil,
-          {:statement => true}
-        ))
+        body = IfNode.new(@filter, @body)
       end
 
-      return_result = "\n#{idt}#{return_result};" unless top_level
-      body = body.compile(o.merge(:indent => body_dent, :top => true))
-      vars = range ? @name : "#{@name}, #{ivar}"
-      return write(set_result + source_part + "for (#{for_part}) {\n#{var_part}#{body}\n#{idt}}\n#{idt}#{return_result}")
+      return_result = "\n#{o[:indent]}#{return_result};"
+      indent = o[:indent] + TAB
+      body = body.compile(o.merge(:indent => indent))
+      write("#{source_part}#{set_result}for (#{for_part}) {#{var_part}#{index_part}\n#{indent}#{save_result}#{body}#{suffix}\n#{o[:indent]}}#{return_result}")
     end
   end
 
   # A try/catch/finally block.
   class TryNode < Node
     statement
+    custom_return
+    custom_assign
 
     attr_reader :try, :error, :recovery, :finally
 
@@ -704,19 +600,24 @@ module CoffeeScript
       @try, @error, @recovery, @finally = try, error, recovery, finally
     end
 
-    def compile_node(o)
-      o[:indent] = idt(1)
-      o[:top] = true
+    def line_ending
+      ''
+    end
+
+    def compile(o={})
+      o = super(o)
+      indent = o[:indent]
+      o[:indent] += TAB
       error_part = @error ? " (#{@error}) " : ' '
-      catch_part = @recovery &&  " catch#{error_part}{\n#{@recovery.compile(o)}\n#{idt}}"
-      finally_part = @finally && " finally {\n#{@finally.compile(o.merge(:return => nil))}\n#{idt}}"
-      write("#{idt}try {\n#{@try.compile(o)}\n#{idt}}#{catch_part}#{finally_part}")
+      catch_part = @recovery &&  " catch#{error_part}{\n#{@recovery.compile(o)}\n#{indent}}"
+      finally_part = @finally && " finally {\n#{@finally.compile(o.merge(:assign => nil, :return => nil))}\n#{indent}}"
+      write("try {\n#{@try.compile(o)}\n#{indent}}#{catch_part}#{finally_part}")
     end
   end
 
   # Throw an exception.
   class ThrowNode < Node
-    statement_only
+    statement
 
     attr_reader :expression
 
@@ -724,22 +625,9 @@ module CoffeeScript
       @expression = expression
     end
 
-    def compile_node(o)
-      write("#{idt}throw #{@expression.compile(o)};")
-    end
-  end
-
-  # Check an expression for existence (meaning not null or undefined).
-  class ExistenceNode < Node
-    attr_reader :expression
-
-    def initialize(expression)
-      @expression = expression
-    end
-
-    def compile_node(o)
-      val = @expression.compile(o)
-      write("(typeof #{val} !== \"undefined\" && #{val} !== null)")
+    def compile(o={})
+      o = super(o)
+      write("throw #{@expression.compile(o)}")
     end
   end
 
@@ -749,12 +637,25 @@ module CoffeeScript
   class ParentheticalNode < Node
     attr_reader :expressions
 
-    def initialize(expressions, line=nil)
+    def initialize(expressions)
       @expressions = expressions.unwrap
-      @line = line
     end
 
-    def compile_node(o)
+    def statement?
+      @expressions.unwrap.statement?
+    end
+
+    def custom_assign?
+      @expressions.custom_assign?
+    end
+
+    def custom_return?
+      @expressions.custom_return?
+    end
+
+    def compile(o={})
+      raise SyntaxError, "parentheses can't be wrapped around a statement" if statement?
+      o = super(o)
       compiled = @expressions.compile(o)
       compiled = compiled[0...-1] if compiled[-1..-1] == ';'
       write("(#{compiled})")
@@ -782,16 +683,6 @@ module CoffeeScript
       self
     end
 
-    def add_comment(comment)
-      @comment = comment
-      self
-    end
-
-    def force_statement
-      @tags[:statement] = true
-      self
-    end
-
     # Rewrite a chain of IfNodes with their switch condition for equality.
     def rewrite_condition(expression)
       @condition = OpNode.new("is", expression, @condition)
@@ -800,8 +691,8 @@ module CoffeeScript
     end
 
     # Rewrite a chain of IfNodes to add a default case as the final else.
-    def add_else(exprs)
-      chain? ? @else_body.add_else(exprs) : @else_body = (exprs && exprs.unwrap)
+    def add_else(expressions)
+      chain? ? @else_body.add_else(expressions) : @else_body = expressions
       self
     end
 
@@ -813,29 +704,36 @@ module CoffeeScript
     # The IfNode only compiles into a statement if either of the bodies needs
     # to be a statement.
     def statement?
-      @is_statement ||= !!(@comment || @tags[:statement] || @body.statement? || (@else_body && @else_body.statement?))
+      @is_statement ||= !!(@tags[:statement] || @body.statement? || (@else_body && @else_body.statement?))
     end
 
-    def compile_node(o)
+    def custom_return?
+      statement?
+    end
+
+    def custom_assign?
+      statement?
+    end
+
+    def line_ending
+      statement? ? '' : ';'
+    end
+
+    def compile(o={})
+      o = super(o)
       write(statement? ? compile_statement(o) : compile_ternary(o))
     end
 
     # Compile the IfNode as a regular if-else statement. Flattened chains
     # force sub-else bodies into statement form.
     def compile_statement(o)
-      child       = o.delete(:chain_child)
-      cond_o      = o.dup
-      cond_o.delete(:return)
-      o[:indent]  = idt(1)
-      o[:top]     = true
-      if_dent     = child ? '' : idt
-      com_dent    = child ? idt : ''
-      prefix      = @comment ? @comment.compile(cond_o) + "\n#{com_dent}" : ''
-      if_part     = "#{prefix}#{if_dent}if (#{@condition.compile(cond_o)}) {\n#{Expressions.wrap(@body).compile(o)}\n#{idt}}"
+      indent = o[:indent]
+      o[:indent] += TAB
+      if_part   = "if (#{@condition.compile(o)}) {\n#{Expressions.wrap(@body).compile(o)}\n#{indent}}"
       return if_part unless @else_body
       else_part = chain? ?
-        " else #{@else_body.compile(o.merge(:indent => idt, :chain_child => true))}" :
-        " else {\n#{Expressions.wrap(@else_body).compile(o)}\n#{idt}}"
+        " else #{@else_body.compile(o.merge(:indent => indent))}" :
+        " else {\n#{Expressions.wrap(@else_body).compile(o)}\n#{indent}}"
       if_part + else_part
     end
 

lib/coffee_script/parse_error.rb

@@ -12,9 +12,8 @@ module CoffeeScript
     def message
       line      = @value.respond_to?(:line) ? @value.line : "END"
       line_part = "line #{line}:"
-      id_part   = @token_id != @value.inspect ? ", unexpected #{@token_id.to_s.downcase}" : ""
-      val_part  = ['INDENT', 'OUTDENT'].include?(@token_id) ? '' : " for '#{@value.to_s}'"
-      "#{line_part} syntax error#{val_part}#{id_part}"
+      id_part   = @token_id != @value.inspect ? ", unexpected #{@token_id.downcase}" : ""
+      "#{line_part} syntax error for '#{@value.to_s}'#{id_part}"
     end
     alias_method :inspect, :message
 

lib/coffee_script/rewriter.rb

@@ -1,212 +0,0 @@
-module CoffeeScript
-
-  # In order to keep the grammar simple, the stream of tokens that the Lexer
-  # emits is rewritten by the Rewriter, smoothing out ambiguities, mis-nested
-  # indentation, and single-line flavors of expressions.
-  class Rewriter
-
-    # Tokens that must be balanced.
-    BALANCED_PAIRS = [['(', ')'], ['[', ']'], ['{', '}'], [:INDENT, :OUTDENT]]
-
-    # Tokens that signal the start of a balanced pair.
-    EXPRESSION_START = BALANCED_PAIRS.map {|pair| pair.first }
-
-    # Tokens that signal the end of a balanced pair.
-    EXPRESSION_TAIL  = BALANCED_PAIRS.map {|pair| pair.last }
-
-    # Tokens that indicate the close of a clause of an expression.
-    EXPRESSION_CLOSE = [:CATCH, :WHEN, :ELSE, :FINALLY] + EXPRESSION_TAIL
-
-    # The inverse mappings of token pairs we're trying to fix up.
-    INVERSES = BALANCED_PAIRS.inject({}) do |memo, pair|
-      memo[pair.first] = pair.last
-      memo[pair.last]  = pair.first
-      memo
-    end
-
-    # Single-line flavors of block expressions that have unclosed endings.
-    # The grammar can't disambiguate them, so we insert the implicit indentation.
-    SINGLE_LINERS  = [:ELSE, "=>", :TRY, :FINALLY, :THEN]
-    SINGLE_CLOSERS = ["\n", :CATCH, :FINALLY, :ELSE, :OUTDENT, :LEADING_WHEN]
-
-    # Rewrite the token stream in multiple passes, one logical filter at
-    # a time. This could certainly be changed into a single pass through the
-    # stream, with a big ol' efficient switch, but it's much nicer like this.
-    def rewrite(tokens)
-      @tokens = tokens
-      adjust_comments
-      remove_mid_expression_newlines
-      move_commas_outside_outdents
-      add_implicit_indentation
-      ensure_balance(*BALANCED_PAIRS)
-      rewrite_closing_parens
-      @tokens
-    end
-
-    # Rewrite the token stream, looking one token ahead and behind.
-    # Allow the return value of the block to tell us how many tokens to move
-    # forwards (or backwards) in the stream, to make sure we don't miss anything
-    # as the stream changes length under our feet.
-    def scan_tokens
-      i = 0
-      loop do
-        break unless @tokens[i]
-        move = yield(@tokens[i - 1], @tokens[i], @tokens[i + 1], i)
-        i += move
-      end
-    end
-
-    # Massage newlines and indentations so that comments don't have to be
-    # correctly indented, or appear on their own line.
-    def adjust_comments
-      scan_tokens do |prev, token, post, i|
-        next 1 unless token[0] == :COMMENT
-        before, after = @tokens[i - 2], @tokens[i + 2]
-        if before && after &&
-            ((before[0] == :INDENT && after[0] == :OUTDENT) ||
-            (before[0] == :OUTDENT && after[0] == :INDENT)) &&
-            before[1] == after[1]
-          @tokens.delete_at(i + 2)
-          @tokens.delete_at(i - 2)
-          next 0
-        elsif prev[0] == "\n" && [:INDENT, :OUTDENT].include?(after[0])
-          @tokens.delete_at(i + 2)
-          @tokens[i - 1] = after
-          next 1
-        elsif !["\n", :INDENT, :OUTDENT].include?(prev[0])
-          @tokens.insert(i, ["\n", Value.new("\n", token[1].line)])
-          next 2
-        else
-          next 1
-        end
-      end
-    end
-
-    # Some blocks occur in the middle of expressions -- when we're expecting
-    # this, remove their trailing newlines.
-    def remove_mid_expression_newlines
-      scan_tokens do |prev, token, post, i|
-        next 1 unless post && EXPRESSION_CLOSE.include?(post[0]) && token[0] == "\n"
-        @tokens.delete_at(i)
-        next 0
-      end
-    end
-
-    # Make sure that we don't accidentally break trailing commas, which need
-    # to go on the outside of expression closers.
-    def move_commas_outside_outdents
-      scan_tokens do |prev, token, post, i|
-        if token[0] == :OUTDENT && prev[0] == ','
-          @tokens.delete_at(i)
-          @tokens.insert(i - 1, token)
-        end
-        next 1
-      end
-    end
-
-    # Because our grammar is LALR(1), it can't handle some single-line
-    # expressions that lack ending delimiters. Use the lexer to add the implicit
-    # blocks, so it doesn't need to.
-    # ')' can close a single-line block, but we need to make sure it's balanced.
-    def add_implicit_indentation
-      scan_tokens do |prev, token, post, i|
-        next 1 unless SINGLE_LINERS.include?(token[0]) && post[0] != :INDENT &&
-          !(token[0] == :ELSE && post[0] == :IF) # Elsifs shouldn't get blocks.
-        line = token[1].line
-        @tokens.insert(i + 1, [:INDENT, Value.new(2, line)])
-        idx = i + 1
-        parens = 0
-        loop do
-          idx += 1
-          tok = @tokens[idx]
-          if !tok || SINGLE_CLOSERS.include?(tok[0]) ||
-              (tok[0] == ')' && parens == 0)
-            @tokens.insert(idx, [:OUTDENT, Value.new(2, line)])
-            break
-          end
-          parens += 1 if tok[0] == '('
-          parens -= 1 if tok[0] == ')'
-        end
-        next 1 unless token[0] == :THEN
-        @tokens.delete_at(i)
-        next 0
-      end
-    end
-
-    # Ensure that all listed pairs of tokens are correctly balanced throughout
-    # the course of the token stream.
-    def ensure_balance(*pairs)
-      levels = Hash.new(0)
-      scan_tokens do |prev, token, post, i|
-        pairs.each do |pair|
-          open, close = *pair
-          levels[open] += 1 if token[0] == open
-          levels[open] -= 1 if token[0] == close
-          raise ParseError.new(token[0], token[1], nil) if levels[open] < 0
-        end
-        next 1
-      end
-      unclosed = levels.detect {|k, v| v > 0 }
-      raise SyntaxError, "unclosed '#{unclosed[0]}'" if unclosed
-    end
-
-    # We'd like to support syntax like this:
-    #    el.click(event =>
-    #      el.hide())
-    # In order to accomplish this, move outdents that follow closing parens
-    # inwards, safely. The steps to accomplish this are:
-    #
-    # 1. Check that all paired tokens are balanced and in order.
-    # 2. Rewrite the stream with a stack: if you see an '(' or INDENT, add it
-    #    to the stack. If you see an ')' or OUTDENT, pop the stack and replace
-    #    it with the inverse of what we've just popped.
-    # 3. Keep track of "debt" for tokens that we fake, to make sure we end
-    #    up balanced in the end.
-    #
-    def rewrite_closing_parens
-      verbose = ENV['VERBOSE']
-      stack, debt = [], Hash.new(0)
-      stack_stats = lambda { "stack: #{stack.inspect} debt: #{debt.inspect}\n\n" }
-      puts "rewrite_closing_original: #{@tokens.inspect}" if verbose
-      scan_tokens do |prev, token, post, i|
-        tag, inv = token[0], INVERSES[token[0]]
-        # Push openers onto the stack.
-        if EXPRESSION_START.include?(tag)
-          stack.push(token)
-          puts "pushing #{tag} #{stack_stats[]}" if verbose
-          next 1
-        # The end of an expression, check stack and debt for a pair.
-        elsif EXPRESSION_TAIL.include?(tag)
-          puts @tokens[i..-1].inspect if verbose
-          # If the tag is already in our debt, swallow it.
-          if debt[inv] > 0
-            debt[inv] -= 1
-            @tokens.delete_at(i)
-            puts "tag in debt #{tag} #{stack_stats[]}" if verbose
-            next 0
-          else
-            # Pop the stack of open delimiters.
-            match = stack.pop
-            mtag  = match[0]
-            # Continue onwards if it's the expected tag.
-            if tag == INVERSES[mtag]
-              puts "expected tag #{tag} #{stack_stats[]}" if verbose
-              next 1
-            else
-              # Unexpected close, insert correct close, adding to the debt.
-              debt[mtag] += 1
-              puts "unexpected #{tag}, replacing with #{INVERSES[mtag]} #{stack_stats[]}" if verbose
-              val = mtag == :INDENT ? match[1] : INVERSES[mtag]
-              @tokens.insert(i, [INVERSES[mtag], Value.new(val, token[1].line)])
-              next 1
-            end
-          end
-        else
-          # Uninteresting token:
-          next 1
-        end
-      end
-    end
-
-  end
-end

lib/coffee_script/scope.rb

@@ -5,19 +5,18 @@ module CoffeeScript
   # whether a variable has been seen before or if it needs to be declared.
   class Scope
 
-    attr_reader :parent, :expressions, :variables, :temp_variable
+    attr_reader :parent, :variables, :temp_variable
 
-    # Initialize a scope with its parent, for lookups up the chain,
-    # as well as the Expressions body where it should declare its variables.
-    def initialize(parent, expressions)
-      @parent, @expressions = parent, expressions
+    # Initialize a scope with its parent, for lookups up the chain.
+    def initialize(parent=nil)
+      @parent = parent
       @variables = {}
-      @temp_variable = @parent ? @parent.temp_variable.dup : '__a'
+      @temp_variable = @parent ? @parent.temp_variable : '__a'
     end
 
     # Look up a variable in lexical scope, or declare it if not found.
     def find(name, remote=false)
-      found = check(name)
+      found = check(name, remote)
       return found if found || remote
       @variables[name.to_sym] = :var
       found
@@ -30,9 +29,9 @@ module CoffeeScript
     end
 
     # Just check to see if a variable has already been declared.
-    def check(name)
+    def check(name, remote=false)
       return true if @variables[name.to_sym]
-      !!(@parent && @parent.check(name))
+      @parent && @parent.find(name, true)
     end
 
     # You can reset a found variable on the immediate scope.
@@ -47,8 +46,8 @@ module CoffeeScript
       @temp_variable.dup
     end
 
-    def declarations?(body)
-      !declared_variables.empty? && body == @expressions
+    def any_declared?
+      !declared_variables.empty?
     end
 
     # Return the list of variables first declared in current scope.
@@ -56,10 +55,6 @@ module CoffeeScript
       @variables.select {|k, v| v == :var }.map {|pair| pair[0].to_s }.sort
     end
 
-    def inspect
-      "<Scope:#{__id__} #{@variables.inspect}>"
-    end
-
   end
 
 end

lib/coffee_script/value.rb

@@ -5,7 +5,7 @@ module CoffeeScript
   class Value
     attr_reader :value, :line
 
-    def initialize(value, line=nil)
+    def initialize(value, line)
       @value, @line = value, line
     end
 

package.json

@@ -1,9 +1,9 @@
 {
     "name":         "coffee-script",
-    "lib":          "lib/coffee_script/narwhal/lib",
-    "preload":      ["coffee-script/loader"],
+    "lib":          "lib/coffee_script/narwhal/js",
+    "preload":      ["loader"],
     "description":  "Unfancy JavaScript",
     "keywords":     ["javascript", "language"],
     "author":       "Jeremy Ashkenas",
-    "version":      "0.2.2"
+    "version":      "0.1.5"
 }

test/fixtures/execution/test_arguments.coffee

@@ -1,24 +0,0 @@
-area: x, y, x1, y1 =>
-  (x - x1) * (x - y1)
-
-x:  y:  10
-x1: y1: 20
-
-print(area(x, y, x1, y1) is 100)
-
-print(area(x, y,
-           x1, y1) is 100)
-
-print(area(
-  x
-  y
-  x1
-  y1
-) is 100)
-
-
-# Arguments are turned into arrays.
-curried: =>
-  print(area.apply(this, arguments.concat(20, 20)) is 100)
-
-curried(10, 10)

test/fixtures/execution/test_array_comprehension.coffee

@@ -1,25 +1,4 @@
-nums:    n * n for n in [1, 2, 3] when n % 2 isnt 0
-results: n * 2 for n in nums
-
-print(results.join(',') is '2,18')
-
-
-obj:   {one: 1, two: 2, three: 3}
-names: key + '!' for key ino obj
-odds:  key + '!' for key, value ino obj when value % 2 isnt 0
-
-print(names.join(' ') is "one! two! three!")
-print(odds.join(' ')  is "one! three!")
-
-
-evens: for num in [1, 2, 3, 4, 5, 6] when num % 2 is 0
-           num *= -1
-           num -= 2
-           num * -1
-
-print(evens.join(', ') is '4, 6, 8')
-
-# Make sure that the "in" operator still works.
-
-print(2 in evens)
+nums: n * n for n in [1, 2, 3] if n % 2 isnt 0.
+result: n * 2 for n in nums.
 
+print(result.join(',') is '2,18')

test/fixtures/execution/test_assign_to_try_catch.coffee

@@ -1,8 +1,6 @@
 result: try
   nonexistent * missing
 catch error
-  true
-  
-result2: try nonexistent * missing catch error then true
-  
-print(result is true and result2 is true)
+  true.
+
+print(result)

test/fixtures/execution/test_blocks.coffee

@@ -1,4 +0,0 @@
-results: [1, 2, 3].map() x =>
-  x * x
-
-print(results.join(' ') is '1 4 9')

test/fixtures/execution/test_calling_super.coffee

@@ -1,38 +1,23 @@
-Base: =>
-Base::func: string =>
-  'zero/' + string
+Base: => .
+Base.prototype.func: string =>
+  'zero/' + string.
 
-FirstChild: =>
+FirstChild: => .
 FirstChild extends Base
-FirstChild::func: string =>
-  super('one/') + string
+FirstChild.prototype.func: string =>
+  super('one/') + string.
 
-SecondChild: =>
+SecondChild: => .
 SecondChild extends FirstChild
-SecondChild::func: string =>
-  super('two/') + string
+SecondChild.prototype.func: string =>
+  super('two/') + string.
 
-ThirdChild: =>
-  this.array: [1, 2, 3]
+ThirdChild: => .
 ThirdChild extends SecondChild
-ThirdChild::func: string =>
-  super('three/') + string
+ThirdChild.prototype.func: string =>
+  super('three/') + string.
 
 result: (new ThirdChild()).func('four')
 
 print(result is 'zero/one/two/three/four')
 
-
-TopClass: arg =>
-  this.prop: 'top-' + arg
-
-SuperClass: arg =>
-  super('super-' + arg)
-
-SubClass: =>
-  super('sub')
-
-SuperClass extends TopClass
-SubClass extends SuperClass
-
-print((new SubClass()).prop is 'top-super-sub')

test/fixtures/execution/test_chained_calls.coffee

@@ -1,24 +1,5 @@
-identity_wrap: x => => x
+identity_wrap: x => => x..
 
 result: identity_wrap(identity_wrap(true))()()
 
-print(result)
-
-
-str: 'god'
-
-result: str.
-  split('').
-  reverse().
-  reverse().
-  reverse()
-
-print(result.join('') is 'dog')
-
-result: str
-  .split('')
-  .reverse()
-  .reverse()
-  .reverse()
-
-print(result.join('') is 'dog')
+print(result)

test/fixtures/execution/test_everything.coffee

@@ -1,15 +1,12 @@
 func: =>
   a: 3
   b: []
-
   while a >= 0
     b.push('o')
-    a--
+    a--.
 
   c: {
     "text": b
-    other: null
-    something_else: x => x + 5
   }
 
   c: 'error' unless 42 > 41
@@ -17,13 +14,14 @@ func: =>
   c.text: if false
     'error'
   else
-    c.text + '---'
+    c.text + '---'.
+
   d = {
     text = c.text
   }
 
-  c.list: l for l in d.text.split('') when l is '-'
+  c.list: l for l in d.text.split('') if l is '-'.
 
-  c.single: c.list[1..1][0]
+  c.single: c.list[1..1][0].
 
 print(func() == '-')

test/fixtures/execution/test_existence.coffee

@@ -1,5 +0,0 @@
-print(if my_special_variable? then false else true)
-
-my_special_variable: false
-
-print(if my_special_variable? then true else false)

test/fixtures/execution/test_fancy_if_statement.coffee

@@ -3,8 +3,9 @@ c: false
 
 result: if a
   if b
-    if c then false else
+    if c then false
+    else
       if d
-        true
+        true....
 
 print(result)

test/fixtures/execution/test_funky_comments.coffee

@@ -1,17 +0,0 @@
-  # comment
-func: =>
-# comment
-  false
-  false   # comment
-  false
-# comment
-  true
-
-switch 'string'
-  # comment
-  when false then something()
-  # comment
-  when null
-    something_else()
-
-print(func())

test/fixtures/execution/test_literals.coffee

@@ -1,37 +0,0 @@
-a: [(x => x), (x => x * x)]
-
-print(a.length is 2)
-
-
-regex: /match/i
-words: "I think there is a match in here."
-
-print(!!words.match(regex))
-
-
-neg: (3 -4)
-
-print(neg is -1)
-
-
-func: =>
-  return if true
-
-print(func() is null)
-
-
-str: "\\"
-reg: /\\/
-
-print(reg(str) and str is '\\')
-
-
-i: 10
-while i -= 1
-
-print(i is 0)
-
-
-money$: 'dollars'
-
-print(money$ is 'dollars')

test/fixtures/execution/test_named_functions.coffee

@@ -1,8 +0,0 @@
-x: 1
-y: {}
-y.x: => 3
-
-print(x is 1)
-print(typeof(y.x) is 'function')
-print(y.x() is 3)
-print(y.x.name is 'x')

test/fixtures/execution/test_nested_comprehensions.coffee

@@ -1,11 +0,0 @@
-multi_liner:
-  for x in [3..5]
-    for y in [3..5]
-      [x, y]
-
-single_liner:
-  [x, y] for y in [3..5] for x in [3..5]
-
-print(multi_liner.length is single_liner.length)
-print(5 is multi_liner[2][2][1])
-print(5 is single_liner[2][2][1])

test/fixtures/execution/test_newline_escaping.coffee

@@ -1,6 +1,6 @@
-six:
-  1 +
-  2 +
-  3
+six: \
+  1 + \
+   2 + \
+    3
 
 print(six is 6)

test/fixtures/execution/test_range_comprehension.coffee

@@ -1,20 +1,8 @@
-nums: i * 3 for i in [1..3]
+nums: i * 3 for i in [1..3].
 
-negs: x for x in [-20..-5*2]
+negs: x for x in [-20..-10].
 negs: negs[0..2]
 
 result: nums.concat(negs).join(', ')
 
-print(result is '3, 6, 9, -20, -19, -18')
-
-# Ensure that ranges are safe. This used to infinite loop:
-j = 5
-result: for j in [j..(j+3)]
-  j
-
-print(result.join(' ') is '5 6 7 8')
-
-# With range comprehensions, you can loop in steps.
-results: x for x in [0..25] by 5
-
-print(results.join(' ') is '0 5 10 15 20 25')
+print(result is '3, 6, 9, -20, -19, -18')

test/fixtures/execution/test_ranges_and_slices.coffee

@@ -5,7 +5,4 @@ b: array[2...4]
 
 result: a.concat(b).join(' ')
 
-print(result is "7 8 9 2 3")
-
-countdown: [10..1].join(' ')
-print(countdown is "10 9 8 7 6 5 4 3 2 1")
+print(result is "7 8 9 2 3")

test/fixtures/execution/test_splats.coffee

@@ -1,35 +0,0 @@
-func: first, second, rest... =>
-  rest.join(' ')
-
-result: func(1, 2, 3, 4, 5)
-
-print(result is "3 4 5")
-
-
-gold: silver: bronze: the_field: null
-
-medalists: first, second, third, rest... =>
-  gold:       first
-  silver:     second
-  bronze:     third
-  the_field:  rest
-
-contenders: [
-  "Michael Phelps"
-  "Liu Xiang"
-  "Yao Ming"
-  "Allyson Felix"
-  "Shawn Johnson"
-  "Roman Sebrle"
-  "Guo Jingjing"
-  "Tyson Gay"
-  "Asafa Powell"
-  "Usain Bolt"
-]
-
-medalists("Mighty Mouse", contenders...)
-
-print(gold is "Mighty Mouse")
-print(silver is "Michael Phelps")
-print(bronze is "Liu Xiang")
-print(the_field.length is 8)

test/fixtures/execution/test_splices.coffee

@@ -1,5 +0,0 @@
-array: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-
-array[5..10]: [0, 0, 0]
-
-print(array.join(' ') is '0 1 2 3 4 0 0 0')

test/fixtures/execution/test_switch.coffee

@@ -1,17 +1,11 @@
 num: 10
 
 result: switch num
-  when 5 then false
-  when 'a'
-    true
-    true
-    false
-  when 10 then true
-
-
-  # Mid-switch comment with whitespace
-  # and multi line
-  when 11 then false
-  else false
+when 5 then false
+when 'a'
+  false
+when 10 then true
+when 11 then false
+else false.
 
 print(result)

test/fixtures/generation/each.coffee

@@ -6,9 +6,9 @@ _.each: obj, iterator, context =>
     if obj.forEach
       obj.forEach(iterator, context)
     else if _.isArray(obj) or _.isArguments(obj)
-      iterator.call(context, item, i, obj) for item, i in obj
+      iterator.call(context, item, i, obj) for item, i in obj.
     else
-      iterator.call(context, obj[key], key, obj) for key in _.keys(obj)
+      iterator.call(context, obj[key], key, obj) for key in _.keys(obj)..
   catch e
-    throw e if e isnt breaker
-  obj
+    throw e if e isnt breaker.
+  obj.

test/fixtures/generation/each.js

@@ -0,0 +1,36 @@
+(function(){
+
+  // The cornerstone, an each implementation.
+  // Handles objects implementing forEach, arrays, and raw objects.
+  _.each = function(obj, iterator, context) {
+    var __a, __b, __c, __d, __e, __f, __g, __h, i, index, item, key;
+    index = 0;
+    try {
+      if (obj.forEach) {
+        obj.forEach(iterator, context);
+      } else if (_.isArray(obj) || _.isArguments(obj)) {
+        __a = obj;
+        __d = [];
+        for (__b=0, __c=__a.length; __b<__c; __b++) {
+          item = __a[__b];
+          i = __b;
+          __d[__b] = iterator.call(context, item, i, obj);
+        }
+        __d;
+      } else {
+        __e = _.keys(obj);
+        __h = [];
+        for (__f=0, __g=__e.length; __f<__g; __f++) {
+          key = __e[__f];
+          __h[__f] = iterator.call(context, obj[key], key, obj);
+        }
+        __h;
+      }
+    } catch (e) {
+      if (e !== breaker) {
+        throw e;
+      }
+    }
+    return obj;
+  };
+})();

test/fixtures/generation/each.tokens

@@ -1 +1 @@
-[[:COMMENT, [" The cornerstone, an each implementation.", " Handles objects implementing forEach, arrays, and raw objects."]], ["\n", "\n"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "each"], [:ASSIGN, ":"], [:PARAM, "obj"], [",", ","], [:PARAM, "iterator"], [",", ","], [:PARAM, "context"], ["=>", "=>"], [:INDENT, 2], [:IDENTIFIER, "index"], [:ASSIGN, ":"], [:NUMBER, "0"], ["\n", "\n"], [:TRY, "try"], [:INDENT, 2], [:IF, "if"], [:IDENTIFIER, "obj"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "forEach"], [:INDENT, 2], [:IDENTIFIER, "obj"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "forEach"], ["(", "("], [:IDENTIFIER, "iterator"], [",", ","], [:IDENTIFIER, "context"], [")", ")"], [:OUTDENT, 2], [:ELSE, "else"], [:IF, "if"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "isArray"], ["(", "("], [:IDENTIFIER, "obj"], [")", ")"], [:OR, "or"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "isArguments"], ["(", "("], [:IDENTIFIER, "obj"], [")", ")"], [:INDENT, 2], [:IDENTIFIER, "iterator"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "call"], ["(", "("], [:IDENTIFIER, "context"], [",", ","], [:IDENTIFIER, "item"], [",", ","], [:IDENTIFIER, "i"], [",", ","], [:IDENTIFIER, "obj"], [")", ")"], [:FOR, "for"], [:IDENTIFIER, "item"], [",", ","], [:IDENTIFIER, "i"], [:IN, "in"], [:IDENTIFIER, "obj"], [:OUTDENT, 2], [:ELSE, "else"], [:INDENT, 2], [:IDENTIFIER, "iterator"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "call"], ["(", "("], [:IDENTIFIER, "context"], [",", ","], [:IDENTIFIER, "obj"], ["[", "["], [:IDENTIFIER, "key"], ["]", "]"], [",", ","], [:IDENTIFIER, "key"], [",", ","], [:IDENTIFIER, "obj"], [")", ")"], [:FOR, "for"], [:IDENTIFIER, "key"], [:IN, "in"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "keys"], ["(", "("], [:IDENTIFIER, "obj"], [")", ")"], [:OUTDENT, 2], [:OUTDENT, 2], [:CATCH, "catch"], [:IDENTIFIER, "e"], [:INDENT, 2], [:THROW, "throw"], [:IDENTIFIER, "e"], [:IF, "if"], [:IDENTIFIER, "e"], [:ISNT, "isnt"], [:IDENTIFIER, "breaker"], [:OUTDENT, 2], ["\n", "\n"], [:IDENTIFIER, "obj"], [:OUTDENT, 2], ["\n", "\n"]]
+[[:COMMENT, [" The cornerstone, an each implementation.", " Handles objects implementing forEach, arrays, and raw objects."]], ["\n", "\n"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "each"], [:ASSIGN, ":"], [:PARAM, "obj"], [",", ","], [:PARAM, "iterator"], [",", ","], [:PARAM, "context"], ["=>", "=>"], ["\n", "\n"], [:IDENTIFIER, "index"], [:ASSIGN, ":"], [:NUMBER, "0"], ["\n", "\n"], [:TRY, "try"], ["\n", "\n"], [:IF, "if"], [:IDENTIFIER, "obj"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "forEach"], ["\n", "\n"], [:IDENTIFIER, "obj"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "forEach"], ["(", "("], [:IDENTIFIER, "iterator"], [",", ","], [:IDENTIFIER, "context"], [")", ")"], ["\n", "\n"], [:ELSE, "else"], [:IF, "if"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "isArray"], ["(", "("], [:IDENTIFIER, "obj"], [")", ")"], [:OR, "or"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "isArguments"], ["(", "("], [:IDENTIFIER, "obj"], [")", ")"], ["\n", "\n"], [:IDENTIFIER, "iterator"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "call"], ["(", "("], [:IDENTIFIER, "context"], [",", ","], [:IDENTIFIER, "item"], [",", ","], [:IDENTIFIER, "i"], [",", ","], [:IDENTIFIER, "obj"], [")", ")"], [:FOR, "for"], [:IDENTIFIER, "item"], [",", ","], [:IDENTIFIER, "i"], [:IN, "in"], [:IDENTIFIER, "obj"], [".", "."], ["\n", "\n"], [:ELSE, "else"], ["\n", "\n"], [:IDENTIFIER, "iterator"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "call"], ["(", "("], [:IDENTIFIER, "context"], [",", ","], [:IDENTIFIER, "obj"], ["[", "["], [:IDENTIFIER, "key"], ["]", "]"], [",", ","], [:IDENTIFIER, "key"], [",", ","], [:IDENTIFIER, "obj"], [")", ")"], [:FOR, "for"], [:IDENTIFIER, "key"], [:IN, "in"], [:IDENTIFIER, "_"], [:PROPERTY_ACCESS, "."], [:IDENTIFIER, "keys"], ["(", "("], [:IDENTIFIER, "obj"], [")", ")"], [".", "."], [".", "."], ["\n", "\n"], [:CATCH, "catch"], [:IDENTIFIER, "e"], ["\n", "\n"], [:THROW, "throw"], [:IDENTIFIER, "e"], [:IF, "if"], [:IDENTIFIER, "e"], [:ISNT, "isnt"], [:IDENTIFIER, "breaker"], [".", "."], ["\n", "\n"], [:IDENTIFIER, "obj"], [".", "."]]

test/fixtures/generation/each_no_wrap.js

@@ -0,0 +1,34 @@
+
+// The cornerstone, an each implementation.
+// Handles objects implementing forEach, arrays, and raw objects.
+_.each = function(obj, iterator, context) {
+  var __a, __b, __c, __d, __e, __f, __g, __h, i, index, item, key;
+  index = 0;
+  try {
+    if (obj.forEach) {
+      obj.forEach(iterator, context);
+    } else if (_.isArray(obj) || _.isArguments(obj)) {
+      __a = obj;
+      __d = [];
+      for (__b=0, __c=__a.length; __b<__c; __b++) {
+        item = __a[__b];
+        i = __b;
+        __d[__b] = iterator.call(context, item, i, obj);
+      }
+      __d;
+    } else {
+      __e = _.keys(obj);
+      __h = [];
+      for (__f=0, __g=__e.length; __f<__g; __f++) {
+        key = __e[__f];
+        __h[__f] = iterator.call(context, obj[key], key, obj);
+      }
+      __h;
+    }
+  } catch (e) {
+    if (e !== breaker) {
+      throw e;
+    }
+  }
+  return obj;
+};

test/fixtures/generation/statements_as_expressions.coffee

@@ -1,16 +0,0 @@
-# Everything should be able to be an expression.
-
-result: while sunny?
-  go_outside()
-
-print(3 + try
-  nonexistent.no_way
-catch error
-  print(error)
-  3
-)
-
-func: x =>
-  return throw x
-
-print(x * x for x in [1..100])

test/fixtures/generation/whitespace.coffee

@@ -1,20 +0,0 @@
-# test
-f1: x =>
-  x * x
-  f2: y =>
-    y * x
-  f3: 3
-
-# Parens can close on the proper level.
-elements.each(el =>
-  el.click(event =>
-    el.reset()
-    el.show() if event.active
-  )
-)
-
-# Or, parens can close blocks early.
-elements.each(el =>
-  el.click(event =>
-    el.reset()
-    el.show() if event.active))

test/unit/test_execution.rb

@@ -2,35 +2,27 @@ require 'test_helper'
 
 class ExecutionTest < Test::Unit::TestCase
 
-  NO_WARNINGS = "0 error(s), 0 warning(s)"
+  NO_WARNINGS = /\A(0 error\(s\), 0 warning\(s\)\n)+\Z/
+  ALLS_WELL   = /\A\n?(true\n)+\Z/m
 
-  # This is by far the most important test. It evaluates all of the
-  # CoffeeScript in test/fixtures/execution, ensuring that all our
-  # syntax actually works.
   def test_execution_of_coffeescript
     sources = ['test/fixtures/execution/*.coffee'].join(' ')
-    (`bin/coffee -r #{sources}`).split("\n").each do |line|
-      assert line == "true"
-    end
+    assert `bin/coffee -r #{sources}`.match(ALLS_WELL)
   end
 
-  def test_lintless_tests
-    no_warnings `bin/coffee -l test/fixtures/*/*.coffee`
+  def test_lintless_coffeescript
+    lint_results = `bin/coffee -l test/fixtures/execution/*.coffee`
+    assert lint_results.match(NO_WARNINGS)
   end
 
   def test_lintless_examples
-    no_warnings `bin/coffee -l examples/*.coffee`
+    lint_results = `bin/coffee -l examples/*.coffee`
+    assert lint_results.match(NO_WARNINGS)
   end
 
   def test_lintless_documentation
-    no_warnings `bin/coffee -l documentation/coffee/*.coffee`
-  end
-
-
-  private
-
-  def no_warnings(output)
-    output.split("\n").each {|line| assert line == NO_WARNINGS }
+    lint_results = `bin/coffee -l documentation/coffee/*.coffee`
+    assert lint_results.match(NO_WARNINGS)
   end
 
 end

test/unit/test_lexer.rb

@@ -7,47 +7,45 @@ class LexerTest < Test::Unit::TestCase
   end
 
   def test_lexing_an_empty_string
-    assert @lex.tokenize("") == [["\n", "\n"]]
+    assert @lex.tokenize("") == []
   end
 
   def test_lexing_basic_assignment
-    code = "a: 'one'\nb: [1, 2]"
-    assert @lex.tokenize(code) == [[:IDENTIFIER, "a"], [:ASSIGN, ":"], 
-      [:STRING, "'one'"], ["\n", "\n"], [:IDENTIFIER, "b"], [:ASSIGN, ":"], 
-      ["[", "["], [:NUMBER, "1"], [",", ","], [:NUMBER, "2"], ["]", "]"], 
-      ["\n", "\n"]]
+    code = "a: 'one'; b: [1, 2]"
+    assert @lex.tokenize(code) == [[:IDENTIFIER, "a"], [:ASSIGN, ":"],
+      [:STRING, "'one'"], [";", ";"], [:IDENTIFIER, "b"], [:ASSIGN, ":"],
+      ["[", "["], [:NUMBER, "1"], [",", ","], [:NUMBER, "2"], ["]", "]"]]
   end
 
   def test_lexing_object_literal
     code = "{one : 1}"
     assert @lex.tokenize(code) == [["{", "{"], [:IDENTIFIER, "one"], [:ASSIGN, ":"],
-      [:NUMBER, "1"], ["}", "}"], ["\n", "\n"]]
+      [:NUMBER, "1"], ["}", "}"]]
   end
 
   def test_lexing_function_definition
-    code = "x, y => x * y"
+    code = "x, y => x * y."
     assert @lex.tokenize(code) == [[:PARAM, "x"], [",", ","], [:PARAM, "y"],
-      ["=>", "=>"], [:INDENT, 2], [:IDENTIFIER, "x"], ["*", "*"], 
-      [:IDENTIFIER, "y"], [:OUTDENT, 2], ["\n", "\n"]]
+      ["=>", "=>"], [:IDENTIFIER, "x"], ["*", "*"], [:IDENTIFIER, "y"], [".", "."]]
   end
 
   def test_lexing_if_statement
     code = "clap_your_hands() if happy"
     assert @lex.tokenize(code) == [[:IDENTIFIER, "clap_your_hands"], ["(", "("],
-      [")", ")"], [:IF, "if"], [:IDENTIFIER, "happy"], ["\n", "\n"]]
+      [")", ")"], [:IF, "if"], [:IDENTIFIER, "happy"]]
   end
 
   def test_lexing_comment
-    code = "a: 1\n# comment\n# on two lines\nb: 2"
+    code = "a: 1\n # comment\n # on two lines\nb: 2"
     assert @lex.tokenize(code) == [[:IDENTIFIER, "a"], [:ASSIGN, ":"], [:NUMBER, "1"],
       ["\n", "\n"], [:COMMENT, [" comment", " on two lines"]], ["\n", "\n"],
-      [:IDENTIFIER, "b"], [:ASSIGN, ":"], [:NUMBER, "2"], ["\n", "\n"]]
+      [:IDENTIFIER, "b"], [:ASSIGN, ":"], [:NUMBER, "2"]]
   end
 
   def test_lexing_newline_escaper
     code = "two: 1 + \\\n\n 1"
     assert @lex.tokenize(code) == [[:IDENTIFIER, "two"], [:ASSIGN, ":"],
-      [:NUMBER, "1"], ["+", "+"], [:NUMBER, "1"], ["\n", "\n"]]
+      [:NUMBER, "1"], ["+", "+"], [:NUMBER, "1"]]
   end
 
   def test_lexing

test/unit/test_parser.rb

@@ -8,7 +8,7 @@ class ParserTest < Test::Unit::TestCase
 
   def test_parsing_an_empty_string
     nodes = @par.parse("")
-    assert nodes.is_a?(Expressions)
+    assert nodes.is_a? Expressions
     assert nodes.expressions.empty?
   end
 
@@ -16,45 +16,45 @@ class ParserTest < Test::Unit::TestCase
     nodes = @par.parse("a: 'one'").expressions
     assert nodes.length == 1
     assign = nodes.first
-    assert assign.is_a?(AssignNode)
+    assert assign.is_a? AssignNode
     assert assign.variable.literal == 'a'
   end
 
   def test_parsing_an_object_literal
-    nodes = @par.parse("{one : 1\ntwo : 2}").expressions
+    nodes = @par.parse("{one : 1 \n two : 2}").expressions
     obj = nodes.first.literal
-    assert obj.is_a?(ObjectNode)
+    assert obj.is_a? ObjectNode
     assert obj.properties.first.variable.literal.value == "one"
     assert obj.properties.last.variable.literal.value == "two"
   end
 
   def test_parsing_an_function_definition
-    code = @par.parse("x, y => x * y").expressions.first
+    code = @par.parse("x, y => x * y.").expressions.first
     assert code.params == ['x', 'y']
     body = code.body.expressions.first
-    assert body.is_a?(OpNode)
+    assert body.is_a? OpNode
     assert body.operator == '*'
   end
 
   def test_parsing_if_statement
     the_if = @par.parse("clap_your_hands() if happy").expressions.first
-    assert the_if.is_a?(IfNode)
+    assert the_if.is_a? IfNode
     assert the_if.condition.literal == 'happy'
-    assert the_if.body.is_a?(CallNode)
+    assert the_if.body.is_a? CallNode
     assert the_if.body.variable.literal == 'clap_your_hands'
   end
 
   def test_parsing_array_comprehension
-    nodes = @par.parse("i for x, i in [10, 9, 8, 7, 6, 5] when i % 2 is 0").expressions
-    assert nodes.first.is_a?(ForNode)
+    nodes = @par.parse("i for x, i in [10, 9, 8, 7, 6, 5] if i % 2 is 0.").expressions
+    assert nodes.first.is_a? ForNode
     assert nodes.first.body.literal == 'i'
     assert nodes.first.filter.operator == '==='
     assert nodes.first.source.literal.objects.last.literal.value == "5"
   end
 
   def test_parsing_comment
-    nodes = @par.parse("a: 1\n# comment\nb: 2").expressions
-    assert nodes[1].is_a?(CommentNode)
+    nodes = @par.parse("a: 1\n # comment\nb: 2").expressions
+    assert nodes[1].is_a? CommentNode
   end
 
   def test_parsing_inner_comments
@@ -65,10 +65,22 @@ class ParserTest < Test::Unit::TestCase
   def test_parsing
     nodes = @par.parse(File.read('test/fixtures/generation/each.coffee'))
     assign = nodes.expressions[1]
-    assert assign.is_a?(AssignNode)
+    assert assign.is_a? AssignNode
     assert assign.variable.literal == '_'
-    assert assign.value.is_a?(CodeNode)
+    assert assign.value.is_a? CodeNode
     assert assign.value.params == ['obj', 'iterator', 'context']
+    assert nodes.compile == File.read('test/fixtures/generation/each.js')
+  end
+
+  def test_no_wrap
+    nodes = @par.parse(File.read('test/fixtures/generation/each.coffee'))
+    assert nodes.compile(:no_wrap => true) == File.read('test/fixtures/generation/each_no_wrap.js')
+  end
+
+  def test_no_wrapping_parens_around_statements
+    assert_raises(SyntaxError) do
+      @par.parse("(try thing() catch error fail().)").compile
+    end
   end
 
 end