delorean_lang 0.6.3 → 1.0.0

data/spec/func_spec.rb

@@ -13,7 +13,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('MAX', 'a')
-    r.should == 3
+    expect(r).to eq(3)
   end
 
   it 'should handle COMPACT' do
@@ -32,7 +32,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', 'a')
-    r.should == -3
+    expect(r).to eq(-3)
   end
 
   it 'should handle ROUND' do
@@ -43,7 +43,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', ['a', 'b', 'c'])
-    r.should == [12.35, 12.3, 12]
+    expect(r).to eq([12.35, 12.3, 12])
   end
 
   it 'should handle TRUNCATE' do
@@ -54,7 +54,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', ['a', 'b', 'c'])
-    r.should == [12.34, 12.3, 12]
+    expect(r).to eq([12.34, 12.3, 12])
   end
 
   it 'should handle FLOOR' do
@@ -63,7 +63,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', 'a')
-    r.should == [12, 13]
+    expect(r).to eq([12, 13])
   end
 
   it 'should handle TO_F' do
@@ -75,7 +75,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', ['a', 'b', 'c', 'd'])
-    r.should == [12.3456, 12.3456, 12, 1_525_456_587.0]
+    expect(r).to eq([12.3456, 12.3456, 12, 1_525_456_587.0])
   end
 
   it 'should handle ABS' do
@@ -87,7 +87,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', ['a', 'b', 'c', 'd'])
-    r.should == [123, 1.1, 2.3, 0]
+    expect(r).to eq([123, 1.1, 2.3, 0])
   end
 
   it 'should handle STRING' do
@@ -98,7 +98,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', ['a', 'b', 'c'])
-    r.should == ['hello', '12.3456', [1, 2, 3].to_s]
+    expect(r).to eq(['hello', '12.3456', [1, 2, 3].to_s])
   end
 
   it 'should handle FETCH' do
@@ -110,7 +110,7 @@ describe 'Delorean' do
                      )
 
     r = engine.evaluate('A', ['a', 'b', 'c'])
-    r.should == [123, 111, 456]
+    expect(r).to eq([123, 111, 456])
   end
 
   it 'should handle TIMEPART' do
@@ -126,10 +126,10 @@ describe 'Delorean' do
     p = Time.now
     params = { 'p' => p }
     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]
+    expect(r).to  eq([p.hour, p.min, p.sec, p.to_date, p.to_date])
 
     # Non time argument should raise an error
-    expect { engine.evaluate('A', ['m'], 'p' => 123) }.to raise_error
+    expect { engine.evaluate('A', ['m'], 'p' => 123) }.to raise_error(RuntimeError)
   end
 
   it 'should handle DATEPART' do
@@ -142,12 +142,12 @@ describe 'Delorean' do
 
     p = Date.today
     r = engine.evaluate('A', ['y', 'd', 'm'], 'p' => p)
-    r.should == [p.year, p.day, p.month]
+    expect(r).to eq([p.year, p.day, p.month])
 
     # Non date argument should raise an error
     expect do
       engine.evaluate('A', ['y', 'd', 'm'], 'p' => 123)
-    end.to raise_error
+    end.to raise_error(RuntimeError)
   end
 
   it 'should handle FLATTEN' do
@@ -158,7 +158,7 @@ describe 'Delorean' do
                       '    b = a.flatten() + a.flatten(1)'
                      )
 
-    engine.evaluate('A', 'b').should == x.flatten + x.flatten(1)
+    expect(engine.evaluate('A', 'b')).to eq(x.flatten + x.flatten(1))
   end
 
   it 'should handle ZIP' do
@@ -173,7 +173,7 @@ describe 'Delorean' do
                       '    d = a.zip(b) + a.zip(b, c)',
                      )
 
-    expect(engine.evaluate('A', 'd')).to eq a.zip(b) + a.zip(b, c)
+    expect(engine.evaluate('A', 'd')).to eq(a.zip(b) + a.zip(b, c))
   end
 
   it 'should handle ERR' do
@@ -184,9 +184,7 @@ describe 'Delorean' do
 
     expect { engine.evaluate('A', 'a') }.to raise_error('hello')
 
