janeway-jsonpath 1.0.0 → 1.1.0

data/lib/janeway/interpreters/iteration_helper.rb

@@ -6,21 +6,28 @@ module Janeway
   module Interpreters
     # Mixin for interpreter classes that yield to a block
     module IterationHelper
+      # Sentinel block used by Interpreter#make_deleter to turn a DeleteIf
+      # into an unconditional deleter. `equal?`-comparable so future fast
+      # paths (bulk clear) can detect it.
+      PASS_ALL = proc { true }.freeze
       # Returns a Proc that yields the correct number of parameters to a block
       #
       # block.arity is -1 when no block is given, and an enumerator is being returned
       # @return [Proc] which takes 3 parameters
       def make_yield_proc(&block)
+        # Bind the block locally so the returned proc captures a local, not the
+        # containing instance's @block ivar (avoids an ivar read per yield).
+        b = block
         if block.arity.negative?
           # Yield just the value to an enumerator, to enable instance method calls on
           # matched values like this: enum.delete_if(&:even?)
-          proc { |value, _parent, _path| @block.call(value) }
+          proc { |value, _parent, _path| b.call(value) }
         elsif block.arity > 3
           # Only do the work of constructing the normalized path when it is actually used
-          proc { |value, parent, path| @block.call(value, parent, path.last, normalized_path(path)) }
+          proc { |value, parent, path| b.call(value, parent, path.last, normalized_path(path)) }
         else
           # block arity is 1, 2 or 3. Send all 3 parameters regardless.
-          proc { |value, parent, path| @block.call(value, parent, path.last) }
+          proc { |value, parent, path| b.call(value, parent, path.last) }
         end
       end
 
@@ -37,8 +44,15 @@ module Janeway
       def normalized_path(components)
         # First component is the root identifer, the remaining components are
         # all index selectors or name selectors.
-        # Handle the root identifier separately, because .normalize does not handle those.
-        '$' + components[1..].map { NormalizedPath.normalize(_1) }.join
+        # Build the result string in a single pass — avoids `components[1..]`
+        # (slice allocation) plus `.map { ... }.join` (intermediate Array).
+        result = +'$'
+        i = 1
+        while i < components.size
+          result << NormalizedPath.normalize(components[i])
+          i += 1
+        end
+        result
       end
     end
   end

data/lib/janeway/interpreters/root_node_delete_if.rb

@@ -1,33 +1,74 @@
 # frozen_string_literal: true
 
 require_relative 'root_node_interpreter'
+require_relative 'iteration_helper'
 
 module Janeway
   module Interpreters
-    # Interprets the root node for deletion
-    class RootNodeDeleter < RootNodeInterpreter
-      # Delete all values from the root node.
-      #
-      # TODO: unclear, for deletion is there a difference between queries '$' and '$.*'?
+    # Delete values from the root node for which the block returns a truthy value.
+    class RootNodeDeleteIf < RootNodeInterpreter
+      include IterationHelper
+
+      # @param node [AST::RootNode]
+      def initialize(node, &block)
+        super(node)
+        @block = block
+
+        # Make a proc that yields the correct number of values to a block
+        @yield_proc = make_yield_proc(&block)
+      end
+
+      # Delete values from the root container for which the block returns truthy.
       #
       # @param _input [Array, Hash] the results of processing so far
       # @param _parent [Array, Hash] parent of the input object
       # @param root [Array, Hash] the entire input
       # @param _path [Array<String>] elements of normalized path to the current input
       # @return [Array] deleted elements
-      def interpret(_input, _parent, root, _path)
+      def interpret(_input, _parent, root, _path = nil)
         case root
