janeway-jsonpath 0.5.0 → 0.6.0

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/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,40 @@
+# 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
+        return unless @yield_proc.call(input[index], input, path + [index])
+
+        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/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]

data/lib/janeway/lexer.rb

@@ -5,50 +5,50 @@ require_relative 'token'
 require_relative 'error'
 
 module Janeway
-  OPERATORS = {
-    and: '&&',
-    array_slice_separator: ':',
-    child_end: ']',
-    child_start: '[',
-    current_node: '@',
-    descendants: '..',
-    dot: '.',
-    equal: '==',
-    filter: '?',
-    greater_than: '>',
-    greater_than_or_equal: '>=',
-    group_end: ')',
-    group_start: '(',
-    less_than: '<',
-    less_than_or_equal: '<=',
-    minus: '-',
-    not: '!',
-    not_equal: '!=',
-    or: '||',
-    root: '$',
-    union: ',',
-    wildcard: '*',
-  }.freeze
-  ONE_CHAR_LEX = OPERATORS.values.select { |lexeme| lexeme.size == 1 }.freeze
-  TWO_CHAR_LEX = OPERATORS.values.select { |lexeme| lexeme.size == 2 }.freeze
-  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
-
-  WHITESPACE = " \t\n\r"
-  KEYWORD = %w[true false null].freeze
-  FUNCTIONS = %w[length count match search value].freeze
-
-  # faster to check membership in a string than an array of char (benchmarked ruby 3.1.2)
-  ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-  DIGITS = '0123456789'
-
-  # chars that may be used as the first letter of member-name-shorthand
-  NAME_FIRST = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
-
   # Transforms source code into tokens
   class Lexer
     class Error < Janeway::Error; end
 
+    OPERATORS = {
+      and: '&&',
+      array_slice_separator: ':',
+      child_end: ']',
+      child_start: '[',
+      current_node: '@',
+      descendants: '..',
+      dot: '.',
+      equal: '==',
+      filter: '?',
+      greater_than: '>',
+      greater_than_or_equal: '>=',
+      group_end: ')',
+      group_start: '(',
+      less_than: '<',
+      less_than_or_equal: '<=',
+      minus: '-',
+      not: '!',
+      not_equal: '!=',
+      or: '||',
+      root: '$',
+      union: ',',
+      wildcard: '*',
+    }.freeze
+    ONE_CHAR_LEX = OPERATORS.values.select { |lexeme| lexeme.size == 1 }.freeze
+    TWO_CHAR_LEX = OPERATORS.values.select { |lexeme| lexeme.size == 2 }.freeze
+    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
+
+    WHITESPACE = " \t\n\r"
+    KEYWORD = %w[true false null].freeze
+    FUNCTIONS = %w[length count match search value].freeze
+
+    # faster to check membership in a string than an array of char (benchmarked ruby 3.1.2)
+    ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    DIGITS = '0123456789'
+
+    # chars that may be used as the first letter of member-name-shorthand
+    NAME_FIRST = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
+
     attr_reader :source, :tokens
     attr_accessor :next_p, :lexeme_start_p
 

data/lib/janeway/parser.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'ast'
 require_relative 'error'
 require_relative 'functions'
 require_relative 'lexer'
+require_relative 'query'
 
 module Janeway
   # Transform a list of tokens into an Abstract Syntax Tree

data/lib/janeway/query.rb

@@ -30,10 +30,19 @@ module Janeway
       Janeway::Enumerator.new(self, input)
     end
 
+    # @return [String]
     def to_s
       @root.to_s
     end
 
+    # Return true if this query can only possibly match 0 or 1 elements in any input.
+    # Such a query must be composed exclusively of the root identifier followed by
+    # name selectors and / or index selectors.
+    # @return [Boolean]
+    def singular_query?
+      @root.singular_query?
+    end
+
     # Return a list of the nodes in the AST.
     # The AST of a jsonpath query is a straight line, so this is expressible as an array.
     # The only part of the AST with branches is inside a filter selector, but that doesn't show up here.
@@ -66,5 +75,36 @@ module Janeway
 
       result.flatten.join("\n")
     end
+
+    # Deep copy the query
+    # @return [Query]
+    def dup
+      Parser.parse(to_s)
+    end
+
+    # Delete the last element from the chain of selectors.
+    # For a singular query, this makes the query point to the match's parent instead of the match itself.
+    #
+    # Don't do this for a non-singular query, those may contain child segments and
+    # descendant segments which would lead to different results.
+    #
+    # @return [AST::Selector]
+    def pop
+      unless singular_query?
+        raise Janeway::Error.new('not allowed to pop from a non-singular query', to_s)
+      end
+
+      # Sever the link to the last selector
+      nodes = node_list
+      if nodes.size == 1
+        # Special case: cannot pop from the query "$" even though it is a singular query
+        raise Janeway::Error.new('cannot pop from single-element query', to_s)
+      end
+
+      nodes[-2].next = nil
+
+      # Return the last selector
+      nodes.last
+    end
   end
 end