CoffeeScript 0.2.3, with 'of', not 'ino'

added a whole slew of nice Potion examples from the pamphlet -- CoffeeScript stacks up pretty well.
more refactors to nodes
2026-01-13 08:47:55 -05:00 · 2010-01-11 00:01:16 -05:00 · 2010-01-10 23:27:57 -05:00 · 2010-01-10 22:35:55 -05:00 · 2010-01-10 22:04:38 -05:00 · 2010-01-10 20:25:09 -05:00
19 changed files with 356 additions and 129 deletions
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2009 Jeremy Ashkenas
+Copyright (c) 2010 Jeremy Ashkenas

 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
--- a/coffee-script.gemspec
+++ b/coffee-script.gemspec
@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
  s.name      = 'coffee-script'
-  s.version   = '0.2.2'         # Keep version in sync with coffee-script.rb
+  s.version   = '0.2.3'         # Keep version in sync with coffee-script.rb
  s.date      = '2010-1-10'

  s.homepage    = "http://jashkenas.github.com/coffee-script/"
--- a/documentation/coffee/expressions_comprehension.coffee
+++ b/documentation/coffee/expressions_comprehension.coffee
@@ -1,3 +1,3 @@
 # The first ten global properties.

-globals: (name for name ino window)[0...10]
+globals: (name for name of window)[0...10]
--- a/documentation/coffee/object_comprehensions.coffee
+++ b/documentation/coffee/object_comprehensions.coffee
@@ -1,3 +1,4 @@
 years_old: {max: 10, ida: 9, tim: 11}

-ages: child + " is " + age for child, age ino years_old
+ages: for child, age of years_old
+  child + " is " + age
--- a/documentation/index.html.erb
+++ b/documentation/index.html.erb
@@ -51,7 +51,7 @@

    <p>
      <b>Latest Version:</b>
-      <a href="http://gemcutter.org/gems/coffee-script">0.2.2</a>
+      <a href="http://gemcutter.org/gems/coffee-script">0.2.3</a>
    </p>

    <h2>Table of Contents</h2>
@@ -415,8 +415,8 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
    <%= 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.
+      an object. Use <tt>of</tt> to signal comprehension over the properties of 
+      an object instead of the values in an array.
    </p>
    <%= code_for('object_comprehensions', 'ages.join(", ")') %>

@@ -588,6 +588,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.3</b>
+      Axed the unsatisfactory <tt>ino</tt> keyword, replacing it with <tt>of</tt> for
+      object comprehensions. They now look like: <tt>for key, value of object</tt>.
+    </p>

    <p>
      <b class="header" style="margin-top: 20px;">0.2.2</b>
--- a/documentation/underscore.html
+++ b/documentation/underscore.html
@@ -41,7 +41,7 @@
 <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">  25 </span>     <span class="FunctionName">this._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>
@@ -54,7 +54,7 @@
 <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">  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> <span class="FunctionName">exports._</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>
@@ -66,7 +66,7 @@
 <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">  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>
@@ -79,7 +79,7 @@
 <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">  63 </span>       iterator.call(context, val, key, obj) <span class="Keyword">for</span> key, val <span class="Keyword">of</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
@@ -167,7 +167,7 @@
 <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"> 151 </span>     <span class="Keyword">for</span> key, val <span class="Keyword">of</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>
@@ -399,7 +399,7 @@
 <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"> 383 </span>     key <span class="Keyword">for</span> key, val <span class="Keyword">of</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>
@@ -414,7 +414,7 @@
 <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"> 398 </span>     <span class="Keyword">for</span> key, val <span class="Keyword">of</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>
@@ -522,7 +522,7 @@
 <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"> 506 </span>     <span class="FunctionName">root._</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>
@@ -561,15 +561,15 @@
 <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"> 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>
@@ -605,7 +605,7 @@
 <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"> 589 </span>     <span class="FunctionName">this._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>
--- a/examples/potion.coffee
+++ b/examples/potion.coffee
@@ -0,0 +1,205 @@
+# Examples from _why's Potion, the Readme and "Potion: A Short Pamphlet".
+
+# 5 times: "Odelay!" print.
+
+print("Odelay!") for i in [1..5]
+
+
+# add = (x, y): x + y.
+# add(2, 4) string print
+
+add: x, y => x + y
+print(add(2, 4))
+
+
+# loop: 'quaff' print.
+
+while true
+  print('quaff')
+
+
+# ('cheese', 'bread', 'mayo') at (1) print
+
+print(['cheese', 'bread', 'mayo'][1])
+
+
+# (language='Potion', pointless=true) at (key='language') print
+
+print({language: 'Potion', pointless: true}['language'])
+
+
+# minus = (x, y): x - y.
+# minus (y=10, x=6)
+
+minus: x, y => x - y
+minus(6, 10)
+
+
+# foods = ('cheese', 'bread', 'mayo')
+# foods (2)
+
+foods: ['cheese', 'bread', 'mayo']
+foods[2]
+
+
+# (dog='canine', cat='feline', fox='vulpine') each (key, val):
+#   (key, ' is a ', val) join print.
+
+for key, val of {dog: 'canine', cat: 'feline', fox: 'vulpine'}
+  print(key + ' is a ' + val)
+
+
+# Person = class: /name, /age, /sex.
+# Person print = ():
+#   ('My name is ', /name, '.') join print.
+
+Person: =>
+Person::print: =>
+  print('My name is ' + this.name + '.')
+
+
+# p = Person ()
+# p /name string print
+
+p: new Person()
+print(p.name)
+
+
+# Policeman = Person class (rank): /rank = rank.
+# Policeman print = ():
+#   ('My name is ', /name, ' and I'm a ', /rank, '.') join print.
+#
+# Policeman ('Constable') print
+
+Policeman: rank => this.rank: rank
+Policeman extends Person
+Policeman::print: =>
+  print('My name is ' + this.name + " and I'm a " + this.rank + '.')
+
+print(new Policeman('Constable'))
+
+
+# app = [window (width=200, height=400)
+#         [para 'Welcome.', button 'OK']]
+# app first name
+
+app = {
+  window:  {width: 200, height: 200}
+  para:    'Welcome.'
+  button:  'OK'
+}
+app.window
+
+
+# x = 1
+# y = 2
+#
+# x = 1, y = 2
+
+x: 1
+y: 2
+
+x: 1; y: 2
+
+
+# table = (language='Potion'
+#           pointless=true)
+
+table: {
+  language: 'Potion'
+  pointless: yes
+}
+
+
+# # this foul business...
+# String length = (): 10.
+
+# this foul business...
+String::length: => 10
+
+
+# block = :
+#   'potion' print.
+
+block: =>
+  print('potion')
+
+
+# if (age > 100): 'ancient'.
+
+if age > 100 then 'ancient'
+
+
+# author =
+#   if (title == 'Jonathan Strange & Mr. Norrell'):
+#     'Susanna Clarke'.
+#   elsif (title == 'The Star Diaries'):
+#     'Stanislaw Lem'.
+#   elsif (title == 'The Slynx'):
+#     'Tatyana Tolstaya'.
+#   else:
+#     '... probably Philip K. Dick'.
+
+switch author
+  when 'Jonathan Strange & Mr. Norrell'
+    'Susanna Clarke'
+  when 'The Star Diaries'
+    'Stanislaw Lem'
+  when 'The Slynx'
+    'Tatyana Tolstaya'
+  else
+    '... probably Philip K. Dick'
+
+
+# count = 8
+# while (count > 0):
+#   'quaff' print
+#   count--.
+
+count: 8
+while count > 0
+  print('quaff')
+  count--
+
+
+# 1 to 5 (a):
+#   a string print.
+
+print(a) for a in [1..5]
+
+
+# if (3 ?gender):
+#   "Huh? Numbers are sexed? That's amazing." print.
+
+if (3).gender?
+  print("Huh? Numbers are sexed? That's amazing.")
+
+
+# HomePage get = (url):
+#   session = url query ? at ('session').
+
+HomePage::get: url =>
+  session: url.query.session if url.query?
+
+
+# BTree = class: /left, /right.
+# b = BTree ()
+# b /left = BTree ()
+# b /right = BTree ()
+
+BTree:    =>
+b:        new BTree()
+b.left:   new BTree()
+b.right:  new BTree()
+
+
+# BTree = class: /left, /right.
+# b = BTree ()
+#
+# if (b ? /left):
+#   'left path found!' print.
+
+BTree: =>
+b: new BTree()
+
+print('left path found!') if b.left?
--- a/examples/underscore.coffee
+++ b/examples/underscore.coffee
@@ -60,7 +60,7 @@
      return obj.forEach(iterator, context) if obj.forEach
      if _.isArray(obj) or _.isArguments(obj)
        return iterator.call(context, obj[i], i, obj) for i in [0...obj.length]
-      iterator.call(context, val, key, obj) for key, val ino obj
+      iterator.call(context, val, key, obj) for key, val of obj
    catch e
      throw e if e isnt breaker
    obj
@@ -148,7 +148,7 @@
  # based on '==='.
  _.include: obj, target =>
    return _.indexOf(obj, target) isnt -1 if _.isArray(obj)
-    for key, val ino obj
+    for key, val of obj
      return true if val is target
    false

@@ -380,7 +380,7 @@
  # Retrieve the names of an object's properties.
  _.keys: obj =>
    return _.range(0, obj.length) if _.isArray(obj)
-    key for key, val ino obj
+    key for key, val of obj


  # Retrieve the values of an object's properties.
@@ -395,7 +395,7 @@

  # Extend a given object with all of the properties in a source object.
  _.extend: destination, source =>
-    for key, val ino source
+    for key, val of source
      destination[key]: val
    destination

--- a/index.html
+++ b/index.html
@@ -37,7 +37,7 @@

    <p>
      <b>Latest Version:</b>
-      <a href="http://gemcutter.org/gems/coffee-script">0.2.2</a>
+      <a href="http://gemcutter.org/gems/coffee-script">0.2.3</a>
    </p>

    <h2>Table of Contents</h2>
@@ -782,12 +782,13 @@ egg_delivery = function egg_delivery() {
 ;alert(countdown);'>run: countdown</button><br class='clear' /></div>
    <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.
+      an object. Use <tt>of</tt> to signal comprehension over the properties of 
+      an object instead of the values in an array.
    </p>
    <div class='code'><pre class="idle"><span class="FunctionName">years_old</span><span class="Keyword">:</span> {<span class="FunctionName">max</span><span class="Keyword">:</span> <span class="Number">10</span>, <span class="FunctionName">ida</span><span class="Keyword">:</span> <span class="Number">9</span>, <span class="FunctionName">tim</span><span class="Keyword">:</span> <span class="Number">11</span>}

-<span class="FunctionName">ages</span><span class="Keyword">:</span> child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age <span class="Keyword">for</span> child, age <span class="Keyword">ino</span> years_old
+<span class="FunctionName">ages</span><span class="Keyword">:</span> <span class="Keyword">for</span> child, age <span class="Keyword">of</span> years_old
+  child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age
 </pre><pre class="idle"><span class="Storage">var</span> __a, __b, age, ages, child, years_old;
 years_old <span class="Keyword">=</span> {
  max: <span class="Number">10</span>,
@@ -927,7 +928,7 @@ six = (one = 1) + (two = 2) + (three = 3);
    </p>
    <div class='code'><pre class="idle"><span class="Comment"><span class="Comment">#</span> The first ten global properties.</span>

-<span class="FunctionName">globals</span><span class="Keyword">:</span> (name <span class="Keyword">for</span> name <span class="Keyword">ino</span> window)[<span class="Number">0</span>...<span class="Number">10</span>]
+<span class="FunctionName">globals</span><span class="Keyword">:</span> (name <span class="Keyword">for</span> name <span class="Keyword">of</span> window)[<span class="Number">0</span>...<span class="Number">10</span>]
 </pre><pre class="idle"><span class="Storage">var</span> __a, __b, globals, name;
 <span class="Comment"><span class="Comment">//</span> The first ten global properties.</span>
 globals <span class="Keyword">=</span> ((<span class="Storage">function</span>() {
@@ -1001,13 +1002,13 @@ globals = ((function() {
 <span class="FunctionName">Animal::move</span><span class="Keyword">:</span> <span class="FunctionArgument">meters</span> <span class="Storage">=&gt;</span>
  alert(<span class="Variable">this</span>.name <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> moved <span class="String">&quot;</span></span> <span class="Keyword">+</span> meters <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>m.<span class="String">&quot;</span></span>)

-<span class="FunctionName">Snake</span><span class="Keyword">:</span> <span class="FunctionArgument">name</span> <span class="Storage">=&gt;</span> <span class="Variable">this</span>.<span class="FunctionName">name</span><span class="Keyword">:</span> name
+<span class="FunctionName">Snake</span><span class="Keyword">:</span> <span class="FunctionArgument">name</span> <span class="Storage">=&gt;</span> <span class="FunctionName">this.name</span><span class="Keyword">:</span> name
 Snake <span class="Variable">extends</span> Animal
 <span class="FunctionName">Snake::move</span><span class="Keyword">:</span> <span class="Storage">=&gt;</span>
  alert(<span class="String"><span class="String">&quot;</span>Slithering...<span class="String">&quot;</span></span>)
  <span class="Variable">super</span>(<span class="Number">5</span>)

-<span class="FunctionName">Horse</span><span class="Keyword">:</span> <span class="FunctionArgument">name</span> <span class="Storage">=&gt;</span> <span class="Variable">this</span>.<span class="FunctionName">name</span><span class="Keyword">:</span> name
+<span class="FunctionName">Horse</span><span class="Keyword">:</span> <span class="FunctionArgument">name</span> <span class="Storage">=&gt;</span> <span class="FunctionName">this.name</span><span class="Keyword">:</span> name
 Horse <span class="Variable">extends</span> Animal
 <span class="FunctionName">Horse::move</span><span class="Keyword">:</span> <span class="Storage">=&gt;</span>
  alert(<span class="String"><span class="String">&quot;</span>Galloping...<span class="String">&quot;</span></span>)
@@ -1280,6 +1281,12 @@ world...";
    </ul>

    <h2 id="change_log">Change Log</h2>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">0.2.3</b>
+      Axed the unsatisfactory <tt>ino</tt> keyword, replacing it with <tt>of</tt> for
+      object comprehensions. They now look like: <tt>for key, value of object</tt>.
+    </p>

    <p>
      <b class="header" style="margin-top: 20px;">0.2.2</b>
--- a/lib/coffee-script.rb
+++ b/lib/coffee-script.rb
@@ -10,7 +10,7 @@ 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.2.3'   # Keep in sync with the gemspec.

  # Compile a script (String or IO) to JavaScript.
  def self.compile(script, options={})
--- a/lib/coffee_script/CoffeeScript.tmbundle/Syntaxes/CoffeeScript.tmLanguage
+++ b/lib/coffee_script/CoffeeScript.tmbundle/Syntaxes/CoffeeScript.tmLanguage
@@ -208,13 +208,13 @@
 		</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|by|catch|continue|else|finally|for|in|of|if|return|switch|then|throw|try|unless|when|while)\b</string>
 			<key>name</key>
 			<string>keyword.control.coffee</string>
 		</dict>
 		<dict>
 			<key>match</key>
-			<string>\b([a-zA-Z$_](\w|\$|:)*)(\:)\s</string>
+			<string>\b([a-zA-Z$_](\w|\$|:|\.)*)(\:)\s</string>
 			<key>name</key>
 			<string>variable.assignment.coffee</string>
 			<key>captures</key>
@@ -263,7 +263,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(instanceof|new|delete|typeof|and|or|is|isnt|not)\b</string>
 			<key>name</key>
 			<string>keyword.operator.coffee</string>
 		</dict>
--- a/lib/coffee_script/grammar.y
+++ b/lib/coffee_script/grammar.y
@@ -8,7 +8,7 @@ token IDENTIFIER PROPERTY_ACCESS PROTOTYPE_ACCESS
 token CODE PARAM NEW RETURN
 token TRY CATCH FINALLY THROW
 token BREAK CONTINUE
-token FOR IN INO BY WHEN WHILE
+token FOR IN OF BY WHEN WHILE
 token SWITCH LEADING_WHEN
 token DELETE INSTANCEOF TYPEOF
 token SUPER EXTENDS
@@ -34,7 +34,7 @@ prechigh
  left     '.'
  right    INDENT
  left     OUTDENT
-  right    WHEN LEADING_WHEN IN INO BY
+  right    WHEN LEADING_WHEN IN OF BY
  right    THROW FOR NEW SUPER
  left     EXTENDS
  left     ASSIGN '||=' '&&='
@@ -361,7 +361,7 @@ 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} }
+  | OF Expression                     { result = {:source => val[1], :object => true} }
  | ForSource
    WHEN Expression                   { result = val[0].merge(:filter => val[2]) }
  | ForSource
--- a/lib/coffee_script/lexer.rb
+++ b/lib/coffee_script/lexer.rb
@@ -12,7 +12,7 @@ module CoffeeScript
                  "new", "return",
                  "try", "catch", "finally", "throw",
                  "break", "continue",
-                  "for", "in", "ino", "by", "where", "while",
+                  "for", "in", "of", "by", "where", "while",
                  "switch", "when",
                  "super", "extends",
                  "arguments",
--- a/lib/coffee_script/narwhal/lib/coffee-script.js
+++ b/lib/coffee_script/narwhal/lib/coffee-script.js
@@ -20,17 +20,13 @@
  // Run a simple REPL, round-tripping to the CoffeeScript compiler for every
  // command.
  exports.run = function run(args) {
-    var __a, __b, i, result;
+    var __a, i, path, result;
    if (args.length) {
      __a = args;
-      __b = function(path, i) {
+      for (i=0; i<__a.length; i++) {
+        path = __a[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;
    }
--- a/lib/coffee_script/nodes.rb
+++ b/lib/coffee_script/nodes.rb
@@ -1,6 +1,12 @@
 module CoffeeScript

  # The abstract base class for all CoffeeScript nodes.
+  # All nodes are implement a "compile_node" method, which performs the
+  # code generation for that node. To compile a node, call the "compile"
+  # method, which wraps "compile_node" in some extra smarts, to know when the
+  # generated code should be wrapped up in a closure. An options hash is passed
+  # and cloned throughout, containing messages from higher in the AST,
+  # information about the current scope, and indentation level.
  class Node
    # Tabs are two spaces for pretty-printing.
    TAB = '  '
@@ -41,7 +47,7 @@ module CoffeeScript
      "(function() {\n#{compile_node(o.merge(:return => true))}\n#{indent}})()"
    end

-    # Quick method for the current indentation level, plus tabs out.
+    # Quick short method for the current indentation level, plus tabbing in.
    def idt(tabs=0)
      @indent + (TAB * tabs)
    end
@@ -57,7 +63,8 @@ module CoffeeScript
    statement
    attr_reader :expressions

-    STRIP_TRAILING_WHITESPACE = /\s+$/
+    TRAILING_WHITESPACE = /\s+$/
+    UPPERCASE           = /[A-Z]/

    # Wrap up a node as an Expressions, unless it already is.
    def self.wrap(*nodes)
@@ -69,12 +76,13 @@ module CoffeeScript
      @expressions = nodes.flatten
    end

-    # Tack an expression onto the end of this node.
+    # Tack an expression on to the end of this expression list.
    def <<(node)
      @expressions << node
      self
    end

+    # Tack an expression on to the beginning of this expression list.
    def unshift(node)
      @expressions.unshift(node)
      self
@@ -91,36 +99,19 @@ module CoffeeScript
      node == @expressions[@last_index]
    end

+    # Determine if this is the expressions body within a constructor function.
+    # Constructors are capitalized by CoffeeScript convention.
+    def constructor?(o)
+      o[:top] && o[:last_assign] && o[:last_assign][0..0][UPPERCASE]
+    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.
+    # Compile each expression in the Expressions body.
    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"))
+      write(@expressions.map {|n| compile_expression(n, options.dup) }.join("\n"))
    end

    # If this is the top-level Expressions, wrap everything in a safety closure.
@@ -129,15 +120,33 @@ module CoffeeScript
      @indent = indent
      o.merge!(:indent => indent, :scope => Scope.new(nil, self))
      code = o[:globals] ? compile_node(o) : compile_with_declarations(o)
-      code.gsub!(STRIP_TRAILING_WHITESPACE, '')
-      o[:no_wrap] ? code : "(function(){\n#{code}\n})();"
+      code.gsub!(TRAILING_WHITESPACE, '')
+      write(o[:no_wrap] ? code : "(function(){\n#{code}\n})();")
    end

+    # Compile the expressions body, with declarations of all inner variables
+    # at the top.
    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
+      return code unless o[:scope].declarations?(self)
+      write("#{idt}var #{o[:scope].declared_variables.join(', ')};\n#{code}")
+    end
+
+    # Compiles a single expression within the expression list.
+    def compile_expression(node, o)
+      @indent = o[:indent]
+      stmt    = node.statement?
+      # We need to return the result if this is the last node in the expressions body.
+      returns = o.delete(:return) && last?(node) && !node.statement_only?
+      # Return the regular compile of the node, unless we need to return the result.
+      return "#{stmt ? '' : idt}#{node.compile(o.merge(:top => true))}#{stmt ? '' : ';'}" unless returns
+      # If it's a statement, the node knows how to return itself.
+      return node.compile(o.merge(:return => true)) if node.statement?
+      # If it's not part of a constructor, we can just return the value of the expression.
+      return "#{idt}return #{node.compile(o)};" unless constructor?(o)
+      # It's the last line of a constructor, add a safety check.
+      temp = o[:scope].free_variable
+      "#{idt}#{temp} = #{node.compile(o)};\n#{idt}return #{o[:last_assign]} === this.constructor ? this : #{temp};"
    end

  end
@@ -145,14 +154,18 @@ module CoffeeScript
  # Literals are static values that have a Ruby representation, eg.: a string, a number,
  # true, false, nil, etc.
  class LiteralNode < Node
+
+    # Values of a literal node that much be treated as a statement -- no
+    # sense returning or assigning them.
    STATEMENTS = ['break', 'continue']

-    CONVERSIONS = {
-      'arguments' => 'Array.prototype.slice.call(arguments, 0)'
-    }
+    # If we get handed a literal reference to an arguments object, convert
+    # it to an array.
+    ARG_ARRAY  = 'Array.prototype.slice.call(arguments, 0)'

    attr_reader :value

+    # Wrap up a compiler-generated string as a LiteralNode.
    def self.wrap(string)
      self.new(Value.new(string))
    end
@@ -167,14 +180,14 @@ module CoffeeScript
    alias_method :statement_only?, :statement?

    def compile_node(o)
-      val    = CONVERSIONS[@value.to_s] || @value.to_s
+      @value = ARG_ARRAY if @value.to_s.to_sym == :arguments
      indent = statement? ? idt : ''
      ending = statement? ? ';' : ''
-      write("#{indent}#{val}#{ending}")
+      write "#{indent}#{@value}#{ending}"
    end
  end

-  # Try to return your expression, or tell it to return itself.
+  # Return an expression, or wrap it in a closure and return it.
  class ReturnNode < Node
    statement_only

@@ -202,8 +215,7 @@ module CoffeeScript

    def compile_node(o={})
      delimiter = "\n#{idt}//"
-      comment   = "#{delimiter}#{@lines.join(delimiter)}"
-      write(comment)
+      write("#{delimiter}#{@lines.join(delimiter)}")
    end

  end
@@ -238,6 +250,7 @@ module CoffeeScript
      @arguments << argument
    end

+    # Compile a vanilla function call.
    def compile_node(o)
      return write(compile_splat(o)) if splat?
      args = @arguments.map{|a| a.compile(o) }.join(', ')
@@ -245,6 +258,7 @@ module CoffeeScript
      write("#{prefix}#{@variable.compile(o)}(#{args})")
    end

+    # Compile a call against the superclass's implementation of the current function.
    def compile_super(args, o)
      methname = o[:last_assign]
      arg_part = args.empty? ? '' : ", #{args}"
@@ -253,6 +267,7 @@ module CoffeeScript
      "#{meth}.call(this#{arg_part})"
    end

+    # Compile a function call being passed variable arguments.
    def compile_splat(o)
      meth = @variable.compile(o)
      obj  = @variable.source || 'this'
@@ -275,6 +290,7 @@ module CoffeeScript
      @sub_object, @super_object = sub_object, super_object
    end

+    # Hooking one constructor into another's prototype chain.
    def compile_node(o={})
      constructor = o[:scope].free_variable
      sub, sup = @sub_object.compile(o), @super_object.compile(o)
@@ -289,10 +305,10 @@ module CoffeeScript

  # A value, indexed or dotted into, or vanilla.
  class ValueNode < Node
-    attr_reader :literal, :properties, :last, :source
+    attr_reader :base, :properties, :last, :source

-    def initialize(literal, properties=[])
-      @literal, @properties = literal, properties
+    def initialize(base, properties=[])
+      @base, @properties = base, properties
    end

    def <<(other)
@@ -304,23 +320,23 @@ module CoffeeScript
      return !@properties.empty?
    end

+    # Values are statements if their base is a statement.
    def statement?
-      @literal.is_a?(Node) && @literal.statement? && !properties?
+      @base.is_a?(Node) && @base.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|
-        val.respond_to?(:compile) ? val.compile(o) : val.to_s
-      end
+      parts = [@base, props].flatten.map {|val| val.compile(o) }
      @last = parts.last
      @source = parts.length > 1 ? parts[0...-1].join('') : nil
      write(parts.join(''))
    end
  end

-  # A dotted accessor into a part of a value.
+  # A dotted accessor into a part of a value, or the :: shorthand for
+  # an accessor into the object's prototype.
  class AccessorNode < Node
    attr_reader :name

@@ -360,14 +376,6 @@ module CoffeeScript
      @exclusive
    end

-    def less_operator
-      @exclusive ? '<' : '<='
-    end
-
-    def greater_operator
-      @exclusive ? '>' : '>='
-    end
-
    def compile_variables(o)
      @indent = o[:indent]
      @from_var, @to_var = o[:scope].free_variable, o[:scope].free_variable
@@ -376,12 +384,13 @@ module CoffeeScript
    end

    def compile_node(o)
+      return compile_array(o) unless o[:index]
      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})"
+      vars      = "#{idx}=#{@from_var}"
+      step      = step ? step.compile(o) : '1'
+      equals    = @exclusive ? '' : '='
+      compare   = "(#{@from_var} <= #{@to_var} ? #{idx} <#{equals} #{@to_var} : #{idx} >#{equals} #{@to_var})"
+      incr      = "(#{@from_var} <= #{@to_var} ? #{idx} += #{step} : #{idx} -= #{step})"
      write("#{vars}; #{compare}; #{incr}")
    end

@@ -640,8 +649,8 @@ module CoffeeScript

    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
+      range         = @source.is_a?(ValueNode) && @source.base.is_a?(RangeNode) && @source.properties.empty?
+      source        = range ? @source.base : @source
      scope         = o[:scope]
      name_found    = @name  && scope.find(@name)
      index_found   = @index && scope.find(@index)
@@ -657,8 +666,7 @@ module CoffeeScript
      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
+        for_part    = @object ? "#{ivar} in #{svar}" : "#{ivar}=0; #{ivar}<#{svar}.length; #{ivar}++"
        var_part    = @name ? "#{body_dent}#{@name} = #{svar}[#{ivar}];\n" : ''
      end
      body          = @body
--- a/lib/coffee_script/value.rb
+++ b/lib/coffee_script/value.rb
@@ -18,6 +18,10 @@ module CoffeeScript
      to_str.to_sym
    end

+    def compile(o={})
+      to_s
+    end
+
    def inspect
      @value.inspect
    end
--- a/package.json
+++ b/package.json
@@ -5,5 +5,5 @@
    "description":  "Unfancy JavaScript",
    "keywords":     ["javascript", "language"],
    "author":       "Jeremy Ashkenas",
-    "version":      "0.2.2"
+    "version":      "0.2.3"
 }
--- a/test/fixtures/execution/test_array_comprehension.coffee
+++ b/test/fixtures/execution/test_array_comprehension.coffee
@@ -5,8 +5,8 @@ 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
+names: key + '!' for key of obj
+odds:  key + '!' for key, value of obj when value % 2 isnt 0

 print(names.join(' ') is "one! two! three!")
 print(odds.join(' ')  is "one! three!")
--- a/test/unit/test_parser.rb
+++ b/test/unit/test_parser.rb
@@ -17,15 +17,15 @@ class ParserTest < Test::Unit::TestCase
    assert nodes.length == 1
    assign = nodes.first
    assert assign.is_a?(AssignNode)
-    assert assign.variable.literal == 'a'
+    assert assign.variable.base == 'a'
  end

  def test_parsing_an_object_literal
    nodes = @par.parse("{one : 1\ntwo : 2}").expressions
-    obj = nodes.first.literal
+    obj = nodes.first.base
    assert obj.is_a?(ObjectNode)
-    assert obj.properties.first.variable.literal.value == "one"
-    assert obj.properties.last.variable.literal.value == "two"
+    assert obj.properties.first.variable.base.value == "one"
+    assert obj.properties.last.variable.base.value == "two"
  end

  def test_parsing_an_function_definition
@@ -39,17 +39,17 @@ class ParserTest < Test::Unit::TestCase
  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.condition.literal == 'happy'
+    assert the_if.condition.base == 'happy'
    assert the_if.body.is_a?(CallNode)
-    assert the_if.body.variable.literal == 'clap_your_hands'
+    assert the_if.body.variable.base == '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)
-    assert nodes.first.body.literal == 'i'
+    assert nodes.first.body.base == 'i'
    assert nodes.first.filter.operator == '==='
-    assert nodes.first.source.literal.objects.last.literal.value == "5"
+    assert nodes.first.source.base.objects.last.base.value == "5"
  end

  def test_parsing_comment
@@ -66,7 +66,7 @@ class ParserTest < Test::Unit::TestCase
    nodes = @par.parse(File.read('test/fixtures/generation/each.coffee'))
    assign = nodes.expressions[1]
    assert assign.is_a?(AssignNode)
-    assert assign.variable.literal == '_'
+    assert assign.variable.base == '_'
    assert assign.value.is_a?(CodeNode)
    assert assign.value.params == ['obj', 'iterator', 'context']
  end
Author	SHA1	Message	Date
Jeremy Ashkenas	cfa357cbc3	CoffeeScript 0.2.3, with 'of', not 'ino'	2010-01-11 00:01:16 -05:00
Jeremy Ashkenas	9d8668f37f	added a whole slew of nice Potion examples from the pamphlet -- CoffeeScript stacks up pretty well.	2010-01-10 23:27:57 -05:00
Jeremy Ashkenas	d1ddeacbe3	more refactors to nodes	2010-01-10 22:35:55 -05:00
Jeremy Ashkenas	d9d09a9a72	refactoring and commenting nodes.rb Expressions	2010-01-10 22:04:38 -05:00
Jeremy Ashkenas	a1528f3f19	rebuilt the narwhal interface	2010-01-10 20:25:09 -05:00
Jeremy Ashkenas	7d2a955e0a	bumping the license to 2010	2010-01-10 17:57:29 -05:00