dentaku 3.5.1 → 3.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5592654ee45adeb24167b584374fb2d69bc67d1db4d5f4ac99050130f187f8f
-  data.tar.gz: 31d3952b08887ae934661f4c0ecc5c298b2f36f0f8365cc1503495eb044eb558
+  metadata.gz: 0b10f7d9e6a9d200c283dcf077fd56e8f4abe4922c02e3095ba20dbb29f6b81c
+  data.tar.gz: add2d3bf7c462edefb9a4c52d79595d3a161e1d78046dbb1fe90e8aa9979a13b
 SHA512:
-  metadata.gz: d8e0d003f897e06173c91b200e62d9fed12ec3bacfe0f2ecc3f3705a1cbf914d1705948b79962f5ac6a5397138ff89c2123aa5c3753963f0046a88280b29825b
-  data.tar.gz: 5f48d3b8fef4e56ed308e717da88937bef508e47dfca4c3e16610aff7523f11405e53e2b55d00c53b5eca8efbe7be64df0d0d12e7ddafbc61099cde08bf92a53
+  metadata.gz: 48c2571ea61f8bb9f8a7a4483b8d588741f2c44c4fdc2d04ecd2a5c5b75a94f414b5772a3e1dca21898f8d2ed6488e54925c6a689bfd721315c0c8e0992991d7
+  data.tar.gz: b469e9c4a69c6083b93cda29ea8bf5bf4ad9c91e4a6362e5880768492e21ecd476a09eb858134b8e6c78017207c6cf50479c7ebb3af661c7e20f3866f034b49a

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Change Log
 
+## [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 +244,7 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
-[Unreleased]: https://github.com/rubysolo/dentaku/compare/v3.5.1...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`
 
 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,8 +54,8 @@ 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
@@ -57,6 +64,13 @@ module Dentaku
         BigDecimal(val.to_s, Float::DIG + 1)
       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)
         node && (node.type == :numeric || node.type == :integer || node.dependencies.any?)
       end
@@ -102,10 +116,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 +137,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/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'

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
 
@@ -94,9 +100,10 @@ module Dentaku
 
       @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)

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
 

data/lib/dentaku/parser.rb

@@ -45,22 +45,29 @@ 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
+      fail! :invalid_statement if output_size < args_size
       args = Array.new(args_size) { output.pop }.reverse
 
       output.push operator.new(*args)
+
+      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 +327,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

data/lib/dentaku/token_scanner.rb

@@ -7,6 +7,8 @@ module Dentaku
   class TokenScanner
     extend StringCasing
 