-        when Array
-          results = root.dup
-          root.clear
-          results
-        when Hash
-          results = root.values
-          root.clear
-          results
-        else
-          []
+        when Array then maybe_delete_array_values(root)
+        when Hash then maybe_delete_hash_values(root)
+        else []
+        end
+      end
+
+      private
+
+      # @param input [Array]
+      def maybe_delete_array_values(input)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.dup
+          input.clear
+          return results
+        end
+
+        results = []
+        (input.size - 1).downto(0).each do |i|
+          next unless @yield_proc.call(input[i], input, ['$', i])
+
+          results << input.delete_at(i)
+        end
+        results.reverse
+      end
+
+      # @param input [Hash]
+      def maybe_delete_hash_values(input)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.values
+          input.clear
+          return results
+        end
+
+        results = []
+        input.each do |key, value|
+          next unless @yield_proc.call(value, input, ['$', key])
+
+          results << input.delete(key)
         end
+        results
       end
     end
   end

data/lib/janeway/interpreters/tree_constructor.rb

@@ -44,26 +44,6 @@ module Janeway
         end
       end
 
-      # Return a Deleter interpreter for the given AST node.
-      # This interpreter deletes matched values.
-      #
-      # @param expr [AST::Expression]
-      # @return [Interprteters::Base]
-      def self.ast_node_to_deleter(expr)
-        case expr
-        when AST::IndexSelector then IndexSelectorDeleter.new(expr)
-        when AST::ArraySliceSelector then ArraySliceSelectorDeleter.new(expr)
-        when AST::NameSelector then NameSelectorDeleter.new(expr)
-        when AST::FilterSelector then FilterSelectorDeleter.new(expr)
-        when AST::WildcardSelector then WildcardSelectorDeleter.new(expr)
-        when AST::ChildSegment then ChildSegmentDeleter.new(expr)
-        when AST::RootNode then RootNodeDeleter.new(expr)
-        when nil then nil # caller has no @next node
-        else
-          raise "Unknown AST expression: #{expr.inspect}"
-        end
-      end
-
       # Return a DeleteIf interpreter for the given AST node.
       # This interpreter deletes matched values, but only after
       # yielding to a block that returns a truthy value.

data/lib/janeway/interpreters/wildcard_selector_delete_if.rb

@@ -36,6 +36,15 @@ module Janeway
       # @param input [Array]
       # @param path [Array]
       def maybe_delete_array_values(input, path)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        # Bulk clear is O(n) with much smaller constants than reverse-iterate
+        # + delete_at + per-element proc call.
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.dup
+          input.clear
+          return results
+        end
+
         results = []
         (input.size - 1).downto(0).each do |i|
           next unless @yield_proc.yield(input[i], input, path + [i])
@@ -48,6 +57,13 @@ module Janeway
       # @param input [Hash]
       # @param path [Array]
       def maybe_delete_hash_values(input, path)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.values
+          input.clear
+          return results
+        end
+
         results = []
         input.each do |key, value|
           next unless @yield_proc.yield(value, input, path + [key])

data/lib/janeway/interpreters/yielder.rb

@@ -19,6 +19,12 @@ module Janeway
         @yield_proc = make_yield_proc(&block)
       end
 
+      # Frozen empty array — Yielder is only used by Enumerator#each and
+      # #find_paths, both of which discard the traversal's return value
+      # (results are surfaced via yield instead). Returning a shared frozen
+      # array avoids allocating a wrapper array per leaf.
+      EMPTY_RESULT = [].freeze
+
       # Yield each input value
       #
       # @param input [Array, Hash] the results of processing so far
@@ -26,10 +32,10 @@ module Janeway
       # @param _root [Array, Hash] the entire input
       # @param path [Array<String, Integer>] components of normalized path to the current input
       # @yieldparam [Object] matched value
-      # @return [Object] input as node list
+      # @return [Array] frozen empty array — see EMPTY_RESULT
       def interpret(input, parent, _root, path)
         @yield_proc.call(input, parent, path)
-        input.is_a?(Array) ? input : [input]
+        EMPTY_RESULT
       end
 
       # Dummy method from Interpreters::Base, allow child segment interpreter to disable the

data/lib/janeway/lexer.rb

