lutaml-xsd 1.2.83 → 1.2.84

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efe4fbd2d864e7cbe9218faaf7f67fc879c4e20cc32c54e04761fcee59d2d1dc
-  data.tar.gz: 3b5618daa924a8a493645bab5ea7f0408d3b9245c32695306131c1cb9a0cfeb8
+  metadata.gz: 0ba83c4ddd3e8f05926b71bd53ed35e0aba700381e1ca5ed13c803ac2164412b
+  data.tar.gz: ae5e50d04a1a0230afbbdf904484601800b5772b2348c2b374feef2fa75403d7
 SHA512:
-  metadata.gz: 909c81244dd126cbbb8843fcd3a010f5da4a3c70bd325b71ed5865496cc390d101fecb6d6a4c38069b350abad064c4837328f5ee28cdcb583b4ec5e439c629da
-  data.tar.gz: 34a60915d85511b36be444dc6903e8f3f221e6740d3d6147fd5966c0fe82a852896dffb20fbf6253376bb78abeaa4a2717da83b4b44e644739acda1e85105c33
+  metadata.gz: 6d52035a236b15bc9a063269dd5ee14389ec12d36619eb22cfcc85bbb9e98e17b2aedd55e41b6dbcbf7eb9e2f1797aaf83423b58d657e6e281befd52ab61c928
+  data.tar.gz: 6b35f257dbc8cadcd929212015294b407c2e5836c375e568a24bf71f05e41eb9823fbb97bf167f7bc289792e9a0f1d8f060088a7931594bc1b5d96aa99992a11

data/TODO.conformance.md

