lutaml-path 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35c6031869535e5000b1a97f6f19fcb33427eff85871c391a0c9923ed799f0d5
+  data.tar.gz: 1a2c3b642aa03c059228ccd75400d87adf4d5410c170e008fe9151ec6f31422c
+SHA512:
+  metadata.gz: 1e24edbb6013b5375f0f91506b4b8c710f7a20c33c9d64ed2a6a0411f61c5a340b5a96096ae4a20dccddc5eb129a0bf0ea8f49e311fc91ee75c2c6aa011942dd
+  data.tar.gz: 82595300ac867fe4dead6f7638af14ffe61a642f0c0979a9e7d1f2eed1e7c2f8e459f8db4715d4bf724da44f9d6ede030bad1c56ac4f1f706a197a47475a181b

data/.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Ruby ${{ matrix.ruby }}
+    strategy:
+      matrix:
+        ruby:
+          - '3.3.2'
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Run the default task
+      run: bundle exec rake

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_from: .rubocop_todo.yml
+
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/.rubocop_todo.yml

@@ -0,0 +1,25 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2024-11-12 03:37:16 UTC using RuboCop version 1.68.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 2
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+# AllowedMethods: refine
+Metrics/BlockLength:
+  Max: 69
+
+# Offense count: 5
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/lutaml/path.rb'
+    - 'lib/lutaml/path/element_path.rb'
+    - 'lib/lutaml/path/parser.rb'
+    - 'lib/lutaml/path/path_segment.rb'
+    - 'lib/lutaml/path/transformer.rb'

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in lutaml-model.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rubocop", "~> 1.21"
+gem "rubocop-performance", require: false
+gem "rubocop-rake", require: false
+gem "rubocop-rspec", require: false

data/README.adoc

@@ -0,0 +1,153 @@
+= LutaML Path
+:source-highlighter: highlight.js
+:toc: macro
+
+image:https://github.com/lutaml/lutaml-path/workflows/build/badge.svg["Build Status", link="https://github.com/lutaml/lutaml-path/actions?workflow=build"]
+image:https://img.shields.io/gem/v/lutaml-path.svg["Gem Version", link="https://rubygems.org/gems/lutaml-path"]
+
+toc::[]
+
+== What is LutaML Path?
+
+LutaML Path provides a parser for path expressions that reference elements
+within UML models. It implements a path notation similar to the Object
+Constraint Language (OCL) to locate UML model elements across package
+hierarchies.
+
+This gem is specifically designed to work with OMG UML models and supports
+referencing any UML element including packages, classes, interfaces, properties,
+and operations.
+
+== How to install
+
+[source,ruby]
+----
+gem install lutaml-path
+----
+
+Or add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'lutaml-path'
+----
+
+== Basic usage
+
+The path syntax follows UML namespace conventions using `::` as a separator:
+
+[source,ruby]
+----
+require 'lutaml/path'
+
+# Simple element reference
+path = Lutaml::Path.parse("Package::Class")
+
+# Absolute path (starts from root namespace)
+path = Lutaml::Path.parse("::Root::Package::Class")
+
+# Path with wildcards
+path = Lutaml::Path.parse("Package::*::BaseClass*")
+----
+
+== Working with patterns
+
+The parser supports several kinds of patterns:
+
+* `*` - matches any sequence of characters
+* `?` - matches any single character
+* `[abc]` - matches any character in the set
+* `{pattern1,pattern2}` - matches any of the comma-separated patterns
+
+Examples:
+
+[source,ruby]
+----
+# Match any class starting with "Base"
+path = Lutaml::Path.parse("Base*")
+
+# Match specific character patterns
+path = Lutaml::Path.parse("Package::[A-Z]*::Interface")
+
+# Match multiple alternatives
+path = Lutaml::Path.parse("model::{Abstract,Base}Class")
+----
+
+== How to match paths
+
+The parsed path can be used to match against actual element paths:
+
+[source,ruby]
+----
+path = Lutaml::Path.parse("model::*::BaseClass")
+
+path.match?(["model", "core", "BaseClass"])     # => true
+path.match?(["model", "BaseClass"])             # => false
+path.match?(["other", "core", "BaseClass"])     # => false
+----
+
+== Understanding absolute and relative paths
+
+* Absolute paths (starting with `::`) must match the entire element path
+* Relative paths can match elements at any depth
+
+[source,ruby]
+----
+absolute = Lutaml::Path.parse("::model::Class")
+relative = Lutaml::Path.parse("model::Class")
+
+absolute.match?(["model", "Class"])           # => true
+absolute.match?(["root", "model", "Class"])   # => false
+
+relative.match?(["model", "Class"])           # => true
+relative.match?(["root", "model", "Class"])   # => true
+----
+
+== Path syntax reference
+
+The path expression grammar follows these rules:
+
+* Path segments are separated by `::`
+* The separator can be escaped with a backslash: `\::`
+* An absolute path starts with `::`
+* Each segment can contain:
+** Regular characters (including Unicode)
+** Wildcards (`*`, `?`)
+** Character classes (`[abc]`)
+** Alternatives (`{pattern1,pattern2}`)
+
+== Matching paths with escaped colons
+
+When matching paths with escaped colons, the escaped sequences are treated as
+part of the segment name:
+
+[source,ruby]
+----
+path = Lutaml::Path.parse("model::std\\::string")
+
+path.match?(["model", "std::string"])     # => true
+path.match?(["model", "std", "string"])   # => false
+----
+
+== Examples of UML element references
+
+[source,ruby]
+----
+# Reference a class in a package
+"model::shapes::Rectangle"
+
+# Reference an operation on a class
+"model::shapes::Rectangle::area"
+
+# Reference a property in a nested class
+"model::university::Student::Address::street"
+
+# Find all classes implementing an interface
+"model::*::IShape"
+
+# Match any stereotype application
+"model::profiles::UMLProfile::*Stereotype"
+----
+
+These paths can be used to locate elements across UML model hierarchies, making
+it easier to reference and work with model elements programmatically.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "lutaml/path"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/lutaml/path/element_path.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Path
+    class ElementPath
+      attr_reader :segments, :absolute
+
+      def initialize(segments, absolute: false)
+        @segments = Array(segments)
+        @absolute = absolute
+      end
+
+      def absolute?
+        @absolute
+      end
+
+      def match?(path_segments)
+        return false if absolute? && path_segments.length != segments.length
+        return false if path_segments.length < segments.length
+
+        segments.zip(path_segments).all? { |seg, path_seg| seg.match?(path_seg) }
+      end
+    end
+  end
+end

