dentaku 3.3.1 → 3.4.1

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

@@ -17,6 +17,14 @@ module Dentaku
       end
 
       class Left < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @string, @length = *@args
@@ -24,13 +32,21 @@ 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
       end
 
       class Right < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @string, @length = *@args
@@ -38,13 +54,21 @@ 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
       end
 
       class Mid < Base
+        def self.min_param_count
+          3
+        end
+
+        def self.max_param_count
+          3
+        end
+
         def initialize(*args)
           super
           @string, @offset, @length = *@args
@@ -52,15 +76,23 @@ 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
       end
 
       class Len < Base
+        def self.min_param_count
+          1
+        end
+
+        def self.max_param_count
+          1
+        end
+
         def initialize(*args)
           super
           @string = @args[0]
@@ -77,6 +109,14 @@ module Dentaku
       end
 
       class Find < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @needle, @haystack = *@args
@@ -96,6 +136,14 @@ module Dentaku
       end
 
       class Substitute < Base
+        def self.min_param_count
+          3
+        end
+
+        def self.max_param_count
+          3
+        end
+
         def initialize(*args)
           super
           @original, @search, @replacement = *@args
@@ -111,6 +159,14 @@ module Dentaku
       end
 
       class Concat < Base
+        def self.min_param_count
+          1
+        end
+
+        def self.max_param_count
+          Float::INFINITY
+        end
+
         def initialize(*args)
           super
         end
@@ -121,6 +177,14 @@ module Dentaku
       end
 
       class Contains < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @needle, @haystack = *args

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,11 @@ 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
           v
         end

data/lib/dentaku/ast/negation.rb

@@ -1,11 +1,13 @@
 module Dentaku
   module AST
     class Negation < Arithmetic
+      attr_reader :node
+
       def initialize(node)
         @node = node
 
         unless valid_node?(node)
-          raise NodeError.new(:numeric, left.type, :left),
+          raise NodeError.new(:numeric, node.type, :node),
                 "#{self.class} requires numeric operands"
         end
       end

data/lib/dentaku/ast/node.rb

@@ -15,6 +15,10 @@ module Dentaku
       def dependencies(context = {})
         []
       end
+
+      def type
+        nil
+      end
     end
   end
 end

data/lib/dentaku/ast/operation.rb

@@ -5,6 +5,14 @@ module Dentaku
     class Operation < Node
       attr_reader :left, :right
 
+      def self.min_param_count
+        arity
+      end
+
+      def self.max_param_count
+        arity
+      end
+
       def initialize(left, right)
         @left  = left
         @right = right

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

@@ -9,7 +9,8 @@ require 'dentaku/token'
 module Dentaku
   class Calculator
     include StringCasing
-    attr_reader :result, :memory, :tokenizer, :case_sensitive, :aliases, :nested_data_support
+    attr_reader :result, :memory, :tokenizer, :case_sensitive, :aliases,
+                :nested_data_support, :ast_cache
 
     def initialize(options = {})
       clear
@@ -61,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
@@ -76,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,
@@ -97,6 +106,10 @@ module Dentaku
       }
     end
 
+    def load_cache(ast_cache)
+      @ast_cache = ast_cache
+    end
+
     def clear_cache(pattern = :all)
       case pattern
       when :all
@@ -114,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

@@ -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