dentaku 3.5.2 → 3.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b10f7d9e6a9d200c283dcf077fd56e8f4abe4922c02e3095ba20dbb29f6b81c
-  data.tar.gz: add2d3bf7c462edefb9a4c52d79595d3a161e1d78046dbb1fe90e8aa9979a13b
+  metadata.gz: ef9e8cb8d852db9a8e4c81c28815c6a7e7008c6e9bebcc8a11222768756fd7a8
+  data.tar.gz: f7d1c005ef1ba8bcfc77fcac8b885378a0e3e36fdba8f97a2c602b6b0ba6f34c
 SHA512:
-  metadata.gz: 48c2571ea61f8bb9f8a7a4483b8d588741f2c44c4fdc2d04ecd2a5c5b75a94f414b5772a3e1dca21898f8d2ed6488e54925c6a689bfd721315c0c8e0992991d7
-  data.tar.gz: b469e9c4a69c6083b93cda29ea8bf5bf4ad9c91e4a6362e5880768492e21ecd476a09eb858134b8e6c78017207c6cf50479c7ebb3af661c7e20f3866f034b49a
+  metadata.gz: 6d616fd597440c13e8432ac6f9d5480592cdcbb7e9aec30c1f2c21e94e0a4bcf3ffced31cf486dc7390bd8668bb5e377745a7eebf467edfab1cd5fa0ae4f70e9
+  data.tar.gz: fca27bf921a54469f065f634a44d4a6481c6420ccbcaa39400ffe4a5cdd172ff6ae209a04aee96208a64979bbff814635719732b557df33f7d406f87123b1c3a

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Change Log
 
+## [v3.5.4]
+- add support for default value for PLUCK function
+- improve error handling for MAP/ANY/ALL functions
+- fix modulo / percentage operator determination
+- fix string casing bug with bulk expressions
+- add explicit gem dependency for BigDecimal
+
+## [v3.5.3]
+- add support for empty array literals
+- add support for quoted identifiers
+- add REDUCE function
+- add INTERCEPT function
+- improve date/time parsing an arithmetic
+- improve custom class arithmetic
+- fix IF dependency
+
 ## [v3.5.2]
 - add ABS function
 - add array support for AST visitors
@@ -244,6 +260,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[v3.5.4]: https://github.com/rubysolo/dentaku/compare/v3.5.3...v3.5.4
+[v3.5.3]: https://github.com/rubysolo/dentaku/compare/v3.5.2...v3.5.3
 [v3.5.2]: https://github.com/rubysolo/dentaku/compare/v3.5.1...v3.5.2
 [v3.5.1]: https://github.com/rubysolo/dentaku/compare/v3.5.0...v3.5.1
 [v3.5.0]:  https://github.com/rubysolo/dentaku/compare/v3.4.2...v3.5.0

data/README.md

@@ -145,7 +145,7 @@ Comparison: `<`, `>`, `<=`, `>=`, `<>`, `!=`, `=`,
 
 Logic: `IF`, `AND`, `OR`, `XOR`, `NOT`, `SWITCH`
 
-Numeric: `MIN`, `MAX`, `SUM`, `AVG`, `COUNT`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`, `ABS`
+Numeric: `MIN`, `MAX`, `SUM`, `AVG`, `COUNT`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`, `ABS`, `INTERCEPT`
 
 Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/master/spec/calculator_spec.rb#L593))
 

data/dentaku.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
     Dentaku is a parser and evaluator for mathematical formulas
   DESC
 
+  s.add_dependency('bigdecimal')
   s.add_dependency('concurrent-ruby')
 
   s.add_development_dependency('codecov')

data/lib/dentaku/ast/access.rb

@@ -17,9 +17,6 @@ module Dentaku
         arity
       end
 
-      def self.peek(*)
-      end
-
       def initialize(data_structure, index)
         @structure = data_structure
         @index = index

