dentaku 3.5.1 → 3.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5592654ee45adeb24167b584374fb2d69bc67d1db4d5f4ac99050130f187f8f
-  data.tar.gz: 31d3952b08887ae934661f4c0ecc5c298b2f36f0f8365cc1503495eb044eb558
+  metadata.gz: a51418767c413ccded1f235a56d34866005edf21cbc0d4cf5848d4cff4bc801f
+  data.tar.gz: 2009c09a76a5cc0b85cf04769c93f0d372cc8613f410a18401de53ca268b134d
 SHA512:
-  metadata.gz: d8e0d003f897e06173c91b200e62d9fed12ec3bacfe0f2ecc3f3705a1cbf914d1705948b79962f5ac6a5397138ff89c2123aa5c3753963f0046a88280b29825b
-  data.tar.gz: 5f48d3b8fef4e56ed308e717da88937bef508e47dfca4c3e16610aff7523f11405e53e2b55d00c53b5eca8efbe7be64df0d0d12e7ddafbc61099cde08bf92a53
+  metadata.gz: 6cfeabc676fa63016096d2f3c291d60a68ce247fe7c75ba195cdc2968c28af85de9ab9eeaaa9e88749cbf7920a120b1e6fe4d78464b98f9c825180d42aafc4f1
+  data.tar.gz: 42863ad11afff2dc72dfe906d1fdc1c07821f4391dcb7fc67921d862c736350be15a6671beac9c16de9e1345f17869e0de40bb131bc1fcfea70190538274bd53

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Change Log
 
+## [Unreleased]
+- 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
+- add support for function callbacks
+- improve support for date / time values
+- improve error messaging for invalid arity
+- improve AVG function accuracy
+- validate enum arguments at parse time
+- support adding multiple functions at once to global registry
+- fix bug in print visitor precedence checking
+- fix handling of Math::DomainError
+- fix invalid cast
+
 ## [v3.5.1]
 - add bitwise shift left and shift right operators
 - improve numeric conversions
