lutaml-xsd 1.2.0 → 1.2.2

data/lib/lutaml/xsd/spa/schema_serializer.rb

@@ -575,9 +575,9 @@ module Lutaml
         # @return [Array<Hash>] Serialized complex types (sorted alphabetically by name)
         def serialize_complex_types(schema, prefix = nil, schema_source = nil,
 file_path = nil)
-          return [] unless schema.respond_to?(:complex_types) || schema.respond_to?(:complex_type)
+          return [] unless schema.is_a?(Lutaml::Xml::Schema::Xsd::Schema)
 
-          types = schema.respond_to?(:complex_types) ? schema.complex_types : schema.complex_type
+          types = schema.complex_types
           serialized = types.map.with_index do |type, index|
             serialize_complex_type(
               type, index, prefix, schema_source, file_path
@@ -598,13 +598,13 @@ file_path = nil)
         # @param file_path [String, nil] Optional file path for diagram generation
         # @return [Array<Hash>] Serialized inline complex types
         def serialize_inline_complex_types(schema, prefix = nil, _schema_source = nil, _file_path = nil)
-          return [] unless schema.respond_to?(:element) && schema.element
+          return [] unless schema.element
 
           elements = schema.element.is_a?(Array) ? schema.element : [schema.element]
           inline_types = []
 
           elements.compact.each do |element|
-            next unless element.respond_to?(:complex_type) && element.complex_type
+            next unless element.complex_type
             next if element.complex_type.name # Skip if already named (top-level)
 
             # Generate a synthetic name for the inline type
@@ -615,8 +615,8 @@ file_path = nil)
               name: inline_name,
               base: nil,
               content_model: extract_content_model(element.complex_type),
-              abstract: element.complex_type.respond_to?(:abstract) ? element.complex_type.abstract : false,
-              mixed: element.complex_type.respond_to?(:mixed) ? element.complex_type.mixed : false,
+              abstract: element.complex_type.abstract || false,
+              mixed: element.complex_type.mixed || false,
               attributes: serialize_type_attributes(element.complex_type),
               elements: serialize_type_elements(element.complex_type),
               choice: serialize_choice(element.complex_type.choice),
@@ -705,7 +705,7 @@ schema_source = nil, file_path = nil)
         # @param model [Object] Model that may contain choice
         # @return [Array<Hash>] Serialized choices
         def serialize_choices(model)
-          return [] if !model.respond_to?(:choice) || !model.choice
+          return [] unless model.choice
 
           model_choices = if model.choice.is_a?(Array)
                             model.choice
@@ -743,7 +743,7 @@ schema_source = nil, file_path = nil)
         # @param model [Object] Model that may contain sequence
         # @return [Array<Hash>] Serialized sequences
         def serialize_sequences(model)
-          return [] if !model.respond_to?(:sequence) || !model.sequence
+          return [] unless model.sequence
 
           model_sequences = if model.sequence.is_a?(Array)
                               model.sequence
@@ -880,9 +880,9 @@ schema_source = nil, file_path = nil)
         # @param schema [Schema] Schema object
         # @return [Array<Hash>] Serialized groups
         def serialize_groups(schema, prefix = nil)
-          return [] unless schema.respond_to?(:groups) || schema.respond_to?(:group)
+          return [] unless schema.groups
 
-          grps = schema.respond_to?(:groups) ? schema.groups : schema.group
+          grps = schema.groups
           grps.map.with_index do |group, index|
             # serialize_group(group, index, prefix)
             serialize_type_group(group, index, prefix)
@@ -1081,8 +1081,8 @@ source = nil)
 
           {
             id: group_id(index, model, prefix),
-            ref: model.respond_to?(:ref) ? model.ref : nil,
-            name: model.respond_to?(:name) ? model.name : nil,
+            ref: model.ref,
+            name: model.name,
             occurs: {
               min: model.min_occurs || 1,
               max: model.max_occurs || 1,
@@ -1098,7 +1098,7 @@ source = nil)
         # @param model [Object] Model that may contain group
         # @return [Array<Hash>] Serialized groups
         def serialize_type_groups(model)
-          return [] if !model.respond_to?(:group) || !model.group
+          return [] unless model.group
 
           model_groups = if model.group.is_a?(Array)
                            model.group
@@ -1110,22 +1110,18 @@ source = nil)
           end
         end
 
