delorean_lang 0.3.1 → 0.3.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjVkZjgyMDRiZjAyZmRlOGQxYjhhZmNmZTQyNTQ4M2VkNDlhZTg0OA==
+    ZDc1Y2Y0NzUxOGNkMzlmNmE2Y2M5OGM3YjBiOGNiNjBjZTM5OTY1Ng==
   data.tar.gz: !binary |-
-    MTBlZDY5YzkxYWExMWM1MzMwM2UzNjU1ZjFkNzg4ODhmYmUxMDZkNg==
+    ZDgxMGNiOTM4NDhhM2Q3NDM0ZWQ4NjU3NDIzMDc4NzNlNDE4YzUxZg==
 SHA512:
   metadata.gz: !binary |-
-    ZWYzNTQ3ZmY3NzhjMDU1NTc3ZGE1ZDQ5ZGJmNTUwMjBkOWZjNjBkMDIyYTcw
-    MGFmZTQ2ZWQwMWQ4NmJiM2ZhMTBjOWNlMGFkNjZkN2NjZmMwNzIzNDE4MTAz
-    ODEyYzg2YzY1MzI4Y2Q2MGY5ZmU1M2JjYzEwZTQ4NDU1ZjgxODc=
+    MjM0ODI5NmY0NmU4MGE1YWQ5ZmVlMDFkNThmYzdiNGQxNjJmZmE3OGZiNzNl
+    NmRlYzQwZTcyZjNmOThlNTExNDNmZmRiZmQ1MTMyNWFlODMzOTk2NjQzYWNi
+    ZDNjNmNlYzlmNzk5ZTU0Nzk4Y2Q5YzYwNmEzOWFlOWQyYWI0ODk=
   data.tar.gz: !binary |-
-    YzRmOGIyOGI3NWNlZGY4MmIzN2FmZTlkMjhlYWU2ZjdiNzEwY2MzOTM1YTYx
-    NjliNGYwMDE3Y2IyZWMwOTM2NWI1MjA0OTliMzc0ZGE3ZDVhNDM1YmQ0MDVi
-    ODk0MjA0YTFmZDZkMjFhM2EwZGM4YTM0ZmEyMGRiOWIyNzNmZjQ=
+    NGQwM2M5YWU2MTAwNTlhNGE0ZmU4YjI4NmU5OWE4OTkwNjk0MGRlYTVhZGUz
+    ZDQ3ZTFlNjQ1OTU1MWExZDM0YjI0ZDRiZmMzMzFmNzkwNGM1YThhMjg2MmEz
+    NjZjMjAxZmM1ZmIwNjBjMjY0ZDAyMTc5NTk3ZGFlMzE0MzZlZmU=

data/lib/delorean/base.rb

@@ -69,7 +69,9 @@ module Delorean
     class NodeCall < Struct.new(:_e, :engine, :node, :params)
       def evaluate(attr)
         # FIXME: evaluate() modifies params! => need to clone it.
-        # This is pretty awful.
+        # This is pretty awful.  NOTE: can't sanitize params as Marty
+        # patches NodeCall and modifies params to send _parent_id.
+        # This whole thing needs to be redone.
         engine.evaluate(node, attr, params.clone)
       end
 
@@ -77,7 +79,7 @@ module Delorean
         raise "bad arg to %" unless args.is_a?(Array)
 
         # FIXME: params.clone!!!!
-        engine.evaluate_attrs_hash(node, args, params.clone)
+        engine.eval_to_hash(node, args, params.clone)
       end
 
       # add new arguments, results in a new NodeCall
@@ -86,6 +88,10 @@ module Delorean
 
         NodeCall.new(_e, engine, node, params.merge(args))
       end
+
+      def sanitized_params
+        BaseClass._sanitize_hash(params)
+      end
     end
 
     class BaseClass
@@ -147,6 +153,15 @@ module Delorean
 
       ######################################################################
 
+      def self._sanitize_hash(_e)
+        _e.each_with_object({}) do
+          |(k,v), h|
+          h[k] = v if k =~ /\A[a-z][A-Za-z0-9_]*\z/
+        end
+      end
+
+      ######################################################################
+
       def self._err(*args)
         str = args.map(&:to_s).join(", ")
         raise str

data/lib/delorean/delorean.rb

@@ -2308,112 +2308,117 @@ module Delorean
             if r5
               r0 = r5
             else
