lutaml-path 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8584a51742dcb31b61b6bc37e68f2edf493a1e7a48708c870e47cadeeb4beef6
-  data.tar.gz: 51a38b742ecacf795837ae41a9eea14245ba1eb5293796b179cb0eb939b600b8
+  metadata.gz: c8c0a8ead1612a0e7855fa1b1deb4e3ba69ac7e979d8d0a821fd352e2aa52c32
+  data.tar.gz: 5942c6e8c60f1166e9554661e02e0684be30e7232a65e78c37f93195e5cfbcc3
 SHA512:
-  metadata.gz: 15f279e14d46e29330f325c4bd649d96a78aae0612b3db20accb0b310b9988197c29129ddbfb333a4338a7417363d26cf3f3c6056e2b4399beaf262aefc8c593
-  data.tar.gz: 4ba0a918560a74402a7bfd5088cf5ed83a5ff96881d4d200425dd9a4bca82eeb6c31672da5414b82abe1bce088ecb290e4dc716ebe374934e77fa9dcefc68ddc
+  metadata.gz: 74a28aeccc015653c0e64e266aa323eb1f88bc1b12ddef91fdfb251b1582307b708b111c19a37d8f52db7a73158e7690a3a4a4fe93a247cc9dc7c2dd73e42240
+  data.tar.gz: 74bedffad67bc25619f7b50d0ba213eaba57afc3c0577fd956d0f17b638d52ea39db9418cc57e45892d54135c5aca7d264680e8532a916eb5f11d2349c44212c

data/.rubocop.yml

@@ -1,7 +1,7 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.2
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes

data/lib/lutaml/path/parser.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
 # lib/lutaml/path/parser.rb
-require "parslet"
+require "parsanol"
+require_relative "errors"
 
 module Lutaml
   module Path
-    class Parser < Parslet::Parser
+    class Parser < Parsanol::Parser
+      def parse(input, mode_or_opts = {}, **kwargs)
+        options = mode_or_opts.is_a?(Hash) ? mode_or_opts : {}
+        # Keep recursive grammar failures catchable on the Ruby engine.
+        super(input, **options, **kwargs, mode: :ruby)
+      rescue SystemStackError
+        raise ParseError, "expression nests too deeply to parse"
+      end
+
       rule(:sp) { match('\s').repeat }
       rule(:sp?) { sp.maybe }
 
@@ -88,14 +97,16 @@ module Lutaml
       # silently parses as `and` + the attribute "roid" rather than raising.
       rule(:and_op) { str("&&") | (str("and") >> ident_char.absent?) }
 
+      # Parse each operand once; repeating it in an alternative compounds
+      # backtracking inside nested groups.
       rule(:and_expr) do
-        (not_expr.as(:left) >> sp? >> and_op.as(:operator) >>
-          sp? >> and_expr.as(:right)).as(:binary) | not_expr
+        (not_expr.as(:left) >> (sp? >> and_op.as(:operator) >>
+          sp? >> and_expr.as(:right)).maybe).as(:binary)
       end
 
       rule(:or_expr) do
-        (and_expr.as(:left) >> sp? >> str("||").as(:operator) >>
-          sp? >> or_expr.as(:right)).as(:binary) | and_expr
+        (and_expr.as(:left) >> (sp? >> str("||").as(:operator) >>
+          sp? >> or_expr.as(:right)).maybe).as(:binary)
       end
 
       rule(:condition) { or_expr }
@@ -171,7 +182,7 @@ module Lutaml
       end
 
       # Full path expression. `absolute` is ALWAYS emitted (nil when relative)
-      # so the transform sees one stable key set: Parslet matches a hash on its
+      # so the transform sees one stable key set: Parsanol matches a hash on its
       # exact keys, and a second root rule would have to be duplicated for
       # every key added later.
       rule(:path_expr) do

data/lib/lutaml/path/transformer.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 # lib/lutaml/path/transformer.rb
-require "parslet"
+require "parsanol"
 
 module Lutaml
   module Path
-    class Transformer < Parslet::Transform
+    class Transformer < Parsanol::Transform
       # --- condition AST ----------------------------------------------------
       # Tokenise into names rather than splitting on a naive lookbehind: a name
       # may itself end in an escaped backslash, so "a\\\\.b" is the two names
@@ -15,7 +15,7 @@ module Lutaml
         names = a.to_s.scan(/(?:\\.|[^.\\])+/)
         Condition::AttributeRef.new(names.map { |n| n.gsub(/\\(.)/) { ::Regexp.last_match(1) } })
       end
-      # An empty quoted value ('') makes Parslet's repeat yield [] rather than a
+      # An empty quoted value ('') makes Parsanol's repeat yield [] rather than a
       # slice, so `simple` would never match and the node would stay raw.
       rule(string: subtree(:s)) do
         raw = s.is_a?(Array) ? "" : s.to_s