-        # Collect attribute group references from a model (handles extension nesting)
+        # Collect attribute group references from a content wrapper
+        # (simpleContent/complexContent — both declare extension and
+        # restriction); the extensions carry the attribute groups.
         #
-        # Used for both direct attribute groups and those inside content model extensions.
-        #
-        # @param model [Object] Any object that may have attribute_group or extension
+        # @param model [SimpleContent, ComplexContent] Content wrapper
         # @return [Array<Object>] Collected attribute group reference objects
         def collect_attribute_group_refs(model)
           refs = []
 
-          if model.respond_to?(:attribute_group) && model.attribute_group && !model.attribute_group.empty?
-            groups = model.attribute_group.is_a?(Array) ? model.attribute_group : [model.attribute_group]
-            refs.concat(groups)
-          end
-
-          if model.respond_to?(:extension) && model.extension
-            refs.concat(collect_extension_attribute_group_refs(model.extension))
+          %i[extension restriction].each do |kind|
+            part = model.public_send(kind)
+            refs.concat(collect_extension_attribute_group_refs(part)) if part
           end
 
           refs
@@ -1385,7 +1381,8 @@ source = nil)
         # @param type [ComplexType] Complex type
         # @return [Array<Hash>] Serialized elements
         def serialize_type_elements(type)
-          return [] unless type.respond_to?(:element)
+          return [] unless type.is_a?(Lutaml::Xml::Schema::Xsd::Sequence) ||
+            type.is_a?(Lutaml::Xml::Schema::Xsd::Choice)
 
           type.element.map do |elem|
             {

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

@@ -22,6 +22,14 @@ module Lutaml
         #
         # @see docs/JING_ALGORITHM_PORTING_GUIDE.md Attribute Validation
         class AttributeValidationRule < ValidationRule
+          PROBE_SCHEMA = <<~XSD
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:complexType name="probe">
+                <xs:anyAttribute namespace="##local"/>
+              </xs:complexType>
+            </xs:schema>
+          XSD
+
           CONTENT_KINDS = %i[complex_content simple_content].freeze
           CONTENT_PART_KINDS = %i[extension restriction].freeze
 
@@ -371,6 +379,18 @@ module Lutaml
           #   Lutaml::Xsd::ComplexType, nil]
           # @param repository [SchemaDefinitionResolver, nil]
           # @return [AnyAttribute, nil]
+          # Whether the loaded lutaml-model parses xs:anyAttribute on
+          # complexType (the mapping landed after 0.8.121); probed once
+          # with a minimal schema.
+          def complex_type_wildcard_support?
+            @complex_type_wildcard_support ||= begin
+              probe = Lutaml::Xml::Schema::Xsd.parse(PROBE_SCHEMA)
+              !probe.complex_type.first.any_attribute.nil?
+            rescue StandardError
+              false
+            end
+          end
+
           def collect_any_attribute(schema_def, repository = nil)
             if schema_def.is_a?(Lutaml::Xml::Schema::Xsd::Element)
               type_def = resolve_type(schema_def, repository)
@@ -378,6 +398,12 @@ module Lutaml
             end
             return nil unless schema_def
 
+            if schema_def.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType) &&
+                complex_type_wildcard_support?
+              wildcard = schema_def.any_attribute
+              return wildcard if wildcard
+            end
+
             Array(schema_def.attribute_group).each do |group|
               wildcard = Array(group.any_attribute).first
               return wildcard if wildcard
@@ -389,7 +415,7 @@ module Lutaml
 
               CONTENT_PART_KINDS.each do |part_kind|
                 part = Array(content.public_send(part_kind)).first
-                next unless part.respond_to?(:any_attribute)
+                next unless part
 
                 wildcard = Array(part.any_attribute).first
                 return wildcard if wildcard

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

@@ -22,6 +22,15 @@ module Lutaml
         #
         # @see docs/JING_ALGORITHM_PORTING_GUIDE.md Content Model Validation
         class ContentModelValidationRule < ValidationRule
+          # Types whose particle accessors type_particles reads — all are
+          # declared model attributes (lutaml-model 0.8.114+).
+          COMPLEX_PARTICLE_TYPES = [
+            Lutaml::Xml::Schema::Xsd::ComplexType,
+            Lutaml::Xml::Schema::Xsd::ExtensionComplexContent,
+            Lutaml::Xml::Schema::Xsd::RestrictionComplexContent,
+          ].freeze
+          COMPLEX_PARTICLE_KINDS = %i[sequence choice all group].freeze
+
           # Rule category
           #
           # @return [Symbol] :structure
