dentaku 3.5.5 → 3.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42f22227c2d7aef33e71f5c177f65ca3e7855115466d4d04851e6286bcbe1955
-  data.tar.gz: e779f142e5f458aed8437539bfe98ee73b4bf86a0ddb280cceec586ebcd62190
+  metadata.gz: 6992ab2a13558e752be1db54e612dba4230c8e273ebb4bc11b51d655435ab463
+  data.tar.gz: fe53f64d1015b13ec909382679e3dbc93ec822fb97d8389a3bd83870fe2dacea
 SHA512:
-  metadata.gz: 8c4305e2d7f5c8289edcc5f530dbb0d98cbc95f6db59a8ba98561506f2ec7e41ef89c6ab7271d8754f0a0dfc5ade6325833269f38595593c39eca44c8dcce7c5
-  data.tar.gz: 9a186d4164b031bbe27fb1490184d9c23387849267d4b1067c6bec6a39afdee4e6bf97d8bbbb364f36474fdad0e37e59f4ef63dae1454055244bc06f6791905b
+  metadata.gz: cad7fc2694c626beb952b44c5014bda140ef5e7953de85e333e8482b35ac02ce87f8054e2e752f9f47a0ae2c5af7666224803d28b484c7c2defaa11aa782521f
+  data.tar.gz: 53a267501045fce0f6f4cb26bfb7308e65a9b6cb1a1e8d4386cafffbbb865976b0c320fae2553da30b07193a9126be05068c2b7ba7c5034a341698733cf88305

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Change Log
 
+## [v3.5.7] 2025-12-16
+- fix misclassification of unary minus as subtraction
+- fix parsing empty function call
+
+## [v3.5.6] 2025-10-20
+- fix comparison of Hash with integer
+- refactor case parsing
+- remove input mutation
+- fix bug with arithmetic node validation
+
 ## [v3.5.5] 2025-08-20
 - fix percentages in print visitor
 - repo cleanup
@@ -267,6 +277,7 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[v3.5.6]: https://github.com/rubysolo/dentaku/compare/v3.5.5...v3.5.6
 [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

data/lib/dentaku/ast/arithmetic.rb

@@ -9,6 +9,20 @@ module Dentaku
       DECIMAL = /\A-?\d*\.\d+\z/.freeze
       INTEGER = /\A-?\d+\z/.freeze
 
+      def initialize(*)
+        super
+
+        unless valid_left?
+          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(:incompatible, right.type, :right),
+                "#{self.class} requires operands that are numeric or compatible types, not #{right.type}"
+        end
+      end
+
       def type
         :numeric
       end
@@ -61,7 +75,19 @@ module Dentaku
       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?

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/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)
@@ -82,19 +83,20 @@ module Dentaku
 
       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)
+        process_token(token, lookahead, i)
         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
@@ -113,7 +115,7 @@ module Dentaku
 
     private
 
-    def process_token(token, lookahead, index, tokens)
+    def process_token(token, lookahead, index)
       case token.category
       when :datetime      then output << AST::DateTime.new(token)
       when :numeric       then output << AST::Numeric.new(token)
@@ -127,13 +129,13 @@ module Dentaku
       when :function
         handle_function(token)
       when :case
-        handle_case(token, index, tokens)
+        handle_case(token)
       when :access
         handle_access(token)
       when :array
         handle_array(token)
       when :grouping
-        handle_grouping(token, lookahead, tokens)
+        handle_grouping(token, lookahead, index)
       else
         fail! :not_implemented_token_category, token_category: token.category
       end
@@ -142,13 +144,9 @@ module Dentaku
     def handle_operator(token, lookahead)
       op_class = operation(token).resolve_class(lookahead)
       if op_class.right_associative?
-        while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
-          consume
-        end
+        consume while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
       else
-        while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
-          consume
-        end
+        consume while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
       end
       operations.push op_class
     end
@@ -160,74 +158,40 @@ module Dentaku
       operations.push func
     end
 
-    def handle_case(token, index, tokens)
-      case_index = operations.index { |o| o == AST::Case } || -1
+    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
-        if operations.include?(AST::Case)
-          # nested case extraction (non-recursive outer parser)
-          open_cases = 0
-          case_end_index = nil
-          j = index + 1
-          while j < tokens.length
-            t = tokens[j]
-            if t.category == :case
-              if t.value == :open
-                open_cases += 1
-              elsif t.value == :close
-                if open_cases > 0
-                  open_cases -= 1
-                else
-                  case_end_index = j
-                  break
-                end
-              end
-            end
-            j += 1
-          end
-          inner_case_inputs = tokens.slice!(index + 1, case_end_index - 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
+        # 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
-          while operations.last != AST::Case
-            consume
-          end
+          consume_until(AST::Case)
           operations.push(AST::CaseConditional)
           consume(2)
           arities[-1] += 1
         elsif operations[token_index] == AST::CaseElse
-          while operations.last != AST::Case
-            consume
-          end
+          consume_until(AST::Case)
           arities[-1] += 1
         end
-        fail! :unprocessed_token, token_name: token.value unless operations.count >= 1 && operations.last == AST::Case
+        fail! :unprocessed_token, token_name: token.value unless operations.last == AST::Case
         consume(arities.pop.succ)
 
       when :when
         if operations[token_index] == AST::CaseThen
-          while ![AST::CaseWhen, AST::Case].include?(operations.last)
-            consume
-          end
+          # 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
@@ -235,36 +199,41 @@ module Dentaku
 
       when :then
         if operations[token_index] == AST::CaseWhen
-          while ![AST::CaseThen, AST::Case].include?(operations.last)
-            consume
-          end
+          consume_until([AST::CaseThen, AST::Case])
         end
         operations.push(AST::CaseThen)
 
       when :else
         if operations[token_index] == AST::CaseThen
-          while operations.last != AST::Case
-            consume
-          end
+          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
-        while operations.any? && operations.last != AST::Access
-          consume
-        end
+        consume while operations.any? && operations.last != AST::Access
         fail! :unbalanced_bracket, token: token unless operations.last == AST::Access
         consume
       end
@@ -277,20 +246,19 @@ module Dentaku
         arities.push 0
 
       when :array_end
-        while operations.any? && operations.last != AST::Array
-          consume
-        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)
+    def handle_grouping(token, lookahead, token_index)
       case token.value
       when :open
         if lookahead && lookahead.value == :close
           # empty grouping (e.g. function with zero arguments) — we trigger consume later
