dentaku 3.5.5 → 3.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42f22227c2d7aef33e71f5c177f65ca3e7855115466d4d04851e6286bcbe1955
-  data.tar.gz: e779f142e5f458aed8437539bfe98ee73b4bf86a0ddb280cceec586ebcd62190
+  metadata.gz: fc1bbfde891d6c98eda08b9176f9ed791744b2043176f07d3aac997fae34a3e9
+  data.tar.gz: b8658f3d74364672f1a4538928e40d7b4d7aff7489273b573dbd1970303a60b3
 SHA512:
-  metadata.gz: 8c4305e2d7f5c8289edcc5f530dbb0d98cbc95f6db59a8ba98561506f2ec7e41ef89c6ab7271d8754f0a0dfc5ade6325833269f38595593c39eca44c8dcce7c5
-  data.tar.gz: 9a186d4164b031bbe27fb1490184d9c23387849267d4b1067c6bec6a39afdee4e6bf97d8bbbb364f36474fdad0e37e59f4ef63dae1454055244bc06f6791905b
+  metadata.gz: bc53fba03a05ddf47875ffd08aa54266b3f6894a91d292f18236aba4db4c4c270bfeb4f039f84f10d4ac7ce2ca0f6a86580d65c1f5a0169b74bd7c2dfacf9363
+  data.tar.gz: 88a65a6e103b40fbf3ef0dfc89173ced19e3df7f568514f4a12b451f7d4a91c69b1e25af89b5f9f1c9cadf34b71c200fc4a14ea11ef49aeeb2f2d4be6e36da2e

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,19 @@ 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)
         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
@@ -127,7 +128,7 @@ module Dentaku
       when :function
         handle_function(token)
       when :case
-        handle_case(token, index, tokens)
+        handle_case(token)
       when :access
         handle_access(token)
       when :array
@@ -142,13 +143,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 +157,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 +198,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,9 +245,7 @@ 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
@@ -290,7 +256,9 @@ module Dentaku
       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
+          lookahead_index = tokens.index(lookahead)
+          @skip_indices << lookahead_index if lookahead_index
           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/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.5"
+  VERSION = "3.5.6"
 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

metadata

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