delorean_lang 0.0.33

data/lib/delorean/version.rb

@@ -0,0 +1,3 @@
+module Delorean
+  VERSION = "0.0.33"
+end

data/lib/delorean_lang.rb

@@ -0,0 +1,12 @@
+require "delorean/version"
+
+require 'treetop'
+require 'delorean/delorean'
+require 'delorean/nodes'
+require 'delorean/engine'
+require 'delorean/functions'
+require 'delorean/base'
+require 'delorean/error'
+require 'delorean/container'
+require 'delorean/model'
+

data/spec/dev_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Delorean" do
+
+  let(:engine) {
+    Delorean::Engine.new("YYY")
+  }
+
+  it "can enumerate nodes" do
+    engine.parse defn("X:",
+                      "  a = 123",
+                      "  b = a",
+                      "Y: X",
+                      "A:",
+                      "XX: Y",
+                      "  a = 11",
+                      "  c =?",
+                      "  d = 456",
+                      )
+    engine.enumerate_nodes.should == SortedSet.new(["A", "X", "XX", "Y"])
+  end
+
+  it "can enumerate all attrs" do
+    engine.parse defn("X:",
+                      "  a = 123",
+                      "  b = a",
+                      "Y: X",
+                      "Z:",
+                      "XX: Y",
+                      "  a = 11",
+                      "  c =?",
+                      "  d = 456",
+                      )
+    engine.enumerate_attrs.should == {
+      "X"=>["a", "b"],
+      "Y"=>["a", "b"],
+      "Z"=>[],
+      "XX"=>["a", "c", "d", "b"],
+    }
+  end
+
+  it "can enumerate attrs by node" do
+    engine.parse defn("X:",
+                      "  a = 123",
+                      "  b = a",
+                      "Y: X",
+                      "Z:",
+                      "XX: Y",
+                      "  a = 11",
+                      "  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 == { }
+  end
+
+  it "can enumerate params" do
+    engine.parse defn("X:",
+                      "  a =? 123",
+                      "  b = a",
+                      "Y: X",
+                      "Z:",
+                      "XX: Y",
+                      "  a = 11",
+                      "  c =?",
+                      "  d = 123",
+                      "YY: XX",
+                      "  c =? 22",
+                      "  e =? 11",
+                      )
+
+    engine.enumerate_params.should == Set.new(["a", "c", "e"])
+  end
+
+  it "can enumerate params by node" do
+    engine.parse defn("X:",
+                      "  a =? 123",
+                      "  b = a",
+                      "Y: X",
+                      "Z:",
+                      "XX: Y",
+                      "  a = 11",
+                      "  c =?",
+                      "  d = 123",
+                      "YY: XX",
+                      "  c =? 22",
+                      "  e =? 11",
+                      )
+    engine.enumerate_params_by_node("X").should == Set.new(["a"])
+    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

@@ -0,0 +1,609 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Delorean" do
+
+  let(:engine) {
+    Delorean::Engine.new "XXX"
+  }
+
+  let(:sset) {
+    TestContainer.new({
+                        ["AAA", "0001"] =>
+                        defn("X:",
+                             "  a =? 123",
+                             "  b = a*2",
+                             )
+                      })
+  }
+
+  it "evaluate simple expressions" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  x = -(a * 2)",
+                      "  b = -(a + 1)",
+                      "  c = -a + 1",
+                      )
+    
+    engine.evaluate_attrs("A", ["a"]).should == [123]
+
+    r = engine.evaluate_attrs("A", ["x", "b"])
+    r.should == [-246, -124]
+  end
+
+  it "proper unary expression evaluation" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  c = -a + 1",
+                      )
+
+    r = engine.evaluate("A", "c")
+    r.should == -122
+  end
+
+  it "should be able to evaluate multiple node attrs" do
+    engine.parse defn("A:",
+                      "  a =? 123",
+                      "  b = a % 11",
+                      "  c = a / 4.0",
+                      )
+
+    h = {"a" => 16}
+    r = engine.evaluate_attrs("A", ["c", "b"], h)
+    r.should == [4, 5]
+  end
+
+  it "should give error when accessing undefined attr" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  c = a.to_s",
+                      )
+
+    lambda {
+      r = engine.evaluate("A", "c")
+    }.should raise_error(Delorean::InvalidGetAttribute)
+  end
+
+  it "should handle default param values" do
+    engine.parse defn("A:",
+                      "  a =? 123",
+                      "  c = a / 123.0",
+                      )
+
+    r = engine.evaluate("A", "c")
+    r.should == 1
+  end
+
+  it "order of attr evaluation should not matter" do
+    engine.parse defn("A:",
+                      "	a =? 1",
+                      "B:",
+                      "	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]
+  end
+
+  it "params should behave properly with inheritance" do
+    engine.parse defn("A:",
+                      "	a =? 1",
+                      "B: A",
+                      "	a =? 2",
+                      "C: B",
+                      " a =? 3",
+                      " 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]
+  end
+
+  it "should give error when param is undefined for eval" do
+    engine.parse defn("A:",
+                      "  a =?",
+                      "  c = a / 123.0",
+                      )
+
+    lambda {
+      r = engine.evaluate("A", "c")
+    }.should raise_error(Delorean::UndefinedParamError)
+  end
+
+  it "should handle simple param computation" do
+    engine.parse defn("A:",
+                      "  a =?",
+                      "  c = a / 123.0",
+                      )
+
+    r = engine.evaluate("A", "c", {"a" => 123})
+    r.should == 1
+  end
+
+  it "should give error on unknown node" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      )
+
+    lambda {
+      r = engine.evaluate("B", "a")
+    }.should raise_error(Delorean::UndefinedNodeError)
+  end
+
+  it "should handle runtime errors and report module/line number" do
+    engine.parse defn("A:",
+                      "  a = 1/0",
+                      "  b = 10 * a",
+                      )
+    
+    begin
+      engine.evaluate("A", "b")
+    rescue => exc
+      res = engine.parse_runtime_exception(exc)
+    end
+
+    res.should == ["divided by 0", [["XXX", 2, "/"], ["XXX", 2, "a"], ["XXX", 3, "b"]]]
+  end
+
+  it "should handle runtime errors 2" do
+    engine.parse defn("A:",
+                      "  b = Dummy.call_me_maybe('a', 'b')",
+                      )
+    
+    begin
+      engine.evaluate("A", "b")
+    rescue => exc
+      res = engine.parse_runtime_exception(exc)
+    end
+
+    res[1].should == [["XXX", 2, "b"]]
+  end
+
+  it "should handle operator precedence properly" do
+    engine.parse defn("A:",
+                      "  b = 3+2*4-1",
+                      "  c = b*3+5",
+                      "  d = b*2-c*2",
+                      "  e = if (d < -10) then -123-1 else -456+1",
+                      )
+
+    r = engine.evaluate("A", "d")
+    r.should == -50
+
+    r = engine.evaluate("A", "e")
+    r.should == -124
+  end
+
+  it "should handle if/else" do
+    text = defn("A:",
+                "  d =? -10",
+                '  e = if d < -10 then "gungam"+"style" else "korea"'
+                )
+
+    engine.parse text
+    r = engine.evaluate("A", "e", {"d" => -100})
+    r.should == "gungam"+"style"
+
+    r = engine.evaluate("A", "e")
+    r.should == "korea"
+  end
+
+  it "should be able to access specific node attrs " do
+    engine.parse defn("A:",
+                      "  b = 123",
+                      "  c =?",
+                      "B: A",
+                      "  b = 111",
+                      "  c = A.b * 123",
+                      "C:",
+                      "  c = A.c + B.c",
+                      )
+    
+    r = engine.evaluate("B", "c")
+    r.should == 123*123
+    r = engine.evaluate("C", "c", {"c" => 5})
+    r.should == 123*123 + 5
+  end
+
+  it "should be able to call class methods on ActiveRecord classes" do
+    engine.parse defn("A:",
+                      "  b = Dummy.call_me_maybe(1, 2, 3, 4)",
+                      "  c = Dummy.call_me_maybe()",
+                      "  d = Dummy.call_me_maybe(5) + b + c",
+                      )
+    r = engine.evaluate_attrs("A", ["b", "c", "d"])
+    r.should == [10, 0, 15]
+  end
+
+  it "should be able to get attr on ActiveRecord objects using a.b syntax" do
+    engine.parse defn("A:",
+                      '  b = Dummy.i_just_met_you("this is crazy", 0.404)',
+                      "  c = b.number",
+                      "  d = b.name",
+                      "  e = b.foo",
+                      )
+    r = engine.evaluate("A", "c")
+    r.should == 0.404
+
+    r = engine.evaluate("A", "d")
+    r.should == "this is crazy"
+
+    lambda {
+      r = engine.evaluate("A", "e")
+    }.should raise_error(Delorean::InvalidGetAttribute)
+  end
+
+  it "should be able to get attr on ActiveRecord objects using Class.method().attr syntax" do
+    engine.parse defn("A:",
+                      '  b = Dummy.i_just_met_you("CRJ", 1.234).name',
+                      )
+    r = engine.evaluate("A", "b")
+    r.should == "CRJ"
+  end
+
+  it "should be able to get attr on Hash objects using a.b syntax" do
+    engine.parse defn("A:",
+                      '  b = Dummy.i_threw_a_hash_in_the_well()',
+                      "  c = b.a",
+                      "  d = b.b",
+                      "  e = b.this_is_crazy",
+                      )
+    engine.evaluate_attrs("A", %w{c d e}).should == [456, 789, nil]
+  end
+
+  it "get attr on nil should return nil" do
+    engine.parse defn("A:",
+                      '  b = Dummy.i_just_met_you("CRJ", 1.234).dummy',
+                      '  c = b.gaga',
+                      '  d = b.gaga || 55',
+                      )
+    r = engine.evaluate_attrs("A", ["b", "c", "d"])
+    r.should == [nil, nil, 55]
+  end
+
+  it "should be able to get assoc attr on ActiveRecord objects" do
+    engine.parse defn("A:",
+                      '  b = Dummy.miss_you_so_bad()',
+                      '  c = b.dummy',
+                      )
+    r = engine.evaluate("A", "c")
+    r.name.should == "hello"
+  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)",
+                      )
+    r = engine.evaluate("A", "b")
+    r.should == 867 + 5309
+  end
+
+  it "should not eval inside strings" do
+    engine.parse defn("A:",
+                      '  d = "#{this is a test}"',
+                      )
+
+    r = engine.evaluate("A", "d")
+    r.should == '#{this is a test}'
+  end
+
+  it "should ignore undeclared params sent to eval which match attr names" do
+    engine.parse defn("A:",
+                      "  d = 12",
+                      )
+    r = engine.evaluate("A", "d", {"d" => 5, "e" => 6})
+    r.should == 12
+  end
+
+  it "should handle different param defaults on nodes" do
+    engine.parse defn("A:",
+                      "  p =? 1",
+                      "  c = p * 123",
+                      "B: A",
+                      "  p =? 2",
+                      "C: A",
+                      "  p =? 3",
+                      )
+
+    r = engine.evaluate("C", "c", {"p" => 5})
+    r.should == 5*123
+
+    r = engine.evaluate("B", "c", {"p" => 10})
+    r.should == 10*123
+
+    r = engine.evaluate("A", "c")
+    r.should == 1*123
+
+    r = engine.evaluate("B", "c")
+    r.should == 2*123
+
+    r = engine.evaluate("C", "c")
+    r.should == 3*123
+  end
+
+  it "should allow overriding of attrs as params" do
+    engine.parse defn("A:",
+                      "  a = 2",
+                      "  b = a*3",
+                      "B: A",
+                      "  a =?",
+                      )
+
+    r = engine.evaluate("A", "b", {"a" => 10})
+    r.should == 2*3
+
+    r = engine.evaluate("B", "b", {"a" => 10})
+    r.should == 10*3
+    
+    lambda {
+      r = engine.evaluate("B", "b")
+    }.should raise_error(Delorean::UndefinedParamError)
+
+  end
+  
+  sample_script = <<eof
+A:
+	a = 2
+	p =?
+	c = a * 2
+	pc = p + c
+
+C: A
+    p =? 3
+
+B: A
+	p =? 5
+eof
+
+  it "should allow overriding of attrs as params" do
+    engine.parse sample_script
+
+    r = engine.evaluate("C", "c")
+    r.should == 4
+
+    r = engine.evaluate("B", "pc")
+    r.should == 4 + 5
+
+    r = engine.evaluate("C", "pc")
+    r.should == 4 + 3
+
+    lambda {
+      r = engine.evaluate("A", "pc")
+    }.should raise_error(Delorean::UndefinedParamError)
+  end
+
+  it "engines of same name should be independent" do
+    engin2 = Delorean::Engine.new(engine.module_name)
+
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  b = a*3",
+                      "B: A",
+                      "  c = b*2",
+                      )
+
+    engin2.parse defn("A:",
+                      "  a = 222.0",
+                      "  b = a/5",
+                      "B: A",
+                      "  c = b*3",
+                      "C:",
+                      "  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_attrs("B", ["a", "b", "c"]).should == [123, 123*3, 123*3*2]
+    engin2.evaluate_attrs("B", ["a", "b", "c"]).should == [222.0, 222.0/5, 222.0/5*3]
+
+    engin2.evaluate("C", "d").should == 111
+    lambda {
+      engine.evaluate("C", "d")
+    }.should raise_error(Delorean::UndefinedNodeError)
+  end
+
+  it "should handle invalid expression evaluation" do
+    # Should handle errors on expression such as -[] or -"xxx" or ("x"
+    # + []) better. Currently, it raised NoMethodError.
+    pending
+  end
+
+  it "should eval lists" do
+    engine.parse defn("A:",
+                      "  b = []",
+                      "  c = [1,2,3]",
+                      "  d = [b, c, b, c, 1, 2, '123', 1.1, -1.23]",
+                      "  e = [1, 1+1, 1+1+1, 1*2*4]",
+                      )
+
+    engine.evaluate_attrs("A", %w{b c d e}).should ==
+      [[],
+       [1, 2, 3],
+       [[], [1, 2, 3], [], [1, 2, 3], 1, 2, "123", 1.1, -1.23],
+       [1, 2, 3, 8],
+      ]
+  end
+
+  it "should eval list expressions" do
+    engine.parse defn("A:",
+                      "  b = []+[]",
+                      "  c = [1,2,3]+b",
+                      "  d = c*2",
+                      )
+
+    engine.evaluate_attrs("A", %w{b c d}).should ==
+      [[],
+       [1, 2, 3],
+       [1, 2, 3]*2,
+      ]
+  end
+
+  it "should eval list comprehension" do
+    engine.parse defn("A:",
+                      "  b = [i*5 for i in [1,2,3]]",
+                      )
+    engine.evaluate("A", "b").should == [5, 10, 15]
+  end
+
+  it "should eval nested list comprehension" do
+    engine.parse defn("A:",
+                      "  b = [[a+c for c in [4,5]] for a in [1,2,3]]",
+                      )
+    engine.evaluate("A", "b").should == [[5, 6], [6, 7], [7, 8]]
+
+  end
+
+  it "should eval list comprehension variable override" do
+    engine.parse defn("A:",
+                      "  b = [b/2.0 for b in [1,2,3]]",
+                      )
+    engine.evaluate("A", "b").should == [0.5, 1.0, 1.5]
+  end
+
+  it "should eval list comprehension variable override (2)" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  b = [a+1 for a in [1,2,3]]",
+                      )
+    engine.evaluate("A", "b").should == [2, 3, 4]
+  end
+
+  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]",
+                      )
+    engine.evaluate("A", "b").should == [5, 15, 25]
+  end
+
+  it "should eval hashes" do
+    engine.parse defn("A:",
+                      "  b = {}",
+                      "  c = {'a':1, 'b': 2,'c':3}",
+                      "  d = {123*2: -123, 'b_b': 1+1}",
+                      "  e = {'x': 1, 'y': 1+1, 'z': 1+1+1, 'zz': 1*2*4}",
+                      "  f = {'a': nil, 'b': [1, nil, 2]}",
+                      "  g = {b:b, [b]:[1,23], []:345}",
+                      )
+
+    engine.evaluate_attrs("A", %w{b c d e f g}).should ==
+      [{},
+       {"a"=>1, "b"=>2, "c"=>3},
+       {123*2=>-123, "b_b"=>2},
+       {"x"=>1, "y"=>2, "z"=>3, "zz"=>8},
+       {"a"=>nil, "b"=>[1, nil, 2]},
+       {{}=>{}, [{}]=>[1, 23], []=>345},
+      ]
+  end
+
+  it "should eval module calls" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  b = 456 + a",
+                      "  n = 'A'",
+                      "  c = @('a', 'b', x: 123, y: 456)",
+                      "  d = @n('a', 'b', x: 123, y: 456)",
+                      "  e = @('b')",
+                      )
+
+    engine.evaluate_attrs("A", %w{n c d e}).should ==
+      ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, 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)",
+                      )
+    
+    engine.evaluate("A", "factorial", "n" => 10).should == 3628800
+  end
+
+  it "should eval module calls by node name" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  b = @A('a')",
+                      )
+    engine.evaluate("A", "b").should == 123
+  end
+
+  it "should eval multiline expressions" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  b = [a+1",
+                      "       for a in [1,2,3]",
+                      "	     ]",
+                      )
+    engine.evaluate("A", "b").should == [2, 3, 4]
+  end
+
+  it "should eval multiline expressions" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  b = 456 + ",
+                      "      a",
+                      "  n = 'A'",
+                      "  c = @('a', ",
+                      "        'b', ",
+                      "        x: 123, ",
+                      "        y: 456)",
+                      "  d = @n('a', ",
+                      "         'b', ",
+                      "         x: 123, y: 456)",
+                      "  e = @(",
+                      "        'b'",
+                      "       )",
+                      )
+
+    engine.evaluate_attrs("A", %w{n c d e}).should ==
+      ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, 579]
+  end
+
+  it "should eval imports" do
+    engine.parse defn("import AAA 0001",
+                      "A:",
+                      "  b = 456",
+                      "B: AAA::X",
+                      "  a = 111",
+                      "  c = @AAA::X('b', a: 456)",
+                      ), sset
+    engine.evaluate_attrs("B", ["a", "b", "c"], {}).should == [111, 222, 456*2]
+  end
+
+  it "should eval imports (2)" do
+    sset.merge({
+                 ["BBB", "0002"] =>
+                 defn("import AAA 0001",
+                      "B: AAA::X",
+                      "  a = 111",
+                      "  c = @AAA::X('b', a: -1)",
+                      "  d = a * 2",
+                      ),
+                 ["CCC", "0003"] =>
+                 defn("import BBB 0002",
+                      "import AAA 0001",
+                      "B: BBB::B",
+                      "  e = d * 3",
+                      "C: AAA::X",
+                      "  d = b * 3",
+                      ),
+               })
+
+    e2 = sset.get_engine("BBB", "0002")
+
+    e2.evaluate_attrs("B", ["a", "b", "c", "d"]).should == [111, 222, -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]
+
+    e4 = sset.get_engine("CCC", "0003")
+
+    e4.evaluate_attrs("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]
+  end
+
+end