-    lambda {
-      engine.evaluate('A', 'b')
-    }.should raise_error('xx, 1, 2, 3')
+    expect { engine.evaluate('A', 'b') }.to raise_error('xx, 1, 2, 3')
   end
 
   it 'should handle RUBY' do
@@ -208,30 +206,27 @@ describe 'Delorean' do
                       "    o = 'hello'.length",
                      )
 
-    engine.evaluate('A', 'c').should == x.flatten(1)
-    engine.evaluate('A', 'd').should == x.flatten + x.flatten(1)
+    expect(engine.evaluate('A', 'c')).to eq(x.flatten(1))
+    expect(engine.evaluate('A', 'd')).to eq(x.flatten + x.flatten(1))
     dd = engine.evaluate('A', 'dd')
-    engine.evaluate('A', 'e').should == dd.sort
-    engine.evaluate('A', 'f').should == dd.sort.uniq
-    engine.evaluate('A', 'g').should == dd.length
-    engine.evaluate('A', 'gg').should == x.length
-    engine.evaluate('A', 'm').should == [x.member?(5), x.member?(55)]
-    engine.evaluate('A', 'n').should == 3
-    engine.evaluate('A', 'o').should == 5
+    expect(engine.evaluate('A', 'e')).to eq(dd.sort)
+    expect(engine.evaluate('A', 'f')).to eq(dd.sort.uniq)
+    expect(engine.evaluate('A', 'g')).to eq(dd.length)
+    expect(engine.evaluate('A', 'gg')).to eq(x.length)
+    expect(engine.evaluate('A', 'm')).to eq([x.member?(5), x.member?(55)])
+    expect(engine.evaluate('A', 'n')).to eq(3)
+    expect(engine.evaluate('A', 'o')).to eq(5)
   end
 
   it 'should be able to call function on hash' do
-    # FIXME: this is actually a Delorean design issue.  How do
-    # whitelisted functions interact with attrs?  In this case, we
-    # return nil since there is no Delorean 'length' attr in the hash.
-    skip 'Delorean design issue to be resolved'
-
     engine.parse defn('A:',
-                      '    n = {}.length',
                       "    m = {'length':100}.length",
+                      '    n = {}.length',
+                      '    o = {}["length"]',
                      )
-    engine.evaluate('A', 'n').should == 0
-    engine.evaluate('A', 'm').should == 100
+    expect(engine.evaluate('A', 'n')).to eq(0)
+    expect(engine.evaluate('A', 'm')).to eq(100)
+    expect(engine.evaluate('A', 'o')).to be_nil
   end
 
   it 'should be able to call hash except' do
@@ -249,7 +244,7 @@ describe 'Delorean' do
                       "    a = #{x}",
                       '    b = a.slice(0, 4)',
                      )
-    engine.evaluate('A', 'b').should == x.slice(0, 4)
+    expect(engine.evaluate('A', 'b')).to eq(x.slice(0, 4))
   end
 
   it 'should handle RUBY empty? function' do
@@ -262,7 +257,9 @@ describe 'Delorean' do
                       '    c1 = {1,2,3}',
                       '    res = [a0.empty, b0.empty(), c0.empty, a1.empty, b1.empty(), c1.empty]',
                      )
-    engine.evaluate('A', 'res').should == [true, true, true, false, false, false]
+    expect(engine.evaluate('A', 'res')).to eq(
+      [true, true, true, false, false, false]
+    )
   end
 
   it 'should handle BETWEEN' do

data/spec/parse_spec.rb

@@ -59,97 +59,97 @@ describe 'Delorean' do
   end
 
   it 'should accept default param definitions' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a =? 0.0123',
                         '    b =? 0',
                         '    c =? -1.1',
                         '    d = b + c',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
   end
 
   it 'gives errors with attrs not in node' do
