lutaml-xsd 1.2.97 → 1.2.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74cc0c3c59a0cb1a80968d340ccf4d8be8b7d9ce9d1257c7e59044ebd85bc5b0
-  data.tar.gz: 453526a2baaeb84186acb8f3d84b573ddaeb988af120acf601bd2e621cd159e2
+  metadata.gz: fa20de2fba923a0b6485653e7902c20694898ac8583b90f5e144b11b7ae61fc4
+  data.tar.gz: ccd4a57412cd1095538a9a72988d9b792f8f3ae213d4c644a401391d32cafcbc
 SHA512:
-  metadata.gz: 67c01245e71827ab4682e6dda886b296586d96960b5e814b1b1e9ccbdee53d4fc33ee95ed705b90730e636f0f2c0ea5a7f325809072a7e0a0bd79d0928b91a79
-  data.tar.gz: 3246ef0bfd177d2019fa3fd08b01409647d2d2d71c4bb8757e108a55c9374f72684f258e46419bece176a03f94a24a3c44c11ec484b38f9fe60e4114099f022e
+  metadata.gz: 421748a4d525018acc64f0a85f0d84b07320f456017bd06c481bb2cb0b97eeb8b394fbbed64a50f8c3e037277a627d8aa322aabbb2eb9983861f798c78126734
+  data.tar.gz: 63b4a57e42b8431ab7cec97f0fd015520c991c1ff8ab4017a7f4210f1d9b3f7f3480c8fca5e4c7ddc11079e818bfe4211030ef30cdeb4e6e04714468ca1015d7

data/TODO.conformance.md

@@ -523,7 +523,41 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   \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
   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