data/lib/dentaku/ast/arithmetic.rb

@@ -62,6 +62,8 @@ module Dentaku
 
       def decimal(val)
         BigDecimal(val.to_s, Float::DIG + 1)
+      rescue # return as is, in case value can't be coerced to big decimal
+        val
       end
 
       def datetime?(val)
@@ -177,50 +179,42 @@ module Dentaku
 
     class Modulo < Arithmetic
       def self.arity
-        @arity
+        2
       end
 
-      def self.peek(input)
-        @arity = 1
-        @arity = 2 if input.length > 1
+      def self.precedence
+        20
       end
 
-      def initialize(left, right = nil)
-        if right
-          @left  = left
-          @right = right
-        else
-          @right = left
-        end
+      def self.resolve_class(next_token)
+        next_token.nil? || next_token.operator? || next_token.close? ? Percentage : self
+      end
+
+      def operator
+        :%
+      end
+    end
+
+    class Percentage < Arithmetic
+      def self.arity
+        1
+      end
+
+      def initialize(child)
+        @right = child
 
-        unless valid_left?
-          raise NodeError.new(%i[numeric nil], left.type, :left),
-                "#{self.class} requires numeric operands or nil"
-        end
         unless valid_right?
           raise NodeError.new(:numeric, right.type, :right),
-                "#{self.class} requires numeric operands"
+                "#{self.class} requires a numeric operand"
         end
       end
 
       def dependencies(context = {})
-        if percent?
-          @right.dependencies(context)
-        else
-          super
-        end
-      end
-
-      def percent?
-        left.nil?
+        @right.dependencies(context)
       end
 
       def value(context = {})
-        if percent?
-          cast(right.value(context)) * 0.01
-        else
-          super
-        end
+        cast(right.value(context)) * 0.01
       end
 
       def operator
@@ -228,11 +222,7 @@ module Dentaku
       end
 
       def self.precedence
-        20
-      end
-
-      def valid_left?
-        valid_node?(left) || left.nil?
+        30
       end
     end
 

data/lib/dentaku/ast/array.rb

@@ -14,9 +14,6 @@ module Dentaku
         Float::INFINITY
       end
 
-      def self.peek(*)
-      end
-
       def initialize(*elements)
         @elements = *elements
       end
@@ -32,7 +29,7 @@ module Dentaku
       def type
         nil
       end
-      
+
       def accept(visitor)
         visitor.visit_array(self)
       end

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

@@ -9,11 +9,7 @@ module Dentaku
         expression      = @args[2]
 
         collection.all? do |item_value|
-          expression.value(
-            context.merge(
-              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
-            )
-          )
+          mapped_value(expression, context, item_identifier => item_value)
         end
       end
     end

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

@@ -9,11 +9,7 @@ module Dentaku
         expression      = @args[2]
 
         collection.any? do |item_value|
-          expression.value(
-            context.merge(
-              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
-            )
-          )
+          mapped_value(expression, context, item_identifier => item_value)
         end
       end
     end

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

@@ -33,6 +33,19 @@ module Dentaku
       def validate_identifier(arg, message = "#{name}() requires second argument to be an identifier")
         raise ParseError.for(:node_invalid), message unless arg.is_a?(Identifier)
       end
+
+      private
+
+      def mapped_value(expression, context, item_context)
+        expression.value(
+          context.merge(
+            FlatHash.from_hash_with_intermediates(item_context)
+          )
+        )
+      rescue => e
+        raise e if context["__evaluation_mode"] == :strict
+        nil
+      end
     end
   end
 end

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

@@ -36,13 +36,9 @@ module Dentaku
       end
 
       def dependencies(context = {})
-        deps = predicate.dependencies(context)
-
-        if deps.empty?
-          predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
-        else
-          (deps + left.dependencies(context) + right.dependencies(context)).uniq
-        end
+        predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
+      rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError
+        args.flat_map { |arg| arg.dependencies(context) }.uniq
       end
     end
   end

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