+    DATE_TIME_REGEXP = /\d{2}\d{2}?-\d{1,2}-\d{1,2}( \d{1,2}:\d{1,2}:\d{1,2})? ?(Z|((\+|\-)\d{2}\:?\d{2}))?(?!\d)/.freeze
+
     def initialize(category, regexp, converter = nil, condition = nil)
       @category  = category
       @regexp    = %r{\A(#{ regexp })}i
@@ -73,7 +75,9 @@ module Dentaku
 
       def scanners(options = {})
         @case_sensitive = options.fetch(:case_sensitive, false)
-        @scanners.values
+        raw_date_literals = options.fetch(:raw_date_literals, true)
+
+        @scanners.select { |k, _| raw_date_literals || k != :datetime }.values
       end
 
       def whitespace
@@ -86,7 +90,7 @@ module Dentaku
 
       # NOTE: Convert to DateTime as Array(Time) returns the parts of the time for some reason
       def datetime
-        new(:datetime, /\d{2}\d{2}?-\d{1,2}-\d{1,2}( \d{1,2}:\d{1,2}:\d{1,2})? ?(Z|((\+|\-)\d{2}\:?\d{2}))?/, lambda { |raw| Time.parse(raw).to_datetime })
+        new(:datetime, DATE_TIME_REGEXP, lambda { |raw| Time.parse(raw).to_datetime })
       end
 
       def numeric

data/lib/dentaku/tokenizer.rb

@@ -4,7 +4,7 @@ require 'dentaku/token_scanner'
 
 module Dentaku
   class Tokenizer
-    attr_reader :case_sensitive, :aliases
+    attr_reader :aliases
 
     LPAREN = TokenMatcher.new(:grouping, :open)
     RPAREN = TokenMatcher.new(:grouping, :close)
@@ -15,10 +15,14 @@ module Dentaku
       @aliases = options.fetch(:aliases, global_aliases)
       input    = strip_comments(string.to_s.dup)
       input    = replace_aliases(input)
-      @case_sensitive = options.fetch(:case_sensitive, false)
+
+      scanner_options = {
+        case_sensitive: options.fetch(:case_sensitive, false),
+        raw_date_literals: options.fetch(:raw_date_literals, true)
+      }
 
       until input.empty?
-        scanned = TokenScanner.scanners(case_sensitive: case_sensitive).any? do |scanner|
+        scanned = TokenScanner.scanners(scanner_options).any? do |scanner|
           scanned, input = scan(input, scanner)
           scanned
         end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.1"
+  VERSION = "3.5.2"
 end

data/lib/dentaku/visitor/infix.rb

@@ -77,6 +77,10 @@ module Dentaku
       def visit_nil(node)
         process(node)
       end
+
+      def visit_array(node)
+        process(node)
+      end
     end
   end
 end

data/spec/ast/abs_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/abs'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Abs' do
+  it 'returns the absolute value of number' do
+    result = Dentaku('ABS(-4.2)')
+    expect(result).to eq(4.2)
+  end
+
+  it 'returns the correct value for positive number' do
+    result = Dentaku('ABS(1.3)')
+    expect(result).to eq(1.3)
+  end
+
+  it 'returns the correct value for zero' do
+    result = Dentaku('ABS(0)')
+    expect(result).to eq(0)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if argument is not numeric' do
+      expect { Dentaku!("ABS(2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/all_spec.rb

@@ -19,7 +19,7 @@ describe Dentaku::AST::All do
 
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('ALL({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
-      Dentaku::ArgumentError, 'ALL() requires second argument to be an identifier'
+      Dentaku::ParseError, 'ALL() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/any_spec.rb

@@ -18,6 +18,6 @@ describe Dentaku::AST::Any do
   end
 
   it 'raises argument error if a string is passed as identifier' do
-    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ArgumentError)
+    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ParseError)
   end
 end

data/spec/ast/arithmetic_spec.rb

@@ -4,12 +4,12 @@ require 'dentaku/ast/arithmetic'
 require 'dentaku/token'
 
 describe Dentaku::AST::Arithmetic do
-  let(:one)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
-  let(:two)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
-  let(:x)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
-  let(:y)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
+  let(:one)  { Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, 1)) }
+  let(:two)  { Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, 2)) }
+  let(:x)    { Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, 'x')) }
+  let(:y)    { Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, 'y')) }
   let(:ctx)  { {'x' => 1, 'y' => 2} }
-  let(:date) { Dentaku::AST::DateTime.new Dentaku::Token.new(:datetime, DateTime.new(2020, 4, 16)) }
+  let(:date) { Dentaku::AST::DateTime.new(Dentaku::Token.new(:datetime, DateTime.new(2020, 4, 16))) }
 
   it 'performs an arithmetic operation with numeric operands' do
     expect(add(one, two)).to eq(3)
@@ -46,12 +46,20 @@ describe Dentaku::AST::Arithmetic do
     expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
     expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
 
-    int_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1")
-    decimal_one = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, "1.0")
+    int_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1"))
+    int_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1"))
+    decimal_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1.0"))
+    decimal_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1.0"))
 
-    expect(add(int_one, int_one).class).to eq(Integer)
-    expect(add(int_one, decimal_one).class).to eq(BigDecimal)
-    expect(add(decimal_one, decimal_one).class).to eq(BigDecimal)
+    [int_one, int_neg_one].permutation(2).each do |(left, right)|
+      expect(add(left, right).class).to eq(Integer)
+    end
+
+    [decimal_one, decimal_neg_one].each do |left|
+      [int_one, int_neg_one, decimal_one, decimal_neg_one].each do |right|
+        expect(add(left, right).class).to eq(BigDecimal)
+      end
+    end
   end
 
   it 'performs arithmetic on arrays' do

data/spec/ast/avg_spec.rb

@@ -3,6 +3,11 @@ require 'dentaku/ast/functions/avg'
 require 'dentaku'
 
 describe 'Dentaku::AST::Function::Avg' do
+  it 'returns the average of an array of Numeric values as BigDecimal' do
+    result = Dentaku('AVG(1, 2)')
+    expect(result).to eq(1.5)
+  end
+
   it 'returns the average of an array of Numeric values' do
     result = Dentaku('AVG(1, x, 1.8)', x: 2.3)
     expect(result).to eq(1.7)

