delorean_lang 0.2.0 → 0.2.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzA4ZGU5ZGEwNmIwNjU0NzYyYWZkMTU4MTAxNzdiMzg3ZjFjODQyNA==
+    MjQ5M2EzMTc3OGJlMmFhYTY0YmY1YTE5ODg5MTZiYjk2NmFjNDk1OA==
   data.tar.gz: !binary |-
-    ZmNkNTk2Y2Y2YzU5NzJiZTE5MzNmYTU4ODAwYzU3NTAyNmY5ZTJiNg==
+    NTVhYzM1MGQxNmNkNjM1YWQ4Zjc3ZjU2MDQzOGJjNzA5MjczNmNmNA==
 SHA512:
   metadata.gz: !binary |-
-    MzY1ZTk3YWMyYTgzODY5ZjM1YjFmODAxM2JlZWJlNDQ4NTg4Yzg1ODNjNGFm
-    NGQwYzM1MmE4YTYxZDVhNzA0NDlhYmFiZGM1NjJhNTVlOGEzYjViYmRiYzA2
-    NGFhMDQyZWEwYjUxOTdiOTc2ZDAyYjE5M2M1NjZlMzgxMDU3OTc=
+    ZjA2NWM5NmQ0Zjg1NjkxYTI1YjBmZTEzYTdkNzJiODRkMzI2YTQ1NWNlZjA1
+    ODgyZjkzODAxYWViOTBmNDI0ODViNzBmMWE0NjRjZjE2NzI4ZWZjMmMzZDYw
+    YzhjMDQ5MjQyNzVhYjYyN2ZhYTMzODcyNzNkYTg4Y2Q5OWVmZWY=
   data.tar.gz: !binary |-
-    MzkwMmQwOGUxN2U2MjJmZjJhZjQ0MmU0NGY0Mzg4ZmQ2NmVhZGRlNzI0YjNi
-    NzQyNGE2MTRiYzRkNTdiMTRiMDNmNmNlYzJmOTMyYWU5MDM4ZmY1NjRlM2Y5
-    ZmQxZWNmMmQyZjAyYzE3NmQ0ODg0YWUxZDY2MjAzMTNjOWFiYmU=
+    NzQ5YTJmODYwNTdkMjYyM2I1NzZiYjU2MjIyZmMzNzk1MTU4YTJmNDBlMzE4
+    MzlmYzU0ZmRmNmNmMThiYzA5ODdkNThhZjQ5MzAzZDI5MTVkMjk3MTE4ZjFl
+    ZjAyYjkzOTA5YmJlMmYxYTk5YjcwOWMxYWJjMTJhNWJmY2U2MDI=

data/lib/delorean/delorean.rb

@@ -98,7 +98,7 @@ module Delorean
   end
 
   module Formula0
-    def sp
+    def sp4
       elements[0]
     end
 
@@ -112,7 +112,7 @@ module Delorean
   end
 
   module Formula1
-    def sp
+    def sp4
       elements[0]
     end
 
@@ -123,7 +123,7 @@ module Delorean
   end
 
   module Formula2
-    def sp
+    def sp4
       elements[0]
     end
 
@@ -187,7 +187,7 @@ module Delorean
 
     i0 = index
     i1, s1 = index, []
-    r2 = _nt_sp
+    r2 = _nt_sp4
     s1 << r2
     if r2
       r3 = _nt_identifier
@@ -236,7 +236,7 @@ module Delorean
       r0 = r1
     else
       i10, s10 = index, []
-      r11 = _nt_sp
+      r11 = _nt_sp4
       s10 << r11
       if r11
         r12 = _nt_identifier
@@ -272,7 +272,7 @@ module Delorean
         r0 = r10
       else
         i16, s16 = index, []
-        r17 = _nt_sp
+        r17 = _nt_sp4
         s16 << r17
         if r17
           r18 = _nt_identifier
@@ -2697,22 +2697,31 @@ module Delorean
     r3 = _nt_identifier
     s2 << r3
     if r3
-      if has_terminal?(':', false, index)
-        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
+      r5 = _nt_sp
+      if r5
+        r4 = r5
       else
-        terminal_parse_failure(':')
-        r4 = nil
+        r4 = instantiate_node(SyntaxNode,input, index...index)
       end
       s2 << r4
       if r4
-        r6 = _nt_sp
-        if r6
-          r5 = r6
+        if has_terminal?('=', false, index)
+          r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
         else
-          r5 = instantiate_node(SyntaxNode,input, index...index)
+          terminal_parse_failure('=')
+          r6 = nil
+        end
+        s2 << r6
+        if r6
+          r8 = _nt_sp
+          if r8
+            r7 = r8
+          else
+            r7 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s2 << r7
         end
-        s2 << r5
       end
     end
     if s2.last
@@ -2729,58 +2738,58 @@ module Delorean
     end
     s0 << r1
     if r1
-      r7 = _nt_expression
-      s0 << r7
-      if r7
-        i9, s9 = index, []
-        r11 = _nt_sp
-        if r11
-          r10 = r11
+      r9 = _nt_expression
+      s0 << r9
+      if r9
+        i11, s11 = index, []
+        r13 = _nt_sp
+        if r13
+          r12 = r13
         else
