janeway-jsonpath 1.0.0 → 1.2.0

data/lib/janeway/error.rb

@@ -20,9 +20,38 @@ module Janeway
     # @param query [String] entire query string
     # @param location [Location] location of error
     def initialize(msg, query = nil, location = nil)
-      super("Jsonpath query #{query} - #{msg}")
+      prefix = 'Jsonpath query '
+      pointer = query.is_a?(String) && location
+      # The pointer is only right if the header's copy of the query is on one line.
+      # scrub swaps each invalid byte for one replacement character, so the columns stay valid
+      # and a query that is not valid UTF-8 cannot make building the error raise.
+      shown = query
+      if pointer
+        shown = shown.scrub unless shown.valid_encoding?
+        shown = shown.tr("\r\n", '  ')
+      end
+      full = +''
+      full << "#{prefix}#{shown}" if query
+      full << " (col #{location.col})" if location
+      full << ' - ' unless full.empty?
+      full << msg
+      full << pointer_line(shown, location, prefix.length) if pointer
+      super(full)
       @query = query
       @location = location
     end
+
+    private
+
+    # Build the line of carets that marks the problem, aligned under the query in the message header.
+    # @param line [String] the query as shown in the header, on one line
+    # @param location [Location]
+    # @param offset [Integer] width of the text that comes before the query in the header
+    # @return [String] starts with a newline
+    def pointer_line(line, location, offset)
+      col = (location.col || 0).clamp(0, line.length)
+      length = (location.length || 1).clamp(1, [line.length - col, 1].max)
+      "\n#{' ' * (offset + col)}#{'^' * length}"
+    end
   end
 end

data/lib/janeway/functions/count.rb

@@ -29,14 +29,7 @@ module Janeway
       raise Error, "Invalid parameter - count() expects node list, got #{arg.value.inspect}" if arg.literal?
       raise Error, 'Too many parameters for count() function call' unless current.type == :group_end
 
-      # Define function body
-      AST::Function.new('count', parameters) do |node_list|
-        if node_list.is_a?(Array)
-          node_list.size
-        else
-          1 # the count of a non-empty singular nodelist such as count(@) is always 1.
-        end
-      end
+      AST::Function.new('count', parameters)
     end
   end
 end

data/lib/janeway/functions/length.rb

@@ -21,18 +21,7 @@ module Janeway
       end
       raise err('Too many parameters for length() function call') unless current.type == :group_end
 
-      # Meaning of return value depends on the JSON type:
-      #   * string - number of Unicode scalar values in the string.
-      #   * array -  number of elements in the array.
-      #   * object - number of members in the object.
-      # For any other argument value, the result is the special result Nothing.
-      AST::Function.new('length', parameters) do |value|
-        if [Array, Hash, String].include?(value.class)
-          value.size
-        else
-          :nothing
-        end
-      end
+      AST::Function.new('length', parameters)
     end
   end
 end

data/lib/janeway/functions/match.rb

@@ -19,16 +19,10 @@ module Janeway
     # otherwise.
     #
     #
-    # The regexp dialect is called "I-Regexp" and is defined in RFC9485.
-    #
-    # Fortunately a shortcut is availalble, that RFC contains instructions
-    # for converting an I-Regexp to ruby's regexp format.
-    # @see https://www.rfc-editor.org/rfc/rfc9485.html#name-pcre-re2-and-ruby-regexps
-    #
-    # The instructions are:
-    #   * For any unescaped dots (.) outside character classes (first
-    #     alternative of charClass production), replace the dot with [^\n\r].
-    #   * Enclose the regexp in \A(?: and )\z.
+    # The pattern is validated and translated by Janeway::IRegexp (RFC 9485). A pattern that is not an
+    # I-Regexp gives LogicalFalse (RFC 9535 sections 2.4.6 and 2.4.7). A literal pattern that is over
+    # one of the limits in IRegexp (MAX_LENGTH, MAX_REPEAT, MAX_GROUP_DEPTH) raises Janeway::Error when
+    # the query is parsed. In a pattern ^ and $ are ordinary characters, as RFC 9485 has no anchors.
     #
     # tl;dr: How is this different from the search function?
     # "match" must match the entire string, "search" matches a substring.
@@ -52,14 +46,11 @@ module Janeway
       parameters << parse_function_parameter
       raise Error, 'Too many parameters for match() function call' unless current.type == :group_end
 
-      AST::Function.new('match', parameters) do |str, str_iregexp|
-        if str.is_a?(String) && str_iregexp.is_a?(String)
-          regexp = translate_iregex_to_ruby_regex(str_iregexp)
-          regexp.match?(str)
-        else
-          false # result defined by RFC9535
-        end
-      end
+      validate_literal_pattern(parameters.last) # after the syntax checks, so they are reported first
+
+      # Body (including literal-regex fast path) is supplied by
+      # Functions::REGISTRY at FunctionInterpreter construction time.
+      AST::Function.new('match', parameters)
     end
   end
 end

data/lib/janeway/functions/search.rb

@@ -25,6 +25,11 @@ module Janeway
     # the result is LogicalTrue if at least one such substring exists and is
     # LogicalFalse otherwise.
     #
+    # The pattern is validated and translated by Janeway::IRegexp (RFC 9485). A pattern that is not an
+    # I-Regexp gives LogicalFalse (RFC 9535 sections 2.4.6 and 2.4.7). A literal pattern that is over
+    # one of the limits in IRegexp (MAX_LENGTH, MAX_REPEAT, MAX_GROUP_DEPTH) raises Janeway::Error when
+    # the query is parsed. In a pattern ^ and $ are ordinary characters, as RFC 9485 has no anchors.
+    #
     # tl;dr: How is this different from the match function?
     # "match" must match the entire string, "search" matches a substring.
     def parse_function_search
@@ -45,16 +50,13 @@ module Janeway
       # Otherwise it is an expression that takes the regexp from the input document,
       # and the iregexp will not be available until interpretation.
       parameters << parse_function_parameter
-      raise Error, 'Too many parameters for match() function call' unless current.type == :group_end
+      raise Error, 'Too many parameters for search() function call' unless current.type == :group_end
+
+      validate_literal_pattern(parameters.last) # after the syntax checks, so they are reported first
 
-      AST::Function.new('search', parameters) do |str, str_iregexp|
-        if str.is_a?(String) && str_iregexp.is_a?(String)
-          regexp = translate_iregex_to_ruby_regex(str_iregexp, anchor: false)
-          regexp.match?(str)
-        else
-          false # result defined by RFC9535
-        end
-      end
+      # Body (including literal-regex fast path) is supplied by
+      # Functions::REGISTRY at FunctionInterpreter construction time.
+      AST::Function.new('search', parameters)
     end
   end
 end

data/lib/janeway/functions/value.rb

@@ -36,13 +36,7 @@ module Janeway
       parameters = [parse_function_parameter]
       raise Error, 'Too many parameters for value() function call' unless current.type == :group_end
 
-      AST::Function.new('value', parameters) do |nodes|
-        if nodes.is_a?(Array) && nodes.size == 1
-          nodes.first
-        else
-          :nothing
-        end
-      end
+      AST::Function.new('value', parameters)
     end
   end
 end

data/lib/janeway/functions.rb

@@ -1,39 +1,29 @@
 # frozen_string_literal: true
 
 require_relative 'ast/function'
+require_relative 'ast/string_type'
+require_relative 'iregexp'
 
 module Janeway
-  # Mixin to provide JSONPath function handlers for Parser
+  # Mixin to provide JSONPath function handlers for Parser, plus the built-in function registry.
   module Functions
