dentaku 3.5.4 → 3.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef9e8cb8d852db9a8e4c81c28815c6a7e7008c6e9bebcc8a11222768756fd7a8
-  data.tar.gz: f7d1c005ef1ba8bcfc77fcac8b885378a0e3e36fdba8f97a2c602b6b0ba6f34c
+  metadata.gz: fc1bbfde891d6c98eda08b9176f9ed791744b2043176f07d3aac997fae34a3e9
+  data.tar.gz: b8658f3d74364672f1a4538928e40d7b4d7aff7489273b573dbd1970303a60b3
 SHA512:
-  metadata.gz: 6d616fd597440c13e8432ac6f9d5480592cdcbb7e9aec30c1f2c21e94e0a4bcf3ffced31cf486dc7390bd8668bb5e377745a7eebf467edfab1cd5fa0ae4f70e9
-  data.tar.gz: fca27bf921a54469f065f634a44d4a6481c6420ccbcaa39400ffe4a5cdd172ff6ae209a04aee96208a64979bbff814635719732b557df33f7d406f87123b1c3a
+  metadata.gz: bc53fba03a05ddf47875ffd08aa54266b3f6894a91d292f18236aba4db4c4c270bfeb4f039f84f10d4ac7ce2ca0f6a86580d65c1f5a0169b74bd7c2dfacf9363
+  data.tar.gz: 88a65a6e103b40fbf3ef0dfc89173ced19e3df7f568514f4a12b451f7d4a91c69b1e25af89b5f9f1c9cadf34b71c200fc4a14ea11ef49aeeb2f2d4be6e36da2e

data/.github/workflows/rspec.yml

@@ -0,0 +1,26 @@
+name: rspec
+on:
+  push:
+  pull_request:
+jobs:
+  rspec:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby:
+        - '2.5'
+        - '2.6'
+        - '2.7'
+        - '3.0'
+        - '3.1'
+        - '3.2'
+        - '3.3'
+        - '3.4'
+      fail-fast: false
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: "${{ matrix.ruby }}"
+        bundler-cache: true
+    - run: bundle exec rspec --format documentation

data/.github/workflows/rubocop.yml

@@ -0,0 +1,14 @@
+name: rubocop
+on:
+  push:
+  pull_request:
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3'
+        bundler-cache: true
+    - run: bundle exec rubocop

data/CHANGELOG.md

@@ -1,13 +1,20 @@
 # Change Log
 
-## [v3.5.4]
+## [v3.5.5] 2025-08-20
+- fix percentages in print visitor
+- repo cleanup
+- fix modulo zero
+- fix array arithmetic
+- refactor parser
+
+## [v3.5.4] 2024-08-13
 - add support for default value for PLUCK function
 - improve error handling for MAP/ANY/ALL functions
 - fix modulo / percentage operator determination
 - fix string casing bug with bulk expressions
 - add explicit gem dependency for BigDecimal
 
-## [v3.5.3]
+## [v3.5.3] 2024-07-04
 - add support for empty array literals
 - add support for quoted identifiers
 - add REDUCE function
@@ -16,7 +23,7 @@
 - improve custom class arithmetic
 - fix IF dependency
 
-## [v3.5.2]
+## [v3.5.2] 2023-12-06
 - add ABS function
 - add array support for AST visitors
 - add support for function callbacks
@@ -29,14 +36,14 @@
 - fix handling of Math::DomainError
 - fix invalid cast
 
-## [v3.5.1]
+## [v3.5.1] 2022-10-24
 - 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]
+## [v3.5.0] 2022-03-17
 - fix bug with function argument count
 - add XOR operator
 - make function args publicly accessible
@@ -48,7 +55,7 @@
 - respect case sensitivity in nested case statments
 - add visitor pattern
 
-## [v3.4.2]
+## [v3.4.2] 2021-07-14
 - add FILTER function
 - add concurrent-ruby dependency to make global calculator object thread safe
 - add Ruby 3 support
@@ -260,6 +267,7 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[v3.5.5]: https://github.com/rubysolo/dentaku/compare/v3.5.4...v3.5.5
 [v3.5.4]: https://github.com/rubysolo/dentaku/compare/v3.5.3...v3.5.4
 [v3.5.3]: https://github.com/rubysolo/dentaku/compare/v3.5.2...v3.5.3
 [v3.5.2]: https://github.com/rubysolo/dentaku/compare/v3.5.1...v3.5.2

