delorean_lang 0.0.34 → 0.0.38

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.0.34"
+  VERSION = "0.0.38"
 end

data/spec/dev_spec.rb

@@ -50,11 +50,10 @@ describe "Delorean" do
                       "  c =?",
                       "  d = 456",
                       )
-    engine.enumerate_attrs_by_node("X").should == { "X"=>["a", "b"] }
-    engine.enumerate_attrs_by_node("Y").should == { "Y"=>["a", "b"] }
-    engine.enumerate_attrs_by_node("Z").should == { "Z"=>[] }
-    engine.enumerate_attrs_by_node("XX").should == { "XX"=>["a", "c", "d", "b"] }
-    engine.enumerate_attrs_by_node("UNK").should == { }
+    engine.enumerate_attrs_by_node("X").should == ["a", "b"]
+    engine.enumerate_attrs_by_node("Y").should == ["a", "b"]
+    engine.enumerate_attrs_by_node("Z").should == []
+    engine.enumerate_attrs_by_node("XX").should == ["a", "c", "d", "b"]
   end
 
   it "can enumerate params" do
@@ -93,6 +92,5 @@ describe "Delorean" do
     engine.enumerate_params_by_node("XX").should == Set.new(["a", "c"])
     engine.enumerate_params_by_node("YY").should == Set.new(["a", "c", "e"])
     engine.enumerate_params_by_node("Z").should == Set.new([])
-    engine.enumerate_params_by_node("UNK").should == Set.new([])
   end
 end

data/spec/eval_spec.rb

@@ -40,6 +40,14 @@ describe "Delorean" do
     r.should == -122
   end
 
+  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",
+                      )
+    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",
@@ -270,6 +278,33 @@ describe "Delorean" do
     r.name.should == "hello"
   end
 
+  it "should be able to get attr on node" do
+    engine.parse defn("A:",
+                      "  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
+B:
+	x = 2
+C:
+	x = 3
+D:
+	xs = [A, B, C]
+E:
+	xx = [n.x for n in D.xs]
+eoc
+
+  it "should be able to get attr on node 2" do
+    engine.parse getattr_code
+    engine.evaluate("E", "xx").should == [1,2,3]
+  end
+
   it "should be able to call class methods on ActiveRecord classes in modules" do
     engine.parse defn("A:",
                       "  b = M::LittleDummy.heres_my_number(867, 5309)",
@@ -472,8 +507,10 @@ eof
   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]",
                       )
     engine.evaluate("A", "b").should == [5, 15, 25]
+    engine.evaluate("A", "c").should == [0.5]
   end
 
   it "should eval hashes" do
@@ -496,7 +533,41 @@ eof
       ]
   end
 
-  it "should eval module calls" do
+  it "should eval hash comprehension" do
+    engine.parse defn("A:",
+                      "  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]}",
+                      )
+    engine.evaluate("A", "b").should ==
+      {1=>{5=>-3, 6=>-4}, 2=>{6=>-2, 7=>-3}, 3=>{7=>-1, 8=>-2}}
+  end
+
+  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}",
+                      )
+    engine.evaluate("A", "b").should == {5=>6, 15=>8, 25=>10}
+    engine.evaluate("A", "c").should == {0.5=>50}
+  end
+
+  it "should eval module calls 1" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  n = A",
+                      "  d = @n('a')",
+                      )
+
+    engine.evaluate_attrs("A", %w{d}).should == [{"a" => 123}]
+  end
+
+  it "should eval module calls 2" do
     engine.parse defn("A:",
                       "  a = 123",
                       "  b = 456 + a",
@@ -507,16 +578,16 @@ eof
                       )
 
     engine.evaluate_attrs("A", %w{n c d e}).should ==
-      ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, 579]
+      ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, {"b"=>579}]
   end
 
   it "should be possible to implement recursive calls" do
     engine.parse defn("A:",
                       "  n =?",
-                      "  factorial = if n <= 1 then 1 else n * @('factorial', n: n-1)",
+                      "  fact = if n <= 1 then 1 else n * @('fact', n: n-1).fact",
                       )
     
-    engine.evaluate("A", "factorial", "n" => 10).should == 3628800
+    engine.evaluate("A", "fact", "n" => 10).should == 3628800
   end
 
   it "should eval module calls by node name" do
@@ -524,7 +595,7 @@ eof
                       "  a = 123",
                       "  b = @A('a')",
                       )
-    engine.evaluate("A", "b").should == 123
+    engine.evaluate("A", "b").should == {"a"=>123}
   end
 
   it "should eval multiline expressions" do
@@ -556,7 +627,7 @@ eof
                       )
 
     engine.evaluate_attrs("A", %w{n c d e}).should ==
-      ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, 579]
+      ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, {"b"=>579}]
   end
 
   it "should eval imports" do
@@ -567,7 +638,8 @@ eof
                       "  a = 111",
                       "  c = @AAA::X('b', a: 456)",
                       ), sset
-    engine.evaluate_attrs("B", ["a", "b", "c"], {}).should == [111, 222, 456*2]
+    engine.evaluate_attrs("B", ["a", "b", "c"], {}).should ==
+      [111, 222, {"b"=>456*2}]
   end
 
   it "should eval imports (2)" do
@@ -591,19 +663,51 @@ eof
 
     e2 = sset.get_engine("BBB", "0002")
 
-    e2.evaluate_attrs("B", ["a", "b", "c", "d"]).should == [111, 222, -2, 222]
+    e2.evaluate_attrs("B", ["a", "b", "c", "d"]).should ==
+      [111, 222, {"b"=>-2}, 222]
 
     engine.parse defn("import BBB 0002",
                       "B: BBB::B",
                       "  e = d + 3",
                       ), sset
 
-    engine.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should == [111, 222, -2, 222, 225]
+    engine.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should ==
+      [111, 222, {"b"=>-2}, 222, 225]
 
     e4 = sset.get_engine("CCC", "0003")
 
-    e4.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should == [111, 222, -2, 222, 666]
+    e4.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should ==
+      [111, 222, {"b"=>-2}, 222, 666]
+
     e4.evaluate_attrs("C", ["a", "b", "d"]).should == [123, 123*2, 123*3*2]
   end
 
+  it "should eval imports (3)" do
+    sset.merge({
+                 ["BBB", "0002"] => getattr_code,
+                 ["CCC", "0003"] =>
+                 defn("import BBB 0002",
+                      "X:",
+                      "  xx = [n.x for n in @BBB::D('xs').xs]",
+                      "  yy = [n.x for n in BBB::D.xs]",
+                      ),
+               })
+
+    e4 = sset.get_engine("CCC", "0003")
+    e4.evaluate("X", "xx").should == [1,2,3]
+    e4.evaluate("X", "yy").should == [1,2,3]
+  end
+
+  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']",
+                      )
+    r = engine.evaluate_attrs("A", ["b", "c", "e"])
+    r.should == [2, 3, 456]
+  end
+
 end

data/spec/func_spec.rb

@@ -68,6 +68,28 @@ describe "Delorean" do
     r.should == [12.35, 12.3, 12]
   end
 
+  it "should handle NUMBER" do
+    engine.parse defn("A:",
+                      "  a = NUMBER(12.3456)",
+                      "  b = NUMBER('12.3456')",
+                      "  c = NUMBER('12')",
+                      )
+
+    r = engine.evaluate_attrs("A", ["a", "b", "c"])
+    r.should == [12.3456, 12.3456, 12]
+  end
+
+  it "should handle STRING" do
+    engine.parse defn("A:",
+                      "  a = STRING('hello')",
+                      "  b = STRING(12.3456)",
+                      "  c = STRING([1,2,3])",
+                      )
+
+    r = engine.evaluate_attrs("A", ["a", "b", "c"])
+    r.should == ["hello", '12.3456', [1,2,3].to_s]
+  end
+
   it "should handle TIMEPART" do
     engine.parse defn("A:",
                       "  p =?",
@@ -147,14 +169,6 @@ describe "Delorean" do
     expect { engine.evaluate_attrs("A", ["x"], {"p" => p}) }.to raise_error
   end
 
-  it "should handle INDEX" do
-    engine.parse defn("A:",
-                      "  a = [INDEX([0, 11, 22, 33], i) for i in [1,2]]",
-                      )
-
-    engine.evaluate("A", "a").should == [11,22]
-  end
-
   it "should handle FLATTEN" do
     x = [[1,2,[3]], 4, 5, [6]]
 
@@ -179,14 +193,4 @@ describe "Delorean" do
     }.should raise_error("xx, 1, 2, 3")
 
   end
-
-  it "should handle SYM" do
-    engine.parse defn("S:",
-                      '  a = TOSYM("hello")',
-                      )
-
-    r = engine.evaluate("S", "a")
-    r.should == :hello
-  end
-
 end

data/spec/parse_spec.rb

@@ -44,6 +44,12 @@ describe "Delorean" do
                       )
   end
 
+  it "can parse indexing" do
+    engine.parse defn("A:",
+                      "  b = [1,2,3][1]",
+                      )
+  end
+
   it "should accept default param definitions" do
     lambda {
       engine.parse defn("A:",
@@ -122,6 +128,13 @@ describe "Delorean" do
 
   end
 
+  it "should allow getattr in expressions" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  b = A.a * A.a - A.a",
+                      )
+  end
+
   it "should allow non-recursive code 1" do
     # this is not a recursion error
     engine.parse defn("A:",
@@ -588,6 +601,14 @@ describe "Delorean" do
     engine.reset
   end
 
+  it "should allow nodes as values" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "B:",
+                      "  a = A",
+                      )
+  end
+
   it "should parse module calls" do
     engine.parse defn("A:",
                       "  a = 123",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.0.34
+  version: 0.0.38
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-29 00:00:00.000000000 Z
+date: 2013-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +90,7 @@ files:
 - Rakefile
 - delorean.gemspec
 - lib/delorean/base.rb
+- lib/delorean/const.rb
 - lib/delorean/container.rb
 - lib/delorean/delorean.rb
 - lib/delorean/delorean.treetop