json_p3 0.2.1 → 0.3.1

data/lib/json_p3/selector.rb

@@ -70,7 +70,7 @@ module JSONP3
       @sym = @name.to_sym
     end
 
-    def resolve(node) # rubocop:disable Metrics/MethodLength
+    def resolve(node)
       if node.value.is_a?(Hash)
         if node.value.key?(@name)
           [node.new_child(node.value[@name], @name)]
@@ -172,7 +172,7 @@ module JSONP3
       @step = step || 1
     end
 
-    def resolve(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def resolve(node)
       return [] unless node.value.is_a?(Array)
 
       length = node.value.length
@@ -248,8 +248,8 @@ module JSONP3
       @expression = expression
     end
 
-    def resolve(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      nodes = []
+    def resolve(node)
+      nodes = [] # : Array[JSONPathNode]
 
       if node.value.is_a?(Array)
         node.value.each_with_index do |e, i|

data/lib/json_p3/token.rb

@@ -7,44 +7,6 @@ module JSONP3
   # string from a JSONPath expression, its location within the JSONPath expression and a
   # symbol indicating what type of token it is.
   class Token
-    EOI = :token_eoi
-    ERROR = :token_error
-
-    SHORTHAND_NAME = :token_shorthand_name
-    COLON = :token_colon
-    COMMA = :token_comma
-    DOT = :token_dot
-    DOUBLE_DOT = :token_double_dot
-    FILTER = :token_filter
-    INDEX = :token_index
-    LBRACKET = :token_lbracket
-    NAME = :token_name
-    RBRACKET = :token_rbracket
-    ROOT = :token_root
-    WILD = :token_wild
-
-    AND = :token_and
-    CURRENT = :token_current
-    DOUBLE_QUOTE_STRING = :token_double_quote_string
-    EQ = :token_eq
-    FALSE = :token_false
-    FLOAT = :token_float
-    FUNCTION = :token_function
-    GE = :token_ge
-    GT = :token_gt
-    INT = :token_int
-    LE = :token_le
-    LPAREN = :token_lparen
-    LT = :token_lt
-    NE = :token_ne
-    NOT = :token_not
-    NULL = :token_null
-    OP = :token_op
-    OR = :token_or
-    RPAREN = :token_rparen
-    SINGLE_QUOTE_STRING = :token_single_quote_string
-    TRUE = :token_true
-
     # @dynamic type, value, start, query, message
     attr_reader :type, :value, :start, :query, :message
 

data/lib/json_p3/unescape.rb

@@ -6,7 +6,7 @@ module JSONP3 # rubocop:disable Style/Documentation
   # @param quote [String] one of '"' or "'".
   # @param token [Token]
   # @return [String] A new string without escape sequences.
-  def self.unescape_string(value, quote, token) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def self.unescape_string(value, quote, token)
     unescaped = String.new(encoding: "UTF-8")
     index = 0
     length = value.length
@@ -51,13 +51,13 @@ module JSONP3 # rubocop:disable Style/Documentation
     unescaped
   end
 
-  def self.decode_hex_char(value, index, token) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+  def self.decode_hex_char(value, index, token)
     length = value.length
 
     raise JSONPathSyntaxError.new("incomplete escape sequence", token) if index + 4 >= length
 
     index += 1 # move past 'u'
-    code_point = parse_hex_digits(value[index...index + 4], token)
+    code_point = parse_hex_digits(value[index, 4], token)
 
     raise JSONPathSyntaxError.new("unexpected low surrogate", token) if low_surrogate?(code_point)
 
@@ -67,7 +67,7 @@ module JSONP3 # rubocop:disable Style/Documentation
       raise JSONPathSyntaxError.new("incomplete escape sequence", token)
     end
 
-    low_surrogate = parse_hex_digits(value[index + 6...index + 10], token)
+    low_surrogate = parse_hex_digits(value[index + 6, 10], token)
 
     raise JSONPathSyntaxError.new("unexpected low surrogate", token) unless low_surrogate?(low_surrogate)
 
@@ -78,7 +78,7 @@ module JSONP3 # rubocop:disable Style/Documentation
     [code_point, index + 9]
   end
 
-  def self.parse_hex_digits(digits, token) # rubocop:disable Metrics/MethodLength
+  def self.parse_hex_digits(digits, token)
     code_point = 0
     digits.each_byte do |b|
       code_point <<= 4

data/lib/json_p3/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONP3
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 end

data/lib/json_p3.rb

@@ -2,6 +2,8 @@
 
 require_relative "json_p3/version"
 require_relative "json_p3/environment"
+require_relative "json_p3/pointer"
+require_relative "json_p3/patch"
 
 # RFC 9535 JSONPath query expressions for JSON.
 module JSONP3
@@ -14,4 +16,12 @@ module JSONP3
   def self.compile(path)
     DefaultEnvironment.compile(path)
   end
+
+  def self.resolve(pointer, value, default: JSONPointer::UNDEFINED)
+    JSONPointer.new(pointer).resolve(value, default: default)
+  end
+
+  def self.apply(ops, value)
+    JSONPatch.new(ops).apply(value)
+  end
 end

data/sig/json_p3.rbs

@@ -1,16 +1,20 @@
-# RFC 9535 JSONPath query expressions for JSON.
+# JSONPath, JSON Patch and JSON Pointer for Ruby
 module JSONP3
   DefaultEnvironment: JSONPathEnvironment
 
   def self.find: (String path, untyped data) -> JSONPathNodeList
 
   def self.compile: (String path) -> JSONPath
+                  
+  def self.resolve: (String pointer, untyped value, ?default: untyped) -> untyped
+
+  def self.apply: (Array[Op | Hash[String, untyped]] ops, untyped value) -> untyped
 end
 
 module JSONP3
   # A least recently used cache relying on Ruby hash insertion order.
   class LRUCache
-    @data: untyped
+    @data: Hash[untyped, untyped]
 
     @max_size: Integer
 
@@ -91,6 +95,25 @@ module JSONP3
 
   class JSONPathRecursionError < JSONPathError
   end
+
+  class JSONPointerError < StandardError
+  end
+
+  class JSONPointerIndexError < JSONPointerError
+  end
+
+  class JSONPointerSyntaxError < JSONPointerError
+  end
+
+  class JSONPointerTypeError < JSONPointerError
+  end
+
+  class JSONPatchError < StandardError
+  end
+
+  class JSONPatchTestFailure < JSONPatchError
+  end
+  
 end
 
 module JSONP3
@@ -333,7 +356,7 @@ module JSONP3
 
   def self.lt?: (Expression left, Expression right) -> bool
 
-  # Contextural information and data used for evaluating a filter expression.
+  # Contextual information and data used for evaluating a filter expression.
   class FilterContext
     @env: JSONPathEnvironment
 
@@ -351,20 +374,14 @@ module JSONP3
   end
 end
 
-module JSONP3
-  class ExpressionType
-    VALUE: :value_expression
-
-    LOGICAL: :logical_expression
-
-    NODES: :nodes_expression
-  end
+type expression_t = :value_expression | :logical_expression | :nodes_expression
 
+module JSONP3
   # Base class for all filter functions.
   class FunctionExtension
-    ARG_TYPES: ::Array[Symbol]
+    ARG_TYPES: Array[expression_t]
 
-    RETURN_TYPE: Symbol
+    RETURN_TYPE: expression_t
 
     def call: (*untyped _args, **untyped _kwargs) -> untyped
   end
@@ -412,7 +429,7 @@ module JSONP3
     # @param token_type [Symbol] one of the constants defined on the _Token_ class.
     # @param value [String | nil] a the token's value, if it is known, otherwise the
     #   value will be sliced from @query. This is a performance optimisation.
-    def emit: (Symbol token_type, ?untyped value) -> void
+    def emit: (token_t token_type, ?untyped value) -> void
 
     def next: () -> String
 
@@ -445,7 +462,7 @@ module JSONP3
 
     def lex_inside_filter: () -> untyped
 
-    def self.lex_string_factory: (String quote, Symbol state, Symbol token) -> untyped
+    def self.lex_string_factory: (String quote, Symbol state, token_t token) -> untyped
   end
 end
 
@@ -507,9 +524,9 @@ module JSONP3
 
     def peek: () -> Token
 
-    def expect: (Symbol token_type) -> void
+    def expect: (token_t token_type) -> void
 
-    def expect_not: (Symbol token_type, String message) -> void
+    def expect_not: (token_t token_type, String message) -> void
 
     def to_s: () -> ::String
   end
@@ -577,15 +594,15 @@ module JSONP3
 
     def raise_for_non_comparable_function: (Expression expression) -> void
 
-    def raise_for_uncompared_literal: (Expression expression) -> void
+    def raise_for_not_compared_literal: (Expression expression) -> void
 
     def validate_function_extension_signature: (Token token, untyped args) -> void
 
-    def function_return_type: (Expression expression) -> (Symbol | nil)
+    def function_return_type: (Expression expression) -> (expression_t | nil)
 
-    PRECEDENCES: ::Hash[Symbol, Integer]
+    PRECEDENCES: ::Hash[token_t, Integer]
 
-    BINARY_OPERATORS: ::Hash[Symbol, "&&" | "||" | "==" | ">=" | ">" | "<=" | "<" | "!="]
+    BINARY_OPERATORS: ::Hash[token_t, "&&" | "||" | "==" | ">=" | ">" | "<=" | "<" | "!="]
 
     COMPARISON_OPERATORS: Set[String]
   end
@@ -828,12 +845,48 @@ module JSONP3
   end
 end
 
+type token_t = (
+  :token_eoi |
+  :token_error |
+  :token_colon |
+  :token_comma |
+  :token_double_dot |
+  :token_filter |
+  :token_index |
+  :token_lbracket |
+  :token_name |
+  :token_rbracket |
+  :token_root |
+  :token_wild |
+  :token_and |
+  :token_current |
+  :token_double_quote_string |
+  :token_eq |
+  :token_false |
+  :token_float |
+  :token_function |
+  :token_ge |
+  :token_gt |
+  :token_int |
+  :token_le |
+  :token_lparen |
+  :token_lt |
+  :token_ne |
+  :token_not |
+  :token_null |
+  :token_or |
+  :token_rparen |
+  :token_single_quote_string |
+  :token_true
+)
+    
+
 module JSONP3
   # Tokens are produced by the lexer and consumed by the parser. Each token contains sub
   # string from a JSONPath expression, its location within the JSONPath expression and a
   # symbol indicating what type of token it is.
   class Token
-    @type: Symbol
+    @type: token_t
 
     @value: String
 
@@ -843,78 +896,8 @@ module JSONP3
 
     @message: (String | nil)
 
-    EOI: :token_eoi
-
-    ERROR: :token_error
-
-    SHORTHAND_NAME: :token_shorthand_name
-
-    COLON: :token_colon
-
-    COMMA: :token_comma
-
-    DOT: :token_dot
-
-    DOUBLE_DOT: :token_double_dot
-
-    FILTER: :token_filter
-
-    INDEX: :token_index
-
-    LBRACKET: :token_lbracket
-
-    NAME: :token_name
-
-    RBRACKET: :token_rbracket
-
-    ROOT: :token_root
-
-    WILD: :token_wild
-
-    AND: :token_and
-
-    CURRENT: :token_current
-
-    DOUBLE_QUOTE_STRING: :token_double_quote_string
-
-    EQ: :token_eq
-
-    FALSE: :token_false
-
-    FLOAT: :token_float
-
-    FUNCTION: :token_function
-
-    GE: :token_ge
-
-    GT: :token_gt
-
-    INT: :token_int
-
-    LE: :token_le
-
-    LPAREN: :token_lparen
-
-    LT: :token_lt
-
-    NE: :token_ne
-
-    NOT: :token_not
-
-    NULL: :token_null
-
-    OP: :token_op
-
-    OR: :token_or
-
-    RPAREN: :token_rparen
-
-    SINGLE_QUOTE_STRING: :token_single_quote_string
-
-    TRUE: :token_true
-
     # @dynamic type, value, start, query
-    attr_reader type: Symbol
+    attr_reader type: token_t
 
     # @dynamic type, value, start, query
     attr_reader value: String
@@ -928,7 +911,7 @@ module JSONP3
     # @dynamic type, value, start, query
     attr_reader message: (String | nil)
 
-    def initialize: (Symbol type, String value, Integer start, String query, ?message: (String | nil)?) -> void
+    def initialize: (token_t type, String value, Integer start, String query, ?message: (String | nil)?) -> void
 
     def ==: (untyped other) -> bool
 
@@ -964,9 +947,9 @@ end
 module JSONP3
   # The standard `count` function.
   class Count < FunctionExtension
-    ARG_TYPES: ::Array[Symbol]
+    ARG_TYPES: Array[expression_t]
 
-    RETURN_TYPE: Symbol
+    RETURN_TYPE: expression_t
 
     def call: (JSONPathNodeList node_list) -> untyped
   end
@@ -975,9 +958,9 @@ end
 module JSONP3
   # The standard `length` function.
   class Length < FunctionExtension
-    ARG_TYPES: ::Array[Symbol]
+    ARG_TYPES: Array[expression_t]
 
-    RETURN_TYPE: Symbol
+    RETURN_TYPE: expression_t
 
     def call: (untyped obj) -> (:nothing | untyped)
   end
@@ -992,9 +975,9 @@ module JSONP3
 
     @cache: LRUCache
 
-    ARG_TYPES: ::Array[Symbol]
+    ARG_TYPES: Array[expression_t]
 
-    RETURN_TYPE: Symbol
+    RETURN_TYPE: expression_t
 
     # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
     #   zero or negative to disable the cache.
@@ -1029,9 +1012,9 @@ module JSONP3
 
     @cache: LRUCache
 
-    ARG_TYPES: ::Array[Symbol]
+    ARG_TYPES: Array[expression_t]
 
-    RETURN_TYPE: Symbol
+    RETURN_TYPE: expression_t
 
     # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
     #   zero or negative to disable the cache.
@@ -1049,10 +1032,245 @@ end
 module JSONP3
   # The standard `value` function.
   class Value < FunctionExtension
-    ARG_TYPES: ::Array[Symbol]
+    ARG_TYPES: Array[expression_t]
 
-    RETURN_TYPE: Symbol
+    RETURN_TYPE: expression_t
 
     def call: (JSONPathNodeList node_list) -> (untyped | :nothing)
   end
 end
+
+module JSONP3
+  # Identify a single value in JSON-like data, as per RFC 6901.
+  class JSONPointer
+    @tokens: Array[String | Integer]
+
+    @pointer: String
+
+    UNDEFINED: :__undefined
+
+    RE_INT: ::Regexp
+
+    attr_reader tokens: Array[String | Integer]
+
+    # Encode an array of strings and integers into a JSON pointer.
+    # @param tokens [Array<String | Integer>]
+    # @return [String]
+    def self.encode: (Array[String | Integer] tokens) -> String
+
+    # @param pointer [String]
+    def initialize: (String pointer) -> void
+
+    # Resolve this pointer against JSON-like data _value_.
+    def resolve: (untyped value, ?default: untyped) -> untyped
+
+    def resolve_with_parent: (untyped value) -> ::Array[untyped]
+
+    def relative_to?: (JSONPointer pointer) -> bool
+
+    # @param parts [String]
+    def join: (*String parts) -> JSONPointer
+            
+    # Return _true_ if this pointer can be resolved against _value_, even if the resolved
+    # value is false or nil.
+    def exist?: (untyped value) -> bool
+
+    # Return this pointer's parent as a new pointer. If this pointer points to the
+    # document root, self is returned.
+    def parent: () -> JSONPointer
+
+    # @param rel [String | RelativeJSONPointer]
+    # @return [JSONPointer]
+    def to: ((String | RelativeJSONPointer) rel) -> JSONPointer
+
+    def to_s: () -> String
+
+    # @param pointer [String]
+    # @return [Array<String | Integer>]
+    def parse: (String pointer) -> Array[(String | Integer)]
+
+    # @param value [Object]
+    # @param token [String | Integer]
+    # @return [Object] the "fetched" object from _value_ or UNDEFINED.
+    def get_item: (untyped value, (String | Integer) token) -> untyped
+
+    # Like `#parse`, but assumes there's no leading slash.
+    # @param pointer [String]
+    # @return [Array<String | Integer>]
+    def _parse: (String pointer) -> Array[(String | Integer)]
+
+    def _join: (String other) -> JSONPointer
+  end
+
+  # A relative JSON Pointer.
+  # See https://datatracker.ietf.org/doc/html/draft-hha-relative-json-pointer
+  class RelativeJSONPointer
+    @origin: Integer
+
+    @index: Integer
+
+    @pointer: (String | JSONPointer)
+
+    RE_RELATIVE_POINTER: ::Regexp
+
+    RE_INT: ::Regexp
+
+    # @param rel [String]
+    def initialize: (String rel) -> void
+
+    def to_s: () -> ::String
+
+    # @param pointer [String | JSONPointer]
+    # @return [JSONPointer]
+    def to: ((String | JSONPointer) pointer) -> JSONPointer
+
+    private
+
+    # @param token [String]
+    # @return [Integer]
+    def parse_int: (String token) -> Integer
+  end
+end
+
+module JSONP3
+  # Base class for all JSON Patch operations
+  class Op
+    # Return the name of the patch operation.
+    def name: () -> String
+
+    # Apply the patch operation to _value_.
+    def apply: (untyped _value, Integer _index) -> untyped
+
+    # Return a JSON-like representation of this patch operation.
+    def to_h: () -> untyped
+  end
+
+  # The JSON Patch _add_ operation.
+  class OpAdd < Op
+    @pointer: JSONPointer
+
+    @value: untyped
+
+    # @param pointer [JSONPointer]
+    # @param value [JSON-like value]
+    def initialize: (JSONPointer pointer, untyped value) -> void
+
+    def name: () -> "add"
+  end
+
+  # The JSON Patch _remove_ operation.
+  class OpRemove < Op
+    @pointer: JSONPointer
+
+    # @param papointerth [JSONPointer]
+    def initialize: (JSONPointer pointer) -> void
+
+    def name: () -> "remove"
+  end
+
+  # The JSON Patch _replace_ operation.
+  class OpReplace < Op
+    @pointer: JSONPointer
+
+    @value: untyped
+
+    # @param pointer [JSONPointer]
+    # @param value [JSON-like value]
+    def initialize: (JSONPointer pointer, untyped value) -> void
+
+    def name: () -> "replace"
+  end
+
+  # The JSON Patch _move_ operation.
+  class OpMove < Op
+    @from: JSONPointer
+
+    @pointer: JSONPointer
+
+    # @param from [JSONPointer]
+    # @param pointer [JSONPointer]
+    def initialize: (JSONPointer from, JSONPointer pointer) -> void
+
+    def name: () -> "move"
+  end
+
+  # The JSON Patch _copy_ operation.
+  class OpCopy < Op
+    @from: JSONPointer
+
+    @pointer: JSONPointer
+
+    # @param from [JSONPointer]
+    # @param pointer [JSONPointer]
+    def initialize: (JSONPointer from, JSONPointer pointer) -> void
+
+    def name: () -> "copy"
+            
+    def deep_copy: (untyped obj) -> untyped
+  end
+
+  # The JSON Patch _test_ operation.
+  class OpTest < Op
+    @pointer: JSONPointer
+
+    @value: untyped
+
+    # @param pointer [JSONPointer]
+    # @param value [JSON-like value]
+    def initialize: (JSONPointer pointer, untyped value) -> void
+
+    def name: () -> "test"
+  end
+
+  # A JSON Patch containing zero or more patch operations.
+  class JSONPatch
+    @ops: Array[Op]
+
+    # @param ops [Array<Op>?]
+    def initialize: (?Array[Op | Hash[String, untyped]]? ops) -> void
+
+    # @param pointer [String | JSONPointer]
+    # @param value [JSON-like value]
+    # @return [self]
+    def add: (JSONPointer | String pointer, untyped value) -> self
+
+    # @param pointer [String | JSONPointer]
+    # @return [self]
+    def remove: (JSONPointer | String pointer) -> self
+
+    # @param pointer [String | JSONPointer]
+    # @param value [JSON-like value]
+    # @return [self]
+    def replace: (JSONPointer | String pointer, untyped value) -> self
+
+    # @param from [String | JSONPointer]
+    # @param pointer [String | JSONPointer]
+    # @return [self]
+    def move: (JSONPointer | String from, JSONPointer | String pointer) -> self
+
+    # @param from [String | JSONPointer]
+    # @param pointer [String | JSONPointer]
+    # @return [self]
+    def copy: (JSONPointer | String from, JSONPointer | String pointer) -> self
+
+    # @param pointer [String | JSONPointer]
+    # @param value [JSON-like value]
+    # @return [self]
+    def test: (JSONPointer | String pointer, untyped value) -> self
+
+    # Apply this patch to JSON-like value _value_.
+    def apply: (untyped value) -> untyped
+
+    def to_a: () -> Array[untyped]
+
+    private
+
+    def ensure_pointer: (JSONPointer | String pointer, Symbol op, Integer index) -> JSONPointer
+                      
+    def build: (Array[Op | Hash[String, untyped]]) -> void
+             
+    def op_pointer: (Hash[String, untyped] obj, String key, String op, Integer index) -> JSONPointer
+
+    def op_value: (Hash[String, untyped] obj, String key, String op, Integer index) -> untyped
+  end
+end