data/spec/ast/filter_spec.rb

@@ -19,7 +19,7 @@ describe Dentaku::AST::Filter do
 
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('FILTER({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
-      Dentaku::ArgumentError, 'FILTER() requires second argument to be an identifier'
+      Dentaku::ParseError, 'FILTER() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/map_spec.rb

@@ -21,7 +21,7 @@ describe Dentaku::AST::Map do
 
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('MAP({1, 2, 3}, "val", val + 1)') }.to raise_error(
-      Dentaku::ArgumentError,  'MAP() requires second argument to be an identifier'
+      Dentaku::ParseError,  'MAP() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/pluck_spec.rb

@@ -21,7 +21,7 @@ describe Dentaku::AST::Pluck do
     expect do Dentaku.evaluate!('PLUCK(users, "age")', users: [
       {name: "Bob",  age: 44},
       {name: "Jane", age: 27}
-    ]) end.to raise_error(Dentaku::ArgumentError, 'PLUCK() requires second argument to be an identifier')
+    ]) end.to raise_error(Dentaku::ParseError, 'PLUCK() requires second argument to be an identifier')
   end
 
   it 'raises argument error if a non array of hashes is passed as collection' do

data/spec/calculator_spec.rb

@@ -22,6 +22,7 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('(2 + 3) - 1')).to eq(4)
     expect(calculator.evaluate('(-2 + 3) - 1')).to eq(0)
     expect(calculator.evaluate('(-2 - 3) - 1')).to eq(-6)
+    expect(calculator.evaluate('1353+91-1-3322-22')).to eq(-1901)
     expect(calculator.evaluate('1 + -(2 ^ 2)')).to eq(-3)
     expect(calculator.evaluate('3 + -num', num: 2)).to eq(1)
     expect(calculator.evaluate('-num + 3', num: 2)).to eq(1)
@@ -329,6 +330,11 @@ describe Dentaku::Calculator do
       }.not_to raise_error
     end
 
+    it 'allows to compare "-" or "-."' do
+      expect { calculator.solve("IF('-' =  '-', 0, 1)") }.not_to raise_error
+      expect { calculator.solve("IF('-.'= '-.', 0, 1)") }.not_to raise_error
+    end
+
     it "integrates with custom functions" do
       calculator.add_function(:custom, :integer, -> { 1 })
 
@@ -440,19 +446,42 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('t1 > 2017-01-02', t1: Time.local(2017, 1, 3).to_datetime)).to be_truthy
   end
 
-  it 'supports date arithmetic' do
-    expect(calculator.evaluate!('2020-01-01 + 30').to_date).to eq(Time.local(2020, 1, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 - 1').to_date).to eq(Time.local(2019, 12, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 - 2019-12-31')).to eq(1)
-    expect(calculator.evaluate!('2020-01-01 + duration(1, day)').to_date).to eq(Time.local(2020, 1, 2).to_date)
-    expect(calculator.evaluate!('2020-01-01 - duration(1, day)').to_date).to eq(Time.local(2019, 12, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(30, days)').to_date).to eq(Time.local(2020, 1, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(1, month)').to_date).to eq(Time.local(2020, 2, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 - duration(1, month)').to_date).to eq(Time.local(2019, 12, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(30, months)').to_date).to eq(Time.local(2022, 7, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(1, year)').to_date).to eq(Time.local(2021, 1, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 - duration(1, year)').to_date).to eq(Time.local(2019, 1, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(30, years)').to_date).to eq(Time.local(2050, 1, 1).to_date)
+  describe 'disabling date literals' do
+    it 'does not parse formulas with minus signs as dates' do
+      calculator = described_class.new(raw_date_literals: false)
+      expect(calculator.evaluate!('2020-01-01')).to eq(2018)
+    end
+  end
+
+  describe 'supports date arithmetic' do
+    it 'from hardcoded string' do
+      expect(calculator.evaluate!('2020-01-01 + 30').to_date).to eq(Time.local(2020, 1, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 - 1').to_date).to eq(Time.local(2019, 12, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 - 2019-12-31')).to eq(1)
+      expect(calculator.evaluate!('2020-01-01 + duration(1, day)').to_date).to eq(Time.local(2020, 1, 2).to_date)
+      expect(calculator.evaluate!('2020-01-01 - duration(1, day)').to_date).to eq(Time.local(2019, 12, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(30, days)').to_date).to eq(Time.local(2020, 1, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(1, month)').to_date).to eq(Time.local(2020, 2, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 - duration(1, month)').to_date).to eq(Time.local(2019, 12, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(30, months)').to_date).to eq(Time.local(2022, 7, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(1, year)').to_date).to eq(Time.local(2021, 1, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 - duration(1, year)').to_date).to eq(Time.local(2019, 1, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(30, years)').to_date).to eq(Time.local(2050, 1, 1).to_date)
+    end
+
+    it 'from string variable' do
+      value = '2023-01-01'
+
+      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eql(Date.parse('2023-02-01'))
+      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eql(Date.parse('2022-12-01'))
+    end
+
+    it 'from date object' do
+      value = Date.parse('2023-01-01').to_date
+
+      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eql(Date.parse('2023-02-01'))
+      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eql(Date.parse('2022-12-01'))
+    end
   end
 
   describe 'functions' do
@@ -471,6 +500,13 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('ROUND(apples * 0.93)', apples: 10)).to eq(9)
     end
 
+    it 'include ABS' do
+      expect(calculator.evaluate('abs(-2.2)')).to eq(2.2)
+      expect(calculator.evaluate('abs(5)')).to eq(5)
+
+      expect(calculator.evaluate('ABS(x * -1)', x: 10)).to eq(10)
+    end
+
     it 'include NOT' do
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: true)).to be_falsey
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: false)).to be_truthy
@@ -758,9 +794,9 @@ describe Dentaku::Calculator do
     end
   end
 
