lutaml-xsd 1.2.98 → 1.2.100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e129470c8c939e17b19e748ffaebf593f7f3909876fbe05e1b733e1129f448ba
-  data.tar.gz: '03015085efe53c4dca6dec3bc5115d9081b42a24c2f758b19c4c3424b672521f'
+  metadata.gz: 2fb04a8aef728bbfb826bd9e49561e8a2e4949a0a8da01afb5d3f0306b50a14e
+  data.tar.gz: 438fdfc6d197d4f1aa146232aa5a2d73c77f2181b0925c2d44328631876dd433
 SHA512:
-  metadata.gz: 4e1be4de4f925cb152fa5f69e2cb57fb42d9337ab37628b71314ab0e3bc7a5d10da9cf829173a78303c0e8e495682286bb9ecf4bde0d72056324d6e572d309cc
-  data.tar.gz: ae47a5ca4b9bc803c7e7c35aaeb0a9e8a35e9610bddacdd82d14b269310863f91d64a9f59f1cd9f0014ea72dd0040f975098feccd30914fc6e7cf053845a9b91
+  metadata.gz: 2a7fb730886d8296d8c3daff45401f6b7b1dc817a5030ce1f9a5170914290cc95c6bc532eb6f42eecb9a85026686b0e5ecca47ca2f7d9b0f9b70ba68d5c71413
+  data.tar.gz: dbe58ef59e792eb32eb0b42f6db501a797cc8423fea41656d89e20ec7b79257e279832ad0ef4c2c5e1ede93f142b6e66fdd5fdf09599f5b55fafef6c11d588ce

data/TODO.conformance.md

@@ -522,7 +522,39 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   ~177 cases — the ENTIRE Unicode-block escape family (~80
   \p{Is...} per-block tests) plus the reL/reP/reQ/reR/reS/reT
   series — filed leptris-rs#47; moxml 0.6.3 regressed 5 attribute
