delorean_lang 0.4.2 → 0.4.4

data/lib/delorean/delorean.treetop

@@ -50,7 +50,7 @@ grammar Delorean
     /
     '(' sp? al:kw_args? sp? ')' <NodeCall>
     /
-    '.' sp? i:identifier '(' sp? al:kw_args? sp? ')' <Call>
+    '.' sp? i:identifier '(' sp? al:fn_args? sp? ')' <Call>
     /
     '.' sp? i:(identifier / integer) <GetAttr>
   end
@@ -127,12 +127,22 @@ grammar Delorean
   end
 
   rule hash_args
-    e0:expression sp? ':' sp? e1:expression
+    splat:('**') e0:expression sp?
+    ifexp:('if' sp e3:expression sp?)?
+    args_rest:(sp? ',' sp? al:hash_args?)? <HashArgs>
+    /
+    e0:expression sp? ':' sp? e1:expression sp?
+    ifexp:('if' sp e3:expression sp?)?
     args_rest:(sp? ',' sp? al:hash_args?)? <HashArgs>
   end
 
   rule kw_args
-    k:(i:identifier sp? '=' sp?)? arg0:expression
+    splat:('**') arg0:expression sp?
+    ifexp:('if' sp e3:expression sp?)?
+    args_rest:(sp? ',' sp? al:kw_args?)? <KwArgs>
+    /
+    k:(i:identifier sp? '=' sp?)? arg0:expression sp?
+    ifexp:('if' sp e3:expression sp?)?
     args_rest:(sp? ',' sp? al:kw_args?)? <KwArgs>
   end
 

data/lib/delorean/engine.rb

@@ -27,6 +27,13 @@ module Delorean
       @param_set = Set.new
 
       @imports = {}
+
+      @hcount = 0
+    end
+
+    # used in counting literal hashes
+    def hcount
+      @hcount += 1
     end
 
     def curr_line

data/lib/delorean/nodes.rb

@@ -240,7 +240,7 @@ eos
       raise "String interpolation not supported" if text_value =~ /\#\{.*\}/
 
       # FIXME: syntax check?
-      text_value + ".freeze"
+      text_value
     end
   end
 
@@ -248,7 +248,7 @@ eos
     def rewrite(context)
       # remove the quotes and requote.  We don't want the likes of #{}
       # evals to just pass through.
-      text_value[1..-2].inspect + ".freeze"
+      text_value[1..-2].inspect
     end
   end
 
@@ -314,44 +314,36 @@ eos
 
   class Call < SNode
     def check(context, *)
-      al.check(context) unless al.text_value.empty?
-      []
+      al.text_value.empty? ? [] : al.check(context)
     end
 
     def rewrite(context, vcode)
-      args, kw = al.text_value.empty? ? [[], {}] : al.rewrite(context)
-
-      raise "Keyword arguments not supported" unless
-        kw.empty?
-
-      args_str = args.reverse.join(',')
+      if al.text_value.empty?
+        args_str, arg_count = "", 0
+      else
+        args_str, arg_count = al.rewrite(context), al.arg_count
+      end
 
       if vcode.is_a?(ClassText)
         # ruby class call
         class_name = vcode.text
-        context.parse_check_call_fn(i.text_value, args.count, class_name)
+        context.parse_check_call_fn(i.text_value, arg_count, class_name)
         "#{class_name}.#{i.text_value}(#{args_str})"
       else
         "_instance_call(#{vcode}, '#{i.text_value}', [#{args_str}], _e)"
       end
-
     end
   end
 
   class NodeCall < SNode
     def check(context, *)
-      al.check(context) unless al.text_value.empty?
-      []
+      al.text_value.empty? ? [] : al.check(context)
     end
 
     def rewrite(context, node_name)
-      args, kw = al.text_value.empty? ? [[], {}] : al.rewrite(context)
-
-      kw_str =
-        (kw.map {|k, v| "'#{k}' => #{v}"} +
-         args.reverse.each_with_index.map {|v, i| "#{i} => #{v}"}).join(',')
-
-      "_node_call(#{node_name}, _e, {#{kw_str}})"
+      var = "_h#{context.hcount}"
+      res = al.text_value.empty? ? "" : al.rewrite(context, var)
+      "(#{var}={}; #{res}; _node_call(#{node_name}, _e, #{var}))"
     end
   end
 
@@ -410,7 +402,7 @@ eos
     end
 
     def rewrite(context)
-      "[" + (defined?(args) ? args.rewrite(context) : "") + "].freeze"
+      "[" + (defined?(args) ? args.rewrite(context) : "") + "]"
     end
   end
 
