lutaml-xsd 1.2.76 → 1.2.78

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c49965da4c942d79c67fd51902349ca702ed0f60a35bb44aef6a2f47f4745bc
-  data.tar.gz: d9bfe229ec7147df509f0b8f01ea18e3b263df232b041d76d12c7c3f86362286
+  metadata.gz: 22d795e689f88ccef5f61459e717e04bafc7eaf5504b080a6062a59d9501a86e
+  data.tar.gz: fb39b92dc122c263bf6b144c70d7f6eaee7841209f8d2ad8a013daa540c13f5c
 SHA512:
-  metadata.gz: 559fe20193f7575c8893b5e25fc656b3cface817c7aa7190b97ab8d2e7ae226330281e02e6eeae3e02b38965ba77f3e958d94688aa788b015f7736692ba7d403
-  data.tar.gz: 638b9280631242c2ada79b449bbc19f30cd1d706b502d7db9bce4d012dc3e421ed35312eacd0b9b64ef373bf283436105eb98a7abcf70e54ba0665d67fa8a73c
+  metadata.gz: 311267aaa35718e4f3c149ed3d7e7f14eda7bee3a077ca39c6c5c4041ca70184bd4aa458c2680ed435295bbe8460bf0b1b96ce77d473225062e5afa6439cc353
+  data.tar.gz: 36edcae8faa4d6062edc3f873cc34e0c67c01c156089c1517ed21cb265df5e66729ca5588264eb856476705f62e59879c3bf47aed112497b97f5b16c17475d23

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lutaml-xsd (1.2.76)
+    lutaml-xsd (1.2.78)
       liquid (>= 4.0, < 6.0)
       lutaml-model (~> 0.8.123)
       lutaml-store (~> 0.3)
@@ -264,7 +264,7 @@ CHECKSUMS
   liquid (5.14.0) sha256=e1020c2b2ee58c7a4d3bfdc7a331537bd27a783353748bff0bf27c6ac0c17065
   lutaml-model (0.8.155) sha256=3d90f2fb4fdf41a42d4a05b62b3f6644b433070b82291a9371deaa8e68a1e02d
   lutaml-store (0.3.2) sha256=9c455dbab32b4c635c48a27213f6f56fda191731c4574eb6187184ba0588a672
-  lutaml-xsd (1.2.76)
+  lutaml-xsd (1.2.78)
   memo_wise (1.13.0) sha256=30220c38c4cef410849bc73553c58664dc2c91c6379e4a1df22aea02358b716b
   moxml (0.6.1) sha256=5b7677258bbad372f0725a421f8adeae37b65d6f7871da2747e2c1906cdac7ea
   nokogiri (1.19.4-aarch64-linux-gnu) sha256=1269fb644a6de405057a53dd5c762b1209b43ca7424f839454d3dbc677c31a8f

data/TODO.conformance.md

@@ -120,21 +120,21 @@ pinned commit) is measured via `rake conformance:w3c`:
 
 | mode | pass-rate |
 |---|---|