@@ -231,7 +253,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
-[Unreleased]: https://github.com/rubysolo/dentaku/compare/v3.5.1...HEAD
+[Unreleased]: https://github.com/rubysolo/dentaku/compare/v3.5.2...HEAD
+[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
 [v3.4.2]:  https://github.com/rubysolo/dentaku/compare/v3.4.1...v3.4.2

data/README.md

@@ -145,7 +145,7 @@ Comparison: `<`, `>`, `<=`, `>=`, `<>`, `!=`, `=`,
 
 Logic: `IF`, `AND`, `OR`, `XOR`, `NOT`, `SWITCH`
 
-Numeric: `MIN`, `MAX`, `SUM`, `AVG`, `COUNT`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`
+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/lib/dentaku/ast/arithmetic.rb

@@ -6,6 +6,9 @@ require 'bigdecimal/util'
 module Dentaku
   module AST
     class Arithmetic < Operation
+      DECIMAL = /\A-?\d*\.\d+\z/.freeze
+      INTEGER = /\A-?\d+\z/.freeze
+
       def initialize(*)
         super
 
@@ -29,8 +32,14 @@ module Dentaku
       end
 
       def value(context = {})
-        l = cast(left.value(context))
-        r = cast(right.value(context))
+        calculate(left.value(context), right.value(context))
+      end
+
+      private
+
+      def calculate(left_value, right_value)
+        l = cast(left_value)
+        r = cast(right_value)
 
         l.public_send(operator, r)
       rescue ::TypeError => e
@@ -38,8 +47,6 @@ module Dentaku
         raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
       end
 
-      private
-
       def cast(val)
         validate_value(val)
         numeric(val)
@@ -47,14 +54,23 @@ module Dentaku
 
       def numeric(val)
         case val.to_s
-        when /\A\d*\.\d+\z/ then decimal(val)
-        when /\A-?\d+\z/ then val.to_i
+        when DECIMAL then decimal(val)
+        when INTEGER then val.to_i
         else val
         end
       end
 
       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)
+        # val is a Date, Time, or DateTime
+        return true if val.respond_to?(:strftime)
+
+        val.to_s =~ Dentaku::TokenScanner::DATE_TIME_REGEXP
       end
 
       def valid_node?(node)
@@ -102,10 +118,13 @@ module Dentaku
       end
 
       def value(context = {})
-        if left.type == :datetime
-          Dentaku::DateArithmetic.new(left.value(context)).add(right.value(context))
+        left_value = left.value(context)
+        right_value = right.value(context)
+
+        if left.type == :datetime || datetime?(left_value)
+          Dentaku::DateArithmetic.new(left_value).add(right_value)
         else
-          super
+          calculate(left_value, right_value)
         end
       end
     end
@@ -120,10 +139,13 @@ module Dentaku
       end
 
       def value(context = {})
-        if left.type == :datetime
-          Dentaku::DateArithmetic.new(left.value(context)).sub(right.value(context))
+        left_value = left.value(context)
+        right_value = right.value(context)
+
+        if left.type == :datetime || datetime?(left_value)
+          Dentaku::DateArithmetic.new(left_value).sub(right_value)
         else
-          super
+          calculate(left_value, right_value)
         end
       end
     end

data/lib/dentaku/ast/comparators.rb

@@ -28,8 +28,7 @@ module Dentaku
 
       def cast(val)
         return val unless val.is_a?(::String)
-        return val if val.empty?
-        return val unless val.match?(/\A-?\d*(\.\d+)?\z/)
+        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?

data/lib/dentaku/ast/function_registry.rb

@@ -8,7 +8,7 @@ module Dentaku
         nil
       end
 
-      def register(name, type, implementation)
+      def register(name, type, implementation, callback = nil)
         function = Class.new(Function) do
           def self.name=(name)
             @name = name
@@ -34,6 +34,14 @@ module Dentaku
             @type
           end
 
+          def self.callback=(callback)
+            @callback = callback
+          end
+
+          def self.callback
+            @callback
+          end
+
           def self.arity
             @implementation.arity < 0 ? nil : @implementation.arity
           end
@@ -61,6 +69,7 @@ module Dentaku
         function.name = name
         function.type = type
         function.implementation = implementation
+        function.callback = callback
 
         self[function_name(name)] = function
       end

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

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

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

@@ -9,5 +9,5 @@ Dentaku::AST::Function.register(:avg, :numeric, ->(*args) {
     ), 'AVG() requires at least one argument'
   end
 
-  flatten_args.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+) / flatten_args.length
+  flatten_args.map { |arg| Dentaku::AST::Function.numeric(arg) }.reduce(0, :+) / BigDecimal(flatten_args.length)
 })

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

@@ -12,9 +12,12 @@ module Dentaku
         3
       end
 
-      def dependencies(context = {})
+      def initialize(*args)
+        super
         validate_identifier(@args[1])
+      end
 
+      def dependencies(context = {})
         collection      = @args[0]
         item_identifier = @args[1].identifier
         expression      = @args[2]
@@ -28,9 +31,7 @@ module Dentaku
       end
 
       def validate_identifier(arg, message = "#{name}() requires second argument to be an identifier")
-        unless arg.is_a?(Identifier)
-          raise ArgumentError.for(:incompatible_type, value: arg, for: Identifier), message
-        end
+        raise ParseError.for(:node_invalid), message unless arg.is_a?(Identifier)
       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/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/functions/ruby_math.rb

@@ -34,6 +34,8 @@ module Dentaku
 
       def self.call(*args)
         @implementation.call(*args)
+      rescue Math::DomainError => _e
+        raise Dentaku::MathDomainError.new(name, args)
       end
 
       def value(context = {})

data/lib/dentaku/ast.rb

@@ -15,6 +15,7 @@ require_relative './ast/array'
 require_relative './ast/grouping'
 require_relative './ast/case'
 require_relative './ast/function_registry'
+require_relative './ast/functions/abs'
 require_relative './ast/functions/all'
 require_relative './ast/functions/and'
 require_relative './ast/functions/any'
@@ -23,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'
@@ -36,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/calculator.rb

@@ -10,7 +10,7 @@ module Dentaku
   class Calculator
     include StringCasing
     attr_reader :result, :memory, :tokenizer, :case_sensitive, :aliases,
-                :nested_data_support, :ast_cache
+                :nested_data_support, :ast_cache, :raw_date_literals
 
     def initialize(options = {})
       clear
@@ -19,22 +19,28 @@ module Dentaku
       @aliases = options.delete(:aliases) || Dentaku.aliases
       @nested_data_support = options.fetch(:nested_data_support, true)
       options.delete(:nested_data_support)
+      @raw_date_literals = options.fetch(:raw_date_literals, true)
+      options.delete(:raw_date_literals)
       @ast_cache = options
       @disable_ast_cache = false
       @function_registry = Dentaku::AST::FunctionRegistry.new
     end
 
-    def self.add_function(name, type, body)
-      Dentaku::AST::FunctionRegistry.default.register(name, type, body)
+    def self.add_function(name, type, body, callback = nil)
+      Dentaku::AST::FunctionRegistry.default.register(name, type, body, callback)
     end
 
-    def add_function(name, type, body)
-      @function_registry.register(name, type, body)
+    def self.add_functions(functions)
+      functions.each { |(name, type, body, callback)| add_function(name, type, body, callback) }
+    end
+
+    def add_function(name, type, body, callback = nil)
+      @function_registry.register(name, type, body, callback)
       self
     end
 
-    def add_functions(fns)
-      fns.each { |(name, type, body)| add_function(name, type, body) }
+    def add_functions(functions)
+      functions.each { |(name, type, body, callback)| add_function(name, type, body, callback) }
       self
     end
 
@@ -57,8 +63,7 @@ module Dentaku
       } if expression.is_a? Array
 
       store(data) do
-        node = expression
-        node = ast(node) unless node.is_a?(AST::Node)
+        node = ast(expression)
         unbound = node.dependencies(memory)
         unless unbound.empty?
           raise UnboundVariableError.new(unbound),
@@ -90,13 +95,15 @@ 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) {
         options = {
+          aliases: aliases,
           case_sensitive: case_sensitive,
           function_registry: @function_registry,
-          aliases: aliases
+          raw_date_literals: raw_date_literals
         }
 
         tokens = tokenizer.tokenize(expression, options)

data/lib/dentaku/date_arithmetic.rb

@@ -1,7 +1,11 @@
 module Dentaku
   class DateArithmetic
     def initialize(date)
-      @base = date
+      if date.respond_to?(:strftime)
+        @base = date
+      else
+        @base = Time.parse(date).to_datetime
+      end
     end
 
     def add(duration)
@@ -25,7 +29,7 @@ module Dentaku
 
     def sub(duration)
       case duration
-      when DateTime, Numeric
+      when Date, DateTime, Numeric
         @base - duration
       when Dentaku::AST::Duration::Value
         case duration.unit
@@ -36,6 +40,8 @@ module Dentaku
         when :day
           @base - 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"

data/lib/dentaku/exceptions.rb

@@ -11,6 +11,15 @@ module Dentaku
     end
   end
 
+  class MathDomainError < Error
+    attr_reader :function_name, :args
+
+    def initialize(function_name, args)
+      @function_name = function_name
+      @args = args
+    end
+  end
+
   class NodeError < Error
     attr_reader :child, :expect, :actual
 
@@ -58,7 +67,9 @@ module Dentaku
     private_class_method :new
 
     VALID_REASONS = %i[
-      parse_error too_many_opening_parentheses too_many_closing_parentheses
+      parse_error
+      too_many_closing_parentheses
+      too_many_opening_parentheses
       unexpected_zero_width_match
     ].freeze
 
@@ -83,8 +94,11 @@ module Dentaku
     private_class_method :new
 
     VALID_REASONS = %i[
-      invalid_operator invalid_value too_few_arguments
-      too_much_arguments incompatible_type
+      incompatible_type
+      invalid_operator
+      invalid_value
+      too_few_arguments
+      wrong_number_of_arguments
     ].freeze
 
     def self.for(reason, **meta)

data/lib/dentaku/parser.rb

@@ -45,22 +45,33 @@ module Dentaku
 
       operator.peek(output)
 
+      output_size = output.length
       args_size = operator.arity || count
       min_size = operator.arity || operator.min_param_count || count
       max_size = operator.arity || operator.max_param_count || count
 
-      if output.length < min_size || args_size < min_size
-        fail! :too_few_operands, operator: operator, expect: min_size, actual: output.length
+      if output_size < min_size || args_size < min_size
+        expect = min_size == max_size ? min_size : min_size..max_size
+        fail! :too_few_operands, operator: operator, expect: expect, actual: output_size
       end
 
-      if output.length > max_size && operations.empty? || args_size > max_size
-        fail! :too_many_operands, operator: operator, expect: max_size, actual: output.length
+      if output_size > max_size && operations.empty? || args_size > max_size
+        expect = min_size == max_size ? min_size : min_size..max_size
+        fail! :too_many_operands, operator: operator, expect: expect, actual: output_size
       end
 
-      fail! :invalid_statement if output.size < args_size
-      args = Array.new(args_size) { output.pop }.reverse
+      if operator == AST::Array && output.empty?
+        output.push(operator.new())
+      else
+        fail! :invalid_statement if output_size < args_size
+        args = Array.new(args_size) { output.pop }.reverse
 
-      output.push operator.new(*args)
+        output.push operator.new(*args)
+      end
+
+      if operator.respond_to?(:callback) && !operator.callback.nil?
+        operator.callback.call(args)
+      end
     rescue ::ArgumentError => e
       raise Dentaku::ArgumentError, e.message
     rescue NodeError => e
@@ -320,9 +331,9 @@ module Dentaku
         when :node_invalid
           "#{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"
+          "#{meta.fetch(:operator)} has too few operands (given #{meta.fetch(:actual)}, expected #{meta.fetch(:expect)})"
         when :too_many_operands
-          "#{meta.fetch(:operator)} has too many operands"
+          "#{meta.fetch(:operator)} has too many operands (given #{meta.fetch(:actual)}, expected #{meta.fetch(:expect)})"
         when :undefined_function
           "Undefined function #{meta.fetch(:function_name)}"
         when :unprocessed_token

data/lib/dentaku/print_visitor.rb

@@ -7,24 +7,31 @@ module Dentaku
 
     def visit_operation(node)
       if node.left
-        visit_operand(node.left, node.class.precedence, suffix: " ")
+        visit_operand(node.left, node.class.precedence, suffix: " ", dir: :left)
       end
 
       @output << node.display_operator
 
       if node.right
-        visit_operand(node.right, node.class.precedence, prefix: " ")
+        visit_operand(node.right, node.class.precedence, prefix: " ", dir: :right)
       end
     end
 
-    def visit_operand(node, precedence, prefix: "", suffix: "")
+    def visit_operand(node, precedence, prefix: "", suffix: "", dir: :none)
       @output << prefix
-      @output << "(" if node.is_a?(Dentaku::AST::Operation) && node.class.precedence < precedence
+      @output << "(" if should_output?(node, precedence, dir == :right)
       node.accept(self)
-      @output << ")" if node.is_a?(Dentaku::AST::Operation) && node.class.precedence < precedence
+      @output << ")" if should_output?(node, precedence, dir == :right)
       @output << suffix
     end
 
+    def should_output?(node, precedence, output_on_equal)
+      return false unless node.is_a?(Dentaku::AST::Operation)
+
+      target_precedence = node.class.precedence
+      target_precedence < precedence || (output_on_equal && target_precedence == precedence)
+    end
+
     def visit_function(node)
       @output << node.name
       @output << "("
@@ -94,6 +101,10 @@ module Dentaku
       @output << "NULL"
     end
 
+    def visit_array(node)
+      @output << node.value.to_s
+    end
+
     def to_s
       @output
     end