+- WILDCARD-LAYERING ROUND (2026-11-07): +3 Wildcards (wildZ013b/c
+  valid, wildZ013e invalid; suite 4624->4627 = 98.57%, zero
+  regressions, rspec green). THREE defects: (1) attributeGroup refs
+  nested in content parts never contributed their anyAttribute
+  wildcards (wildZ013b — the extension's attG2-51 ref); (2) the
+  derivation wildcard list admitted with plain UNION semantics where
+  same-type wildcards must INTERSECT (wildZ013e: intersection1's
+  ##other + ##local b c give set(b, c) — absent-ns attributes fail
+  ##other) — collect_any_attribute now returns one GROUP per
+  derivation layer: groups union (the extension union, ctH011
+  unchanged), members intersect; (3) the chameleon import's ##other
+  evaluated against the INCLUDER's target namespace — the
+  per-wildcard owner tns (indexed for attributeGroup declarations
+  and redefine bodies now) evaluates a chameleon's ##other against
+  its own ABSENT target (wildZ013c's ##local b c + ##other(not-
+  absent) admit everything the instance carries). Family: Wildcards
+  + Attribute clean; AttributeGroup 14 = the parked moxml#522 set.
+
   cases (addB059/196c/197c, attO009/011) — filed moxml#529. THE
+- REDEFINE-GROUP ROUND (2026-11-07): +2 ModelGroups (mgO006,
+  mgO034; suite 4622->4624 = 98.46%, zero regressions, rspec
+  green). index_redefine registered simpleType bodies
+  (@redefined_simple_bodies) and attributeGroup bodies
+  (@attribute_groups) but NOT group bodies — resolve_group walked
+  the schemas and found the TARGET original (mgO006B's
+  all(e1, e2?)) instead of the redefining body (choice(e1)), so
+  foo's sequence(e1, group-ref) saw two e1s against the all's
+  max-1 and false-positived occurrence bounds. The body IS the
+  effective definition for every reference to the name (§4.2.2 —
+  the same principle the simple-type round landed for stZ033).
+  Group sentinels (schT redefine trio, groupG/H/J, idF/G engine
+  legs) unchanged.
+
   STACK IS PINNED BACK to the known-good 1.9.406.0/0.6.2/0.8.161
 - SKIP-WILDCARD-FIELD ROUND (2026-11-07): +1 IC (idZ015; suite
   4621->4622 = 98.42%, zero regressions, rspec green). THE LAST IC

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

@@ -538,9 +538,14 @@ module Lutaml
 
               xml_attr = xml_attrs.find { |xa| xa.name == attr_name }
               next unless xml_attr
-              next if wildcards.any? do |wildcard|
-                wildcard_permits_attribute?(wildcard, xml_element, xml_attr,
-                                            nil)
+              # A wildcard that admits the attribute shadows the
+              # prohibition (attZ002): any group admitting (union
+              # across layers, intersection within).
+              next if wildcards.any? do |group|
+                group.all? do |wildcard|
+                  wildcard_permits_attribute?(wildcard, xml_element,
+                                              xml_attr, nil)
+                end
               end
 
               report_error(
@@ -1042,20 +1047,23 @@ module Lutaml
               next if xml_attr.namespace_uri == XmlBuiltins::NAMESPACE &&
                 XmlBuiltins.attribute(xml_attr.name)
 
-              # The derivation's wildcard UNION admits: any permitting
-              # wildcard covers the attribute, and a strict mode on any
-              # admitting wildcard still demands a declaration in the
-              # attribute's own namespace.
+              # The derivation's wildcard GROUPS admit: ACROSS groups
+              # (derivation layers) any group admits the attribute — the
+              # extension union; WITHIN a group every wildcard must
+              # admit — same-type wildcards intersect (wildZ013b/c/e).
               admitted = false
               strict_undeclared = false
-              wildcards.each do |wildcard|
-                next unless wildcard_permits_attribute?(wildcard,
-                                                        xml_element,
-                                                        xml_attr, repository)
+              wildcards.each do |group|
+                next unless group.all? do |wildcard|
+                  wildcard_permits_attribute?(wildcard, xml_element,
+                                              xml_attr, repository)
+                end
 
                 admitted = true
-                if wildcard_process_mode(wildcard) == "strict" &&
+                group.each do |wildcard|
+                  next unless wildcard_process_mode(wildcard) == "strict" &&
                     !attribute_declared?(xml_attr, repository)
+
                   strict_undeclared = true
                 end
               end
@@ -1106,7 +1114,12 @@ module Lutaml
           # UNION — a base type's wildcard stays in force beside the
           # extension's own (ctH011: ##local base + ##other extension).
           #
-          # @return [Array<AnyAttribute>]
+          # @return [Array<Array<AnyAttribute>>] wildcard GROUPS: one
+          #   group per derivation layer (the base's groups stay beside
+          #   the derived layer — the extension union, wildZ013b/c);
+          #   wildcards INSIDE one group are same-type and intersect
+          #   (wildZ013e: intersection1's two attributeGroup refs give
+          #   set(b, c), rejecting what ##other alone would admit).
           def collect_any_attribute(schema_def, repository = nil,
                                     xml_element = nil)
             if schema_def.is_a?(Lutaml::Xml::Schema::Xsd::Element)
@@ -1122,21 +1135,21 @@ module Lutaml
             end
             return [] unless schema_def
 
-            wildcards = []
+            own = []
             complex_wildcard = schema_def.any_attribute if
               schema_def.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType) &&
                 complex_type_wildcard_support?
-            wildcards << complex_wildcard if complex_wildcard
+            own << complex_wildcard if complex_wildcard
 
             # A wildcard nested in an attributeGroup DECLARATION reaches
             # the type only through the group's resolution — the type's
             # ref particle carries no children of its own (attgD019).
             Array(schema_def.attribute_group).each do |group|
               Array(group.any_attribute).each do |wildcard|
-                wildcards << wildcard
+                own << wildcard
               end
 
-              collect_group_wildcards(group, repository, wildcards, 0)
+              collect_group_wildcards(group, repository, own, 0)
             end
 
             CONTENT_KINDS.each do |content_kind|
@@ -1146,22 +1159,31 @@ module Lutaml
               CONTENT_PART_KINDS.each do |part_kind|
                 Array(content.public_send(part_kind)).each do |part|
                   Array(part.any_attribute).each do |wildcard|
-                    wildcards << wildcard
+                    own << wildcard
+                  end
+                  # An attributeGroup REF inside the derivation body
+                  # carries the wildcard the type presents (wildZ013b:
+                  # the extension's attG2-51 ref).
+                  Array(part.attribute_group).each do |group_ref|
+                    collect_group_wildcards(group_ref, repository, own, 0)
                   end
                 end
               end
             end
 
             # The base type's wildcard flows into the derived type
-            # through extension and restriction alike.
+            # through extension and restriction alike — as its own
+            # layer beside the derived one.
             base = derivation_base(schema_def, repository)
-            wildcards.concat(collect_any_attribute(base, repository)) if base
-
-            wildcards
+            groups = base ? collect_any_attribute(base, repository) : []
+            groups.unshift(own) unless own.empty?
+            groups
           end
 
           # The wildcards of an attributeGroup reference's DECLARATION,
-          # following nested attributeGroup refs (depth-guarded).
+          # following nested attributeGroup refs (depth-guarded). Each
+          # wildcard records its declaring group's effective target
+          # namespace for the ##other evaluation.
           #
           # @return [void]
           def collect_group_wildcards(group, repository, wildcards, depth)
@@ -1175,6 +1197,8 @@ module Lutaml
 
             Array(declaration.any_attribute).each do |wildcard|
               wildcards << wildcard
+              wildcard_owner_tns[wildcard] =
+                repository&.target_namespace_for(declaration)
             end
 
             Array(declaration.attribute_group).each do |nested|
@@ -1214,7 +1238,15 @@ module Lutaml
           def wildcard_permits_attribute?(wildcard, parent, xml_attr,
                                           repository)
             ns = xml_attr.namespace_uri.to_s
-            target = content_target_namespace(parent, repository).to_s
+            # The WILDCARD's own declaration namespace — a chameleon
+            # document's ##other evaluates against its own (absent)
+            # target, not the includer's (wildZ013c).
+            target =
+              if wildcard_owner_tns.key?(wildcard)
+                wildcard_owner_tns[wildcard].to_s
+              else
+                content_target_namespace(parent, repository).to_s
+              end
             case wildcard.namespace.to_s
             when "##any", ""
               true
@@ -1237,6 +1269,16 @@ module Lutaml
             end
           end
 
+          # The effective target namespace of each collected wildcard's
+          # DECLARING attributeGroup (identity-keyed — equal-valued
+          # wildcards eql? together). Untracked wildcards fall back to
+          # the element declaration's namespace.
+          #
+          # @return [Hash]
+          def wildcard_owner_tns
+            @wildcard_owner_tns ||= {}.compare_by_identity
+          end
+
           # Whether a strict-wildcard attribute resolves to a global
           # declaration in the attribute's OWN namespace — the
           # unique-name fallback may not answer for a different

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

@@ -65,6 +65,11 @@ module Lutaml
           # redefined enumeration). The facet walk never recurses into
           # named bases, so the body's base reference terminates here.
           @redefined_simple_bodies = {}
+          # Redefine GROUP bodies: the body is the effective definition
+          # for every reference to the name (§4.2.2 — same principle as
+          # the simple-type bodies; mgO006/034: the body's choice(e1)
+          # replaces the target's all(...)).
+          @redefined_groups = {}
           # Exact namespaces for PREFIXED ref particles, from the
           # owning schema's xmlns declarations (lutaml-model 0.8.167
           # retains them — #1131). The prefix IS the semantics: a ref
@@ -483,6 +488,11 @@ module Lutaml
         def resolve_group(local_name)
           return nil if local_name.nil? || local_name.empty?
 
+          # A redefine body is the effective definition for every
+          # reference to the name — the target originals never serve.
+          body = @redefined_groups[local_name]
+          return body if body
+
           schemas.each do |schema|
             found = Array(schema.group).find { |g| g.name == local_name }
             return found if found
@@ -941,6 +951,10 @@ module Lutaml
           Array(schema.attribute_group).each do |group|
             name = group.name.to_s
             @attribute_groups[name] = group unless name.empty?
+            # The group's own effective target namespace — a chameleon
+            # document's wildcards evaluate against the includer's
+            # (wildZ013c), a named document's against its own.
+            @namespaces[group] = namespace unless name.empty?
             Array(group.attribute).each do |member|
               index_local_attribute(member, namespace, defaults_schema)
             end
@@ -1039,6 +1053,13 @@ module Lutaml
             original = @attribute_groups[name]
             @redefined_originals[name] = original if original
             @attribute_groups[name] = group
+            @namespaces[group] = namespace
+          end
+          Array(red.group).each do |group|
+            name = group.name.to_s
+            next if name.empty?
+
+            @redefined_groups[name] = group
           end
         end
 

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.98"
+    VERSION = "1.2.100"
   end
 end

metadata

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