-  describe 'math functions' do
+  describe 'math support' do
     Math.methods(false).each do |method|
-      it method do
+      it "includes `#{method}`" do
         if Math.method(method).arity == 2
           expect(calculator.evaluate("#{method}(x,y)", x: 1, y: '2')).to eq(Math.send(method, 1, 2))
           expect(calculator.evaluate("#{method}(x,y) + 1", x: 1, y: '2')).to be_within(0.00001).of(Math.send(method, 1, 2) + 1)
@@ -774,11 +810,16 @@ describe Dentaku::Calculator do
       end
     end
 
-    it 'are defined with a properly named class that represents it to support AST marshaling' do
+    it 'defines a properly named class to support AST marshaling' do
       expect {
         Marshal.dump(calculator.ast('SQRT(20)'))
       }.not_to raise_error
     end
+
+    it 'properly handles a Math::DomainError' do
+      expect(calculator.evaluate('asin(2)')).to be_nil
+      expect { calculator.evaluate!('asin(2)') }.to raise_error(Dentaku::MathDomainError)
+    end
   end
 
   describe 'disable_cache' do

data/spec/external_function_spec.rb

@@ -5,8 +5,7 @@ require 'dentaku/calculator'
 describe Dentaku::Calculator do
   describe 'functions' do
     describe 'external functions' do
-
-      let(:with_external_funcs) do
+      let(:custom_calculator) do
         c = described_class.new
 
         c.add_function(:now, :string, -> { Time.now.to_s })
@@ -22,30 +21,30 @@ describe Dentaku::Calculator do
       end
 
       it 'includes NOW' do
-        now = with_external_funcs.evaluate('NOW()')
+        now = custom_calculator.evaluate('NOW()')
         expect(now).not_to be_nil
         expect(now).not_to be_empty
       end
 
       it 'includes POW' do
