dentaku 3.4.2 → 3.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dadbc209e58b2d2206dfaf48b83be3224db37f71d60cf590aadb63be9f4bebd
-  data.tar.gz: 86530c9c3333139994775a6bde16202005d89161a0b98670db58bcdda47f8e55
+  metadata.gz: d5592654ee45adeb24167b584374fb2d69bc67d1db4d5f4ac99050130f187f8f
+  data.tar.gz: 31d3952b08887ae934661f4c0ecc5c298b2f36f0f8365cc1503495eb044eb558
 SHA512:
-  metadata.gz: f132401168218a3c021124ddabb56bbf485550bdff60a03a291ad811d8628e25caab2ba36e4bed4f8148bde048e56bed1fa31480774f2c19617a79282da81280
-  data.tar.gz: 3b6a8fc5e40988a9442be9dbdf890dc813e13b95fc2d0cb2f60252b2492d07fdf4ba47cdfedd0a85c002aaaa23a83bffb141b8f8f31fbf518678439d55c1e795
+  metadata.gz: d8e0d003f897e06173c91b200e62d9fed12ec3bacfe0f2ecc3f3705a1cbf914d1705948b79962f5ac6a5397138ff89c2123aa5c3753963f0046a88280b29825b
+  data.tar.gz: 5f48d3b8fef4e56ed308e717da88937bef508e47dfca4c3e16610aff7523f11405e53e2b55d00c53b5eca8efbe7be64df0d0d12e7ddafbc61099cde08bf92a53

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Change Log
 
+## [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
+- make function args publicly accessible
+- better argument handling for collection functions
+- better dependency reporting for collection functions
+- allow ruby math-backed functions to be serialized
+- improve scientific notation handling
+- improve comparator argument errors
+- respect case sensitivity in nested case statments
+- add visitor pattern
+
 ## [v3.4.2]
 - add FILTER function
 - add concurrent-ruby dependency to make global calculator object thread safe