-          r10 = instantiate_node(SyntaxNode,input, index...index)
+          r12 = instantiate_node(SyntaxNode,input, index...index)
         end
-        s9 << r10
-        if r10
+        s11 << r12
+        if r12
           if has_terminal?(',', false, index)
-            r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
             @index += 1
           else
             terminal_parse_failure(',')
-            r12 = nil
+            r14 = nil
           end
-          s9 << r12
-          if r12
-            r14 = _nt_sp
-            if r14
-              r13 = r14
+          s11 << r14
+          if r14
+            r16 = _nt_sp
+            if r16
+              r15 = r16
             else
-              r13 = instantiate_node(SyntaxNode,input, index...index)
+              r15 = instantiate_node(SyntaxNode,input, index...index)
             end
-            s9 << r13
-            if r13
-              r16 = _nt_kw_args
-              if r16
-                r15 = r16
+            s11 << r15
+            if r15
+              r18 = _nt_kw_args
+              if r18
+                r17 = r18
               else
-                r15 = instantiate_node(SyntaxNode,input, index...index)
+                r17 = instantiate_node(SyntaxNode,input, index...index)
               end
-              s9 << r15
+              s11 << r17
             end
           end
         end
-        if s9.last
-          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-          r9.extend(KwArgs1)
+        if s11.last
+          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+          r11.extend(KwArgs1)
         else
-          @index = i9
-          r9 = nil
+          @index = i11
+          r11 = nil
         end
-        if r9
-          r8 = r9
+        if r11
+          r10 = r11
         else
-          r8 = instantiate_node(SyntaxNode,input, index...index)
+          r10 = instantiate_node(SyntaxNode,input, index...index)
         end
-        s0 << r8
+        s0 << r10
       end
     end
     if s0.last
@@ -3064,6 +3073,30 @@ module Delorean
     r0
   end
 
+  def _nt_sp4
+    start_index = index
+    if node_cache[:sp4].has_key?(index)
+      cached = node_cache[:sp4][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?('    ', false, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 4))
+      @index += 4
+    else
+      terminal_parse_failure('    ')
+      r0 = nil
+    end
+
+    node_cache[:sp4][start_index] = r0
+
+    r0
+  end
+
   def _nt_sp
     start_index = index
     if node_cache[:sp].has_key?(index)

data/lib/delorean/delorean.treetop

@@ -4,11 +4,11 @@ grammar Delorean
   end
 
   rule formula
-    sp i:identifier sp? '=?' sp? e:expression <ParameterDefault>
+    sp4 i:identifier sp? '=?' sp? e:expression <ParameterDefault>
     /
-    sp i:identifier sp? '=?' <Parameter>
+    sp4 i:identifier sp? '=?' <Parameter>
     /
-    sp i:identifier sp? '=' sp? e:expression <Formula>
+    sp4 i:identifier sp? '=' sp? e:expression <Formula>
     /
     n:class_name ':' sp? mod:(m:class_name '::')? p:class_name <SubNode>
     /
@@ -26,9 +26,9 @@ grammar Delorean
     /
     op:unary_op sp? e:expression <UnOp>
     /
-    'if' 	sp? v:expression sp?
-    'then' 	sp? e1:expression sp?
-    'else' 	sp? e2:expression <IfElse>
+    'if'        sp? v:expression sp?
+    'then'      sp? e1:expression sp?
+    'else'      sp? e2:expression <IfElse>
     /
     v:getattr_exp sp? op:binary_op sp? e:expression <BinOp>
     /
@@ -100,16 +100,16 @@ grammar Delorean
   end
 
   rule value
-    number 						/
-    string 						/
-    boolean 						/
-    nil_val						/
-    identifier						/
-    list_expr 						/
-    set_expr 						/
-    hash_expr 						/
+    number                                              /
+    string                                              /
+    boolean                                             /
+    nil_val                                             /
+    identifier                                          /
+    list_expr                                           /
+    set_expr                                            /
+    hash_expr                                           /
     mod:(m:class_name '::')? c:class_name <NodeAsValue> /
-    '(' sp? e:expression sp? ')' 	 <Expr>
+    '(' sp? e:expression sp? ')'         <Expr>
   end
 
   rule fn_args
@@ -121,7 +121,7 @@ grammar Delorean
   end
 
   rule kw_args
-    k:(i:identifier ':' sp?)? arg0:expression args_rest:(sp? ',' sp? al:kw_args?)? <KwArgs>
+    k:(i:identifier sp? '=' sp?)? arg0:expression args_rest:(sp? ',' sp? al:kw_args?)? <KwArgs>
   end
 
   rule number
@@ -148,6 +148,11 @@ grammar Delorean
     'nil' <Literal>
   end
 
+  # and you thought python was anal about spaces?
+  rule sp4
+    '    '
+  end
+
   rule sp
     [\s]+
   end

data/lib/delorean/error.rb

@@ -10,6 +10,10 @@ module Delorean
       @line = line
       @module_name = module_name
     end
+
+    def to_s
+      super + " #{module_name}:#{line}"
+    end
   end
 
   class UndefinedError < ParseError

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/spec/dev_spec.rb

@@ -8,28 +8,28 @@ describe "Delorean" do
 
   it "can enumerate nodes" do
     engine.parse defn("X:",
-                      "  a = 123",
-                      "  b = a",
+                      "    a = 123",
+                      "    b = a",
                       "Y: X",
                       "A:",
                       "XX: Y",
-                      "  a = 11",
-                      "  c =?",
-                      "  d = 456",
+                      "    a = 11",
+                      "    c =?",
+                      "    d = 456",
                       )
     engine.enumerate_nodes.should == SortedSet.new(["A", "X", "XX", "Y"])
   end
 
   it "can enumerate all attrs" do
     engine.parse defn("X:",
-                      "  a = 123",
-                      "  b = a",
+                      "    a = 123",
+                      "    b = a",
                       "Y: X",
                       "Z:",
                       "XX: Y",
-                      "  a = 11",
-                      "  c =?",
-                      "  d = 456",
+                      "    a = 11",
+                      "    c =?",
+                      "    d = 456",
                       )
     engine.enumerate_attrs.should == {
       "X"=>["a", "b"],
@@ -41,14 +41,14 @@ describe "Delorean" do
 
   it "can enumerate attrs by node" do
     engine.parse defn("X:",
-                      "  a = 123",
-                      "  b = a",
+                      "    a = 123",
+                      "    b = a",
                       "Y: X",
                       "Z:",
                       "XX: Y",
-                      "  a = 11",
-                      "  c =?",
-                      "  d = 456",
+                      "    a = 11",
+                      "    c =?",
+                      "    d = 456",
                       )
     engine.enumerate_attrs_by_node("X").should == ["a", "b"]
     engine.enumerate_attrs_by_node("Y").should == ["a", "b"]
@@ -58,17 +58,17 @@ describe "Delorean" do
 
   it "can enumerate params" do
     engine.parse defn("X:",
-                      "  a =? 123",
-                      "  b = a",
+                      "    a =? 123",
+                      "    b = a",
                       "Y: X",
                       "Z:",
                       "XX: Y",
-                      "  a = 11",
-                      "  c =?",
-                      "  d = 123",
+                      "    a = 11",
+                      "    c =?",
+                      "    d = 123",
                       "YY: XX",
-                      "  c =? 22",
-                      "  e =? 11",
+                      "    c =? 22",
+                      "    e =? 11",
                       )
 
     engine.enumerate_params.should == Set.new(["a", "c", "e"])
@@ -76,17 +76,17 @@ describe "Delorean" do
 
   it "can enumerate params by node" do
     engine.parse defn("X:",
-                      "  a =? 123",
-                      "  b = a",
+                      "    a =? 123",
+                      "    b = a",
                       "Y: X",
                       "Z:",
                       "XX: Y",
-                      "  a = 11",
-                      "  c =?",
-                      "  d = 123",
+                      "    a = 11",
+                      "    c =?",
+                      "    d = 123",
                       "YY: XX",
-                      "  c =? 22",
-                      "  e =? 11",
+                      "    c =? 22",
+                      "    e =? 11",
                       )
     engine.enumerate_params_by_node("X").should == Set.new(["a"])
     engine.enumerate_params_by_node("XX").should == Set.new(["a", "c"])

data/spec/eval_spec.rb

@@ -6,8 +6,8 @@ describe "Delorean" do
     TestContainer.new({
                         "AAA" =>
                         defn("X:",
-                             "  a =? 123",
-                             "  b = a*2",
+                             "    a =? 123",
+                             "    b = a*2",
                              )
                       })
   }
@@ -18,10 +18,10 @@ describe "Delorean" do
 
   it "evaluate simple expressions" do
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  x = -(a * 2)",
-                      "  b = -(a + 1)",
-                      "  c = -a + 1",
+                      "    a = 123",
+                      "    x = -(a * 2)",
+                      "    b = -(a + 1)",
+                      "    c = -a + 1",
                       )
 
     engine.evaluate_attrs("A", ["a"]).should == [123]
@@ -32,8 +32,8 @@ describe "Delorean" do
 
   it "proper unary expression evaluation" do
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  c = -a + 1",
+                      "    a = 123",
+                      "    c = -a + 1",
                       )
 
     r = engine.evaluate("A", "c")
@@ -42,17 +42,17 @@ describe "Delorean" do
 
   it "should handle getattr in expressions" do
     engine.parse defn("A:",
-                      "  a = {'x':123, 'y':456, 'z':789}",
-                      "  b = A.a.x * A.a.y - A.a.z",
+                      "    a = {'x':123, 'y':456, 'z':789}",
+                      "    b = A.a.x * A.a.y - A.a.z",
                       )
     engine.evaluate_attrs("A", ["b"]).should == [123*456-789]
   end
 
   it "should be able to evaluate multiple node attrs" do
     engine.parse defn("A:",
-                      "  a =? 123",
-                      "  b = a % 11",
-                      "  c = a / 4.0",
+                      "    a =? 123",
+                      "    b = a % 11",
+                      "    c = a / 4.0",
                       )
 
     h = {"a" => 16}
