dentaku 3.5.0 → 3.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a0b093e29b178197c0f92c1f63ec56342716c1fa84a4d12a73a7d355d42bc76
-  data.tar.gz: 480ccf9248568006227518363a0ef6350843007389f2e94ac5610ae62028e87e
+  metadata.gz: 0b10f7d9e6a9d200c283dcf077fd56e8f4abe4922c02e3095ba20dbb29f6b81c
+  data.tar.gz: add2d3bf7c462edefb9a4c52d79595d3a161e1d78046dbb1fe90e8aa9979a13b
 SHA512:
-  metadata.gz: 904292b2d2fd834701fd18900d689b9125579d58421fc58aaad03cd75c0fb556eeaeb5635dcd034a3f29e9f70f5c8fe0370e605acefd599c3dd75eae64436fdd
-  data.tar.gz: 3b6ed8763b9241e55e85f1a1e5a09d2652ec91eee21c080ca825029e04867b8fe65b128ddfc557cab3ef4fae76abb30b936f5971326355ea763081f90ba66638
+  metadata.gz: 48c2571ea61f8bb9f8a7a4483b8d588741f2c44c4fdc2d04ecd2a5c5b75a94f414b5772a3e1dca21898f8d2ed6488e54925c6a689bfd721315c0c8e0992991d7
+  data.tar.gz: b469e9c4a69c6083b93cda29ea8bf5bf4ad9c91e4a6362e5880768492e21ecd476a09eb858134b8e6c78017207c6cf50479c7ebb3af661c7e20f3866f034b49a

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # 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
+- improve parse exceptions
+- improve bitwise exceptions
+- include variable name in bulk expression exceptions
+
 ## [v3.5.0]
 - fix bug with function argument count
 - add XOR operator
@@ -224,6 +244,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[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
 [v3.4.1]:  https://github.com/rubysolo/dentaku/compare/v3.4.0...v3.4.1

data/README.md

@@ -137,7 +137,7 @@ application, AST caching will consume more memory with each new formula.
 BUILT-IN OPERATORS AND FUNCTIONS
 ---------------------------------
 
-Math: `+`, `-`, `*`, `/`, `%`, `^`, `|`, `&`
+Math: `+`, `-`, `*`, `/`, `%`, `^`, `|`, `&`, `<<`, `>>`
 
 Also, all functions from Ruby's Math module, including `SIN`, `COS`, `TAN`, etc.
 
@@ -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,31 +32,43 @@ module Dentaku
       end
 
       def value(context = {})
-        l = cast(left.value(context))
-        r = cast(right.value(context))
-        begin
-          l.public_send(operator, r)
-        rescue ::TypeError => e
-          # Right cannot be converted to a suitable type for left. e.g. [] + 1
-          raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
-        end
+        calculate(left.value(context), right.value(context))
       end
 
       private
 
-      def cast(val, prefer_integer = true)
+      def calculate(left_value, right_value)
+        l = cast(left_value)
+        r = cast(right_value)
+
+        l.public_send(operator, r)
+      rescue ::TypeError => e
+        # Right cannot be converted to a suitable type for left. e.g. [] + 1
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
+      end
+
+      def cast(val)
         validate_value(val)
-        numeric(val, prefer_integer)
+        numeric(val)
+      end
+
+      def numeric(val)
+        case val.to_s
+        when DECIMAL then decimal(val)
+        when INTEGER then val.to_i
+        else val
+        end
       end
 
-      def numeric(val, prefer_integer)
-        v = BigDecimal(val, Float::DIG + 1)
-        v = v.to_i if prefer_integer && v.frac.zero?
-        v
-      rescue ::TypeError
-        # If we got a TypeError BigDecimal or to_i failed;
-        # let value through so ruby things like Time - integer work
-        val
+      def decimal(val)
+        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)
@@ -101,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
@@ -119,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
@@ -143,7 +164,7 @@ module Dentaku
       end
 
       def value(context = {})
-        r = cast(right.value(context), false)
+        r = decimal(cast(right.value(context)))
         raise Dentaku::ZeroDivisionError if r.zero?
 
         cast(cast(left.value(context)) / r)

data/lib/dentaku/ast/bitwise.rb