@@ -0,0 +1,33 @@
+require_relative '../function'
+
+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
+    ), 'INTERCEPT() requires exactly two arrays of numbers'
+  end
+
+  x_values, y_values = 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()'
+    ), '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_avg = x_values.sum / n
+  y_avg = y_values.sum / n
+
+  xy_sum = x_values.zip(y_values).map { |x, y| (x_avg - x) * (y_avg - y) }.sum
+  x_square_sum = x_values.map { |x| (x_avg - x)**2 }.sum
+
+  slope = xy_sum / x_square_sum
+  intercept = x_values.zip(y_values).map { |x, y| y - slope * x }.sum / n
+
+  BigDecimal(intercept, Float::DIG + 1)
+})

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

@@ -9,11 +9,7 @@ module Dentaku
         expression      = @args[2]
 
         collection.map do |item_value|
-          expression.value(
-            context.merge(
-              FlatHash.from_hash_with_intermediates(item_identifier => item_value)
-            )
-          )
+          mapped_value(expression, context, item_identifier => item_value)
         end
       end
     end

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

@@ -9,19 +9,23 @@ module Dentaku
       end
 
       def self.max_param_count
-        2
+        3
       end
 
       def value(context = {})
         collection = Array(@args[0].value(context))
+
         unless collection.all? { |elem| elem.is_a?(Hash) }
           raise ArgumentError.for(:incompatible_type, value: collection),
                 'PLUCK() requires first argument to be an array of hashes'
         end
 
         pluck_path = @args[1].identifier
+        default    = @args[2]
 
-        collection.map { |h| h.transform_keys(&:to_s)[pluck_path] }
+        collection.map { |h|
+          h.transform_keys(&:to_s).fetch(pluck_path, default&.value(context))
+        }
       end
     end
   end

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

@@ -0,0 +1,61 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Reduce < Function
+      def self.min_param_count
+        4
+      end
+
+      def self.max_param_count
+        5
+      end
+
+      def initialize(*args)
+        super
+
+        validate_identifier(@args[1], 'second')
+        validate_identifier(@args[2], 'third')
+      end
+
+      def dependencies(context = {})
+        collection      = @args[0]
+        memo_identifier = @args[1].identifier
+        item_identifier = @args[2].identifier
+        expression      = @args[3]
+
+        collection_deps = collection.dependencies(context)
+        expression_deps = expression.dependencies(context).reject do |i|
+          i == memo_identifier || i.start_with?("#{memo_identifier}.") ||
+          i == item_identifier || i.start_with?("#{item_identifier}.")
+        end
+        inital_value_deps = @args[4] ? @args[4].dependencies(context) : []
+
+        collection_deps + expression_deps + inital_value_deps
+      end
+
+      def value(context = {})
+        collection      = Array(@args[0].value(context))
+        memo_identifier = @args[1].identifier
+        item_identifier = @args[2].identifier
+        expression      = @args[3]
+        initial_value   = @args[4] && @args[4].value(context)
+
+        collection.reduce(initial_value) do |memo, item|
+          expression.value(
+            context.merge(
+              FlatHash.from_hash_with_intermediates(memo_identifier => memo, item_identifier => item)
+            )
+          )
+        end
+      end
+
+      def validate_identifier(arg, position, message = "#{name}() requires #{position} argument to be an identifier")
+        raise ParseError.for(:node_invalid), message unless arg.is_a?(Identifier)
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:reduce, Dentaku::AST::Reduce)

data/lib/dentaku/ast/node.rb

@@ -9,7 +9,8 @@ module Dentaku
         nil
       end
 
-      def self.peek(*)
+      def self.resolve_class(*)
+        self
       end
 
       def dependencies(context = {})

data/lib/dentaku/ast.rb

@@ -24,12 +24,14 @@ require_relative './ast/functions/count'
 require_relative './ast/functions/duration'
 require_relative './ast/functions/filter'
 require_relative './ast/functions/if'