-| pipeline | 4546/4696 (96.8%) |
+| pipeline | 4565/4696 (97.2%) |
 
 (2026-11-02, bundled-stack measurement on main with the escape,
 hint-following, pattern-alternative, identity-crash, engine-set,
 engine-refresh, IC value-space, IC field-resolution, facade-silence,
-regex-semantics, redefine-refresh, gmonth-refresh, digit-vintage and
-stgh-refresh rounds; moxml 0.6.1 (gemspec floor `~> 0.6.0` per the
-owner — the 0.6 line drops the Opal surface; measured
-conformance-neutral), lutaml-model 0.8.155, engine leptris
-1.9.401.0.) Same-stack comparison: 1.2.43 baseline 3961 (84.3%) →
-4039 (86.0%) → 4090 (87.1%) → 4360 (92.8%, lockfile refresh) → 4411
-(93.9%) → 4430 (94.3%) → 4435 (94.4%) → 4436 (94.5%) → 4439 (94.5%)
-→ 4454 (94.9%) → 4495 (95.7%) → 4524 (96.3%) → 4534 (96.6%) → 4540
-(96.7%) → 4542 (96.7%) → 4546 (96.8%), +585 net over the 1.2.43
-baseline. The escapes round (PR #197 — \d→\p{Nd},
+regex-semantics, redefine-refresh, gmonth-refresh, digit-vintage,
+stgh-refresh, group-ref and attribute-group-redefine rounds; moxml
+0.6.1 (gemspec floor `~> 0.6.0` per the owner — the 0.6 line drops
+the Opal surface; measured conformance-neutral), lutaml-model
+0.8.155, engine leptris 1.9.401.0.) Same-stack comparison: 1.2.43
+baseline 3961 (84.3%) → 4039 (86.0%) → 4090 (87.1%) → 4360 (92.8%,
+lockfile refresh) → 4411 (93.9%) → 4430 (94.3%) → 4435 (94.4%) →
+4436 (94.5%) → 4439 (94.5%) → 4454 (94.9%) → 4495 (95.7%) → 4524
+(96.3%) → 4534 (96.6%) → 4540 (96.7%) → 4542 (96.7%) → 4546 (96.8%)
+→ 4557 (97.0%) → 4565 (97.2%), +604 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
@@ -242,7 +242,8 @@ moxml 0.5.170 + lutaml-model 0.8.147) → 93.9% (escape + hint rounds)
 4439) → 94.9% (IC field-resolution round PR #206, 4454) → 95.7%
 (facade-silence dep refresh, moxml 0.5.177, 4495) → 96.3% (regex
 semantics round PR #208, 4524) → 96.6% (redefine refresh, leptris
-1.9.396/1.9.397, 4534). Failure
+1.9.396/1.9.397, 4534) → 96.8% (stG/stH refresh, leptris 1.9.401,
+4546) → 97.0% (group-ref round PR #217, 4557). Failure
 concentration (the work queue, largest first):
 
 - `Regex_w3c` (131) — decomposed by error source (2026-10-25): the
@@ -344,6 +345,33 @@ tuple keys, node-set field violations and absent-field rows handled, cross-eleme
   (stG010/012, stH005/007); SimpleType 10→6; suite 4546/4696
   (96.8%), zero regressions. #1936 remainder: reZ char-reference
   shapes, reT51 \D vintage; plus moxml#510 addB116 straggler.
+- GROUP-REF ROUND (2026-11-02, PR #217): +11 Group cases (19→8,
+  suite 4557/4696 = 97.0%). TWO Ruby defects: (a) `particle_for_type`
+  read sequence/choice/all from extension and restriction bodies but
+  NOT `group` — a derivation body that is a bare group reference
+  compiled to NO content model and the walk enforced nothing
+  (groupG/groupH class); (b) `composite_capacity` decided sum-vs-max
+  from the PARTICLE's class — for a Group ref it always took the max
+  branch even when the group's declaration is a SEQUENCE whose
+  members' capacities must ADD (groupH002: one branch of x1+x2 was
+  counted as two choice occurrences). Neighbors verified identical;
+  zero regressions. Group remainder: groupB009/010 + groupO004
+  (false-reject class), groupH008/J003/006/008/L008 under-detections
+  (choice-of-group capacity depth).
+- ATTRIBUTE-GROUP-REDEFINE ROUND (2026-11-02, PR #218): +8 net
+  (AttributeGroup 17→11, Schema 14→12, Attribute 10→9; suite
+  4557→4565 = 97.2%). lutaml-model does NOT chase xs:redefine
+  targets — the original document was never parsed, so the
+  redefined group's self-ref hook had nothing to hook to and
+  expansions truncated at the cycle guard. The resolver now chases
+  the redefine target itself (relative to the defining file, via
+  the repository's source path), indexes it, keeps the ORIGINAL
+  declaration as the hook target, and expands the redefining body
+  with the self-ref resolved to that original (attgC007/attgD036).
+  Wildcards nested in attributeGroup DECLARATIONS reach types
+  through the group's resolution (attgD019). All remaining
+  AttributeGroup failures are ENGINE-only strict re-checks on
+  composed shapes (the moxml#510 thread).
 - 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/attribute_validation_rule.rb

@@ -268,14 +268,23 @@ module Lutaml
             return [] if depth > 5
             return [] unless group
 
+            own = (group.name || group.ref).to_s.split(":").last
             attrs = Array(group.attribute)
 
             # An attributeGroup may reference other attributeGroups —
-            # their declarations flow into the expansion (attgD004).
+            # their declarations flow into the expansion (attgD004). A
+            # reference to the group's OWN name inside an xs:redefine
+            # body is the §4.2.2 hook to the ORIGINAL definition.
             Array(group.attribute_group).each do |nested_ref|
               local = (nested_ref.ref || nested_ref.name).to_s
                 .split(":").last
-              declaration = repository&.resolve_attribute_group(local)
+              declaration =
+                if !local.empty? && local == own &&
+                    repository&.redefined_original_for(local)
+                  repository.redefined_original_for(local)
+                else
+                  repository&.resolve_attribute_group(local)
+                end
               next unless declaration
 
               attrs.concat(expand_attribute_group(declaration, repository,
@@ -889,10 +898,15 @@ module Lutaml
                 complex_type_wildcard_support?
             wildcards << 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
               end
+
+              collect_group_wildcards(group, repository, wildcards, 0)
             end
 
             CONTENT_KINDS.each do |content_kind|
@@ -916,6 +930,29 @@ module Lutaml
             wildcards
           end
 
+          # The wildcards of an attributeGroup reference's DECLARATION,
+          # following nested attributeGroup refs (depth-guarded).
+          #
+          # @return [void]
+          def collect_group_wildcards(group, repository, wildcards, depth)
+            return if depth > 5
+
+            local = (group.ref || group.name).to_s.split(":").last
+            return if local.to_s.empty?
+
+            declaration = repository&.resolve_attribute_group(local)
+            return unless declaration
+
+            Array(declaration.any_attribute).each do |wildcard|
+              wildcards << wildcard
+            end
+
+            Array(declaration.attribute_group).each do |nested|
+              collect_group_wildcards(nested, repository, wildcards,
+                                      depth + 1)
+            end
+          end
+
           # The named base type of the derivation shape, when present.
           #
           # @return [Lutaml::Xml::Schema::Xsd::ComplexType, nil]

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

@@ -501,24 +501,36 @@ module Lutaml
           end
 
           def composite_capacity(particle, repository, depth)
-            children = if particle.is_a?(Lutaml::Xml::Schema::Xsd::Group)
-                         container = expand_group_container(particle,
-                                                            repository).first
-                         container ? choice_alternatives(container) : []
-                       else
-                         # sequence: capacities add; choice: the largest
-                         choice_alternatives(particle)
-                       end
+            # The CONTAINER's kind decides aggregation: a group whose
+            # declaration is a sequence ADDS its members' capacities, a
+            # choice takes the largest — deciding from the ref particle
+            # itself always maxed (groupH class).
+            children, aggregate =
+              if particle.is_a?(Lutaml::Xml::Schema::Xsd::Group)
+                container = expand_group_container(particle,
+                                                   repository).first
+                if container
+                  [choice_alternatives(container),
+                   container_choice?(container) ? :max : :sum]
+                else
+                  [[], :max]
+                end
+              else
+                [choice_alternatives(particle),
+                 particle.is_a?(Lutaml::Xsd::Sequence) ? :sum : :max]
+              end
             caps = children.map do |child|
               branch_capacity(child, repository, depth + 1)
             end
             return :unbounded if caps.include?(:unbounded)
 
-            if particle.is_a?(Lutaml::Xsd::Sequence)
-              caps.sum
-            else
-              caps.max || 0
-            end
+            aggregate == :sum ? caps.sum : (caps.max || 0)
+          end
+
+          # @return [Boolean]
+          def container_choice?(container)
+            container.is_a?(Lutaml::Xsd::Choice) ||
+              container.is_a?(Lutaml::Xml::Schema::Xsd::Choice)
           end
 
           # Choice alternatives are particles of any kind.

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

@@ -49,6 +49,7 @@ module Lutaml
           @named_types = {}
           @attributes = Hash.new { |hash, key| hash[key] = [] }
           @attribute_groups = {}
+          @redefined_originals = {}
           @elements = index_elements
         end
 
@@ -100,6 +101,16 @@ module Lutaml
           @attribute_groups[local_name]
         end
 
+        # The pre-redefinition declaration of an attributeGroup that an
+        # xs:redefine replaced — the target of the redefining body's
+        # self-reference hook.
+        #
+        # @param local_name [String]
+        # @return [Object, nil]
+        def redefined_original_for(local_name)
+          @redefined_originals[local_name]
+        end
+
         # Owner schema's target namespace for a resolved declaration
         # (parsed element models carry no owner-schema link).
         #
@@ -428,8 +439,12 @@ module Lutaml
             nil
           when Lutaml::Xml::Schema::Xsd::ExtensionComplexContent,
                Lutaml::Xml::Schema::Xsd::RestrictionComplexContent
+            # A derivation body may be a bare group reference — the
+            # ref's own minOccurs/maxOccurs govern the expanded model
+            # (groupG/groupH class).
             Array(type.sequence).first ||
-              Array(type.choice).first || Array(type.all).first
+              Array(type.choice).first || Array(type.all).first ||
+              Array(type.group).first
           end
         end
 
@@ -534,6 +549,46 @@ module Lutaml
 
             index_schema(index, nested)
           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.
+          Array(schema.redefine).each do |red|
+            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
+                )
+                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?
+
+              original = @attribute_groups[name]
+              @redefined_originals[name] = original if original
+              @attribute_groups[name] = group
+            end
+          end
         end
 
         def index_attribute(attribute, namespace)

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.76"
+    VERSION = "1.2.78"
   end
 end

metadata

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