dentaku 3.5.7 → 4.0.0

data/lib/dentaku/ast/comparators.rb

@@ -21,24 +21,20 @@ module Dentaku
 
         l.public_send(operator, r)
       rescue ::ArgumentError, ::TypeError => e
-        raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
+        raise Dentaku::ArgumentError.for(:incompatible_type, actual: r, expected: l.class), e.message
       end
 
       private
 
       def cast(val)
         return val unless val.is_a?(::String)
-        return val unless val.match?(Arithmetic::DECIMAL) || val.match?(Arithmetic::INTEGER)
 
-        v = BigDecimal(val, Float::DIG + 1)
-        v = v.to_i if v.frac.zero?
-        v
+        Dentaku::NumericParser.parse_string(val) || val
       end
 
       def validate_value(value)
         unless value.respond_to?(operator)
-          raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator),
-                "#{ self.class } requires operands that respond to #{operator}"
+          raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator)
         end
 
         value

data/lib/dentaku/ast/function.rb

@@ -22,12 +22,19 @@ module Dentaku
              .flat_map { |a, _| a.dependencies(context) }
       end
 
+      # volatile functions may not be evaluated during dependency
+      # resolution; registry-generated classes override this per the
+      # volatile: option passed at registration
+      def self.volatile?
+        false
+      end
+
       def self.get(name)
         registry.get(name)
       end
 
-      def self.register(name, type, implementation)
-        registry.register(name, type, implementation)
+      def self.register(name, type, implementation, volatile: false)
+        registry.register(name, type, implementation, volatile: volatile)
       end
 
       def self.register_class(name, function_class)
@@ -38,18 +45,10 @@ module Dentaku
         @registry ||= FunctionRegistry.new
       end
 
-      # @return [Numeric] where possible it returns an Integer otherwise a BigDecimal.
-      # An Exception will be raised if a value is passed that cannot be cast to a Number.
-      def self.numeric(value)
-        return value if value.is_a?(::Numeric)
-
-        if value.is_a?(::String)
-          number = value[/\A-?\d*\.?\d+\z/]
-          return number.include?('.') ? BigDecimal(number, DIG) : number.to_i if number
-        end
+      private
 
-        raise Dentaku::ArgumentError.for(:incompatible_type, value: value, for: Numeric),
-          "'#{value || value.class}' is not coercible to numeric"
+      def compute_pure?
+        !self.class.volatile? && args.all?(&:pure?)
       end
     end
   end

data/lib/dentaku/ast/function_registry.rb

@@ -8,10 +8,10 @@ module Dentaku
         nil
       end
 
-      def register(name, type, implementation, callback = nil)
+      def register(name, type, implementation, callback = nil, volatile: false)
         function = Class.new(Function) do
           def self.name=(name)
-            @name = name
+            @name = name.to_s
           end
 
           def self.name
@@ -42,6 +42,14 @@ module Dentaku
             @callback
           end
 
+          def self.volatile=(volatile)
+            @volatile = volatile
+          end
+
+          def self.volatile?
+            @volatile
+          end
+
           def self.arity
             @implementation.arity < 0 ? nil : @implementation.arity
           end
@@ -70,6 +78,7 @@ module Dentaku
         function.type = type
         function.implementation = implementation
         function.callback = callback
+        function.volatile = volatile
 
         self[function_name(name)] = function
       end

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:abs, :numeric, lambda { |numeric|
-  Dentaku::AST::Function.numeric(numeric).abs
+  Dentaku::NumericParser.ensure_numeric!(numeric).abs
 })

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

@@ -5,8 +5,8 @@ Dentaku::AST::Function.register(:and, :logical, lambda { |*args|
   if args.empty?
     raise Dentaku::ArgumentError.for(
       :too_few_arguments,
-      function_name: 'AND()', at_least: 1, given: 0
-    ), 'AND() requires at least one argument'
+      function_name: 'AND', expected: 1.., actual: 0
+    )
   end
 
   args.all? do |arg|
@@ -18,8 +18,8 @@ Dentaku::AST::Function.register(:and, :logical, lambda { |*args|
     else
       raise Dentaku::ArgumentError.for(
         :incompatible_type,
-        function_name: 'AND()', expect: :logical, actual: arg.class
-      ), 'AND() requires arguments to be logical expressions'
+        function_name: 'AND', expected: :logical, actual: arg
+      )
     end
   end
 })

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

