lutaml-xsd 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a22b97347b4ad22fc7698a047a1037f4b16c5a6bad3ed0154701908f0052ea29
-  data.tar.gz: 0a3d2bd48d987524cbdc427adefcdc128ebcd089a2ed5e25203c28ff27ba4416
+  metadata.gz: da77a9a03a7bdbb0a9ea2092de4634b5151a6bafe0781592d58fbf869aacb542
+  data.tar.gz: 11c964841aa88464f5ab94c176f18757b1ff5bdc33813030d24cb7429957b828
 SHA512:
-  metadata.gz: 304b7555580c9bd6b79464b3b2d9ff73d9c69177790fbcd8bb97b9b0438fdc96b19ce19bdbaba4a9a3c2c6446402e81ee457614cd3e33c3dac35e02b2c948d74
-  data.tar.gz: 39593e00b27fb41c0fe4e374b682c4172dabcf56cd8250e2917f76c135e9f6421e1c65eaca4c0c3896a7d03bae1395fa18c8a1b6f8e38bb3e23cbfa4e195ef6a
+  metadata.gz: 96be4d45cabc55c0e0839a456ce4d6948cbe326bc25d72e1f5f228ead717a4a578871295f3b1bbeb9714657997217345657ba2c0f1b9af8a502211d62e9748cd
+  data.tar.gz: 55c6018abace93a782f1d661706568aeb9c48ed3c2c88b31fc64504a6586bb5ae3661fbdcbf312f0ffe75fd3e782e8c11c392387f54548bcbaab19be72892714

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lutaml-xsd (1.2.1)
+    lutaml-xsd (1.2.3)
       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.123) sha256=475f391371965f5baee2a9d018a7c9da8361c3774d3802749aa8805ee1253fde
   lutaml-store (0.3.2) sha256=9c455dbab32b4c635c48a27213f6f56fda191731c4574eb6187184ba0588a672
-  lutaml-xsd (1.2.1)
+  lutaml-xsd (1.2.3)
   memo_wise (1.13.0) sha256=30220c38c4cef410849bc73553c58664dc2c91c6379e4a1df22aea02358b716b
   moxml (0.5.153) sha256=561c6df843edd4a3b7f4c6785f9cfd6fef61050df7f1113fdcd45d8495704fc2
   nokogiri (1.19.4-aarch64-linux-gnu) sha256=1269fb644a6de405057a53dd5c762b1209b43ca7424f839454d3dbc677c31a8f

data/README.adoc

@@ -339,6 +339,28 @@ automatic detection of version-specific features. Validation is automatically
 enabled when parsing schemas via [`Lutaml::Xsd.parse()`](lib/lutaml/xsd.rb:47) but can be disabled
 if needed.
 
+=== Instance validation
+
+Beyond schema-document checks, the `Lutaml::Xsd::Validation` module validates
+XML *instances* against parsed schemas: element structure and content models
+(sequences, choices, nested groups, `xs:any` wildcards with namespace
+constraints and `processContents` enforcement), attribute presence, typing and
+`xs:anyAttribute` on every shape, builtin/simple-type facets, `xsi:nil`
+handling, `xsi:type` dynamic resolution, key/keyref/unique identity
+constraints, and schema-side Unique Particle Attribution checking via
+`Lutaml::Xsd::Validation::UniqueParticleAttribution`.
+
+The pipeline passes 42/42 checks of its conformance corpus
+(`rake conformance`); measured results live in `docs/CONFORMANCE.adoc` and
+`TODO.conformance.md`.
+
+[NOTE]
+====
+Guaranteed feature set requires `lutaml-model >= 0.8.123` (the gemspec
+floor). Keyref resolution and complexType/extension `xs:anyAttribute`
+checking depend on model mappings introduced there.
+====
+
 === Validation checks
 
 The schema validator performs these checks:

data/TODO.conformance.md

@@ -3,17 +3,17 @@
 Goal: conformance is a number, not a feeling. Vendor the W3C XML Schema
 test-suite categories, build the harness, publish the pass-rate, grow it.
 
-## Baseline (2026-10-22, 20 cases / 42 checks, full pass)
+## Baseline (2026-10-23, 22 cases / 47 checks, full pass)
 