-    lambda {
+    expect do
       engine.parse defn('a = 123',
                         'b = a * 2',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should disallow .<digits> literals' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = .123',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should disallow leading 0s in numbers' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = 00.123',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should disallow leading 0s in numbers (2)' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = 0123',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should disallow bad attr names' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    B = 1',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    _b = 1',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should disallow bad node names' do
-    lambda {
+    expect do
       engine.parse defn('a:',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('_A:',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should disallow recursion' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = 1',
                         'B: A',
                         '    a = a + 1',
                        )
-    }.should raise_error(Delorean::RecursionError)
+    end.to raise_error(Delorean::RecursionError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = 1',
                         'B: A',
                         '    b = a',
                         '    a = b',
                        )
-    }.should raise_error(Delorean::RecursionError)
+    end.to raise_error(Delorean::RecursionError)
   end
 
   it 'should allow getattr in expressions' do
@@ -197,194 +197,194 @@ describe 'Delorean' do
   end
 
   it 'should check for recursion with default params 1' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a =? a',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should check for recursion with default params 2' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = 1',
                         'B: A',
                         '    b =? a',
                         '    a =? b',
                        )
-    }.should raise_error(Delorean::RecursionError)
+    end.to raise_error(Delorean::RecursionError)
   end
 
   it 'gives errors for attrs defined more than once in a node' do
-    lambda {
+    expect do
       engine.parse defn('B:',
                         '    b = 1 + 1',
                         '    b = 123',
                        )
-    }.should raise_error(Delorean::RedefinedError)
+    end.to raise_error(Delorean::RedefinedError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('B:',
                         '    b =?',
                         '    b = 123',
                        )
-    }.should raise_error(Delorean::RedefinedError)
+    end.to raise_error(Delorean::RedefinedError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('B:',
                         '    b =? 22',
                         '    b = 123',
                        )
-    }.should raise_error(Delorean::RedefinedError)
+    end.to raise_error(Delorean::RedefinedError)
   end
 
   it 'should raise error for nodes defined more than once' do
-    lambda {
+    expect do
       engine.parse defn('B:',
                         '    b =?',
                         'B:',
                        )
-    }.should raise_error(Delorean::RedefinedError)
+    end.to raise_error(Delorean::RedefinedError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('B:',
                         'A:',
                         'B:',
                        )
-    }.should raise_error(Delorean::RedefinedError)
+    end.to raise_error(Delorean::RedefinedError)
   end
 
   it 'should not be valid to derive from undefined nodes' do
