dentaku 3.3.4 → 3.4.1

data/lib/dentaku/ast/functions/string_functions.rb

@@ -32,7 +32,7 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = @length.value(context)
+          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
           negative_argument_failure('LEFT') if length < 0
           string[0, length]
         end
@@ -54,7 +54,7 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = @length.value(context)
+          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
           negative_argument_failure('RIGHT') if length < 0
           string[length * -1, length] || string
         end
@@ -76,9 +76,9 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          offset = @offset.value(context)
+          offset = Dentaku::AST::Function.numeric(@offset.value(context)).to_i
           negative_argument_failure('MID', 'offset') if offset < 0
-          length = @length.value(context)
+          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
           negative_argument_failure('MID') if length < 0
           string[offset - 1, length].to_s
         end

data/lib/dentaku/ast/functions/sum.rb

@@ -1,12 +1,13 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:sum, :numeric, ->(*args) {
-  if args.empty?
+  flatten_args = args.flatten
+  if flatten_args.empty?
     raise Dentaku::ArgumentError.for(
         :too_few_arguments,
         function_name: 'SUM()', at_least: 1, given: 0
     ), 'SUM() requires at least one argument'
   end
 
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+)
+  flatten_args.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+)
 })

data/lib/dentaku/ast/grouping.rb

@@ -1,6 +1,8 @@
+require_relative "./node"
+
 module Dentaku
   module AST
-    class Grouping
+    class Grouping < Node
       def initialize(node)
         @node = node
       end

data/lib/dentaku/ast/identifier.rb

@@ -20,7 +20,9 @@ module Dentaku
 
         case v
         when Node
-          v.value(context)
+          value = v.value(context)
+          context[identifier] = value if Dentaku.cache_identifier?
+          value
         when Proc
           v.call
         else

data/lib/dentaku/bulk_expression_solver.rb

@@ -53,40 +53,55 @@ module Dentaku
     end
 
     def expression_with_exception_handler(&block)
-      ->(expr, ex) { block.call(ex) }
+      ->(_expr, ex) { block.call(ex) }
     end
 
     def load_results(&block)
-      variables_in_resolve_order.each_with_object({}) do |var_name, r|
-        begin
-          solved = calculator.memory
-          value_from_memory = solved[var_name.downcase]
-
-          if value_from_memory.nil? &&
-              expressions[var_name].nil? &&
-              !solved.has_key?(var_name)
-            next
-          end
-
-          value = value_from_memory || evaluate!(
+      facts, _formulas = expressions.transform_keys(&:downcase)
+                                    .transform_values { |v| calculator.ast(v) }
+                                    .partition { |_, v| calculator.dependencies(v, nil).empty? }
+
+      evaluated_facts = facts.to_h.each_with_object({}) do |(var_name, ast), h|
+        with_rescues(var_name, h, block) do
+          h[var_name] = ast.is_a?(Array) ? ast.map(&:value) : ast.value
+        end
+      end
+
+      context = calculator.memory.merge(evaluated_facts)
+
+      variables_in_resolve_order.each_with_object({}) do |var_name, results|
+        next if expressions[var_name].nil?
+
+        with_rescues(var_name, results, block) do
+          results[var_name] = evaluated_facts[var_name] || calculator.evaluate!(
             expressions[var_name],
-            expressions.merge(r).merge(solved),
+            context.merge(results),
             &expression_with_exception_handler(&block)
           )
-
-          r[var_name] = value
-        rescue UnboundVariableError, Dentaku::ZeroDivisionError => ex
-          ex.recipient_variable = var_name
-          r[var_name] = block.call(ex)
-        rescue Dentaku::ArgumentError => ex
-          r[var_name] = block.call(ex)
         end
       end
+
     rescue TSort::Cyclic => ex
       block.call(ex)
       {}
     end
 
+    def with_rescues(var_name, results, block)
+      yield
+
+    rescue UnboundVariableError,  Dentaku::ZeroDivisionError => ex
+      ex.recipient_variable = var_name
+      results[var_name] = block.call(ex)
+
+    rescue Dentaku::ArgumentError => ex
+      results[var_name] = block.call(ex)
+
+    ensure
+      if results[var_name] == :undefined && calculator.memory.has_key?(var_name.downcase)
+        results[var_name] = calculator.memory[var_name.downcase]
+      end
+    end
+
     def expressions
       @expressions ||= Hash[expression_hash.map { |k, v| [k.to_s, v] }]
     end
@@ -113,9 +128,5 @@ module Dentaku
         end
       }
     end
-
-    def evaluate!(expression, results, &block)
-      calculator.evaluate!(expression, results, &block)
-    end
   end
 end

data/lib/dentaku/calculator.rb

@@ -62,7 +62,7 @@ module Dentaku
         unbound = node.dependencies - memory.keys
         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.4"
+  VERSION = "3.4.1"
 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/mul_spec.rb

@@ -34,5 +34,9 @@ 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 'raises an error if an empty array is passed' do
+      expect { calculator.evaluate!('MUL(x)', x: []) }.to raise_error(Dentaku::ArgumentError)
+    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