dentaku 3.2.0 → 3.5.1

data/spec/ast/or_spec.rb

@@ -6,30 +6,30 @@ describe 'Dentaku::AST::Or' do
   let(:calculator) { Dentaku::Calculator.new }
 
   it 'returns false if all of the arguments are false' do
-    result = Dentaku('OR(1 = "1", 0 = 1)')
-    expect(result).to eq false
+    result = Dentaku('OR(1 = "2", 0 = 1)')
+    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/pluck_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/pluck'
+require 'dentaku'
+
+describe Dentaku::AST::Pluck do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'operates on each value in an array' do
+    result = Dentaku('PLUCK(users, age)', users: [
+      {name: "Bob",  age: 44},
+      {name: "Jane", age: 27}
+    ])
+    expect(result).to eq([44, 27])
+  end
+
+  it 'works with an empty array' do
+    result = Dentaku('PLUCK(users, age)', users: [])
+    expect(result).to eq([])
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect do Dentaku.evaluate!('PLUCK(users, "age")', users: [
+      {name: "Bob",  age: 44},
+      {name: "Jane", age: 27}
+    ]) end.to raise_error(Dentaku::ArgumentError, 'PLUCK() requires second argument to be an identifier')
+  end
+
+  it 'raises argument error if a non array of hashes is passed as collection' do
+    expect { calculator.evaluate!('PLUCK({1, 2, 3}, age)') }.to raise_error(
+      Dentaku::ArgumentError, 'PLUCK() requires first argument to be an array of hashes'
+    )
+  end
+end

data/spec/ast/round_spec.rb

@@ -5,21 +5,31 @@ 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
+
+  context 'checking errors' do
+    it 'raises an error if first argument is not numeric' do
+      expect { Dentaku!("ROUND(2020-1-1, 0)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if places is not numeric' do
+      expect { Dentaku!("ROUND(1.8, 2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
   end
 end

data/spec/ast/rounddown_spec.rb

@@ -5,21 +5,31 @@ 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
+
+  context 'checking errors' do
+    it 'raises an error if first argument is not numeric' do
+      expect { Dentaku!("ROUND(2020-1-1, 0)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if places is not numeric' do
+      expect { Dentaku!("ROUND(1.8, 2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
   end
 end

data/spec/ast/roundup_spec.rb

@@ -5,21 +5,31 @@ 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
+
+  context 'checking errors' do
+    it 'raises an error if first argument is not numeric' do
+      expect { Dentaku!("ROUND(2020-1-1, 0)") }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if places is not numeric' do
+      expect { Dentaku!("ROUND(1.8, 2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
   end
 end

data/spec/ast/string_functions_spec.rb

@@ -25,6 +25,26 @@ describe Dentaku::AST::StringFunctions::Left do
   it 'handles size greater than input string length correctly' do
     expect(subject.value('string' => 'abcdefg', 'length' => 40)).to eq 'abcdefg'
   end
+
+  it 'accepts strings as length if they can be parsed to a number' do
+    expect(subject.value('string' => 'ABCDEFG', 'length' => '4')).to eq 'ABCD'
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+
+  it 'raises an error if given invalid length' do
+    expect {
+      subject.value('string' => 'abcdefg', 'length' => -2)
+    }.to raise_error(Dentaku::ArgumentError, /LEFT\(\) requires length to be positive/)
+  end
+
+  it 'raises an error when given a junk length' do
+    expect {
+      subject.value('string' => 'abcdefg', 'length' => 'junk')
+    }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Right do
@@ -42,6 +62,20 @@ describe Dentaku::AST::StringFunctions::Right do
     subject = described_class.new(literal('abcdefg'), literal(40))
     expect(subject.value).to eq 'abcdefg'
   end
+
+  it 'accepts strings as length if they can be parsed to a number' do
+    subject = described_class.new(literal('ABCDEFG'), literal('4'))
+    expect(subject.value).to eq 'DEFG'
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+
+  it 'raises an error when given a junk length' do
+    subject = described_class.new(literal('abcdefg'), literal('junk'))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Mid do
@@ -64,6 +98,25 @@ describe Dentaku::AST::StringFunctions::Mid do
     subject = described_class.new(literal('abcdefg'), literal(4), literal(40))
     expect(subject.value).to eq 'defg'
   end
+
+  it 'accepts strings as offset and length if they can be parsed to a number' do
+    subject = described_class.new(literal('ABCDEFG'), literal('4'), literal('2'))
+    expect(subject.value).to eq 'DE'
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+
+  it 'raises an error when given a junk offset' do
+    subject = described_class.new(literal('abcdefg'), literal('junk offset'), literal(2))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk offset' is not coercible to numeric")
+  end
+
+  it 'raises an error when given a junk length' do
+    subject = described_class.new(literal('abcdefg'), literal(4), literal('junk'))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Len do
@@ -76,6 +129,10 @@ describe Dentaku::AST::StringFunctions::Len do
     subject = described_class.new(literal(''))
     expect(subject.value).to eq 0
   end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:numeric)
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Find do
@@ -93,6 +150,10 @@ describe Dentaku::AST::StringFunctions::Find do
     subject = described_class.new(literal('DE'), literal(''))
     expect(subject.value).to be_nil
   end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:numeric)
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Substitute do
@@ -110,6 +171,10 @@ describe Dentaku::AST::StringFunctions::Substitute do
     subject = described_class.new(literal('ABCDEFG'), literal('DE'), literal(''))
     expect(subject.value).to eq 'ABCFG'
   end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Concat do
@@ -132,6 +197,10 @@ describe Dentaku::AST::StringFunctions::Concat do
     subject = described_class.new(literal(''), literal(''))
     expect(subject.value).to eq ''
   end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
 end
 
 describe Dentaku::AST::StringFunctions::Contains do
@@ -141,4 +210,8 @@ describe Dentaku::AST::StringFunctions::Contains do
     subject = described_class.new(literal('app'), literal('orange'))
     expect(subject.value).to be_falsy
   end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:logical)
+  end
 end

data/spec/ast/sum_spec.rb

@@ -5,34 +5,39 @@ 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
+
+    it 'does not raise an error if an empty array is passed' do
+      result = calculator.evaluate!('SUM(x)', x: [])
+      expect(result).to eq(0)
     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/ast/xor_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/ast/functions/or'
+
+describe 'Dentaku::AST::Xor' do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'returns false if all of the arguments are false' do
+    result = Dentaku('XOR(false, false)')
+    expect(result).to eq(false)
+  end
+
+  it 'returns true if only one of the arguments is true' do
+    result = Dentaku('XOR(false, true)')
+    expect(result).to eq(true)
+  end
+
+  it 'returns false if more than one of the arguments is true' do
+    result = Dentaku('XOR(false, true, true)')
+    expect(result).to eq(false)
+  end
+
+  it 'supports nested expressions' do
+    result = Dentaku('XOR(y = 1, x = 1)', x: 1, y: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises an error if no arguments are passed' do
+    expect { calculator.evaluate!('XOR()') }.to raise_error(Dentaku::ParseError)
+  end
+
+  it 'raises an error if a non logical argument is passed' do
+    expect { calculator.evaluate!('XOR("r")') }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/bulk_expression_solver_spec.rb

@@ -26,6 +26,13 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       }.to raise_error(Dentaku::UnboundVariableError)
     end
 
+    it "properly handles access on an unbound variable" do
+      expressions = {more_apples: "apples[0]"}
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::UnboundVariableError)
+    end
+
     it "lets you know if the result is a div/0 error" do
       expressions = {more_apples: "1/0"}
       expect {
@@ -39,6 +46,26 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(solver.solve!).to eq("the value of x, incremented" => 4)
     end
 
+    it "allows self-referential formulas" do
+      expressions = { x: "x + 1" }
+      solver = described_class.new(expressions, calculator.store(x: 1))
+      expect(solver.solve!).to eq(x: 2)
+
+      expressions = { x: "y + 3", y: "x * 2" }
+      solver = described_class.new(expressions, calculator.store(x: 5, y: 3))
+      expect(solver.solve!).to eq(x: 6, y: 12) # x = 6 by the time y is calculated
+    end
+
+    it "does not execute functions unnecessarily" do
+      calls = 0
+      external = ->() { calls += 1 }
+      hash = {test: 'EXTERNAL()'}
+      calculator = Dentaku::Calculator.new
+      calculator.add_function(:external, :numeric, external)
+      calculator.solve(hash)
+      expect(calls).to eq(1)
+    end
+
     it "evaluates expressions in hashes and arrays, and expands the results" do
       calculator.store(
         fruit_quantities: {
@@ -116,6 +143,15 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(exception.recipient_variable).to eq('more_apples')
     end
 
+    it 'stores the recipient variable on the exception when there is an ArgumentError' do
+      expressions = {apples: "NULL", more_apples: "1 + apples"}
+      exception = nil
+      described_class.new(expressions, calculator).solve do |ex|
+        exception = ex
+      end
+      expect(exception.recipient_variable).to eq('more_apples')
+    end
+
     it 'safely handles argument errors' do
       expressions = {i: "a / 5 + d", a: "m * 12", d: "a + b"}
       result = described_class.new(expressions, calculator.store(m: 3)).solve
@@ -137,7 +173,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