delorean_lang 0.3.29 → 0.3.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96287421d2dcd9466e66523240bc23ec575de758
-  data.tar.gz: 8f4aa577c92a71eee2f86b1e683dcd7ca35aa7a4
+  metadata.gz: 6533974257ae71867de5f7237d671a74c5df653c
+  data.tar.gz: 0be5b0053ac67c03e22b4d79f8ff6ca6699edbfc
 SHA512:
-  metadata.gz: 79f25ccee7e831ea7efaca0b947dd0749f120d150e9aa9177e9b9437a659874d423feaa82911423ac2d317c8db5a185baa6d259eb42dee318b5296f407dff47e
-  data.tar.gz: 0be39ffa9bd46e0aa48a6c97887a27bd225e4d5771c33c25a9f132cfd2fd571ecdfe3a06679a3123ce8dff50d18fe5fdcb729e4a2b9e9c9100c059fce6d7d4ef
+  metadata.gz: 61f051c79ce4219de27151c228ef8f997f6caffe5a30af7f53e7e3ace82e92803b6221a34bd5eb13677a697d63d7ff7e5b12df8da96c32e9979709b02042cb8b
+  data.tar.gz: 6e1e789f69566b2c526b6a7f84da419588963e419664ead313a5cfcad8c9bd8edaf5e56417df46dc6f988e743b83adcd1f6c00401cc623f52dbba1d022565f3c

data/README.md

@@ -29,7 +29,7 @@ Or add it to your `Gemfile`, etc.
     
     engine.parse my_code
     
-    engine.evaluate_attrs("NodeB", %w{attr1 attr2 attr3})
+    engine.evaluate("NodeB", %w{attr1 attr2 attr3})
 
 ## The Delorean Language
 

data/lib/delorean/engine.rb

@@ -346,18 +346,9 @@ module Delorean
     # Runtime
     ######################################################################
 
-    def evaluate(node, attr, params={})
-      evaluate_attrs(node, [attr], params)[0]
-    end
-
-    def eval_to_hash(node, attrs, params={})
-      res = evaluate_attrs(node, attrs, params)
-      Hash[* attrs.zip(res).flatten(1)]
-    end
-
-    def evaluate_attrs(node, attrs, params={})
+    def evaluate(node, attrs, params={})
       raise "bad params" unless params.is_a?(Hash)
-
+      
       if node.is_a?(Class)
         klass = node
       else
@@ -372,10 +363,19 @@ module Delorean
 
       params[:_engine] = self
 
-      attrs.map { |attr|
+      type_arr = attrs.is_a?(Array)
+      attrs = [attrs] unless type_arr
+      
+      res = attrs.map { |attr|
         raise "bad attribute '#{attr}'" unless attr =~ /^[a-z][A-Za-z0-9_]*$/
         klass.send("#{attr}#{POST}".to_sym, params)
       }
+      type_arr ? res : res[0]
+    end
+
+    def eval_to_hash(node, attrs, params={})
+      res = evaluate(node, attrs, params)
+      Hash[* attrs.zip(res).flatten(1)]
     end
 
     def self.grok_runtime_exception(exc)

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.3.29"
+  VERSION = "0.3.30"
 end

data/spec/eval_spec.rb

@@ -25,9 +25,9 @@ describe "Delorean" do
                       "    d = a ** 3 - 10*0.2",
                       )
 
-    engine.evaluate_attrs("A", ["a"]).should == [123]
+    engine.evaluate("A", ["a"]).should == [123]
 
-    r = engine.evaluate_attrs("A", ["x", "b"])
+    r = engine.evaluate("A", ["x", "b"])
     r.should == [-246, -124]
 
     expect(engine.evaluate("A", "d")).to eq 1860865.0
@@ -57,7 +57,7 @@ describe "Delorean" do
                       "    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]
+    engine.evaluate("A", ["b"]).should == [123*456-789]
   end
 
   it "should handle numeric getattr" do
@@ -65,7 +65,7 @@ describe "Delorean" do
                       "    a = {1:123, 0:456, 'z':789, 2: {'a':444}}",
                       "    b = A.a.1 * A.a.0 - A.a.z - A.a.2.a",
                       )
-    engine.evaluate_attrs("A", ["b"]).should == [123*456-789-444]
+    engine.evaluate("A", ["b"]).should == [123*456-789-444]
   end
 
   it "should be able to evaluate multiple node attrs" do
@@ -76,7 +76,7 @@ describe "Delorean" do
                       )
 
     h = {"a" => 16}
