delorean_lang 0.5.1 → 0.5.2

data/spec/func_spec.rb

@@ -1,298 +1,294 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+# frozen_string_literal: true
 
-describe "Delorean" do
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-  let(:engine) {
-    Delorean::Engine.new("ZZZ")
-  }
+describe 'Delorean' do
+  let(:engine) do
+    Delorean::Engine.new('ZZZ')
+  end
 
-  it "should handle MAX as a node name" do
-    engine.parse defn("MAX:",
-                      "    a = [1, 2, 3, 0, -10].max()",
-                      )
+  it 'should handle MAX as a node name' do
+    engine.parse defn('MAX:',
+                      '    a = [1, 2, 3, 0, -10].max()',
+                     )
 
-    r = engine.evaluate("MAX", "a")
+    r = engine.evaluate('MAX', 'a')
     r.should == 3
   end
 
-  it "should handle COMPACT" do
-    engine.parse defn("A:",
-                      "    a = [1, 2, nil, -3, 4].compact",
+  it 'should handle COMPACT' do
+    engine.parse defn('A:',
+                      '    a = [1, 2, nil, -3, 4].compact',
                       "    b = {'a': 1, 'b': nil, 'c': nil}.compact()",
-                      )
+                     )
 
-    expect(engine.evaluate("A", "a")).to eq([1, 2, -3, 4])
-    expect(engine.evaluate("A", "b")).to eq({"a" => 1})
+    expect(engine.evaluate('A', 'a')).to eq([1, 2, -3, 4])
+    expect(engine.evaluate('A', 'b')).to eq('a' => 1)
   end
 
-  it "should handle MIN" do
-    engine.parse defn("A:",
-                      "    a = [1, 2, -3, 4].min()",
-                      )
+  it 'should handle MIN' do
+    engine.parse defn('A:',
+                      '    a = [1, 2, -3, 4].min()',
+                     )
 
-    r = engine.evaluate("A", "a")
+    r = engine.evaluate('A', 'a')
     r.should == -3
   end
 
-  it "should handle ROUND" do
-    engine.parse defn("A:",
-                      "    a = 12.3456.round(2)",
-                      "    b = 12.3456.round(1)",
-                      "    c = 12.3456.round()",
-                      )
+  it 'should handle ROUND' do
+    engine.parse defn('A:',
+                      '    a = 12.3456.round(2)',
+                      '    b = 12.3456.round(1)',
+                      '    c = 12.3456.round()',
+                     )
 
-    r = engine.evaluate("A", ["a", "b", "c"])
+    r = engine.evaluate('A', ['a', 'b', 'c'])
     r.should == [12.35, 12.3, 12]
   end
 
-  it "should handle TRUNCATE" do
-    engine.parse defn("A:",
-                      "    a = 12.3456.truncate(2)",
-                      "    b = 12.3456.truncate(1)",
-                      "    c = 12.3456.truncate()",
-                      )
+  it 'should handle TRUNCATE' do
+    engine.parse defn('A:',
+                      '    a = 12.3456.truncate(2)',
+                      '    b = 12.3456.truncate(1)',
+                      '    c = 12.3456.truncate()',
+                     )
 
-    r = engine.evaluate("A", ["a", "b", "c"])
+    r = engine.evaluate('A', ['a', 'b', 'c'])
     r.should == [12.34, 12.3, 12]
   end
 
-  it "should handle FLOOR" do
-    engine.parse defn("A:",
-                      "    a = [12.3456.floor(), 13.7890.floor()]",
-                      )
+  it 'should handle FLOOR' do
+    engine.parse defn('A:',
+                      '    a = [12.3456.floor(), 13.7890.floor()]',
+                     )
 
-    r = engine.evaluate("A", "a")
+    r = engine.evaluate('A', 'a')
     r.should == [12, 13]
   end
 
-  it "should handle TO_F" do
-    engine.parse defn("A:",
-                      "    a = 12.3456.to_f()",
+  it 'should handle TO_F' do
+    engine.parse defn('A:',
+                      '    a = 12.3456.to_f()',
                       "    b = '12.3456'.to_f()",
                       "    c = '12'.to_f()",
                       "    d = '2018-05-04 10:56:27 -0700'.to_time.to_f",
-                      )
+                     )
 
-    r = engine.evaluate("A", ["a", "b", "c", "d"])
-    r.should == [12.3456, 12.3456, 12, 1525456587.0]
+    r = engine.evaluate('A', ['a', 'b', 'c', 'd'])
+    r.should == [12.3456, 12.3456, 12, 1_525_456_587.0]
   end
 
-  it "should handle ABS" do
-    engine.parse defn("A:",
-                      "    a = (-123).abs()",
-                      "    b = (-1.1).abs()",
-                      "    c = 2.3.abs()",
-                      "    d = 0.abs()",
-                      )
+  it 'should handle ABS' do
+    engine.parse defn('A:',
+                      '    a = (-123).abs()',
+                      '    b = (-1.1).abs()',
+                      '    c = 2.3.abs()',
+                      '    d = 0.abs()',
+                     )
 
