json_p3 0.4.0 → 1.0.0

data/sig/json_p3/path/filter.rbs

@@ -0,0 +1,196 @@
+module JSONP3
+  module Path
+    # Base class for all filter expression nodes.
+    class Expression
+      @token: t_token
+
+      # @dynamic token
+      attr_reader token: t_token
+
+      def initialize: (t_token token) -> void
+
+      # Evaluate the filter expression in the given context.
+      def evaluate: (FilterContext _context) -> untyped
+                  
+      def to_s: () -> String
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+    end
+
+    # An expression that evaluates to true or false.
+    class FilterExpression < Expression
+      @expression: Expression
+
+      attr_reader expression: Expression
+
+      def initialize: (t_token token, Expression expression) -> void
+  
+      private
+
+      class Precedence
+        LOWEST: 1
+
+        LOGICAL_OR: 3
+
+        LOGICAL_AND: 4
+
+        PREFIX: 7
+      end
+
+      def to_canonical_string: (Expression expression, Integer parent_precedence) -> String
+    end
+
+    # Base class for expression literals.
+    class FilterExpressionLiteral < Expression
+      @value: untyped
+
+      attr_reader value: untyped
+
+      def initialize: (t_token token, untyped value) -> void
+    end
+
+    # Literal true or false.
+    class BooleanLiteral < FilterExpressionLiteral
+    end
+
+    # A double or single quoted string literal.
+    class StringLiteral < FilterExpressionLiteral
+    end
+
+    # A literal integer.
+    class IntegerLiteral < FilterExpressionLiteral
+    end
+
+    # A literal float
+    class FloatLiteral < FilterExpressionLiteral
+    end
+
+    # A literal null
+    class NullLiteral < FilterExpressionLiteral
+    end
+
+    # An expression prefixed with the logical not operator.
+    class LogicalNotExpression < Expression
+      @expression: Expression
+
+      attr_reader expression: Expression
+
+      def initialize: (t_token token, Expression expression) -> void
+    end
+
+    # Base class for expression with a left expression, operator and right expression.
+    class InfixExpression < Expression
+      @left: Expression
+
+      @right: Expression
+
+      attr_reader left: Expression
+
+      attr_reader right: Expression
+
+      def initialize: (t_token token, Expression left, Expression right) -> void
+    end
+
+    # A logical `&&` expression.
+    class LogicalAndExpression < InfixExpression
+    end
+
+    # A logical `||` expression.
+    class LogicalOrExpression < InfixExpression
+    end
+
+    # An `==` expression.
+    class EqExpression < InfixExpression
+    end
+
+    # A `!=` expression.
+    class NeExpression < InfixExpression
+    end
+
+    # A `<=` expression.
+    class LeExpression < InfixExpression
+    end
+
+    # A `>=` expression.
+    class GeExpression < InfixExpression
+    end
+
+    # A `<` expression.
+    class LtExpression < InfixExpression
+    end
+
+    # A `>` expression.
+    class GtExpression < InfixExpression
+    end
+
+    # Base class for all embedded filter queries
+    class QueryExpression < Expression
+      @query: Query
+
+      attr_reader query: Query
+
+      def initialize: (t_token token, Query query) -> void
+    end
+
+    # An embedded query starting at the current node.
+    class RelativeQueryExpression < QueryExpression
+    end
+
+    # An embedded query starting at the root node.
+    class AbsoluteQueryExpression < QueryExpression
+    end
+
+    # A filter function call.
+    class FunctionExpression < Expression
+      @name: String
+
+      @func: FunctionExtension
+
+      @args: Array[Expression]
+
+      attr_reader name: String
+
+      attr_reader func: FunctionExtension
+
+      attr_reader args: Array[Expression]
+
+      # @param name [String]
+      # @param args [Array<Expression>]
+      def initialize: (t_token token, String name, JSONP3::Path::FunctionExtension func, Array[Expression] args) -> void
+
+      private
+
+      # @param func [Proc]
+      # @param args [Array<Object>]
+      # @return [Array<Object>]
+      def unpack_node_lists: (FunctionExtension func, Array[untyped] args) -> Array[untyped]
+    end
+
+    def self.truthy?: (untyped obj) -> (true | false)
+
+    def self.eq?: (untyped left, untyped right) -> (false | true)
+
+    def self.lt?: (untyped left, untyped right) -> (true | false)
+
+    # Contextual information and data used for evaluating a filter expression.
+    class FilterContext
+      @env: Environment
+
+      @current: untyped
+
+      @root: untyped
+
+      attr_reader env: Environment
+
+      attr_reader current: untyped
+
+      attr_reader root: untyped
+
+      def initialize: (Environment env, untyped current, untyped root) -> void
+    end
+  end
+end

data/sig/json_p3/path/function.rbs

@@ -0,0 +1,94 @@
+module JSONP3
+  module Path
+    def self.map_iregexp: (String pattern) -> String
+                        
+    # Base class for all filter functions.
+    class FunctionExtension
+      ARG_TYPES: Array[Symbol]
+      RETURN_TYPE: Symbol
+
+      def call: (*untyped _args, **untyped _kwargs) -> untyped
+    end
+
+    # The standard `count` function.
+    class Count < FunctionExtension
+      ARG_TYPES: Array[Symbol]
+      RETURN_TYPE: Symbol
+      def call: (NodeList node_list) -> untyped
+    end
+
+    # The standard `count` function.
+    class Length < FunctionExtension
+      ARG_TYPES: Array[Symbol]
+      RETURN_TYPE: Symbol
+      def call: (untyped obj) -> untyped
+    end
+
+    # The standard `match` function.
+    class Match < FunctionExtension
+      @cache_size: Integer
+
+      @raise_errors: (true | false)
+
+      @cache: LRUCache
+
+      ARG_TYPES: ::Array[Symbol]
+
+      RETURN_TYPE: Symbol
+
+      # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
+      #   zero or negative to disable the cache.
+      # @param raise_errors [Boolean] if _false_ (the default), return _false_ when this
+      #   function causes a RegexpError instead of raising the exception.
+      def initialize: (?::Integer cache_size, ?raise_errors: bool) -> void
+
+      # @param value [String]
+      # @param pattern [String]
+      # @return Boolean
+      def call: (untyped value, untyped pattern) -> untyped
+
+      private
+
+      def full_match: (String pattern) -> String
+    end
+
+    # The standard `search` function.
+    class Search < FunctionExtension
+      @cache_size: Integer
+
+      @raise_errors: (true | false)
+
+      @cache: LRUCache
+
+      ARG_TYPES: ::Array[Symbol]
+
+      RETURN_TYPE: Symbol
+
+      # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
+      #   zero or negative to disable the cache.
+      # @param raise_errors [Boolean] if _false_ (the default), return _false_ when this
+      #   function causes a RegexpError instead of raising the exception.
+      def initialize: (?::Integer cache_size, ?raise_errors: bool) -> void
+
+      # @param value [String]
+      # @param pattern [String]
+      # @return Boolean
+      def call: (untyped value, untyped pattern) -> untyped
+    end
+
+    # The standard `value` function.
+    class Value < FunctionExtension
+      ARG_TYPES: ::Array[Symbol]
+
+      RETURN_TYPE: Symbol
+
+      def call: (NodeList node_list) -> untyped
+    end
+  end
+end
+
+
+
+
+    
+

data/sig/json_p3/path/lexer.rbs

