calculator_spec.rb in dentaku-3.1.0

- old
+ new

@@ -1,11 +1,13 @@
 require 'spec_helper'
 require 'dentaku'
 
 describe Dentaku::Calculator do
-  let(:calculator)  { described_class.new }
-  let(:with_memory) { described_class.new.store(apples: 3) }
+  let(:calculator)   { described_class.new }
+  let(:with_memory)  { described_class.new.store(apples: 3) }
+  let(:with_aliases) { described_class.new(aliases: { round: ['rrround'] }) }
+  let(:without_nested_data) { described_class.new(nested_data_support: false) }
 
   it 'evaluates an expression' do
     expect(calculator.evaluate('7+3')).to eq(10)
     expect(calculator.evaluate('2 -1')).to eq(1)
     expect(calculator.evaluate('-1 + 2')).to eq(1)
@@ -30,10 +32,11 @@
     expect(calculator.evaluate('15 % 8')).to eq(7)
     expect(calculator.evaluate('(((695759/735000)^(1/(1981-1991)))-1)*1000').round(4)).to eq(5.5018)
     expect(calculator.evaluate('0.253/0.253')).to eq(1)
     expect(calculator.evaluate('0.253/d', d: 0.253)).to eq(1)
     expect(calculator.evaluate('10 + x', x: 'abc')).to be_nil
+    expect(calculator.evaluate('x * y', x: '.123', y: '100')).to eq(12.3)
     expect(calculator.evaluate('a/b', a: '10', b: '2')).to eq(5)
     expect(calculator.evaluate('t + 1*24*60*60', t: Time.local(2017, 1, 1))).to eq(Time.local(2017, 1, 2))
     expect(calculator.evaluate("2 | 3 * 9")).to eq (27)
     expect(calculator.evaluate("2 & 3 * 9")).to eq (2)
   end
@@ -63,21 +66,25 @@
       calculator.store_formula('area', 'length * width')
       expect(calculator.evaluate!('area', length: 5, width: 5)).to eq 25
     end
 
     it 'stores nested hashes' do
-      calculator.store({a: {basket: {of: 'apples'}}, b: 2})
+      calculator.store(a: {basket: {of: 'apples'}}, b: 2)
       expect(calculator.evaluate!('a.basket.of')).to eq 'apples'
       expect(calculator.evaluate!('b')).to eq 2
     end
 
     it 'stores arrays' do
-      calculator.store({a: [1, 2, 3]})
+      calculator.store(a: [1, 2, 3])
       expect(calculator.evaluate!('a[0]')).to eq 1
       expect(calculator.evaluate!('a[x]', x: 1)).to eq 2
       expect(calculator.evaluate!('a[x+1]', x: 1)).to eq 3
     end
+
+    it 'evalutates arrays' do
+      expect(calculator.evaluate([1, 2, 3])).to eq([1, 2, 3])
+    end
   end
 
   describe 'dependencies' do
     it "finds dependencies in a generic statement" do
       expect(calculator.dependencies("bob + dole / 3")).to eq(['bob', 'dole'])
@@ -90,10 +97,14 @@
     end
 
     it "doesn't consider variables in memory as dependencies" do
       expect(with_memory.dependencies("apples + oranges")).to eq(['oranges'])
     end
+
+    it "finds no dependencies in array literals" do
+      expect(calculator.dependencies([1, 2, 3])).to eq([])
+    end
   end
 
   describe 'solve!' do
     it "evaluates properly with variables, even if some in memory" do
       expect(with_memory.solve!(
@@ -284,11 +295,11 @@
     it 'include ROUND' do
       expect(calculator.evaluate('round(8.2)')).to eq(8)
       expect(calculator.evaluate('round(8.8)')).to eq(9)
       expect(calculator.evaluate('round(8.75, 1)')).to eq(BigDecimal.new('8.8'))
 
-      expect(calculator.evaluate('ROUND(apples * 0.93)', { apples: 10 })).to eq(9)
+      expect(calculator.evaluate('ROUND(apples * 0.93)', apples: 10)).to eq(9)
     end
 
     it 'include NOT' do
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: true)).to be_falsey
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: false)).to be_truthy
@@ -481,15 +492,15 @@
     before do
       allow(Dentaku).to receive(:cache_ast?) { true }
     end
 
     it 'disables the AST cache' do
-      expect(calculator.disable_cache{ |c| c.cache_ast? }).to be false
+      expect(calculator.disable_cache { |c| c.cache_ast? }).to be false
     end
 
     it 'calculates normally' do
-      expect(calculator.disable_cache{ |c| c.evaluate("2 + 2") }).to eq(4)
+      expect(calculator.disable_cache { |c| c.evaluate("2 + 2") }).to eq(4)
     end
   end
 
   describe 'clear_cache' do
     before do
@@ -535,8 +546,30 @@
   describe 'zero-arity functions' do
     it 'can be used in formulas' do
       calculator.add_function(:two, :numeric, -> { 2 })
       expect(calculator.evaluate("max(two(), 1)")).to eq 2
       expect(calculator.evaluate("max(1, two())")).to eq 2
+    end
+  end
+
+  describe 'aliases' do
+    it 'accepts aliases as instance option' do
+      expect(with_aliases.evaluate('rrround(5.1)')).to eq 5
+    end
+  end
+
+  describe 'nested_data' do
+    it 'default to nested data enabled' do
+      expect(calculator.nested_data_support).to be_truthy
+    end
+
+    it 'allow opt out of nested data support' do
+      expect(without_nested_data.nested_data_support).to be_falsy
+    end
+
+    it 'should allow optout of nested hash' do
+      expect do
+        without_nested_data.solve!('a.b.c')
+      end.to raise_error(Dentaku::UnboundVariableError)
     end
   end
 end