+require_relative './ast/functions/intercept'
 require_relative './ast/functions/map'
 require_relative './ast/functions/max'
 require_relative './ast/functions/min'
 require_relative './ast/functions/not'
 require_relative './ast/functions/or'
 require_relative './ast/functions/pluck'
+require_relative './ast/functions/reduce'
 require_relative './ast/functions/round'
 require_relative './ast/functions/rounddown'
 require_relative './ast/functions/roundup'
@@ -37,4 +39,4 @@ require_relative './ast/functions/ruby_math'
 require_relative './ast/functions/string_functions'
 require_relative './ast/functions/sum'
 require_relative './ast/functions/switch'
-require_relative './ast/functions/xor'
+require_relative './ast/functions/xor'

data/lib/dentaku/bulk_expression_solver.rb

@@ -6,16 +6,41 @@ require 'dentaku/tokenizer'
 
 module Dentaku
   class BulkExpressionSolver
+    class StrictEvaluator
+      def initialize(calculator)
+        @calculator = calculator
+      end
+
+      def evaluate(*args)
+        @calculator.evaluate!(*args)
+      end
+    end
+
+    class PermissiveEvaluator
+      def initialize(calculator, block)
+        @calculator = calculator
+        @block = block || ->(*) { :undefined }
+      end
+
+      def evaluate(*args)
+        @calculator.evaluate(*args) { |expr, ex|
+          @block.call(ex)
+        }
+      end
+    end
+
     def initialize(expressions, calculator)
       @expression_hash = FlatHash.from_hash(expressions)
       @calculator = calculator
     end
 
     def solve!
+      @evaluator = StrictEvaluator.new(calculator)
       solve(&raise_exception_handler)
     end
 
     def solve(&block)
+      @evaluator ||= PermissiveEvaluator.new(calculator, block)
       error_handler = block || return_undefined_handler
       results = load_results(&error_handler)
 
@@ -42,7 +67,7 @@ module Dentaku
       @dep_cache ||= {}
     end
 
-    attr_reader :expression_hash, :calculator
+    attr_reader :expression_hash, :calculator, :evaluator
 
     def return_undefined_handler
       ->(*) { :undefined }
@@ -52,8 +77,11 @@ module Dentaku
       ->(ex) { raise ex }
     end
 
-    def expression_with_exception_handler(&block)
-      ->(_expr, ex) { block.call(ex) }
+    def expression_with_exception_handler(var_name, &block)
+      ->(_expr, ex) {
+        ex.recipient_variable = var_name
+        block.call(ex)
+      }
     end
 
     def load_results(&block)
@@ -73,11 +101,14 @@ module Dentaku
         next if expressions[var_name].nil?
 
         with_rescues(var_name, results, block) do
-          results[var_name] = evaluated_facts[var_name] || calculator.evaluate!(
+          results[var_name] = evaluated_facts[var_name] || evaluator.evaluate(
             expressions[var_name],
             context.merge(results),
-            &expression_with_exception_handler(&block)
-          )
+            &expression_with_exception_handler(var_name, &block)
+          ).tap { |res|
+            res.recipient_variable = var_name if res.respond_to?(:recipient_variable=)
+            res
+          }
         end
       end
 
@@ -88,7 +119,6 @@ module Dentaku
 
     def with_rescues(var_name, results, block)
       yield
-
     rescue Dentaku::UnboundVariableError, Dentaku::ZeroDivisionError, Dentaku::ArgumentError => ex
       ex.recipient_variable = var_name
       results[var_name] = block.call(ex)

data/lib/dentaku/calculator.rb

@@ -52,28 +52,39 @@ module Dentaku
     end
 
     def evaluate(expression, data = {}, &block)