@@ -97,22 +106,21 @@ module Lutaml
             end
           end
 
-          # Ordered particles of a type: own sequence/choice/all/element/
-          # any/group particles plus, for extensions, the base type's
-          # particles first. Cycle-guarded. Particles are kept whole —
-          # nested containers are expanded by the walk's matching, which
+          # Ordered particles of a type: own sequence/choice/all/group
+          # particles plus, for extensions, the base type's particles
+          # first. Cycle-guarded. Particles are kept whole — nested
+          # containers are expanded by the walk's matching, which
           # preserves their own occurrence constraints.
           #
           # @return [Array]
           def type_particles(type, repository, seen)
             return [] if type.nil? || seen.key?(type)
+            return [] unless COMPLEX_PARTICLE_TYPES.any? { |k| type.is_a?(k) }
 
             seen[type] = true
             particles = []
 
-            %i[sequence choice all element any group].each do |kind|
-              next unless type.respond_to?(kind)
-
+            COMPLEX_PARTICLE_KINDS.each do |kind|
               Array(type.public_send(kind)).each do |particle|
                 next unless particle
 
@@ -127,7 +135,8 @@ module Lutaml
               end
             end
 
-            if type.respond_to?(:complex_content) && type.complex_content
+            if type.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType) &&
+                type.complex_content
               content = type.complex_content
               extension = Array(content.extension).first
               if extension
@@ -135,17 +144,15 @@ module Lutaml
                 base_type = base_local && repository&.resolve_named_type(base_local)
                 particles = type_particles(base_type, repository, seen) +
                   particles
-              end
-              %i[sequence choice all element any group].each do |kind|
-                next unless extension.respond_to?(kind)
-
-                Array(extension.public_send(kind)).each do |particle|
-                  next unless particle
-
-                  if particle.is_a?(Lutaml::Xsd::Sequence)
-                    particles.concat(collect_particles(particle))
-                  else
-                    particles << particle
+                COMPLEX_PARTICLE_KINDS.each do |kind|
+                  Array(extension.public_send(kind)).each do |particle|
+                    next unless particle
+
+                    if particle.is_a?(Lutaml::Xsd::Sequence)
+                      particles.concat(collect_particles(particle))
+                    else
+                      particles << particle
+                    end
                   end
                 end
               end
@@ -390,10 +397,8 @@ module Lutaml
           def collect_particles(content_model)
             # resolved_element_order preserves declaration order including
             # xs:any particles (which child_elements drops).
-            if content_model.respond_to?(:resolved_element_order) &&
-                content_model.resolved_element_order.to_a.any?
-              return content_model.resolved_element_order.to_a
-            end
+            ordered = content_model.resolved_element_order
+            return ordered.to_a if ordered.to_a.any?
 
             particles = []
 

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

@@ -100,13 +100,33 @@ module Lutaml
           def selector_xpaths(constraint)
             return [] unless constraint.selector
 
-            xpaths = constraint.selector.respond_to?(:xpath) ? constraint.selector.xpath : constraint.selector
-            Array(xpaths).map { |x| x.respond_to?(:xpath) ? x.xpath : x.to_s }
+            selector = constraint.selector
+            if selector.is_a?(Lutaml::Xml::Schema::Xsd::Selector)
+              xpath_strings(selector.xpath)
+            else
+              xpath_strings(selector)
+            end
           end
 
           def field_xpaths(constraint)
-            Array(constraint.field).map do |field|
-              field.respond_to?(:xpath) ? field.xpath : field.to_s
+            Array(constraint.field).flat_map do |field|
+              if field.is_a?(Lutaml::Xml::Schema::Xsd::Field)
+                xpath_strings(field.xpath)
+              else
+                xpath_strings(field)
+              end
+            end
+          end
+
+          # Selector/field values are either the raw XPath string or the
+          # parsed xs:selector/xs:field model whose xpath attribute holds
+          # it; whitespace-separated lists yield one entry each.
+          def xpath_strings(value)
+            case value
+            when String
+              value.split(/\s+/).reject(&:empty?)
+            else
+              []
             end
           end
 
@@ -114,7 +134,10 @@ module Lutaml
             first = Array(node.xpath(field_xpath)).first
             return nil unless first
 
-            first.respond_to?(:value) && first.value ? first.value : first.text
+            case first
+            when Moxml::Attribute then first.value
+            else first.text
+            end
           end
 
           # Keyref `refer` as a string; nil when the model left it

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

@@ -15,7 +15,25 @@ module Lutaml
       # Deliberately not resolved here (rule-engine backlog): dynamic
       # typing via xsi:type and derivation closure.
       class SchemaDefinitionResolver
-        PARTICLE_KINDS = %i[sequence choice all].freeze
+        # Nested particle accessors per container class — all are declared
+        # model attributes (lutaml-model 0.8.114+), so dispatch is by
+        # class rather than duck-typed probing. Sequence/Choice cannot
+        # nest xs:all, and only xs:all carries bare elements.
+        CONTAINER_NESTED_KINDS = {
+          Lutaml::Xml::Schema::Xsd::ComplexType => %i[sequence choice all],
+          Lutaml::Xml::Schema::Xsd::ExtensionComplexContent =>
+            %i[sequence choice all],
+          Lutaml::Xml::Schema::Xsd::RestrictionComplexContent =>
+            %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,
+        }.freeze
+        CONTAINER_LEAF_KINDS = {
+          Lutaml::Xml::Schema::Xsd::Sequence => %i[element any group],
+          Lutaml::Xml::Schema::Xsd::Choice => %i[element any group],
+          Lutaml::Xml::Schema::Xsd::All => %i[element].freeze,
+        }.freeze
 
         def initialize(repository)
           @repository = repository
@@ -126,21 +144,26 @@ module Lutaml
         private
 
         def particle_for_type(type)
-          return nil unless type.respond_to?(:sequence) || type.respond_to?(:choice) || type.respond_to?(:all)
-
-          direct = Array(type.sequence).first ||
-            Array(type.choice).first || Array(type.all).first
-          return direct if direct
-
-          # Derived types keep their particles under complex_content.
-          if type.respond_to?(:complex_content) && type.complex_content
-            content = type.complex_content
-            part = Array(content.extension).first ||
-              Array(content.restriction).first
-            return particle_for_type(part) if part
-          end
+          case type
+          when Lutaml::Xml::Schema::Xsd::ComplexType
+            direct = Array(type.sequence).first ||
+              Array(type.choice).first || Array(type.all).first
+            return direct if direct
+
+            # Derived types keep their particles under complex_content.
+            if type.complex_content
+              content = type.complex_content
+              part = Array(content.extension).first ||
+                Array(content.restriction).first
+              return particle_for_type(part) if part
+            end
 
-          nil
+            nil
+          when Lutaml::Xml::Schema::Xsd::ExtensionComplexContent,
+               Lutaml::Xml::Schema::Xsd::RestrictionComplexContent
+            Array(type.sequence).first ||
+              Array(type.choice).first || Array(type.all).first
+          end
         end
 
         def schemas
@@ -216,25 +239,32 @@ module Lutaml
           end
           return if visited_particle?(node)
 
-          PARTICLE_KINDS.each do |kind|
-            next unless node.respond_to?(kind) # optional particle collections
+          nested = CONTAINER_NESTED_KINDS[node.class]
+          return unless nested
 
+          nested.each do |kind|
             Array(node.public_send(kind)).each do |particle|
-              next unless particle
-
-              Array(particle.element).each(&)
-              PARTICLE_KINDS.each do |nested|
-                next unless particle.respond_to?(nested)
-
-                each_particle_element(particle.public_send(nested), &)
-              end
+              each_particle_element(particle, &) if particle
+            end
+          end
+          (CONTAINER_LEAF_KINDS[node.class] || []).each do |kind|
+            Array(node.public_send(kind)).each do |leaf|
+              # xs:any wildcards and xs:group references are not element
+              # declarations; the index holds Element models only.
+              yield leaf if leaf.is_a?(Lutaml::Xml::Schema::Xsd::Element)
             end
           end
 
-          return unless node.respond_to?(:complex_content) && node.complex_content
+          walk_complex_content(node, &) if
+            node.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
+        end
+
+        def walk_complex_content(node, &)
+          content = node.complex_content
+          return unless content
 
           %i[extension restriction].each do |kind|
-            part = node.complex_content.public_send(kind)
+            part = content.public_send(kind)
             each_particle_element(part, &) if part
           end
         end