@@ -30,7 +30,7 @@ module Lutaml
         Condition::Comparison.new(d[:l], d[:o].to_s, d[:r])
       end
 
-      # Parslet collapses a one-element repetition to a bare Hash rather than a
+      # Parsanol collapses a one-element repetition to a bare Hash rather than a
       # one-element Array, and Array({v: x}) would yield [[:v, x]] via Hash#to_a
       # -- so `in ('ISBN')` used to raise TypeError out of Lutaml::Path.parse.
       # Wrap-then-flatten normalises both shapes.
@@ -40,6 +40,8 @@ module Lutaml
 
       rule(not: subtree(:n)) { Condition::Negation.new(n) }
 
+      rule(binary: { left: subtree(:l) }) { l }
+
       rule(binary: { left: subtree(:l), operator: simple(:o), right: subtree(:r) }) do |d|
         Condition::BinaryOperation.new(d[:o].to_s, d[:l], d[:r])
       end

data/lib/lutaml/path/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Path
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/lib/lutaml/path.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "parslet"
+require "parsanol"
 require_relative "path/version"
 require_relative "path/errors"
 require_relative "path/parser"
@@ -20,13 +20,10 @@ module Lutaml
     def self.parse(input)
       tree = Parser.new.parse(input)
       Transformer.new.apply(tree)
-    rescue Parslet::ParseFailed => e
+    rescue Parsanol::ParseFailed => e
       raise ParseError, e.message
     rescue SystemStackError
-      # The condition grammar recurses through group/not/and/or, so an input
-      # nested deeply enough (~200 parentheses) exhausts the stack. That is a
-      # property of the input, not a bug in the caller: parse must only ever
-      # raise ParseError.
+      # Transforming deeply nested conditions can also exhaust the stack.
       raise ParseError, "expression nests too deeply to parse"
     end
 
@@ -43,7 +40,7 @@ module Lutaml
     def self.parse_instance(input)
       tree = Parser.new.parse(input)
       Transformer.new.apply(tree)
-    rescue Parslet::ParseFailed => e
+    rescue Parsanol::ParseFailed => e
       raise ParseError, e.message
     rescue SystemStackError
       raise ParseError, "expression nests too deeply to parse"

data/lutaml-path.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
 
   spec.bindir = "exe"
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the
@@ -29,6 +29,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
 
   spec.add_dependency "lutaml-model", ">= 0.8"
-  spec.add_dependency "parslet", "~> 2"
+  spec.add_dependency "parsanol", "~> 1.3"
   spec.metadata["rubygems_mfa_required"] = "true"
 end

data/spec/lutaml/path_spec.rb

@@ -1,9 +1,141 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "open3"
+require "rbconfig"
 
 RSpec.describe Lutaml::Path do
+  describe ".parse_instance" do
+    it "preserves parsed model and instance path shapes" do
+      %w[title contributor.role.type contributor[exists]].each do |input|
+        expect(described_class.parse_instance(input)).to eq(described_class.parse(input))
+      end
+    end
+
+    it "normalizes malformed instance path failures" do
+      expect { described_class.parse_instance("contributor[type=]") }
+        .to raise_error(described_class::ParseError)
+    end
+  end
+
+  describe ".resolve" do
+    it "normalizes malformed path failures before resolving" do
+      expect { described_class.resolve({}, "contributor[type=]") }
+        .to raise_error(described_class::ParseError)
+    end
+  end
+
   describe ".parse" do
+    it "uses Parsanol parser and transformer classes" do
+      expect(described_class::Parser.superclass).to eq(Parsanol::Parser)
+      expect(described_class::Transformer.superclass).to eq(Parsanol::Transform)
+    end
+
+    it "keeps parsing on the Ruby engine" do
+      allow(Parsanol::Native).to receive(:parse).and_raise(NotImplementedError)
+
+      expect(described_class.parse("obj.x[exists]").conditions.first)
+        .to eq(described_class::Condition::Existence.new)
+    end
+
+    it "preserves the parser arity and forwards prefix options" do
+      parser = described_class::Parser.new
+
+      expect(parser.method(:parse).arity).to eq(-2)
+      expect(parser.parse("obj.", { prefix: true })[:first_segment][:segment][:content].to_s)
+        .to eq("obj")
+      expect(parser.parse("obj.", prefix: true)[:first_segment][:segment][:content].to_s)
+        .to eq("obj")
+    end
+
+    it "honors keyword options over positional options while keeping Ruby parsing" do
+      allow(Parsanol::Native).to receive(:parse).and_raise(NotImplementedError)
+      parser = described_class::Parser.new
+
+      tree = parser.parse("Element", { mode: :native }, mode: :native)
+      expect(tree[:first_segment][:segment][:content].to_s).to eq("Element")
+      expect(parser.parse("obj.", { prefix: false }, prefix: true)[:first_segment][:segment][:content].to_s)
+        .to eq("obj")
+      expect { parser.parse("obj.", { prefix: true }, prefix: false) }
+        .to raise_error(Parsanol::ParseFailed)
+    end
+
+    it "keeps direct parser nesting catchable even with explicit native requests" do
+      program = <<~'RUBY'
+        require "lutaml/path"
+        input = "obj.x[#{"(" * ARGV[0].to_i}exists#{")" * ARGV[0].to_i}]"
+        parser = Lutaml::Path::Parser.new
+        begin
+          tree = case ARGV[1]
+                 when "symbol" then parser.parse(input, :native)
+                 when "hash" then parser.parse(input, { mode: :native })
+                 when "keyword" then parser.parse(input, mode: :native)
+                 else parser.parse(input)
+                 end
+          condition = tree.fetch(:attrs).first.fetch(:segment).fetch(:condition)
+          condition = condition.fetch(:binary).fetch(:left) while condition.key?(:binary)
+          puts condition.fetch(:exists).to_s
+        rescue Lutaml::Path::ParseError => e
+          puts e.message
+        end
+      RUBY
+      library = File.expand_path("../../lib", __dir__)
+
+      [200, 500, 2000].product(%w[default symbol hash keyword]).each do |depth, mode|
+        output, error, status = Open3.capture3(RbConfig.ruby, "-I", library,
+                                               "-e", program, depth.to_s, mode)
+        expect(status.success?).to be(true), error
+        expect(output.strip).to satisfy do |result|
+          ["exists", "expression nests too deeply to parse"].include?(result)
+        end
+      end
+    end
+
+    it "normalizes direct parser stack exhaustion" do
+      input = "obj.x[#{"(" * 5000}exists#{")" * 5000}]"
+
+      expect { described_class::Parser.new.parse(input) }
+        .to raise_error(described_class::ParseError, "expression nests too deeply to parse")
+    end
+
+    it "translates the actual Parsanol failure without losing its message" do
+      input = "obj.x[a=]"
+      failure = begin
+        described_class::Parser.new.parse(input, mode: :ruby)
+      rescue Parsanol::ParseFailed => e
+        e
+      end
+
+      expect(failure).to be_a(Parsanol::ParseFailed)
+      expect { described_class.parse(input) }
+        .to raise_error(described_class::ParseError, failure.message)
+    end
+
+    it "captures each boolean operand once when no operator follows" do
+      { and_expr: :exists, or_expr: :binary }.each do |rule, left_key|
+        tree = described_class::Parser.new.public_send(rule).parse("exists")
+        expect(tree.fetch(:binary).keys).to eq([:left])
+        expect(tree.fetch(:binary).fetch(:left).keys).to eq([left_key])
+      end
+    end
+
+    it "keeps repeated boolean operators right associative" do
+      %w[&& and ||].each do |operator|
+        condition = described_class.parse("obj.x[a='1' #{operator} b='2' #{operator} c='3']")
+                                   .conditions.first
+
+        expect(condition.left.lhs.names).to eq(["a"])
+        expect(condition.right.left.lhs.names).to eq(["b"])
+        expect(condition.right.right.lhs.names).to eq(["c"])
+      end
+    end
+
+    it "reports a balanced filter beyond the Ruby stack limit as ParseError" do
+      input = "obj.x[#{"(" * 2000}exists#{")" * 2000}]"
+
+      expect { described_class.parse(input) }.to raise_error(described_class::ParseError)
+    end
+
     it "parses simple paths" do
       path = described_class.parse("Element")
       expect(path.absolute?).to be false
@@ -298,7 +430,7 @@ RSpec.describe Lutaml::Path do
     end
 
     it "parses an in-list of any arity" do
-      # A one-element list collapses to a bare Hash in Parslet rather than a
+      # A one-element list collapses to a bare Hash in Parsanol rather than a
       # one-element Array. Getting that wrong raised TypeError straight out of
       # .parse, bypassing the ParseError rescue. The README only ever shows a
       # three-element list, so this was never exercised.
@@ -357,7 +489,7 @@ RSpec.describe Lutaml::Path do
     end
 
     it "parses an empty quoted value" do
-      # Parslet yields [] rather than a slice for an empty repeat, so a
+      # Parsanol yields [] rather than a slice for an empty repeat, so a
       # `simple` transform rule would never match and the node would stay raw.
       path = described_class.parse("obj.x[a='']")
       expect(path.conditions.first.rhs)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-path
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.8'
 - !ruby/object:Gem::Dependency
-  name: parslet
+  name: parsanol
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1.3'
 description: Parser for element paths
 email:
 - open.source@ribose.com
@@ -88,7 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="