-              r6 = _nt_list_expr
+              r6 = _nt_self
               if r6
                 r0 = r6
               else
-                r7 = _nt_set_expr
+                r7 = _nt_list_expr
                 if r7
                   r0 = r7
                 else
-                  r8 = _nt_hash_expr
+                  r8 = _nt_set_expr
                   if r8
                     r0 = r8
                   else
-                    i9, s9 = index, []
-                    i11, s11 = index, []
-                    r12 = _nt_class_name
-                    s11 << r12
-                    if r12
-                      if has_terminal?('::', false, index)
-                        r13 = instantiate_node(SyntaxNode,input, index...(index + 2))
-                        @index += 2
-                      else
-                        terminal_parse_failure('::')
-                        r13 = nil
-                      end
-                      s11 << r13
-                    end
-                    if s11.last
-                      r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-                      r11.extend(Value0)
-                    else
-                      @index = i11
-                      r11 = nil
-                    end
-                    if r11
-                      r10 = r11
-                    else
-                      r10 = instantiate_node(SyntaxNode,input, index...index)
-                    end
-                    s9 << r10
-                    if r10
-                      r14 = _nt_class_name
-                      s9 << r14
-                    end
-                    if s9.last
-                      r9 = instantiate_node(NodeAsValue,input, i9...index, s9)
-                      r9.extend(Value1)
-                    else
-                      @index = i9
-                      r9 = nil
-                    end
+                    r9 = _nt_hash_expr
                     if r9
                       r0 = r9
                     else
-                      i15, s15 = index, []
-                      if has_terminal?('(', false, index)
-                        r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                        @index += 1
+                      i10, s10 = index, []
+                      i12, s12 = index, []
+                      r13 = _nt_class_name
+                      s12 << r13
+                      if r13
+                        if has_terminal?('::', false, index)
+                          r14 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                          @index += 2
+                        else
+                          terminal_parse_failure('::')
+                          r14 = nil
+                        end
+                        s12 << r14
+                      end
+                      if s12.last
+                        r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+                        r12.extend(Value0)
+                      else
+                        @index = i12
+                        r12 = nil
+                      end
+                      if r12
+                        r11 = r12
+                      else
+                        r11 = instantiate_node(SyntaxNode,input, index...index)
+                      end
+                      s10 << r11
+                      if r11
+                        r15 = _nt_class_name
+                        s10 << r15
+                      end
+                      if s10.last
+                        r10 = instantiate_node(NodeAsValue,input, i10...index, s10)
+                        r10.extend(Value1)
                       else
-                        terminal_parse_failure('(')
-                        r16 = nil
+                        @index = i10
+                        r10 = nil
                       end
-                      s15 << r16
-                      if r16
-                        r18 = _nt_sp
-                        if r18
-                          r17 = r18
+                      if r10
+                        r0 = r10
+                      else
+                        i16, s16 = index, []
+                        if has_terminal?('(', false, index)
+                          r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                          @index += 1
                         else
-                          r17 = instantiate_node(SyntaxNode,input, index...index)
+                          terminal_parse_failure('(')
+                          r17 = nil
                         end
-                        s15 << r17
+                        s16 << r17
                         if r17
-                          r19 = _nt_expression
-                          s15 << r19
+                          r19 = _nt_sp
                           if r19
-                            r21 = _nt_sp
-                            if r21
-                              r20 = r21
-                            else
-                              r20 = instantiate_node(SyntaxNode,input, index...index)
-                            end
-                            s15 << r20
+                            r18 = r19
+                          else
+                            r18 = instantiate_node(SyntaxNode,input, index...index)
+                          end
+                          s16 << r18
+                          if r18
+                            r20 = _nt_expression
+                            s16 << r20
                             if r20
-                              if has_terminal?(')', false, index)
-                                r22 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                                @index += 1
+                              r22 = _nt_sp
+                              if r22
+                                r21 = r22
                               else
-                                terminal_parse_failure(')')
-                                r22 = nil
+                                r21 = instantiate_node(SyntaxNode,input, index...index)
+                              end
+                              s16 << r21
+                              if r21
+                                if has_terminal?(')', false, index)
+                                  r23 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                                  @index += 1
+                                else
+                                  terminal_parse_failure(')')
+                                  r23 = nil
+                                end
+                                s16 << r23
                               end
-                              s15 << r22
                             end
                           end
                         end
-                      end
-                      if s15.last
-                        r15 = instantiate_node(Expr,input, i15...index, s15)
-                        r15.extend(Value2)
-                      else
-                        @index = i15
-                        r15 = nil
-                      end
-                      if r15
-                        r0 = r15
-                      else
-                        @index = i0
-                        r0 = nil
+                        if s16.last
+                          r16 = instantiate_node(Expr,input, i16...index, s16)
+                          r16.extend(Value2)
+                        else
+                          @index = i16
+                          r16 = nil
+                        end
+                        if r16
+                          r0 = r16
+                        else
+                          @index = i0
+                          r0 = nil
+                        end
                       end
                     end
                   end
@@ -3049,6 +3054,30 @@ module Delorean
     r0
   end
 
+  def _nt_self
+    start_index = index
+    if node_cache[:self].has_key?(index)
+      cached = node_cache[:self][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(Self,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('_')
+      r0 = nil
+    end
+
+    node_cache[:self][start_index] = r0
+
+    r0
+  end
+
   def _nt_nil_val
     start_index = index
     if node_cache[:nil_val].has_key?(index)

data/lib/delorean/delorean.treetop

@@ -105,6 +105,7 @@ grammar Delorean
     boolean                                             /
     nil_val                                             /
     identifier                                          /
+    self                                                /
     list_expr                                           /
     set_expr                                            /
     hash_expr                                           /
@@ -144,6 +145,10 @@ grammar Delorean
     'true' <Literal> / 'false' <Literal>
   end
 
+  rule self
+    '_' <Self>
+  end
+
   rule nil_val
     'nil' <Literal>
   end

data/lib/delorean/engine.rb

@@ -343,7 +343,7 @@ module Delorean
       evaluate_attrs(node, [attr], params)[0]
     end
 
-    def evaluate_attrs_hash(node, attrs, params={})
+    def eval_to_hash(node, attrs, params={})
       res = evaluate_attrs(node, attrs, params)
       Hash[* attrs.zip(res).flatten(1)]
     end

data/lib/delorean/nodes.rb

@@ -202,6 +202,17 @@ eos
     end
   end
 
+  # _ is self -- a naive implementation of "self" for now.
+  class Self < SNode
+    def check(context, *)
+      []
+    end
+
+    def rewrite(context)
+      "_sanitize_hash(_e)"
+    end
+  end
+
   class DString < Literal
     def rewrite(context)
       # remove the quotes and requote.  We don't want the likes of #{}

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/spec/eval_spec.rb

@@ -244,7 +244,7 @@ describe "Delorean" do
     }.should raise_error(Delorean::InvalidGetAttribute)
   end
 
-  it "should be able to get attr on ActiveRecord objects using Class.method().attr syntax" do
+  it "should be able to get attr on AR objs using Class.method().attr syntax" do
     engine.parse defn("A:",
                       '    b = Dummy.i_just_met_you("CRJ", 1.234).name',
                       )
@@ -252,7 +252,7 @@ describe "Delorean" do
     r.should == "CRJ"
   end
 
-  it "should be able to access ActiveRecord whitelisted fns using .attr syntax" do
+  it "should be able to access ActiveRecord whitelisted fns using .x syntax" do
     engine.parse defn("A:",
                       '    b = Dummy.i_just_met_you("CRJ", 1.234).name2',
                       )
@@ -809,4 +809,22 @@ eof
     engine.evaluate("B", "m").should == [5, 2]
   end
 
+  it "implements simple version of self (_)" do
+    engine.parse defn("B:",
+                      "    a =?",
+                      "    b =?",
+                      "    x = a - b",
+                      "A:",
+                      "    a =?",
+                      "    b =?",
+                      "    x = _.a * _.b",
+                      "    y = a && _",
+                      "    z = (B() + _).x",
+                      )
+
+    engine.evaluate("A", "x", {"a"=>3, "b"=>5}).should == 15
+    h = {"a"=>1, "b"=>2, "c"=>3}
+    engine.evaluate("A", "y", {"a"=>1, "b"=>2, "c"=>3}).should == h
+    engine.evaluate("A", "z", {"a"=>1, "b"=>2, "c"=>3}).should == -1
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Arman Bostani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-05 00:00:00.000000000 Z
+date: 2014-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop