dentaku 3.3.0 → 3.4.0

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:round, :numeric, lambda { |numeric, places = 0|
-  Dentaku::AST::Function.numeric(numeric).round(places.to_i)
+  Dentaku::AST::Function.numeric(numeric).round(Dentaku::AST::Function.numeric(places || 0).to_i)
 })

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

@@ -1,7 +1,7 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:rounddown, :numeric, lambda { |numeric, precision = 0|
-  precision = precision.to_i
+  precision = Dentaku::AST::Function.numeric(precision || 0).to_i
   tens = 10.0**precision
   result = (Dentaku::AST::Function.numeric(numeric) * tens).floor / tens
   precision <= 0 ? result.to_i : result

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

@@ -1,7 +1,7 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:roundup, :numeric, lambda { |numeric, precision = 0|
-  precision = precision.to_i
+  precision = Dentaku::AST::Function.numeric(precision || 0).to_i
   tens = 10.0**precision
   result = (Dentaku::AST::Function.numeric(numeric) * tens).ceil / tens
   precision <= 0 ? result.to_i : result

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

@@ -1,8 +1,52 @@
 # import all functions from Ruby's Math module
 require_relative '../function'
 
+module Dentaku
+  module AST
+    class RubyMath < Function
+      def self.[](method)
+        klass = Class.new(self)
+        klass.implement(method)
+        klass
+      end
+
+      def self.implement(method)
+        @name = method
+        @implementation = Math.method(method)
+      end
+
+      def self.name
+        @name
+      end
+
+      def self.arity
+        @implementation.arity < 0 ? nil : @implementation.arity
+      end
+
+      def self.min_param_count
+        @implementation.parameters.select { |type, _name| type == :req }.count
+      end
+
+      def self.max_param_count
+        @implementation.parameters.select { |type, _name| type == :rest }.any? ? Float::INFINITY : @implementation.parameters.count
+      end
+
+      def self.call(*args)
+        @implementation.call(*args)
+      end
+
+      def value(context = {})
+        args = @args.flatten.map { |a| Dentaku::AST::Function.numeric(a.value(context)) }
+        self.class.call(*args)
+      end
+
+      def type
+        nil
+      end
+    end
+  end
+end
+
 Math.methods(false).each do |method|
-  Dentaku::AST::Function.register(method, :numeric, lambda { |*args|
-    Math.send(method, *args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) })
-  })
+  Dentaku::AST::Function.register_class(method, Dentaku::AST::RubyMath[method])
 end

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,53 @@ 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? }
+
+      context = calculator.memory.merge(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)
+
+      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] = 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 +126,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