lutaml-xsd 1.2.102 → 1.2.103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1b37fc4af01d8c2f652a899644d9f85f13fec225d6ae0ce393b7d16f19df5bc
-  data.tar.gz: 2b08927d906be739a784888c3e1d9c9fb5a303362cc6dcc565404e0500b4f74d
+  metadata.gz: 0406cd7f1ca030db5b4c6db63f060fdaae3981f61d2913f3552c510129f80b8c
+  data.tar.gz: 067f44365c98c7a9b3fd221c74d35965d5e628b3cb58f788e7210bd8a8cc6964
 SHA512:
-  metadata.gz: 95823a7f86274b2363e65b1a36d0b9aff1078c55196c8f53982d065ec67f0b32b60d1c18436ff8839f65f150373ffa822fa0c4cdaf046f042694ef94279fb0cc
-  data.tar.gz: f85b40f50b7ac8d93bfe7341feb8eaf4442ea4ac3b0fb9f3ea51cbb3f832835ac3f36033f9897e816371ba99ddf206f7c271a81389b3bf32370acc2104670968
+  metadata.gz: d7b9a1f01944bfe42b257e750226f2e9b200fbe3a30fe14ac834f3b1b7fdd675a12afb77764eaf821e09662674788ecf764064516477e26df394da4ba8b66ac2
+  data.tar.gz: 8dc0ac9729456a8903c6a2f70c4db8d1d2c7704076654ac173c4450aa089c76d3369a48f61d1638c210e26cd5b94584cebeff2af4700bdf3964b587136082183

data/TODO.conformance.md

@@ -519,6 +519,30 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   0.6.3 + lutaml-model 0.8.166 train carried fixes (the FULL #45
   stE legs, the #522 attgC four + attgD mostly + attJ018 +
   schF1/P2, stE065/066/096) AND a WHOLESALE 407 regex regression:
+- PARENT-CONTEXT ROUND B (2026-11-08): +1 Additional (isDefault079;
+  suite 4629->4630 = 98.59%, zero regressions, rspec green).
+  POSITIONAL BINDING for duplicate same-named locals: a model with
+  two regvalueop locals carrying DIFFERENT fixed values never bound
+  the second child to the second particle — the name-only dispatch
+  always hit the first. The engine computes each child's same-name
+  sibling index (on the RAW moxml nodes — wrapper objects are not
+  identity-stable across accessor calls, the IdUniquenessRule
+  lesson) and dispatches the positionally-bound declaration when
+  (a) the parent's model holds MORE THAN ONE same-named particle,
+  (b) every particle is INDEXED (attempt-3's starvation guard: raw
+  parent-model particles carry none of the form/ns metadata the
+  rules assume — resolver positional_children returns [] otherwise),
+  and (c) the candidate's expected namespace AGREES with the child's
+  (particlesQ016's global/local namesake guard). The ordered walk
+  keeps a PER-CALL visited set — the resolver's
+  each_particle_element memoizes on the instance and would poison
+  repeats. LESSON: scripted line-surgery on lib files dropped a
+  class end and leaked methods to top level (runtime-only
+  uninitialized-constant failures, caught by sentinel probes) —
+  structural edits go through the Edit tool only. Remaining parked
+  (matcher-assignment + root-assessment shapes): QFE1700c1,
+  addB065, addB188, schA1/D10 + the lax-wildcard six.
+
   ~177 cases — the ENTIRE Unicode-block escape family (~80
 - PARENT-CONTEXT ROUND A (2026-11-08): +1 Errata10 (errC007; suite
   4628->4629 = 98.57%, zero regressions, rspec green). The

data/lib/lutaml/xsd/validation/rule_engine.rb

@@ -65,6 +65,25 @@ module Lutaml
             schema_def = resolver.resolve(
               xml_element.name, xml_element.namespace_uri
             )
+            if parent
+              parent_declaration =
+                resolver.resolve(parent.name, parent.namespace_uri)
+              candidates = resolver.positional_children(parent_declaration,
+                                                        xml_element.name)
+              positional = candidates[same_name_sibling_index(xml_element,
+                                                              parent)]
+              # The binding must agree with the child's OWN namespace:
+              # an unqualified ref's global namesake never serves a
+              # qualified local namesake (particlesQ016).
+              child_ns = xml_element.namespace_uri.to_s
+              expected_ns =
+                resolver.expected_namespace_for(positional).to_s
+              if positional &&
+                  ((child_ns.empty? && expected_ns.empty?) ||
+                   child_ns == expected_ns)
+                schema_def = positional
+              end
+            end
             rules.each do |rule|
               argument = rule.schema_argument(schema_def, repository: resolver)
               next if argument.nil? && !rule.runs_without_schema?
@@ -204,6 +223,23 @@ module Lutaml
           end
         end
 
+        # The child's position among its same-named siblings — the index
+        # the positional binding (duplicate same-named declarations,
+        # isDefault079) binds to. Computed on the RAW moxml nodes: the
+        # wrapper objects are not identity-stable across accessor calls
+        # (the IdUniquenessRule lesson).
+        #
+        # @return [Integer]
+        def same_name_sibling_index(element, parent)
+          raw_children = Array(parent.moxml_element.elements)
+          position = raw_children.index do |node|
+            node.equal?(element.moxml_element)
+          end
+          return 0 if position.nil?
+
+          raw_children.take(position).count { |node| node.name == element.name }
+        end
+
         # Whether the parent's content model holds a processContents
         # skip wildcard whose namespace range admits the child — the
         # child subtree then escapes assessment entirely (addB125).

data/lib/lutaml/xsd/validation/schema_definition_resolver.rb

@@ -587,8 +587,92 @@ module Lutaml
           element_declaration_simple?(field_decl)
         end
 
+        # The ordered same-named inline particles of the parent's
+        # content model — the POSITIONAL binding for duplicate
+        # declarations (isDefault079: two regvalueop locals with
+        # different fixed values; the second child binds to the second
+        # particle). Returns [] unless the name appears MORE THAN ONCE
+        # and every particle is INDEXED (attempt-3's starvation: raw
+        # particles carry none of the form/ns metadata the rules
+        # assume). The walk keeps its own cycle guard — the resolver's
+        # each_particle_element memoizes visited nodes on the instance
+        # and would poison repeated walks.
+        #
+        # @param parent_declaration [Lutaml::Xml::Schema::Xsd::Element, nil]
+        # @param local_name [String]
+        # @return [Array<Lutaml::Xml::Schema::Xsd::Element>]
+        def positional_children(parent_declaration, local_name)
+          type = parent_declaration&.complex_type ||
+            resolve_type(parent_declaration)
+          return [] unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+
+          particles = []
+          collect_named_particles(particle_for_type(type), local_name,
+                                  particles, {}.compare_by_identity, 0)
+          return [] if particles.length < 2
+          return [] unless particles.all? { |p| @namespaces.key?(p) }
+
+          particles
+        end
+
         private
 
+        # Depth-first ordered collection of same-named element
+        # particles; per-call visited set (identity-keyed), group refs
+        # expanded.
+        #
+        # @return [void]
+        def collect_named_particles(node, local_name, out, visited, depth)
+          return if node.nil? || depth > 24
+
+          if node.is_a?(Array)
+            node.each do |child|
+              collect_named_particles(child, local_name, out, visited,
+                                      depth + 1)
+            end
+            return
+          end
+          return if visited[node]
+
+          visited[node] = true
+
+          if node.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+            if node.name.to_s.split(":").last == local_name
+              out << node
+            elsif node.ref.to_s.match?(/\S/) &&
+                node.ref.to_s.split(":").last == local_name
+              global = resolve_global(node.ref.to_s.split(":").last, nil)
+              out << global if global
+            end
+            return
+          end
+
+          nested = CONTAINER_NESTED_KINDS[node.class]
+          nested&.each do |kind|
+            collect_named_particles(Array(node.public_send(kind)),
+                                    local_name, out, visited, depth + 1)
+          end
+          (CONTAINER_LEAF_KINDS[node.class] || []).each do |kind|
+            Array(node.public_send(kind)).each do |leaf|
+              next unless leaf
+
+              if leaf.is_a?(Lutaml::Xml::Schema::Xsd::Group)
+                resolved = if leaf.ref
+                             resolve_group(leaf.ref.to_s
+                                             .split(":").last)
+                           else
+                             leaf
+                           end
+                collect_named_particles(resolved, local_name, out, visited,
+                                        depth + 1)
+              elsif leaf.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+                collect_named_particles(leaf, local_name, out, visited,
+                                        depth + 1)
+              end
+            end
+          end
+        end
+
         # Whether a TYPE carries an identity value for a field bound to
         # the selector node itself (a "." field): a simple type or a
         # complex type with simple content does; complex content does not.

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.102"
+    VERSION = "1.2.103"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.102
+  version: 1.2.103
 platform: ruby
 authors:
 - Ribose Inc.