data/lib/lutaml/path/parser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# lib/lutaml/path/parser.rb
+require "parslet"
+
+module Lutaml
+  module Path
+    class Parser < Parslet::Parser
+      rule(:space) { match('\s').repeat }
+
+      rule(:escaped_separator) { str("\\") >> str("::") }
+      rule(:separator) { str("::") }
+
+      # Character rules
+      rule(:glob_char) { match('[*?\[{]') }
+      rule(:regular_char) do
+        (separator.absent? >> str("\\").absent? >> any) |
+          escaped_separator
+      end
+
+      # Single segment can contain any regular chars or glob chars
+      rule(:segment_content) do
+        (glob_char | regular_char).repeat(1).as(:content) >>
+          glob_char.present?.maybe.as(:is_pattern)
+      end
+
+      rule(:segment) do
+        segment_content.as(:segment)
+      end
+
+      rule(:segments) do
+        (separator >> segment).repeat.as(:more_segments)
+      end
+
+      # Full path expression - either absolute or relative
+      rule(:path_expr) do
+        ((separator.as(:absolute) >> segment.as(:first_segment) >> segments) |
+         (segment.as(:first_segment) >> segments))
+      end
+
+      root(:path_expr)
+    end
+  end
+end

data/lib/lutaml/path/path_segment.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Path
+    class PathSegment
+      attr_reader :name, :pattern
+
+      def initialize(name, is_pattern: false)
+        @name = name.gsub('\::', "::")
+        @pattern = is_pattern
+      end
+
+      def pattern?
+        @pattern
+      end
+
+      def match?(segment)
+        return File.fnmatch(name, segment) if pattern?
+
+        name == segment
+      end
+    end
+  end
+end

data/lib/lutaml/path/transformer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# lib/lutaml/path/transformer.rb
+require "parslet"
+
+module Lutaml
+  module Path
+    class Transformer < Parslet::Transform
+      rule(content: simple(:content), is_pattern: simple(:is_pattern)) do |dict|
+        content = dict[:content].to_s
+        is_pattern = !dict[:is_pattern].nil?
+        PathSegment.new(content, is_pattern: is_pattern)
+      end
+
+      rule(segment: subtree(:segment)) { segment }
+
+      # Transform more_segments rule
+      rule(more_segments: sequence(:segments)) { segments }
+      rule(more_segments: simple(:segment)) { [segment].compact } # For single segment
+      rule(more_segments: []) { [] } # For empty segments
+
+      # Absolute path
+      rule(
+        absolute: simple(:_),
+        first_segment: simple(:first),
+        more_segments: sequence(:rest)
+      ) do |dict|
+        segments = [dict[:first]] + Array(dict[:rest]).compact
+        ElementPath.new(segments, absolute: true)
+      end
+
+      # Relative path
+      rule(
+        first_segment: simple(:first),
+        more_segments: sequence(:rest)
+      ) do |dict|
+        segments = [dict[:first]] + Array(dict[:rest]).compact
+        ElementPath.new(segments, absolute: false)
+      end
+    end
+  end
+end

data/lib/lutaml/path/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Path
+    VERSION = "0.1.0"
+  end
+end

data/lib/lutaml/path.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "path/version"
+require_relative "path/parser"
+require_relative "path/transformer"
+require_relative "path/element_path"
+require_relative "path/path_segment"
+
+module Lutaml
+  module Path
+    class ParseError < StandardError; end
+
+    def self.parse(input)
+      tree = Parser.new.parse(input)
+      Transformer.new.apply(tree)
+    rescue Parslet::ParseFailed => e
+      raise ParseError, e.message
+    end
+  end
+end

data/lutaml-path.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/lutaml/path/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "lutaml-path"
+  spec.version = Lutaml::Path::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Element path parser supporting OCL-style paths"
+  spec.description = "Parser for element paths"
+
+  spec.homepage = "https://github.com/lutaml/lutaml-path"
+  spec.license = "BSD-2-Clause"
+
+  spec.bindir = "exe"
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the
+  # RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|features)/})
+    end
+  end
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+
+  spec.add_dependency "parslet"
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

data/sig/lutaml/path.rbs

@@ -0,0 +1,6 @@
+module Lutaml
+  module Path
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/spec/lutaml/path_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Path do
+  describe ".parse" do
+    it "parses simple paths" do
+      path = described_class.parse("Element")
+      expect(path.absolute?).to be false
+      expect(path.segments.length).to eq(1)
+      expect(path.segments.first.name).to eq("Element")
+      expect(path.segments.first.pattern?).to be false
+    end
+
+    it "parses absolute paths" do
+      path = described_class.parse("::Package::Element")
+      expect(path.absolute?).to be true
+      expect(path.segments.map(&:name)).to eq(%w[Package Element])
+    end
+
+    xit "parses paths with patterns" do
+      path = described_class.parse("Package::*::Base*")
+      expect(path.segments.map(&:pattern?)).to eq([false, true, true])
+      expect(path.segments.map(&:name)).to eq(["Package", "*", "Base*"])
+    end
+
+    it "handles escaped separators" do
+      path = described_class.parse("core\\::types::Element")
+      expect(path.segments.map(&:name)).to eq(["core::types", "Element"])
+    end
+
+    it "handles Unicode characters" do
+      path = described_class.parse("建物::窓::ガラス")
+      expect(path.segments.map(&:name)).to eq(%w[建物 窓 ガラス])
+    end
+
+    xit "handles glob patterns" do
+      path = described_class.parse("pkg::{a,b}*::[0-9]*")
+      expect(path.segments.last.pattern?).to be true
+      expect(path.match?(%w[pkg btest 123])).to be true
+    end
+
+    it "raises error on empty segments" do
+      expect { described_class.parse("pkg::::element") }.to raise_error(described_class::ParseError)
+    end
+
+    it "raises error on invalid syntax" do
+      expect { described_class.parse("") }.to raise_error(described_class::ParseError)
+    end
+  end
+
+  describe Lutaml::Path::PathSegment do
+    it "matches exact names" do
+      segment = described_class.new("Element")
+      expect(segment.match?("Element")).to be true
+      expect(segment.match?("Other")).to be false
+    end
+
+    it "matches patterns" do
+      segment = described_class.new("Base*", is_pattern: true)
+      expect(segment.match?("BaseClass")).to be true
+      expect(segment.match?("Other")).to be false
+    end
+  end
+
+  describe Lutaml::Path::ElementPath do
+    it "matches path segments" do
+      path = described_class.new([
+                                   Lutaml::Path::PathSegment.new("pkg"),
+                                   Lutaml::Path::PathSegment.new("*", is_pattern: true),
+                                   Lutaml::Path::PathSegment.new("Element")
+                                 ])
+
+      expect(path.match?(%w[pkg sub Element])).to be true
+      expect(path.match?(%w[other sub Element])).to be false
+    end
+
+    it "respects absolute paths" do
+      path = described_class.new([
+                                   Lutaml::Path::PathSegment.new("pkg"),
+                                   Lutaml::Path::PathSegment.new("Element")
+                                 ], absolute: true)
+
+      expect(path.match?(%w[pkg Element])).to be true
+      expect(path.match?(%w[root pkg Element])).to be false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "lutaml/path"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: lutaml-path
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parser for element paths
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.adoc
+- Rakefile
+- bin/console
+- bin/setup
+- lib/lutaml/path.rb
+- lib/lutaml/path/element_path.rb
+- lib/lutaml/path/parser.rb
+- lib/lutaml/path/path_segment.rb
+- lib/lutaml/path/transformer.rb
+- lib/lutaml/path/version.rb
+- lutaml-path.gemspec
+- sig/lutaml/path.rbs
+- spec/lutaml/path_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/lutaml/lutaml-path
+licenses:
+- BSD-2-Clause
+metadata:
+  rubygems_mfa_required: 'true'
+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.22
+signing_key:
+specification_version: 4
+summary: Element path parser supporting OCL-style paths
+test_files: []