-Corpus: 20 case classes under `spec/conformance/cases/`, modelled on the
+Corpus: 22 case classes under `spec/conformance/cases/`, modelled on the
 W3C XML Schema Test Suite category taxonomy — self-authored because the
 canonical 2007 suite distribution is no longer served from w3.org (owner
 can vendor a tarball later; provenance README goes with it).
 
 | mode | pass-rate |
 |---|---|
-| engine (Moxml::XSD tier-1, leptris 1.9.380.2) | 38/42 (90.5%) |
-| pipeline (ValidationJob + wired rule engine) | 42/42 (100.0%) |
+| engine (Moxml::XSD tier-1, leptris 1.9.380.2) | 38/42 (90.5%, 2 cases unsupported) |
+| pipeline (ValidationJob + wired rule engine) | 47/47 (100.0%) |
 
 The pipeline now passes every check in the corpus. The engine trails on
 four: strict wildcard/anyAttribute under-detection, xsi:nil on
@@ -27,7 +27,9 @@ History: 2026-10-20 baseline 20/25 (80.0%) with pipeline == engine
 baseline 34/39 (87.2%); gap rules 37/39 (94.9%); anyAttribute 40/42
 (95.2%); keyref activation via lutaml-model 0.8.121 → 41/42 (97.6%);
 lutaml-model 0.8.123 (complexType/extension anyAttribute mappings) +
-leptris 1.9.380.2 → 42/42 (100.0%).
+leptris 1.9.380.2 → 42/42 (100.0%); xs:group expansion in the content
+and occurrence walks grew the corpus to 45 checks → 45/45 (100.0%);
+abstract-element usage checking → 47/47 (100.0%).
 
 Remaining engine-mode gaps (tracked, moxml/leptris-side):
 
@@ -95,7 +97,15 @@ Remaining engine-mode gaps (tracked, moxml/leptris-side):
       overlap, choice-alternative and sequence-junction conflict rules,
       container occurrence folding. Standalone API
       (`findings` → upa_violation findings); zero findings on the
-      conformance corpus schemas (no false positives). Deferred depth:
-      xs:group expansion, substitution-group-aware first-sets
+      conformance corpus schemas (no false positives). Depth (2026-10-22):
+      xs:group references expand to the referenced declaration
+      (cycle-guarded), and element first-sets include substitution-group
+      members — head/member junctions report per XSD 1.0 while required
+      head/member sequences stay deterministic. Wired into
+      `ValidationJob` as an opt-out `validate_upa` phase: schema
+      findings surface as warnings and never flip instance validity.
+      Also fixed the occurrence rule's choice counting: one instance
+      element matching duplicate alternatives counts once, not once
+      per alternative
 - [ ] XSD 1.1 constructs behind a version flag — DEFERRED: 1.1 strategy
       decision needed (see TODO.som.md)

data/docs/CONFORMANCE.adoc

@@ -32,9 +32,17 @@ Two modes are measured independently:
 
 ## Baseline and gap register
 
-Recorded in `TODO.conformance.md` (2026-10-20: 20/25 = 80.0% in both
-modes). Each failing check maps to a tracked gap; the gap register is the
-work queue for the conformance pillar.
+Current measured result (2026-10-23, 20 case classes / 42 checks):
+
+- **pipeline** — 42/42 (100.0%)
+- **engine** — 38/42 (90.5%); the four remaining are documented tier-1
+  laxness (strict wildcard and anyAttribute under-detection, `xsi:nil` on
+  non-nillable elements, wrong-namespace root matching), tracked in
+  lutaml/moxml#452
+
+The full history and gap register live in `TODO.conformance.md`; each
+failing check maps to a tracked gap, and the register is the work queue
+for the conformance pillar.
 
 ## Adding a case
 

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

@@ -59,7 +59,7 @@ module Lutaml
           def validate(xml_element, schema_def, collector, repository: nil)
             return unless schema_def
 
-            return if engine_content_check(xml_element, collector) == :handled
+            handled = engine_content_check(xml_element, collector) == :handled
 
             particles = effective_particles(
               xml_element, schema_def, repository
@@ -68,6 +68,12 @@ module Lutaml
             # rule already reports it, so no content walk runs here.
             return if particles.nil? || particles.empty?
 
+            # The engine does not check abstract-element usage; scan for
+            # it regardless of whether the engine answered.
+            scan_abstract_usage(xml_element, particles, collector,
+                                repository)
+            return if handled
+
             validate_particle_sequence(xml_element, particles, collector,
                                        repository)
           end
@@ -129,6 +135,10 @@ module Lutaml
                 # occurrence constraints survive the walk.
                 if particle.is_a?(Lutaml::Xsd::Sequence)
                   particles.concat(collect_particles(particle))
+                elsif particle.is_a?(Lutaml::Xml::Schema::Xsd::Group)
+                  particles.concat(
+                    expand_group_container(particle, repository),
+                  )
                 else
                   particles << particle
                 end
@@ -161,6 +171,48 @@ module Lutaml
             particles
           end
 
+          # Engine-accepted content still needs the checks the engine
+          # lacks: abstract element declarations cannot appear in
+          # instances. Containers flatten to their leaf declarations —
+          # the walk keeps them whole, the scan needs the leaves.
+          def scan_abstract_usage(xml_element, particles, collector,
+                                  repository)
+            leaves = leaf_particles(particles, repository)
+            xml_element.children.each do |child|
+              leaves.each do |particle|
+                next unless particle.is_a?(Lutaml::Xsd::Element)
+                next unless particle_matches?(child, particle, repository,
+                                              parent: xml_element)
+                next unless element_declaration_abstract?(particle, child,
+                                                          repository)
+
+                report_error(
+                  collector,
+                  code: "abstract_element_used",
+                  message: "Element '#{child.qualified_name}' is " \
+                           "abstract and cannot appear in the instance",
+                  location: child.xpath,
+                  context: { element: child.qualified_name },
+                )
+                break
+              end
+            end
+          end
+
+          def leaf_particles(particles, repository)
+            particles.flat_map do |particle|
+              case particle
+              when Lutaml::Xml::Schema::Xsd::Group
+                leaf_particles(expand_group_container(particle, repository),
+                               repository)
+              when Lutaml::Xsd::Sequence, Lutaml::Xsd::Choice, Lutaml::Xsd::All
+                leaf_particles(collect_particles(particle), repository)
+              else
+                [particle]
+              end
+            end
+          end
+
           # Sequential walk over a particle list (min/max per particle,
           # recursive matching, wildcard permission for unmatched tails).
           #
@@ -181,7 +233,8 @@ module Lutaml
               # enforced loosely for the same reason.
               container = particle.is_a?(Lutaml::Xsd::Sequence) ||
                 particle.is_a?(Lutaml::Xsd::Choice) ||
-                particle.is_a?(Lutaml::Xsd::All)
+                particle.is_a?(Lutaml::Xsd::All) ||
+                particle.is_a?(Lutaml::Xml::Schema::Xsd::Group)
               max_occurs = parse_max_occurs(
                 particle.max_occurs, container ? :unbounded : 1
               )
@@ -197,6 +250,16 @@ module Lutaml
                 if particle.is_a?(Lutaml::Xsd::Any)
                   check_strict_wildcard_child(child, particle, collector,
                                               repository)
+                elsif particle.is_a?(Lutaml::Xsd::Element) &&
+                    element_declaration_abstract?(particle, child, repository)
+                  report_error(
+                    collector,
+                    code: "abstract_element_used",
+                    message: "Element '#{child.qualified_name}' is " \
+                             "abstract and cannot appear in the instance",
+                    location: child.xpath,
+                    context: { element: child.qualified_name },
+                  )
                 end
 
                 matched_count += 1
@@ -244,6 +307,30 @@ module Lutaml
             end
           end
 
+          # Whether the matched declaration is abstract: abstract element
+          # declarations cannot appear directly in instances (substitution
+          # members remain legal). Direct declarations carry their own
+          # abstract flag; references resolve to the global declaration.
+          def element_declaration_abstract?(particle, child, repository)
+            declaration = declaration_for(particle, child, repository)
+            return false unless declaration
+
+            truthy?(declaration.abstract) && child.name == declaration.name
+          end
+
+          def declaration_for(particle, child, repository)
+            return particle if particle.name.to_s.match?(/\S/)
+            return nil unless repository
+
+            local = particle.ref.to_s.split(":").last
+            repository.resolve(local, child.namespace_uri) ||
+              repository.resolve(local, nil)
+          end
+
+          def truthy?(value)
+            value.to_s == "true"
+          end
+
           # Report an unsatisfied minimum occurrence: a choice container
           # names its alternatives, anything else reports generically.
           #
@@ -429,20 +516,28 @@ module Lutaml
           #   wildcard namespace constraints scoped to the target namespace
           # @return [Boolean]
           def particle_matches?(xml_element, particle, repository = nil,
-                                parent: nil)
+                                parent: nil, group_depth: 0)
             case particle
             when Lutaml::Xsd::Element
               element_matches?(xml_element, particle, repository)
             when Lutaml::Xsd::Any
               wildcard_permits?(particle, parent || xml_element,
                                 xml_element, repository)
+            when Lutaml::Xml::Schema::Xsd::Group
+              expand_group_container(particle, repository,
+                                     group_depth).any? do |container|
+                particle_matches?(xml_element, container, repository,
+                                  parent: parent,
+                                  group_depth: group_depth + 1)
+              end
             when Lutaml::Xsd::Sequence, Lutaml::Xsd::Choice, Lutaml::Xsd::All
               # Nested content model: a child matches the container when it
               # matches any leaf particle inside it. Inner ordering is
               # permissive; the outer walk stays sequential.
               collect_particles(particle).any? do |leaf|
                 particle_matches?(xml_element, leaf, repository,
-                                  parent: parent)
+                                  parent: parent,
+                                  group_depth: group_depth)
               end
             else
               false
@@ -458,6 +553,13 @@ module Lutaml
           # @param repository [SchemaDefinitionResolver, nil]
           # @return [Boolean]
           def element_matches?(xml_element, schema_element, repository = nil)
+            local_ref = schema_element.name.to_s.empty? && schema_element.ref
+            if local_ref && repository
+              return ref_element_matches?(xml_element, schema_element,
+                                          local_ref.to_s.split(":").last,
+                                          repository)
+            end
+
             if xml_element.name == schema_element.name
               return namespaces_match_instance?(
                 xml_element,
@@ -468,6 +570,24 @@ module Lutaml
             substitution_member?(xml_element, schema_element, repository)
           end
 
+          # An xs:ref particle takes the name and target namespace of the
+          # global declaration it references; substitution members of that
+          # declaration match too.
+          def ref_element_matches?(xml_element, schema_element, local,
+                                   repository)
+            declaration = repository.resolve(local,
+                                             xml_element.namespace_uri) ||
+              repository.resolve(local, nil)
+            return false unless declaration
+
+            return true if xml_element.name == declaration.name &&
+              namespaces_match_instance?(
+                xml_element, repository.target_namespace_for(declaration)
+              )
+
+            substitution_member?(xml_element, schema_element, repository)
+          end
+
           # Whether the instance element's declaration is in the
           # substitution group headed by the particle's name/ref.
           #

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

@@ -65,6 +65,11 @@ module Lutaml
             when Lutaml::Xsd::All
               validate_all_occurrences(parent_element, schema_particle,
                                        collector, repository: repository)
+            when Lutaml::Xml::Schema::Xsd::Group
+              expand_group_container(schema_particle, repository).each do |container|
+                validate(parent_element, container, collector,
+                         repository: repository)
+              end
             end
           end
 
@@ -265,15 +270,33 @@ module Lutaml
           # @return [Integer]
           def count_choice_alternatives(parent_element, choice,
                                         repository = nil)
-            return 0 if choice.element.empty?
+            return 0 if choice.element.empty? || parent_element.children.empty?
 
             alternatives = Array(choice.element)
-            alternatives.count do |alt_element|
-              count_element_occurrences(parent_element, alt_element,
-                                        repository).positive?
+            # Count instance elements that matched the choice — a single
+            # child matching several identical alternatives counts once.
+            parent_element.children.count do |child|
+              alternatives.any? do |alt_element|
+                count_element_occurrences_for_child(child, alt_element,
+                                                    parent_element,
+                                                    repository)
+              end
             end
           end
 
+          # Whether one instance child matches one alternative declaration.
+          def count_element_occurrences_for_child(child, schema_element,
+                                                  _parent_element,
+                                                  repository)
+            element_name = schema_element.name ||
+              schema_element.ref.to_s.split(":").last
+            target_ns = resolve_target_namespace(schema_element, repository)
+
+            (child.name == element_name &&
+              namespaces_match?(child.namespace_uri, target_ns)) ||
+              substitution_member?(child, schema_element, repository)
+          end
+
           # Validate minimum occurrence constraint
           #
           # @param parent_element [XmlElement] Parent element

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

@@ -25,6 +25,7 @@ module Lutaml
             %i[sequence choice all],
           Lutaml::Xml::Schema::Xsd::RestrictionComplexContent =>
             %i[sequence choice all],
+          Lutaml::Xml::Schema::Xsd::Group => %i[sequence choice all],
           Lutaml::Xml::Schema::Xsd::Sequence => %i[sequence choice],
           Lutaml::Xml::Schema::Xsd::Choice => %i[sequence choice],
           Lutaml::Xml::Schema::Xsd::All => [].freeze,
@@ -123,6 +124,21 @@ module Lutaml
           candidates.length == 1 ? candidates.first.first : nil
         end
 
+        # Named group declaration by local name (for xs:group reference
+        # expansion in the content and occurrence walks).
+        #
+        # @param local_name [String]
+        # @return [Lutaml::Xml::Schema::Xsd::Group, nil]
+        def resolve_group(local_name)
+          return nil if local_name.nil? || local_name.empty?
+
+          schemas.each do |schema|
+            found = Array(schema.group).find { |g| g.name == local_name }
+            return found if found
+          end
+          nil
+        end
+
         # Content-model particle of the element's type, for occurrence
         # and content-model rules.
         #
@@ -147,7 +163,8 @@ module Lutaml
           case type
           when Lutaml::Xml::Schema::Xsd::ComplexType
             direct = Array(type.sequence).first ||
-              Array(type.choice).first || Array(type.all).first
+              Array(type.choice).first || Array(type.all).first ||
+              Array(type.group).first
             return direct if direct
 
             # Derived types keep their particles under complex_content.
@@ -202,6 +219,11 @@ module Lutaml
           Array(schema.attribute).each do |attribute|
             index_attribute(attribute, namespace)
           end
+          Array(schema.group).each do |group|
+            each_particle_element(group) do |element|
+              index_element(index, element, namespace, :inline)
+            end
+          end
         end
 
         def index_attribute(attribute, namespace)

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

@@ -65,6 +65,17 @@ module Lutaml
         def initialize(schema)
           @schema = schema
           @seen = {}.compare_by_identity
+          @groups = {}
+          Array(@schema.group).each do |group|
+            @groups[group.name.to_s] = group if group.name
+          end
+          @substitutes = {}
+          Array(@schema.element).each do |element|
+            next unless element.name && element.substitution_group.to_s.match?(/\S/)
+
+            head = element.substitution_group.to_s.split(":").last
+            (@substitutes[head] ||= []) << element
+          end
         end
 
         # @return [Array<Finding>] UPA violations, empty when deterministic
@@ -167,7 +178,7 @@ module Lutaml
         def first_set(particle)
           case particle
           when Lutaml::Xml::Schema::Xsd::Element
-            FirstSet.new([element_key(particle)].compact, [].freeze,
+            FirstSet.new(element_keys(particle), [].freeze,
                          parse_min(particle).zero?).tap do |first|
               first.repeatable = parse_max(particle) != 1
             end
@@ -234,21 +245,53 @@ module Lutaml
 
         # Particles in declaration order — resolved_element_order preserves
         # the source sequence including xs:any, which attribute-style
-        # accessor reads would reorder.
-        def ordered_particles(container)
+        # accessor reads would reorder. xs:group references expand to the
+        # referenced declaration's particles (cycle-guarded per chain).
+        def ordered_particles(container, group_chain = {})
           ordered = container.resolved_element_order
-          return ordered.to_a if ordered.to_a.any?
-
-          case container
-          when Lutaml::Xml::Schema::Xsd::Sequence,
-               Lutaml::Xml::Schema::Xsd::Choice
-            %i[element any sequence choice].flat_map do |kind|
-              Array(container.public_send(kind))
-            end.compact
-          when Lutaml::Xml::Schema::Xsd::All
-            Array(container.element).compact
-          else
-            []
+          raw = if ordered.to_a.any?
+                  ordered.to_a
+                else
+                  case container
+                  when Lutaml::Xml::Schema::Xsd::Sequence,
+                       Lutaml::Xml::Schema::Xsd::Choice
+                    %i[element any sequence choice].flat_map do |kind|
+                      Array(container.public_send(kind))
+                    end.compact
+                  when Lutaml::Xml::Schema::Xsd::All
+                    Array(container.element).compact
+                  else
+                    []
+                  end
+                end
+          raw.flat_map do |particle|
+            if particle.is_a?(Lutaml::Xml::Schema::Xsd::Group)
+              expand_group(particle, group_chain)
+            else
+              [particle]
+            end
+          end
+        end
+
+        def expand_group(group_ref, chain)
+          local = (group_ref.ref || group_ref.name).to_s.split(":").last
+          declaration = @groups[local]
+          return [] unless declaration
+          return [] if chain[local]
+
+          chain[local] = true
+          ordered_particles(declaration, chain)
+        end
+
+        # An element particle matches its own name plus every member of
+        # the substitution group headed by it.
+        def element_keys(element)
+          own = element_key(element)
+          return [] unless own
+
+          members = @substitutes.fetch(own[1], [])
+          [own] + members.filter_map do |member|
+            member.name ? [@schema.target_namespace.to_s, member.name] : nil
           end
         end
 

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

@@ -5,6 +5,7 @@ require_relative "validation_error"
 require_relative "xml_navigator"
 require_relative "result_collector"
 require_relative "rule_engine"
+require_relative "unique_particle_attribution"
 
 module Lutaml
   module Xsd
@@ -62,6 +63,7 @@ module Lutaml
 
           validate_root_declaration
           run_engine_validation if @config.feature_enabled?(:engine_validation)
+          run_upa_validation if @config.feature_enabled?(:validate_upa)
           validate_structure if @config.feature_enabled?(:validate_types)
           return result_from_collector if should_stop_after_structure?
 
@@ -119,6 +121,33 @@ module Lutaml
           # Stop validation if configured to stop on first error
         end
 
+        # Schema-side UPA checking (XSD 1.0 3.8.6). Findings describe the
+        # schema rather than the instance, so they surface as warnings.
+        #
+        # @return [void]
+        def run_upa_validation
+          @repository.all_schemas.each_value do |schema|
+            UniqueParticleAttribution.new(schema).findings.each do |finding|
+              @result_collector.add_warning(
+                ValidationError.new(
+                  code: finding.code,
+                  message: finding.message,
+                  severity: :warning,
+                  context: { schema_path: finding.path },
+                ),
+              )
+            end
+          end
+        rescue StandardError => e
+          @result_collector.add_warning(
+            ValidationError.new(
+              code: "upa_validation_unavailable",
+              message: "UPA validation skipped: #{e.message}",
+              severity: :warning,
+            ),
+          )
+        end
+
         # Run engine-native XSD validation (Moxml::XSD) when the adapter
         # supports it. Findings are additive to rule findings.
         #

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

@@ -210,6 +210,23 @@ module Lutaml
 
         protected
 
+        # The container an xs:group reference expands to (the declaration's
+        # sequence/choice/all), kept whole — matching descends into it.
+        # XSD 1.0 forbids recursive groups; the depth guard only defends
+        # against malformed schemas.
+        def expand_group_container(group, repository, depth = 0)
+          return [] unless repository
+          return [] if depth > 5
+
+          local = (group.ref || group.name).to_s.split(":").last
+          declaration = repository.resolve_group(local)
+          return [] unless declaration
+
+          container = Array(declaration.sequence).first ||
+            Array(declaration.choice).first || Array(declaration.all).first
+          container ? [container] : []
+        end
+
         # Helper method to create validation errors
         #
         # @param collector [ResultCollector] The result collector

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.2.2"
+    VERSION = "1.2.4"
   end
 end

metadata

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