dentaku 3.3.3 → 3.4.2

data/lib/dentaku/calculator.rb

@@ -59,10 +59,10 @@ module Dentaku
       store(data) do
         node = expression
         node = ast(node) unless node.is_a?(AST::Node)
-        unbound = node.dependencies - memory.keys
+        unbound = node.dependencies(memory)
         unless unbound.empty?
           raise UnboundVariableError.new(unbound),
-                "no value provided for variables: #{unbound.join(', ')}"
+                "no value provided for variables: #{unbound.uniq.join(', ')}"
         end
         node.value(memory)
       end
@@ -77,13 +77,21 @@ module Dentaku
     end
 
     def dependencies(expression, context = {})
-      if expression.is_a? Array
-        return expression.flat_map { |e| dependencies(e, context) }
+      test_context = context.nil? ? {} : store(context) { memory }
+
+      case expression
+      when Dentaku::AST::Node
+        expression.dependencies(test_context)
+      when Array
+        expression.flat_map { |e| dependencies(e, context) }
+      else
+        ast(expression).dependencies(test_context)
       end
-      store(context) { ast(expression).dependencies(memory) }
     end
 
     def ast(expression)
+      return expression.map { |e| ast(e) } if expression.is_a? Array
+
       @ast_cache.fetch(expression) {
         options = {
           case_sensitive: case_sensitive,
@@ -119,7 +127,7 @@ module Dentaku
       restore = Hash[memory]
 
       if value.nil?
-        key_or_hash = FlatHash.from_hash(key_or_hash) if nested_data_support
+        key_or_hash = FlatHash.from_hash_with_intermediates(key_or_hash) if nested_data_support
         key_or_hash.each do |key, val|
           memory[standardize_case(key.to_s)] = val
         end

data/lib/dentaku/date_arithmetic.rb

@@ -25,7 +25,7 @@ module Dentaku
 
     def sub(duration)
       case duration
-      when Numeric
+      when DateTime, Numeric
         @base - duration
       when Dentaku::AST::Duration::Value
         case duration.unit

data/lib/dentaku/exceptions.rb

@@ -44,7 +44,7 @@ module Dentaku
         raise ::ArgumentError, "Unhandled #{reason}"
       end
 
-      new reason, meta
+      new(reason, **meta)
     end
   end
 
@@ -68,7 +68,7 @@ module Dentaku
         raise ::ArgumentError, "Unhandled #{reason}"
       end
 
-      new reason, meta
+      new(reason, **meta)
     end
   end
 
@@ -92,7 +92,7 @@ module Dentaku
         raise ::ArgumentError, "Unhandled #{reason}"
       end
 
-      new reason, meta
+      new(reason, **meta)
     end
   end
 

data/lib/dentaku/flat_hash.rb

@@ -6,6 +6,13 @@ module Dentaku
       flatten_keys(acc)
     end
 
+    def self.from_hash_with_intermediates(h, key = [], acc = {})
+      acc.update(key => h) unless key.empty?
+      return unless h.is_a? Hash
+      h.each { |k, v| from_hash_with_intermediates(v, key + [k], acc) }
+      flatten_keys(acc)
+    end
+
     def self.flatten_keys(hash)
       hash.each_with_object({}) do |(k, v), h|
         h[flatten_key(k)] = v

data/lib/dentaku/parser.rb

@@ -51,6 +51,7 @@ module Dentaku
         fail! :too_many_operands, operator: operator, expect: max_size, actual: output.length
       end
 
+      fail! :invalid_statement if output.size < args_size
       args = Array.new(args_size) { output.pop }.reverse
 
       output.push operator.new(*args)
@@ -335,7 +336,7 @@ module Dentaku
           raise ::ArgumentError, "Unhandled #{reason}"
         end
 
-      raise ParseError.for(reason, meta), message
+      raise ParseError.for(reason, **meta), message
     end
   end
 end

data/lib/dentaku/tokenizer.rb

@@ -104,7 +104,7 @@ module Dentaku
           raise ::ArgumentError, "Unhandled #{reason}"
         end
 
-      raise TokenizerError.for(reason, meta), message
+      raise TokenizerError.for(reason, **meta), message
     end
   end
 end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.3.3"
+  VERSION = "3.4.2"
 end

data/spec/ast/arithmetic_spec.rb

@@ -4,11 +4,12 @@ require 'dentaku/ast/arithmetic'
 require 'dentaku/token'
 
 describe Dentaku::AST::Arithmetic do
-  let(:one) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
-  let(:two) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
-  let(:x)   { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
-  let(:y)   { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
-  let(:ctx) { {'x' => 1, 'y' => 2} }
+  let(:one)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
+  let(:two)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
+  let(:x)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
+  let(:y)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
+  let(:ctx)  { {'x' => 1, 'y' => 2} }
+  let(:date) { Dentaku::AST::DateTime.new Dentaku::Token.new(:datetime, DateTime.new(2020, 4, 16)) }
 
   it 'performs an arithmetic operation with numeric operands' do
     expect(add(one, two)).to eq(3)
@@ -46,6 +47,19 @@ describe Dentaku::AST::Arithmetic do
     expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
   end
 
+  it 'performs arithmetic on arrays' do
+    expect(add(x, y, 'x' => [1], 'y' => [2])).to eq([1, 2])
+  end
+
+  it 'performs date arithmetic' do
+    expect(add(date, one)).to eq(DateTime.new(2020, 4, 17))
+  end
+
+  it 'raises ArgumentError if given individually valid but incompatible arguments' do
+    expect { add(one, date) }.to raise_error(Dentaku::ArgumentError)
+    expect { add(x, one, 'x' => [1]) }.to raise_error(Dentaku::ArgumentError)
+  end
+
   private
 
   def add(left, right, context = ctx)

data/spec/ast/avg_spec.rb

@@ -29,5 +29,9 @@ describe 'Dentaku::AST::Function::Avg' do
     it 'raises an error if no arguments are passed' do
       expect { calculator.evaluate!('AVG()') }.to raise_error(Dentaku::ArgumentError)
     end
+
+    it 'raises an error if an empty array is passed' do
+      expect { calculator.evaluate!('AVG(x)', x: []) }.to raise_error(Dentaku::ArgumentError)
+    end
   end
 end

data/spec/ast/filter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/filter'
+require 'dentaku'
+
+describe Dentaku::AST::Filter do
+  it 'excludes unmatched values' do
+    result = Dentaku('SUM(FILTER(vals, val, val > 1))', vals: [1, 2, 3])
+    expect(result).to eq(5)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 1)
+    expect(result).to eq([])
+
+    result = Dentaku('FILTER(vals, val, val > 1)', vals: 2)
+    expect(result).to eq([2])
+  end
+end

data/spec/ast/map_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/map'
+require 'dentaku'
+
+describe Dentaku::AST::Map do
+  it 'operates on each value in an array' do
+    result = Dentaku('SUM(MAP(vals, val, val + 1))', vals: [1, 2, 3])
+    expect(result).to eq(9)
+  end
+
+  it 'works with an empty array' do
+    result = Dentaku('MAP(vals, val, val + 1)', vals: [])
+    expect(result).to eq([])
+  end
+end

data/spec/ast/max_spec.rb

@@ -17,4 +17,17 @@ describe 'Dentaku::AST::Function::Max' do
     result = Dentaku('MAX(1, x, 1.8)', x: [1.5, 2.3, 1.7])
     expect(result).to eq(2.3)
   end
+
+  it 'returns the largest value if only an Array is passed' do
+    result = Dentaku('MAX(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(2.3)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MAX(x)', x: [])).to eq(nil)
+    end
+  end
 end

data/spec/ast/min_spec.rb

@@ -17,4 +17,17 @@ describe 'Dentaku::AST::Function::Min' do
     result = Dentaku('MIN(1, x, 1.8)', x: [1.5, 0.3, 1.7])
     expect(result).to eq(0.3)
   end
+
+  it 'returns the smallest value if only an Array is passed' do
+    result = Dentaku('MIN(x)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq(1.5)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'does not raise an error if an empty array is passed' do
+      expect(calculator.evaluate!('MIN(x)', x: [])).to eq(nil)
+    end
+  end
 end

data/spec/ast/mul_spec.rb

@@ -34,5 +34,10 @@ describe 'Dentaku::AST::Function::Mul' do
     it 'raises an error if no arguments are passed' do
       expect { calculator.evaluate!('MUL()') }.to raise_error(Dentaku::ArgumentError)
     end
+
+    it 'does not raise an error if an empty array is passed' do
+      result = calculator.evaluate!('MUL(x)', x: [])
+      expect(result).to eq(1)
+    end
   end
 end

data/spec/ast/negation_spec.rb

@@ -4,8 +4,9 @@ require 'dentaku/ast/arithmetic'
 require 'dentaku/token'
 
 describe Dentaku::AST::Negation do
-  let(:five) { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 5) }
-  let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
+  let(:five) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 5) }
+  let(:t)    { Dentaku::AST::Logical.new Dentaku::Token.new(:logical, true) }
+  let(:x)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
 
   it 'allows access to its sub-node' do
     node = described_class.new(five)