@@ -5,9 +5,9 @@ Dentaku::AST::Function.register(:avg, :numeric, ->(*args) {
   if flatten_args.empty?
     raise Dentaku::ArgumentError.for(
         :too_few_arguments,
-        function_name: 'AVG()', at_least: 1, given: 0
-    ), 'AVG() requires at least one argument'
+        function_name: 'AVG', expected: 1.., actual: 0
+    )
   end
 
-  flatten_args.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+) / BigDecimal(flatten_args.length)
+  flatten_args.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.reduce(0, :+) / BigDecimal(flatten_args.length)
 })

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

@@ -25,7 +25,7 @@ module Dentaku
           when /months?/ then :month
           when /days?/ then :day
           else
-            raise Dentaku::ArgumentError.for(:incompatible_type, value: unit, for: Duration),
+            raise Dentaku::ArgumentError.for(:incompatible_type, actual: unit, expected: Duration),
               "'#{unit || unit.class}' is not a valid duration unit"
           end
         end

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

@@ -36,8 +36,16 @@ module Dentaku
       end
 
       def dependencies(context = {})
+        return all_arg_dependencies(context) if static_mode?(context) || !predicate.pure?
+
         predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
-      rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError
+      rescue Dentaku::Error
+        all_arg_dependencies(context)
+      end
+
+      private
+
+      def all_arg_dependencies(context)
         args.flat_map { |arg| arg.dependencies(context) }.uniq
       end
     end

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

@@ -4,7 +4,7 @@ Dentaku::AST::Function.register(:intercept, :list, ->(*args) {
   if args.length != 2
     raise Dentaku::ArgumentError.for(
         :wrong_number_of_arguments,
-        function_name: 'INTERCEPT()', exact: 2, given: args.length
+        function_name: 'INTERCEPT', expected: 2, actual: args.length
     ), 'INTERCEPT() requires exactly two arrays of numbers'
   end
 
@@ -12,13 +12,13 @@ Dentaku::AST::Function.register(:intercept, :list, ->(*args) {
   if !x_values.is_a?(Array) || !y_values.is_a?(Array) || x_values.length != y_values.length
     raise Dentaku::ArgumentError.for(
         :invalid_value,
-        function_name: 'INTERCEPT()'
+        function_name: 'INTERCEPT'
     ), 'INTERCEPT() requires arrays of equal length'
   end
 
   n = x_values.length.to_f
-  x_values = x_values.map { |arg| Dentaku::AST::Function.numeric(arg) }
-  y_values = y_values.map { |arg| Dentaku::AST::Function.numeric(arg) }
+  x_values = x_values.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }
+  y_values = y_values.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }
 
   x_avg = x_values.sum / n
   y_avg = y_values.sum / n

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:max, :numeric, ->(*args) {
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.max
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.max
 })

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

@@ -1,5 +1,5 @@
 require_relative '../function'
 
 Dentaku::AST::Function.register(:min, :numeric, ->(*args) {
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.min
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.min
 })

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

@@ -4,9 +4,9 @@ Dentaku::AST::Function.register(:mul, :numeric, ->(*args) {
   if args.empty?
     raise Dentaku::ArgumentError.for(
         :too_few_arguments,
-        function_name: 'MUL()', at_least: 1, given: 0
-    ), 'MUL() requires at least one argument'
+        function_name: 'MUL', expected: 1.., actual: 0
+    )
   end
 
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(1, :*)
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.reduce(1, :*)
 })

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

@@ -5,8 +5,8 @@ Dentaku::AST::Function.register(:or, :logical, lambda { |*args|
   if args.empty?
     raise Dentaku::ArgumentError.for(
       :too_few_arguments,
-      function_name: 'OR()', at_least: 1, given: 0
-    ), 'OR() requires at least one argument'
+      function_name: 'OR', expected: 1.., actual: 0
+    )
   end
 
   args.any? do |arg|
@@ -18,8 +18,8 @@ Dentaku::AST::Function.register(:or, :logical, lambda { |*args|
     else
       raise Dentaku::ArgumentError.for(
         :incompatible_type,
-        function_name: 'OR()', expect: :logical, actual: arg.class
-      ), 'OR() requires arguments to be logical expressions'
+        function_name: 'OR', expected: :logical, actual: arg
+      )
     end
   end
 })

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

@@ -16,7 +16,7 @@ module Dentaku
         collection = Array(@args[0].value(context))
 
         unless collection.all? { |elem| elem.is_a?(Hash) }