-          tokens.delete_at(tokens.index(lookahead)) # remove the close to mimic previous shift behavior
+          # skip to the end
+          @skip_indices << token_index + 1
           arities.pop
           consume(0)
         else
@@ -298,9 +266,7 @@ module Dentaku
         end
 
       when :close
-        while operations.any? && operations.last != AST::Grouping
-          consume
-        end
+        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
@@ -310,9 +276,8 @@ module Dentaku
       when :comma
         fail! :invalid_statement if arities.empty?
         arities[-1] += 1
-        while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
-          consume
-        end
+        consume while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
+
       else
         fail! :unknown_grouping_token, token_name: token.value
       end

data/lib/dentaku/token_scanner.rb

@@ -114,12 +114,14 @@ module Dentaku
 
       def negate
         new(:operator, '-', lambda { |raw| :negate }, lambda { |last_token|
-          last_token.nil?             ||
-          last_token.is?(:operator)   ||
-          last_token.is?(:comparator) ||
-          last_token.is?(:combinator) ||
-          last_token.value == :open   ||
-          last_token.value == :comma
+          last_token.nil?               ||
+          last_token.is?(:operator)     ||
+          last_token.is?(:comparator)   ||
+          last_token.is?(:combinator)   ||
+          last_token.value == :open     ||
+          last_token.value == :comma    ||
+          last_token.value == :lbracket ||
+          last_token.value == :array_start
         })
       end
 

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.5"
+  VERSION = "3.5.7"
 end

data/spec/ast/addition_spec.rb

@@ -22,14 +22,14 @@ describe Dentaku::AST::Addition do
 
   it 'requires operands that respond to +' do
     expect {
-      described_class.new(five, t).value
-    }.to raise_error(Dentaku::ArgumentError, /requires operands that respond to +/)
+      described_class.new(five, t)
+    }.to raise_error(Dentaku::NodeError, /requires operands/)
 
     expression = Dentaku::AST::Multiplication.new(five, five)
     group = Dentaku::AST::Grouping.new(expression)
 
     expect {
-      described_class.new(group, five).value
+      described_class.new(group, five)
     }.not_to raise_error
   end
 

data/spec/ast/division_spec.rb

@@ -22,14 +22,14 @@ describe Dentaku::AST::Division do
 
   it 'requires operands that respond to /' do
     expect {
-      described_class.new(five, t).value
-    }.to raise_error(Dentaku::ArgumentError, /requires operands that respond to \//)
+      described_class.new(five, t)
+    }.to raise_error(Dentaku::NodeError, /requires operands/)
 
     expression = Dentaku::AST::Multiplication.new(five, five)
     group = Dentaku::AST::Grouping.new(expression)
 
     expect {
-      described_class.new(group, five).value
+      described_class.new(group, five)
     }.not_to raise_error
   end
 

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

data/spec/parser_spec.rb

@@ -52,6 +52,11 @@ describe Dentaku::Parser do
     expect(node.value).to eq(2)
   end
 
+  it 'parses multiple zero-argument functions in sequence' do
+    node = parse('count() + count()') # count() without arguments returns 0
+    expect(node.value).to eq(0)
+  end
+
   it 'represents formulas with variables' do
     node = parse('5 * x')
     expect { node.value }.to raise_error(Dentaku::UnboundVariableError)

data/spec/tokenizer_spec.rb

@@ -49,6 +49,20 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:category)).to eq([:grouping, :operator, :numeric, :grouping])
     expect(tokens.map(&:value)).to eq([:open, :negate, 5, :close])
 
+    tokens = tokenizer.tokenize('{-5, -2}[-1]')
+    expect(tokens.map(&:category)).to eq([
+      :array,                                   # {
+      :operator, :numeric, :grouping,           # -5,
+      :operator, :numeric, :array,              # -2}
+      :access, :operator, :numeric, :access     # [-1]
+    ])
+    expect(tokens.map(&:value)).to eq([
+      :array_start,                     # {
+      :negate, 5, :comma,               # -5,
+      :negate, 2, :array_end,           # -2}
+      :lbracket, :negate, 1, :rbracket  # [-1]
+    ])
+
     tokens = tokenizer.tokenize('if(-5 > x, -7, -8) - 9')
     expect(tokens.map(&:category)).to eq([
       :function, :grouping,                                      # if(

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.5
+  version: 3.5.7
 platform: ruby
 authors:
 - Solomon White
 bindir: bin
 cert_chain: []
-date: 2025-08-21 00:00:00.000000000 Z
+date: 2025-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal