dentaku 3.3.0 → 3.3.1

data/spec/ast/function_spec.rb

@@ -14,7 +14,7 @@ describe Dentaku::AST::Function do
     described_class.register("flarble", :string, -> { "flarble" })
     expect { described_class.get("flarble") }.not_to raise_error
     function = described_class.get("flarble").new
-    expect(function.value).to eq "flarble"
+    expect(function.value).to eq("flarble")
   end
 
   it 'does not throw an error when registering a function with a name that matches a currently defined constant' do
@@ -24,13 +24,13 @@ describe Dentaku::AST::Function do
   describe "#arity" do
     it "gives the correct arity for custom functions" do
       zero = described_class.register("zero", :numeric, ->() { 0 })
-      expect(zero.arity).to eq 0
+      expect(zero.arity).to eq(0)
 
       one = described_class.register("one", :numeric, ->(x) { x * 2 })
-      expect(one.arity).to eq 1
+      expect(one.arity).to eq(1)
 
       two = described_class.register("two", :numeric, ->(x, y) { x + y })
-      expect(two.arity).to eq 2
+      expect(two.arity).to eq(2)
 
       many = described_class.register("many", :numeric, ->(*args) { args.max })
       expect(many.arity).to be_nil
@@ -38,19 +38,19 @@ describe Dentaku::AST::Function do
   end
 
   it 'casts a String to an Integer if possible' do
-    expect(described_class.numeric('3')).to eq 3
+    expect(described_class.numeric('3')).to eq(3)
   end
 
   it 'casts a String to a BigDecimal if possible and if Integer would loose information' do
-    expect(described_class.numeric('3.2')).to eq 3.2
+    expect(described_class.numeric('3.2')).to eq(3.2)
   end
 
   it 'casts a String to a BigDecimal with a negative number' do
-    expect(described_class.numeric('-3.2')).to eq -3.2
+    expect(described_class.numeric('-3.2')).to eq(-3.2)
   end
 
   it 'casts a String to a BigDecimal without a leading zero' do
-    expect(described_class.numeric('-.2')).to eq -0.2
+    expect(described_class.numeric('-.2')).to eq(-0.2)
   end
 
   it 'raises an error if the value could not be cast to a Numeric' do

data/spec/ast/max_spec.rb

@@ -5,16 +5,16 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Max' do
   it 'returns the largest numeric value in an array of Numeric values' do
     result = Dentaku('MAX(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'returns the largest value even if a String is passed' do
     result = Dentaku('MAX(1, x, 1.8)', x: '2.3')
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'returns the largest value even if an Array is passed' do
     result = Dentaku('MAX(1, x, 1.8)', x: [1.5, 2.3, 1.7])
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 end

data/spec/ast/min_spec.rb

@@ -5,16 +5,16 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Min' do
   it 'returns the smallest numeric value in an array of Numeric values' do
     result = Dentaku('MIN(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 1
+    expect(result).to eq(1)
   end
 
   it 'returns the smallest value even if a String is passed' do
     result = Dentaku('MIN(1, x, 1.8)', x: '0.3')
-    expect(result).to eq 0.3
+    expect(result).to eq(0.3)
   end
 
   it 'returns the smallest value even if an Array is passed' do
     result = Dentaku('MIN(1, x, 1.8)', x: [1.5, 0.3, 1.7])
-    expect(result).to eq 0.3
+    expect(result).to eq(0.3)
   end
 end

data/spec/ast/mul_spec.rb

@@ -5,34 +5,34 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Mul' do
   it 'returns the product of an array of Numeric values' do
     result = Dentaku('MUL(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 4.14
+    expect(result).to eq(4.14)
   end
 
   it 'returns the product of a single entry array of a Numeric value' do
     result = Dentaku('MUL(x)', x: 2.3)
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'coerces string inputs to numeric' do
     result = Dentaku('mul(1, x, 1.8)', x: '2.3')
-    expect(result).to eq 4.14
+    expect(result).to eq(4.14)
   end
 
   it 'returns the product even if an array is passed' do
     result = Dentaku('mul(1, x, 2.3)', x: [4, 5])
-    expect(result).to eq 46
+    expect(result).to eq(46)
   end
 
   it 'handles nested calls' do
     result = Dentaku('mul(1, x, mul(4, 5))', x: '2.3')
-    expect(result).to eq 46
+    expect(result).to eq(46)
   end
 
   context 'checking errors' do
     let(:calculator) { Dentaku::Calculator.new }
 
     it 'raises an error if no arguments are passed' do
-      expect { calculator.evaluate!('MUL()') }.to raise_error(ArgumentError)
+      expect { calculator.evaluate!('MUL()') }.to raise_error(Dentaku::ArgumentError)
     end
   end
 end

data/spec/ast/node_spec.rb

@@ -6,30 +6,30 @@ require 'dentaku/parser'
 describe Dentaku::AST::Node do
   it 'returns list of dependencies' do
     node = make_node('x + 5')
-    expect(node.dependencies).to eq ['x']
+    expect(node.dependencies).to eq(['x'])
 
     node = make_node('5 < x')
-    expect(node.dependencies).to eq ['x']
+    expect(node.dependencies).to eq(['x'])
 
     node = make_node('5 < 7')
-    expect(node.dependencies).to eq []
+    expect(node.dependencies).to eq([])
 
     node = make_node('(y * 7)')
-    expect(node.dependencies).to eq ['y']
+    expect(node.dependencies).to eq(['y'])
 
     node = make_node('if(x > 5, y, z)')
-    expect(node.dependencies).to eq ['x', 'y', 'z']
+    expect(node.dependencies).to eq(['x', 'y', 'z'])
 
     node = make_node('if(x > 5, y, z)')
-    expect(node.dependencies('x' => 7)).to eq ['y', 'z']
+    expect(node.dependencies('x' => 7)).to eq(['y', 'z'])
 
     node = make_node('')
-    expect(node.dependencies).to eq []
+    expect(node.dependencies).to eq([])
   end
 
   it 'returns unique list of dependencies' do
     node = make_node('x + x')
-    expect(node.dependencies).to eq ['x']
+    expect(node.dependencies).to eq(['x'])
   end
 
   private

data/spec/ast/numeric_spec.rb

@@ -7,7 +7,7 @@ describe Dentaku::AST::Numeric do
   subject { described_class.new(Dentaku::Token.new(:numeric, 5)) }
 
   it 'has numeric type' do
-    expect(subject.type).to eq :numeric
+    expect(subject.type).to eq(:numeric)
   end
 
   it 'has no dependencies' do

data/spec/ast/or_spec.rb

@@ -7,29 +7,29 @@ describe 'Dentaku::AST::Or' do
 
   it 'returns false if all of the arguments are false' do
     result = Dentaku('OR(1 = "1", 0 = 1)')
-    expect(result).to eq false
+    expect(result).to eq(false)
   end
 
   it 'supports nested expressions' do
     result = Dentaku('OR(y = 1, x = 1)', x: 1, y: 2)
-    expect(result).to eq true
+    expect(result).to eq(true)
   end
 
   it 'returns true if any of the arguments is true' do
     result = Dentaku('OR(1 = "1", "2" = "2", true = false, false)')
-    expect(result).to eq true
+    expect(result).to eq(true)
   end
 
   it 'returns true if any nested OR function returns true' do
     result = Dentaku('OR(OR(1 = 0), OR(true = false, OR(true)))')
-    expect(result).to eq true
+    expect(result).to eq(true)
   end
 
   it 'raises an error if no arguments are passed' do
-    expect { calculator.evaluate!('OR()') }.to raise_error(ArgumentError)
+    expect { calculator.evaluate!('OR()') }.to raise_error(Dentaku::ArgumentError)
   end
 
   it 'raises an error if a non logical argument is passed' do
-    expect { calculator.evaluate!('OR("r")') }.to raise_error(ArgumentError)
+    expect { calculator.evaluate!('OR("r")') }.to raise_error(Dentaku::ArgumentError)
   end
 end

data/spec/ast/round_spec.rb

@@ -5,21 +5,21 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Round' do
   it 'returns the rounded down value' do
     result = Dentaku('ROUND(1.8)')
-    expect(result).to eq 2
+    expect(result).to eq(2)
   end
 
   it 'returns the rounded down value to the given precision' do
     result = Dentaku('ROUND(x, y)', x: 1.8453, y: 3)
-    expect(result).to eq 1.845
+    expect(result).to eq(1.845)
   end
 
   it 'returns the rounded down value to the given precision, also with strings' do
     result = Dentaku('ROUND(x, y)', x: '1.8453', y: '3')
-    expect(result).to eq 1.845
+    expect(result).to eq(1.845)
   end
 
   it 'returns the rounded down value to the given precision, also with nil' do
     result = Dentaku('ROUND(x, y)', x: '1.8453', y: nil)
-    expect(result).to eq 2
+    expect(result).to eq(2)
   end
 end

data/spec/ast/rounddown_spec.rb

@@ -5,21 +5,21 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Round' do
   it 'returns the rounded value' do
     result = Dentaku('ROUNDDOWN(1.8)')
-    expect(result).to eq 1
+    expect(result).to eq(1)
   end
 
   it 'returns the rounded value to the given precision' do
     result = Dentaku('ROUNDDOWN(x, y)', x: 1.8453, y: 3)
-    expect(result).to eq 1.845
+    expect(result).to eq(1.845)
   end
 
   it 'returns the rounded value to the given precision, also with strings' do
     result = Dentaku('ROUNDDOWN(x, y)', x: '1.8453', y: '3')
-    expect(result).to eq 1.845
+    expect(result).to eq(1.845)
   end
 
   it 'returns the rounded value to the given precision, also with nil' do
     result = Dentaku('ROUNDDOWN(x, y)', x: '1.8453', y: nil)
-    expect(result).to eq 1
+    expect(result).to eq(1)
   end
 end

data/spec/ast/roundup_spec.rb

@@ -5,21 +5,21 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Round' do
   it 'returns the rounded value' do
     result = Dentaku('ROUNDUP(1.8)')
-    expect(result).to eq 2
+    expect(result).to eq(2)
   end
 
   it 'returns the rounded value to the given precision' do
     result = Dentaku('ROUNDUP(x, y)', x: 1.8453, y: 3)
-    expect(result).to eq 1.846
+    expect(result).to eq(1.846)
   end
 
   it 'returns the rounded value to the given precision, also with strings' do
     result = Dentaku('ROUNDUP(x, y)', x: '1.8453', y: '3')
-    expect(result).to eq 1.846
+    expect(result).to eq(1.846)
   end
 
   it 'returns the rounded value to the given precision, also with nil' do
     result = Dentaku('ROUNDUP(x, y)', x: '1.8453', y: nil)
-    expect(result).to eq 2
+    expect(result).to eq(2)
   end
 end

data/spec/ast/sum_spec.rb

@@ -5,34 +5,34 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Sum' do
   it 'returns the sum of an array of Numeric values' do
     result = Dentaku('SUM(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 5.1
+    expect(result).to eq(5.1)
   end
 
   it 'returns the sum of a single entry array of a Numeric value' do
     result = Dentaku('SUM(x)', x: 2.3)
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'returns the sum even if a String is passed' do
     result = Dentaku('SUM(1, x, 1.8)', x: '2.3')
-    expect(result).to eq 5.1
+    expect(result).to eq(5.1)
   end
 
   it 'returns the sum even if an array is passed' do
     result = Dentaku('SUM(1, x, 2.3)', x: [4, 5])
-    expect(result).to eq 12.3
+    expect(result).to eq(12.3)
   end
 
   it 'returns the sum of nested sums' do
     result = Dentaku('SUM(1, x, SUM(4, 5))', x: '2.3')
-    expect(result).to eq 12.3
+    expect(result).to eq(12.3)
   end
 
   context 'checking errors' do
     let(:calculator) { Dentaku::Calculator.new }
 
     it 'raises an error if no arguments are passed' do
-      expect { calculator.evaluate!('SUM()') }.to raise_error(ArgumentError)
+      expect { calculator.evaluate!('SUM()') }.to raise_error(Dentaku::ArgumentError)
     end
   end
 end

data/spec/ast/switch_spec.rb

@@ -5,26 +5,26 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Switch' do
   it 'returns the match if present in argumtents' do
     result = Dentaku('SWITCH(1, 1, "one", 2, "two")')
-    expect(result).to eq 'one'
+    expect(result).to eq('one')
   end
 
   it 'returns nil if no match was found' do
     result = Dentaku('SWITCH(3, 1, "one", 2, "two")')
-    expect(result).to eq nil
+    expect(result).to eq(nil)
   end
 
   it 'returns the default value if present and no match was found' do
     result = Dentaku('SWITCH(3, 1, "one", 2, "two", "no match")')
-    expect(result).to eq 'no match'
+    expect(result).to eq('no match')
   end
 
   it 'returns the first match if multiple matches exist' do
     result = Dentaku('SWITCH(1, 1, "one", 2, "two", 1, "three")')
-    expect(result).to eq 'one'
+    expect(result).to eq('one')
   end
 
   it 'does not return a match where a value matches the search value' do
     result = Dentaku('SWITCH(1, "one", 1, 2, "two", 3)')
-    expect(result).to eq 3
+    expect(result).to eq(3)
   end
 end

data/spec/bulk_expression_solver_spec.rb

@@ -137,7 +137,7 @@ RSpec.describe Dentaku::BulkExpressionSolver do
         f: "e[0] + 1"
       }
       results = described_class.new(expressions, calculator).solve
-      expect(results[:f]).to eq 10
+      expect(results[:f]).to eq(10)
     end
 
     it 'uses stored values for expressions when they are known' do

data/spec/calculator_spec.rb

@@ -103,6 +103,10 @@ describe Dentaku::Calculator do
       expect { calculator.evaluate!('ROUNDUP(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('SUM(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
     end
+
+    it 'raises argument error if a function is called with incorrect arity' do
+      expect { calculator.evaluate!('IF(a,b)', a: 1, b: 1) }.to raise_error(Dentaku::ArgumentError)
+    end
   end
 
   it 'supports unicode characters in identifiers' do
@@ -121,31 +125,31 @@ describe Dentaku::Calculator do
 
     it 'can store the value `false`' do
       calculator.store('i_am_false', false)
-      expect(calculator.evaluate!('i_am_false')).to eq false
+      expect(calculator.evaluate!('i_am_false')).to eq(false)
     end
 
     it 'can store multiple values' do
       calculator.store(first: 1, second: 2)
-      expect(calculator.evaluate!('first')).to eq 1
-      expect(calculator.evaluate!('second')).to eq 2
+      expect(calculator.evaluate!('first')).to eq(1)
+      expect(calculator.evaluate!('second')).to eq(2)
     end
 
     it 'stores formulas' do
       calculator.store_formula('area', 'length * width')
-      expect(calculator.evaluate!('area', length: 5, width: 5)).to eq 25
+      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)
-      expect(calculator.evaluate!('a.basket.of')).to eq 'apples'
-      expect(calculator.evaluate!('b')).to eq 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])
-      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
+      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 'evaluates arrays' do
@@ -203,7 +207,7 @@ describe Dentaku::Calculator do
 
     it 'is case-insensitive' do
       result = with_memory.solve!(total_fruit: "Apples + pears", pears: 10)
-      expect(result[:total_fruit]).to eq 13
+      expect(result[:total_fruit]).to eq(13)
     end
 
     it "lets you know if a variable is unbound" do
@@ -223,7 +227,7 @@ describe Dentaku::Calculator do
         width:  "length * 2",
       )
 
-      expect(result[:weight]).to eq 130.368
+      expect(result[:weight]).to eq(130.368)
     end
 
     it 'raises an exception if there are cyclic dependencies' do
@@ -304,14 +308,14 @@ describe Dentaku::Calculator do
     unbound = 'foo * 1.5'
     expect { calculator.evaluate!(unbound) }.to raise_error(Dentaku::UnboundVariableError)
     expect { calculator.evaluate!(unbound) }.to raise_error do |error|
-      expect(error.unbound_variables).to eq ['foo']
+      expect(error.unbound_variables).to eq(['foo'])
     end
     expect { calculator.evaluate!('a + b') }.to raise_error do |error|
-      expect(error.unbound_variables).to eq ['a', 'b']
+      expect(error.unbound_variables).to eq(['a', 'b'])
     end
     expect(calculator.evaluate(unbound)).to be_nil
-    expect(calculator.evaluate(unbound) { :bar }).to eq :bar
-    expect(calculator.evaluate(unbound) { |e| e }).to eq unbound
+    expect(calculator.evaluate(unbound) { :bar }).to eq(:bar)
+    expect(calculator.evaluate(unbound) { |e| e }).to eq(unbound)
   end
 
   it 'fails to evaluate incomplete statements' do
@@ -390,7 +394,7 @@ describe Dentaku::Calculator do
     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(8.75, 1)')).to eq(BigDecimal('8.8'))
 
       expect(calculator.evaluate('ROUND(apples * 0.93)', apples: 10)).to eq(9)
     end
@@ -406,7 +410,7 @@ describe Dentaku::Calculator do
     it 'evaluates functions with negative numbers' do
       expect(calculator.evaluate('if (-1 < 5, -1, 5)')).to eq(-1)
       expect(calculator.evaluate('if (-1 = -1, -1, 5)')).to eq(-1)
-      expect(calculator.evaluate('round(-1.23, 1)')).to eq(BigDecimal.new('-1.2'))
+      expect(calculator.evaluate('round(-1.23, 1)')).to eq(BigDecimal('-1.2'))
       expect(calculator.evaluate('NOT(some_boolean) AND -1 > 3', some_boolean: true)).to be_falsey
     end
 
@@ -506,14 +510,14 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate(formula, number: 6)).to eq(2)
     end
 
-    it 'throws an exception when no match and there is no default value' do
+    it 'raises an exception when no match and there is no default value' do
       formula = <<-FORMULA
       CASE number
       WHEN 42
         THEN 1
       END
       FORMULA
-      expect { calculator.evaluate(formula, number: 2) }
+      expect { calculator.evaluate!(formula, number: 2) }
         .to raise_error("No block matched the switch value '2'")
     end
 
@@ -579,9 +583,9 @@ describe Dentaku::Calculator do
     Math.methods(false).each do |method|
       it method do
         if Math.method(method).arity == 2
-          expect(calculator.evaluate("#{method}(x,y)", x: 1, y: '2')).to eq Math.send(method, 1, 2)
+          expect(calculator.evaluate("#{method}(x,y)", x: 1, y: '2')).to eq(Math.send(method, 1, 2))
         else
-          expect(calculator.evaluate("#{method}(1)")).to eq Math.send(method, 1)
+          expect(calculator.evaluate("#{method}(1)")).to eq(Math.send(method, 1))
         end
       end
     end
@@ -615,7 +619,7 @@ describe Dentaku::Calculator do
     end
 
     it 'clears all items from cache' do
-      expect(calculator.ast_cache.length).to eq 3
+      expect(calculator.ast_cache.length).to eq(3)
       calculator.clear_cache
       expect(calculator.ast_cache.keys).to be_empty
     end
@@ -638,21 +642,21 @@ describe Dentaku::Calculator do
     it 'concatenates strings' do
       expect(
         calculator.evaluate('CONCAT(s1, s2, s3)', 's1' => 'ab', 's2' => 'cd', 's3' => 'ef')
-      ).to eq 'abcdef'
+      ).to eq('abcdef')
     end
   end
 
   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
+      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
+      expect(with_aliases.evaluate('rrround(5.1)')).to eq(5)
     end
   end