-          raise ArgumentError.for(:incompatible_type, value: collection),
+          raise ArgumentError.for(:incompatible_type, actual: collection),
                 'PLUCK() requires first argument to be an array of hashes'
         end
 

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(Dentaku::AST::Function.numeric(places || 0).to_i)
+  Dentaku::NumericParser.ensure_numeric!(numeric).round(Dentaku::NumericParser.ensure_numeric!(places || 0).to_i)
 })

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

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

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

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

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

@@ -16,8 +16,11 @@ module Dentaku
         @implementation = Math.method(method)
       end
 
+      # Ruby documents Module#name as a String (or nil for anonymous
+      # classes), so expose one even though the function is registered
+      # under a Symbol
       def self.name
-        @name
+        @name.to_s
       end
 
       def self.arity
@@ -39,7 +42,7 @@ module Dentaku
       end
 
       def value(context = {})
-        args = @args.flatten.map { |a| Dentaku::AST::Function.numeric(a.value(context)) }
+        args = @args.flatten.map { |a|Dentaku::NumericParser.ensure_numeric!(a.value(context)) }
         self.class.call(*args)
       end
 

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

@@ -11,7 +11,7 @@ module Dentaku
         def negative_argument_failure(fun, arg = 'length')
           raise Dentaku::ArgumentError.for(
             :invalid_value,
-            function_name: "#{fun}()"
+            function_name: fun
           ), "#{fun}() requires #{arg} to be positive"
         end
       end
@@ -32,7 +32,7 @@ module Dentaku
 
         def value(context = {})
           string = @string.value(context).to_s
-          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
+          length = Dentaku::NumericParser.ensure_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 = Dentaku::AST::Function.numeric(@length.value(context)).to_i
+          length = Dentaku::NumericParser.ensure_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 = Dentaku::AST::Function.numeric(@offset.value(context)).to_i
+          offset = Dentaku::NumericParser.ensure_numeric!(@offset.value(context)).to_i
           negative_argument_failure('MID', 'offset') if offset < 0
-          length = Dentaku::AST::Function.numeric(@length.value(context)).to_i
+          length = Dentaku::NumericParser.ensure_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

@@ -4,9 +4,9 @@ Dentaku::AST::Function.register(:sum, :numeric, ->(*args) {
   if args.empty?
     raise Dentaku::ArgumentError.for(
         :too_few_arguments,
-        function_name: 'SUM()', at_least: 1, given: 0
-    ), 'SUM() requires at least one argument'
+        function_name: 'SUM', expected: 1.., actual: 0
+    )
   end
 
-  args.flatten.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+)
+  args.flatten.map { |arg| Dentaku::NumericParser.ensure_numeric!(arg) }.reduce(0, :+)
 })

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

@@ -16,8 +16,8 @@ module Dentaku
         if @args.empty?
           raise Dentaku::ArgumentError.for(
             :too_few_arguments,
-            function_name: 'XOR()', at_least: 1, given: 0
-          ), 'XOR() requires at least one argument'
+            function_name: 'XOR', expected: 1.., actual: 0
+          )
         end
 
         true_arg_count = 0
@@ -31,8 +31,8 @@ module Dentaku
           else
             raise Dentaku::ArgumentError.for(
               :incompatible_type,
-              function_name: 'XOR()', expect: :logical, actual: arg.class
-            ), 'XOR() requires arguments to be logical expressions'
+              function_name: 'XOR', expected: :logical, actual: arg
+            )
           end
         end
         true_arg_count == 1

data/lib/dentaku/ast/grouping.rb

@@ -18,6 +18,12 @@ module Dentaku
       def dependencies(context = {})
         @node.dependencies(context)
       end
+
+      private
+
+      def compute_pure?
+        @node.pure?
+      end
     end
   end
 end

data/lib/dentaku/ast/negation.rb

@@ -46,6 +46,11 @@ module Dentaku
 
       private
 
+      # bypasses Operation's binary initialize, so left/right are unset
+      def compute_pure?
+        @node.pure?
+      end
+
       def valid_node?(node)
         node && (node.dependencies.any? || node.type == :numeric)
       end

data/lib/dentaku/ast/node.rb

@@ -1,6 +1,12 @@
 module Dentaku
   module AST
     class Node
+      # reserved context key (double-underscore prefix, like
+      # __evaluation_mode) that switches dependencies() into static mode:
+      # guards are never evaluated and every branch is reported
+      STATIC_MODE_KEY = "__static_dependencies".freeze
+      STATIC_CONTEXT = { STATIC_MODE_KEY => true }.freeze
+
       def self.precedence
         0
       end
@@ -17,6 +23,15 @@ module Dentaku
         []
       end
 