-      evaluate!(expression, data)
+      context = evaluation_context(data, :permissive)
+      return evaluate_array(expression, context, &block) if expression.is_a?(Array)
+
+      evaluate!(expression, context)
     rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError => ex
       block.call(expression, ex) if block_given?
     end
 
+    private def evaluate_array(expression, data = {}, &block)
+      expression.map { |e| evaluate(e, data, &block) }
+    end
+
     def evaluate!(expression, data = {}, &block)
-      return expression.map { |e|
-        evaluate(e, data, &block)
-      } if expression.is_a? Array
+      context = evaluation_context(data, :strict)
+      return evaluate_array!(expression, context, &block) if expression.is_a? Array
 
-      store(data) do
-        node = expression
-        node = ast(node) unless node.is_a?(AST::Node)
+      store(context) do
+        node = ast(expression)
         unbound = node.dependencies(memory)
+
         unless unbound.empty?
           raise UnboundVariableError.new(unbound),
                 "no value provided for variables: #{unbound.uniq.join(', ')}"
         end
+
         node.value(memory)
       end
     end
 
+    private def evaluate_array!(expression, data = {}, &block)
+      expression.map { |e| evaluate!(e, data, &block) }
+    end
+
     def solve!(expression_hash)
       BulkExpressionSolver.new(expression_hash, self).solve!
     end
@@ -96,6 +107,7 @@ module Dentaku
     end
 
     def ast(expression)
+      return expression if expression.is_a?(AST::Node)
       return expression.map { |e| ast(e) } if expression.is_a? Array
 
       @ast_cache.fetch(expression) {
@@ -130,6 +142,10 @@ module Dentaku
       end
     end
 
+    def evaluation_context(data, evaluation_mode)
+      data.key?(:__evaluation_mode) ? data : data.merge(__evaluation_mode: evaluation_mode)
+    end
+
     def store(key_or_hash, value = nil)
       restore = Hash[memory]
 

data/lib/dentaku/date_arithmetic.rb

@@ -13,13 +13,11 @@ module Dentaku
       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
+        case @base
+        when Time
+          change_datetime(@base.to_datetime, duration.unit, duration.value).to_time
+        else
+          change_datetime(@base, duration.unit, duration.value)
         end
       else
         raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
@@ -29,21 +27,34 @@ module Dentaku
 
     def sub(duration)
       case duration
-      when DateTime, Numeric
+      when Date, DateTime, Numeric, Time
         @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
+        case @base
+        when Time
+          change_datetime(@base.to_datetime, duration.unit, -duration.value).to_time
+        else
+          change_datetime(@base, duration.unit, -duration.value)
         end
+      when Dentaku::TokenScanner::DATE_TIME_REGEXP
+        @base - Time.parse(duration).to_datetime
       else
         raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
           "'#{duration || duration.class}' is not coercible for date arithmetic"
       end
     end
+
+    private
+
+    def change_datetime(base, unit, value)
+      case unit
+      when :year
+        base >> (value * 12)
+      when :month
+        base >> value
+      when :day
+        base + value
+      end
+    end
   end
 end

data/lib/dentaku/dependency_resolver.rb

@@ -4,13 +4,18 @@ module Dentaku
   class DependencyResolver
     include TSort
 
-    def self.find_resolve_order(vars_to_dependencies_hash)
-      self.new(vars_to_dependencies_hash).tsort
+    def self.find_resolve_order(vars_to_dependencies_hash, case_sensitive = false)
+      self.new(vars_to_dependencies_hash).sort
     end
 
     def initialize(vars_to_dependencies_hash)
-      # ensure variables are strings
-      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.to_s, v] }]
+      @key_mapping = Hash[vars_to_dependencies_hash.keys.map { |k| [k.downcase, k] }]
+      # ensure variables are normalized strings
+      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.downcase.to_s, v] }]
+    end
+
+    def sort
+      tsort.map { |k| @key_mapping.fetch(k, k) }
     end
 
     def tsort_each_node(&block)