@@ -0,0 +1,62 @@
+type t_token = [t_token_kind, Integer, Integer]
+         
+type t_token_kind = (
+  :token_and |
+  :token_asterisk |
+  :token_at |
+  :token_colon |
+  :token_comma |
+  :token_dollar |
+  :token_dot |
+  :token_double_dot |
+  :token_double_quoted_esc_string |
+  :token_double_quoted_string |
+  :token_eoi |
+  :token_eq |
+  :token_error |
+  :token_false |
+  :token_float |
+  :token_function |
+  :token_ge |
+  :token_gt |
+  :token_index |
+  :token_int |
+  :token_lbracket |
+  :token_le |
+  :token_lparen |
+  :token_lt |
+  :token_name |
+  :token_ne |
+  :token_not |
+  :token_null |
+  :token_or |
+  :token_question |
+  :token_rbracket |
+  :token_rparen |
+  :token_single_quoted_esc_string |
+  :token_single_quoted_string |
+  :token_true |
+  :token_trivia
+) 
+
+module JSONP3
+  module Path
+    RE_FLOAT: Regexp
+    RE_INDEX: Regexp
+    RE_INT: Regexp
+
+    def self.tokenize: (String query) -> Array[t_token]
+                
+    def self.scan_string_literal: (String query, Integer byte, Integer pos) -> [t_token, Integer]
+                
+    def self.name_first?: (Integer ch) -> bool
+                        
+    def self.name_ch?: (Integer ch) -> bool
+                    
+    def self.number_ch?: (Integer ch) -> bool
+                      
+    def self.trivia?: (Integer ch) -> bool
+                    
+    def self.get_token_value: (t_token token, String query) -> String
+  end
+end

data/sig/json_p3/path/node.rbs

@@ -0,0 +1,46 @@
+type location_item = String | Integer | Array[location_item]
+
+module JSONP3
+  module Path
+    # A JSON-like value and its location.
+    class Node
+      @value: untyped
+
+      @location: Array[location_item]
+
+      @root: untyped
+
+      # @dynamic value, location, root
+      attr_reader value: untyped
+
+      # @dynamic value, location, root
+      attr_reader location: Array[location_item]
+
+      # @dynamic value, location, root
+      attr_reader root: untyped
+
+      # @param value [JSON-like] the value at this node.
+      # @param location [Array<String | Integer | Array<String | Integer>>] the sequence of
+      #   names and/or indices leading to _value_ in _root_.
+      # @param root [JSON-like] the root value containing _value_ at _location_.
+      def initialize: (untyped value, Array[location_item] location, untyped root) -> void
+
+      # Return the normalized path to this node.
+      # @return [String] the normalized path.
+      def path: () -> ::String
+
+      # Return a new node that is a child of this node.
+      # @param value the JSON-like value at the new node.
+      # @param key [Integer, String] the array index or hash key associated with _value_.
+      def new_child: (untyped value, String | Integer key) -> Node
+
+      def to_s: () -> ::String
+    end
+
+    # An array of JSONPathNode instances. We use this internally to differentiate
+    # arrays of Nodes and arrays of data values, which is required when calling
+    # filter functions expecting nodes as arguments. It is just an array though.
+    class NodeList < Array[Node]
+    end
+  end
+end

data/sig/json_p3/path/parser.rbs

@@ -0,0 +1,92 @@
+module JSONP3
+  # JSONPath
+  module Path
+    # JSONPath query parser.
+    class Parser
+      @env: Environment
+
+      @query: String
+
+      @tokens: Array[t_token]
+
+      @pos: Integer
+
+      @eoi: t_token
+
+      class Precedence
+        LOWEST: 1
+        LOGICAL_OR: 3
+        LOGICAL_AND: 4
+        RELATIONAL: 5
+        PREFIX: 7
+      end
+
+      PRECEDENCES: Hash[Symbol, Integer]
+
+      BINARY_OPERATORS: Hash[Symbol, String]
+
+      COMPARISON_OPERATORS: Set[Symbol]
+
+      # @param env [Environment]
+      # @param query [String]
+      # @param tokens [Array[t_token]]
+      def initialize: (Environment env, String query, Array[t_token] tokens) -> void
+
+      def next: () -> t_token
+
+      def eat: (t_token_kind kind, ?String? message) -> t_token
+
+      def skip: (t_token_kind kind) -> void
+
+      def kind: () -> t_token_kind
+
+      def peek: () -> t_token
+
+      def parse: () -> Array[Segment]
+
+      def parse_segments: () -> Array[Segment]
+
+      def parse_descendant_selectors: () -> Array[Selector]
+
+      def parse_shorthand_selector: () -> Selector
+
+      def parse_bracketed_selectors: () -> Array[Selector]
+
+      def parse_index_or_slice: () -> Selector
+
+      def parse_slice_selector: () -> Selector
+
+      def parse_filter_selector: () -> Selector
+
+      def parse_filter_expression: (Integer precedence) -> Expression
+
+      def parse_function_expression: () -> Expression
+
+      def parse_primary: () -> Expression
+
+      def parse_grouped_expression: () -> Expression
+
+      def parse_prefix_expression: () -> Expression
+
+      def parse_infix_expression: (Expression left) -> Expression
+
+      def parse_integer_literal: () -> Expression
+                               
+      def parse_float_literal: () -> Expression
+
+      def parse_absolute_query: () -> Expression
+
+      def parse_relative_query: () -> Expression
+
+      def parse_i_json_int: (t_token token) -> Integer
+
+      def throw_for_not_compared: (Expression expression) -> void
+
+      def throw_for_non_comparable: (Expression expression) -> void
+
+      def validate_function_signature: (String name, FunctionExtension func, Array[Expression] args, t_token token) -> void
+
+      def function_return_type: (Expression expression) -> (nil | Symbol)
+    end
+  end
+end

data/sig/json_p3/path/query.rbs

@@ -0,0 +1,47 @@
+module JSONP3
+  module Path
+    # A compiled JSONPath expression ready to be applied to JSON-like values.
+    class Query
+      @env: JSONP3::Path::Environment
+
+      @segments: Array[JSONP3::Path::Segment]
+
+      def initialize: (JSONP3::Path::Environment env, Array[JSONP3::Path::Segment] segments) -> void
+
+      def to_s: () -> ::String
+
+      # Apply this JSONPath expression to JSON-like value _root_.
+      # @param root [Array, Hash, String, Integer, nil] the root JSON-like value to apply this query to.
+      # @return [Array<JSONPathNode>] the sequence of nodes found while applying this query to _root_.
+      def find: (untyped root) -> JSONP3::Path::NodeList
+
+      alias apply find
+
+      # Apply this JSONPath expression to JSON-like value _root_.
+      # @param root [Array, Hash, String, Integer, nil] the root JSON-like value to apply this query to.
+      # @return [Enumerable<JSONPathNode>] the sequence of nodes found while applying this query to _root_.
+      def find_enum: (untyped root) ->Enumerable[JSONP3::Path::Node]
+
+      # Return the first node from applying this JSONPath expression to JSON-like value _root_.
+      # @param root [Array, Hash, String, Integer, nil] the root JSON-like value to apply this query to.
+      # @return [JSONPathNode | nil] the first available node or nil if there were no matches.
+      def match: (untyped root) -> (JSONP3::Path::Node | nil)
+
+      # Return `true` if this query results in at least one node, or `false` otherwise.
+      # @param root [Array, Hash, String, Integer, nil] the root JSON-like value to apply this query to.
+      # @return [bool] `true` if this query results in at least one node, or `false` otherwise.
+      def match?: (untyped root) -> bool
+
+      # Return the first node from applying this JSONPath expression to JSON-like value _root_.
+      # @param root [Array, Hash, String, Integer, nil] the root JSON-like value to apply this query to.
+      # @return [JSONPathNode | nil] the first available node or nil if there were no matches.
+      def first: (untyped root) -> (JSONP3::Path::Node | nil)
+
+      # Return _true_ if this JSONPath expression is a singular query.
+      def singular?: () -> (false | true)
+
+      # Return _true_ if this JSONPath expression has no segments.
+      def empty?: () -> (false | true)
+    end
+  end
+end

data/sig/json_p3/path/segment.rbs

@@ -0,0 +1,54 @@
+module JSONP3
+  module Path
+    # Base class for all JSONPath segments.
+    class Segment
+      @env: JSONP3::Path::Environment
+
+      @token: t_token
+
+      @selectors: Array[Selector]
+
+      # @dynamic token, selectors
+      attr_reader token: t_token
+
+      # @dynamic token, selectors
+      attr_reader selectors: Array[Selector]
+
+      def initialize: (JSONP3::Path::Environment env, t_token token, Array[Selector] selectors) -> void
+
+      # Select the children of each node in _nodes_.
+      # @return [Array<Node>]
+      def resolve: (Array[Node] _nodes) -> Array[Node]
+
+      # Select the children of each node in _nodes_.
+      # @return [Enumerable<Node>]
+      def resolve_enum: (Enumerable[Node] _nodes) -> Enumerable[Node]
+    end
+
+    # The child selection segment.
+    class ChildSegment < Segment
+      def to_s: () -> ::String
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+    end
+
+    # The descendent segment
+    class DescendantSegment < Segment
+      def to_s: () -> ::String
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+
+      def visit: (Node node, ?::Integer depth) -> Array[Node]
+
+      def visit_enum: (Node node, ?::Integer depth) -> Enumerable[Node]
+    end
+  end
+end

data/sig/json_p3/path/selector.rbs

@@ -0,0 +1,100 @@
+module JSONP3
+  module Path
+    # Base class for all JSONPath selectors
+    class Selector
+      @env: JSONP3::Path::Environment
+
+      @token: t_token
+
+      # @dynamic token
+      attr_reader token: t_token
+
+      def initialize: (Environment env, t_token token) -> void
+
+      # Apply this selector to _node_.
+      # @return [Array<JSONPathNode>]
+      def resolve: (Node _node) -> Array[Node]
+
+      # Apply this selector to _node_.
+      # @return [Enumerable<JSONPathNode>]
+      def resolve_enum: (Node node) -> Enumerable[Node]
+
+      # Return true if this selector is a singular selector.
+      def singular?: () -> (false | true)
+                   
+      def to_s: () -> String
+
+      def ==: (untyped other) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+    end
+
+    # The name selector select values from hashes given a key.
+    class NameSelector < Selector
+      @name: String
+
+      # @dynamic name
+      attr_reader name: untyped
+
+      def initialize: (Environment env, t_token token, String name) -> void      
+    end
+
+    # This non-standard name selector selects values from hashes given a string or
+    # symbol key.
+    class SymbolNameSelector < NameSelector
+      @sym: String
+
+      def initialize: (Environment env, t_token token, String name) -> void
+    end
+
+    # The index selector selects values from arrays given an index.
+    class IndexSelector < Selector
+      @index: Integer
+
+      # @dynamic index
+      attr_reader index: Integer
+
+      def initialize: (Environment env, t_token token, Integer index) -> void
+
+      private
+
+      def normalize: (Integer index, Integer length) -> Integer
+    end
+
+    # The wildcard selector selects all elements from an array or values from a hash.
+    class WildcardSelector < Selector
+    end
+
+    # The slice selector selects a range of elements from an array.
+    class SliceSelector < Selector
+      @start: (Integer | nil)
+
+      @stop: (Integer | nil)
+
+      @step: Integer
+
+      # @dynamic start, stop, step
+      attr_reader start: (Integer | nil)
+
+      # @dynamic start, stop, step
+      attr_reader stop: (Integer | nil)
+
+      # @dynamic start, stop, step
+      attr_reader step: Integer
+
+      def initialize: (Environment env, t_token token, (Integer | nil) start, (Integer | nil) stop, (Integer | nil) step) -> void
+    end
+
+    # Select array elements or hash values according to a filter expression.
+    class FilterSelector < Selector
+      @expression: Expression
+
+      # @dynamic expression
+      attr_reader expression: Expression
+
+      def initialize: (Environment env, t_token token, Expression expression) -> void
+    end
+  end
+end

data/sig/json_p3/path/serialize.rbs

@@ -0,0 +1,9 @@
+module JSONP3
+  module Path
+    TRANS: Hash[String, String]
+
+    # Return _value_ formatted as a canonical string literal.
+    # @param value [String]
+    def self.canonical_string: (untyped value) -> ::String
+  end
+end