json_path_rfc9535 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 341631a563a6872bcf0f04f58fdb547a5a17500f3f7fae04ba29ada044c17dbd
+  data.tar.gz: '0669414a8c33cd4ddfd67f2e330d72783ec862ba1a26573053a5bbf372a6b26e'
+SHA512:
+  metadata.gz: c355da298d64c50f35f59a76bbff44b2511de1dafbf65181a078db74909433396dd86f803ecd1b821ce0bf4327264786298d7189e5c7ee37777bf35e53dacc8e
+  data.tar.gz: f8e4f5e8a131adb0b1d88b9a820218687db2a146fea1a4ef91e33adb461b1d299285895c5fde88554f6ac14d87b7e86235ed97734253f397e06e741a5f270b13

data/.rubocop.yml

@@ -0,0 +1,455 @@
+AllCops:
+  NewCops: enable
+  Exclude:
+    - 'bin/**'
+
+Gemspec/DeprecatedAttributeAssignment:
+  Enabled: true
+
+Gemspec/DevelopmentDependencies:
+  Enabled: true
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+Layout/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Layout/BeginEndAlignment:
+  EnforcedStyleAlignWith: begin
+
+Layout/BlockAlignment:
+  EnforcedStyleAlignWith: start_of_block
+
+Layout/CommentIndentation:
+  AllowForAlignment: true
+
+Layout/EmptyLineAfterMultilineCondition:
+  Enabled: true
+
+Layout/EndOfLine:
+  EnforcedStyle: lf
+
+Layout/ExtraSpacing:
+  AllowForAlignment: true
+  AllowBeforeTrailingComments: true
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+  EnforcedLastArgumentHashStyle: ignore_implicit
+
+Layout/LineContinuationLeadingSpace:
+  Enabled: true
+
+Layout/LineContinuationSpacing:
+  Enabled: true
+
+Layout/LineEndStringConcatenationIndentation:
+  Enabled: true
+
+Layout/MultilineArrayLineBreaks:
+  Enabled: true
+
+Layout/MultilineAssignmentLayout:
+  Enabled: true
+  EnforcedStyle: same_line
+
+Layout/MultilineHashKeyLineBreaks:
+  Enabled: true
+
+Layout/MultilineMethodArgumentLineBreaks:
+  Enabled: true
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented_relative_to_receiver
+
+Layout/SingleLineBlockChain:
+  Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: no_space
+
+Layout/SpaceAroundOperators:
+  EnforcedStyleForExponentOperator: space
+
+Layout/SpaceBeforeBrackets:
+  Enabled: true
+
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Layout/TrailingWhitespace:
+  AllowInHeredoc: true
+
+Lint/AmbiguousAssignment:
+  Enabled: true
+
+Lint/AmbiguousOperatorPrecedence:
+  Enabled: true
+
+Lint/AmbiguousRange:
+  Enabled: true
+  RequireParenthesesForMethodChains: true
+
+Lint/AssignmentInCondition:
+  AllowSafeAssignment: false
+
+Lint/ConstantOverwrittenInRescue:
+  Enabled: true
+
+Lint/DeprecatedConstants:
+  Enabled: true
+
+Lint/DuplicateBranch:
+  Enabled: true
+  IgnoreLiteralBranches: true
+  IgnoreConstantBranches: true
+
+Lint/DuplicateMagicComment:
+  Enabled: true
+
+Lint/DuplicateRegexpCharacterClassElement:
+  Enabled: true
+
+Lint/EmptyBlock:
+  Enabled: true
+
+Lint/EmptyClass:
+  Enabled: true
+  AllowComments: true
+
+Lint/EmptyInPattern:
+  Enabled: true
+
+Lint/HeredocMethodCallPosition:
+  Enabled: true
+
+Lint/IncompatibleIoSelectWithFiberScheduler:
+  Enabled: false
+
+Lint/LambdaWithoutLiteralBlock:
+  Enabled: true
+
+Lint/NoReturnInBeginEndBlocks:
+  Enabled: true
+
+Lint/NonAtomicFileOperation:
+  Enabled: true
+
+Lint/NumberedParameterAssignment:
+  Enabled: true
+
+Lint/OrAssignmentToConstant:
+  Enabled: true
+
+Lint/RedundantDirGlobSort:
+  Enabled: true
+
+Lint/RedundantSplatExpansion:
+  AllowPercentLiteralArrayArgument: false
+
+Lint/RefinementImportMethods:
+  Enabled: true
+
+Lint/RequireRangeParentheses:
+  Enabled: true
+
+Lint/RequireRelativeSelfPath:
+  Enabled: true
+
+Lint/SymbolConversion:
+  Enabled: true
+
+Lint/ToEnumArguments:
+  Enabled: true
+
+Lint/TripleQuotes:
+  Enabled: true
+
+Lint/UnexpectedBlockArity:
+  Enabled: true
+
+Lint/UnmodifiedReduceAccumulator:
+  Enabled: true
+
+Lint/UnusedBlockArgument:
+  AutoCorrect: false
+
+Lint/UnusedMethodArgument:
+  AutoCorrect: false
+
+Lint/UselessRescue:
+  Enabled: true
+
+Lint/UselessRuby2Keywords:
+  Enabled: true
+
+Metrics:
+  Enabled: false
+
+Naming/BlockForwarding:
+  Enabled: true
+
+Naming/InclusiveLanguage:
+  Enabled: false
+
+Security/CompoundHash:
+  Enabled: true
+
+Security/Eval:
+  Enabled: false
+
+Security/IoMethods:
+  Enabled: true
+
+Security/YAMLLoad:
+  Enabled: false
+
+Style/AccessorGrouping:
+  EnforcedStyle: separated
+
+Style/ArgumentsForwarding:
+  Enabled: false
+
+Style/ArrayIntersect:
+  Enabled: true
+
+Style/AutoResourceCleanup:
+  Enabled: true
+
+Style/CollectionCompact:
+  Enabled: true
+
+Style/CollectionMethods:
+  Enabled: true
+
+Style/ComparableClamp:
+  Enabled: true
+
+Style/ConcatArrayLiterals:
+  Enabled: true
+
+Style/DirEmpty:
+  Enabled: true
+
+Style/DocumentDynamicEvalDefinition:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DocumentationMethod:
+  Enabled: false
+
+Style/DoubleNegation:
+  EnforcedStyle: forbidden
+
+Style/EmptyHeredoc:
+  Enabled: true
+
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+Style/EndlessMethod:
+  Enabled: true
+  EnforcedStyle: disallow
+
+Style/EnvHome:
+  Enabled: true
+
+Style/FetchEnvVar:
+  Enabled: false
+
+Style/FileEmpty:
+  Enabled: true
+
+Style/FileRead:
+  Enabled: true
+
+Style/FileWrite:
+  Enabled: true
+
+Style/FormatString:
+  EnforcedStyle: percent
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/HashConversion:
+  Enabled: true
+
+Style/HashExcept:
+  Enabled: true
+
+Style/HashSyntax:
+  EnforcedShorthandSyntax: never
+
+Style/IfWithBooleanLiteralBranches:
+  Enabled: true
+
+Style/ImplicitRuntimeError:
+  Enabled: true
+
+Style/InPatternThen:
+  Enabled: true
+
+Style/IpAddresses:
+  Enabled: true
+
+Style/MagicCommentFormat:
+  Enabled: true
+
+Style/MapCompactWithConditionalBlock:
+  Enabled: true
+
+Style/MapToHash:
+  Enabled: true
+
+Style/MapToSet:
+  Enabled: true
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  EnforcedStyle: omit_parentheses
+  AllowParenthesesInMultilineCall: true
+  AllowParenthesesInChaining: true
+  AllowParenthesesInCamelCaseMethod: true
+
+Style/MethodDefParentheses:
+  EnforcedStyle: require_no_parentheses_except_multiline
+
+Style/MinMaxComparison:
+  Enabled: true
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/MultilineInPatternThen:
+  Enabled: true
+
+Style/NegatedIfElseCondition:
+  Enabled: true
+
+Style/NestedFileDirname:
+  Enabled: true
+
+Style/NestedParenthesizedCalls:
+  Enabled: false
+
+Style/NilLambda:
+  Enabled: true
+
+Style/NonNilCheck:
+  Enabled: false
+
+Style/NumberedParameters:
+  Enabled: true
+  EnforcedStyle: disallow
+
+Style/NumberedParametersLimit:
+  Enabled: true
+
+Style/ObjectThen:
+  Enabled: true
+
+Style/OpenStructUse:
+  Enabled: false
+
+Style/OperatorMethodCall:
+  Enabled: true
+
+Style/OptionHash:
+  Enabled: true
+
+Style/QuotedSymbols:
+  Enabled: true
+
+Style/RedundantArgument:
+  Enabled: false
+
+Style/RedundantConstantBase:
+  Enabled: false
+
+Style/RedundantDoubleSplatHashBraces:
+  Enabled: true
+
+Style/RedundantEach:
+  Enabled: true
+
+Style/RedundantException:
+  Enabled: false
+
+Style/RedundantHeredocDelimiterQuotes:
+  Enabled: true
+
+Style/RedundantInitialize:
+  Enabled: true
+
+Style/RedundantParentheses:
+  Enabled: false
+
+Style/RedundantSelfAssignmentBranch:
+  Enabled: true
+
+Style/RedundantStringEscape:
+  Enabled: true
+
+Style/RegexpLiteral:
+  EnforcedStyle: percent_r
+
+Style/ReturnNil:
+  Enabled: true
+
+Style/SelectByRegexp:
+  Enabled: true
+
+Style/SingleLineMethods:
+  AllowIfMethodIsEmpty: false
+
+Style/StaticClass:
+  Enabled: true
+
+Style/StringChars:
+  Enabled: true
+
+Style/StringHashKeys:
+  Enabled: false
+
+Style/SwapValues:
+  Enabled: true
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/TernaryParentheses:
+  EnforcedStyle: require_parentheses_when_complex
+  AllowSafeAssignment: false
+
+Style/TopLevelMethodDefinition:
+  Enabled: true
+
+Style/TrailingCommaInArguments:
+  Enabled: true
+  EnforcedStyleForMultiline: no_comma
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: no_comma
+
+Style/TrailingCommaInBlockArgs:
+  Enabled: true
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: no_comma
+
+Style/UnlessLogicalOperators:
+  EnforcedStyle: forbid_logical_operators
+
+Style/WordArray:
+  EnforcedStyle: brackets
+
+Style/YodaCondition:
+  Enabled: true
+  EnforcedStyle: forbid_for_all_comparison_operators

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+<!--[//]: # (
+## <Release number> <Date YYYY-MM-DD>
+### Breaking changes
+### Deprecations
+### New features
+### Bug fixes
+)-->
+
+## 1.0.0 2024-09-09
+
+First public release. Refer to [README.md](README.md) for the full documentation.

data/README.md

@@ -0,0 +1,126 @@
+# Json Path RFC 9535
+
+A Ruby implementation of RFC 9535.
+
+Like XPath is a query language for XML, JsonPath is a query language for JSON. This gem aims to be an implementation of RFC 9535. Unlike tha original JsonPath description (http://goessner.net/articles/JsonPath/), RFC 9535 is strictly normative, which ideally should leave open fewer doors for inconsistencies.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'json_path_rfc9535', '~> 1.0'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or you can install the gem on its own:
+
+```bash
+gem install json_path_rfc9535
+```
+
+## Usage
+
+Parse the Json into a `JsonPath::Doc` instance...
+
+```ruby
+doc = JsonPath::Doc(<<~JSON)
+{ 
+  "store": {
+    "book": [
+      { 
+        "category": "reference",
+        "author": "Nigel Rees",
+        "title": "Sayings of the Century",
+        "price": 8.95
+      },
+      { 
+        "category": "fiction",
+        "author": "Evelyn Waugh",
+        "title": "Sword of Honour",
+        "price": 12.99
+      },
+      { 
+        "category": "fiction",
+        "author": "Herman Melville",
+        "title": "Moby Dick",
+        "isbn": "0-553-21311-3",
+        "price": 8.99
+      },
+      { 
+        "category": "fiction",
+        "author": "J. R. R. Tolkien",
+        "title": "The Lord of the Rings",
+        "isbn": "0-395-19395-8",
+        "price": 22.99
+      }
+    ],
+    "bicycle": {
+      "color": "red",
+      "price": 399
+    }
+  }
+}
+JSON
+```
+
+... and then query it.
+
+```ruby
+doc.query('$.store.bicycle.color')
+```
+
+The returned object has methods to retrieve the values or the paths of all the retrieved nodes:
+
+```ruby
+doc.query('$.store.book.*.category').values
+# => ["reference", "fiction", "fiction", "fiction"]
+doc.query('$.store.book.*.category').paths
+# => ["$['store']['book'][0]['category']", "$['store']['book'][1]['category']", "$['store']['book'][2]['category']", "$['store']['book'][3]['category']"]
+```
+
+You can also query it further:
+
+```ruby
+results = doc.query('$.store.book[?(@.price > 10)]')
+results.paths
+# => ["$['store']['book'][1]", "$['store']['book'][3]"]
+results.query('$.author').values
+# => ["Evelyn Waugh", "J. R. R. Tolkien"]
+```
+
+This gem implements most of RFC 9535, with the exception of [function extensions](https://datatracker.ietf.org/doc/html/rfc9535#name-function-extensions) and the related [type system](https://datatracker.ietf.org/doc/html/rfc9535#name-type-system-for-function-ex). It also relies on the underlying Ruby interpreter for string evaluation, meaning that characters don't need to be double-escaped.
+
+## Plans for future development
+
+- Function extensions
+  - Function extensions type system
+
+## Version numbers
+
+Json Path RFC 9535 loosely follows [Semantic Versioning](https://semver.org/), with a hard guarantee that breaking changes to the public API will always coincide with an increase to the `MAJOR` number.
+
+Version numbers are in three parts: `MAJOR.MINOR.PATCH`.
+
+- Breaking changes to the public API increment the `MAJOR`. There may also be changes that would otherwise increase the `MINOR` or the `PATCH`.
+- Additions, deprecations, and "big" non breaking changes to the public API increment the `MINOR`. There may also be changes that would otherwise increase the `PATCH`.
+- Bug fixes and "small" non breaking changes to the public API increment the `PATCH`.
+
+Notice that any feature deprecated by a minor release can be expected to be removed by the next major release.
+
+## Changelog
+
+Full list of changes in [CHANGELOG.md](CHANGELOG.md)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/moku-io/json_path_rfc9535.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/json_path/doc.rb

@@ -0,0 +1,27 @@
+require 'json'
+require_relative 'nodes'
+require_relative 'path'
+require_relative 'node_list'
+
+module JsonPath
+  class Doc
+    attr_reader :root_node
+
+    def initialize json_string, parse_json: json_string.is_a?(String)
+      json = (parse_json ? JSON.parse(json_string) : json_string)
+      @root_node = Nodes.parse '$', json
+    end
+
+    def query json_path
+      json_path = Path.new json_path
+
+      json_path
+        .apply(root_node)
+        .then { NodeList.new _1 }
+    end
+
+    def value
+      root_node.value
+    end
+  end
+end

data/lib/json_path/error.rb

@@ -0,0 +1,4 @@
+module JsonPath
+  class Error < StandardError
+  end
+end

data/lib/json_path/multiple_values_returned_by_singular_query.rb

@@ -0,0 +1,6 @@
+require_relative 'error'
+
+module JsonPath
+  class MultipleValuesReturnedBySingularQuery < Error
+  end
+end

data/lib/json_path/node_list.rb

@@ -0,0 +1,27 @@
+require_relative 'path'
+
+module JsonPath
+  class NodeList
+    attr_reader :nodes
+
+    def initialize nodes
+      @nodes = nodes
+    end
+
+    def query json_path
+      json_path = Path.new json_path
+
+      nodes
+        .flat_map { json_path.apply _1 }
+        .then { self.class.new _1 }
+    end
+
+    def values
+      nodes.map(&:value)
+    end
+
+    def paths
+      nodes.map(&:path)
+    end
+  end
+end

data/lib/json_path/nodes/array.rb

@@ -0,0 +1,19 @@
+module JsonPath
+  module Nodes
+    class Array < Base
+      alias elements children
+
+      def initialize path, values
+        super path
+        @children = values
+                      .map.with_index do |value, i|
+                        Nodes.parse "#{path}[#{i}]", value
+                      end
+      end
+
+      def value
+        elements.map(&:value)
+      end
+    end
+  end
+end

data/lib/json_path/nodes/base.rb

@@ -0,0 +1,13 @@
+module JsonPath
+  module Nodes
+    class Base
+      attr_reader :path
+      attr_reader :children
+
+      def initialize path
+        @path = path
+        @children = []
+      end
+    end
+  end
+end

data/lib/json_path/nodes/false.rb

@@ -0,0 +1,9 @@
+module JsonPath
+  module Nodes
+    class False < Base
+      def value
+        false
+      end
+    end
+  end
+end

data/lib/json_path/nodes/null.rb

@@ -0,0 +1,9 @@
+module JsonPath
+  module Nodes
+    class Null < Base
+      def value
+        nil
+      end
+    end
+  end
+end

data/lib/json_path/nodes/number.rb

@@ -0,0 +1,12 @@
+module JsonPath
+  module Nodes
+    class Number < Base
+      attr_reader :value
+
+      def initialize path, value
+        super path
+        @value = value
+      end
+    end
+  end
+end

data/lib/json_path/nodes/object.rb

@@ -0,0 +1,19 @@
+module JsonPath
+  module Nodes
+    class Object < Base
+      attr_reader :hash
+
+      def initialize path, hash
+        super path
+        @hash = hash.to_h do |key, value|
+          [key, Nodes.parse("#{path}['#{key}']", value)]
+        end
+        @children = self.hash.values
+      end
+
+      def value
+        hash.transform_values(&:value)
+      end
+    end
+  end
+end

data/lib/json_path/nodes/string.rb

@@ -0,0 +1,12 @@
+module JsonPath
+  module Nodes
+    class String < Base
+      attr_reader :value
+
+      def initialize path, value
+        super path
+        @value = value
+      end
+    end
+  end
+end

data/lib/json_path/nodes/true.rb

@@ -0,0 +1,9 @@
+module JsonPath
+  module Nodes
+    class True < Base
+      def value
+        true
+      end
+    end
+  end
+end

data/lib/json_path/nodes.rb

@@ -0,0 +1,27 @@
+require_relative 'nodes/base'
+Dir["#{__dir__}/nodes/**"].each { |filename| require_relative filename }
+
+module JsonPath
+  module Nodes
+    def self.parse path, value
+      case value
+      when nil
+        Null.new path
+      when true
+        True.new path
+      when false
+        False.new path
+      when ::String
+        String.new path, value
+      when Numeric
+        Number.new path, value
+      when ::Array
+        Array.new path, value
+      when Hash
+        Object.new path, value
+      else
+        raise UnrecognizedNode, "JSON value expected, #{value.class} found"
+      end
+    end
+  end
+end

data/lib/json_path/parser/core.rb

@@ -0,0 +1,75 @@
+require 'parslet'
+
+module JsonPath
+  module Parser
+    class Core < Parslet::Parser
+      # Never matches
+      rule(:none) { match('').absent? }
+      # Always matches, but doesn't consume any input
+      rule(:empty) { str('') }
+
+      def many parser
+        parser.repeat
+      end
+
+      def some parser
+        parser.repeat 1
+      end
+
+      rule(:digit) { match('[0-9]') }
+      rule(:digits) { digit.repeat(1) }
+      rule(:double_quoted_string_char) { match('[^\\\\"]') | str('\\\\') | str('\\"') }
+      rule(:single_quoted_string_char) { match("[^\\\\']") | str('\\\\') | str("\\'") }
+      rule(:whitespace) { match('[\s]').repeat }
+
+      rule(:int) { str('-').maybe >> digits }
+      rule :num do
+        int >>
+          (str('.') >> digits).maybe >>
+          (str('e') >> (str('-') | str('+')).maybe >> digits).maybe
+      end
+
+      rule(:double_quoted_string) { token(str('"') >> many(double_quoted_string_char).as(:string) >> str('"')) }
+      rule(:single_quoted_string) { token(str("'") >> many(single_quoted_string_char).as(:string) >> str("'")) }
+
+      rule(:true_constant) { symbol('true') }
+      rule(:false_constant) { symbol('false') }
+      rule(:integer) { token(int) }
+      rule(:number) { token(num) }
+      rule(:string) { double_quoted_string | single_quoted_string }
+
+      def symbol string
+        token(str(string))
+      end
+
+      def many_separated parser, separator_parser
+        some_separated(parser, separator_parser).maybe
+      end
+
+      def some_separated parser, separator_parser
+        parser >> many(separator_parser >> parser)
+      end
+
+      def any_unless parser
+        parser.absent? >> any
+      end
+
+      def any_until parser, prefix_name=nil
+        prefix_parser = some(any_unless(parser))
+        prefix_parser = prefix_parser.as(prefix_name) if prefix_name.present?
+        prefix_parser
+      end
+
+    protected
+
+      # Takes a block which needs to be a predicate over strings
+      def predicate parser
+        parser.capture(:input) >> dynamic { |_, c| yield(c.captures[:input].to_s) ? empty : none }
+      end
+
+      def token parser
+        whitespace.maybe >> parser >> whitespace
+      end
+    end
+  end
+end

data/lib/json_path/parser/raw_parser.rb

@@ -0,0 +1,73 @@
+require_relative 'core'
+
+module JsonPath
+  module Parser
+    class RawParser < Core
+      rule(:jsonpath_query) { root_identifier >> many(segment).as(:segments) }
+      root :jsonpath_query
+
+      rule(:root_identifier) { str('$') }
+      rule(:current_node_identifier) { str('@') }
+
+      # Selectors
+      rule(:selector) { name_selector | wildcard_selector | slice_selector | index_selector | filter_selector }
+      rule(:name_selector) { string.as(:name) }
+      rule(:wildcard_selector) { str('*').as(:wildcard) }
+      rule(:index_selector) { int.as(:index) }
+      rule :slice_selector do
+        integer.maybe.as(:start) >>
+          str(':') >> whitespace >>
+          integer.maybe.as(:end) >>
+          (str(':') >> whitespace >> integer.maybe.as(:step)).maybe
+      end
+      rule(:filter_selector) { str('?') >> whitespace >> logical_expr.as(:filter) }
+
+      # Logical expressions
+      rule(:logical_expr) { logical_or_expr }
+      rule(:logical_or_expr) { some_separated(logical_and_expr.as(:logical_or_operands), symbol('||')) }
+      rule(:logical_and_expr) { some_separated(basic_expr.as(:logical_and_operands), symbol('&&')) }
+      rule(:basic_expr) { paren_expr | comparison_expr | test_expr }
+      rule(:logical_not_op) { symbol('!') }
+      rule :paren_expr do
+        logical_not_op.maybe.as(:negation) >> symbol('(') >> logical_expr.as(:parenthesized_expr) >> symbol(')')
+      end
+      rule(:test_expr) { logical_not_op.maybe.as(:negation) >> (filter_query | function_expr).as(:test_expr) }
+      rule(:filter_query) { (rel_query | jsonpath_query).as(:filter_query) }
+      rule(:rel_query) { current_node_identifier >> many(segment).as(:relative_segments) }
+      rule :comparison_expr do
+        comparable.as(:comparable1) >> comparison_op.as(:comparison_op) >> comparable.as(:comparable2)
+      end
+      rule(:comparison_op) { symbol('==') | symbol('!=') | symbol('<=') | symbol('>=') | symbol('<') | symbol('>') }
+      rule(:comparable) { literal | singular_query | function_expr }
+      rule :literal do
+        number.as(:literal_number) |
+          string.as(:literal_string) |
+          symbol('true').as(:literal_true) |
+          symbol('false').as(:literal_false) |
+          symbol('null').as(:literal_null)
+      end
+      rule(:singular_query) { (rel_singular_query | abs_singular_query).as(:singular_query) }
+      rule :rel_singular_query do
+        current_node_identifier >> many(singular_query_segment).as(:relative_segments)
+      end
+      rule :abs_singular_query do
+        root_identifier >> many(singular_query_segment).as(:segments)
+      end
+      rule(:singular_query_segment) { name_segment | index_segment }
+      rule(:name_segment) { ((str('[') >> name_selector >> str(']')) | (str('.') >> member_name_shorthand)).as(:child) }
+      rule(:index_segment) { (str('[') >> index_selector >> str(']')).as(:child) }
+      rule(:function_expr) { none }
+
+      # Segments
+      rule(:segment) { child_segment | descendant_segment }
+      rule :child_segment do
+        (bracketed_selection | (str('.') >> (wildcard_selector | member_name_shorthand))).as :child
+      end
+      rule(:bracketed_selection) { str('[') >> some_separated(selector, symbol(',')).as(:bracketed) >> str(']') }
+      rule(:member_name_shorthand) { (match('[a-zA-Z_]') >> many(match('[a-zA-Z_0-9]'))).as(:name) }
+      rule :descendant_segment do
+        (str('..') >> (bracketed_selection | wildcard_selector | member_name_shorthand)).as :descendant
+      end
+    end
+  end
+end

data/lib/json_path/parser/transformer.rb

@@ -0,0 +1,219 @@
+require 'parslet'
+require_relative '../multiple_values_returned_by_singular_query'
+
+module JsonPath
+  module Parser
+    class Transformer < Parslet::Transform
+      EMPTY = ::Object.new
+
+      rule segments: sequence(:segments) do
+        proc do |root|
+          segments.reduce [root] do |nodes, segment|
+            segment.call nodes, root
+          end
+        end
+      end
+
+      rule(child: simple(:segment)) { segment }
+
+      rule descendant: simple(:segment) do
+        proc do |nodes, root|
+          recursive_application = proc do |node|
+            segment.call([node], root) + node.children.flat_map(&recursive_application)
+          end
+
+          nodes.flat_map(&recursive_application)
+        end
+      end
+
+      rule(bracketed: simple(:segment)) { segment }
+
+      rule bracketed: sequence(:segments) do
+        proc do |nodes, root|
+          segments.flat_map { _1.call nodes, root }
+        end
+      end
+
+      rule name: simple(:name) do
+        proc do |nodes|
+          nodes.filter_map do |node|
+            node.hash[name.to_s] if node.is_a? Nodes::Object
+          end
+        end
+      end
+
+      rule wildcard: simple(:x) do
+        proc do |nodes|
+          nodes.flat_map(&:children)
+        end
+      end
+
+      rule index: simple(:index) do
+        proc do |nodes|
+          nodes.filter_map do |node|
+            node.elements[Integer(index)] if node.is_a? Nodes::Array
+          end
+        end
+      end
+
+      rule start: simple(:slice_start),
+           end: simple(:slice_end),
+           step: simple(:slice_step) do
+             proc do |nodes|
+               slice_step = Integer(self.slice_step) || 1
+
+               next [] if slice_step.zero?
+
+               nodes.flat_map do |node|
+                 next [] unless node.is_a? Nodes::Array
+
+                 len = node.elements.size
+
+                 slice_start, slice_end = if slice_step.positive?
+                                            [
+                                              Integer(self.slice_start) || 0,
+                                              Integer(self.slice_end) || len
+                                            ]
+                                          else
+                                            [
+                                              Integer(self.slice_start) || (len - 1),
+                                              Integer(self.slice_end) || (-len - 1)
+                                            ]
+                                          end
+
+                 slice_start += len if slice_start.negative?
+                 slice_end += len if slice_end.negative?
+
+                 lower, upper = if slice_step.positive?
+                                  [
+                                    [[slice_start, 0].max, len].min,
+                                    [[slice_end, 0].max, len].min
+                                  ]
+                                else
+                                  [
+                                    [[slice_end, -1].max, len - 1].min,
+                                    [[slice_start, -1].max, len - 1].min
+                                  ]
+                                end
+
+                 # This is horrible, but it's also the easiest way to implement the semantics from the RFC
+                 [].tap do |result|
+                   if slice_step.positive?
+                     i = lower
+                     while i < upper
+                       result << node.elements[i] if (0...node.elements.size).include? i
+                       i += slice_step
+                     end
+                   else
+                     i = upper
+                     while i > lower
+                       result << node.elements[i] if (0...node.elements.size).include? i
+                       i += step
+                     end
+                   end
+                 end
+               end
+             end
+           end
+
+      rule filter: simple(:filter) do
+        proc do |nodes, root|
+          nodes.flat_map do |node|
+            case node
+            when Nodes::Array
+              node.elements
+            when Nodes::Object
+              node.hash.values
+            else
+              []
+            end
+              .filter { filter.call root, _1 }
+          end
+        end
+      end
+
+      rule(logical_or_operands: simple(:operand)) { operand }
+      rule(logical_and_operands: simple(:operand)) { operand }
+
+      rule logical_or_operands: sequence(:operands) do
+        proc do |*args, **kwargs, &block|
+          operands.any? { _1.call(*args, **kwargs, &block) }
+        end
+      end
+
+      rule logical_and_operands: sequence(:operands) do
+        proc do |*args, **kwargs, &block|
+          operands.all? { _1.call(*args, **kwargs, &block) }
+        end
+      end
+
+      rule negation: simple(:negation),
+           test_expr: simple(:expr) do
+             expr >> proc { negation ? !_1 : _1 }
+           end
+
+      rule filter_query: simple(:query) do
+        query >> proc { !_1.empty? }
+      end
+
+      rule negation: simple(:negation),
+           parenthesized_expr: simple(:expr) do
+             expr >> proc { negation ? !_1 : _1 }
+           end
+
+      rule comparable1: simple(:comp1),
+           comparison_op: simple(:op),
+           comparable2: simple(:comp2) do
+             proc do |*args, **kwargs, &block|
+               [comp1.call(*args, **kwargs, &block), comp2.call(*args, **kwargs, &block)]
+             end >> proc { _1.public_send op.to_s.strip.to_sym, _2 }
+           end
+
+      rule relative_segments: sequence(:segments) do
+        proc do |root, current_node|
+          segments.reduce [current_node] do |nodes, segment|
+            segment.call nodes, root
+          end
+        end
+      end
+
+      rule literal_number: simple(:num) do
+        proc { eval num }
+      end
+
+      rule literal_string: simple(:string) do
+        proc { string.to_s }
+      end
+
+      rule literal_true: simple(:x) do
+        proc { true }
+      end
+
+      rule literal_false: simple(:x) do
+        proc { false }
+      end
+
+      rule literal_null: simple(:x) do
+        proc {}
+      end
+
+      rule string: simple(:string) do
+        string
+      end
+
+      rule singular_query: simple(:query) do
+        proc do |*args, **kwargs, &block|
+          nodes = query.call(*args, **kwargs, &block)
+
+          if nodes.empty?
+            EMPTY
+          elsif nodes.size == 1
+            nodes.first.value
+          else
+            raise MultipleValuesReturnedBySingularQuery, 'Singular query must return single value'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_path/parser.rb

@@ -0,0 +1,16 @@
+require_relative 'parser/raw_parser'
+require_relative 'parser/transformer'
+
+module JsonPath
+  module Parser
+    RAW_PARSER = RawParser.new
+    TRANSFORMER = Transformer.new
+
+    def self.compile json_path_string
+      reporter = Parslet::ErrorReporter::Contextual.new
+      TRANSFORMER.apply RAW_PARSER.parse(json_path_string, reporter: reporter)
+    rescue Parslet::ParseFailed
+      reporter.deepest_cause.raise
+    end
+  end
+end

data/lib/json_path/path.rb

@@ -0,0 +1,22 @@
+require_relative 'parser'
+
+module JsonPath
+  class Path
+    attr_reader :string
+    attr_reader :proc
+
+    def initialize json_path
+      if json_path.is_a? Path
+        @string = json_path.string
+        @proc = json_path.proc
+      else
+        @string = -json_path
+        @proc = Parser.compile json_path
+      end
+    end
+
+    def apply node
+      proc.call node
+    end
+  end
+end

data/lib/json_path/unrecognized_node.rb

@@ -0,0 +1,4 @@
+module JsonPath
+  class UnrecognizedNode < Error
+  end
+end

data/lib/json_path.rb

@@ -0,0 +1,7 @@
+require_relative 'json_path/doc'
+
+module JsonPath
+  def self.Doc(...)
+    Doc.new(...)
+  end
+end

data/lib/json_path_rfc9535/version.rb

@@ -0,0 +1,3 @@
+module JsonPathRfc9535
+  VERSION = '1.0.0'
+end

data/lib/json_path_rfc9535.rb

@@ -0,0 +1,2 @@
+require_relative 'json_path_rfc9535/version'
+require_relative 'json_path'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: json_path_rfc9535
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Moku S.r.l.
+- Riccardo Agatea
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Like XPath is a query language for XML, JsonPath is a query language
+  for JSON. This gem aims to be an implementation of RFC 9535. Unlike tha original
+  JsonPath description (http://goessner.net/articles/JsonPath/), RFC 9535 is strictly
+  normative, which ideally should leave open fewer doors for inconsistencies.
+email:
+- info@moku.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- README.md
+- lib/json_path.rb
+- lib/json_path/doc.rb
+- lib/json_path/error.rb
+- lib/json_path/multiple_values_returned_by_singular_query.rb
+- lib/json_path/node_list.rb
+- lib/json_path/nodes.rb
+- lib/json_path/nodes/array.rb
+- lib/json_path/nodes/base.rb
+- lib/json_path/nodes/false.rb
+- lib/json_path/nodes/null.rb
+- lib/json_path/nodes/number.rb
+- lib/json_path/nodes/object.rb
+- lib/json_path/nodes/string.rb
+- lib/json_path/nodes/true.rb
+- lib/json_path/parser.rb
+- lib/json_path/parser/core.rb
+- lib/json_path/parser/raw_parser.rb
+- lib/json_path/parser/transformer.rb
+- lib/json_path/path.rb
+- lib/json_path/unrecognized_node.rb
+- lib/json_path_rfc9535.rb
+- lib/json_path_rfc9535/version.rb
+homepage: https://github.com/moku-io/json_path_rfc9535
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/moku-io/json_path_rfc9535
+  source_code_uri: https://github.com/moku-io/json_path_rfc9535
+  changelog_uri: https://github.com/moku-io/json_path_rfc9535/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A Ruby implementation of RFC 9535.
+test_files: []