dentaku 3.3.0 → 3.4.0

data/lib/dentaku/date_arithmetic.rb

@@ -0,0 +1,45 @@
+module Dentaku
+  class DateArithmetic
+    def initialize(date)
+      @base = date
+    end
+
+    def add(duration)
+      case duration
+      when Numeric
+        @base + duration
+      when Dentaku::AST::Duration::Value
+        case duration.unit
+        when :year
+          Time.local(@base.year + duration.value, @base.month, @base.day).to_datetime
+        when :month
+          @base >> duration.value
+        when :day
+          @base + duration.value
+        end
+      else
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
+          "'#{duration || duration.class}' is not coercible for date arithmetic"
+      end
+    end
+
+    def sub(duration)
+      case duration
+      when DateTime, Numeric
+        @base - duration
+      when Dentaku::AST::Duration::Value
+        case duration.unit
+        when :year
+          Time.local(@base.year - duration.value, @base.month, @base.day).to_datetime
+        when :month
+          @base << duration.value
+        when :day
+          @base - duration.value
+        end
+      else
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
+          "'#{duration || duration.class}' is not coercible for date arithmetic"
+      end
+    end
+  end
+end

data/lib/dentaku/exceptions.rb

@@ -33,7 +33,7 @@ module Dentaku
     private_class_method :new
 
     VALID_REASONS = %i[
-      node_invalid too_few_operands undefined_function
+      node_invalid too_few_operands too_many_operands undefined_function
       unprocessed_token unknown_case_token unbalanced_bracket
       unbalanced_parenthesis unknown_grouping_token not_implemented_token_category
       invalid_statement
@@ -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
@@ -19,8 +26,8 @@ module Dentaku
       key
     end
 
-    def self.expand(h)
-      h.each_with_object({}) do |(k, v), r|
+    def self.expand(hash)
+      hash.each_with_object({}) do |(k, v), r|
         hash_levels = k.to_s.split('.')
         hash_levels = hash_levels.map(&:to_sym) if k.is_a?(Symbol)
         child_hash = hash_levels[0...-1].reduce(r) { |h, n| h[n] ||= {} }

data/lib/dentaku/parser.rb

@@ -40,12 +40,23 @@ module Dentaku
       operator.peek(output)
 
       args_size = operator.arity || count
-      if args_size > output.length
-        fail! :too_few_operands, operator: operator, expect: args_size, actual: output.length
+      min_size = operator.arity || operator.min_param_count || count
+      max_size = operator.arity || operator.max_param_count || count
+
+      if output.length < min_size
+        fail! :too_few_operands, operator: operator, expect: min_size, actual: output.length
+      end
+
+      if output.length > max_size && operations.empty?
+        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)
+    rescue ::ArgumentError => e
+      raise Dentaku::ArgumentError, e.message
     rescue NodeError => e
       fail! :node_invalid, operator: operator, child: e.child, expect: e.expect, actual: e.actual
     end
@@ -111,17 +122,19 @@ module Dentaku
               open_cases = 0
               case_end_index = nil
 
-              input.each_with_index do |token, index|
-                if token.category == :case && token.value == :open
-                  open_cases += 1
-                end
+              input.each_with_index do |input_token, index|
+                if input_token.category == :case
+                  if input_token.value == :open
+                    open_cases += 1
+                  end
 
-                if token.category == :case && token.value == :close
-                  if open_cases > 0
-                    open_cases -= 1
-                  else
-                    case_end_index = index
-                    break
+                  if input_token.value == :close
+                    if open_cases > 0
+                      open_cases -= 1
+                    else
+                      case_end_index = index
+                      break
+                    end
                   end
                 end
               end
@@ -129,7 +142,8 @@ module Dentaku
               subparser = Parser.new(
                 inner_case_inputs,
                 operations: [AST::Case],
-                arities: [0]
+                arities: [0],
+                function_registry: @function_registry
               )
               subparser.parse
               output.concat(subparser.output)
@@ -253,6 +267,7 @@ module Dentaku
             end
 
           when :comma
+            fail! :invalid_statement if arities.empty?
             arities[-1] += 1
             while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
               consume
@@ -299,6 +314,8 @@ module Dentaku
           "#{meta.fetch(:operator)} requires #{meta.fetch(:expect).join(', ')} operands, but got #{meta.fetch(:actual)}"
         when :too_few_operands
           "#{meta.fetch(:operator)} has too few operands"
+        when :too_many_operands
+          "#{meta.fetch(:operator)} has too many operands"
         when :undefined_function
           "Undefined function #{meta.fetch(:function_name)}"
         when :unprocessed_token
@@ -319,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/token_matcher.rb

@@ -16,7 +16,7 @@ module Dentaku
       @range = (@min..@max)
     end
 
-    def | (other_matcher)
+    def |(other_matcher)
       self.class.new(:nomatch, :nomatch, leaf_matchers + other_matcher.leaf_matchers)
     end
 

data/lib/dentaku/token_scanner.rb

@@ -91,7 +91,7 @@ module Dentaku
 
       def numeric
         new(:numeric, '((?:\d+(\.\d+)?|\.\d+)(?:(e|E)(\+|-)?\d+)?)\b', lambda { |raw|
-          raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i
+          raw =~ /\./ ? BigDecimal(raw) : raw.to_i
         })
       end
 

data/lib/dentaku/tokenizer.rb

@@ -12,7 +12,7 @@ module Dentaku
     def tokenize(string, options = {})
       @nesting = 0
       @tokens  = []
-      @aliases = options.fetch(:aliases, Dentaku.aliases)
+      @aliases = options.fetch(:aliases, global_aliases)
       input    = strip_comments(string.to_s.dup)
       input    = replace_aliases(input)
       @case_sensitive = options.fetch(:case_sensitive, false)
@@ -84,6 +84,11 @@ module Dentaku
 
     private
 
+    def global_aliases
+      return {} unless Dentaku.respond_to?(:aliases)
+      Dentaku.aliases
+    end
+
     def fail!(reason, **meta)
       message =
         case reason
@@ -99,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.0"
+  VERSION = "3.4.0"
 end

data/spec/ast/addition_spec.rb

@@ -9,9 +9,15 @@ describe Dentaku::AST::Addition do
 
   let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
 
+  it 'allows access to its sub-trees' do
+    node = described_class.new(five, six)
+    expect(node.left).to eq(five)
+    expect(node.right).to eq(six)
+  end
+
   it 'performs addition' do
     node = described_class.new(five, six)
-    expect(node.value).to eq 11
+    expect(node.value).to eq(11)
   end
 
   it 'requires numeric operands' do

data/spec/ast/and_function_spec.rb

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

data/spec/ast/and_spec.rb

@@ -11,7 +11,7 @@ describe Dentaku::AST::And do
 
   it 'performs logical AND' do
     node = described_class.new(t, f)
-    expect(node.value).to eq false
+    expect(node.value).to eq(false)
   end
 
   it 'requires logical operands' do

data/spec/ast/arithmetic_spec.rb

@@ -4,53 +4,81 @@ 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
-    expect(sub(one, two)).to eq -1
-    expect(mul(one, two)).to eq  2
-    expect(div(one, two)).to eq  0.5
+    expect(add(one, two)).to eq(3)
+    expect(sub(one, two)).to eq(-1)
+    expect(mul(one, two)).to eq(2)
+    expect(div(one, two)).to eq(0.5)
+    expect(neg(one)).to eq(-1)
   end
 
   it 'performs an arithmetic operation with one numeric operand and one string operand' do
-    expect(add(one, x)).to eq 2
-    expect(sub(one, x)).to eq 0
-    expect(mul(one, x)).to eq 1
-    expect(div(one, x)).to eq 1
+    expect(add(one, x)).to eq(2)
+    expect(sub(one, x)).to eq(0)
+    expect(mul(one, x)).to eq(1)
+    expect(div(one, x)).to eq(1)
 
-    expect(add(y, two)).to eq 4
-    expect(sub(y, two)).to eq 0
-    expect(mul(y, two)).to eq 4
-    expect(div(y, two)).to eq 1
+    expect(add(y, two)).to eq(4)
+    expect(sub(y, two)).to eq(0)
+    expect(mul(y, two)).to eq(4)
+    expect(div(y, two)).to eq(1)
   end
 
   it 'performs an arithmetic operation with string operands' do
-    expect(add(x, y)).to eq  3
-    expect(sub(x, y)).to eq -1
-    expect(mul(x, y)).to eq  2
-    expect(div(x, y)).to eq  0.5
+    expect(add(x, y)).to eq(3)
+    expect(sub(x, y)).to eq(-1)
+    expect(mul(x, y)).to eq(2)
+    expect(div(x, y)).to eq(0.5)
+    expect(neg(x)).to eq(-1)
+  end
+
+  it 'correctly parses string operands to numeric values' do
+    expect(add(x, one, 'x' => '1')).to eq(2)
+    expect(add(x, one, 'x' => '1.1')).to eq(2.1)
+    expect(add(x, one, 'x' => '.1')).to eq(1.1)
+    expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
+    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)
-    Dentaku::AST::Addition.new(left, right).value(ctx)
+  def add(left, right, context = ctx)
+    Dentaku::AST::Addition.new(left, right).value(context)
+  end
+
+  def sub(left, right, context = ctx)
+    Dentaku::AST::Subtraction.new(left, right).value(context)
   end
 
-  def sub(left, right)
-    Dentaku::AST::Subtraction.new(left, right).value(ctx)
+  def mul(left, right, context = ctx)
+    Dentaku::AST::Multiplication.new(left, right).value(context)
   end
 
-  def mul(left, right)
-    Dentaku::AST::Multiplication.new(left, right).value(ctx)
+  def div(left, right, context = ctx)
+    Dentaku::AST::Division.new(left, right).value(context)
   end
 
-  def div(left, right)
-    Dentaku::AST::Division.new(left, right).value(ctx)
+  def neg(node, context = ctx)
+    Dentaku::AST::Negation.new(node).value(context)
   end
 end

data/spec/ast/avg_spec.rb

@@ -5,29 +5,33 @@ require 'dentaku'
 describe 'Dentaku::AST::Function::Avg' do
   it 'returns the average of an array of Numeric values' do
     result = Dentaku('AVG(1, x, 1.8)', x: 2.3)
-    expect(result).to eq 1.7
+    expect(result).to eq(1.7)
   end
 
   it 'returns the average of a single entry array of a Numeric value' do
     result = Dentaku('AVG(x)', x: 2.3)
-    expect(result).to eq 2.3
+    expect(result).to eq(2.3)
   end
 
   it 'returns the average even if a String is passed' do
     result = Dentaku('AVG(1, x, 1.8)', x: '2.3')
-    expect(result).to eq 1.7
+    expect(result).to eq(1.7)
   end
 
   it 'returns the average even if an array is passed' do
     result = Dentaku('AVG(1, x, 2.3)', x: [4, 5])
-    expect(result).to eq 3.075
+    expect(result).to eq(3.075)
   end
 
   context 'checking errors' do
     let(:calculator) { Dentaku::Calculator.new }
 
     it 'raises an error if no arguments are passed' do
-      expect { calculator.evaluate!('AVG()') }.to raise_error(ArgumentError)
+      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