@@ -62,8 +62,8 @@ describe "Delorean" do
 
   it "should give error when accessing undefined attr" do
     engine.parse defn("A:",
-                      "  a = 1",
-                      "  c = a.to_s",
+                      "    a = 1",
+                      "    c = a.to_s",
                       )
 
     lambda {
@@ -73,8 +73,8 @@ describe "Delorean" do
 
   it "should handle default param values" do
     engine.parse defn("A:",
-                      "  a =? 123",
-                      "  c = a / 123.0",
+                      "    a =? 123",
+                      "    c = a / 123.0",
                       )
 
     r = engine.evaluate("A", "c")
@@ -83,10 +83,10 @@ describe "Delorean" do
 
   it "order of attr evaluation should not matter" do
     engine.parse defn("A:",
-                      "	a =? 1",
+                      "    a =? 1",
                       "B:",
-                      "	a =? 2",
-                      "	c = A.a",
+                      "    a =? 2",
+                      "    c = A.a",
                       )
     engine.evaluate_attrs("B", %w{c a}).should == [1, 2]
     engine.evaluate_attrs("B", %w{a c}).should == [2, 1]
@@ -94,13 +94,13 @@ describe "Delorean" do
 
   it "params should behave properly with inheritance" do
     engine.parse defn("A:",
-                      "	a =? 1",
+                      "    a =? 1",
                       "B: A",
-                      "	a =? 2",
+                      "    a =? 2",
                       "C: B",
-                      " a =? 3",
-                      " b = B.a",
-                      " c = A.a",
+                      "    a =? 3",
+                      "    b = B.a",
+                      "    c = A.a",
                       )
     engine.evaluate_attrs("C", %w{a b c}).should == [3, 2, 1]
     engine.evaluate_attrs("C", %w{a b c}, {"a" => 4}).should == [4, 4, 4]
@@ -109,8 +109,8 @@ describe "Delorean" do
 
   it "should give error when param is undefined for eval" do
     engine.parse defn("A:",
-                      "  a =?",
-                      "  c = a / 123.0",
+                      "    a =?",
+                      "    c = a / 123.0",
                       )
 
     lambda {
@@ -120,8 +120,8 @@ describe "Delorean" do
 
   it "should handle simple param computation" do
     engine.parse defn("A:",
-                      "  a =?",
-                      "  c = a / 123.0",
+                      "    a =?",
+                      "    c = a / 123.0",
                       )
 
     r = engine.evaluate("A", "c", {"a" => 123})
@@ -130,7 +130,7 @@ describe "Delorean" do
 
   it "should give error on unknown node" do
     engine.parse defn("A:",
-                      "  a = 1",
+                      "    a = 1",
                       )
 
     lambda {
@@ -140,8 +140,8 @@ describe "Delorean" do
 
   it "should handle runtime errors and report module/line number" do
     engine.parse defn("A:",
-                      "  a = 1/0",
-                      "  b = 10 * a",
+                      "    a = 1/0",
+                      "    b = 10 * a",
                       )
 
     begin
@@ -158,7 +158,7 @@ describe "Delorean" do
 
   it "should handle runtime errors 2" do
     engine.parse defn("A:",
-                      "  b = Dummy.call_me_maybe('a', 'b')",
+                      "    b = Dummy.call_me_maybe('a', 'b')",
                       )
 
     begin
@@ -172,10 +172,10 @@ describe "Delorean" do
 
   it "should handle operator precedence properly" do
     engine.parse defn("A:",
-                      "  b = 3+2*4-1",
-                      "  c = b*3+5",
-                      "  d = b*2-c*2",
-                      "  e = if (d < -10) then -123-1 else -456+1",
+                      "    b = 3+2*4-1",
+                      "    c = b*3+5",
+                      "    d = b*2-c*2",
+                      "    e = if (d < -10) then -123-1 else -456+1",
                       )
 
     r = engine.evaluate("A", "d")
@@ -187,8 +187,8 @@ describe "Delorean" do
 
   it "should handle if/else" do
     text = defn("A:",
-                "  d =? -10",
-                '  e = if d < -10 then "gungam"+"style" else "korea"'
+                "    d =? -10",
+                '    e = if d < -10 then "gungam"+"style" else "korea"'
                 )
 
     engine.parse text
@@ -201,13 +201,13 @@ describe "Delorean" do
 
   it "should be able to access specific node attrs " do
     engine.parse defn("A:",
-                      "  b = 123",
-                      "  c =?",
+                      "    b = 123",
+                      "    c =?",
                       "B: A",
-                      "  b = 111",
-                      "  c = A.b * 123",
+                      "    b = 111",
+                      "    c = A.b * 123",
                       "C:",
-                      "  c = A.c + B.c",
+                      "    c = A.c + B.c",
                       )
 
     r = engine.evaluate("B", "c")
@@ -218,9 +218,9 @@ describe "Delorean" do
 
   it "should be able to call class methods on ActiveRecord classes" do
     engine.parse defn("A:",
-                      "  b = Dummy.call_me_maybe(1, 2, 3, 4)",
-                      "  c = Dummy.call_me_maybe()",
-                      "  d = Dummy.call_me_maybe(5) + b + c",
+                      "    b = Dummy.call_me_maybe(1, 2, 3, 4)",
+                      "    c = Dummy.call_me_maybe()",
+                      "    d = Dummy.call_me_maybe(5) + b + c",
                       )
     r = engine.evaluate_attrs("A", ["b", "c", "d"])
     r.should == [10, 0, 15]
@@ -228,10 +228,10 @@ describe "Delorean" do
 
   it "should be able to get attr on ActiveRecord objects using a.b syntax" do
     engine.parse defn("A:",
-                      '  b = Dummy.i_just_met_you("this is crazy", 0.404)',
-                      "  c = b.number",
-                      "  d = b.name",
-                      "  e = b.foo",
+                      '    b = Dummy.i_just_met_you("this is crazy", 0.404)',
+                      "    c = b.number",
+                      "    d = b.name",
+                      "    e = b.foo",
                       )
     r = engine.evaluate("A", "c")
     r.should == 0.404
@@ -246,7 +246,7 @@ describe "Delorean" do
 
   it "should be able to get attr on ActiveRecord objects using Class.method().attr syntax" do
     engine.parse defn("A:",
-                      '  b = Dummy.i_just_met_you("CRJ", 1.234).name',
+                      '    b = Dummy.i_just_met_you("CRJ", 1.234).name',
                       )
     r = engine.evaluate("A", "b")
     r.should == "CRJ"
@@ -254,19 +254,19 @@ describe "Delorean" do
 
   it "should be able to get attr on Hash objects using a.b syntax" do
     engine.parse defn("A:",
-                      '  b = Dummy.i_threw_a_hash_in_the_well()',
-                      "  c = b.a",
-                      "  d = b.b",
-                      "  e = b.this_is_crazy",
+                      '    b = Dummy.i_threw_a_hash_in_the_well()',
+                      "    c = b.a",
+                      "    d = b.b",
+                      "    e = b.this_is_crazy",
                       )
     engine.evaluate_attrs("A", %w{c d e}).should == [456, 789, nil]
   end
 
   it "get attr on nil should return nil" do
     engine.parse defn("A:",
-                      '  b = Dummy.i_just_met_you("CRJ", 1.234).dummy',
-                      '  c = b.gaga',
-                      '  d = b.gaga || 55',
+                      '    b = Dummy.i_just_met_you("CRJ", 1.234).dummy',
+                      '    c = b.gaga',
+                      '    d = b.gaga || 55',
                       )
     r = engine.evaluate_attrs("A", ["b", "c", "d"])
     r.should == [nil, nil, 55]
@@ -274,8 +274,8 @@ describe "Delorean" do
 
   it "should be able to get assoc attr on ActiveRecord objects" do
     engine.parse defn("A:",
-                      '  b = Dummy.miss_you_so_bad()',
-                      '  c = b.dummy',
+                      '    b = Dummy.miss_you_so_bad()',
+                      '    c = b.dummy',
                       )
     r = engine.evaluate("A", "c")
     r.name.should == "hello"
@@ -283,24 +283,24 @@ describe "Delorean" do
 
   it "should be able to get attr on node" do
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  b = A",
-                      "  c = b.a * 2",
+                      "    a = 123",
+                      "    b = A",
+                      "    c = b.a * 2",
                       )
     engine.evaluate_attrs("A", %w{a c}).should == [123, 123*2]
   end
 
   getattr_code = <<eoc
 A:
-	x = 1
+    x = 1
 B:
-	x = 2
+    x = 2
 C:
-	x = 3
+    x = 3
 D:
-	xs = [A, B, C]
+    xs = [A, B, C]
 E:
-	xx = [n.x for n in D.xs]
+    xx = [n.x for n in D.xs]
 eoc
 
   it "should be able to get attr on node 2" do
@@ -310,7 +310,7 @@ eoc
 
   it "should be able to call class methods on AR classes in modules" do
     engine.parse defn("A:",
-                      "  b = M::LittleDummy.heres_my_number(867, 5309)",
+                      "    b = M::LittleDummy.heres_my_number(867, 5309)",
                       )
     r = engine.evaluate("A", "b")
     r.should == 867 + 5309
@@ -318,7 +318,7 @@ eoc
 
   it "should not eval inside strings" do
     engine.parse defn("A:",
-                      '  d = "#{this is a test}"',
+                      '    d = "#{this is a test}"',
                       )
 
     r = engine.evaluate("A", "d")
@@ -327,7 +327,7 @@ eoc
 
   it "should ignore undeclared params sent to eval which match attr names" do
     engine.parse defn("A:",
-                      "  d = 12",
+                      "    d = 12",
                       )
     r = engine.evaluate("A", "d", {"d" => 5, "e" => 6})
     r.should == 12
@@ -335,12 +335,12 @@ eoc
 
   it "should handle different param defaults on nodes" do
     engine.parse defn("A:",
-                      "  p =? 1",
-                      "  c = p * 123",
+                      "    p =? 1",
+                      "    c = p * 123",
                       "B: A",
-                      "  p =? 2",
+                      "    p =? 2",
                       "C: A",
-                      "  p =? 3",
+                      "    p =? 3",
                       )
 
     r = engine.evaluate("C", "c", {"p" => 5})
@@ -361,10 +361,10 @@ eoc
 
   it "should allow overriding of attrs as params" do
     engine.parse defn("A:",
-                      "  a = 2",
-                      "  b = a*3",
+                      "    a = 2",
+                      "    b = a*3",
                       "B: A",
-                      "  a =?",
+                      "    a =?",
                       )
 
     r = engine.evaluate("A", "b", {"a" => 10})
@@ -381,16 +381,16 @@ eoc
 
   sample_script = <<eof
 A:
-	a = 2
-	p =?
-	c = a * 2
-	pc = p + c
+    a = 2
+    p =?
+    c = a * 2
+    pc = p + c
 
 C: A
     p =? 3
 
 B: A
-	p =? 5
+    p =? 5
 eof
 
   it "should allow overriding of attrs as params" do
@@ -414,19 +414,19 @@ eof
     engin2 = Delorean::Engine.new(engine.module_name)
 
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  b = a*3",
+                      "    a = 123",
+                      "    b = a*3",
                       "B: A",
-                      "  c = b*2",
+                      "    c = b*2",
                       )
 
     engin2.parse defn("A:",
-                      "  a = 222.0",
-                      "  b = a/5",
+                      "    a = 222.0",
+                      "    b = a/5",
                       "B: A",
-                      "  c = b*3",
+                      "    c = b*3",
                       "C:",
-                      "  d = 111",
+                      "    d = 111",
                       )
 
     engine.evaluate_attrs("A", ["a", "b"]).should == [123, 123*3]
@@ -450,10 +450,10 @@ eof
 
   it "should eval lists" do
     engine.parse defn("A:",
-                      "  b = []",
-                      "  c = [1,2,3]",
-                      "  d = [b, c, b, c, 1, 2, '123', 1.1, -1.23]",
-                      "  e = [1, 1+1, 1+1+1, 1*2*4]",
+                      "    b = []",
+                      "    c = [1,2,3]",
+                      "    d = [b, c, b, c, 1, 2, '123', 1.1, -1.23]",
+                      "    e = [1, 1+1, 1+1+1, 1*2*4]",
                       )
 
     engine.evaluate_attrs("A", %w{b c d e}).should ==
@@ -466,9 +466,9 @@ eof
 
   it "should eval list expressions" do
     engine.parse defn("A:",
-                      "  b = []+[]",
-                      "  c = [1,2,3]+b",
-                      "  d = c*2",
+                      "    b = []+[]",
+                      "    c = [1,2,3]+b",
+                      "    d = c*2",
                       )
 
     engine.evaluate_attrs("A", %w{b c d}).should ==
@@ -480,9 +480,9 @@ eof
 
   it "should eval sets and set comprehension" do
     engine.parse defn("A:",
-                      "  a = {-}",
-                      "  b = {i*5 for i in {1,2,3}}",
-                      "  c = {1,2,3} | {4,5}",
+                      "    a = {-}",
+                      "    b = {i*5 for i in {1,2,3}}",
+                      "    c = {1,2,3} | {4,5}",
                       )
     engine.evaluate_attrs("A", ["a", "b", "c"]).should ==
       [Set[], Set[5,10,15], Set[1,2,3,4,5]]
@@ -490,14 +490,14 @@ eof
 
   it "should eval list comprehension" do
     engine.parse defn("A:",
-                      "  b = [i*5 for i in [1,2,3]]",
+                      "    b = [i*5 for i in [1,2,3]]",
                       )
     engine.evaluate("A", "b").should == [5, 10, 15]
   end
 
   it "should eval nested list comprehension" do
     engine.parse defn("A:",
-                      "  b = [[a+c for c in [4,5]] for a in [1,2,3]]",
+                      "    b = [[a+c for c in [4,5]] for a in [1,2,3]]",
                       )
     engine.evaluate("A", "b").should == [[5, 6], [6, 7], [7, 8]]
 
@@ -505,23 +505,23 @@ eof
 
   it "should eval list comprehension variable override" do
     engine.parse defn("A:",
-                      "  b = [b/2.0 for b in [1,2,3]]",
+                      "    b = [b/2.0 for b in [1,2,3]]",
                       )
     engine.evaluate("A", "b").should == [0.5, 1.0, 1.5]
   end
 
   it "should eval list comprehension variable override (2)" do
     engine.parse defn("A:",
-                      "  a = 1",
-                      "  b = [a+1 for a in [1,2,3]]",
+                      "    a = 1",
+                      "    b = [a+1 for a in [1,2,3]]",
                       )
     engine.evaluate("A", "b").should == [2, 3, 4]
   end
 
   it "should eval conditional list comprehension" do
     engine.parse defn("A:",
-                      "  b = [i*5 for i in [1,2,3,4,5] if i%2 == 1]",
-                      "  c = [i/10.0 for i in [1,2,3,4,5] if i>4]",
+                      "    b = [i*5 for i in [1,2,3,4,5] if i%2 == 1]",
+                      "    c = [i/10.0 for i in [1,2,3,4,5] if i>4]",
                       )
     engine.evaluate("A", "b").should == [5, 15, 25]
     engine.evaluate("A", "c").should == [0.5]
@@ -529,12 +529,12 @@ eof
 
   it "should eval hashes" do
     engine.parse defn("A:",
-                      "  b = {}",
-                      "  c = {'a':1, 'b': 2,'c':3}",
-                      "  d = {123*2: -123, 'b_b': 1+1}",
-                      "  e = {'x': 1, 'y': 1+1, 'z': 1+1+1, 'zz': 1*2*4}",
-                      "  f = {'a': nil, 'b': [1, nil, 2]}",
-                      "  g = {b:b, [b]:[1,23], []:345}",
+                      "    b = {}",
+                      "    c = {'a':1, 'b': 2,'c':3}",
+                      "    d = {123*2: -123, 'b_b': 1+1}",
+                      "    e = {'x': 1, 'y': 1+1, 'z': 1+1+1, 'zz': 1*2*4}",
+                      "    f = {'a': nil, 'b': [1, nil, 2]}",
+                      "    g = {b:b, [b]:[1,23], []:345}",
                       )
 
     engine.evaluate_attrs("A", %w{b c d e f g}).should ==
@@ -549,14 +549,14 @@ eof
 
   it "should eval hash comprehension" do
     engine.parse defn("A:",
-                      "  b = {i*5 :i for i in [1,2,3]}",
+                      "    b = {i*5 :i for i in [1,2,3]}",
                       )
     engine.evaluate("A", "b").should == {5=>1, 10=>2, 15=>3}
   end
 
   it "should eval nested hash comprehension" do
     engine.parse defn("A:",
-                      "  b = { a:{a+c:a-c for c in [4,5]} for a in [1,2,3]}",
+                      "    b = { a:{a+c:a-c for c in [4,5]} for a in [1,2,3]}",
                       )
     engine.evaluate("A", "b").should ==
       {1=>{5=>-3, 6=>-4}, 2=>{6=>-2, 7=>-3}, 3=>{7=>-1, 8=>-2}}
@@ -564,8 +564,8 @@ eof
 
   it "should eval conditional hash comprehension" do
     engine.parse defn("A:",
-                      "  b = {i*5:i+5 for i in [1,2,3,4,5] if i%2 == 1}",
-                      "  c = {i/10.0:i*10 for i in [1,2,3,4,5] if i>4}",
+                      "    b = {i*5:i+5 for i in [1,2,3,4,5] if i%2 == 1}",
+                      "    c = {i/10.0:i*10 for i in [1,2,3,4,5] if i>4}",
                       )
     engine.evaluate("A", "b").should == {5=>6, 15=>8, 25=>10}
     engine.evaluate("A", "c").should == {0.5=>50}
@@ -573,10 +573,10 @@ eof
 
   it "should eval node calls as intermediate results" do
     engine.parse defn("A:",
-                      "  a =?",
-                      "  e = A(a: 13)",
-                      "  d = e.a * 2",
-                      "  f = e.d / e.a",
+                      "    a =?",
+                      "    e = A(a=13)",
+                      "    d = e.a * 2",
+                      "    f = e.d / e.a",
                       )
 
     engine.evaluate_attrs("A", ["d", "f"]).should == [26, 2]
@@ -584,9 +584,9 @@ eof
 
   it "should eval module calls 1" do
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  n = A",
-                      "  d = n().a",
+                      "    a = 123",
+                      "    n = A",
+                      "    d = n().a",
                       )
 
     engine.evaluate_attrs("A", %w{d}).should == [123]