-    r = engine.evaluate("A", ["a", "b", "c", "d"])
+    r = engine.evaluate('A', ['a', 'b', 'c', 'd'])
     r.should == [123, 1.1, 2.3, 0]
   end
 
-  it "should handle STRING" do
-    engine.parse defn("A:",
+  it 'should handle STRING' do
+    engine.parse defn('A:',
                       "    a = 'hello'.to_s()",
-                      "    b = 12.3456.to_s()",
-                      "    c = [1,2,3].to_s()",
-                      )
+                      '    b = 12.3456.to_s()',
+                      '    c = [1,2,3].to_s()',
+                     )
 
-    r = engine.evaluate("A", ["a", "b", "c"])
-    r.should == ["hello", '12.3456', [1,2,3].to_s]
+    r = engine.evaluate('A', ['a', 'b', 'c'])
+    r.should == ['hello', '12.3456', [1, 2, 3].to_s]
   end
 
-  it "should handle FETCH" do
-    engine.parse defn("A:",
+  it 'should handle FETCH' do
+    engine.parse defn('A:',
                       "    h = {'a':123, 1:111}",
                       "    a = h.fetch('a')",
-                      "    b = h.fetch(1)",
+                      '    b = h.fetch(1)',
                       "    c = h.fetch('xxx', 456)",
-                      )
+                     )
 
-    r = engine.evaluate("A", ["a", "b", "c"])
+    r = engine.evaluate('A', ['a', 'b', 'c'])
     r.should == [123, 111, 456]
   end
 
-  it "should handle TIMEPART" do
-    engine.parse defn("A:",
-                      "    p =?",
-                      "    h = p.hour()",
-                      "    m = p.min()",
-                      "    s = p.sec()",
-                      "    d = p.to_date()",
-                      "    e = p.to_date.to_s.to_date",
-                      )
+  it 'should handle TIMEPART' do
+    engine.parse defn('A:',
+                      '    p =?',
+                      '    h = p.hour()',
+                      '    m = p.min()',
+                      '    s = p.sec()',
+                      '    d = p.to_date()',
+                      '    e = p.to_date.to_s.to_date',
+                     )
 
     p = Time.now
-    params = {"p" => p}
-    r = engine.evaluate("A", %w{h m s d e}, params)
+    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]
 
     # 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
   end
 
-  it "should handle DATEPART" do
-    engine.parse defn("A:",
-                      "    p =?",
-                      "    y = p.year()",
-                      "    d = p.day()",
-                      "    m = p.month()",
-                      )
+  it 'should handle DATEPART' do
+    engine.parse defn('A:',
+                      '    p =?',
+                      '    y = p.year()',
+                      '    d = p.day()',
+                      '    m = p.month()',
+                     )
 
     p = Date.today
-    r = engine.evaluate("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("A", ["y", "d", "m"], {"p" => 123})
-    }.to raise_error
+    expect do
+      engine.evaluate('A', ['y', 'd', 'm'], 'p' => 123)
+    end.to raise_error
   end
 
-  it "should handle FLATTEN" do
-    x = [[1,2,[3]], 4, 5, [6]]
+  it 'should handle FLATTEN' do
+    x = [[1, 2, [3]], 4, 5, [6]]
 
-    engine.parse defn("A:",
+    engine.parse defn('A:',
                       "    a = #{x}",
-                      "    b = a.flatten() + a.flatten(1)"
-                      )
+                      '    b = a.flatten() + a.flatten(1)'
+                     )
 
-    engine.evaluate("A", "b").should == x.flatten + x.flatten(1)
+    engine.evaluate('A', 'b').should == x.flatten + x.flatten(1)
   end
 
-  it "should handle ZIP" do
+  it 'should handle ZIP' do
     a = [1, 2]
     b = [4, 5, 6]
     c = [7, 8]
 