@@ -120,7 +120,7 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4585/4696 (97.64%) |
+| pipeline | 4588/4696 (97.7%) |
 
 (2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
@@ -144,7 +144,7 @@ lockfile refresh) → 4411 (93.9%) → 4430 (94.3%) → 4435 (94.4%) →
 → 4557 (97.0%) → 4565 (97.2%) → 4569 (97.3%) → 4562 (drift raw) →
 4563 (97.17%, ref-namespace round) → 4573 (97.38%, group-content
 round) → 4578 (97.49%, attribute-prohibition round) → 4585 (97.64%,
-multi-document round), +624 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
+multi-document round) → 4588 (97.7%, type-binding round), +627 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
 \w/\W/\s to their XSD value spaces) collapses Regex 120→69;
 same-step pattern facets now behave as alternatives and
 whitespace-only text reaches the facets intact (PR #200), Regex
@@ -494,6 +494,20 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   lutaml-model Redefine model shape study). Remaining Schema 9:
   schA1/Q1/D10/F2 (ours), schD7/G8 (lutaml-model#1087),
   schF1/G2/G7/P2 (moxml#510 composed bindings).
+- TYPE-BINDING ROUND (2026-11-03): +3 (Schema 9→8 — schQ1/schF2
+  flip; Particles 12→8 cumulatively with the collision round; suite
+  4585→4588 = 97.7%, zero regressions, rspec green). Same-local-name
+  types across a composition (three documents each declaring ct-A in
+  ns-a/ns-b/no-namespace) resolved to the FIRST candidate; the
+  resolver now keeps every candidate in document order and prefers
+  the one declared in the OWNING declaration's namespace (type
+  namespaces indexed at index time), with the no-namespace owner
+  preferring the no-namespace candidate; xsi:type overrides and
+  extension-base walks thread the deriving type namespace through.
+  STILL OPEN: schA1/schD10 (the hinted composition's CHILD value
+  checks bind the no-ns int ct-A to the ns-b boolean children —
+  'true' vs xsd:int — the per-child type plumbing under hint
+  layering), full type-redefine body semantics.
 - REGEX SEMANTICS ROUND (2026-10-31, PR #208): \w/\W now carry their
   Appendix F complements (\w = [^\p{P}\p{Z}\p{C}], class interiors
   via the exact positive partition L/M/N/S), \I/\C complements added

data/lib/lutaml/xsd/validation/rules/content_model_validation_rule.rb

@@ -247,7 +247,9 @@ module Lutaml
             xsi = repository && xsi_attribute(xml_element, "type")
             if xsi&.value.to_s.match?(/\S/)
               local = xsi.value.to_s.split(":").last
-              named = repository.resolve_named_type(local)
+              named = repository.resolve_named_type(
+                local, repository.target_namespace_for(schema_def)
+              )
               return nil unless named
 
               return type_particles(named, repository, {}.compare_by_identity)
@@ -303,7 +305,9 @@ module Lutaml
               if extension
                 base_local = extension.base.to_s.split(":").last
                 base_type = base_local &&
-                  repository&.resolve_named_type(base_local)
+                  repository&.resolve_named_type(
+                    base_local, repository&.target_namespace_for(type)
+                  )
                 particles = type_particles(base_type, repository, seen) +
                   particles
                 COMPLEX_PARTICLE_KINDS.each do |kind|

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

@@ -186,6 +186,9 @@ module Lutaml
         end
 
         # Named type for an element's `type="prefix:Name"` reference.
+        # Same-local-name types across composed documents resolve by
+        # the OWNING declaration's namespace (schA1: ct-A exists in
+        # ns-a/ns-b/no-namespace; the reference binds its own).
         #
         # @param schema_element [Lutaml::Xml::Schema::Xsd::Element, nil]
         # @return [Object, nil]
@@ -195,40 +198,67 @@ module Lutaml
           reference = schema_element.type
           return nil if reference.nil? || reference.to_s.empty?
 
-          resolve_named_type(reference.to_s.split(":").last)
+          resolve_named_type(reference.to_s.split(":").last,
+                             target_namespace_for(schema_element))
         end
 
-        # Named complex or simple type by local name.
+        # Named complex or simple type by local name, preferring a
+        # candidate declared in owner_ns.
         #
         # @param local_name [String]
+        # @param owner_ns [String, nil] the referencing declaration's
+        #   target namespace
         # @return [Object, nil]
-        def resolve_named_type(local_name)
+        def resolve_named_type(local_name, owner_ns = nil)
           return nil if local_name.nil? || local_name.empty?
-          return @named_types[local_name] if @named_types.key?(local_name)
 
-          result = nil
-          schemas.each do |schema|
-            result = named_type_in(local_name, schema)
-            break if result
+          list = named_type_candidates(local_name)
+          return nil if list.empty?
+          # A nil owner means the referencing declaration lives in NO
+          # namespace (schA1_c): prefer the no-namespace candidate, not
+          # just the first.
+          if owner_ns.nil?
+            return list.find { |t| @namespaces[t].to_s.empty? } ||
+                list.first
           end
-          if result.nil? && !@redefined_body_names.include?(local_name)
-            @redefined_targets.each do |schema|
-              result = named_type_in(local_name, schema)
-              break if result
-            end
-          end
-          @named_types[local_name] = result
+
+          list.find { |t| @namespaces[t] == owner_ns } || list.first
         end
 
-        # @return [Object, nil]
-        def named_type_in(local_name, schema)
-          found = Array(schema.complex_type).find do |ct|
-            ct.name == local_name
+        # Every top-level and nested declaration of the name, in
+        # document order: schemas first, then parsed redefine targets
+        # (names a redefine body redefines stay off the targets).
+        #
+        # @return [Array<Object>]
+        def named_type_candidates(local_name)
+          cache = @named_type_lists ||= {}
+          return cache[local_name] if cache.key?(local_name)
+
+          list = []
+          schemas.each do |schema|
+            found = Array(schema.complex_type).find do |ct|
+              ct.name == local_name
+            end
+            found ||= Array(schema.simple_type).find do |st|
+              st.name == local_name
+            end
+            list << found if found
+
+            nested = find_nested_named_type(local_name, schema)
+            list << nested if nested
           end
-          found ||= Array(schema.simple_type).find do |st|
-            st.name == local_name
+          unless @redefined_body_names.include?(local_name)
+            @redefined_targets.each do |schema|
+              found = Array(schema.complex_type).find do |ct|
+                ct.name == local_name
+              end
+              found ||= Array(schema.simple_type).find do |st|
+                st.name == local_name
+              end
+              list << found if found
+            end
           end
-          found || find_nested_named_type(local_name, schema)
+          cache[local_name] = list.uniq
         end
 
         # Named types declared in documents reached through resolved
@@ -767,6 +797,7 @@ module Lutaml
         def index_type(index, complex_type, namespace, schema)
           return unless complex_type
 
+          @namespaces[complex_type] = namespace
           each_particle_element(complex_type, schema) do |element|
             index_element(index, element, namespace, :inline, schema)
           end

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.83"
+    VERSION = "1.2.84"
   end
 end

metadata

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