@@ -29,4 +30,19 @@ describe Dentaku::AST::Negation do
       described_class.new(group)
     }.not_to raise_error
   end
+
+  it 'correctly parses string operands to numeric values' do
+    node = described_class.new(x)
+    expect(node.value('x' => '5')).to eq(-5)
+  end
+
+  it 'raises error if input string is not coercible to numeric' do
+    node = described_class.new(x)
+    expect { node.value('x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
+  end
+
+  it 'raises error if given a non-numeric argument' do
+    node = described_class.new(x)
+    expect { node.value('x' => true) }.to raise_error(Dentaku::ArgumentError)
+  end
 end

data/spec/ast/round_spec.rb

@@ -22,4 +22,14 @@ describe 'Dentaku::AST::Function::Round' do
     result = Dentaku('ROUND(x, y)', x: '1.8453', y: nil)
     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

@@ -22,4 +22,14 @@ describe 'Dentaku::AST::Function::Round' do
     result = Dentaku('ROUNDDOWN(x, y)', x: '1.8453', y: nil)
     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

@@ -22,4 +22,14 @@ describe 'Dentaku::AST::Function::Round' do
     result = Dentaku('ROUNDUP(x, y)', x: '1.8453', y: nil)
     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

@@ -26,6 +26,10 @@ describe Dentaku::AST::StringFunctions::Left 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
@@ -35,6 +39,12 @@ describe Dentaku::AST::StringFunctions::Left do
       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
@@ -53,9 +63,19 @@ describe Dentaku::AST::StringFunctions::Right do
     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
@@ -79,9 +99,24 @@ describe Dentaku::AST::StringFunctions::Mid do
     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

data/spec/ast/sum_spec.rb

@@ -34,5 +34,10 @@ describe 'Dentaku::AST::Function::Sum' do
     it 'raises an error if no arguments are passed' do
       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/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: {