+      # whether this subtree may be evaluated during dependency resolution
+      # without running volatile user code; a property of the parsed AST,
+      # computed once and memoized
+      def pure?
+        return @pure if defined?(@pure)
+
+        @pure = compute_pure?
+      end
+
       def type
         nil
       end
@@ -24,6 +39,16 @@ module Dentaku
       def name
         self.class.name.to_s.split("::").last.upcase
       end
+
+      private
+
+      def static_mode?(context)
+        context[STATIC_MODE_KEY] == true
+      end
+
+      def compute_pure?
+        true
+      end
     end
   end
 end

data/lib/dentaku/ast/operation.rb

@@ -39,6 +39,13 @@ module Dentaku
       def operator_spacing
         " "
       end
+
+      private
+
+      # compact: unary operations (e.g. Percentage) only populate left
+      def compute_pure?
+        [left, right].compact.all?(&:pure?)
+      end
     end
   end
 end

data/lib/dentaku/bulk_expression_solver.rb

@@ -11,8 +11,8 @@ module Dentaku
         @calculator = calculator
       end
 
-      def evaluate(*args)
-        @calculator.evaluate!(*args)
+      def evaluate(*args, &block)
+        @calculator.evaluate!(*args, &block)
       end
     end
 
@@ -22,10 +22,9 @@ module Dentaku
         @block = block || ->(*) { :undefined }
       end
 
-      def evaluate(*args)
-        @calculator.evaluate(*args) { |expr, ex|
-          @block.call(ex)
-        }
+      def evaluate(*args, &block)
+        handler = block || ->(_expr, ex) { @block.call(ex) }
+        @calculator.evaluate(*args, &handler)
       end
     end
 
@@ -79,13 +78,13 @@ module Dentaku
 
     def expression_with_exception_handler(var_name, &block)
       ->(_expr, ex) {
-        ex.recipient_variable = var_name
+        ex.assigned_to = var_name
         block.call(ex)
       }
     end
 
     def load_results(&block)
-      facts, _formulas = expressions.transform_keys(&:downcase)
+      facts, _formulas = expressions.transform_keys { |k| normalized_name(k) }
                                     .transform_values { |v| calculator.ast(v) }
                                     .partition { |_, v| calculator.dependencies(v, nil).empty? }
 
@@ -101,12 +100,12 @@ module Dentaku
         next if expressions[var_name].nil?
 
         with_rescues(var_name, results, block) do
-          results[var_name] = evaluated_facts[var_name] || evaluator.evaluate(
+          results[var_name] = evaluated_facts[normalized_name(var_name)] || evaluator.evaluate(
             expressions[var_name],
             context.merge(results),
             &expression_with_exception_handler(var_name, &block)
           ).tap { |res|
-            res.recipient_variable = var_name if res.respond_to?(:recipient_variable=)
+            res.assigned_to = var_name if res.respond_to?(:assigned_to=)
             res
           }
         end
@@ -120,14 +119,21 @@ module Dentaku
     def with_rescues(var_name, results, block)
       yield
     rescue Dentaku::UnboundVariableError, Dentaku::ZeroDivisionError, Dentaku::ArgumentError => ex
-      ex.recipient_variable = var_name
+      ex.assigned_to = var_name
       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]
+      stored_name = normalized_name(var_name)
+      if results[var_name] == :undefined && calculator.memory.has_key?(stored_name)
+        results[var_name] = calculator.memory[stored_name]
       end
     end
 
+    # names are normalized the same way the calculator stores them, so that
+    # facts and memory lookups line up with the identifiers the parser emits
+    def normalized_name(variable_name)
+      calculator.standardize_case(variable_name.to_s)
+    end
+
     def expressions
       @expressions ||= Hash[expression_hash.map { |k, v| [k.to_s, v] }]
     end
@@ -147,10 +153,10 @@ module Dentaku
     end
 
     def variables_in_resolve_order
-      cache_key = expressions.keys.map(&:to_s).sort.join("|")
+      cache_key = "#{!!calculator.case_sensitive}|#{expressions.keys.map(&:to_s).sort.join("|")}"
       @ordered_deps ||= self.class.dependency_cache.fetch(cache_key) {
-        DependencyResolver.find_resolve_order(dependencies).tap do |d|
-          self.class.dependency_cache[cache_key] = d if Dentaku.cache_dependency_order?
+        DependencyResolver.find_resolve_order(dependencies, calculator.case_sensitive).tap do |d|
+          self.class.dependency_cache[cache_key] = d if calculator.cache_dependency_order?
         end
       }
     end