@@ -594,12 +594,12 @@ eof
 
   it "should eval module calls 2" do
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  b = 456 + a",
-                      "  n = 'A'",
-                      "  c = nil(x: 123, y: 456) % ['a', 'b']",
-                      "  d = n(x: 123, y: 456) % ['a', 'b']",
-                      "  e = nil() % ['b']",
+                      "    a = 123",
+                      "    b = 456 + a",
+                      "    n = 'A'",
+                      "    c = nil(x = 123, y = 456) % ['a', 'b']",
+                      "    d = n(x = 123, y = 456) % ['a', 'b']",
+                      "    e = nil() % ['b']",
                       )
 
     engine.evaluate_attrs("A", %w{n c d e}).should ==
@@ -608,10 +608,10 @@ eof
 
   it "should eval module calls 3" do
     engine.parse defn("A:",
-                      "  a = 123",
+                      "    a = 123",
                       "B:",
-                      "  n = 'A'",
-                      "  d = n().a",
+                      "    n = 'A'",
+                      "    d = n().a",
                       )
 
     engine.evaluate_attrs("B", %w{d}).should == [123]
@@ -619,8 +619,8 @@ eof
 
   it "should be possible to implement recursive calls" do
     engine.parse defn("A:",
-                      "  n =?",
-                      "  fact = if n <= 1 then 1 else n * A(n: n-1).fact",
+                      "    n =?",
+                      "    fact = if n <= 1 then 1 else n * A(n=n-1).fact",
                       )
 
     engine.evaluate("A", "fact", "n" => 10).should == 3628800
@@ -628,34 +628,34 @@ eof
 
   it "should eval module calls by node name" do
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  b = A().a",
+                      "    a = 123",
+                      "    b = A().a",
                       )
     engine.evaluate("A", "b").should == 123
   end
 
   it "should eval multiline expressions" do
     engine.parse defn("A:",
-                      "  a = 1",
-                      "  b = [a+1",
-                      "       for a in [1,2,3]",
-                      "	     ]",
+                      "    a = 1",
+                      "    b = [a+1",
+                      "         for a in [1,2,3]",
+                      "    ]",
                       )
     engine.evaluate("A", "b").should == [2, 3, 4]
   end
 
   it "should eval multiline expressions" do
     engine.parse defn("A:",
-                      "  a = 123",
-                      "  b = 456 + ",
-                      "      a",
-                      "  n = 'A'",
-                      "  c = nil(x: 123,",
-                      "        y: 456) % ['a', 'b']",
-                      "  d = n(",
-                      "         x: 123, y: 456) % ['a', 'b']",
-                      "  e = nil(",
-                      "       ) % ['b']",
+                      "    a = 123",
+                      "    b = 456 + ",
+                      "        a",
+                      "    n = 'A'",
+                      "    c = nil(x = 123,",
+                      "          y = 456) % ['a', 'b']",
+                      "    d = n(",
+                      "           x = 123, y = 456) % ['a', 'b']",
+                      "    e = nil(",
+                      "         ) % ['b']",
                       )
 
     engine.evaluate_attrs("A", %w{n c d e}).should ==
@@ -665,10 +665,10 @@ eof
   it "should eval imports" do
     engine.parse defn("import AAA",
                       "A:",
-                      "  b = 456",
+                      "    b = 456",
                       "B: AAA::X",
-                      "  a = 111",
-                      "  c = AAA::X(a: 456).b",
+                      "    a = 111",
+                      "    c = AAA::X(a=456).b",
                       )
     engine.evaluate_attrs("B", ["a", "b", "c"], {}).should ==
       [111, 222, 456*2]
@@ -676,20 +676,20 @@ eof
 
   it "should eval imports (2)" do
     sset.merge({
-                 "BBB"  =>
+                 "BBB"    =>
                  defn("import AAA",
                       "B: AAA::X",
-                      "  a = 111",
-                      "  c = AAA::X(a: -1).b",
-                      "  d = a * 2",
+                      "    a = 111",
+                      "    c = AAA::X(a=-1).b",
+                      "    d = a * 2",
                       ),
                  "CCC" =>
                  defn("import BBB",
                       "import AAA",
                       "B: BBB::B",
-                      "  e = d * 3",
+                      "    e = d * 3",
                       "C: AAA::X",
-                      "  d = b * 3",
+                      "    d = b * 3",
                       ),
                })
 
@@ -700,7 +700,7 @@ eof
 
     engine.parse defn("import BBB",
                       "B: BBB::B",
-                      "  e = d + 3",
+                      "    e = d + 3",
                       )
 
     engine.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should ==