-        expect(with_external_funcs.evaluate('POW(2,3)')).to eq(8)
-        expect(with_external_funcs.evaluate('POW(3,2)')).to eq(9)
-        expect(with_external_funcs.evaluate('POW(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
+        expect(custom_calculator.evaluate('POW(2,3)')).to eq(8)
+        expect(custom_calculator.evaluate('POW(3,2)')).to eq(9)
+        expect(custom_calculator.evaluate('POW(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
       end
 
       it 'includes BIGGEST' do
-        expect(with_external_funcs.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
+        expect(custom_calculator.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
       end
 
       it 'includes SMALLEST' do
-        expect(with_external_funcs.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
+        expect(custom_calculator.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
       end
 
       it 'includes OPTIONAL' do
-        expect(with_external_funcs.evaluate('OPTIONAL(1,2)')).to eq(3)
-        expect(with_external_funcs.evaluate('OPTIONAL(1,2,3)')).to eq(6)
-        expect { with_external_funcs.dependencies('OPTIONAL()') }.to raise_error(Dentaku::ParseError)
-        expect { with_external_funcs.dependencies('OPTIONAL(1,2,3,4)') }.to raise_error(Dentaku::ParseError)
+        expect(custom_calculator.evaluate('OPTIONAL(1,2)')).to eq(3)
+        expect(custom_calculator.evaluate('OPTIONAL(1,2,3)')).to eq(6)
+        expect { custom_calculator.dependencies('OPTIONAL()') }.to raise_error(Dentaku::ParseError)
+        expect { custom_calculator.dependencies('OPTIONAL(1,2,3,4)') }.to raise_error(Dentaku::ParseError)
       end
 
       it 'supports array parameters' do
@@ -62,6 +61,66 @@ describe Dentaku::Calculator do
       end
     end
 
+    describe 'with callbacks' do
+      let(:custom_calculator) do
+        c = described_class.new
+
+        @counts = Hash.new(0)
+
+        @initial_time = "2023-02-03"
+        @last_time = @initial_time
+
+        c.add_function(
+            :reverse,
+            :stringl,
+            ->(a) { a.reverse },
+            lambda do |args|
+              args.each do |arg|
+                @counts[arg.value] += 1 if arg.type == :string
+              end
+            end
+        )
+
+        fns = [
+          [:biggest_callback,  :numeric, ->(*args) { args.max }, ->(args) { args.each { |arg| raise Dentaku::ArgumentError unless arg.type == :numeric } }],
+          [:pythagoras, :numeric, ->(l1, l2) { Math.sqrt(l1**2 + l2**2) }, ->(e) { @last_time = Time.now.to_s }],
+          [:callback_lambda, :string, ->() { " " }, ->() { "lambda executed" }],
+          [:no_lambda_function, :numeric, ->(a) { a**a }],
+        ]
+
+        c.add_functions(fns)
+      end
+
+      it 'includes BIGGEST_CALLBACK' do
+        expect(custom_calculator.evaluate('BIGGEST_CALLBACK(1, 2, 5, 4)')).to eq(5)
+        expect { custom_calculator.dependencies('BIGGEST_CALLBACK(1, 3, 6, "hi", 10)') }.to raise_error(Dentaku::ArgumentError)
+      end
+
+      it 'includes REVERSE' do
+        expect(custom_calculator.evaluate('REVERSE(\'Dentaku\')')).to eq('ukatneD')
+        expect { custom_calculator.evaluate('REVERSE(22)') }.to raise_error(NoMethodError)
+        expect(@counts["Dentaku"]).to eq(1)
+      end
+
+      it 'includes PYTHAGORAS' do
+        expect(custom_calculator.evaluate('PYTHAGORAS(8, 7)')).to eq(10.63014581273465)
+        expect(custom_calculator.evaluate('PYTHAGORAS(3, 4)')).to eq(5)
+        expect(@last_time).not_to eq(@initial_time)
+      end
+
+      it 'exposes the `callback` method of a function' do
+        expect(Dentaku::AST::Function::Callback_lambda.callback.call()).to eq("lambda executed")
+      end
+
+      it 'does not add a `callback` method to built-in functions' do
+        expect { Dentaku::AST::If.callback.call }.to raise_error(NoMethodError)
+      end
+
+      it 'defaults `callback` method to nil if not specified' do
+        expect(Dentaku::AST::Function::No_lambda_function.callback).to eq(nil)
+      end
+    end
+
     it 'allows registering "bang" functions' do
       calculator = described_class.new
       calculator.add_function(:hey!, :string, -> { "hey!" })
@@ -82,24 +141,36 @@ describe Dentaku::Calculator do
     end
 
     it 'does not store functions across all calculators' do
-      calculator1 = Dentaku::Calculator.new
+      calculator1 = described_class.new
       calculator1.add_function(:my_function, :numeric, ->(x) { 2 * x + 1 })
 
-      calculator2 = Dentaku::Calculator.new
+      calculator2 = described_class.new
       calculator2.add_function(:my_function, :numeric, ->(x) { 4 * x + 3 })
 
       expect(calculator1.evaluate!("1 + my_function(2)")). to eq(1 + 2 * 2 + 1)
       expect(calculator2.evaluate!("1 + my_function(2)")). to eq(1 + 4 * 2 + 3)
 
       expect {
-        Dentaku::Calculator.new.evaluate!("1 + my_function(2)")
+        described_class.new.evaluate!("1 + my_function(2)")
       }.to raise_error(Dentaku::ParseError)
     end
 
     describe 'Dentaku::Calculator.add_function' do
-      it 'adds to default/global function registry' do
-        Dentaku::Calculator.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })
-        expect(Dentaku::Calculator.new.evaluate("global_function(3) + 5")).to eq(10 + 3**2 + 5)
+      it 'adds a function to default/global function registry' do
+        described_class.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })
+        expect(described_class.new.evaluate("global_function(3) + 5")).to eq(10 + 3**2 + 5)
+      end
+    end
+
+    describe 'Dentaku::Calculator.add_functions' do
+      it 'adds multiple functions to default/global function registry' do
+        described_class.add_functions([
+          [:cube, :numeric, ->(x) { x**3 }],
+          [:spongebob, :string, ->(x) { x.split("").each_with_index().map { |c,i| i.even? ? c.upcase : c.downcase }.join() }],
+        ])
+
+        expect(described_class.new.evaluate("1 + cube(3)")).to eq(28)
+        expect(described_class.new.evaluate("spongebob('How are you today?')")).to eq("HoW ArE YoU ToDaY?")
       end
     end
   end

data/spec/print_visitor_spec.rb

@@ -8,6 +8,12 @@ describe Dentaku::PrintVisitor do
     expect(repr).to eq('5 + 4')
   end
 
+  it 'handles grouping correctly' do
+    formula = '10 - (0 - 10)'
+    repr = roundtrip(formula)
+    expect(repr).to eq(formula)
+  end
+
   it 'quotes string literals' do
     repr = roundtrip('Concat(\'a\',   "B")')
     expect(repr).to eq('CONCAT("a", "B")')

data/spec/visitor/infix_spec.rb

@@ -10,6 +10,21 @@ class ArrayProcessor
     @expression = []
   end
 
+  def visit_array(node)
+    @expression << "{"
+
+    head, *tail = node.value
+
+    process(head) if head
+
+    tail.each do |v|
+      @expression << ","
+      process(v)
+    end
+
+    @expression << "}"
+  end
+
   def process(node)
     @expression << node.to_s
   end
@@ -22,10 +37,16 @@ RSpec.describe Dentaku::Visitor::Infix do
     expect(processor.expression).to eq ['5', '+', '3']
   end
 
+  it 'supports array nodes' do
+    processor = ArrayProcessor.new
+    processor.visit(ast('{1, 2, 3}'))
+    expect(processor.expression).to eq ['{', '1', ',', '2', ',', '3', '}']
+  end
+
   private
 
   def ast(expression)
     tokens = Dentaku::Tokenizer.new.tokenize(expression)
     Dentaku::Parser.new(tokens).parse
   end
-end
+end

data/spec/visitor_spec.rb

@@ -114,7 +114,7 @@ describe TestVisitor do
     visit_nodes('case (a % 5) when 0 then a else b end')
     visit_nodes('0xCAFE & (0xDECAF << 3) | (0xBEEF >> 5)')
     visit_nodes('2017-12-24 23:59:59')
-    visit_nodes('ALL({1, 2, 3}, "val", val % 2 == 0)')
+    visit_nodes('ALL({1, 2, 3}, val, val % 2 == 0)')
     visit_nodes('ANY(vals, val, val > 1)')
     visit_nodes('COUNT({1, 2, 3})')
     visit_nodes('PLUCK(users, age)')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.1
+  version: 3.5.2
 platform: ruby
 authors:
 - Solomon White
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-24 00:00:00.000000000 Z
+date: 2023-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -170,6 +170,7 @@ files:
 - lib/dentaku/ast/datetime.rb
 - lib/dentaku/ast/function.rb
 - lib/dentaku/ast/function_registry.rb
+- lib/dentaku/ast/functions/abs.rb
 - lib/dentaku/ast/functions/all.rb
 - lib/dentaku/ast/functions/and.rb
 - lib/dentaku/ast/functions/any.rb
@@ -220,6 +221,7 @@ files:
 - lib/dentaku/tokenizer.rb
 - lib/dentaku/version.rb
 - lib/dentaku/visitor/infix.rb
+- spec/ast/abs_spec.rb
 - spec/ast/addition_spec.rb
 - spec/ast/all_spec.rb
 - spec/ast/and_function_spec.rb
@@ -288,6 +290,7 @@ signing_key:
 specification_version: 4
 summary: A formula language parser and evaluator
 test_files:
+- spec/ast/abs_spec.rb
 - spec/ast/addition_spec.rb
 - spec/ast/all_spec.rb
 - spec/ast/and_function_spec.rb