lutaml-xsd 1.2.82 → 1.2.84

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c3da66790f16686077f84ff27947241c3fd9290e4a36f92d5b26ee70d340af4
-  data.tar.gz: 205af1e6a170523b054c34ba0cf43b86203877784bfe471ef88e47bcdbf60ae9
+  metadata.gz: 0ba83c4ddd3e8f05926b71bd53ed35e0aba700381e1ca5ed13c803ac2164412b
+  data.tar.gz: ae5e50d04a1a0230afbbdf904484601800b5772b2348c2b374feef2fa75403d7
 SHA512:
-  metadata.gz: 6901b1b6a2fc09e00325fe3e24df146097e6bf6967493e46e04d7eabe8b7a9183cdccc2cc8ccf39cfd9d0f3cf90157b0647c772f61512a68085c041fbf1329be
-  data.tar.gz: 221ce2f9ce160b0524a99cb9dfb029ccc10040adbe8282e8cb37ecbc94cc9f689e1a6b2e28a6ca27cd069ef2c6547a5d728f37a3254b5fc501b9cce50d27118c
+  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 | 4578/4696 (97.49%) |
+| pipeline | 4588/4696 (97.7%) |
 
 (2026-11-02, bundled-stack measurement with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
@@ -143,7 +143,8 @@ lockfile refresh) → 4411 (93.9%) → 4430 (94.3%) → 4435 (94.4%) →
 (96.3%) → 4534 (96.6%) → 4540 (96.7%) → 4542 (96.7%) → 4546 (96.8%)
 → 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), +617 net over the 1.2.43 baseline. The escapes round (PR #197 — \d→\p{Nd},
+round) → 4578 (97.49%, attribute-prohibition round) → 4585 (97.64%,
+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
@@ -470,6 +471,43 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   use-site fixed overlays the global declaration in the value check
   (attLa005). Attribute remainder (4): attJ018 + attO009/011
   (engine-silent — queue), attO006 (leptris-rs#25 attribute leg).
+- MULTI-DOCUMENT ROUND (2026-11-03): +7 (Schema 12→9 — the schT3/T9/
+  T10 redefine trio; ComplexType 4→1, Particles 12→10, Additional
+  10→9, IC 7→6 — same-namespace collision pairs; suite 4578→4585 =
+  97.64%, zero regressions, rspec green). TWO defects: (a) the
+  conformance repository keyed documents by TARGET NAMESPACE, so two
+  schemaDocuments sharing a namespace silently overwrote each other
+  and only one survived (schT3's redefine pair, both ns-a); a
+  same-namespace collision now suffixes the key instead of dropping
+  the document — every other case keeps the production one-doc-per-
+  namespace semantics (a naive path-key for everything cost 25
+  regressions via the unique-name fallback and first-match type
+  lookup, caught and reverted in-round). (b) resolve_named_type now
+  falls back to the parsed xs:redefine target documents: types living
+  only in the target (schT3 b-ct/b-st) resolve for plain references;
+  names a redefine BODY redefines stay OFF that path (the body is the
+  effective type and is not resolvable here — idF/idG/idH keep the
+  lenient path). KNOWN GAPS left open: schA1/schQ1/schD10/schF2
+  (hint-composition with same-local-name ct-A across namespaces —
+  per-namespace type binding), full type-redefine body semantics
+  (the body as effective type with the self-base hook — a
+  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/conformance/w3c_suite.rb

@@ -154,8 +154,17 @@ module Lutaml
           test_case.schema_paths.each do |path|
             schema = Lutaml::Xml::Schema::Xsd.parse(File.read(path),
                                                     location: path)
-            key = schema.target_namespace if
-              schema.target_namespace.to_s.match?(/\S/)
+            # Keyed by target namespace like production, EXCEPT that a
+            # same-namespace collision suffixes the key instead of
+            # dropping the document (schT3's redefine pair both declare
+            # ns-a). The resolver iterates values; keys only need to
+            # keep every document present.
+            key = if schema.target_namespace.to_s.match?(/\S/)
+                    schema.target_namespace
+                  else
+                    path
+                  end
+            key = "#{key}##{path}" while schemas.key?(key)
             schemas[key] = schema
             locations[path] = schema
           end

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

@@ -222,7 +222,11 @@ module Lutaml
               # Base attributes flow through both derivations — a
               # restriction narrows them but cannot drop them (XSD 1.0
               # §3.4.2).
-              attributes.concat(inherited_attributes(part.base, repository)) if part
+              if part
+                attributes.concat(
+                  inherited_attributes(part, repository),
+                )
+              end
             end
 
             # Handle simple content
@@ -234,7 +238,11 @@ module Lutaml
               )
               part = Array(schema_def.simple_content.extension).first ||
                 Array(schema_def.simple_content.restriction).first
-              attributes.concat(inherited_attributes(part.base, repository)) if part
+              if part
+                attributes.concat(
+                  inherited_attributes(part, repository),
+                )
+              end
             end
 
             override_base_prohibitions(schema_def, attributes)
@@ -267,11 +275,13 @@ module Lutaml
           end
 
           # The base type's attribute set flows into the derived type
-          # through extension and restriction alike.
+          # through extension and restriction alike. The base resolves
+          # through the derivation so a redefine body's own base hooks
+          # to the original definition.
           #
           # @return [Array<Lutaml::Xml::Schema::Xsd::Attribute>]
-          def inherited_attributes(base_name, repository)
-            local = base_name.to_s.split(":").last
+          def inherited_attributes(part, repository)
+            local = part.base.to_s.split(":").last
             return [] if local.to_s.empty?
 
             base = repository&.resolve_named_type(local)

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)
@@ -302,7 +304,10 @@ module Lutaml
               restriction = Array(content.restriction).first
               if extension
                 base_local = extension.base.to_s.split(":").last
-                base_type = base_local && repository&.resolve_named_type(base_local)
+                base_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

@@ -50,6 +50,14 @@ module Lutaml
           @attributes = Hash.new { |hash, key| hash[key] = [] }
           @attribute_groups = {}
           @redefined_originals = {}
+          # Parsed xs:redefine target documents: their named types back
+          # the redefined bodies (schT3: b-ct/b-st live in the target,
+          # which the repository does not hold). Names a redefine BODY
+          # redefines are NOT served from the target: the body is the
+          # effective type and is not resolvable here, so those keep
+          # the lenient unresolvable path (idF/idG/idH class).
+          @redefined_targets = []
+          @redefined_body_names = []
           @elements = index_elements
         end
 
@@ -178,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]
@@ -187,18 +198,43 @@ 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
+          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
+
+          list.find { |t| @namespaces[t] == owner_ns } || list.first
+        end
+
+        # 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
@@ -206,10 +242,23 @@ module Lutaml
             found ||= Array(schema.simple_type).find do |st|
               st.name == local_name
             end
-            result = found || find_nested_named_type(local_name, schema)
-            break if result
+            list << found if found
+
+            nested = find_nested_named_type(local_name, schema)
+            list << nested if nested
+          end
+          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
-          @named_types[local_name] = result
+          cache[local_name] = list.uniq
         end
 
         # Named types declared in documents reached through resolved
@@ -602,35 +651,60 @@ module Lutaml
           # indexed under the name (attgC007/attgD036). Runs after the
           # nested descent so included declarations are already in.
           Array(schema.redefine).each do |red|
-            target_path = nil
-            base = begin
-              File.dirname(@repository.source_path_for(schema))
+            index_redefine(index, schema, red, held_signatures, namespace,
+                           defaults_schema)
+          end
+        end
+
+        # xs:redefine replaces an attributeGroup with a body whose
+        # self-reference is the §4.2.2 hook to the ORIGINAL
+        # definition. lutaml-model does NOT chase the redefine
+        # target, so the original document is parsed here (relative
+        # to the defining file) and indexed; the original
+        # declaration is kept for that hook and the redefining body
+        # indexed under the name (attgC007/attgD036). Runs after the
+        # nested descent so included declarations are already in.
+        def index_redefine(index, schema, red, held_signatures, namespace,
+                           defaults_schema)
+          target_path = nil
+          base = begin
+            File.dirname(@repository.source_path_for(schema))
+          rescue StandardError
+            nil
+          end
+          if base && red.schema_path.to_s.match?(/\S/)
+            candidate = File.expand_path(red.schema_path.to_s, base)
+            target_path = candidate if File.exist?(candidate)
+          end
+          if target_path
+            begin
+              target = Lutaml::Xml::Schema::Xsd.parse(
+                File.read(target_path), location: target_path
+              )
+              @redefined_targets << target
+              index_schema(index, target, held_signatures, namespace,
+                           defaults_schema)
             rescue StandardError
               nil
             end
-            if base && red.schema_path.to_s.match?(/\S/)
-              candidate = File.expand_path(red.schema_path.to_s, base)
-              target_path = candidate if File.exist?(candidate)
-            end
-            if target_path
-              begin
-                target = Lutaml::Xml::Schema::Xsd.parse(
-                  File.read(target_path), location: target_path
-                )
-                index_schema(index, target, held_signatures, namespace,
-                             defaults_schema)
-              rescue StandardError
-                nil
-              end
-            end
-            Array(red.attribute_group).each do |group|
-              name = group.name.to_s
-              next if name.empty?
+          end
+          # Names the body redefines: served by the body (not
+          # resolvable here), never by the target originals.
+          Array(red.complex_type).each do |body|
+            name = body.name.to_s
+            @redefined_body_names << name unless name.empty?
+          end
+          Array(red.simple_type).each do |body|
+            name = body.name.to_s
+            @redefined_body_names << name unless name.empty?
+          end
+          Array(red.attribute_group).each do |group|
+            name = group.name.to_s
+            next if name.empty?
 
-              original = @attribute_groups[name]
-              @redefined_originals[name] = original if original
-              @attribute_groups[name] = group
-            end
+            original = @attribute_groups[name]
+            @redefined_originals[name] = original if original
+            @attribute_groups[name] = group
           end
         end
 
@@ -723,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.82"
+    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.82
+  version: 1.2.84
 platform: ruby
 authors:
 - Ribose Inc.