@@ -2,23 +2,40 @@ require_relative './operation'
 
 module Dentaku
   module AST
-    class BitwiseOr < Operation
+    class Bitwise < Operation
       def value(context = {})
-        left.value(context) | right.value(context)
+        left_value = left.value(context)
+        right_value = right.value(context)
+
+        left_value.public_send(operator, right_value)
+      rescue NoMethodError => e
+        raise Dentaku::ArgumentError.for(:invalid_operator, value: left_value, for: left_value.class)
+      rescue TypeError => e
+        raise Dentaku::ArgumentError.for(:invalid_operator, value: right_value, for: right_value.class)
       end
+    end
 
+    class BitwiseOr < Bitwise
       def operator
         :|
       end
     end
 
-    class BitwiseAnd < Operation
-      def value(context = {})
-        left.value(context) & right.value(context)
+    class BitwiseAnd < Bitwise
+      def operator
+        :&
       end
+    end
 
+    class BitwiseShiftLeft < Bitwise
       def operator
-        :&
+        :<<
+      end
+    end
+
+    class BitwiseShiftRight < Bitwise
+      def operator
+        :>>
       end
     end
   end

data/lib/dentaku/ast/comparators.rb

@@ -16,8 +16,8 @@ module Dentaku
       end
 
       def value(context = {})
-        l = validate_value(left.value(context))
-        r = validate_value(right.value(context))
+        l = validate_value(cast(left.value(context)))
+        r = validate_value(cast(right.value(context)))
 
         l.public_send(operator, r)
       rescue ::ArgumentError => e
@@ -26,6 +26,15 @@ module Dentaku
 
       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
+      end
+
       def validate_value(value)
         unless value.respond_to?(operator)
           raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator),

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/bulk_expression_solver.rb

@@ -89,13 +89,9 @@ module Dentaku
     def with_rescues(var_name, results, block)
       yield
 
-    rescue UnboundVariableError,  Dentaku::ZeroDivisionError => ex
+    rescue Dentaku::UnboundVariableError, Dentaku::ZeroDivisionError, Dentaku::ArgumentError => ex
       ex.recipient_variable = var_name
       results[var_name] = block.call(ex)
-
-    rescue Dentaku::ArgumentError => ex
-      results[var_name] = block.call(ex)
-
     ensure
       if results[var_name] == :undefined && calculator.memory.has_key?(var_name.downcase)
         results[var_name] = calculator.memory[var_name.downcase]

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

@@ -1,10 +1,9 @@
 module Dentaku
   class Error < StandardError
+    attr_accessor :recipient_variable
   end
 
   class UnboundVariableError < Error
-    attr_accessor :recipient_variable
-
     attr_reader :unbound_variables
 
     def initialize(unbound_variables)
@@ -12,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
 
@@ -74,6 +82,7 @@ module Dentaku
 
   class ArgumentError < ::ArgumentError
     attr_reader :reason, :meta
+    attr_accessor :recipient_variable
 
     def initialize(reason, **meta)
       @reason = reason

data/lib/dentaku/parser.rb

@@ -10,8 +10,11 @@ module Dentaku
       pow:      AST::Exponentiation,
       negate:   AST::Negation,
       mod:      AST::Modulo,
+
       bitor:    AST::BitwiseOr,
       bitand:   AST::BitwiseAnd,
+      bitshiftleft:  AST::BitwiseShiftLeft,
+      bitshiftright: AST::BitwiseShiftRight,
 
       lt:       AST::LessThan,
       gt:       AST::GreaterThan,
@@ -38,24 +41,33 @@ module Dentaku
 
     def consume(count = 2)
       operator = operations.pop
+      fail! :invalid_statement if operator.nil?
+
       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
@@ -315,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
@@ -120,9 +124,9 @@ module Dentaku
 
       def operator
         names = {
-          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&'
+          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&', bitshiftleft: '<<', bitshiftright: '>>'
         }.invert
-        new(:operator, '\^|\+|-|\*|\/|%|\||&', lambda { |raw| names[raw] })
+        new(:operator, '\^|\+|-|\*|\/|%|\||&|<<|>>', lambda { |raw| names[raw] })
       end
 
       def grouping

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.0"
+  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