lutaml-path 0.1.0 → 0.1.1

data/lib/lutaml/path/resolver.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "condition"
+require_relative "condition_evaluator"
+require_relative "step"
+require_relative "instance_path"
+
+module Lutaml
+  module Path
+    # Resolves parsed instance paths against real model data:
+    # lutaml-model Serializable instances, plain hashes, and their
+    # collections. This is the evaluation half of RS 3002's instance
+    # data syntax — the parser deliberately stays parse-only
+    # (InstancePath#match? raises), so resolution lives here where the
+    # object-model knowledge (attributes, hashes, enumerables)
+    # belongs.
+    #
+    # Resolution walks InstancePath#steps: base steps anchor the root
+    # (treated as attribute navigation from the given root), attribute
+    # steps read named children, `**` selects every descendant, and a
+    # step's condition filters the step's candidate nodes.
+    module Resolver
+      module_function
+
+      def resolve(root, path)
+        path = normalized(path)
+        context = [root]
+        path.steps.each do |step|
+          context = apply_step(context, step)
+        end
+        finalize(context, path)
+      end
+
+      def apply_step(context, step)
+        context = if step.deep_wildcard?
+                    descendants(context)
+                  else
+                    context.flat_map { |node| named_children(node, step) }
+                  end
+        step.condition? ? filter(context, step.condition) : context
+      end
+
+      def filter(context, condition)
+        context.select { |node| ConditionEvaluator.evaluate(condition, node) }
+      end
+
+      # Reads a dotted AttributeRef ("role.type") from a context node.
+      # Condition paths are plain names (the grammar admits no glob
+      # characters in attribute references).
+      def read_path(object, attribute_ref)
+        context = [object]
+        attribute_ref.names.each do |name|
+          context = context.flat_map { |node| exact_children(node, name) }
+        end
+        return nil if context.empty?
+
+        context.first
+      end
+
+      def exact_children(node, name)
+        entries(node).filter_map do |child_name, value|
+          next if value.nil?
+          next unless child_name.to_s == name
+
+          value.is_a?(::Enumerable) && !value.is_a?(::Hash) && !value.is_a?(::String) ? value.to_a : value
+        end.flatten(1)
+      end
+
+      def named_children(node, step)
+        named_targets(node, step.segment)
+      end
+
+      # Children of `node` whose name matches the step's segment; a
+      # collection value contributes its elements.
+      def named_targets(node, segment)
+        entries(node).filter_map do |child_name, value|
+          next if value.nil?
+          next unless segment.match?(child_name.to_s)
+
+          value.is_a?(::Enumerable) && !value.is_a?(::Hash) && !value.is_a?(::String) ? value.to_a : value
+        end.flatten(1)
+      end
+
+      def descendants(context)
+        seen = {}.compare_by_identity
+        context.each do |node|
+          walk(node) { |value| seen[value] = true unless value.nil? }
+        end
+        seen.keys
+      end
+
+      def walk(node, &block)
+        entries(node).map(&:last).each do |value|
+          next if value.nil?
+
+          block.call(value)
+          walk(value, &block)
+        end
+      end
+
+      # (name, value) pairs addressable on `node`.
+      def entries(node)
+        return [] if primitive?(node)
+
+        if node.is_a?(::Hash)
+          node.map { |key, value| [key, value] }
+        elsif node.is_a?(::Enumerable)
+          node.each_with_index.map { |value, index| [index, value] }
+        elsif model_instance?(node)
+          model_entries(node)
+        else
+          []
+        end
+      end
+
+      def primitive?(node)
+        node.nil? || node.is_a?(::String) || node.is_a?(::Numeric) || node.is_a?(::Symbol)
+      end
+
+      def model_instance?(node)
+        defined?(Lutaml::Model) && node.is_a?(Lutaml::Model::Serializable)
+      end
+
+      def model_entries(node)
+        node.class.attributes.keys.filter_map do |name|
+          next unless node.respond_to?(name)
+
+          [name, node.public_send(name)]
+        end
+      end
+
+      # A bare name parses as a model path (the grammar's default);
+      # for resolution its segments are attribute steps.
+      def normalized(path)
+        return path if path.respond_to?(:steps)
+
+        steps = path.segments.map { |segment| Step.new(segment) }
+        InstancePath.new(base_steps: [], attribute_steps: steps, absolute: path.absolute?)
+      end
+
+      # Plain chains (no filters, patterns, or deep wildcards) resolve
+      # to a single value when exactly one non-collection node matched;
+      # everything else returns the collection.
+      def finalize(context, path)
+        plain = path.steps.none? do |step|
+          step.condition? || step.pattern? || step.deep_wildcard?
+        end
+        return context.first if plain && context.size == 1 && !context.first.is_a?(::Enumerable)
+
+        context
+      end
+    end
+  end
+end

