janeway-jsonpath 1.0.0 → 1.2.0

data/lib/janeway/interpreters/descendant_segment_interpreter.rb

@@ -21,23 +21,42 @@ module Janeway
         end
       end
 
-      # Visit all descendants of `input`.
-      # Return results of applying `action` on each.
+      # Visit all descendants of `input` and concatenate the results of
+      # `block` at each node. Iterative depth-first pre-order — a recursive
+      # implementation would risk SystemStackError on deep JSON and allocated
+      # an array-per-node plus a flatten pass.
+      #
       # @param input [Array, Hash] the results of processing so far
-      # @param path [Array<String>] elements of normalized path to the current input
       # @param parent [Array, Hash] parent of the input object
-      def visit(input, parent, path, &block)
-        results = [yield(input, parent, path)]
+      # @param path [Array<String>] elements of normalized path to the current input
+      def visit(input, parent, path)
+        results = []
+        stack = [[input, parent, path]]
+        until stack.empty?
+          node, node_parent, node_path = stack.pop
+          results.concat(yield(node, node_parent, node_path))
 
-        case input
-        when Array
-          results.concat(input.map.with_index { |value, i| visit(value, input, path + [i], &block) })
-        when Hash
-          results.concat(input.map { |key, value| visit(value, input, path + [key], &block) })
+          case node
+          when Array
+            # Push in reverse so the leftmost child is popped first (pre-order).
+            i = node.size - 1
+            while i >= 0
+              stack.push([node[i], node, node_path + [i]])
+              i -= 1
+            end
+          when Hash
+            # Iterate to an array once so we can walk it in reverse.
+            pairs = node.to_a
+            i = pairs.size - 1
+            while i >= 0
+              k, v = pairs[i]
+              stack.push([v, node, node_path + [k]])
+              i -= 1
+            end
+          end
+          # Basic (non-container) types have no descendants — nothing to push.
         end
-        # basic types are ignored, they will be added by one of the above
-
-        results.flatten(1)
+        results
       end
     end
   end

data/lib/janeway/interpreters/filter_selector_interpreter.rb

@@ -43,27 +43,9 @@ module Janeway
       # @param root [Array, Hash] the entire input
       # @param path [Array<String>] elements of normalized path to the current input
       def interpret_hash(input, root, path)
-        # Apply filter expressions to the input data
         node_list = []
-        input.each do |key, value|
-          # Run filter and interpret result
-          result = @expr.interpret(value, nil, root, [])
-          case result
-          when TrueClass then node_list << [key, value] # comparison test - pass
-          when FalseClass then nil # comparison test - fail
-          when Array then node_list << [key, value] unless result.empty? # existence test - node list
-          else
-            node_list << [key, value] # existence test. Null values here == success.
-          end
-        end
-        return node_list.map(&:last) unless @next
-
-        # Apply child selector to each node in the output node list
-        results = []
-        node_list.each do |key, value|
-          results.concat @next.interpret(value, input, root, path + [key])
-        end
-        results
+        input.each { |key, value| node_list << [key, value] if filter_match?(value, root) }
+        forward_matches(node_list, input, root, path)
       end
 
       # Interpret selector on the input.
@@ -71,29 +53,39 @@ module Janeway
       # @param root [Array, Hash] the entire input
       # @param path [Array<String>] elements of normalized path to the current input
       def interpret_array(input, root, path)
-        # Apply filter expressions to the input data
         node_list = []
-        input.each_with_index do |value, i|
-          # Run filter and interpret result
-          result = @expr.interpret(value, nil, root, [])
-          case result
-          when TrueClass then node_list << [i, value] # comparison test - pass
-          when FalseClass then nil # comparison test - fail
-          when Array then node_list << [i, value] unless result.empty? # existence test - node list
-          else
-            node_list << [i, value] # existence test. Null values here == success.
-          end
+        input.each_with_index { |value, i| node_list << [i, value] if filter_match?(value, root) }
+        forward_matches(node_list, input, root, path)
+      end
+
+      private
+
+      # Classify the result of running the filter expression against a value.
+      # Returns true if the value should be kept.
+      def filter_match?(value, root)
+        result = @expr.interpret(value, nil, root, [])
+        case result
+        when TrueClass then true    # comparison test - pass
+        when FalseClass then false  # comparison test - fail
+        when Array then !result.empty? # existence test - non-empty node list
+        else true                   # existence test - null / other values count as success
         end
+      end
+
+      # Given a node_list of [key_or_index, value] pairs, apply @next to each
+      # and concat the results. If no @next, return just the values.
+      def forward_matches(node_list, input, root, path)
         return node_list.map(&:last) unless @next
 
-        # Apply child selector to each node in the output node list
         results = []
-        node_list.each do |i, value|
-          results.concat @next.interpret(value, input, root, path + [i])
+        node_list.each do |key, value|
+          results.concat @next.interpret(value, input, root, path + [key])
         end
         results
       end
 
+      public
+
       # @return [Hash]
       def as_json
         { type: type, value: node.to_s, next: @next&.as_json }.compact

data/lib/janeway/interpreters/function_interpreter.rb

@@ -22,6 +22,10 @@ module Janeway
       def initialize(function)
         super
         @params = function.parameters.map { |param| TreeConstructor.ast_node_to_interpreter(param) }
+        # Build the function body from the registry. This is the point at
+        # which per-instance specialization happens — e.g. match/search
+        # compile a literal regex once, capturing it in the closure.
+        @body = Functions::REGISTRY.fetch(function.name)[:build].call(function.parameters)
       end
 
       # @param input [Array, Hash] the results of processing so far
@@ -30,7 +34,7 @@ module Janeway
       # @param _path [Array<String>] elements of normalized path to the current input
       def interpret(input, _parent, root, _path)
         params = interpret_function_parameters(@params, input, root)
-        function.body.call(*params)
+        @body.call(*params)
       end
 
       # Evaluate the expressions in the parameter list to make the parameter values

data/lib/janeway/interpreters/index_selector_delete_if.rb

@@ -31,7 +31,6 @@ module Janeway
         index += input.size if index.negative? # yield positive index for the normalize path
         return unless @yield_proc.call(input[index], input, path + [index])
 
-        index += input.size if index.negative?
         input.delete_at(index) # returns nil if deleted value is nil, or if no value was deleted
         [result]
       rescue IndexError

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