-    lambda {
+    expect do
       engine.parse defn('A: B',
                         '    a = 456 * 123',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should not be valid to use an undefined attr' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = 456 * 123',
                         'B: A',
                         '    b = a',
                         '    c = d',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should not be possible to use a forward definition in hash' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         "    c = {'b': 1, 'd' : d}",
                         '    d = 789',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should not be possible to use a forward definition in node call' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    c = A(b=1, d=d)',
                         '    d = 789',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should not be possible to use a forward definition in array' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    c = [123, 456, d]',
                         '    d = 789',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should be able to use ruby keywords as identifier' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    in = 123',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('B:',
                         '    in1 = 123',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('C:',
                         '    ifx = 123',
                         '    elsey = ifx + 1',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('D:',
                         '    true = false',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('E:',
                         '    a = 1',
                         '    return=a',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
 
     engine.reset
 
     skip 'need to fix'
 
-    lambda {
+    expect do
       engine.parse defn('D:',
                         '    true_1 = false',
                         '    false_1 = true_1',
                         '    nil_1 = false_1',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
 
     engine.reset
   end
 
   it 'should parse calls followed by getattr' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = -1',
                         '    b = A().a',
                        )
-    }.should_not raise_error
+    end.not_to raise_error
   end
 
   it 'should be able to chain method calls on model functions' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         "    b = Dummy.i_just_met_you('CRJ', 123).name"
                        )
-    }.should_not raise_error
+    end.not_to raise_error
   end
 
   it 'should be able to pass model class to model functions' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    b = Dummy.i_just_met_you(Dummy, 1)'
                        )
-    }.should_not raise_error
+    end.not_to raise_error
   end
 
   it 'should be able to call class methods on ActiveRecord classes' do
@@ -436,7 +436,7 @@ describe 'Delorean' do
   end
 
   it 'should not be able to access attrs not defined in ancestors' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    b =? 22',
                         'B: A',
@@ -444,7 +444,7 @@ describe 'Delorean' do
                         'C: A',
                         '    d =? c * b + 11',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should be able to access specific node attrs ' do
@@ -472,11 +472,11 @@ describe 'Delorean' do
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('B:',
                         '    c = b.x.y.z',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should handle lines with comments' do
@@ -495,8 +495,8 @@ describe 'Delorean' do
     rescue StandardError => exc
     end
 
-    exc.module_name.should == 'YYY'
-    exc.line.should == 3
+    expect(exc.module_name).to eq('YYY')
+    expect(exc.line).to eq(3)
 
     engine.reset
 
@@ -507,8 +507,8 @@ describe 'Delorean' do
     rescue StandardError => exc
     end
 
-    exc.module_name.should == 'YYY'
-    exc.line.should == 2
+    expect(exc.module_name).to eq('YYY')
+    expect(exc.line).to eq(2)
   end
 
   it 'correctly report error line during parse' do
@@ -521,32 +521,32 @@ describe 'Delorean' do
     rescue StandardError => exc
     end
 
-    exc.module_name.should == 'YYY'
-    exc.line.should == 2
+    expect(exc.module_name).to eq('YYY')
+    expect(exc.line).to eq(2)
   end
 
   it 'should raise error on malformed string' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '  d = "testing"" ',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should not allow inherited ruby methods as attrs' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = name',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = new',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
   end
 
   it 'should be able to parse lists' do
@@ -559,19 +559,19 @@ describe 'Delorean' do
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = [',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = []-',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it "should handle trailing ',' with lists" do
@@ -581,19 +581,19 @@ describe 'Delorean' do
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = [,]',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = [1,2,,]',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should be able to parse hashes' do
@@ -605,19 +605,19 @@ describe 'Delorean' do
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = {',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = {}+',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should be able to parse conditional hash literals' do
@@ -634,19 +634,19 @@ describe 'Delorean' do
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = {,}',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
 
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = {-1:1,,}',
                        )
-    }.should raise_error(Delorean::ParseError)
+    end.to raise_error(Delorean::ParseError)
   end
 
   it 'should be able to parse list operations ' do
@@ -693,26 +693,26 @@ describe 'Delorean' do
   end
 
   it 'errors out on bad list comprehension' do
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    b = [i+1 for x in [1,2,3]]',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
     engine.reset
 
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    a = [123 for b in b]',
                        )
-    }.should raise_error(Delorean::UndefinedError)
+    end.to raise_error(Delorean::UndefinedError)
     engine.reset
 
     # disallow nested comprehension var reuse
-    lambda {
+    expect do
       engine.parse defn('A:',
                         '    b = [[a+1 for a in [4,5]] for a in [1,2,3]]',
                        )
-    }.should raise_error(Delorean::RedefinedError)
+    end.to raise_error(Delorean::RedefinedError)
     engine.reset
   end
 
@@ -815,7 +815,7 @@ describe 'Delorean' do
                        )
       raise
     rescue Delorean::ParseError => exc
-      exc.line.should == 2
+      expect(exc.line).to eq(2)
     end
   end
 
@@ -828,7 +828,7 @@ describe 'Delorean' do
                        )
       raise
     rescue Delorean::ParseError => exc
-      exc.line.should == 3
+      expect(exc.line).to eq(3)
     end
   end
 
@@ -842,7 +842,7 @@ describe 'Delorean' do
                        )
       raise
     rescue Delorean::ParseError => exc
-      exc.line.should == 3
+      expect(exc.line).to eq(3)
     end
   end
 
@@ -855,7 +855,7 @@ describe 'Delorean' do
                        )
       raise
     rescue Delorean::ParseError => exc
-      exc.line.should == 2
+      expect(exc.line).to eq(2)
     end
   end
 
@@ -867,7 +867,7 @@ describe 'Delorean' do
                        )
       raise
     rescue Delorean::ParseError => exc
-      exc.line.should == 2
+      expect(exc.line).to eq(2)
     end
   end