data/README.md

@@ -3,9 +3,6 @@ Dentaku
 
 [![Join the chat at https://gitter.im/rubysolo/dentaku](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/rubysolo/dentaku?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![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)
-[![Coverage](https://codecov.io/gh/rubysolo/dentaku/branch/master/graph/badge.svg)](https://codecov.io/gh/rubysolo/dentaku)
 
 
 DESCRIPTION
@@ -147,7 +144,7 @@ Logic: `IF`, `AND`, `OR`, `XOR`, `NOT`, `SWITCH`
 
 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))
+Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/main/lib/dentaku/ast/case.rb))
 
 String: `LEFT`, `RIGHT`, `MID`, `LEN`, `FIND`, `SUBSTITUTE`, `CONCAT`, `CONTAINS`
 

data/dentaku.gemspec

@@ -17,7 +17,6 @@ Gem::Specification.new do |s|
   s.add_dependency('bigdecimal')
   s.add_dependency('concurrent-ruby')
 
-  s.add_development_dependency('codecov')
   s.add_development_dependency('pry')
   s.add_development_dependency('pry-byebug')
   s.add_development_dependency('pry-stack_explorer')

data/lib/dentaku/ast/arithmetic.rb

@@ -13,13 +13,13 @@ module Dentaku
         super
 
         unless valid_left?
-          raise NodeError.new(:numeric, left.type, :left),
-                "#{self.class} requires numeric operands"
+          raise NodeError.new(:incompatible, left.type, :left),
+                "#{self.class} requires operands that are numeric or compatible types, not #{left.type}"
         end
 
         unless valid_right?
-          raise NodeError.new(:numeric, right.type, :right),
-                "#{self.class} requires numeric operands"
+          raise NodeError.new(:incompatible, right.type, :right),
+                "#{self.class} requires operands that are numeric or compatible types, not #{right.type}"
         end
       end
 
@@ -69,12 +69,25 @@ module Dentaku
       def datetime?(val)
         # val is a Date, Time, or DateTime
         return true if val.respond_to?(:strftime)
+        return false unless val.is_a?(::String)
 
-        val.to_s =~ Dentaku::TokenScanner::DATE_TIME_REGEXP
+        val =~ Dentaku::TokenScanner::DATE_TIME_REGEXP
       end
 
       def valid_node?(node)
-        node && (node.type == :numeric || node.type == :integer || node.dependencies.any?)
+        return false unless node
+
+        # Allow nodes with dependencies (identifiers that will be resolved later)
+        return true if node.dependencies.any?
+
+        # Allow compatible types
+        return true if [:numeric, :integer, :array].include?(node.type)
+
+        # Allow nodes without a type (operations, groupings)
+        return true if node.type.nil?
+
+        # Reject incompatible types
+        false
       end
 
       def valid_left?
@@ -193,6 +206,13 @@ module Dentaku
       def operator
         :%
       end
+
+      def value(context = {})
+        r = decimal(cast(right.value(context)))
+        raise Dentaku::ZeroDivisionError if r.zero?
+
+        cast(cast(left.value(context)) % r)
+      end
     end
 
     class Percentage < Arithmetic
@@ -201,26 +221,30 @@ module Dentaku
       end
 
       def initialize(child)
-        @right = child
+        @left = child
 
-        unless valid_right?
-          raise NodeError.new(:numeric, right.type, :right),
+        unless valid_left?
+          raise NodeError.new(:numeric, left.type, :left),
                 "#{self.class} requires a numeric operand"
         end
       end
 
       def dependencies(context = {})
-        @right.dependencies(context)
+        @left.dependencies(context)
       end
 
       def value(context = {})
-        cast(right.value(context)) * 0.01
+        cast(left.value(context)) * 0.01
       end
 
       def operator
         :%
       end
 
+      def operator_spacing
+        ""
+      end
+
       def self.precedence
         30
       end

data/lib/dentaku/ast/case.rb

@@ -7,6 +7,18 @@ require 'dentaku/exceptions'
 
 module Dentaku
   module AST
+    # Examples of using in a formula:
+    #
+    #     CASE x WHEN 1 THEN 2 WHEN 3 THEN 4 ELSE END
+    #
+    #     CASE fruit
+    #     WHEN 'apple'
+    #       THEN 1 * quantity
+    #     WHEN 'banana'
+    #       THEN 2 * quantity
+    #     ELSE
+    #       3 * quantity
+    #     END
     class Case < Node
       attr_reader :switch, :conditions, :else
 