@@ -38,9 +38,23 @@ module Janeway
     TWO_CHAR_LEX_FIRST = TWO_CHAR_LEX.map { |lexeme| lexeme[0] }.freeze
     ONE_OR_TWO_CHAR_LEX = ONE_CHAR_LEX & TWO_CHAR_LEX.map { |str| str[0] }.freeze
 
+    # O(1)-lookup companions to the arrays above. Hash#include? and the reverse
+    # lookup avoid the linear scan that .include? / .key would do per token.
+    LEXEME_TO_TYPE = OPERATORS.invert.freeze
+    ONE_CHAR_LEX_SET = ONE_CHAR_LEX.each_with_object({}) { |c, h| h[c] = true }.freeze
+    TWO_CHAR_LEX_SET = TWO_CHAR_LEX.each_with_object({}) { |c, h| h[c] = true }.freeze
+    TWO_CHAR_LEX_FIRST_SET = TWO_CHAR_LEX_FIRST.each_with_object({}) { |c, h| h[c] = true }.freeze
+    ONE_OR_TWO_CHAR_LEX_SET = ONE_OR_TWO_CHAR_LEX.each_with_object({}) { |c, h| h[c] = true }.freeze
+
     WHITESPACE = " \t\n\r"
     KEYWORD = %w[true false null].freeze
+    KEYWORD_SET = KEYWORD.each_with_object({}) { |k, h| h[k] = true }.freeze
     FUNCTIONS = %w[length count match search value].freeze
+    FUNCTIONS_SET = FUNCTIONS.each_with_object({}) { |k, h| h[k] = true }.freeze
+
+    # Hoisted from lex_delimited_string. Given a delimiter, the value is the "other" delimiter.
+    OTHER_DELIMITER = { "'" => '"', '"' => "'" }.freeze
+    QUOTE_LEX_SET = { "'" => true, '"' => true }.freeze
 
     # faster to check membership in a string than an array of char (benchmarked ruby 3.1.2)
     ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -89,18 +103,18 @@ module Janeway
       return if WHITESPACE.include?(c)
 
       token =
-        if ONE_OR_TWO_CHAR_LEX.include?(c)
+        if ONE_OR_TWO_CHAR_LEX_SET.include?(c)
           token_from_one_or_two_char_lex(c)
-        elsif ONE_CHAR_LEX.include?(c)
+        elsif ONE_CHAR_LEX_SET.include?(c)
           token_from_one_char_lex(c)
-        elsif TWO_CHAR_LEX_FIRST.include?(c)
+        elsif TWO_CHAR_LEX_FIRST_SET.include?(c)
           token_from_two_char_lex(c)
-        elsif %w[" '].include?(c)
+        elsif QUOTE_LEX_SET.include?(c)
           lex_delimited_string(c)
         elsif digit?(c)
           lex_number
         elsif name_first_char?(c)
-          lex_member_name_shorthand(ignore_keywords: tokens.last&.type == :dot)
+          lex_member_name_shorthand(ignore_keywords: previous_token_type == :dot)
         end
       raise err("Unknown character: #{c.inspect}") unless token
 
@@ -127,20 +141,20 @@ module Janeway
         raise err("Operator #{lexeme.inspect} must not be followed by whitespace")
       end
 
-      Token.new(OPERATORS.key(lexeme), lexeme, nil, current_location)
+      Token.new(LEXEME_TO_TYPE[lexeme], lexeme, nil, current_location)
     end
 
     # Consumes an operator that could be either 1 or 2 chars in length
     # @return [Token]
     def token_from_one_or_two_char_lex(lexeme)
-      next_two_chars = [lexeme, lookahead].join
-      if TWO_CHAR_LEX.include?(next_two_chars)
+      next_two_chars = lexeme + lookahead
+      if TWO_CHAR_LEX_SET.include?(next_two_chars)
         consume
         if next_two_chars == '..' && WHITESPACE.include?(lookahead)
           raise err("Operator #{next_two_chars.inspect} must not be followed by whitespace")
         end
 
-        Token.new(OPERATORS.key(next_two_chars), next_two_chars, nil, current_location)
+        Token.new(LEXEME_TO_TYPE[next_two_chars], next_two_chars, nil, current_location)
       else
         token_from_one_char_lex(lexeme)
       end
@@ -149,11 +163,11 @@ module Janeway
     # Consumes a 2 char operator
     # @return [Token]
     def token_from_two_char_lex(lexeme)
-      next_two_chars = [lexeme, lookahead].join
-      raise err("Unknown operator \"#{lexeme}\"") unless TWO_CHAR_LEX.include?(next_two_chars)
+      next_two_chars = lexeme + lookahead
+      raise err("Unknown operator \"#{lexeme}\"") unless TWO_CHAR_LEX_SET.include?(next_two_chars)
 
       consume
-      Token.new(OPERATORS.key(next_two_chars), next_two_chars, nil, current_location)
+      Token.new(LEXEME_TO_TYPE[next_two_chars], next_two_chars, nil, current_location)
     end
 
     def consume
@@ -166,12 +180,24 @@ module Janeway
       consume while digit?(lookahead)
     end
 
+    # @return [String] source substring for the lexeme currently being built
+    def current_lexeme
+      source[lexeme_start_p..(next_p - 1)]
+    end
+
+    # Type of the most-recently-emitted token, or nil if none.
+    # Named lookback for the two context-sensitive lexing decisions
+    # (identifier-in-brackets rejection; keyword ignore after `.`).
+    # @return [Symbol, nil]
+    def previous_token_type
+      @tokens.last&.type
+    end
+
     # @param delimiter [String] eg. ' or "
     # @return [Token] string token
     def lex_delimited_string(delimiter)
-      allowed_delimiters = %w[' "]
       # the "other" delimiter char, which is not currently being treated as a delimiter
-      non_delimiter = allowed_delimiters.reject { |char| char == delimiter }.first
+      non_delimiter = OTHER_DELIMITER[delimiter]
 
       literal_chars = []
       while lookahead != delimiter && source_uncompleted?
@@ -190,7 +216,7 @@ module Janeway
             end
           elsif unescaped?(next_char)
             consume
-          elsif allowed_delimiters.include?(next_char) && next_char != delimiter
+          elsif QUOTE_LEX_SET.include?(next_char) && next_char != delimiter
             consume
           else
             raise err("invalid character #{next_char.inspect}")
@@ -204,7 +230,7 @@ module Janeway
       literal = literal_chars.join
 
       # lexeme value includes delimiters and literal escape characters
-      lexeme = source[lexeme_start_p..(next_p - 1)]
+      lexeme = current_lexeme
 
       Token.new(:string, lexeme, literal, current_location)
     end
@@ -285,10 +311,11 @@ module Janeway
     # @param low_surrogate_hex [String] string of hex digits, eg. "DE09"
     # @return [String] UTF-8 string containing a single multi-byte unicode character, eg. "😉"
     def convert_surrogate_pair_to_codepoint(high_surrogate_hex, low_surrogate_hex)
-      [high_surrogate_hex, low_surrogate_hex].each do |hex_str|
-        raise ArgumentError, "expect 4 hex digits, got #{hex_string.inspect}" unless hex_str.size == 4
-      end
-
+      # Callers guarantee 4-char inputs (consume_four_hex_digits followed by
+      # high_surrogate?/low_surrogate? which pre-check size). The old defensive
+      # guard here referenced a non-existent `hex_string` local — dead code
+      # that would NameError if ever reached.
+      #
       # Calculate the code point from the surrogate pair values
       # algorithm from https://russellcottrell.com/greek/utilities/SurrogatePairCalculator.htm
       high = high_surrogate_hex.hex
@@ -317,20 +344,19 @@ module Janeway
     #
     # @return [String]
     def consume_four_hex_digits
-      hex_digits = []
+      hex_digits = String.new(capacity: 4)
       4.times do
-        hex_digits << consume
-        case hex_digits.last.ord
-        when 0x30..0x39 then next # '0'..'1'
-        when 0x40..0x46 then next # 'A'..'F'
+        c = consume
+        hex_digits << c
+        case c.ord
+        when 0x30..0x39 then next # '0'..'9'
+        when 0x41..0x46 then next # 'A'..'F'
         when 0x61..0x66 then next # 'a'..'f'
         else
-          raise err("Invalid unicode escape sequence: \\u#{hex_digits.join}")
+          raise err("Invalid unicode escape sequence: \\u#{hex_digits}")
         end
       end
-      raise err("Incomplete unicode escape sequence: \\u#{hex_digits.join}") if hex_digits.size < 4
-
-      hex_digits.join
+      hex_digits
     end
 
     # Consume a numeric string. May be an integer, fractional, or exponent.
@@ -353,13 +379,13 @@ module Janeway
           consume # "+" / "-"
         end
         unless digit?(lookahead)
-          lexeme = source[lexeme_start_p..(next_p - 1)]
+          lexeme = current_lexeme
           raise err("Exponent 'e' must be followed by number: #{lexeme.inspect}")
         end
         consume_digits
       end
 
-      lexeme = source[lexeme_start_p..(next_p - 1)]
+      lexeme = current_lexeme
       if lexeme.start_with?('0') && lexeme.size > 1
         raise err("Number may not start with leading zero: #{lexeme.inspect}")
       end
@@ -375,36 +401,6 @@ module Janeway
 
     # Consume an alphanumeric string.
     # If `ignore_keywords`, the result is always an :identifier token.
-    # Otherwise, keywords and function names will be recognized and tokenized as those types.
-    #
-    # @param ignore_keywords [Boolean]
-    def lex_identifier(ignore_keywords: false)
-      consume while alpha_numeric?(lookahead)
-
-      identifier = source[lexeme_start_p..(next_p - 1)]
-      type =
-        if KEYWORD.include?(identifier) && !ignore_keywords
-          identifier.to_sym
-        elsif FUNCTIONS.include?(identifier) && !ignore_keywords
-          :function
-        else
-          :identifier
-        end
-
-      Token.new(type, identifier, identifier, current_location)
-    end
-
-    # Parse an identifier string which is not within delimiters.
-    # The standard set of unicode code points are allowed.
-    # No character escapes are allowed.
-    # Keywords and function names are ignored in this context.
-    # @return [Token]
-    def lex_unescaped_identifier
-      consume while unescaped?(lookahead)
-      identifier = source[lexeme_start_p..(next_p - 1)]
-      Token.new(:identifier, identifier, identifier, current_location)
-    end
-
     # Return true if string matches the definition of "unescaped" from RFC9535:
     # unescaped     = %x20-21 /        ; see RFC 8259
     #                    ; omit 0x22 "
@@ -428,19 +424,6 @@ module Janeway
       end
     end
 
-    def escapable?(char)
-      case char.ord
-      when 0x62 then true # backspace
-      when 0x66 then true # form feed
-      when 0x6E then true # line feed
-      when 0x72 then true # carriage return
-      when 0x74 then true # horizontal tab
-      when 0x2F then true # slash
-      when 0x5C then true # backslash
-      else false
-      end
-    end
-
     # True if character is suitable as the first character in a name selector
     # using shorthand notation (ie. no bracket notation.)
     #
@@ -481,14 +464,14 @@ module Janeway
     def lex_member_name_shorthand(ignore_keywords: false)
       # Abort if name is preceded by child_start.  Catches non-delimited identifiers in brackets,
       # eg.  $["key"] is allowed, but $[key] is not
-      raise err('Identifier within brackets must be surrounded by quotes') if @tokens.last&.type == :child_start
+      raise err('Identifier within brackets must be surrounded by quotes') if previous_token_type == :child_start
 
       consume while name_char?(lookahead)
-      identifier = source[lexeme_start_p..(next_p - 1)]
+      identifier = current_lexeme
       type =
-        if KEYWORD.include?(identifier) && !ignore_keywords
+        if KEYWORD_SET.include?(identifier) && !ignore_keywords
           identifier.to_sym
-        elsif FUNCTIONS.include?(identifier) && !ignore_keywords
+        elsif FUNCTIONS_SET.include?(identifier) && !ignore_keywords
           :function
         else
           :identifier

data/lib/janeway/location.rb

@@ -1,3 +1,5 @@
 # frozen_string_literal: true
 
-Location = Struct.new(:col, :length)
+module Janeway
+  Location = Struct.new(:col, :length)
+end

data/lib/janeway/normalized_path.rb

@@ -11,6 +11,15 @@ module Janeway
     # Characters that do not need escaping, defined by hexadecimal range
     NORMAL_UNESCAPED_RANGES = [(0x20..0x26), (0x28..0x5B), (0x5D..0xD7FF), (0xE000..0x10FFFF)].freeze
 
+    # Fast-path check for `escape`: a single anchored regex covering the same
+    # ranges as NORMAL_UNESCAPED_RANGES. Avoids allocating a `chars` array and
+    # scanning four Range objects per character on the common all-normal case.
+    NORMAL_UNESCAPED_REGEX = Regexp.new(
+      '\A[' +
+      NORMAL_UNESCAPED_RANGES.map { |r| "\\u{#{r.min.to_s(16)}}-\\u{#{r.max.to_s(16)}}" }.join +
+      ']*\z'
+    ).freeze
+
     def self.normalize(value)
       case value
       when String then normalize_name(value)
@@ -33,8 +42,8 @@ module Janeway
     end
 
     def self.escape(str)
-      # Common case, all chars are normal.
-      return str if str.chars.all? { |char| NORMAL_UNESCAPED_RANGES.any? { |range| range.include?(char.ord) } }
+      # Common case, all chars are normal — one regex match, no allocations.
+      return str if NORMAL_UNESCAPED_REGEX.match?(str)
 
       # Some escaping must be done
       str.chars.map { |char| escape_char(char) }.join

data/lib/janeway/parser.rb

@@ -16,6 +16,32 @@ module Janeway
     UNARY_OPERATORS = %w[! -].freeze
     BINARY_OPERATORS = %w[== != > < >= <= ,].freeze
     LOGICAL_OPERATORS = %w[&& ||].freeze
+
+    # O(1)-lookup Hash companions to the arrays above, plus the union used by
+    # determine_infix_function. Building these inline in the hot path
+    # allocated a fresh Array per token; hoisting eliminates it.
+    UNARY_OPERATOR_SET = UNARY_OPERATORS.each_with_object({}) { |op, h| h[op] = true }.freeze
+    BINARY_OPERATOR_SET = BINARY_OPERATORS.each_with_object({}) { |op, h| h[op] = true }.freeze
+    INFIX_OPERATOR_SET =
+      (BINARY_OPERATORS + LOGICAL_OPERATORS).each_with_object({}) { |op, h| h[op] = true }.freeze
+    PARSE_METHOD_TYPES =
+      %I[identifier number string true false nil function if while root current_node]
+      .each_with_object({}) { |t, h| h[t] = true }.freeze
+    TERMINATOR_TYPES = %I[child_end union eof].each_with_object({}) { |t, h| h[t] = true }.freeze
+
+    # O(1) dispatch table for determine_parsing_function's type-driven cases.
+    # Sits next to the PARSE_METHOD_TYPES set (the other type branch) so both
+    # are visible when adding a new token type.
+    PARSE_DISPATCH_BY_TYPE = {
+      group_start: :parse_grouped_expr,
+      :"\n" => :parse_terminator,
+      eof: :parse_terminator,
+      child_start: :parse_child_segment,
+      dot: :parse_dot_notation,
+      descendants: :parse_descendant_segment,
+      filter: :parse_filter_selector,
+      null: :parse_null,
+    }.freeze
     LOWEST_PRECEDENCE = 0
     OPERATOR_PRECEDENCE = {
       ',' => 0,
@@ -65,12 +91,8 @@ module Janeway
 
     private
 
-    def pending_tokens?
-      @next_p < tokens.length
-    end
-
     def next_not_terminator?
-      next_token && next_token.type != :"\n" && next_token.type != :eof
+      next_token && next_token.type != :eof
     end
 
     # Make "next" token become "current" by moving the pointer
@@ -135,33 +157,21 @@ module Janeway
     end
 
     def determine_parsing_function
-      parse_methods = %I[identifier number string true false nil function if while root current_node]
-      if parse_methods.include?(current.type)
-        :"parse_#{current.type}"
-      elsif current.type == :group_start # (
-        :parse_grouped_expr
-      elsif %I[\n eof].include?(current.type)
-        :parse_terminator
-      elsif UNARY_OPERATORS.include?(current.lexeme)
-        :parse_unary_operator
-      elsif current.type == :child_start # [
-        :parse_child_segment
-      elsif current.type == :dot # .
-        :parse_dot_notation
-      elsif current.type == :descendants # ..
-        :parse_descendant_segment
-      elsif current.type == :filter # ?
-        :parse_filter_selector
-      elsif current.type == :null # null
-        :parse_null
-      else
-        raise err("Don't know how to parse #{current}")
-      end
+      # Two type-driven tables plus a lexeme-driven check for unary operators.
+      # PARSE_METHOD_TYPES synthesizes the method name (`:parse_<type>`);
+      # PARSE_DISPATCH_BY_TYPE maps to a fixed method name.
+      return :"parse_#{current.type}" if PARSE_METHOD_TYPES.include?(current.type)
+
+      dispatch = PARSE_DISPATCH_BY_TYPE[current.type]
+      return dispatch if dispatch
+      return :parse_unary_operator if UNARY_OPERATOR_SET.include?(current.lexeme)
+
+      raise err("Don't know how to parse #{current}")
     end
 
     # @return [nil, Symbol]
     def determine_infix_function(token = current)
-      return unless (BINARY_OPERATORS + LOGICAL_OPERATORS).include?(token.lexeme)
+      return unless INFIX_OPERATOR_SET.include?(token.lexeme)
 
       :parse_binary_operator
     end
@@ -198,14 +208,16 @@ module Janeway
       end
 
       # '-' must be followed by a number token.
-      # Parse number and apply - sign to its literal value
+      # Consume the minus, then replace the following number token in the
+      # token stream with a copy that has the negated literal. Replacing —
+      # rather than mutating in place — keeps Token immutable.
       consume
-      parse_number
       unless current.literal.is_a?(Numeric)
         raise err("Minus operator \"-\" must be followed by number, got #{current.lexeme.inspect}")
       end
 
-      current.literal *= -1
+      original = current
+      @tokens[@next_p - 1] = Token.new(original.type, original.lexeme, -original.literal, original.location)
       current
     end
 
@@ -481,11 +493,10 @@ module Janeway
     # Feed tokens to the FilterSelector until hitting a terminator
     def parse_filter_selector
       selector = AST::FilterSelector.new
-      terminator_types = %I[child_end union eof]
-      while next_token && !terminator_types.include?(next_token.type)
+      while next_token && !TERMINATOR_TYPES.include?(next_token.type)
         consume
         node =
-          if BINARY_OPERATORS.include?(current.lexeme)
+          if BINARY_OPERATOR_SET.include?(current.lexeme)
             parse_binary_operator(selector.value)
           else
             parse_expr_recursively
@@ -529,6 +540,7 @@ module Janeway
 
       consume
       op.right = parse_expr_recursively(op_precedence)
+      op.validate!
 
       op
     end