lutaml-xsd 1.2.101 → 1.2.103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6105bb86be0d4abbb820b3362454d8b05d2323366b35b6d1e6225feafc12dd57
-  data.tar.gz: 639b6495bc87a3d3b6a8ec3edac0dfc4457da4af3dba1bef20e4d2c464628c54
+  metadata.gz: 0406cd7f1ca030db5b4c6db63f060fdaae3981f61d2913f3552c510129f80b8c
+  data.tar.gz: 067f44365c98c7a9b3fd221c74d35965d5e628b3cb58f788e7210bd8a8cc6964
 SHA512:
-  metadata.gz: 7da7d36525dd07c46f9b81e9e1219f1faf5882c871cca810026b76b65f712cf8387e92ecee363a8f0a4ad23b75b42e7b5a1bcd41cf6a8b1c2793812b58dfaf1d
-  data.tar.gz: 6475b579cbaa25e35cfcdb497e60c501425337e65676406aec619fbc83a386fb66cf5f94b5e7c4d77a96e79b0ae13bd1818517ca2e10191ae9a31976b5f0fb44
+  metadata.gz: d7b9a1f01944bfe42b257e750226f2e9b200fbe3a30fe14ac834f3b1b7fdd675a12afb77764eaf821e09662674788ecf764064516477e26df394da4ba8b66ac2
+  data.tar.gz: 8dc0ac9729456a8903c6a2f70c4db8d1d2c7704076654ac173c4450aa089c76d3369a48f61d1638c210e26cd5b94584cebeff2af4700bdf3964b587136082183

data/TODO.conformance.md

@@ -519,7 +519,50 @@ 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
+  parent-context redesign opens with an ENGINE-LEVEL win: anyType
+  content is LAX — a child validates only against a declaration in
+  its OWN namespace, so a strictly-unresolvable child of an anyType
+  element (including one the namespace fallback would have served
+  from a targeted schema) is lax-undeclared and its subtree escapes
+  assessment (the suppression rides the existing skip-wildcard walk,
+  hereditary like QFE1700a1). The resolver gains resolve_strict
+  (exact-namespace only) and the shared anyType reference check.
+  errC007's contract is now enforced WITHOUT the namespace-fallback
+  narrowing that regressed five substitution/import shapes — those
+  lookups never touch this path. Round B (next): positional binding
+  for duplicate same-named particles (isDefault079) — ordered
+  per-call walk (the resolver's visited_particle? memoizes on the
+  instance and would poison repeats), gated on >1 same-named
+  particles AND all indexed (@namespaces.key? — the attempt-3
+  starvation guard).
+
   \p{Is...} per-block tests) plus the reL/reP/reQ/reR/reS/reT
 - ANYSIMPLETYPE-WHITESPACE ROUND (2026-11-07): +1 Additional
   (test93160; suite 4627->4628 = 98.55%, pending measure confirm).

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

@@ -58,12 +58,32 @@ module Lutaml
             # empty xs:int child escapes assessment too).
             next true if subtree_suppressed
 
-            skip_here = skip_wildcard_subtree?(parent, xml_element, resolver)
+            skip_here = skip_wildcard_subtree?(parent, xml_element, resolver) ||
+              lax_any_type_child?(parent, xml_element, resolver)
             next true if skip_here
 
             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?
@@ -203,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).
@@ -223,6 +260,40 @@ module Lutaml
           end
         end
 
+        # A child of an ANYTYPE element validates only against a
+        # declaration in its OWN namespace (anyType content is lax —
+        # errC007's contract); a child with no exact-namespace
+        # declaration is lax-undeclared and its subtree escapes
+        # assessment. The namespace fallback never serves this
+        # decision: a targeted schema's global is a DIFFERENT element
+        # than the unqualified child.
+        #
+        # @return [Boolean]
+        def lax_any_type_child?(parent, child, resolver)
+          return false unless parent
+
+          declaration = resolver.resolve(parent.name, parent.namespace_uri)
+          return false unless any_type_declaration?(declaration, resolver)
+
+          resolver.resolve_strict(child.name, child.namespace_uri).nil?
+        end
+
+        # Whether the declaration's effective type is xs:anyType:
+        # declared by reference, or the implicit default for a typeless
+        # declaration.
+        #
+        # @return [Boolean]
+        def any_type_declaration?(declaration, resolver)
+          return false unless
+            declaration.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+
+          return true if resolver.builtin_any_type?(declaration.type.to_s)
+
+          declaration.type.to_s.empty? &&
+            declaration.complex_type.nil? &&
+            declaration.simple_type.nil?
+        end
+
         # Handle errors that occur during rule execution
         #
         # @param rule [ValidationRule] The rule that failed

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

@@ -159,10 +159,14 @@ module Lutaml
           @expected_namespaces[element]
         end
 
+        # The namespace-EXACT resolution — no unique-name fallback. The
+        # lax anyType-content decision (errC007) and other
+        # namespace-strict consumers use it.
+        #
         # @param name [String] local element name
         # @param namespace_uri [String, nil] instance element namespace
         # @return [Lutaml::Xml::Schema::Xsd::Element, nil]
-        def resolve(name, namespace_uri)
+        def resolve_strict(name, namespace_uri)
           return nil if name.nil? || name.empty?
 
           candidates = @elements[name]
@@ -171,13 +175,33 @@ module Lutaml
           exact = candidates.find do |_element, namespace, _kind|
             namespace_matches?(namespace, namespace_uri)
           end
-          return exact&.first if exact
+          exact&.first
+        end
+
+        # Whether the type reference names xs:anyType.
+        #
+        # @param reference [String]
+        # @return [Boolean]
+        def builtin_any_type?(reference)
+          parts = reference.to_s.split(":")
+          %w[xs xsd].include?(parts.first) && parts.last == "anyType"
+        end
+
+        # @param name [String] local element name
+        # @param namespace_uri [String, nil] instance element namespace
+        # @return [Lutaml::Xml::Schema::Xsd::Element, nil]
+        def resolve(name, namespace_uri)
+          exact = resolve_strict(name, namespace_uri)
+          return exact if exact
 
           # Unique-name fallback for instances that omit namespaces even
           # though the schema declares one. A foreign namespace never
           # falls back.
           return nil unless namespace_uri.to_s.empty?
 
+          candidates = @elements[name]
+          return nil if candidates.empty?
+
           candidates.length == 1 ? candidates.first.first : nil
         end
 
@@ -563,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.101"
+    VERSION = "1.2.103"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.2.101
+  version: 1.2.103
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-07 00:00:00.000000000 Z
+date: 2026-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid