janeway-jsonpath 0.5.0 → 1.0.0

data/lib/janeway/interpreter.rb

@@ -11,6 +11,7 @@ module Janeway
   # It should be created for a single query and then discarded.
   class Interpreter
     attr_reader :jsonpath, :output
+
     include Interpreters
 
     # Interpret a query on the given input, return result
@@ -25,7 +26,7 @@ module Janeway
     # @param query [Query] abstract syntax tree of the jsonpath query
     def initialize(query, as: :finder, &block)
       raise ArgumentError, "expect Query, got #{query.inspect}" unless query.is_a?(Query)
-      unless %i[finder iterator deleter].include?(as)
+      unless %i[finder iterator deleter delete_if].include?(as)
         raise ArgumentError, "invalid interpreter type: #{as.inspect}"
       end
 
@@ -49,10 +50,6 @@ module Janeway
     # @param input [Array, Hash] object to be searched
     # @return [Object]
     def interpret(input)
-      unless input.is_a?(Hash) || input.is_a?(Array)
-        return [] # can't query on any other types, but need to check because a string is also valid json
-      end
-
       @root.interpret(nil, nil, input, [])
     rescue StandardError => e
       # Error during interpretation. Convert it to a Janeway::Error and include the query in the message
@@ -80,6 +77,7 @@ module Janeway
       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)
       end
 
       # Link interpreters together
@@ -114,6 +112,14 @@ module Janeway
       TreeConstructor.ast_node_to_deleter(interpreter.node)
     end
 
+    # Make a DeleteIf that will delete the results matched by a Selector,
+    # after yielding to a block for approval.
+    #
+    # @param interpreter [Interpreters::Base] interpeter subclass
+    def make_delete_if(interpreter, &block)
+      TreeConstructor.ast_node_to_delete_if(interpreter.node, &block)
+    end
+
     # Return an Interpreter::Error with the specified message, include the query.
     #
     # @param msg [String] error message

data/lib/janeway/interpreters/array_slice_selector_delete_if.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'array_slice_selector_interpreter'
+require_relative 'iteration_helper'
+
+module Janeway
+  module Interpreters
+    # Delete values that match the array slice selector and yield true from the block
+    class ArraySliceSelectorDeleteIf < ArraySliceSelectorInterpreter
+      include IterationHelper
+
+      # @param node [AST::Expression]
+      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 at the indices matched by the array slice selector
+      #
+      # @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]
+      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)
+
+        # 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
+        results = []
+        if selector.step.positive?
+          indexes = lower.step(to: upper - 1, by: selector.step).to_a
+          indexes.reverse_each do |i|
+            next unless @yield_proc.call(input[i], input, path + [i])
+
+            results << input.delete_at(i)
+          end
+          results.reverse
+        else
+          indexes = upper.step(to: lower + 1, by: selector.step).to_a
+          indexes.each { |i| results << input.delete_at(i) }
+          results
+        end
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/array_slice_selector_deleter.rb

@@ -6,7 +6,7 @@ module Janeway
   module Interpreters
     # Interprets array slice selector and deletes matching values
     class ArraySliceSelectorDeleter < ArraySliceSelectorInterpreter
-      # Delete values at the indices matched by the array slice selector
+      # Delete values matched by the array slice selector
       #
       # @param input [Array, Hash] the results of processing so far
       # @param _parent [Array, Hash] parent of the input object

data/lib/janeway/interpreters/child_segment_delete_if.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'child_segment_interpreter'
+
+module Janeway
+  module Interpreters
+    # Child segment interpreter with selectors that delete matching elements if
+    # the given block yields a truthy value
+    class ChildSegmentDeleteIf < ChildSegmentInterpreter
+      # @param child_segment [AST::ChildSegment]
+      def initialize(child_segment, &block)
+        super(child_segment)
+        @selectors =
+          child_segment.map do |expr|
+            TreeConstructor.ast_node_to_delete_if(expr, &block)
+          end
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/child_segment_deleter.rb

@@ -5,7 +5,7 @@ require_relative 'child_segment_interpreter'
 module Janeway
   module Interpreters
     # Child segment interpreter with selectors that delete matching elements
-    class ChildSegmentDeleter < ChildSegmentInterpreter 
+    class ChildSegmentDeleter < ChildSegmentInterpreter
       # @param child_segment [AST::ChildSegment]
       def initialize(child_segment)
         super

data/lib/janeway/interpreters/descendant_segment_interpreter.rb

@@ -37,7 +37,7 @@ module Janeway
         end
         # basic types are ignored, they will be added by one of the above
 
-        results.flatten(1).compact
+        results.flatten(1)
       end
     end
   end

data/lib/janeway/interpreters/filter_selector_delete_if.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'filter_selector_interpreter'
+require_relative 'iteration_helper'
+
+module Janeway
+  module Interpreters
+    # Interprets a filter selector by deleting matching values for which the block returns a truthy value
+    class FilterSelectorDeleteIf < FilterSelectorInterpreter
+      include IterationHelper
+
+      # @param selector [AST::FilterSelector]
+      def initialize(selector, &block)
+        super(selector)
+        @block = block
+
+        # Make a proc that yields the correct number of values to a block
+        @yield_proc = make_yield_proc(&block)
+      end
+
+      # Interpret selector on the input.
+      # @param input [Hash] the results of processing so far
+      # @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
+        results = []
+        input.each do |key, value|
+          # Run filter and interpret result
+          result = @expr.interpret(value, nil, root, [])
+          case result
+          when FalseClass then next # comparison test - fail
+          when Array then next if result.empty?
+          end
+
+          # filter test passed, next yield value to block
+          next unless @yield_proc.call(value, input, path + [key])
+
+          results << input.delete(key)
+        end
+        results
+      end
+
+      # Interpret selector on the input.
+      # @param input [Array] the results of processing so far
+      # @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
+        results = []
+
+        # Iterate in reverse order so that deletion does not alter the remaining indexes
+        i = input.size
+        input.reverse_each do |value|
+          i -= 1 # calculate array index
+
+          # Run filter and interpret result
+          result = @expr.interpret(value, nil, root, [])
+          case result
+          when FalseClass then next # comparison test - fail
+          when Array then next if result.empty?
+          end
+
+          # filter test passed, next yield value to block
+          next unless @yield_proc.call(value, input, path + [i])
+
+          results << input.delete_at(i)
+        end
+        results.reverse
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/index_selector_delete_if.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'index_selector_interpreter'
+require_relative 'iteration_helper'
+
+module Janeway
+  module Interpreters
+    # Interprets an index selector, and deletes the matched value if the block returns true.
+    class IndexSelectorDeleteIf < IndexSelectorInterpreter
+      include IterationHelper
+
+      # @param selector [AST::IndexSelector]
+      def initialize(selector, &block)
+        super(selector)
+        @block = block
+
+        # Make a proc that yields the correct number of values to a block
+        @yield_proc = make_yield_proc(&block)
+      end
+
+      # Interpret selector on the given input.
+      # @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
+      def interpret(input, _parent, _root, path)
+        return [] unless input.is_a?(Array)
+
+        index = selector.value
+        result = input.fetch(index) # raises IndexError if no such index
+        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
+        []
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/index_selector_interpreter.rb

@@ -31,7 +31,9 @@ module Janeway
         result = input.fetch(selector.value) # raises IndexError if no such index
         return [result] unless @next
 
-        @next.interpret(result, input, root, path + [selector.value])
+        index = selector.value
+        index += input.size if index.negative?
+        @next.interpret(result, input, root, path + [index])
       rescue IndexError
         []
       end

data/lib/janeway/interpreters/iteration_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../normalized_path'
+
+module Janeway
+  module Interpreters
+    # Mixin for interpreter classes that yield to a block
+    module IterationHelper
+      # 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)
+        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) }
+        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)) }
+        else
+          # block arity is 1, 2 or 3. Send all 3 parameters regardless.
+          proc { |value, parent, path| @block.call(value, parent, path.last) }
+        end
+      end
+
+      # Convert the list of path elements into a normalized query string.
+      #
+      # This form uses a subset of jsonpath that unambiguously points to a value
+      # using only name and index selectors.
+      # @see https://www.rfc-editor.org/rfc/rfc9535.html#name-normalized-paths
+      #
+      # Name selectors must use bracket notation, not shorthand.
+      #
+      # @param components [Array<String, Integer>]
+      # @return [String]
+      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
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/name_selector_delete_if.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'name_selector_interpreter'
+require_relative 'iteration_helper'
+
+module Janeway
+  module Interpreters
+    # Interprets a name selector, and deletes the matched values if the block returns a truthy value.
+    class NameSelectorDeleteIf < NameSelectorInterpreter
+      include IterationHelper
+
+      # @param selector [AST::NameSelector]
+      def initialize(selector, &block)
+        super(selector)
+        @block = block
+
+        # Make a proc that yields the correct number of values to a block
+        @yield_proc = make_yield_proc(&block)
+      end
+
+      # Interpret selector on the given input.
+      # Delete matching value for which the block returns truthy value.
+      #
+      # @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] elements of normalized path to the current input
+      def interpret(input, _parent, _root, path)
+        return [] unless input.is_a?(Hash) && input.key?(name)
+        return [] unless @yield_proc.call(input[name], input, path + [name])
+
+        [input.delete(name)]
+      end
+
+      # Return hash representation of this interpreter
+      # @return [Hash]
+      def as_json
+        { type: type, value: name }
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/root_node_delete_if.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'root_node_interpreter'
+
+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 '$.*'?
+      #
+      # @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)
+        case root
+        when Array
+          results = root.dup
+          root.clear
+          results
+        when Hash
+          results = root.values
+          root.clear
+          results
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/tree_constructor.rb

@@ -17,6 +17,12 @@ module Janeway
         alias_method :node, :interpret
       end
 
+      # Return an interpreter for the given AST node.
+      # This interpreter forwards matcheed values to the next interpreter, or
+      # returns them if there is no next interpreter.
+      #
+      # @param expr [AST::Expression]
+      # @return [Interprteters::Base]
       def self.ast_node_to_interpreter(expr)
         case expr
         when AST::RootNode then Interpreters::RootNodeInterpreter.new(expr)
@@ -38,6 +44,11 @@ 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)
@@ -47,12 +58,31 @@ module Janeway
         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.
+      #
+      # @param expr [AST::Expression]
+      # @return [Interprteters::Base]
+      def self.ast_node_to_delete_if(expr, &block)
+        case expr
+        when AST::IndexSelector then IndexSelectorDeleteIf.new(expr, &block)
+        when AST::ArraySliceSelector then ArraySliceSelectorDeleteIf.new(expr, &block)
+        when AST::NameSelector then NameSelectorDeleteIf.new(expr, &block)
+        when AST::FilterSelector then FilterSelectorDeleteIf.new(expr, &block)
+        when AST::WildcardSelector then WildcardSelectorDeleteIf.new(expr, &block)
+        when AST::ChildSegment then ChildSegmentDeleteIf.new(expr, &block)
+        when AST::RootNode then RootNodeDeleteIf.new(expr, &block)
+        else
+          raise "Unknown AST expression: #{expr.inspect}"
+        end
+      end
     end
   end
 end

data/lib/janeway/interpreters/wildcard_selector_delete_if.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'wildcard_selector_interpreter'
+require_relative 'iteration_helper'
+
+module Janeway
+  module Interpreters
+    # Interprets a wildcard selector by deleting array / hash values for which a block returns true.
+    class WildcardSelectorDeleteIf < WildcardSelectorInterpreter
+      include IterationHelper
+
+      # @param selector [AST::WildcardSelector]
+      def initialize(selector, &block)
+        super(selector)
+        @block = block
+
+        # Make a proc that yields the correct number of values to a block
+        @yield_proc = make_yield_proc(&block)
+      end
+
+      # Delete all elements from the input
+      #
+      # @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)
+        case input
+        when Array then maybe_delete_array_values(input, path)
+        when Hash then maybe_delete_hash_values(input, path)
+        else []
+        end
+      end
+
+      # @param input [Array]
+      # @param path [Array]
+      def maybe_delete_array_values(input, path)
+        results = []
+        (input.size - 1).downto(0).each do |i|
+          next unless @yield_proc.yield(input[i], input, path + [i])
+
+          results << input.delete_at(i)
+        end
+        results.reverse
+      end
+
+      # @param input [Hash]
+      # @param path [Array]
+      def maybe_delete_hash_values(input, path)
+        results = []
+        input.each do |key, value|
+          next unless @yield_proc.yield(value, input, path + [key])
+
+          results << input.delete(key)
+        end
+        results
+      end
+    end
+  end
+end

data/lib/janeway/interpreters/yielder.rb

@@ -1,31 +1,22 @@
 # frozen_string_literal: true
 
 require_relative 'base'
-require_relative '../normalized_path'
+require_relative 'iteration_helper'
 
 module Janeway
   module Interpreters
     # Yields each input value.
     #
-    # It is inserted at the end of the "real" selectors in the AST, to receive and yield the output.
+    # This is inserted at the end of the "real" selectors in the AST, to receive and yield the output.
     # This is a supporting class for the Janeway.each method.
     class Yielder
+      include IterationHelper
+
       def initialize(&block)
         @block = block
 
-        # Decide how many parameters to yield to this block.
-        # block.arity is -1 when no block was given, and an enumerator is being returned from #each
-        @yield_to_block =
-          if block.arity.negative?
-            # Yield values only to an enumerator.
-            proc { |value, _parent, _path| @block.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)) }
-          else
-            # block arity is 1, 2 or 3. Send all 3.
-            proc { |value, parent, path| @block.call(value, parent, path.last) }
-          end
+        # Make a proc that yields the correct number of values to a block
+        @yield_proc = make_yield_proc(&block)
       end
 
       # Yield each input value
@@ -37,27 +28,10 @@ module Janeway
       # @yieldparam [Object] matched value
       # @return [Object] input as node list
       def interpret(input, parent, _root, path)
-        @yield_to_block.call(input, parent, path)
+        @yield_proc.call(input, parent, path)
         input.is_a?(Array) ? input : [input]
       end
 
-      # Convert the list of path elements into a normalized query string.
-      #
-      # This form uses a subset of jsonpath that unambiguously points to a value
-      # using only name and index selectors.
-      # @see https://www.rfc-editor.org/rfc/rfc9535.html#name-normalized-paths
-      #
-      # Name selectors must use bracket notation, not shorthand.
-      #
-      # @param components [Array<String, Integer>]
-      # @return [String]
-      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
-      end
-
       # Dummy method from Interpreters::Base, allow child segment interpreter to disable the
       # non-exist 'next' link.
       # @return [void]