@@ -457,7 +449,7 @@ eos
 
       res += ".select{|#{args_str}|(#{ifexp.e3.rewrite(context)})}" if
         defined?(ifexp.e3)
-      res += ".map{|#{args_str}| (#{e2.rewrite(context)}) }.freeze"
+      res += ".map{|#{args_str}| (#{e2.rewrite(context)}) }"
       unpack_vars.each {|vname| context.parse_undef_var(vname)}
       res
     end
@@ -465,13 +457,13 @@ eos
 
   class SetExpr < ListExpr
     def rewrite(context)
-      "Set#{super}.freeze"
+      "Set#{super}"
     end
   end
 
   class SetComprehension < ListComprehension
     def rewrite(context)
-      "Set[*#{super}].freeze"
+      "Set[*#{super}]"
     end
   end
 
@@ -514,7 +506,7 @@ eos
       unpack_str = unpack_vars.count > 1 ? "(#{args_str})" : args_str
 
       res += ".each_with_object({}){|#{unpack_str}, _h#{hid}| " +
-        "_h#{hid}[#{el.rewrite(context)}]=(#{er.rewrite(context)})}.freeze"
+        "_h#{hid}[#{el.rewrite(context)}]=(#{er.rewrite(context)})}"
 
       unpack_vars.each {|vname| context.parse_undef_var(vname)}
       res
@@ -527,47 +519,61 @@ eos
     end
 
     def rewrite(context)
-      "{#{args.rewrite(context) if defined?(args)}}.freeze"
+      return "{}" unless defined?(args)
+      var = "_h#{context.hcount}"
+      "(#{var}={}; " + args.rewrite(context, var) + "; #{var})"
     end
   end
 
   class KwArgs < SNode
     def check(context, *)
-      arg0.check(context) + (
-        defined?(args_rest.al) && !args_rest.al.empty? ?
-          args_rest.al.check(context) : [])
+      [arg0.check(context),
+       (ifexp.e3.check(context) if defined?(ifexp.e3)),
+       (args_rest.al.check(context) if
+         defined?(args_rest.al) && !args_rest.al.empty?)
+      ].compact.sum
     end
 
-    def rewrite(context)
+    def rewrite(context, var, i=0)
       arg0_rw = arg0.rewrite(context)
 
-      if defined?(args_rest.al) && !args_rest.al.text_value.empty?
-        args, kw = args_rest.al.rewrite(context)
+      if defined?(splat)
+        res = "#{var}.merge!(#{arg0_rw})"
       else
-        args, kw = [], {}
+        k_rw = defined?(k.i) ? "'#{k.i.text_value}'" : i.to_s
+        res = "#{var}[#{k_rw}]=(#{arg0_rw})"
+        i += 1 unless defined?(k.i)
       end
 
-      if defined?(k.i)
-        kw[k.i.text_value] = arg0_rw
-      else
-        args << arg0_rw
-      end
-
-      [args, kw]
+      res += " if (#{ifexp.e3.rewrite(context)})" if defined?(ifexp.e3)
+      res += ";"
+      res += args_rest.al.rewrite(context, var, i) if
+        defined?(args_rest.al) && !args_rest.al.text_value.empty?
+      res
     end
   end
 
   class HashArgs < SNode
     def check(context, *)
-      e0.check(context) + e1.check(context) +
-        (defined?(args_rest.al) && !args_rest.al.empty? ?
-           args_rest.al.check(context) : [])
+      [e0.check(context),
+       (e1.check(context) unless defined?(splat)),
+       (ifexp.e3.check(context) if defined?(ifexp.e3)),
+       (args_rest.al.check(context) if
+         defined?(args_rest.al) && !args_rest.al.empty?),
+      ].compact.sum
     end
 
-    def rewrite(context)
-      e0.rewrite(context) + " => " + e1.rewrite(context) +
-        (defined?(args_rest.al) && !args_rest.al.text_value.empty? ?
-         ", " + args_rest.al.rewrite(context) : "")
+    def rewrite(context, var)
+      if defined?(splat)
+        res = "#{var}.merge!(#{e0.rewrite(context)})"
+      else
+        res = "#{var}[#{e0.rewrite(context)}]=(#{e1.rewrite(context)})"
+      end
+      res += " if (#{ifexp.e3.rewrite(context)})" if defined?(ifexp.e3)
+      res += ";"
+      res += args_rest.al.rewrite(context, var) if
+        defined?(args_rest.al) && !args_rest.al.text_value.empty?
+      res
     end
   end
 end

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.4.2"
+  VERSION = "0.4.4"
 end