-    # Convert IRegexp format to ruby regexp equivalent, following the instructions in rfc9485.
-    # @see https://www.rfc-editor.org/rfc/rfc9485.html#name-pcre-re2-and-ruby-regexps
-    # @param iregex [String]
-    # @param anchor [Boolean] add anchors to match the string start and end
-    # @return [Regexp]
-    def translate_iregex_to_ruby_regex(iregex, anchor: true)
-      # * For any unescaped dots (.) outside character classes (first
-      #   alternative of charClass production), replace the dot with [^\n\r].
-      chars = iregex.chars
-      in_char_class = false
-      indexes = []
-      chars.each_with_index do |char, i|
-        case char
-        when '[' then in_char_class = true
-        when ']'
-          in_char_class = false unless chars[i - 1] == '\\' # escaped ] does not close char class
-        when '.'
-          next if in_char_class || chars[i - 1] == '\\' # escaped dot
-
-          indexes << i # replace this dot
-        end
-      end
-      indexes.reverse_each do |i|
-        chars[i] = '[^\n\r]'
-      end
+    # Reject a literal pattern that exceeds an I-Regexp limit, at the point where the query is parsed.
+    #
+    # A literal that is not an I-Regexp is not an error: match() and search() return LogicalFalse
+    # for it, see build_regex_body. A literal over a limit is a valid I-Regexp that this library
+    # refuses to run, so the user is told, with the position in the query.
+    # @see https://www.rfc-editor.org/rfc/rfc9485.html#name-security-considerations
+    #   RFC 9485 section 8: an implementation may limit range quantifiers in range and composability
+    # @param parameter [AST::Expression] the second parameter of match() or search(), just parsed
+    # @raise [Janeway::Error]
+    def validate_literal_pattern(parameter)
+      return unless parameter.is_a?(AST::StringType)
 
-      # * Enclose the regexp in \A(?: and )\z.
-      regex_str = anchor ? format('\A(?:%s)\z', chars.join) : chars.join
-      Regexp.new(regex_str)
+      IRegexp.compile(parameter.value)
+    rescue IRegexp::Invalid
+      nil # RFC 9535 section 2.4.6: the function returns LogicalFalse, see build_regex_body
+    rescue IRegexp::LimitExceeded => e
+      raise Error.new("I-Regexp #{e.message}", @jsonpath, parameter.token&.location_of(e.offset, e.length))
     end
 
     # All jsonpath function parameters are one of these accepted types.
@@ -54,10 +44,120 @@ module Janeway
       consume
       result
     end
+
+    # Largest number of distinct document-supplied patterns that one function call remembers.
+    DYNAMIC_PATTERN_CACHE_SIZE = 100
+
+    # Build a match/search body. When the pattern is a StringType literal, the parser has already
+    # validated it (Functions#validate_literal_pattern, which discards the result); the interpreter
+    # compiles it once more, with the anchoring this function needs, when it is built.
+    # Otherwise the pattern comes from the input document and is compiled when it is first used.
+    #
+    # A pattern that is not an I-Regexp, or that exceeds a limit, gives LogicalFalse.
+    # @see https://www.rfc-editor.org/rfc/rfc9535.html#name-match-function-extension
+    #   RFC 9535 section 2.4.6: "If the first argument is not a string or the second argument is
+    #   not a string conforming to [RFC9485], the result is LogicalFalse." Section 2.4.7 says the
+    #   same for search().
+    # A literal that exceeds a limit has already been rejected by the parser, see
+    # Functions#validate_literal_pattern.
+    def self.build_regex_body(parameters, anchor:)
+      literal = parameters[1].is_a?(AST::StringType) ? parameters[1].value : nil
+      # The cache holds compiled regexps keyed by pattern text, so reusing it for other subjects is
+      # correct. It lives as long as the interpreter tree, which Query#interpreter_tree_for caches
+      # on an unfrozen Query.
+      cache = {} # pattern string => Regexp, or nil when the pattern is unusable
+      cache[literal] = compile_or_nil(literal, anchor) if literal # a literal is compiled once, now
+      lambda do |str, pattern|
+        pattern = literal if literal
+        next false unless str.is_a?(String) && pattern.is_a?(String)
+        # A pattern in the wrong encoding is false and never reaches the cache: Hash lookup compares
+        # strings by content, so a binary 'a' would otherwise share the entry of a UTF-8 'a'.
+        next false unless IRegexp.valid_encoding?(pattern)
+        # RFC 9485 section 8 lets an implementation limit patterns; the limit is this library's own
+        # choice. Checked before parsing so that a huge pattern costs almost nothing.
+        next false if pattern.length > IRegexp::MAX_LENGTH
+
+        unless cache.key?(pattern)
+          cache.shift if cache.size >= DYNAMIC_PATTERN_CACHE_SIZE
+          cache[pattern] = compile_or_nil(pattern, anchor)
+        end
+
+        !cache[pattern].nil? && match_safely(cache[pattern], str)
+      end
+    end
+
+    # RFC 9535 section 2.4.6: a pattern that does not conform to RFC 9485 gives LogicalFalse, so it is nil here.
+    # A pattern over a limit (RFC 9485 section 8) is treated the same way.
+    # @return [Regexp, nil] nil when the pattern is not usable, see build_regex_body
+    def self.compile_or_nil(pattern, anchor)
+      IRegexp.compile(pattern, anchor: anchor)
+    rescue IRegexp::Invalid, IRegexp::LimitExceeded
+      nil
+    end
+
+    # Match, and treat a match that Ruby cannot or will not complete as no match.
+    #
+    # Deliberate deviation from RFC 9535 sections 2.4.6 and 2.4.7, which say the result is LogicalTrue or
+    # LogicalFalse and say nothing about a match that cannot complete: a timeout, or a subject that is
+    # not valid UTF-8, gives false. RFC 9485 section 8 (security considerations) is why a timeout exists.
+    # @param regexp [Regexp]
+    # @param str [String]
+    # @return [Boolean]
+    def self.match_safely(regexp, str)
+      regexp.match?(str)
+    rescue IRegexp::TIMEOUT_ERROR, ArgumentError, Encoding::CompatibilityError
+      # TIMEOUT_ERROR: the match took longer than IRegexp::MATCH_TIMEOUT.
+      # ArgumentError, Encoding::CompatibilityError: str is not valid UTF-8.
+      false
+    end
+
+    # Metadata + body builder for every built-in JSONPath function.
+    #
+    #   arity          — number of parameters
+    #   literal_return — true when the result is a literal (see RFC 9535
+    #                    well-typedness of function extensions)
+    #   build          — proc that takes the parsed `parameters` list and
+    #                    returns the body proc (parameters allow per-instance
+    #                    optimization, e.g. literal-regex compilation)
+    REGISTRY = {
+      'count' => {
+        arity: 1,
+        literal_return: true,
+        build: ->(_) { ->(nodes) { nodes.is_a?(Array) ? nodes.size : 1 } },
+      },
+      'length' => {
+        arity: 1,
+        literal_return: true,
+        build: lambda { |_|
+          lambda { |value|
+            [Array, Hash, String].include?(value.class) ? value.size : :nothing
+          }
+        },
+      },
+      'value' => {
+        arity: 1,
+        literal_return: true,
+        build: lambda { |_|
+          lambda { |nodes|
+            nodes.is_a?(Array) && nodes.size == 1 ? nodes.first : :nothing
+          }
+        },
+      },
+      'match' => {
+        arity: 2,
+        literal_return: false,
+        build: ->(parameters) { Functions.build_regex_body(parameters, anchor: true) },
+      },
+      'search' => {
+        arity: 2,
+        literal_return: false,
+        build: ->(parameters) { Functions.build_regex_body(parameters, anchor: false) },
+      },
+    }.freeze
   end
 end
 
-# Require function definitions
+# Require function parse-method definitions
 Dir.children("#{__dir__}/functions/").each do |path|
   require_relative "functions/#{path[0..-4]}"
 end

data/lib/janeway/interpreter.rb

@@ -33,7 +33,7 @@ module Janeway
       @query = query
       @type = as
       @jsonpath = query.jsonpath
-      @root = query_to_interpreter_tree(@query, &block)
+      @root = query.interpreter_tree_for(@type) { query_to_interpreter_tree(@query, &block) }
     end
 
     # Return multiline JSON string describing the interpreter tree.
@@ -51,65 +51,84 @@ module Janeway
     # @return [Object]
     def interpret(input)
       @root.interpret(nil, nil, input, [])
-    rescue StandardError => e
-      # Error during interpretation. Convert it to a Janeway::Error and include the query in the message
-      error = err(e.message)
-      error.set_backtrace e.backtrace
-      raise error
+    rescue Janeway::Error => e
+      # Reformat known interpretation errors to include the query in the message.
+      # Real bugs (NoMethodError, TypeError, NameError, ...) are intentionally
+      # NOT caught here — they should surface with a real backtrace, not be
+      # masked as "Jsonpath query ..." messages.
+      raise if e.query # already annotated
+
+      annotated = err(e.message)
+      annotated.set_backtrace e.backtrace
+      raise annotated
     end
 
     private
 
     # Build a tree of interpreter classes based on the query's abstract syntax tree.
     #
-    # Child segments require special handling.
-    # See the detailed explanation at the end of this file.
+    # Four phases, one per private helper:
+    #   1. build_interpreters  — one interpreter per AST node
+    #   2. append_terminal     — Yielder / Deleter / DeleteIf for the caller's mode
+    #   3. link_next_pointers  — wire each interpreter to the next one
+    #   4. rewire_child_segments — push tail selectors into each ChildSegmentInterpreter
+    #      (branch rewrite explained in the docstring at the end of this file)
     #
     # @return [Interpreters::RootNodeInterpreter]
     def query_to_interpreter_tree(query, &block)
-      # Build an interpreter for each selector
-      interpreters =
-        query.node_list.map do |node|
-          Interpreters::TreeConstructor.ast_node_to_interpreter(node)
-        end
+      interpreters = build_interpreters(query)
+      append_terminal(interpreters, &block)
+      link_next_pointers(interpreters)
+      rewire_child_segments(interpreters)
+    end
+
+    # Phase 1: one interpreter per AST node in the query's top-level chain.
+    def build_interpreters(query)
+      query.node_list.map { |node| Interpreters::TreeConstructor.ast_node_to_interpreter(node) }
+    end
 
-      # Append iterotor / deleter as needed, to support #each, #delete operations
+    # Phase 2: append the terminal interpreter that matches the caller's mode.
+    # Deleter / delete_if REPLACE the last selector (the terminal semantics
+    # live in the leaf itself); iterator APPENDS a Yielder after it.
+    def append_terminal(interpreters, &block)
       case @type
       when :iterator then interpreters.push(Yielder.new(&block))
-      when :deleter then interpreters.push make_deleter(interpreters.pop)
-      when :delete_if then interpreters.push make_delete_if(interpreters.pop, &block)
+      when :deleter then interpreters.push(make_deleter(interpreters.pop))
+      when :delete_if then interpreters.push(make_delete_if(interpreters.pop, &block))
       end
+    end
 
-      # Link interpreters together
+    # Phase 3: link `.next` from each interpreter to the following one.
+    def link_next_pointers(interpreters)
       interpreters.each_with_index do |node, i|
         node.next = interpreters[i + 1]
       end
+    end
 
-      # Child segments which contain multiple selectors are branches in the interpreter tree.
-      #
-      # For every child segment, remove all following interpreters and push
-      # them "inside" the child segment interpreter.
-      #
-      # Work backwards in case there are multiple child segments.
-      # For full explanation see the explanation at the end of this file.
-      selectors = []
+    # Phase 4: for every ChildSegmentInterpreter, remove the interpreters that
+    # follow it in the flat chain and push them into the child segment as
+    # branches. Work backwards so nested child segments compose correctly.
+    # @return [Interpreters::Base] root of the resulting tree
+    def rewire_child_segments(interpreters)
+      pending = []
       interpreters.reverse_each do |node|
         if node.is_a?(Interpreters::ChildSegmentInterpreter)
           node.next = nil
-          node.push(selectors.pop) until selectors.empty?
-          selectors = [node]
+          node.push(pending.pop) until pending.empty?
+          pending = [node]
         else
-          selectors << node
+          pending << node
         end
       end
-
-      selectors.last
+      pending.last
     end
 
     # Make a Deleter that will delete the results matched by a Selector.
+    # Implemented as a DeleteIf with the PASS_ALL sentinel block — the
+    # separate Deleter classes were folded into DeleteIf.
     # @param interpreter [Interpreters::Base] interpeter subclass
     def make_deleter(interpreter)
-      TreeConstructor.ast_node_to_deleter(interpreter.node)
+      TreeConstructor.ast_node_to_delete_if(interpreter.node, &Interpreters::IterationHelper::PASS_ALL)
     end
 
     # Make a DeleteIf that will delete the results matched by a Selector,

data/lib/janeway/interpreters/array_slice_selector_delete_if.rb

@@ -27,19 +27,13 @@ module Janeway
       # @return [Array]
       def interpret(input, _parent, _root, path)
         return [] unless input.is_a?(Array)
-        return [] if selector&.step&.zero? # RFC: When step is 0, no elements are selected.
+        return [] if effective_step.zero? # RFC: When step is 0, no elements are selected.
 
-        # Calculate the upper and lower indices of the target range
-        lower = selector.lower_index(input.size)
-        upper = selector.upper_index(input.size)
-
-        # Convert bounds and step to index values.
-        # Omit the final index, since no value is collected for that.
-        # Delete indexes from largest to smallest, so that deleting an index does
-        # not change the remaining indexes
+        # Delete matching indexes from largest to smallest so that deletion
+        # does not shift the remaining indexes.
+        indexes = index_range(input.size)
         results = []
-        if selector.step.positive?
-          indexes = lower.step(to: upper - 1, by: selector.step).to_a
+        if effective_step.positive?
           indexes.reverse_each do |i|
             next unless @yield_proc.call(input[i], input, path + [i])
 
@@ -47,8 +41,11 @@ module Janeway
           end
           results.reverse
         else
-          indexes = upper.step(to: lower + 1, by: selector.step).to_a
-          indexes.each { |i| results << input.delete_at(i) }
+          indexes.each do |i|
+            next unless @yield_proc.call(input[i], input, path + [i])
+
+            results << input.delete_at(i)
+          end
           results
         end
       end

data/lib/janeway/interpreters/array_slice_selector_interpreter.rb

@@ -17,19 +17,9 @@ module Janeway
       # @return [Array]
       def interpret(input, _parent, root, path)
         return [] unless input.is_a?(Array)
-        return [] if selector&.step&.zero? # RFC: When step is 0, no elements are selected.
-
-        # Calculate the upper and lower indices of the target range
-        lower = selector.lower_index(input.size)
-        upper = selector.upper_index(input.size)
-
-        # Collect real index values. Omit the final index, since no value is collected for that.
-        indexes =
-          if selector.step.positive?
-            lower.step(to: upper - 1, by: selector.step).to_a
-          else
-            upper.step(to: lower + 1, by: selector.step).to_a
-          end
+        return [] if effective_step.zero? # RFC: When step is 0, no elements are selected.
+
+        indexes = index_range(input.size)
         return indexes.map { |i| input[i] } unless @next
 
         # Apply child selector to each node in the output node list
@@ -44,6 +34,59 @@ module Janeway
       def as_json
         { type: type, value: node.to_s, next: @next&.as_json }.compact
       end
+
+      protected
+
+      # Concrete list of source-array indexes this slice selects, in
+      # iteration order. Consumed by both this interpreter and
+      # ArraySliceSelectorDeleteIf.
+      #
+      # @param input_size [Integer]
+      # @return [Array<Integer>]
+      def index_range(input_size)
+        lower, upper = bounds(input_size)
+        if effective_step.positive?
+          lower.step(to: upper - 1, by: effective_step).to_a
+        else
+          upper.step(to: lower + 1, by: effective_step).to_a
+        end
+      end
+
+      # Effective step: raw @step from the AST, or 1 if unspecified.
+      def effective_step
+        selector.step || 1
+      end
+
+      # Compute lower/upper bounds for the slice given the input array size.
+      # RFC 9535 pseudocode lives here (formerly on AST::ArraySliceSelector).
+      # @see https://www.rfc-editor.org/rfc/rfc9535.html#section-2.3.4.2.2
+      #
+      # @param input_size [Integer]
+      # @return [Array(Integer, Integer)] [lower, upper]
+      def bounds(input_size)
+        if effective_step >= 0
+          start = selector.start || 0
+          end_ = selector.end || input_size
+        else
+          start = selector.start || (input_size - 1)
+          end_ = selector.end || ((-1 * input_size) - 1)
+        end
+
+        n_start = normalize(start, input_size)
+        n_end = normalize(end_, input_size)
+
+        if effective_step >= 0
+          [n_start.clamp(0, input_size), n_end.clamp(0, input_size)]
+        else
+          [n_end.clamp(-1, input_size - 1), n_start.clamp(-1, input_size - 1)]
+        end
+      end
+
+      # IETF: slice parameters must be normalized before use as bounds —
+      # negative values count from the end of the array.
+      def normalize(index, len)
+        index >= 0 ? index : len + index
+      end
     end
   end
 end

data/lib/janeway/interpreters/binary_operator_interpreter.rb

@@ -13,6 +13,18 @@ module Janeway
         super
         @left = TreeConstructor.ast_node_to_interpreter(operator.left)
         @right = TreeConstructor.ast_node_to_interpreter(operator.right)
+
+        # Bind the per-op behavior at construction time to avoid dispatching
+        # on operator.name and allocating a symbol on every candidate value.
+        case operator.name
+        when :and, :or
+          @extract_single_value = false
+        when :equal, :not_equal, :less_than, :greater_than, :less_than_or_equal, :greater_than_or_equal
+          @extract_single_value = true
+        else
+          raise "Don't know how to handle binary operator #{operator.name.inspect}"
+        end
+        @op = method(:"interpret_#{operator.name}")
       end
 
       # The binary operators are all comparison operators that test equality.
@@ -28,20 +40,13 @@ module Janeway
       # @param root [Array, Hash] the entire input
       # @param _path [Array] ignored
       def interpret(input, parent, root, _path = nil)
-        # FIXME: this branch could be pushed into the constructor, to convert O(n) work to O(1)
-        case operator.name
-        when :and, :or
-          # handle node list for existence check
-          lhs = @left.interpret(input, parent, root, [])
-          rhs = @right.interpret(input, parent, root, [])
-        when :equal, :not_equal, :less_than, :greater_than, :less_than_or_equal, :greater_than_or_equal
-          # handle node values for comparison check
-          lhs = to_single_value @left.interpret(input, parent, root, [])
-          rhs = to_single_value @right.interpret(input, parent, root, [])
-        else
-          raise "Don't know how to handle binary operator #{operator.name.inspect}"
+        lhs = @left.interpret(input, parent, root, [])
+        rhs = @right.interpret(input, parent, root, [])
+        if @extract_single_value
+          lhs = to_single_value(lhs)
+          rhs = to_single_value(rhs)
         end
-        send(:"interpret_#{operator.name}", lhs, rhs)
+        @op.call(lhs, rhs)
       end
 
       # Interpret a node and extract its value, in preparation for using the node