@@ -720,8 +720,8 @@ eof
                  "CCC" =>
                  defn("import BBB",
                       "X:",
-                      "  xx = [n.x for n in BBB::D().xs]",
-                      "  yy = [n.x for n in BBB::D.xs]",
+                      "    xx = [n.x for n in BBB::D().xs]",
+                      "    yy = [n.x for n in BBB::D.xs]",
                       ),
                })
 
@@ -732,12 +732,12 @@ eof
 
   it "can eval indexing" do
     engine.parse defn("A:",
-                      "  a = [1,2,3]",
-                      "  b = a[1]",
-                      "  c = a[-1]",
-                      "  d = {'a' : 123, 'b': 456}",
-                      "  e = d['b']",
-                      "  f = a[1,2]",
+                      "    a = [1,2,3]",
+                      "    b = a[1]",
+                      "    c = a[-1]",
+                      "    d = {'a' : 123, 'b': 456}",
+                      "    e = d['b']",
+                      "    f = a[1,2]",
                       )
     r = engine.evaluate_attrs("A", ["b", "c", "e", "f"])
     r.should == [2, 3, 456, [2,3]]
@@ -745,10 +745,10 @@ eof
 
   it "can eval indexing 2" do
     engine.parse defn("A:",
-                      "  a = 1",
-                      "  b = {'x' : 123, 'y': 456}",
-                      "  c = A() % ['a', 'b']",
-                      "  d = c['b'].x * c['a'] - c['b'].y",
+                      "    a = 1",
+                      "    b = {'x' : 123, 'y': 456}",
+                      "    c = A() % ['a', 'b']",
+                      "    d = c['b'].x * c['a'] - c['b'].y",
                       )
     r = engine.evaluate_attrs("A", ["a", "b", "c", "d"])
     r.should ==
@@ -757,14 +757,14 @@ eof
 
   it "should properly eval overridden attrs" do
     engine.parse defn("A:",
-                      "  a = 5",
-                      "  b = a",
+                      "    a = 5",
+                      "    b = a",
                       "B: A",
-                      "  a = 2",
-                      "  x = A.b - B.b",
-                      "  k = [A.b, B.b]",
-                      "  l = [x.b for x in [A, B]]",
-                      "  m = [x().b for x in [A, B]]",
+                      "    a = 2",
+                      "    x = A.b - B.b",
+                      "    k = [A.b, B.b]",
+                      "    l = [x.b for x in [A, B]]",
+                      "    m = [x().b for x in [A, B]]",
                       )
 
     engine.evaluate("A", "b").should == 5