data/lib/lutaml/path/step.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Lutaml
+  module Path
+    # One segment of a path plus the filter condition attached to it.
+    #
+    # Step composes a PathSegment rather than extending it, and deliberately
+    # does NOT answer match?: a step can carry a condition, and matching by
+    # name alone would silently ignore that condition and report a match for
+    # a path that says something narrower. PathSegment stays filter-free and
+    # keeps match?; anything that can carry a filter never answers it.
+    #
+    # Composition is also required for correctness: "**[name='ISO']" as a
+    # single PathSegment name is not a deep wildcard, whereas name "**" plus a
+    # separate condition keeps deep_wildcard? true.
+    class Step
+      extend Forwardable
+
+      attr_reader :segment, :condition
+
+      def_delegators :segment, :name, :pattern?, :deep_wildcard?
+
+      def initialize(segment, condition: nil)
+        @segment = segment
+        @condition = condition
+      end
+
+      def condition?
+        !condition.nil?
+      end
+
+      def to_s
+        condition? ? "#{segment}[#{condition}]" : segment.to_s
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) &&
+          segment == other.segment &&
+          condition == other.condition
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, segment, condition].hash
+      end
+    end
+  end
+end

data/lib/lutaml/path/transformer.rb

@@ -6,36 +6,78 @@ 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)
+      # --- 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
+      # ["a\\", "b"] while "a\\.b" is the single name "a.b". Each token is a run
+      # of escaped pairs and ordinary characters; the dots between them separate.
+      rule(attref: simple(:a)) do
+        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
+      # 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
+        # One pass, so "\\\\'" unescapes to a backslash followed by a quote
+        # rather than being double-unescaped by two independent gsubs.
+        Condition::Value.new(raw.gsub(/\\(['\\])/) { ::Regexp.last_match(1) }, :string)
+      end
+      rule(number: simple(:n)) { Condition::Value.new(n.to_s, :number) }
+      rule(exists: simple(:_)) { Condition::Existence.new }
 
-      rule(segment: subtree(:segment)) { segment }
+      rule(lhs: subtree(:l), op: simple(:o), rhs: subtree(:r)) do |d|
+        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
+      # 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.
+      rule(lhs: subtree(:l), literals: subtree(:v)) do |d|
+        Condition::Membership.new(d[:l], [d[:v]].flatten.map { |h| h[:v] })
+      end
 
-      # 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
+      rule(not: subtree(:n)) { Condition::Negation.new(n) }
 
-      # 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)
+      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
 
-      # Relative path
+      # --- steps ------------------------------------------------------------
+      # Every segment becomes a Step uniformly. The transform builds bottom-up
+      # and a leaf cannot know whether the whole path has dot-steps or filters,
+      # so the root rule -- the only place that knows -- decides the type and
+      # unwraps Step -> PathSegment when it picks ElementPath.
+      rule(content: simple(:content)) do |dict|
+        Step.new(PathSegment.new(dict[:content].to_s))
+      end
+
+      rule(content: simple(:content), condition: subtree(:cond)) do |dict|
+        Step.new(PathSegment.new(dict[:content].to_s), condition: dict[:cond])
+      end
+
+      rule(segment: subtree(:segment)) { segment }
+
+      # Single root rule. `abs` is nil for a relative path and a "::" slice for
+      # an absolute one. One rule means one key set, so adding a key later
+      # cannot silently un-match the root and hand back a raw Hash.
       rule(
+        absolute: simple(:abs),
         first_segment: simple(:first),
-        more_segments: sequence(:rest)
+        more_segments: sequence(:rest),
+        attrs: sequence(:attrs)
       ) do |dict|
-        segments = [dict[:first]] + Array(dict[:rest]).compact
-        ElementPath.new(segments, absolute: false)
+        base = [dict[:first]] + Array(dict[:rest]).compact
+        attributes = Array(dict[:attrs]).compact
+        absolute = !dict[:abs].nil?
+
+        if attributes.empty? && base.none?(&:condition?)
+          ElementPath.new(base.map(&:segment), absolute: absolute)
+        else
+          InstancePath.new(base_steps: base, attribute_steps: attributes,
+                           absolute: absolute)
+        end
       end
     end
   end

data/lib/lutaml/path/version.rb

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

data/lib/lutaml/path.rb

@@ -2,20 +2,51 @@
 
 require "parslet"
 require_relative "path/version"
+require_relative "path/errors"
 require_relative "path/parser"
 require_relative "path/transformer"
-require_relative "path/element_path"
 require_relative "path/path_segment"
+require_relative "path/condition"
+require_relative "path/step"
+# abstract_path must precede element_path: `class ElementPath < AbstractPath`
+# resolves the constant at class-definition time.
+require_relative "path/abstract_path"
+require_relative "path/element_path"
+require_relative "path/instance_path"
+require_relative "path/resolver"
 
 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
+    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.
+      raise ParseError, "expression nests too deeply to parse"
+    end
+
+    # Resolves an instance data path against model instance data: a
+    # lutaml-model Serializable instance, a hash, or collections
+    # thereof. The path may be a parsed InstancePath or an instance
+    # path string.
+    def self.resolve(root, path)
+      path = parse_instance(path) if path.is_a?(::String)
+      Resolver.resolve(root, path)
+    end
+
+    # Parses an input explicitly as an instance data path.
+    def self.parse_instance(input)
+      tree = Parser.new.parse(input)
+      Transformer.new.apply(tree)
+    rescue Parslet::ParseFailed => e
+      raise ParseError, e.message
+    rescue SystemStackError
+      raise ParseError, "expression nests too deeply to parse"
     end
   end
 end

data/lutaml-path.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
 
-  spec.add_dependency "parslet"
+  spec.add_dependency "lutaml-model", ">= 0.8"
+  spec.add_dependency "parslet", "~> 2"
   spec.metadata["rubygems_mfa_required"] = "true"
 end