-    r = engine.evaluate_attrs("A", ["c", "b"], h)
+    r = engine.evaluate("A", ["c", "b"], h)
     r.should == [4, 5]
   end
 
@@ -117,8 +117,8 @@ describe "Delorean" do
                       "    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]
+    engine.evaluate("B", %w{c a}).should == [1, 2]
+    engine.evaluate("B", %w{a c}).should == [2, 1]
   end
 
   it "params should behave properly with inheritance" do
@@ -131,9 +131,9 @@ describe "Delorean" do
                       "    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]
-    engine.evaluate_attrs("C", %w{c b a}).should == [1, 2, 3]
+    engine.evaluate("C", %w{a b c}).should == [3, 2, 1]
+    engine.evaluate("C", %w{a b c}, {"a" => 4}).should == [4, 4, 4]
+    engine.evaluate("C", %w{c b a}).should == [1, 2, 3]
   end
 
   it "should give error when param is undefined for eval" do
@@ -273,7 +273,7 @@ describe "Delorean" do
                       "    c = Dummy.call_me_maybe()",
                       "    d = Dummy.call_me_maybe(5) + b + c",
                       )
-    r = engine.evaluate_attrs("A", ["b", "c", "d"])
+    r = engine.evaluate("A", ["b", "c", "d"])
     r.should == [10, 0, 15]
   end
 
@@ -326,7 +326,7 @@ describe "Delorean" do
                       "    d = b.b",
                       "    e = b.this_is_crazy",
                       )
-    engine.evaluate_attrs("A", %w{c d e}).should == [456, 789, nil]
+    engine.evaluate("A", %w{c d e}).should == [456, 789, nil]
   end
 
   it "get attr on nil should return nil" do
@@ -335,7 +335,7 @@ describe "Delorean" do
                       '    c = b.gaga',
                       '    d = b.gaga || 55',
                       )
-    r = engine.evaluate_attrs("A", ["b", "c", "d"])
+    r = engine.evaluate("A", ["b", "c", "d"])
     r.should == [nil, nil, 55]
   end
 
@@ -354,7 +354,7 @@ describe "Delorean" do
                       "    b = A",
                       "    c = b.a * 2",
                       )
-    engine.evaluate_attrs("A", %w{a c}).should == [123, 123*2]
+    engine.evaluate("A", %w{a c}).should == [123, 123*2]
   end
 
   getattr_code = <<eoc
@@ -496,11 +496,11 @@ eof
                       "    d = 111",
                       )
 
-    engine.evaluate_attrs("A", ["a", "b"]).should == [123, 123*3]
-    engin2.evaluate_attrs("A", ["a", "b"]).should == [222.0, 222.0/5]
+    engine.evaluate("A", ["a", "b"]).should == [123, 123*3]
+    engin2.evaluate("A", ["a", "b"]).should == [222.0, 222.0/5]
 
-    engine.evaluate_attrs("B", ["a", "b", "c"]).should == [123, 123*3, 123*3*2]
-    engin2.evaluate_attrs("B", ["a", "b", "c"]).should ==
+    engine.evaluate("B", ["a", "b", "c"]).should == [123, 123*3, 123*3*2]
+    engin2.evaluate("B", ["a", "b", "c"]).should ==
       [222.0, 222.0/5, 222.0/5*3]
 
     engin2.evaluate("C", "d").should == 111
@@ -523,7 +523,7 @@ eof
                       "    e = [1, 1+1, 1+1+1, 1*2*4]",
                       )
 
-    engine.evaluate_attrs("A", %w{b c d e}).should ==
+    engine.evaluate("A", %w{b c d e}).should ==
       [[],
        [1, 2, 3],
        [[], [1, 2, 3], [], [1, 2, 3], 1, 2, "123", 1.1, -1.23],
@@ -538,7 +538,7 @@ eof
                       "    d = c*2",
                       )
 
-    engine.evaluate_attrs("A", %w{b c d}).should ==
+    engine.evaluate("A", %w{b c d}).should ==
       [[],
        [1, 2, 3],
        [1, 2, 3]*2,
@@ -551,7 +551,7 @@ eof
                       "    b = {i*5 for i in {1,2,3}}",
                       "    c = {1,2,3} | {4,5}",
                       )
-    engine.evaluate_attrs("A", ["a", "b", "c"]).should ==
+    engine.evaluate("A", ["a", "b", "c"]).should ==
       [Set[], Set[5,10,15], Set[1,2,3,4,5]]
   end
 
@@ -621,7 +621,7 @@ eof
                       "    g = {b:b, [b]:[1,23], []:345}",
                       )
 
-    engine.evaluate_attrs("A", %w{b c d e f g}).should ==
+    engine.evaluate("A", %w{b c d e f g}).should ==
       [{},
        {"a"=>1, "b"=>2, "c"=>3},
        {123*2=>-123, "b_b"=>2},
@@ -682,7 +682,7 @@ eof
                       "    f = e.d / e.a",
                       )
 
-    engine.evaluate_attrs("A", ["d", "f"]).should == [26, 2]
+    engine.evaluate("A", ["d", "f"]).should == [26, 2]
   end
 
   it "should eval multi-var hash comprehension" do
@@ -706,7 +706,7 @@ eof
                       "    j = d(a=6).aa",
                       )
 
-    engine.evaluate_attrs("A", ["g", "h", "j"]).should ==
+    engine.evaluate("A", ["g", "h", "j"]).should ==
       [3*2 + 4*2, 5*2, 6*2]
   end
 
@@ -717,7 +717,7 @@ eof
                       "    e = [d.a, d(a=4).a]",
                       )
 
-    engine.evaluate_attrs("A", ["e"]).should == [[3,4]]
+    engine.evaluate("A", ["e"]).should == [[3,4]]
   end
 
   it "should eval module calls 1" do
@@ -727,7 +727,7 @@ eof
                       "    d = n().a",
                       )
 
-    engine.evaluate_attrs("A", %w{d}).should == [123]
+    engine.evaluate("A", %w{d}).should == [123]
   end
 
   it "should eval module calls 2" do
@@ -740,7 +740,7 @@ eof
                       "    e = nil() % ['b']",
                       )
 
-    engine.evaluate_attrs("A", %w{n c d e}).should ==
+    engine.evaluate("A", %w{n c d e}).should ==
       ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, {"b"=>579}]
   end
 
@@ -752,7 +752,7 @@ eof
                       "    d = n().a",
                       )
 
-    engine.evaluate_attrs("B", %w{d}).should == [123]
+    engine.evaluate("B", %w{d}).should == [123]
   end
 
   it "should be possible to implement recursive calls" do
@@ -796,7 +796,7 @@ eof
                       "         ) % ['b']",
                       )
 
-    engine.evaluate_attrs("A", %w{n c d e}).should ==
+    engine.evaluate("A", %w{n c d e}).should ==
       ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, {"b"=>579}]
   end
 
@@ -809,7 +809,7 @@ eof
                       "    d = [i*2 for i in s if i in a]",
                       )
 
-    engine.evaluate_attrs("A", %w{b c d}).should ==
+    engine.evaluate("A", %w{b c d}).should ==
       [false, true, [66, 88]]
   end
 
@@ -821,7 +821,7 @@ eof
                       "    a = 111",
                       "    c = AAA::X(a=456).b",
                       )
-    engine.evaluate_attrs("B", ["a", "b", "c"], {}).should ==
+    engine.evaluate("B", ["a", "b", "c"], {}).should ==
       [111, 222, 456*2]
   end
 
@@ -846,7 +846,7 @@ eof
 
     e2 = sset.get_engine("BBB")
 
-    e2.evaluate_attrs("B", ["a", "b", "c", "d"]).should ==
+    e2.evaluate("B", ["a", "b", "c", "d"]).should ==
       [111, 222, -2, 222]
 
     engine.parse defn("import BBB",
@@ -854,15 +854,15 @@ eof
                       "    e = d + 3",
                       )
 
-    engine.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should ==
+    engine.evaluate("B", ["a", "b", "c", "d", "e"]).should ==
       [111, 222, -2, 222, 225]
 
     e4 = sset.get_engine("CCC")
 
-    e4.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should ==
+    e4.evaluate("B", ["a", "b", "c", "d", "e"]).should ==
       [111, 222, -2, 222, 666]
 
-    e4.evaluate_attrs("C", ["a", "b", "d"]).should == [123, 123*2, 123*3*2]
+    e4.evaluate("C", ["a", "b", "d"]).should == [123, 123*2, 123*3*2]
   end
 
   it "should eval imports (3)" do
@@ -890,7 +890,7 @@ eof
                       "    e = d['b']",
                       "    f = a[1,2]",
                       )
-    r = engine.evaluate_attrs("A", ["b", "c", "e", "f"])
+    r = engine.evaluate("A", ["b", "c", "e", "f"])
     r.should == [2, 3, 456, [2,3]]
   end
 