data/spec/eval_spec.rb

@@ -587,6 +587,21 @@ eof
       ]
   end
 
+  it "handles literal hashes with conditionals" do
+    engine.parse defn("A:",
+                      "    a = {'a':1 if 123, 'b':'x' if nil}",
+                      "    b = {'a':a if a, 2: a if true, 'c':nil if 2*2}",
+                      "    c = 1>2",
+                      "    d = {1: {1: 2 if b}, 3: 3 if c, 2: {2: 3 if a}}",
+                      )
+
+    engine.evaluate("A", %w{a b d}).should == [
+      {"a"=>1},
+      {"a"=>{"a"=>1}, 2=>{"a"=>1}, "c"=>nil},
+      {1=>{1=>2}, 2=>{2=>3}},
+    ]
+  end
+
   it "should eval hash comprehension" do
     engine.parse defn("A:",
                       "    b = {i*5 :i for i in [1,2,3]}",
@@ -914,12 +929,17 @@ eof
                       "    x = _.a * _.b",
                       "    y = a && _",
                       "    z = (B() + _).x",
+                      "    w = B(**_).x",
+                      "    v = {**_, 'a': 123}",
                       )
 
     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
+    engine.evaluate("A", "w", {"a"=>4, "b"=>5, "c"=>3}).should == -1
+    engine.evaluate("A", "v", {"a"=>4, "b"=>5, "c"=>3}).should == {
+      "a"=>123, "b"=>5, "c"=>3}
   end
 
   it "implements positional args in node calls" do
@@ -955,6 +975,40 @@ eof
     expect(r).to eq 3
   end
 
+  it "node calls with double splats" do
+    engine.parse defn("A:",
+                      "    a =?",
+                      "    b =?",
+                      "    c = a+b",
+                      "    h = {'a': 123}",
+                      "    k = {'b': 456}",
+                      "    x = A(**h, **k).c"
+                     )
+    r = engine.evaluate("A", "x")
+    expect(r).to eq 579
+  end
+
+  it "hash literal with double splats" do
+    engine.parse defn("A:",
+                      "    a =?",
+                      "    b =?",
+                      "    h = {'a': 123, **a}",
+                      "    k = {'b': 456, **h, **a, **b}",
+                      "    l = {**k}",
+                      "    m = {**k, 1:1, 2:2, 3:33}",
+                      "    n = {**k if false, 1:1, 2:2, 3:33}",
+                     )
+    r = engine.evaluate("A", ["h", "k", "l", "m", "n"],
+                        {"a" => {3=>3, 4=>4}, "b" => {5=>5, "a" => "aa"}})
+    expect(r).to eq [
+                   {"a"=>123, 3=>3, 4=>4},
+                   {"b"=>456, "a"=>"aa", 3=>3, 4=>4, 5=>5},
+                   {"b"=>456, "a"=>"aa", 3=>3, 4=>4, 5=>5},
+                   {"b"=>456, "a"=>"aa", 3=>33, 4=>4, 5=>5, 1=>1, 2=>2},
+                   {1=>1, 2=>2, 3=>33},
+                 ]
+  end
+
   it "understands openstructs" do
     engine.parse defn("A:",
                       "    os = Dummy.returns_openstruct",

data/spec/parse_spec.rb

@@ -614,6 +614,13 @@ describe "Delorean" do
     }.should raise_error(Delorean::ParseError)
   end
 
+  it "should be able to parse conditional hash literals" do
+    engine.parse defn("A:",
+                      "    a = {}",
+                      "    c = {'a':a if a, 'b': 2, 'c':-3 if 123}",
+                      )
+  end
+
   it "should handle trailing ',' with hashes" do
     engine.parse defn("A:",
                       "    b = {-1:1,}",
@@ -746,6 +753,26 @@ describe "Delorean" do
                       )
   end
 
+  it "allow conditional args to node calls" do
+    engine.parse defn("A:",
+                      "    d = A(a=1, b=4 if true, c=4 if false)",
+                      )
+  end
+
+  it "allow double splats in node calls" do
+    engine.parse defn("A:",
+                      "    a =?",
+                      "    d = A(**a, **(a+a), a=123, b=456)",
+                      )
+  end
+
+  it "allow double splats in literal hashes" do
+    engine.parse defn("A:",
+                      "    a =?",
+                      "    d = {'a':1, 2:2, **a, **(a+a)}",
+                      )
+  end
+
   it "should parse instance calls" do
     engine.parse defn("A:",
                       "    a = [1,2,[4]].flatten(1)",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - Arman Bostani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-28 00:00:00.000000000 Z
+date: 2018-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop