delorean_lang 0.0.33

data/spec/func_spec.rb

@@ -0,0 +1,192 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Delorean" do
+
+  let(:engine) {
+    Delorean::Engine.new("ZZZ")
+  }
+
+  it "should handle MAX as a node name" do
+    engine.parse defn("MAX:",
+                      "  a = MAX(1, 2, 3, 0, -10)",
+                      )
+
+    r = engine.evaluate("MAX", "a")
+    r.should == 3
+  end
+
+  it "should handle MAX" do
+    engine.parse defn("A:",
+                      "  a = MAX(1, 2, 3)",
+                      )
+
+    r = engine.evaluate("A", "a")
+    r.should == 3
+  end
+
+  it "should handle insufficient args" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a = MAX(1)",
+                        )
+    }.should raise_error(Delorean::BadCallError)
+  end
+
+  it "should handle MIN" do
+    engine.parse defn("A:",
+                      "  a = MIN(1, 2, -3, 4)",
+                      )
+
+    r = engine.evaluate("A", "a")
+    r.should == -3
+  end
+
+  it "should handle MAXLIST" do
+    engine.parse defn("A:",
+                      "  a = MAXLIST([1, 2, 3])",
+                      )
+
+    engine.evaluate("A", "a").should == 3
+  end
+
+  it "should handle MINLIST" do
+    engine.parse defn("A:",
+                      "  a = MINLIST([1, 10, -3])",
+                      )
+
+    engine.evaluate("A", "a").should == -3
+  end
+
+  it "should handle ROUND" do
+    engine.parse defn("A:",
+                      "  a = ROUND(12.3456, 2)",
+                      "  b = ROUND(12.3456, 1)",
+                      "  c = ROUND(12.3456)",
+                      )
+
+    r = engine.evaluate_attrs("A", ["a", "b", "c"])
+    r.should == [12.35, 12.3, 12]
+  end
+
+  it "should handle TIMEPART" do
+    engine.parse defn("A:",
+                      "  p =?",
+                      "  p2 =?",
+                      "  h = TIMEPART(p, 'h')",
+                      "  m = TIMEPART(p, 'm')",
+                      "  s = TIMEPART(p, 's')",
+                      "  d = TIMEPART(p, 'd')",
+                      "  d2 = TIMEPART(p2, 'd')",
+                      "  h2 = TIMEPART(p2, 'h')",
+                      )
+
+    p = Time.now
+    params = {"p" => p, "p2" => Float::INFINITY}
+    r = engine.evaluate_attrs("A", %w{h m s d d2}, params)
+    r.should == [p.hour, p.min, p.sec, p.to_date, Float::INFINITY]
+
+    expect { engine.evaluate_attrs("A", ["h2"], params) }.to raise_error
+
+    # Non time argument should raise an error
+    expect { engine.evaluate_attrs("A", ["m"], {"p" => 123}) }.to raise_error
+
+  end
+
+  it "should handle DATEPART" do
+    engine.parse defn("A:",
+                      "  p =?",
+                      "  y = DATEPART(p, 'y')",
+                      "  d = DATEPART(p, 'd')",
+                      "  m = DATEPART(p, 'm')",
+                      )
+
+    p = Date.today
+    r = engine.evaluate_attrs("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}) }.to raise_error
+     # Invalid part argument should raise an error
+    engine.reset
+    engine.parse defn("A:",
+                      "  p =?",
+                      "  x = DATEPART(p, 'x')",
+                      )
+    expect { engine.evaluate_attrs("A", ["x"], {"p" => p}) }.to raise_error
+  end
+
+  it "should handle DATEADD" do
+    engine.parse defn("A:",
+                      "  p =?",
+                      "  y = DATEADD(p, 1, 'y')",
+                      "  d = DATEADD(p, 30, 'd')",
+                      "  m = DATEADD(p, 2, 'm')",
+                      )
+
+    p = Date.today
+    r = engine.evaluate_attrs("A", ["y", "d", "m"], {"p" => p})
+    r.should == [p + 1.years, p + 30.days, p + 2.months]
+
+    # Non date argument should raise an error
+    expect { engine.evaluate_attrs("A", ["y", "d", "m"], {"p" => 123}) }.to raise_error
+
+    # Invalid interval argument should raise an error
+    engine.reset
+    engine.parse defn("A:",
+                      "  p =?",
+                      "  m = DATEADD(p, 1.3, 'm')",
+                      )
+    expect { engine.evaluate_attrs("A", ["m"], {"p" => p}) }.to raise_error
+   
+    # Invalid part argument should raise an error
+    engine.reset
+    engine.parse defn("A:",
+                      "  p =?",
+                      "  x = DATEADD(p, 1, 'x')",
+                      )
+    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]]
+
+    engine.parse defn("A:",
+                      "  a = #{x}",
+                      "  b = FLATTEN(a) + FLATTEN(a, 1)"
+                      )
+
+    engine.evaluate("A", "b").should == x.flatten + x.flatten(1)
+  end
+
+  it "should handle ERR" do
+    engine.parse defn("A:",
+                      "  a = ERR('hello')",
+                      "  b = ERR('xx', 1, 2, 3)",
+                      )
+
+    expect { engine.evaluate("A", "a") }.to raise_error('hello')
+
+    lambda {
+      r = engine.evaluate("A", "b")
+    }.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

@@ -0,0 +1,688 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Delorean" do
+
+  let(:engine) {
+    Delorean::Engine.new "YYY"
+  }
+
+  let(:sset) {
+    TestContainer.new({
+                        ["AAA", "0001"] =>
+                        defn("X:",
+                             "  a = 123",
+                             "  b = a",
+                             )
+                      })
+  }
+
+  it "can parse very simple calls" do
+    engine.parse defn("X:",
+                      "  a = 123",
+                      "  b = a",
+                      )
+  end
+
+  it "can parse simple expressions - 1" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  x = -(a*2)",
+                      "  b = -(a + 1)",
+                      )
+  end
+
+  it "can parse simple expressions - 2" do
+    engine.parse defn("A:",
+                      "  a = 1 + 2 * -3 - -4",
+                      )
+  end
+
+  it "can parse params" do
+    engine.parse defn("A:",
+                      "  a =?",
+                      "  b =? a*2",
+                      )
+  end
+
+  it "should accept default param definitions" do
+    lambda {
+      engine.parse defn("A:",
+                        "  b =? 1",
+                        "  c =? -1.1",
+                        "  d = b + c",
+                        )
+    }.should_not raise_error
+  end
+
+  it "gives errors with attrs not in node" do
+    lambda {
+      engine.parse defn("a = 123",
+                        "b = a * 2",
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should disallow .<digits> literals" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a = .123",
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should disallow bad attr names" do
+    lambda {
+      engine.parse defn("A:",
+                        "  B = 1",
+                        )
+    }.should raise_error(Delorean::ParseError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  _b = 1",
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should disallow bad node names" do
+    lambda {
+      engine.parse defn("a:",
+                        )
+    }.should raise_error(Delorean::ParseError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("_A:",
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should disallow recursion" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a = 1",
+                        "B: A",
+                        "  a = a + 1",
+                        )
+    }.should raise_error(Delorean::RecursionError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = 1",
+                        "B: A",
+                        "  b = a",
+                        "  a = b",
+                        )
+    }.should raise_error(Delorean::RecursionError)
+
+  end
+
+  it "should allow non-recursive code 1" do
+    # this is not a recursion error
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  b = 2",
+                      "B: A",
+                      "  a = A.b",
+                      "  b = a",
+                      )
+
+  end
+
+  it "should allow non-recursive code 2" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  b = 2",
+                      "B: A",
+                      "  a = A.b",
+                      "  b = A.b + B.a",
+                      )
+  end
+
+  it "should allow non-recursive code 3" do
+    engine.parse defn("A:",
+                      "  b = 2",
+                      "  a = A.b + A.b",
+                      "  c = a + b + a + b",
+                      )
+  end
+
+  it "should check for recursion with default params 1" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a =? a",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+  end
+
+  it "should check for recursion with default params 2" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a = 1",
+                        "B: A",
+                        "  b =? a",
+                        "  a =? b",
+                        )
+    }.should raise_error(Delorean::RecursionError)
+  end
+
+  it "gives errors for attrs defined more than once in a node" do
+    lambda {
+      engine.parse defn("B:",
+                        "  b = 1 + 1",
+                        "  b = 123",
+                        )
+    }.should raise_error(Delorean::RedefinedError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("B:",
+                        "  b =?",
+                        "  b = 123",
+                        )
+    }.should raise_error(Delorean::RedefinedError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("B:",
+                        "  b =? 22",
+                        "  b = 123",
+                        )
+    }.should raise_error(Delorean::RedefinedError)
+  end
+
+  it "should raise error for nodes defined more than once" do
+    lambda {
+      engine.parse defn("B:",
+                        "  b =?",
+                        "B:",
+                        )
+    }.should raise_error(Delorean::RedefinedError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("B:",
+                        "A:",
+                        "B:",
+                        )
+    }.should raise_error(Delorean::RedefinedError)
+  end
+
+  it "should not be valid to derive from undefined nodes" do
+    lambda {
+      engine.parse defn("A: B",
+                        "  a = 456 * 123",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+  end
+
+  it "should not be valid to use an undefined attr" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a = 456 * 123",
+                        "B: A",
+                        "  b = a",
+                        "  c = d",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+  end
+
+  it "should be able to use ruby keywords as identifier" do
+    lambda {
+      engine.parse defn("A:",
+                        "  in = 123",
+                        )
+    }.should_not raise_error
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("B:",
+                        "  in1 = 123",
+                        )
+    }.should_not raise_error
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("C:",
+                        "  ifx = 123",
+                        "  elsey = ifx + 1",
+                        )
+    }.should_not raise_error
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("D:",
+                        "  true = false",
+                        )
+    }.should_not raise_error
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("E:",
+                        "  a = 1",
+                        "  return=a",
+                        )
+    }.should_not raise_error
+  end
+
+  it "should be able to chain method calls on model functions" do
+    lambda {
+      engine.parse defn("A:",
+                        "  b = Dummy.i_just_met_you('CRJ', 123).name"
+                        )
+    }.should_not raise_error
+  end
+
+  it "should be able to call class methods on ActiveRecord classes" do
+    engine.parse defn("A:",
+                      "  b = Dummy.call_me_maybe()",
+                      )
+  end
+
+  it "shouldn't be able to call ActiveRecord methods without signature" do
+    lambda {
+      engine.parse defn("A:",
+                        "  b = Dummy.this_is_crazy()",
+                        )
+    }.should raise_error(Delorean::UndefinedFunctionError)
+  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)",
+                      )
+  end
+
+  it "should be able to override parameters with attribute definitions" do
+    engine.parse defn("A:",
+                      "  b =? 22",
+                      "B: A",
+                      "  b = 123",
+                      "C: B",
+                      "  b =? 11",
+                      )
+  end
+
+  it "should raise error on node attr access without all needed params" do
+    pending
+  end
+
+  it "should be able to access derived attrs" do
+    engine.parse defn("A:",
+                      "  b =? 22",
+                      "B: A",
+                      "  c = b * 123",
+                      "C: B",
+                      "  d =? c * b + 11",
+                      )
+  end
+
+  it "should not be able to access attrs not defined in ancestors" do
+    lambda {
+      engine.parse defn("A:",
+                        "  b =? 22",
+                        "B: A",
+                        "  c = b * 123",
+                        "C: A",
+                        "  d =? c * b + 11",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+  end
+
+  it "should be able to access specific node attrs " do
+    engine.parse defn("A:",
+                      "  b = 123",
+                      "  c = A.b",
+                      )
+
+    engine.reset
+
+    engine.parse defn("A:",
+                      "  b = 123",
+                      "B: A",
+                      "  b = 111",
+                      "  c = A.b * 123",
+                      "  d = B.b",
+                      )
+  end
+
+  it "should be able to perform arbitrary getattr" do
+    engine.parse defn("A:",
+                      "  b = 22",
+                      "  c = b.x.y.z",
+                      )
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("B:",
+                        "  c = b.x.y.z",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+
+  end
+
+  it "should handle lines with comments" do
+    engine.parse defn("A: # kaka",
+                      "  b = 22  # testing #",
+                      "  c = b",
+                      )
+  end
+
+  it "should be able to report error line during parse" do
+    begin
+      engine.parse defn("A:",
+                        "  b = 123",
+                        "B: .A",
+                        )
+    rescue => exc
+    end
+
+    exc.module_name.should == "YYY"
+    exc.line.should == 3
+
+    engine.reset
+
+    begin
+      engine.parse defn("A:",
+                        "  b = 3 % b",
+                        )
+    rescue => exc
+    end
+
+    exc.module_name.should == "YYY"
+    exc.line.should == 2
+  end
+
+  it "should raise error on malformed string" do
+    lambda {
+      engine.parse defn("A:",
+                        '  d = "testing"" ',
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should not allow inherited ruby methods as attrs" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a = name",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = new",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+  end
+
+  it "should be able to parse lists" do
+    engine.parse defn("A:",
+                      "  b = []",
+                      "  c = [1,2,3]",
+                      "  d = [b, c, b, c, 1, 2, '123', 1.1]",
+                      "  e = [1, 1+1, 1+1+1]",
+                      )
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = [",
+                        )
+    }.should raise_error(Delorean::ParseError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = []-",
+                        )
+    }.should raise_error(Delorean::ParseError)
+
+  end
+
+  it "should handle trailing ',' with lists" do
+    engine.parse defn("A:",
+                      "  b = [1,2,3,]",
+                      )
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = [,]",
+                        )
+    }.should raise_error(Delorean::ParseError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = [1,2,,]",
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should be able to parse hashes" do
+    engine.parse defn("A:",
+                      "  b = {}",
+                      "  c = {'a':1, 'b': 2, 'c':-3}",
+                      "  d = [{1:11}, {2: 22}]",
+                      )
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = {",
+                        )
+    }.should raise_error(Delorean::ParseError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = {}+",
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should handle trailing ',' with hashes" do
+    engine.parse defn("A:",
+                      "  b = {-1:1,}",
+                      )
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = {,}",
+                        )
+    }.should raise_error(Delorean::ParseError)
+
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = {-1:1,,}",
+                        )
+    }.should raise_error(Delorean::ParseError)
+  end
+
+  it "should be able to parse list operations " do
+    engine.parse defn("A:",
+                      "  b = [] + []",
+                      )
+  end
+
+  it "should parse list comprehension" do
+    engine.parse defn("A:",
+                      "  b = [123 for i in 123]",
+                      )
+
+  end
+
+  it "should parse list comprehension (2)" do
+    engine.parse defn("A:",
+                      "  b = [i+1 for i in [1,2,3]]",
+                      )
+
+  end
+
+  it "should parse nested list comprehension" do
+    engine.parse defn("A:",
+                      "  b = [[a+c for c in [4,5]] for a in [1,2,3]]",
+                      )
+
+  end
+
+  it "should accept list comprehension variable override" do
+    engine.parse defn("A:",
+                      "  b = [b+1 for b in [1,2,3]]",
+                      )
+  end
+
+  it "should accept list comprehension variable override (2)" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  b = [a+1 for a in [1,2,3]]",
+                      )
+  end
+
+  it "errors out on bad list comprehension" do
+    lambda {
+      engine.parse defn("A:",
+                        "  b = [i+1 for x in [1,2,3]]",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+    engine.reset
+
+    lambda {
+      engine.parse defn("A:",
+                        "  a = [123 for b in b]",
+                        )
+    }.should raise_error(Delorean::UndefinedError)
+    engine.reset
+
+    # disallow nested comprehension var reuse
+    lambda {
+      engine.parse defn("A:",
+                        "  b = [[a+1 for a in [4,5]] for a in [1,2,3]]",
+                        )
+    }.should raise_error(Delorean::RedefinedError)
+    engine.reset
+  end
+
+  it "should parse 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)",
+                      )
+  end
+
+  it "should parse module calls by node name" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "  d = @A('a')",
+                      )
+  end
+
+  it "should parse multiline attr defs" do
+    engine.parse defn("A:",
+                      "  a = [1,",
+                      "       2,",
+                      "       3]",
+                      "  b = 456",
+                      )
+  end
+
+  it "should give proper errors on parse multiline attr defs" do
+    begin
+      engine.parse defn("A:",
+                        "  a = [1,",
+                        "       2,",
+                        "       3];",
+                        "  b = 456",
+                        )
+      raise "fail"
+    rescue Delorean::ParseError => exc
+      exc.line.should == 2
+    end
+  end
+
+  it "should give proper errors when multiline error falls off the end" do
+    begin
+      engine.parse defn("A:",
+                        "  x = 123",
+                        "  a = 1 +",
+                        "       2 +",
+                        )
+      raise "fail"
+    rescue Delorean::ParseError => exc
+      exc.line.should == 3
+    end
+  end
+
+  it "should parse imports" do
+    engine.parse defn("import AAA 0001",
+                      "A:",
+                      "  b = 456",
+                      "B: AAA::X",
+                      ), sset
+    
+  end
+
+  it "should disallow import loops" do
+    pending
+    sset.merge({
+                 ["BBB", "0001"] =>
+                 defn("import AAA 0001",
+                      "import CCC 0001",
+                      ),
+                 ["CCC", "0001"] =>
+                 defn("import BBB 0001",
+                      ),
+               })
+    sset.get_engine("CCC", "0001")
+  end
+
+  it "should disallow multiple versions of same script" do
+    sset.merge({
+                 ["AAA", "0002"] =>
+                 defn("A:",
+                      ),
+                 ["BBB", "0001"] =>
+                 defn("import AAA 0001",
+                      ),
+                 ["CCC", "0001"] =>
+                 defn("import BBB 0001",
+                      "import AAA 0002",
+                      ),
+               })
+    begin
+      sset.get_engine("CCC", "0001")
+    rescue Delorean::ImportError => exc
+      exc.line.should == 2
+    end
+  end
+
+end
+