@@ -901,7 +901,7 @@ eof
                       "    c = A() % ['a', 'b']",
                       "    d = c['b'].x * c['a'] - c['b'].y",
                       )
-    r = engine.evaluate_attrs("A", ["a", "b", "c", "d"])
+    r = engine.evaluate("A", ["a", "b", "c", "d"])
     r.should ==
       [1, {"x"=>123, "y"=>456}, {"a"=>1, "b"=>{"x"=>123, "y"=>456}}, -333]
   end
@@ -915,15 +915,15 @@ eof
                       "    d = A() / ['a', 'e']",
                       "    f = A() / 'a'",
                       )
-    r = engine.evaluate_attrs("A", ["a", "b", "c"])
+    r = engine.evaluate("A", ["a", "b", "c"])
     r.should ==
       [1, {"x"=>123, "y"=>456}, {"a"=>1, "b"=>{"x"=>123, "y"=>456}}]
 
-    r = engine.evaluate_attrs("A", ["a", "d"])
+    r = engine.evaluate("A", ["a", "d"])
     r.should ==
       [1, {"error"=>"hello", "backtrace"=>[["XXX", 4, "e"], ["XXX", 6, "d"]]}]
 
-    r = engine.evaluate_attrs("A", ["f"])
+    r = engine.evaluate("A", ["f"])
     r.should == [1]
   end
 
@@ -977,7 +977,7 @@ eof
                       "    z = B(10, 20, a=3, b=7).x",
                       "    y = B('x', 'y').y",
                       )
-    engine.evaluate_attrs("A", ["a", "z", "y"], {0 => 123, 1 => 456}).should ==
+    engine.evaluate("A", ["a", "z", "y"], {0 => 123, 1 => 456}).should ==
       [123-456, 40, ["x", "y", nil]]
   end
 

data/spec/func_spec.rb

@@ -31,7 +31,7 @@ describe "Delorean" do
                       "    c = 12.3456.round()",
                       )
 
-    r = engine.evaluate_attrs("A", ["a", "b", "c"])
+    r = engine.evaluate("A", ["a", "b", "c"])
     r.should == [12.35, 12.3, 12]
   end
 
@@ -42,7 +42,7 @@ describe "Delorean" do
                       "    c = '12'.to_f()",
                       )
 
-    r = engine.evaluate_attrs("A", ["a", "b", "c"])
+    r = engine.evaluate("A", ["a", "b", "c"])
     r.should == [12.3456, 12.3456, 12]
   end
 
@@ -54,7 +54,7 @@ describe "Delorean" do
                       "    d = 0.abs()",
                       )
 
-    r = engine.evaluate_attrs("A", ["a", "b", "c", "d"])
+    r = engine.evaluate("A", ["a", "b", "c", "d"])
     r.should == [123, 1.1, 2.3, 0]
   end
 
@@ -65,7 +65,7 @@ describe "Delorean" do
                       "    c = [1,2,3].to_s()",
                       )
 
-    r = engine.evaluate_attrs("A", ["a", "b", "c"])
+    r = engine.evaluate("A", ["a", "b", "c"])
     r.should == ["hello", '12.3456', [1,2,3].to_s]
   end
 
@@ -81,11 +81,11 @@ describe "Delorean" do
 
     p = Time.now
     params = {"p" => p}
-    r = engine.evaluate_attrs("A", %w{h m s d e}, params)
+    r = engine.evaluate("A", %w{h m s d e}, params)
     r.should == [p.hour, p.min, p.sec, p.to_date, p.to_date]
 
     # Non time argument should raise an error
-    expect { engine.evaluate_attrs("A", ["m"], {"p" => 123}) }.to raise_error
+    expect { engine.evaluate("A", ["m"], {"p" => 123}) }.to raise_error
 
   end
 
@@ -98,12 +98,12 @@ describe "Delorean" do
                       )
 
     p = Date.today
-    r = engine.evaluate_attrs("A", ["y", "d", "m"], {"p" => p})
+    r = engine.evaluate("A", ["y", "d", "m"], {"p" => p})
     r.should == [p.year, p.day, p.month]
 
     # Non date argument should raise an error
     expect {
-      engine.evaluate_attrs("A", ["y", "d", "m"], {"p" => 123})
+      engine.evaluate("A", ["y", "d", "m"], {"p" => 123})
     }.to raise_error
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.3.29
+  version: 0.3.30
 platform: ruby
 authors:
 - Arman Bostani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-31 00:00:00.000000000 Z
+date: 2017-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -118,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Delorean compiler