lutaml-xsd 1.1.13 → 1.2.0

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

@@ -48,7 +48,8 @@ module Lutaml
           # @param collector [ResultCollector] Collector for validation
           #   results
           # @return [void]
-          def validate(xml_element, schema_element, collector)
+          def validate(xml_element, schema_element, collector,
+                       repository: nil)
             # Step 1: Validate element declaration exists
             unless validate_element_exists(xml_element, schema_element,
                                            collector)
@@ -59,7 +60,19 @@ module Lutaml
             validate_element_name(xml_element, schema_element, collector)
 
             # Step 3: Validate namespace correctness
-            validate_namespace(xml_element, schema_element, collector)
+            validate_namespace(xml_element, schema_element, collector,
+                               repository: repository)
+          end
+
+          # Structure checks run only for declarations the resolver could
+          # match: unresolved names also cover refs/substitution groups the
+          # resolver does not model yet, so treating them as errors here
+          # would misfire. Undeclared-element detection is tracked in
+          # TODO.conformance.md.
+          #
+          # @return [Boolean]
+          def runs_without_schema?
+            false
           end
 
           private
@@ -117,8 +130,9 @@ module Lutaml
           # @param schema_element [Lutaml::Xsd::Element] Schema element
           # @param collector [ResultCollector] Result collector
           # @return [void]
-          def validate_namespace(xml_element, schema_element, collector)
-            expected_ns = resolve_expected_namespace(schema_element)
+          def validate_namespace(xml_element, schema_element, collector,
+                                 repository: nil)
+            expected_ns = resolve_expected_namespace(schema_element, repository)
             actual_ns = xml_element.namespace_uri
 
             # Both nil is ok (no namespace)
@@ -152,21 +166,17 @@ module Lutaml
             xml_element.name == schema_element.name
           end
 
-          # Resolve expected namespace from schema element
+          # Resolve expected namespace for a schema declaration via the
+          # resolver's index (parsed declarations carry no owner-schema
+          # link).
           #
           # @param schema_element [Lutaml::Xsd::Element] Schema element
+          # @param repository [SchemaDefinitionResolver, nil]
           # @return [String, nil]
-          def resolve_expected_namespace(schema_element)
-            # Check if element has explicit targetNamespace
-            return schema_element.target_namespace if
-              schema_element.target_namespace
-
-            # Check parent schema's targetNamespace
-            if schema_element.schema&.target_namespace
-              return schema_element.schema.target_namespace
-            end
+          def resolve_expected_namespace(schema_element, repository)
+            return nil unless repository
 
-            nil
+            repository.target_namespace_for(schema_element)
           end
 
           # Normalize namespace (treat empty string as nil)

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "../validation_rule"
+
+module Lutaml
+  module Xsd
+    module Validation
+      module Rules
+        # Validates xs:key / xs:unique / xs:keyref identity constraints on
+        # an instance element.
+        #
+        # Selector and field XPaths evaluate against the instance subtree
+        # with unprefixed XPath semantics (no-namespace matching), which
+        # covers the common no-targetNamespace and local-name selector
+        # shapes. Scope: constraints declared on the element itself;
+        # cross-element keyref scopes and recursive selector Depth are
+        # backlog items (TODO.conformance.md).
+        class IdentityConstraintsRule < ValidationRule
+          def category
+            :identity
+          end
+
+          def description
+            "Validates key, keyref and unique identity constraints"
+          end
+
+          def validate(xml_element, schema_element, collector,
+                       repository: nil) # rubocop:disable Lint/UnusedMethodArgument
+            # `repository` is part of the element-scoped dispatch contract;
+            # identity constraints resolve names against the declaration.
+            return unless schema_element.is_a?(Lutaml::Xml::Schema::Xsd::Element)
+
+            collected = {}
+
+            Array(schema_element.key).each do |constraint|
+              values = collect_values(xml_element, constraint)
+              report_duplicates(collector, xml_element, constraint, values,
+                                "duplicate_key_violation")
+              collected[constraint.name] = values if constraint.name
+            end
+
+            Array(schema_element.unique).each do |constraint|
+              values = collect_values(xml_element, constraint)
+              report_duplicates(collector, xml_element, constraint, values,
+                                "duplicate_unique_violation")
+              collected[constraint.name] = values if constraint.name
+            end
+
+            Array(schema_element.keyref).each do |constraint|
+              referred = refer_name(constraint) && collected[refer_name(constraint)]
+              next if referred.nil?
+
+              collect_values(xml_element, constraint).each do |value|
+                next if referred.include?(value)
+
+                report_error(
+                  collector,
+                  code: "keyref_violation",
+                  message: "Value '#{value}' does not match any " \
+                           "'#{refer_name(constraint)}' key",
+                  location: xml_element.xpath,
+                  context: { value: value, refer: refer_name(constraint) },
+                )
+              end
+            end
+          end
+
+          private
+
+          def collect_values(xml_element, constraint)
+            selector_xpaths(constraint).flat_map do |selector|
+              Array(xml_element.moxml_element.xpath(selector)).map do |node|
+                field_xpaths(constraint).filter_map do |field|
+                  field_value(node, field)
+                end
+              end
+            end.flatten.compact
+          end
+
+          def report_duplicates(collector, xml_element, constraint, values,
+                                code)
+            values.group_by(&:itself).each do |value, group|
+              next unless group.length > 1
+
+              report_error(
+                collector,
+                code: code,
+                message: "Duplicate value '#{value}' for " \
+                         "'#{constraint.name}'",
+                location: xml_element.xpath,
+                context: {
+                  value: value,
+                  constraint: constraint.name,
+                  occurrences: group.length,
+                },
+              )
+            end
+          end
+
+          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 }
+          end
+
+          def field_xpaths(constraint)
+            Array(constraint.field).map do |field|
+              field.respond_to?(:xpath) ? field.xpath : field.to_s
+            end
+          end
+
+          def field_value(node, field_xpath)
+            first = Array(node.xpath(field_xpath)).first
+            return nil unless first
+
+            first.respond_to?(:value) && first.value ? first.value : first.text
+          end
+
+          # Keyref `refer` as a string; nil when the model left it
+          # unmapped (UninitializedClass — a lutaml-model mapping gap for
+          # `map_attribute :refer`).
+          def refer_name(constraint)
+            refer = constraint.refer
+            return nil unless refer.is_a?(String)
+
+            text = refer.split(":").last
+            text.to_s.empty? ? nil : text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -46,7 +46,8 @@ module Lutaml
           #   Lutaml::Xsd::Choice, Lutaml::Xsd::All] The schema particle
           # @param collector [ResultCollector] Collector for validation results
           # @return [void]
-          def validate(parent_element, schema_particle, collector)
+          def validate(parent_element, schema_particle, collector,
+                       repository: nil)
             return unless schema_particle
             return unless parent_element
 
@@ -54,19 +55,31 @@ module Lutaml
             case schema_particle
             when Lutaml::Xsd::Element
               validate_element_occurrence(parent_element, schema_particle,
-                                          collector)
+                                          collector, repository: repository)
             when Lutaml::Xsd::Sequence
               validate_sequence_occurrences(parent_element, schema_particle,
-                                            collector)
+                                            collector, repository: repository)
             when Lutaml::Xsd::Choice
               validate_choice_occurrences(parent_element, schema_particle,
-                                          collector)
+                                          collector, repository: repository)
             when Lutaml::Xsd::All
               validate_all_occurrences(parent_element, schema_particle,
-                                       collector)
+                                       collector, repository: repository)
             end
           end
 
+          # This rule validates the element's children against the
+          # content-model particle of the element's type.
+          #
+          # @param schema_def [Object, nil] Resolved schema declaration
+          # @param repository [SchemaDefinitionResolver, nil]
+          # @return [Object, nil]
+          def schema_argument(schema_def, repository: nil)
+            return nil unless schema_def && repository
+
+            repository.content_model_for(schema_def)
+          end
+
           private
 
           # Validate element occurrence
@@ -76,13 +89,14 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_element_occurrence(parent_element, schema_element,
-                                          collector)
+                                          collector, repository: nil)
             min_occurs = parse_occurs(schema_element.min_occurs, 1)
             max_occurs = parse_max_occurs(schema_element.max_occurs, 1)
 
             # Count actual occurrences
-            actual_count = count_element_occurrences(parent_element,
-                                                     schema_element)
+            actual_count = count_element_occurrences(
+              parent_element, schema_element, repository
+            )
 
             # Check minimum occurrence
             validate_min_occurs(parent_element, schema_element, actual_count,
@@ -100,15 +114,17 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_sequence_occurrences(parent_element, sequence,
-                                            collector)
+                                            collector, repository: nil)
             return if sequence.element.empty?
 
             Array(sequence.element).each do |element|
-              validate_element_occurrence(parent_element, element, collector)
+              validate_element_occurrence(parent_element, element, collector,
+                                          repository: repository)
             end
 
             # Also check nested sequences, choices, groups
-            validate_nested_particles(parent_element, sequence, collector)
+            validate_nested_particles(parent_element, sequence, collector,
+                                      repository: repository)
           end
 
           # Validate choice particle occurrences
@@ -117,13 +133,15 @@ module Lutaml
           # @param choice [Lutaml::Xsd::Choice] Schema choice
           # @param collector [ResultCollector] Result collector
           # @return [void]
-          def validate_choice_occurrences(parent_element, choice, collector)
+          def validate_choice_occurrences(parent_element, choice, collector,
+                                          repository: nil)
             min_occurs = parse_occurs(choice.min_occurs, 1)
             max_occurs = parse_max_occurs(choice.max_occurs, 1)
 
             # For choice, at least one alternative should be present
             # Count how many alternatives are present
-            present_count = count_choice_alternatives(parent_element, choice)
+            present_count = count_choice_alternatives(parent_element, choice,
+                                                      repository)
 
             if present_count < min_occurs
               report_error(
@@ -160,13 +178,15 @@ module Lutaml
           # @param all [Lutaml::Xsd::All] Schema all
           # @param collector [ResultCollector] Result collector
           # @return [void]
-          def validate_all_occurrences(parent_element, all, collector)
+          def validate_all_occurrences(parent_element, all, collector,
+                                       repository: nil)
             return if all.element.empty?
 
             # In xs:all, each element can appear 0 or 1 times
             # (or based on its minOccurs/maxOccurs)
             Array(all.element).each do |element|
-              validate_element_occurrence(parent_element, element, collector)
+              validate_element_occurrence(parent_element, element, collector,
+                                          repository: repository)
             end
           end
 
@@ -176,18 +196,21 @@ module Lutaml
           # @param particle [Object] Schema particle
           # @param collector [ResultCollector] Result collector
           # @return [void]
-          def validate_nested_particles(parent_element, particle, collector)
+          def validate_nested_particles(parent_element, particle, collector,
+                                        repository: nil)
             # Check for nested sequences
             if particle.sequence
               Array(particle.sequence).each do |seq|
-                validate_sequence_occurrences(parent_element, seq, collector)
+                validate_sequence_occurrences(parent_element, seq, collector,
+                                              repository: repository)
               end
             end
 
             # Check for nested choices
             if particle.choice
               Array(particle.choice).each do |choice|
-                validate_choice_occurrences(parent_element, choice, collector)
+                validate_choice_occurrences(parent_element, choice, collector,
+                                            repository: repository)
               end
             end
 
@@ -204,27 +227,50 @@ module Lutaml
           # @param parent_element [XmlElement] Parent element
           # @param schema_element [Lutaml::Xsd::Element] Schema element
           # @return [Integer]
-          def count_element_occurrences(parent_element, schema_element)
-            element_name = schema_element.name
-            target_ns = resolve_target_namespace(schema_element)
+          def count_element_occurrences(parent_element, schema_element,
+                                        repository = nil)
+            element_name = schema_element.name ||
+              schema_element.ref.to_s.split(":").last
+            target_ns = resolve_target_namespace(schema_element, repository)
 
             parent_element.children.count do |child|
-              child.name == element_name &&
+              name_matches = child.name == element_name &&
                 namespaces_match?(child.namespace_uri, target_ns)
+              name_matches ||
+                substitution_member?(child, schema_element, repository)
             end
           end
 
+          # Whether the child's declaration is a member of the
+          # substitution group headed by the particle's name/ref.
+          #
+          # @return [Boolean]
+          def substitution_member?(child, schema_element, repository)
+            return false unless repository
+
+            head = schema_element.ref
+            return false if head.to_s.empty?
+
+            declaration = repository.resolve(child.name, child.namespace_uri)
+            return false unless declaration
+
+            declaration.substitution_group.to_s.split(":").last ==
+              head.to_s.split(":").last
+          end
+
           # Count how many choice alternatives are present
           #
           # @param parent_element [XmlElement] Parent element
           # @param choice [Lutaml::Xsd::Choice] Schema choice
           # @return [Integer]
-          def count_choice_alternatives(parent_element, choice)
+          def count_choice_alternatives(parent_element, choice,
+                                        repository = nil)
             return 0 if choice.element.empty?
 
             alternatives = Array(choice.element)
             alternatives.count do |alt_element|
-              count_element_occurrences(parent_element, alt_element).positive?
+              count_element_occurrences(parent_element, alt_element,
+                                        repository).positive?
             end
           end
 
@@ -312,7 +358,12 @@ module Lutaml
           #
           # @param schema_element [Lutaml::Xsd::Element] Schema element
           # @return [String, nil]
-          def resolve_target_namespace(schema_element)
+          def resolve_target_namespace(schema_element, repository = nil)
+            # Inline declarations carry no namespace of their own; the
+            # resolver knows the owning schema's target namespace.
+            from_index = repository&.target_namespace_for(schema_element)
+            return from_index unless from_index.nil?
+
             schema_element.target_namespace
           end
 

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

@@ -46,10 +46,28 @@ module Lutaml
           # @param collector [ResultCollector] Collector for validation
           #   results
           # @return [void]
-          def validate(xml_element, schema_element, collector)
+          def validate(xml_element, schema_element, collector,
+                       repository: nil)
             return unless schema_element
 
-            type_def = resolve_element_type(schema_element)
+            return if xsi_nil_handled?(xml_element, schema_element, collector)
+
+            type_def = resolve_element_type(schema_element, repository)
+            if xsi_type_name(xml_element)
+              type_def = resolve_xsi_type(xsi_type_name(xml_element),
+                                          repository)
+              unless type_def
+                report_error(
+                  collector,
+                  code: "xsi_type_unknown",
+                  message: "xsi:type '#{xsi_type_name(xml_element)}' does " \
+                           "not resolve to a known type definition",
+                  location: xml_element.xpath,
+                  context: { xsi_type: xsi_type_name(xml_element) },
+                )
+                return
+              end
+            end
             return unless type_def
 
             case type_def
@@ -65,11 +83,67 @@ module Lutaml
 
           private
 
+          # xsi:nil handling: allowed only on nillable declarations, and a
+          # nil element must be empty. Returns true when the element is nil
+          # (nothing further to validate).
+          #
+          # @return [Boolean]
+          def xsi_nil_handled?(xml_element, schema_element, collector)
+            nil_attr = xsi_attribute(xml_element, "nil")
+            return false unless nil_attr&.value.to_s.match?(/\A(true|1)\z/)
+
+            unless schema_element.nillable.to_s.match?(/\A(true|1)\z/)
+              report_error(
+                collector,
+                code: "xsi_nil_not_allowed",
+                message: "Element '#{xml_element.name}' is not nillable " \
+                         "but carries xsi:nil",
+                location: xml_element.xpath,
+                context: { element: xml_element.name },
+              )
+              return true
+            end
+
+            return true if xml_element.children.empty?
+
+            report_error(
+              collector,
+              code: "xsi_nil_with_content",
+              message: "Element '#{xml_element.name}' has xsi:nil but " \
+                       "carries content",
+              location: xml_element.xpath,
+              context: { element: xml_element.name },
+            )
+            true
+          end
+
+          # The xsi:type attribute value (local part), or nil.
+          #
+          # @param xml_element [XmlElement]
+          # @return [String, nil]
+          def xsi_type_name(xml_element)
+            attr = xsi_attribute(xml_element, "type")
+            return nil unless attr&.value.to_s.match?(/\S/)
+
+            attr.value.to_s.split(":").last
+          end
+
+          # Resolve an xsi:type local name to a named type definition.
+          #
+          # @param local_name [String]
+          # @param repository [SchemaDefinitionResolver, nil]
+          # @return [Object, nil]
+          def resolve_xsi_type(local_name, repository)
+            return nil unless repository
+
+            repository.resolve_named_type(local_name)
+          end
+
           # Resolve the type definition for an element
           #
           # @param schema_element [Lutaml::Xsd::Element] Schema element
           # @return [Lutaml::Xsd::SimpleType, Lutaml::Xsd::ComplexType, nil]
-          def resolve_element_type(schema_element)
+          def resolve_element_type(schema_element, repository = nil)
             # Check for inline type definition
             return schema_element.simple_type if
               schema_element.simple_type
@@ -79,8 +153,9 @@ module Lutaml
 
             # Check for type reference
             if schema_element.type
-              # TODO: Resolve type from repository
-              # For now, return the type reference as-is
+              resolved = repository&.resolve_type(schema_element)
+              return resolved if resolved
+
               return schema_element.type
             end
 
@@ -154,9 +229,16 @@ module Lutaml
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_base_type(value, base_type, xml_element, collector)
-            # TODO: Implement base type validation
-            # This should use BaseTypeValidator registry
-            # For now, skip validation
+            answer = engine_builtin_answer(base_type, value)
+            return if answer.nil? || answer
+
+            report_error(
+              collector,
+              code: "type_validation_error",
+              message: "'#{value}' is not a valid #{base_type}",
+              location: xml_element.xpath,
+              context: { value: value, type: base_type },
+            )
           end
 
           # Validate facets
@@ -229,9 +311,11 @@ module Lutaml
                                      collector)
             value_length = value.length
 
-            # Check exact length
-            if restriction.length
-              expected_length = restriction.length.value.to_i
+            # Facet collections are arrays; an empty array must not be
+            # treated as a present facet.
+            length_facet = Array(restriction.length).first
+            if length_facet
+              expected_length = length_facet.value.to_i
               if value_length != expected_length
                 report_error(
                   collector,
@@ -249,8 +333,9 @@ module Lutaml
             end
 
             # Check minimum length
-            if restriction.min_length
-              min_length = restriction.min_length.value.to_i
+            min_length_facet = Array(restriction.min_length).first
+            if min_length_facet
+              min_length = min_length_facet.value.to_i
               if value_length < min_length
                 report_error(
                   collector,
@@ -268,9 +353,10 @@ module Lutaml
             end
 
             # Check maximum length
-            return unless restriction.max_length
+            max_length_facet = Array(restriction.max_length).first
+            return unless max_length_facet
 
-            max_length = restriction.max_length.value.to_i
+            max_length = max_length_facet.value.to_i
             return unless value_length > max_length
 
             report_error(
@@ -378,13 +464,44 @@ module Lutaml
 
           # Validate built-in type
           #
+          # The engine answers builtin lexical checks when the adapter ships
+          # an XSD engine; otherwise validation stays unimplemented here
+          # (matching historical behavior).
+          #
           # @param xml_element [XmlElement] The element
           # @param type_name [String] The type name
           # @param collector [ResultCollector] Result collector
           # @return [void]
           def validate_builtin_type(xml_element, type_name, collector)
-            # TODO: Implement built-in type validation using BaseTypeValidator
-            # For now, skip validation
+            answer = engine_builtin_answer(type_name, xml_element.text_content)
+            return if answer.nil?
+            return if answer
+
+            report_error(
+              collector,
+              code: "type_validation_error",
+              message: "'#{xml_element.text_content}' is not a valid " \
+                       "#{type_name}",
+              location: xml_element.xpath,
+              context: {
+                value: xml_element.text_content,
+                type: type_name,
+              },
+            )
+          end
+
+          # Engine answer for a builtin lexical check, nil when unavailable
+          #
+          # @param type_name [String] XSD type name (any prefix spelling)
+          # @param value [String, nil] The lexical value
+          # @return [Boolean, nil]
+          def engine_builtin_answer(type_name, value)
+            engine = @options[:engine_context]
+            return unless engine&.supported?
+
+            engine.builtin_valid?(
+              "xs:#{type_name.to_s.split(':').last}", value
+            )
           end
         end
       end