data/lib/dentaku/ast/comparators.rb

@@ -20,7 +20,7 @@ module Dentaku
         r = validate_value(cast(right.value(context)))
 
         l.public_send(operator, r)
-      rescue ::ArgumentError => e
+      rescue ::ArgumentError, ::TypeError => e
         raise Dentaku::ArgumentError.for(:incompatible_type, value: r, for: l.class), e.message
       end
 

data/lib/dentaku/ast/operation.rb

@@ -33,7 +33,12 @@ module Dentaku
       def display_operator
         operator.to_s
       end
+
       alias_method :to_s, :display_operator
+
+      def operator_spacing
+        " "
+      end
     end
   end
 end

data/lib/dentaku/ast.rb

@@ -39,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/parser.rb

@@ -37,6 +37,7 @@ module Dentaku
       @arities           = options.fetch(:arities, [])
       @function_registry = options.fetch(:function_registry, nil)
       @case_sensitive    = options.fetch(:case_sensitive, false)
+      @skip_indices      = []
     end
 
     def consume(count = 2)
@@ -53,17 +54,18 @@ module Dentaku
         fail! :too_few_operands, operator: operator, expect: expect, actual: output_size
       end
 
-      if output_size > max_size && operations.empty? || args_size > max_size
+      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
 
+      args = []
       if operator == AST::Array && output.empty?
-        output.push(operator.new())
+        # special case: empty array literal '{}'
+        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)
       end
 
@@ -79,233 +81,21 @@ module Dentaku
     def parse
       return AST::Nil.new if input.empty?
 