@@ -212,6 +231,9 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[Unreleased]: https://github.com/rubysolo/dentaku/compare/v3.5.1...HEAD
+[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
 [v3.4.0]:  https://github.com/rubysolo/dentaku/compare/v3.3.4...v3.4.0

data/README.md

@@ -5,7 +5,6 @@ Dentaku
 [![Gem Version](https://badge.fury.io/rb/dentaku.png)](http://badge.fury.io/rb/dentaku)
 [![Build Status](https://travis-ci.org/rubysolo/dentaku.png?branch=master)](https://travis-ci.org/rubysolo/dentaku)
 [![Code Climate](https://codeclimate.com/github/rubysolo/dentaku.png)](https://codeclimate.com/github/rubysolo/dentaku)
-[![Hakiri](https://hakiri.io/github/rubysolo/dentaku/master.svg)](https://hakiri.io/github/rubysolo/dentaku)
 [![Coverage](https://codecov.io/gh/rubysolo/dentaku/branch/master/graph/badge.svg)](https://codecov.io/gh/rubysolo/dentaku)
 
 
@@ -138,17 +137,17 @@ 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.
 
 Comparison: `<`, `>`, `<=`, `>=`, `<>`, `!=`, `=`,
 
-Logic: `IF`, `AND`, `OR`, `NOT`, `SWITCH`
+Logic: `IF`, `AND`, `OR`, `XOR`, `NOT`, `SWITCH`
 
 Numeric: `MIN`, `MAX`, `SUM`, `AVG`, `COUNT`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`
 
-Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/master/spec/calculator_spec.rb#L292))
+Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/master/spec/calculator_spec.rb#L593))
 
 String: `LEFT`, `RIGHT`, `MID`, `LEN`, `FIND`, `SUBSTITUTE`, `CONCAT`, `CONTAINS`
 
@@ -323,7 +322,7 @@ LICENSE
 
 (The MIT License)
 
-Copyright © 2012-2019 Solomon White
+Copyright © 2012-2022 Solomon White
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the ‘Software’), to deal in

data/lib/dentaku/ast/access.rb

@@ -3,6 +3,8 @@ require_relative "./node"
 module Dentaku
   module AST
     class Access < Node
+      attr_reader :structure, :index
+
       def self.arity
         2
       end
@@ -36,6 +38,10 @@ module Dentaku
       def type
         nil
       end
+
+      def accept(visitor)
+        visitor.visit_access(self)
+      end
     end
   end
 end

data/lib/dentaku/ast/arithmetic.rb

@@ -31,33 +31,34 @@ module Dentaku
       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
+
+        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
 
       private
 
-      def cast(val, prefer_integer = true)
+      def cast(val)
         validate_value(val)
-        numeric(val, prefer_integer)
+        numeric(val)
       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 numeric(val)
+        case val.to_s
+        when /\A\d*\.\d+\z/ then decimal(val)
+        when /\A-?\d+\z/ then val.to_i
+        else val
+        end
+      end
+
+      def decimal(val)
+        BigDecimal(val.to_s, Float::DIG + 1)
       end
 
       def valid_node?(node)
-        node && (node.type == :numeric || node.dependencies.any?)
+        node && (node.type == :numeric || node.type == :integer || node.dependencies.any?)
       end
 
       def valid_left?
@@ -143,7 +144,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)
@@ -220,6 +221,10 @@ module Dentaku
         :**
       end
 
+      def display_operator
+        "^"
+      end
+
       def self.precedence
         30
       end

data/lib/dentaku/ast/array.rb

@@ -32,6 +32,10 @@ module Dentaku
       def type
         nil
       end
+      
+      def accept(visitor)
+        visitor.visit_array(self)
+      end
     end
   end
 end

data/lib/dentaku/ast/bitwise.rb

@@ -2,15 +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 BitwiseAnd < Operation
-      def value(context = {})
-        left.value(context) & right.value(context)
+    class BitwiseOr < Bitwise
+      def operator
+        :|
+      end
+    end
+
+    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/case/case_conditional.rb

@@ -29,6 +29,10 @@ module Dentaku
       def dependencies(context = {})
         @when.dependencies(context) + @then.dependencies(context)
       end
+
+      def accept(visitor)
+        visitor.visit_case_conditional(self)
+      end
     end
   end
 end

data/lib/dentaku/ast/case/case_else.rb

@@ -1,6 +1,8 @@
 module Dentaku
   module AST
     class CaseElse < Node
+      attr_reader :node
+
       def initialize(node)
         @node = node
       end
@@ -24,6 +26,10 @@ module Dentaku
       def self.max_param_count
         1
       end
+
+      def accept(visitor)
+        visitor.visit_else(self)
+      end
     end
   end
 end

data/lib/dentaku/ast/case/case_switch_variable.rb

@@ -1,6 +1,8 @@
 module Dentaku
   module AST
     class CaseSwitchVariable < Node
+      attr_reader :node
+
       def initialize(node)
         @node = node
       end
@@ -24,6 +26,10 @@ module Dentaku
       def self.max_param_count
         1
       end
+
+      def accept(visitor)
+        visitor.visit_switch(self)
+      end
     end
   end
 end

data/lib/dentaku/ast/case/case_then.rb

@@ -1,6 +1,8 @@
 module Dentaku
   module AST
     class CaseThen < Node
+      attr_reader :node
+
       def initialize(node)
         @node = node
       end
@@ -24,6 +26,10 @@ module Dentaku
       def self.max_param_count
         1
       end
+
+      def accept(visitor)
+        visitor.visit_then(self)
+      end
     end
   end
 end

data/lib/dentaku/ast/case/case_when.rb

@@ -1,6 +1,8 @@
 module Dentaku
   module AST
     class CaseWhen < Operation
+      attr_reader :node
+
       def initialize(node)
         @node = node
       end
@@ -24,6 +26,14 @@ module Dentaku
       def self.max_param_count
         1
       end
+
+      def accept(visitor)
+        visitor.visit_when(self)
+      end
+
+      def to_s
+        'WHEN'
+      end
     end
   end
 end

data/lib/dentaku/ast/case.rb

@@ -8,6 +8,8 @@ require 'dentaku/exceptions'
 module Dentaku
   module AST
     class Case < Node
+      attr_reader :switch, :conditions, :else
+
       def self.min_param_count
         2
       end
@@ -57,6 +59,10 @@ module Dentaku
         else_dependencies(context)
       end
 
+      def accept(visitor)
+        visitor.visit_case(self)
+      end
+
       private
 
       def switch_dependencies(context = {})

data/lib/dentaku/ast/comparators.rb

@@ -15,74 +15,74 @@ module Dentaku
         raise NotImplementedError
       end
 
+      def value(context = {})
+        l = validate_value(cast(left.value(context)))
+        r = validate_value(cast(right.value(context)))
+
+        l.public_send(operator, r)
+      rescue ::ArgumentError => e
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
+      end
+
       private
 
-      def value
-        yield
-      rescue ::ArgumentError => argument_error
-        raise Dentaku::ArgumentError, argument_error.message
-      rescue NoMethodError => no_method_error
-        raise Dentaku::Error, no_method_error.message
+      def cast(val)
+        return val unless val.is_a?(::String)
+        return val if val.empty?
+        return val unless val.match?(/\A-?\d*(\.\d+)?\z/)
+
+        v = BigDecimal(val, Float::DIG + 1)
+        v = v.to_i if v.frac.zero?
+        v
       end
-    end
 
-    class LessThan < Comparator
-      def value(context = {})
-        super() { left.value(context) < right.value(context) }
+      def validate_value(value)
+        unless value.respond_to?(operator)
+          raise Dentaku::ArgumentError.for(:invalid_operator, operation: self.class, operator: operator),
+                "#{ self.class } requires operands that respond to #{operator}"
+        end
+
+        value
       end
+    end
 
+    class LessThan < Comparator
       def operator
-        return :<
+        :<
       end
     end
 
     class LessThanOrEqual < Comparator
-      def value(context = {})
-        super() { left.value(context) <= right.value(context) }
-      end
-
       def operator
-        return :<=
+        :<=
       end
     end
 
     class GreaterThan < Comparator
-      def value(context = {})
-        super() { left.value(context) > right.value(context) }
-      end
-
       def operator
-        return :>
+        :>
       end
     end
 
     class GreaterThanOrEqual < Comparator
-      def value(context = {})
-        super() { left.value(context) >= right.value(context) }
-      end
-
       def operator
-        return :>=
+        :>=
       end
     end
 
     class NotEqual < Comparator
-      def value(context = {})
-        super() { left.value(context) != right.value(context) }
-      end
-
       def operator
-        return :!=
+        :!=
       end
     end
 
     class Equal < Comparator
-      def value(context = {})
-        super() { left.value(context) == right.value(context) }
+      def operator
+        :==
       end
 
-      def operator
-        return :==
+      def display_operator
+        "="
       end
     end
   end

data/lib/dentaku/ast/function.rb

@@ -4,6 +4,8 @@ require_relative 'function_registry'
 module Dentaku
   module AST
     class Function < Node
+      attr_reader :args
+
       # @return [Integer] with the number of significant decimal digits to use.
       DIG = Float::DIG + 1
 
@@ -11,19 +13,15 @@ module Dentaku
         @args = args
       end
 
+      def accept(visitor)
+        visitor.visit_function(self)
+      end
+
       def dependencies(context = {})
-        deferred = deferred_args
         @args.each_with_index
-             .reject { |_, i| deferred.include? i }
              .flat_map { |a, _| a.dependencies(context) }
       end
 
-      # override if your function implementation needs to defer evaluation of
-      # any arguments
-      def deferred_args
-        []
-      end
-
       def self.get(name)
         registry.get(name)
       end

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

@@ -1,27 +1,14 @@
-require_relative '../function'
-require_relative '../../exceptions'
+require_relative './enum'
 
 module Dentaku
   module AST
-    class All < Function
-      def self.min_param_count
-        3
-      end
-
-      def self.max_param_count
-        3
-      end
-
-      def deferred_args
-        [1, 2]
-      end
-
+    class All < Enum
       def value(context = {})
-        collection      = @args[0].value(context)
+        collection      = Array(@args[0].value(context))
         item_identifier = @args[1].identifier
         expression      = @args[2]
 
-        Array(collection).all? do |item_value|
+        collection.all? do |item_value|
           expression.value(
             context.merge(
               FlatHash.from_hash_with_intermediates(item_identifier => item_value)

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

@@ -1,27 +1,14 @@
-require_relative '../function'
-require_relative '../../exceptions'
+require_relative './enum'
 
 module Dentaku
   module AST
-    class Any < Function
-      def self.min_param_count
-        3
-      end
-
-      def self.max_param_count
-        3
-      end
-
-      def deferred_args
-        [1, 2]
-      end
-
+    class Any < Enum
       def value(context = {})
-        collection      = @args[0].value(context)
+        collection      = Array(@args[0].value(context))
         item_identifier = @args[1].identifier
         expression      = @args[2]
 
-        Array(collection).any? do |item_value|
+        collection.any? do |item_value|
           expression.value(
             context.merge(
               FlatHash.from_hash_with_intermediates(item_identifier => item_value)

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

@@ -4,11 +4,11 @@ module Dentaku
   module AST
     class Duration < Function
       def self.min_param_count
-        1
+        2
       end
 
       def self.max_param_count
-        1
+        2
       end
 
       class Value

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

@@ -0,0 +1,37 @@
+require_relative '../function'
+require_relative '../../exceptions'
+
+module Dentaku
+  module AST
+    class Enum < Function
+      def self.min_param_count
+        3
+      end
+
+      def self.max_param_count
+        3
+      end
+
+      def dependencies(context = {})
+        validate_identifier(@args[1])
+
+        collection      = @args[0]
+        item_identifier = @args[1].identifier
+        expression      = @args[2]
+
+        collection_deps = collection.dependencies(context)
+        expression_deps = (expression&.dependencies(context) || []).reject do |i|
+          i == item_identifier || i.start_with?("#{item_identifier}.")
+        end
+
+        collection_deps + expression_deps
+      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
+      end
+    end
+  end
+end

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

@@ -1,27 +1,14 @@
-require_relative '../function'
-require_relative '../../exceptions'
+require_relative './enum'
 
 module Dentaku
   module AST
-    class Filter < Function
-      def self.min_param_count
-        3
-      end
-
-      def self.max_param_count
-        3
-      end
-
-      def deferred_args
-        [1, 2]
-      end
-
+    class Filter < Enum
       def value(context = {})
-        collection      = @args[0].value(context)
+        collection      = Array(@args[0].value(context))
         item_identifier = @args[1].identifier
         expression      = @args[2]
 
-        Array(collection).select do |item_value|
+        collection.select do |item_value|
           expression.value(
             context.merge(
               FlatHash.from_hash_with_intermediates(item_identifier => item_value)

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

@@ -19,6 +19,10 @@ module Dentaku
         @right     = right
       end
 
+      def args
+        [predicate, left, right]
+      end
+
       def value(context = {})
         predicate.value(context) ? left.value(context) : right.value(context)
       end