delorean_lang 0.0.34 → 0.0.38

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Arman Bostani
+Copyright (c) 2012 PennyMac Loan Services
 
 MIT License
 
@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -3,6 +3,8 @@
 Delorean is a simple functional scripting language.  It is used at
 [PENNYMAC][] as a scripting language for a financial modeling system.
 
+![](http://i.imgur.com/qiG7Av6.jpg)
+
 ## Installation
 
     $ gem install delorean_lang
@@ -41,7 +43,7 @@ Or add it to your `Gemfile`, etc.
   deemed too complex for our users. Also, sand-boxing Ruby to prevent
   unauthorized data access did not seem practical.
 
-* Many of the financial models created at [PENNYMAC][] simple
+* Many of the financial models created at [PENNYMAC][] are simple
   modifications of earlier models. It was important for the scripting
   language to provide a simple inheritance model such that major
   parts of these models could be shared.
@@ -58,7 +60,7 @@ definition:
 
     NodeA:
 	    attr1 = 123
-		attr2 = attr1*2
+	    attr2 = attr1*2
 
 In the above example, `NodeA` is a new node definition. This node
 includes two attributes: `attr1` and `attr2`. `attr1` is defined to be
@@ -75,7 +77,7 @@ Delorean attribute definitions have the following form:
 Where `attr` is an attribute name. Attribute names are required to
 match the following regular expression: `[a-z][a-zA-Z0-9_]*`. An
 attribute can only be specified once in a node.  Also, any attributes
-it refers to in its expression must have been defined.
+it refers to in its expression must have been previously defined.
 
 Delorean also provides a mechanism to provide "input" to a
 computation.  This is performed thorough a special kind of attribute
@@ -84,12 +86,12 @@ parameter:
 
     NodeB:
 	    param =? "hello"
-		attr = param + " world"
+	    attr = param + " world"
 
 In this example, `param` is defined as a parameter whose default value
 is `"hello"`, which is a string literal.  If we evaluate `NodeB.attr`
 without providing `param`, the result will be the string `"hello
-word"`.  If the `param` is sent in with the value `"look out"`, then
+world"`.  If the `param` is sent in with the value `"look out"`, then
 `NodeB.attr` will evaluate to `"look out world"`.
 
 The parameter default value is optional.  If no default value if
@@ -112,7 +114,7 @@ nodes.  The following example shows the usage of inheritance:
 		
 In this example, node `USInfo` provides a definition of a
 `is_teenager` when provided with an `age` parameter. Node `IndiaInfo`
-is derived from `USInfo` an so it shares all of its attribute
+is derived from `USInfo` and so it shares all of its attribute
 definitions.  However, the `teen_min` attribute has been overridden.
 This specifies that the computation of `is_teenager` will use the
 newly defined `teen_min`.  Therefore, `IndiaInfo.is_teenager` with

data/delorean.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Delorean::VERSION
 
-  gem.add_dependency "treetop"
+  gem.add_dependency "treetop", "~> 1.4"
   gem.add_dependency "activerecord", "3.2.11"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "sqlite3"

data/lib/delorean/base.rb

@@ -11,7 +11,7 @@ module Delorean
 
       ######################################################################
 
-      def self._get_attr(obj, attr)
+      def self._get_attr(obj, attr, _e)
         return nil if obj.nil?
 
         if obj.kind_of? ActiveRecord::Base
@@ -26,6 +26,8 @@ module Delorean
           raise InvalidGetAttribute, "ActiveRecord lookup '#{attr}' on #{obj}"
         elsif obj.instance_of?(Hash)
           return obj.member?(attr) ? obj[attr] : obj[attr.to_sym]
+        elsif obj.instance_of?(Class) && (obj < BaseClass)
+          return obj.send((attr + POST).to_sym, _e)
         end
 
         raise InvalidGetAttribute, "bad attribute lookup '#{attr}' on #{obj}"
@@ -33,18 +35,28 @@ module Delorean
 
       ######################################################################
 
-      def self._script_call(node_name, mname, _e, attrs, params)
-        context = _e[:_engine]
-        node_name ||= self.name.split('::')[-1]
-
-        engine = mname ? context.get_import_engine(mname) : context
+      def self._index(obj, args, _e)
+        if obj.instance_of?(Hash)
+          raise InvalidIndex unless args.length == 1
+          obj[args[0]]
+        elsif obj.instance_of?(Array)
+          raise InvalidIndex unless args.length < 2
+          raise InvalidIndex unless
+            args[0].is_a?(Fixnum) && (!args[1] || args[1].is_a?(Fixnum))
+          obj[*args]
+        else
+          raise InvalidIndex
+        end
+      end
 
-        res = engine.evaluate_attrs(node_name, attrs, params)
+      ######################################################################
 
-        return res[0] if attrs.length == 1
+      def self._script_call(node, mname, _e, attrs, params)
+        context = _e[:_engine]
+        node ||= self
 
-        # There are more than one attrs, return hash result
-        Hash[* attrs.zip(res).flatten]
+        engine = mname ? context.get_import_engine(mname) : context
+        engine.evaluate_attrs_hash(node, attrs, params)
       end
 
       ######################################################################

data/lib/delorean/const.rb

@@ -0,0 +1,5 @@
+module Delorean
+  SIG = "_SIG"
+  MOD = "DELOREAN__"
+  POST = "__D"
+end

data/lib/delorean/delorean.rb

@@ -329,7 +329,7 @@ module Delorean
           r0 = r16
         else
           i25, s25 = index, []
-          r26 = _nt_node_name
+          r26 = _nt_class_name
           s25 << r26
           if r26
             if has_terminal?(':', false, index)
@@ -350,7 +350,7 @@ module Delorean
               s25 << r28
               if r28
                 i31, s31 = index, []
-                r32 = _nt_node_name
+                r32 = _nt_class_name
                 s31 << r32
                 if r32
                   if has_terminal?('::', false, index)
@@ -376,7 +376,7 @@ module Delorean
                 end
                 s25 << r30
                 if r30
-                  r34 = _nt_node_name
+                  r34 = _nt_class_name
                   s25 << r34
                 end
               end
@@ -393,7 +393,7 @@ module Delorean
             r0 = r25
           else
             i35, s35 = index, []
-            r36 = _nt_node_name
+            r36 = _nt_class_name
             s35 << r36
             if r36
               if has_terminal?(':', false, index)
@@ -428,7 +428,7 @@ module Delorean
                 r40 = _nt_sp
                 s38 << r40
                 if r40
-                  r41 = _nt_node_name
+                  r41 = _nt_class_name
                   s38 << r41
                   if r41
                     r42 = _nt_sp
@@ -464,13 +464,13 @@ module Delorean
     r0
   end
 
-  module NodeName0
+  module ClassName0
   end
 
-  def _nt_node_name
+  def _nt_class_name
     start_index = index
-    if node_cache[:node_name].has_key?(index)
-      cached = node_cache[:node_name][index]
+    if node_cache[:class_name].has_key?(index)
+      cached = node_cache[:class_name][index]
       if cached
         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
@@ -506,13 +506,13 @@ module Delorean
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(NodeName0)
+      r0.extend(ClassName0)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:node_name][start_index] = r0
+    node_cache[:class_name][start_index] = r0
 
     r0
   end
@@ -555,6 +555,17 @@ module Delorean
     end
   end
 
+  module Expression3
+    def v
+      elements[0]
+    end
+
+    def args
+      elements[4]
+    end
+
+  end
+
   def _nt_expression
     start_index = index
     if node_cache[:expression].has_key?(index)
@@ -690,7 +701,7 @@ module Delorean
         r0 = r6
       else
         i23, s23 = index, []
-        r24 = _nt_value
+        r24 = _nt_getattr_exp
         s23 << r24
         if r24
           r26 = _nt_sp
@@ -728,12 +739,77 @@ module Delorean
         if r23
           r0 = r23
         else
-          r31 = _nt_value
+          i31, s31 = index, []
+          r32 = _nt_getattr_exp
+          s31 << r32
+          if r32
+            r34 = _nt_sp
+            if r34
+              r33 = r34
+            else
+              r33 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s31 << r33
+            if r33
+              if has_terminal?('[', false, index)
+                r35 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure('[')
+                r35 = nil
+              end
+              s31 << r35
+              if r35
+                r37 = _nt_sp
+                if r37
+                  r36 = r37
+                else
+                  r36 = instantiate_node(SyntaxNode,input, index...index)
+                end
+                s31 << r36
+                if r36
+                  r38 = _nt_fn_args
+                  s31 << r38
+                  if r38
+                    r40 = _nt_sp
+                    if r40
+                      r39 = r40
+                    else
+                      r39 = instantiate_node(SyntaxNode,input, index...index)
+                    end
+                    s31 << r39
+                    if r39
+                      if has_terminal?(']', false, index)
+                        r41 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                        @index += 1
+                      else
+                        terminal_parse_failure(']')
+                        r41 = nil
+                      end
+                      s31 << r41
+                    end
+                  end
+                end
+              end
+            end
+          end
+          if s31.last
+            r31 = instantiate_node(IndexOp,input, i31...index, s31)
+            r31.extend(Expression3)
+          else
+            @index = i31
+            r31 = nil
+          end
           if r31
             r0 = r31
           else
-            @index = i0
-            r0 = nil
+            r42 = _nt_getattr_exp
+            if r42
+              r0 = r42
+            else
+              @index = i0
+              r0 = nil
+            end
           end
         end
       end
@@ -744,6 +820,81 @@ module Delorean
     r0
   end
 
+  module GetattrExp0
+    def identifier
+      elements[1]
+    end
+  end
+
+  module GetattrExp1
+    def v
+      elements[0]
+    end
+
+    def ga
+      elements[1]
+    end
+  end
+
+  def _nt_getattr_exp
+    start_index = index
+    if node_cache[:getattr_exp].has_key?(index)
+      cached = node_cache[:getattr_exp][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_value
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        if has_terminal?('.', false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('.')
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          r5 = _nt_identifier
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(GetattrExp0)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(ExpGetAttr,input, i0...index, s0)
+      r0.extend(GetattrExp1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:getattr_exp][start_index] = r0
+
+    r0
+  end
+
   module ListExpr0
     def sp
       elements[1]
@@ -1018,6 +1169,56 @@ module Delorean
   end
 
   module HashExpr0
+    def sp
+      elements[1]
+    end
+
+    def ei
+      elements[2]
+    end
+
+  end
+
+  module HashExpr1
+    def el
+      elements[2]
+    end
+
+    def er
+      elements[6]
+    end
+
+    def sp1
+      elements[7]
+    end
+
+    def sp2
+      elements[9]
+    end
+
+    def i
+      elements[10]
+    end
+
+    def sp3
+      elements[11]
+    end
+
+    def sp4
+      elements[13]
+    end
+
+    def e1
+      elements[14]
+    end
+
+    def ifexp
+      elements[16]
+    end
+
+  end
+
+  module HashExpr2
     def args
       elements[2]
     end
@@ -1064,7 +1265,7 @@ module Delorean
         end
         s2 << r4
         if r4
-          r6 = _nt_hash_args
+          r6 = _nt_expression
           s2 << r6
           if r6
             r8 = _nt_sp
@@ -1075,21 +1276,138 @@ module Delorean
             end
             s2 << r7
             if r7
-              if has_terminal?('}', false, index)
+              if has_terminal?(':', false, index)
                 r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
                 @index += 1
               else
-                terminal_parse_failure('}')
+                terminal_parse_failure(':')
                 r9 = nil
               end
               s2 << r9
+              if r9
+                r11 = _nt_sp
+                if r11
+                  r10 = r11
+                else
+                  r10 = instantiate_node(SyntaxNode,input, index...index)
+                end
+                s2 << r10
+                if r10
+                  r12 = _nt_expression
+                  s2 << r12
+                  if r12
+                    r13 = _nt_sp
+                    s2 << r13
+                    if r13
+                      if has_terminal?('for', false, index)
+                        r14 = instantiate_node(SyntaxNode,input, index...(index + 3))
+                        @index += 3
+                      else
+                        terminal_parse_failure('for')
+                        r14 = nil
+                      end
+                      s2 << r14
+                      if r14
+                        r15 = _nt_sp
+                        s2 << r15
+                        if r15
+                          r16 = _nt_identifier
+                          s2 << r16
+                          if r16
+                            r17 = _nt_sp
+                            s2 << r17
+                            if r17
+                              if has_terminal?('in', false, index)
+                                r18 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                                @index += 2
+                              else
+                                terminal_parse_failure('in')
+                                r18 = nil
+                              end
+                              s2 << r18
+                              if r18
+                                r19 = _nt_sp
+                                s2 << r19
+                                if r19
+                                  r20 = _nt_expression
+                                  s2 << r20
+                                  if r20
+                                    r22 = _nt_sp
+                                    if r22
+                                      r21 = r22
+                                    else
+                                      r21 = instantiate_node(SyntaxNode,input, index...index)
+                                    end
+                                    s2 << r21
+                                    if r21
+                                      i24, s24 = index, []
+                                      if has_terminal?('if', false, index)
+                                        r25 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                                        @index += 2
+                                      else
+                                        terminal_parse_failure('if')
+                                        r25 = nil
+                                      end
+                                      s24 << r25
+                                      if r25
+                                        r26 = _nt_sp
+                                        s24 << r26
+                                        if r26
+                                          r27 = _nt_expression
+                                          s24 << r27
+                                          if r27
+                                            r29 = _nt_sp
+                                            if r29
+                                              r28 = r29
+                                            else
+                                              r28 = instantiate_node(SyntaxNode,input, index...index)
+                                            end
+                                            s24 << r28
+                                          end
+                                        end
+                                      end
+                                      if s24.last
+                                        r24 = instantiate_node(SyntaxNode,input, i24...index, s24)
+                                        r24.extend(HashExpr0)
+                                      else
+                                        @index = i24
+                                        r24 = nil
+                                      end
+                                      if r24
+                                        r23 = r24
+                                      else
+                                        r23 = instantiate_node(SyntaxNode,input, index...index)
+                                      end
+                                      s2 << r23
+                                      if r23
+                                        if has_terminal?('}', false, index)
+                                          r30 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                                          @index += 1
+                                        else
+                                          terminal_parse_failure('}')
+                                          r30 = nil
+                                        end
+                                        s2 << r30
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
             end
           end
         end
       end
       if s2.last
-        r2 = instantiate_node(HashExpr,input, i2...index, s2)
-        r2.extend(HashExpr0)
+        r2 = instantiate_node(HashComprehension,input, i2...index, s2)
+        r2.extend(HashExpr1)
       else
         @index = i2
         r2 = nil
@@ -1097,8 +1415,60 @@ module Delorean
       if r2
         r0 = r2
       else
-        @index = i0
-        r0 = nil
+        i31, s31 = index, []
+        if has_terminal?('{', false, index)
+          r32 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('{')
+          r32 = nil
+        end
+        s31 << r32
+        if r32
+          r34 = _nt_sp
+          if r34
+            r33 = r34
+          else
+            r33 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s31 << r33
+          if r33
+            r35 = _nt_hash_args
+            s31 << r35
+            if r35
+              r37 = _nt_sp
+              if r37
+                r36 = r37
+              else
+                r36 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s31 << r36
+              if r36
+                if has_terminal?('}', false, index)
+                  r38 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure('}')
+                  r38 = nil
+                end
+                s31 << r38
+              end
+            end
+          end
+        end
+        if s31.last
+          r31 = instantiate_node(HashExpr,input, i31...index, s31)
+          r31.extend(HashExpr2)
+        else
+          @index = i31
+          r31 = nil
+        end
+        if r31
+          r0 = r31
+        else
+          @index = i0
+          r0 = nil
+        end
       end
     end
 
@@ -1313,6 +1683,23 @@ module Delorean
   end
 
   module Value0
+    def m
+      elements[0]
+    end
+
+  end
+
+  module Value1
+    def mod
+      elements[0]
+    end
+
+    def c
+      elements[1]
+    end
+  end
+
+  module Value2
     def e
       elements[2]
     end
@@ -1355,84 +1742,116 @@ module Delorean
               if r6
                 r0 = r6
               else
-                r7 = _nt_model_fn_getattr
+                r7 = _nt_model_fn
                 if r7
                   r0 = r7
                 else
-                  r8 = _nt_model_fn
+                  r8 = _nt_identifier
                   if r8
                     r0 = r8
                   else
-                    r9 = _nt_node_getattr
+                    r9 = _nt_list_expr
                     if r9
                       r0 = r9
                     else
-                      r10 = _nt_getattr
+                      r10 = _nt_hash_expr
                       if r10
                         r0 = r10
                       else
-                        r11 = _nt_list_expr
+                        i11, s11 = index, []
+                        i13, s13 = index, []
+                        r14 = _nt_class_name
+                        s13 << r14
+                        if r14
+                          if has_terminal?('::', false, index)
+                            r15 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                            @index += 2
+                          else
+                            terminal_parse_failure('::')
+                            r15 = nil
+                          end
+                          s13 << r15
+                        end
+                        if s13.last
+                          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+                          r13.extend(Value0)
+                        else
+                          @index = i13
+                          r13 = nil
+                        end
+                        if r13
+                          r12 = r13
+                        else
+                          r12 = instantiate_node(SyntaxNode,input, index...index)
+                        end
+                        s11 << r12
+                        if r12
+                          r16 = _nt_class_name
+                          s11 << r16
+                        end
+                        if s11.last
+                          r11 = instantiate_node(NodeAsValue,input, i11...index, s11)
+                          r11.extend(Value1)
+                        else
+                          @index = i11
+                          r11 = nil
+                        end
                         if r11
                           r0 = r11
                         else
-                          r12 = _nt_hash_expr
-                          if r12
-                            r0 = r12
+                          i17, s17 = index, []
+                          if has_terminal?('(', false, index)
+                            r18 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                            @index += 1
                           else
-                            i13, s13 = index, []
-                            if has_terminal?('(', false, index)
-                              r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                              @index += 1
+                            terminal_parse_failure('(')
+                            r18 = nil
+                          end
+                          s17 << r18
+                          if r18
+                            r20 = _nt_sp
+                            if r20
+                              r19 = r20
                             else
-                              terminal_parse_failure('(')
-                              r14 = nil
+                              r19 = instantiate_node(SyntaxNode,input, index...index)
                             end
-                            s13 << r14
-                            if r14
-                              r16 = _nt_sp
-                              if r16
-                                r15 = r16
-                              else
-                                r15 = instantiate_node(SyntaxNode,input, index...index)
-                              end
-                              s13 << r15
-                              if r15
-                                r17 = _nt_expression
-                                s13 << r17
-                                if r17
-                                  r19 = _nt_sp
-                                  if r19
-                                    r18 = r19
+                            s17 << r19
+                            if r19
+                              r21 = _nt_expression
+                              s17 << r21
+                              if r21
+                                r23 = _nt_sp
+                                if r23
+                                  r22 = r23
+                                else
+                                  r22 = instantiate_node(SyntaxNode,input, index...index)
+                                end
+                                s17 << r22
+                                if r22
+                                  if has_terminal?(')', false, index)
+                                    r24 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                                    @index += 1
                                   else
-                                    r18 = instantiate_node(SyntaxNode,input, index...index)
-                                  end
-                                  s13 << r18
-                                  if r18
-                                    if has_terminal?(')', false, index)
-                                      r20 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                                      @index += 1
-                                    else
-                                      terminal_parse_failure(')')
-                                      r20 = nil
-                                    end
-                                    s13 << r20
+                                    terminal_parse_failure(')')
+                                    r24 = nil
                                   end
+                                  s17 << r24
                                 end
                               end
                             end
-                            if s13.last
-                              r13 = instantiate_node(Expr,input, i13...index, s13)
-                              r13.extend(Value0)
-                            else
-                              @index = i13
-                              r13 = nil
-                            end
-                            if r13
-                              r0 = r13
-                            else
-                              @index = i0
-                              r0 = nil
-                            end
+                          end
+                          if s17.last
+                            r17 = instantiate_node(Expr,input, i17...index, s17)
+                            r17.extend(Value2)
+                          else
+                            @index = i17
+                            r17 = nil
+                          end
+                          if r17
+                            r0 = r17
+                          else
+                            @index = i0
+                            r0 = nil
                           end
                         end
                       end
@@ -1456,13 +1875,6 @@ module Delorean
       elements[0]
     end
 
-  end
-
-  module Fn1
-    def fn
-      elements[0]
-    end
-
     def args
       elements[3]
     end
@@ -1480,107 +1892,62 @@ module Delorean
       return cached
     end
 
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_fn_name
-    s1 << r2
-    if r2
+    i0, s0 = index, []
+    r1 = _nt_fn_name
+    s0 << r1
+    if r1
       if has_terminal?('(', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
         @index += 1
       else
         terminal_parse_failure('(')
-        r3 = nil
+        r2 = nil
       end
-      s1 << r3
-      if r3
-        r5 = _nt_sp
-        if r5
-          r4 = r5
-        else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
-        end
-        s1 << r4
+      s0 << r2
+      if r2
+        r4 = _nt_sp
         if r4
-          if has_terminal?(')', false, index)
-            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure(')')
-            r6 = nil
-          end
-          s1 << r6
-        end
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(Fn,input, i1...index, s1)
-      r1.extend(Fn0)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      i7, s7 = index, []
-      r8 = _nt_fn_name
-      s7 << r8
-      if r8
-        if has_terminal?('(', false, index)
-          r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
+          r3 = r4
         else
-          terminal_parse_failure('(')
-          r9 = nil
+          r3 = instantiate_node(SyntaxNode,input, index...index)
         end
-        s7 << r9
-        if r9
-          r11 = _nt_sp
-          if r11
-            r10 = r11
+        s0 << r3
+        if r3
+          r6 = _nt_fn_args
+          if r6
+            r5 = r6
           else
-            r10 = instantiate_node(SyntaxNode,input, index...index)
+            r5 = instantiate_node(SyntaxNode,input, index...index)
           end
-          s7 << r10
-          if r10
-            r12 = _nt_fn_args
-            s7 << r12
-            if r12
-              r14 = _nt_sp
-              if r14
-                r13 = r14
+          s0 << r5
+          if r5
+            r8 = _nt_sp
+            if r8
+              r7 = r8
+            else
+              r7 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s0 << r7
+            if r7
+              if has_terminal?(')', false, index)
+                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
               else
-                r13 = instantiate_node(SyntaxNode,input, index...index)
-              end
-              s7 << r13
-              if r13
-                if has_terminal?(')', false, index)
-                  r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                  @index += 1
-                else
-                  terminal_parse_failure(')')
-                  r15 = nil
-                end
-                s7 << r15
+                terminal_parse_failure(')')
+                r9 = nil
               end
+              s0 << r9
             end
           end
         end
       end
-      if s7.last
-        r7 = instantiate_node(Fn,input, i7...index, s7)
-        r7.extend(Fn1)
-      else
-        @index = i7
-        r7 = nil
-      end
-      if r7
-        r0 = r7
-      else
-        @index = i0
-        r0 = nil
-      end
+    end
+    if s0.last
+      r0 = instantiate_node(Fn,input, i0...index, s0)
+      r0.extend(Fn0)
+    else
+      @index = i0
+      r0 = nil
     end
 
     node_cache[:fn][start_index] = r0
@@ -1856,13 +2223,16 @@ module Delorean
   end
 
   module ModelName0
+    def model_name
+      elements[1]
+    end
+  end
+
+  module ModelName1
     def class_name
       elements[0]
     end
 
-    def model_name
-      elements[2]
-    end
   end
 
   def _nt_model_name
@@ -1876,41 +2246,43 @@ module Delorean
       return cached
     end
 
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_class_name
-    s1 << r2
-    if r2
+    i0, s0 = index, []
+    r1 = _nt_class_name
+    s0 << r1
+    if r1
+      i3, s3 = index, []
       if has_terminal?('::', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
         @index += 2
       else
         terminal_parse_failure('::')
+        r4 = nil
+      end
+      s3 << r4
+      if r4
+        r5 = _nt_model_name
+        s3 << r5
+      end
+      if s3.last
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        r3.extend(ModelName0)
+      else
+        @index = i3
         r3 = nil
       end
-      s1 << r3
       if r3
-        r4 = _nt_model_name
-        s1 << r4
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
       end
+      s0 << r2
     end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(ModelName0)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(ModelName1)
     else
-      r5 = _nt_class_name
-      if r5
-        r0 = r5
-      else
-        @index = i0
-        r0 = nil
-      end
+      @index = i0
+      r0 = nil
     end
 
     node_cache[:model_name][start_index] = r0
@@ -1971,59 +2343,6 @@ module Delorean
     r0
   end
 
-  module ClassName0
-  end
-
-  def _nt_class_name
-    start_index = index
-    if node_cache[:class_name].has_key?(index)
-      cached = node_cache[:class_name][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    if has_terminal?('\G[A-Z]', true, index)
-      r1 = true
-      @index += 1
-    else
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        if has_terminal?('\G[a-zA-Z0-9]', true, index)
-          r3 = true
-          @index += 1
-        else
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
-      end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(ClassName0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:class_name][start_index] = r0
-
-    r0
-  end
-
   module ScriptCall0
     def m
       elements[0]
@@ -2080,7 +2399,7 @@ module Delorean
     s1 << r2
     if r2
       i4, s4 = index, []
-      r5 = _nt_node_name
+      r5 = _nt_class_name
       s4 << r5
       if r5
         if has_terminal?('::', false, index)
@@ -2509,171 +2828,6 @@ module Delorean
     r0
   end
 
-  module NodeGetattr0
-    def n
-      elements[0]
-    end
-
-    def i
-      elements[2]
-    end
-  end
-
-  def _nt_node_getattr
-    start_index = index
-    if node_cache[:node_getattr].has_key?(index)
-      cached = node_cache[:node_getattr][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    r1 = _nt_node_name
-    s0 << r1
-    if r1
-      if has_terminal?('.', false, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('.')
-        r2 = nil
-      end
-      s0 << r2
-      if r2
-        r3 = _nt_identifier
-        s0 << r3
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(NodeGetAttr,input, i0...index, s0)
-      r0.extend(NodeGetattr0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:node_getattr][start_index] = r0
-
-    r0
-  end
-
-  module ModelFnGetattr0
-    def mfn
-      elements[0]
-    end
-
-    def i
-      elements[2]
-    end
-  end
-
-  def _nt_model_fn_getattr
-    start_index = index
-    if node_cache[:model_fn_getattr].has_key?(index)
-      cached = node_cache[:model_fn_getattr][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    r1 = _nt_model_fn
-    s0 << r1
-    if r1
-      if has_terminal?('.', false, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('.')
-        r2 = nil
-      end
-      s0 << r2
-      if r2
-        r3 = _nt_identifier
-        s0 << r3
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(ModelFnGetAttr,input, i0...index, s0)
-      r0.extend(ModelFnGetattr0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:model_fn_getattr][start_index] = r0
-
-    r0
-  end
-
-  module Getattr0
-    def i
-      elements[0]
-    end
-
-    def ga
-      elements[2]
-    end
-  end
-
-  def _nt_getattr
-    start_index = index
-    if node_cache[:getattr].has_key?(index)
-      cached = node_cache[:getattr][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_identifier
-    s1 << r2
-    if r2
-      if has_terminal?('.', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('.')
-        r3 = nil
-      end
-      s1 << r3
-      if r3
-        r4 = _nt_getattr
-        s1 << r4
-      end
-    end
-    if s1.last
-      r1 = instantiate_node(GetAttr,input, i1...index, s1)
-      r1.extend(Getattr0)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      r5 = _nt_identifier
-      if r5
-        r0 = r5
-      else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:getattr][start_index] = r0
-
-    r0
-  end
-
   def _nt_number
     start_index = index
     if node_cache[:number].has_key?(index)