-      while token = input.shift
-        case token.category
-        when :datetime
-          output.push AST::DateTime.new(token)
-
-        when :numeric
-          output.push AST::Numeric.new(token)
-
-        when :logical
-          output.push AST::Logical.new(token)
-
-        when :string
-          output.push AST::String.new(token)
-
-        when :identifier
-          output.push AST::Identifier.new(token, case_sensitive: case_sensitive)
-
-        when :operator, :comparator, :combinator
-          op_class = operation(token)
-          op_class = op_class.resolve_class(input.first)
-
-          if op_class.right_associative?
-            while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
-              consume
-            end
-
-            operations.push op_class
-          else
-            while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
-              consume
-            end
-
-            operations.push op_class
-          end
-
-        when :null
-          output.push AST::Nil.new
-
-        when :function
-          func = function(token)
-          if func.nil?
-            fail! :undefined_function, function_name: token.value
-          end
-
-          arities.push 0
-          operations.push func
-
-        when :case
-          case_index = operations.index { |o| o == AST::Case } || -1
-          token_index = case_index + 1
-
-          case token.value
-          when :open
-            # special handling for case nesting: strip out inner case
-            # statements and parse their AST segments recursively
-            if operations.include?(AST::Case)
-              open_cases = 0
-              case_end_index = nil
-
-              input.each_with_index do |input_token, index|
-                if input_token.category == :case
-                  if input_token.value == :open
-                    open_cases += 1
-                  end
-
-                  if input_token.value == :close
-                    if open_cases > 0
-                      open_cases -= 1
-                    else
-                      case_end_index = index
-                      break
-                    end
-                  end
-                end
-              end
-              inner_case_inputs = input.slice!(0..case_end_index)
-              subparser = Parser.new(
-                inner_case_inputs,
-                operations: [AST::Case],
-                arities: [0],
-                function_registry: @function_registry,
-                case_sensitive: case_sensitive
-              )
-              subparser.parse
-              output.concat(subparser.output)
-            else
-              operations.push AST::Case
-              arities.push(0)
-            end
-          when :close
-            if operations[token_index] == AST::CaseThen
-              while operations.last != AST::Case
-                consume
-              end
-
-              operations.push(AST::CaseConditional)
-              consume(2)
-              arities[-1] += 1
-            elsif operations[token_index] == AST::CaseElse
-              while operations.last != AST::Case
-                consume
-              end
-
-              arities[-1] += 1
-            end
-
-            unless operations.count >= 1 && operations.last == AST::Case
-              fail! :unprocessed_token, token_name: token.value
-            end
-            consume(arities.pop.succ)
-          when :when
-            if operations[token_index] == AST::CaseThen
-              while ![AST::CaseWhen, AST::Case].include?(operations.last)
-                consume
-              end
-              operations.push(AST::CaseConditional)
-              consume(2)
-              arities[-1] += 1
-            elsif operations.last == AST::Case
-              operations.push(AST::CaseSwitchVariable)
-              consume
-            end
-
-            operations.push(AST::CaseWhen)
-          when :then
-            if operations[token_index] == AST::CaseWhen
-              while ![AST::CaseThen, AST::Case].include?(operations.last)
-                consume
-              end
-            end
-            operations.push(AST::CaseThen)
-          when :else
-            if operations[token_index] == AST::CaseThen
-              while operations.last != AST::Case
-                consume
-              end
-
-              operations.push(AST::CaseConditional)
-              consume(2)
-              arities[-1] += 1
-            end
-
-            operations.push(AST::CaseElse)
-          else
-            fail! :unknown_case_token, token_name: token.value
-          end
-
-        when :access
-          case token.value
-          when :lbracket
-            operations.push AST::Access
-          when :rbracket
-            while operations.any? && operations.last != AST::Access
-              consume
-            end
-
-            unless operations.last == AST::Access
-              fail! :unbalanced_bracket, token: token
-            end
-            consume
-          end
-
-        when :array
-          case token.value
-          when :array_start
-            operations.push AST::Array
-            arities.push 0
-          when :array_end
-            while operations.any? && operations.last != AST::Array
-              consume
-            end
-
-            unless operations.last == AST::Array
-              fail! :unbalanced_bracket, token: token
-            end
-
-            consume(arities.pop.succ)
-          end
-
-        when :grouping
-          case token.value
-          when :open
-            if input.first && input.first.value == :close
-              input.shift
-              arities.pop
-              consume(0)
-            else
-              operations.push AST::Grouping
-            end
-
-          when :close
-            while operations.any? && operations.last != AST::Grouping
-              consume
-            end
-
-            lparen = operations.pop
-            unless lparen == AST::Grouping
-              fail! :unbalanced_parenthesis, token
-            end
-
-            if operations.last && operations.last < AST::Function
-              consume(arities.pop.succ)
-            end
-
-          when :comma
-            fail! :invalid_statement if arities.empty?
-            arities[-1] += 1
-            while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
-              consume
-            end
-
-          else
-            fail! :unknown_grouping_token, token_name: token.value
-          end
-
-        else
-          fail! :not_implemented_token_category, token_category: token.category
+      i = 0
+      while i < input.length
+        if @skip_indices.include?(i)
+          i += 1
+          next
         end
+        token = input[i]
+        lookahead = input[i + 1]
+        process_token(token, lookahead, i, input)
+        i += 1
       end
 
-      while operations.any?
-        consume
-      end
+      consume while operations.any?
 
-      unless output.count == 1
-        fail! :invalid_statement
-      end
+      fail! :invalid_statement unless output.count == 1
 
       output.first
     end
@@ -324,6 +114,175 @@ module Dentaku
 
     private
 