-    engine.parse defn("A:",
+    engine.parse defn('A:',
                       "    a = #{a}",
                       "    b = #{b}",
                       "    c = #{c}",
-                      "    d = a.zip(b) + a.zip(b, c)",
-                      )
+                      '    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
-    engine.parse defn("A:",
+  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')
+    expect { engine.evaluate('A', 'a') }.to raise_error('hello')
 
     lambda {
-      r = engine.evaluate("A", "b")
-    }.should raise_error("xx, 1, 2, 3")
+      engine.evaluate('A', 'b')
+    }.should raise_error('xx, 1, 2, 3')
   end
 
-  it "should handle RUBY" do
+  it 'should handle RUBY' do
     x = [[1, 2, [-3]], 4, 5, [6], -3, 4, 5, 0]
 
-    engine.parse defn("A:",
+    engine.parse defn('A:',
                       "    a = #{x}",
-                      "    b = a.flatten()",
-                      "    c = a.flatten(1)",
-                      "    d = b+c",
-                      "    dd = d.flatten()",
-                      "    e = dd.sort()",
-                      "    f = e.uniq()",
-                      "    g = e.length",
-                      "    gg = a.length()",
-                      "    l = a.member(5)",
-                      "    m = [a.member(5), a.member(55)]",
+                      '    b = a.flatten()',
+                      '    c = a.flatten(1)',
+                      '    d = b+c',
+                      '    dd = d.flatten()',
+                      '    e = dd.sort()',
+                      '    f = e.uniq()',
+                      '    g = e.length',
+                      '    gg = a.length()',
+                      '    l = a.member(5)',
+                      '    m = [a.member(5), a.member(55)]',
                       "    n = {'a':1, 'b':2, 'c':3}.length()",
                       "    o = 'hello'.length",
-                      )
-
-    engine.evaluate("A", "c").should == x.flatten(1)
-    d = engine.evaluate("A", "d").should == 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
+                     )
+
+    engine.evaluate('A', 'c').should == x.flatten(1)
+    engine.evaluate('A', 'd').should == 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
   end
 
-  it "should be able to call function on hash" do
+  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",
+    engine.parse defn('A:',
+                      '    n = {}.length',
                       "    m = {'length':100}.length",
-                      )
-    engine.evaluate("A", "n").should == 0
-    engine.evaluate("A", "m").should == 100
+                     )
+    engine.evaluate('A', 'n').should == 0
+    engine.evaluate('A', 'm').should == 100
   end
 
-  it "should be able to call hash except" do
-    engine.parse defn("A:",
+  it 'should be able to call hash except' do
+    engine.parse defn('A:',
                       "    h = {'a': 1, 'b':2, 'c': 3}",
                       "    e = h.except('a', 'c')",
-                      )
-    expect(engine.evaluate("A", "e")).to eq({"b"=>2})
+                     )
+    expect(engine.evaluate('A', 'e')).to eq('b' => 2)
   end
 
-  it "should handle RUBY slice function" do
+  it 'should handle RUBY slice function' do
     x = [[1, 2, [-3]], 4, [5, 6], -3, 4, 5, 0]
 
-    engine.parse defn("A:",
+    engine.parse defn('A:',
                       "    a = #{x}",
-                      "    b = a.slice(0, 4)",
-                      )
-    engine.evaluate("A", "b").should == x.slice(0,4)
+                      '    b = a.slice(0, 4)',
+                     )
+    engine.evaluate('A', 'b').should == x.slice(0, 4)
   end
 
-  it "should handle RUBY empty? function" do
-    engine.parse defn("A:",
-                      "    a0 = []",
-                      "    b0 = {}",
-                      "    c0 = {-}",
-                      "    a1 = [1,2,3]",
+  it 'should handle RUBY empty? function' do
+    engine.parse defn('A:',
+                      '    a0 = []',
+                      '    b0 = {}',
+                      '    c0 = {-}',
+                      '    a1 = [1,2,3]',
                       "    b1 = {'a': 1, 'b':2}",
-                      "    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]
+                      '    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]
   end
 
-  it "should handle BETWEEN" do
-    engine.parse defn("A:",
-                      "    a = 1.23",
-                      "    number_between = [a.between(10,20), a.between(1,3)]",
-
+  it 'should handle BETWEEN' do
+    engine.parse defn('A:',
+                      '    a = 1.23',
+                      '    number_between = [a.between(10,20), a.between(1,3)]',
                       "    c = 'c'",
                       "    string_between = [c.between('a', 'd'), c.between('d', 'e')]",
-
                       "    types_mismatch1 = [a.between('a', 'd')]",
-                      "    types_mismatch2 = [c.between(1, 3)]"
-                      )
+                      '    types_mismatch2 = [c.between(1, 3)]'
+                     )
 
-    expect(engine.evaluate("A", "number_between")).to eq([false, true])
-    expect(engine.evaluate("A", "string_between")).to eq([true, false])
+    expect(engine.evaluate('A', 'number_between')).to eq([false, true])
+    expect(engine.evaluate('A', 'string_between')).to eq([true, false])
 
-    expect { engine.evaluate("A", "types_mismatch1") }.to raise_error(/bad arg/)
-    expect { engine.evaluate("A", "types_mismatch2") }.to raise_error(/bad arg/)
+    expect { engine.evaluate('A', 'types_mismatch1') }.to raise_error(/bad arg/)
+    expect { engine.evaluate('A', 'types_mismatch2') }.to raise_error(/bad arg/)
   end
 
-
-  it "should handle MATCH" do
-    engine.parse defn("A:",
+  it 'should handle MATCH' do
+    engine.parse defn('A:',
                       "    a = 'this is a test'.match('(.*)( is )(.*)')",
-                      "    b = [a[0], a[1], a[2], a[3], a[4]]",
-                      )
+                      '    b = [a[0], a[1], a[2], a[3], a[4]]',
+                     )
 
-    expect(engine.evaluate("A", "b")).
-      to eq(["this is a test", "this", " is ", "a test", nil])
+    expect(engine.evaluate('A', 'b'))
+      .to eq(['this is a test', 'this', ' is ', 'a test', nil])
   end
-
 end