+  SINGLETON — the idK/idZ family is now CLEAN (all six roots fixed
+  across the four rounds). An attribute admitted by a
+  processContents=skip wildcard is NOT ASSESSED, so it supplies no
+  identity-constraint field value: the field treats it as absent and
+  a key whose fields do not all evaluate is violated (idZ015: foo's
+  ##any skip anyAttribute + key field @bar; xmllint: "Not all fields
+  of key identity-constraint evaluate to a node"). The skip check
+  walks the selector node's declaration anyAttribute wildcards
+  (own + content parts + attributeGroup members, depth 3) and the
+  namespace constraint reads the attribute's URI from the MOXML
+  element wrapper — xpath result attributes are ADAPTER objects
+  (leptris ResultAttr carries no namespace). GOTCHA: the first
+  implementation read node.namespace and CRASHED under leptris —
+  the suite probe "passed" as CRASH-AS-INVALID, caught by writing
+  the rule-level spec FIRST (rule_execution_error instead of the
+  finding). Suite verdicts from crashes are not fixes; assert the
+  finding code.
+
   (98.28% restored, zero regressions vs the 406 baseline). The
 - IDREF-RESOLUTION ROUND (2026-11-07): +1 IC (idZ012; suite
   4620->4621 = 98.40%, zero regressions, rspec green). Every

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

@@ -128,6 +128,14 @@ module Lutaml
               ambiguous = true if matched.size > 1
               values << if matched.first.nil?
                           field_supply_value(node, field, repository)
+                        elsif !matched.first.is_a?(Moxml::Element) &&
+                            skip_governed_attribute?(node, matched.first,
+                                                     repository)
+                          # A skip-wildcard-governed attribute is not
+                          # assessed, so it supplies no identity-
+                          # constraint value: the field treats it as
+                          # absent (idZ015).
+                          nil
                         elsif matched.first.is_a?(Moxml::Element) &&
                             field_node_non_simple?(
                               matched.first, constraint, raws[index],
@@ -337,6 +345,104 @@ module Lutaml
             repository.declared_attribute_supply(parent_type, attr_local)
           end
 
+          # Whether the instance attribute is governed by a SKIP
+          # wildcard on the selector node's declaration: a skip-
+          # governed attribute is not assessed, so it supplies no
+          # identity-constraint field value (idZ015).
+          #
+          # @return [Boolean]
+          def skip_governed_attribute?(element_node, attribute_node,
+                                       repository)
+            declaration = repository&.resolve(element_node.name,
+                                              element_node.namespace_uri)
+            return false unless declaration
+
+            type = declaration.complex_type ||
+              repository.resolve_type(declaration)
+            return false unless type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+
+            target_ns = repository.target_namespace_for(declaration)
+            attribute_ns = attribute_namespace(element_node, attribute_node)
+            attribute_skip_wildcards(type, repository, 0).any? do |wildcard|
+              wildcard_process_mode(wildcard) == "skip" &&
+                wildcard_admits_namespace?(wildcard, attribute_ns, target_ns)
+            end
+          end
+
+          # The attribute's namespace URI: the xpath result nodes are
+          # adapter objects (leptris ResultAttr carries no namespace),
+          # so the name-matched attribute on the MOXML element wrapper
+          # resolves it.
+          #
+          # @return [String]
+          def attribute_namespace(element_node, attribute_node)
+            found = element_node.attributes.find do |candidate|
+              candidate.name == attribute_node.name
+            end
+            found&.namespace&.uri.to_s
+          end
+
+          # The anyAttribute wildcards reachable from the type: its own,
+          # content-part bodies, and attributeGroup members (nested
+          # refs depth-guarded).
+          #
+          # @return [Array<Lutaml::Xml::Schema::Xsd::AnyAttribute>]
+          def attribute_skip_wildcards(type, repository, depth)
+            return [] if depth > 3
+
+            wildcards = Array(type.any_attribute)
+            Array(type.attribute_group).each do |group|
+              wildcards.concat(Array(group.any_attribute))
+              local = (group.ref || group.name).to_s.split(":").last
+              declaration = local && repository.resolve_attribute_group(local)
+              if declaration
+                wildcards.concat(attribute_skip_wildcards(declaration,
+                                                          repository,
+                                                          depth + 1))
+              end
+            end
+            content_kinds = %i[complex_content simple_content]
+            part_kinds = %i[extension restriction]
+            content_kinds.each do |content_kind|
+              content = type.public_send(content_kind)
+              next unless content
+
+              part_kinds.each do |part_kind|
+                Array(content.public_send(part_kind)).each do |part|
+                  wildcards.concat(Array(part.any_attribute))
+                end
+              end
+            end
+            wildcards
+          end
+
+          # Whether the wildcard's namespace constraint admits the
+          # attribute's namespace (mirrors WildcardScope#wildcard_permits?
+          # for attribute nodes, against the declaration's target
+          # namespace).
+          #
+          # @return [Boolean]
+          def wildcard_admits_namespace?(wildcard, uri, target_ns)
+            case wildcard.namespace.to_s
+            when "##any", ""
+              true
+            when "##other"
+              !uri.empty? && uri != target_ns.to_s
+            when "##local"
+              uri.empty?
+            when "##targetNamespace"
+              uri == target_ns.to_s
+            else
+              wildcard.namespace.to_s.split(/\s+/).any? do |entry|
+                case entry
+                when "##local" then uri.empty?
+                when "##targetNamespace" then uri == target_ns.to_s
+                else entry == uri
+                end
+              end
+            end
+          end
+
           # Whether an element field's node supplies no identity value:
           # it has element children, is declared non-simple (complex
           # content or xsd:anyType — the typeless default), or carries a

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
@@ -1040,6 +1050,12 @@ module Lutaml
             @redefined_originals[name] = original if original
             @attribute_groups[name] = group
           end
+          Array(red.group).each do |group|
+            name = group.name.to_s
+            next if name.empty?
+
+            @redefined_groups[name] = group
+          end
         end
 
         def index_attribute(attribute, namespace)

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.97"
+    VERSION = "1.2.99"
   end
 end

metadata

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