+    def process_token(token, lookahead, index, tokens)
+      case token.category
+      when :datetime      then output << AST::DateTime.new(token)
+      when :numeric       then output << AST::Numeric.new(token)
+      when :logical       then output << AST::Logical.new(token)
+      when :string        then output << AST::String.new(token)
+      when :identifier    then output << AST::Identifier.new(token, case_sensitive: case_sensitive)
+      when :operator, :comparator, :combinator
+        handle_operator(token, lookahead)
+      when :null
+        output << AST::Nil.new
+      when :function
+        handle_function(token)
+      when :case
+        handle_case(token)
+      when :access
+        handle_access(token)
+      when :array
+        handle_array(token)
+      when :grouping
+        handle_grouping(token, lookahead, tokens)
+      else
+        fail! :not_implemented_token_category, token_category: token.category
+      end
+    end
+
+    def handle_operator(token, lookahead)
+      op_class = operation(token).resolve_class(lookahead)
+      if op_class.right_associative?
+        consume while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
+      else
+        consume while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
+      end
+      operations.push op_class
+    end
+
+    def handle_function(token)
+      func = function(token)
+      fail! :undefined_function, function_name: token.value if func.nil?
+      arities.push 0
+      operations.push func
+    end
+
+    def handle_case(token)
+      # We always operate on the innermost (most recent) CASE on the stack.
+      case_index = operations.rindex(AST::Case) || -1
+      token_index = case_index + 1
+
+      case token.value
+      when :open
+        # Start a new CASE context.
+        operations.push AST::Case
+        arities.push(0)
+
+      when :close
+        # Finalize any trailing THEN/ELSE expression still on the stack.
+        if operations[token_index] == AST::CaseThen
+          consume_until(AST::Case)
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        elsif operations[token_index] == AST::CaseElse
+          consume_until(AST::Case)
+          arities[-1] += 1
+        end
+        fail! :unprocessed_token, token_name: token.value unless operations.last == AST::Case
+        consume(arities.pop.succ)
+
+      when :when
+        if operations[token_index] == AST::CaseThen
+          # Close out previous WHEN/THEN pair.
+          consume_until([AST::CaseWhen, AST::Case])
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        elsif operations.last == AST::Case
+          # First WHEN: finalize switch variable expression.
+          operations.push(AST::CaseSwitchVariable)
+          consume
+        end
+        operations.push(AST::CaseWhen)
+
+      when :then
+        if operations[token_index] == AST::CaseWhen
+          consume_until([AST::CaseThen, AST::Case])
+        end
+        operations.push(AST::CaseThen)
+
+      when :else
+        if operations[token_index] == AST::CaseThen
+          consume_until(AST::Case)
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        end
+        operations.push(AST::CaseElse)
+
+      else
+        fail! :unknown_case_token, token_name: token.value
+      end
+    end
+
+    def consume_until(target)
+      matcher =
+        case target
+        when Array then ->(op) { target.include?(op) }
+        else ->(op) { op == target }
+        end
+
+      consume while operations.any? && !matcher.call(operations.last)
+    end
+
+    def handle_access(token)
+      case token.value
+      when :lbracket
+        operations.push AST::Access
+
+      when :rbracket
+        consume while operations.any? && operations.last != AST::Access
+        fail! :unbalanced_bracket, token: token unless operations.last == AST::Access
+        consume
+      end
+    end
+
+    def handle_array(token)
+      case token.value
+      when :array_start
+        operations.push AST::Array
+        arities.push 0
+
+      when :array_end
+        consume while operations.any? && operations.last != AST::Array
+        fail! :unbalanced_bracket, token: token unless operations.last == AST::Array
+        consume(arities.pop.succ)
+      end
+    end
+
+    def handle_grouping(token, lookahead, tokens)
+      case token.value
+      when :open
+        if lookahead && lookahead.value == :close
+          # empty grouping (e.g. function with zero arguments) — we trigger consume later
+          # skip to the end
+          lookahead_index = tokens.index(lookahead)
+          @skip_indices << lookahead_index if lookahead_index
+          arities.pop
+          consume(0)
+        else
+          operations.push AST::Grouping
+        end
+
+      when :close
+        consume while operations.any? && operations.last != AST::Grouping
+        lparen = operations.pop
+        fail! :unbalanced_parenthesis, token unless lparen == AST::Grouping
+        if operations.last && operations.last < AST::Function
+          consume(arities.pop.succ)
+        end
+
+      when :comma
+        fail! :invalid_statement if arities.empty?
+        arities[-1] += 1
+        consume while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
+
+      else
+        fail! :unknown_grouping_token, token_name: token.value
+      end
+    end
+
     def fail!(reason, **meta)
       message =
         case reason

data/lib/dentaku/print_visitor.rb

@@ -7,13 +7,13 @@ module Dentaku
 
     def visit_operation(node)
       if node.left
-        visit_operand(node.left, node.class.precedence, suffix: " ", dir: :left)
+        visit_operand(node.left, node.class.precedence, suffix: node.operator_spacing, dir: :left)
       end
 
       @output << node.display_operator
 
       if node.right
-        visit_operand(node.right, node.class.precedence, prefix: " ", dir: :right)
+        visit_operand(node.right, node.class.precedence, prefix: node.operator_spacing, dir: :right)
       end
     end
 

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.4"
+  VERSION = "3.5.6"
 end

data/lib/dentaku/visitor/infix.rb

@@ -83,4 +83,4 @@ module Dentaku
       end
     end
   end
-end
+end

data/spec/ast/addition_spec.rb

@@ -20,10 +20,10 @@ describe Dentaku::AST::Addition do
     expect(node.value).to eq(11)
   end
 
-  it 'requires numeric operands' do
+  it 'requires operands that respond to +' do
     expect {
       described_class.new(five, t)
-    }.to raise_error(Dentaku::NodeError, /requires numeric operands/)
+    }.to raise_error(Dentaku::NodeError, /requires operands/)
 
     expression = Dentaku::AST::Multiplication.new(five, five)
     group = Dentaku::AST::Grouping.new(expression)
@@ -35,7 +35,6 @@ describe Dentaku::AST::Addition do
 
   it 'allows operands that respond to addition' do
     # Sample struct that has a custom definition for addition
-
     Addable = Struct.new(:value) do
       def +(other)
         case other
@@ -51,12 +50,18 @@ describe Dentaku::AST::Addition do
     operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Addable.new(6))
 
     expect {
-      described_class.new(operand_five, operand_six)
+      described_class.new(operand_five, operand_six).value
     }.not_to raise_error
 
     expect {
-      described_class.new(operand_five, six)
+      described_class.new(operand_five, six).value
     }.not_to raise_error
+  end
+
+  it 'does not try to parse nested string as date' do
+    a = ['2017-01-01', '2017-01-02']
+    b = ['2017-01-01']
 
+    expect(Dentaku('a + b', a: a, b: b)).to eq(['2017-01-01', '2017-01-02', '2017-01-01'])
   end
 end

data/spec/ast/arithmetic_spec.rb

@@ -111,6 +111,13 @@ describe Dentaku::AST::Arithmetic do
     end
   end
 
+  it 'does not try to parse nested string as date' do
+    a = ['2017-01-01', '2017-01-02']
+    b = ['2017-01-01']
+
+    expect(Dentaku('a - b', a: a, b: b)).to eq(['2017-01-02'])
+  end
+
   it 'raises ArgumentError if given individually valid but incompatible arguments' do
     expect { add(one, date) }.to raise_error(Dentaku::ArgumentError)
     expect { add(x, one, 'x' => [1]) }.to raise_error(Dentaku::ArgumentError)

data/spec/ast/division_spec.rb

@@ -20,10 +20,10 @@ describe Dentaku::AST::Division do
     expect(node.value.round(4)).to eq(0.8333)
   end
 
-  it 'requires numeric operands' do
+  it 'requires operands that respond to /' do
     expect {
       described_class.new(five, t)
-    }.to raise_error(Dentaku::NodeError, /requires numeric operands/)
+    }.to raise_error(Dentaku::NodeError, /requires operands/)
 
     expression = Dentaku::AST::Multiplication.new(five, five)
     group = Dentaku::AST::Grouping.new(expression)
@@ -44,17 +44,21 @@ describe Dentaku::AST::Division do
           value + other
         end
       end
+
+      def zero?
+        value.zero?
+      end
     end
 
     operand_five = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Divisible.new(5))
     operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Divisible.new(6))
 
     expect {
-      described_class.new(operand_five, operand_six)
+      described_class.new(operand_five, operand_six).value
     }.not_to raise_error
 
     expect {
-      described_class.new(operand_five, six)
+      described_class.new(operand_five, six).value
     }.not_to raise_error
   end
 end

data/spec/bulk_expression_solver_spec.rb

@@ -33,13 +33,20 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       }.to raise_error(Dentaku::UnboundVariableError)
     end
 
-    it "lets you know if the result is a div/0 error" do
+    it "lets you know if the result is a div/0 error when dividing" do
       expressions = {more_apples: "1/0"}
       expect {
         described_class.new(expressions, calculator).solve!
       }.to raise_error(Dentaku::ZeroDivisionError)
     end
 
+    it "lets you know if the result is a div/0 error when taking modulo" do
+      expressions = {more_apples: "1%0"}
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::ZeroDivisionError)
+    end
+
     it "does not require keys to be parseable" do
       expressions = { "the value of x, incremented" => "x + 1" }
       solver = described_class.new(expressions, calculator.store("x" => 3))

data/spec/calculator_spec.rb

@@ -130,6 +130,7 @@ describe Dentaku::Calculator do
       expect { calculator.evaluate!('"foo" & "bar"') }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('1.0 & "bar"') }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('1 & "bar"') }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('data < 1', data: { a: 5 }) }.to raise_error(Dentaku::ArgumentError)
     end
 
     it 'raises argument error if a function is called with incorrect arity' do
@@ -235,6 +236,12 @@ describe Dentaku::Calculator do
       expect(calculator.dependencies('MAP(vals, val, val + step)')).to eq(['vals', 'step'])
       expect(calculator.dependencies('ALL(people, person, person.age < adult)')).to eq(['people', 'adult'])
     end
+
+    it "raises an error when trying to find dependencies with invalid syntax" do
+      expect { calculator.dependencies('bob + / 3') }.to raise_error(Dentaku::ParseError)
+      expect { calculator.dependencies('123 * TRUE') }.to raise_error(Dentaku::ParseError)
+      expect { calculator.dependencies('4 + "asdf"') }.to raise_error(Dentaku::ParseError)
+    end
   end
 
   describe 'solve!' do
@@ -531,7 +538,7 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('value + duration(1, month)', { value: value })).to eq(Time.local(2023, 8, 13, 10, 42, 11))
       expect(calculator.evaluate!('value - duration(1, day)', { value: value })).to eq(Time.local(2023, 7, 12, 10, 42, 11))
       expect(calculator.evaluate!('value - duration(1, year)', { value: value })).to eq(Time.local(2022, 7, 13, 10, 42, 11))
-      expect(calculator.evaluate!('value2 - value', { value: value, value2: value2 })).to eq(12_182_399.0)
+      expect(calculator.evaluate!('value2 - value', { value: value, value2: value2 })).to eq(value2 - value)
       expect(calculator.evaluate!('value - 7200', { value: value })).to eq(Time.local(2023, 7, 13, 8, 42, 11))
     end
   end

data/spec/external_function_spec.rb

@@ -166,7 +166,7 @@ describe Dentaku::Calculator 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() }],
+          [: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)

data/spec/parser_spec.rb

@@ -27,6 +27,9 @@ describe Dentaku::Parser do
   it 'calculates bitwise OR' do
     node = parse('2|3')
     expect(node.value).to eq(3)
+
+    node = parse('(5 | 2) + 1')
+    expect(node.value).to eq(8)
   end
 
   it 'performs multiple operations in one stream' do
@@ -77,11 +80,17 @@ describe Dentaku::Parser do
   end
 
   it 'evaluates arrays' do
+    node = parse('{}')
+    expect(node.value).to eq([])
+
     node = parse('{1, 2, 3}')
     expect(node.value).to eq([1, 2, 3])
 
-    node = parse('{}')
-    expect(node.value).to eq([])
+    node = parse('{1, 2, 3} + {4,5,6}')
+    expect(node.value).to eq([1, 2, 3, 4, 5, 6])
+
+    node = parse('{1, 2, 3} - {2,3}')
+    expect(node.value).to eq([1])
   end
 
   context 'invalid expression' do

data/spec/print_visitor_spec.rb

@@ -59,6 +59,11 @@ describe Dentaku::PrintVisitor do
     expect(repr).to eq('2017-12-24 23:59:59')
   end
 
+  it 'handles a percentage in a formula' do
+    repr = roundtrip('((3*4%) * 0.001)')
+    expect(repr).to eq('3 * 4% * 0.001')
+  end
+
   private
 
   def roundtrip(string)

data/spec/spec_helper.rb

@@ -1,14 +1,12 @@
 require 'pry'
 require 'simplecov'
-require 'codecov'
 
 SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
   SimpleCov::Formatter::HTMLFormatter,
-  SimpleCov::Formatter::Codecov,
 ])
 
 SimpleCov.minimum_coverage 90
-SimpleCov.minimum_coverage_by_file 80
+# SimpleCov.minimum_coverage_by_file 80
 
 SimpleCov.start do
   add_filter "spec/"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.4
+  version: 3.5.6
 platform: ruby
 authors:
 - Solomon White
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-14 00:00:00.000000000 Z
+date: 2025-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -38,20 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: codecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -157,6 +142,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rspec.yml"
+- ".github/workflows/rubocop.yml"
 - ".gitignore"
 - ".pryrc"
 - ".rubocop.yml"
@@ -289,7 +276,6 @@ homepage: http://github.com/rubysolo/dentaku
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -304,8 +290,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.9
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A formula language parser and evaluator
 test_files: