lutaml-xsd 1.1.13 → 1.2.0

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

@@ -5,7 +5,6 @@ require "moxml"
 require "tmpdir"
 require "fileutils"
 require "tempfile"
-require "nokogiri"
 require "xsdvi"
 require_relative "xml_instance_generator"
 require_relative "utils/extract_enumeration"
@@ -494,6 +493,8 @@ module Lutaml
           end
         end
 
+        public
+
         # Create a temporary XSD file that wraps a complexType/simpleType
         # in a synthetic root element, so xsdvi can generate a diagram for it.
         #
@@ -501,7 +502,7 @@ module Lutaml
         # @param original_file_path [String] Path to the original XSD file
         # @return [String] Path to the temporary XSD file
         def create_type_wrapper_xsd(type_name, original_file_path)
-          doc = Nokogiri::XML(File.read(original_file_path))
+          doc = Moxml::Context.new.parse(File.read(original_file_path))
           ns = { "xs" => "http://www.w3.org/2001/XMLSchema" }
           schema = doc.at_xpath("//xs:schema", ns)
 
@@ -519,11 +520,11 @@ module Lutaml
           # Create element with proper XSD namespace from the schema
           xsd_ns = "http://www.w3.org/2001/XMLSchema"
           xsd_ns_decl = schema.namespace_definitions.find do |nd|
-            nd.href == xsd_ns
+            nd.uri == xsd_ns
           end
 
           element_node = doc.create_element("element")
-          element_node.namespace = xsd_ns_decl
+          element_node.namespace = xsd_ns_decl if xsd_ns_decl
           element_node["name"] = wrapper_name
           element_node["type"] = type_ref
 
@@ -540,7 +541,7 @@ module Lutaml
         # that the schema uses internally for its targetNamespace.
         #
         # @param type_name [String] The type name
-        # @param doc [Nokogiri::Document] The parsed XSD document
+        # @param doc [Moxml::Document] The parsed XSD document
         # @param ns [Hash] Namespace mapping
         # @return [String] The type reference string (possibly prefixed)
         def resolve_type_prefix(type_name, doc, ns)
@@ -558,12 +559,14 @@ module Lutaml
           # Find what prefix maps to the targetNamespace
           ns_decls = schema.namespace_definitions
           tns_prefix = ns_decls.find do |nd|
-            nd.href == target_ns && nd.prefix
+            nd.uri == target_ns && nd.prefix
           end
 
           tns_prefix ? "#{tns_prefix.prefix}:#{type_name}" : type_name
         end
 
+        protected
+
         # Serialize complex types from schema
         #
         # @param schema [Schema] Schema object
@@ -950,7 +953,9 @@ source = nil)
                       "//#{type}[@#{key}='#{escaped_value}']"
                     end
             node = doc.at_xpath(xpath)
-            node&.to_xml(indent: 2)
+            # Element-level indentation is rejected by the leptris adapter
+            # (moxml 0.5.150+); fragments keep their source whitespace.
+            node&.to_xml
           rescue StandardError
             nil
           end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "moxml"
+
+module Lutaml
+  module Xsd
+    module Validation
+      # EngineContext adapts Moxml::XSD (engine-native XSD validation on
+      # leptris/nokogiri) to lutaml-xsd's validation stack.
+      #
+      # Engine findings are additive: tier-1 engine scope validates laxly
+      # outside named+typed top-level elements / one-level content-model
+      # descent / lexical checks, so the Ruby rule engine stays
+      # authoritative. All query methods return nil (not false) when the
+      # engine cannot answer, and callers fall back to Ruby logic.
+      #
+      # An instance document is validated only against compiled schemas
+      # that declare its root element with a matching targetNamespace —
+      # repositories (and the global processed-schema cache) hold many
+      # unrelated schemas, and blanket validation would let every schema
+      # reject every document.
+      class EngineContext
+        ENGINE_CODE = "engine_validation"
+
+        XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema"
+
+        CompiledSchema = Struct.new(:handle, :target_namespace, :element_names)
+
+        attr_reader :context, :schemas
+
+        class << self
+          # Compile repository schemas for the current adapter.
+          #
+          # @param repository [#all_schemas] Schema repository
+          # @param context [Moxml::Context] Adapter context
+          # @return [EngineContext, nil] nil when the adapter has no engine
+          def compile(repository, context: Moxml::Context.new)
+            return nil unless xsd_supported?(context)
+
+            schemas = repository.all_schemas.values.filter_map do |schema|
+              compile_schema(context, schema)
+            end
+            new(context, schemas)
+          end
+
+          # Whether the adapter ships an XSD validator.
+          #
+          # @param context [Moxml::Context] Adapter context
+          # @return [Boolean]
+          def xsd_supported?(context)
+            Moxml::XSD.supported?(context)
+          rescue Moxml::NotImplementedError, NameError
+            false
+          end
+
+          # Map a Moxml::XSD::ValidationError into the lutaml-xsd error type
+          #
+          # @param finding [Moxml::XSD::ValidationError]
+          # @return [Validation::ValidationError]
+          def map_finding(finding)
+            ValidationError.new(
+              code: ENGINE_CODE,
+              message: finding.message,
+              severity: :error,
+              location: finding.path,
+              line_number: finding.line,
+              context: { column: finding.column }.compact,
+            )
+          end
+
+          private
+
+          def compile_schema(context, schema)
+            source = schema.to_xml
+            compiled = context.xsd(source)
+            return nil if compiled.compile_error
+
+            info = inspect_schema(context, source)
+            CompiledSchema.new(
+              compiled, info[:target_namespace], info[:element_names]
+            )
+          rescue StandardError
+            nil
+          end
+
+          def inspect_schema(context, source)
+            doc = context.parse(source)
+            root = doc.root
+            names = doc.xpath("/xs:schema/xs:element[@name]",
+                              "xs" => XSD_NAMESPACE).map { |node| node["name"] }
+            { target_namespace: root&.[]("targetNamespace"),
+              element_names: names }
+          rescue StandardError
+            { target_namespace: nil, element_names: [] }
+          end
+        end
+
+        def initialize(context, schemas)
+          @context = context
+          @schemas = schemas
+        end
+
+        # @return [Boolean] true when at least one schema compiled
+        def supported?
+          !@schemas.empty?
+        end
+
+        # Validate raw XML against the compiled schemas that declare the
+        # document's root element.
+        #
+        # @param xml_content [String]
+        # @return [Array<Validation::ValidationError>]
+        def findings_for(xml_content)
+          root = instance_root(xml_content)
+          return [] unless root
+
+          matching_schemas(root).flat_map do |compiled|
+            compiled.handle.validate(xml_content)
+          end.map { |finding| self.class.map_finding(finding) }
+        end
+
+        # Lexical check against the built-in type table ("xs:NAME" spelling).
+        #
+        # @param builtin_name [String] e.g. "xs:date"
+        # @param lexical [String] the value to check
+        # @return [Boolean, nil] nil when the engine cannot answer
+        def builtin_valid?(builtin_name, lexical)
+          Moxml::XSD.builtin_valid?(@context, builtin_name, lexical)
+        rescue StandardError
+          nil
+        end
+
+        # Lexical check against a schema's named simpleType.
+        #
+        # @param type_name [String]
+        # @param lexical [String]
+        # @return [Boolean, nil] nil when no compiled schema knows the type
+        def simple_valid(type_name, lexical)
+          @schemas.each do |compiled|
+            answer = compiled.handle.simple_valid?(type_name, lexical)
+            return answer
+          rescue StandardError
+            next
+          end
+          nil
+        end
+
+        # Content-model check for one element's children (Moxml nodes).
+        #
+        # @param element_name [String]
+        # @param children [Array<Moxml::Node>]
+        # @return [Boolean, nil] nil when the engine cannot answer
+        def content_valid(element_name, children)
+          @schemas.each do |compiled|
+            answer = compiled.handle.content_valid?(element_name, children)
+            return answer
+          rescue StandardError
+            next
+          end
+          nil
+        end
+
+        private
+
+        def instance_root(xml_content)
+          @context.parse(xml_content).root
+        rescue StandardError
+          nil
+        end
+
+        def matching_schemas(root)
+          name = root.name
+          ns = root_namespace(root)
+
+          @schemas.select do |compiled|
+            compiled.element_names.include?(name) &&
+              (compiled.target_namespace.nil? ||
+               compiled.target_namespace == ns)
+          end
+        end
+
+        def root_namespace(root)
+          root.namespace&.uri
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative "rule_registry"
 require_relative "result_collector"
+require_relative "schema_definition_resolver"
 
 module Lutaml
   module Xsd
@@ -45,9 +46,19 @@ module Lutaml
         # @raise [StopValidationError] if stop-on-first-error is enabled
         def execute_category(category, document, repository)
           rules = @registry.rules_for_category(category)
-
-          rules.each do |rule|
-            execute_rule(rule, document, repository)
+          return if rules.empty?
+
+          resolver = SchemaDefinitionResolver.new(repository)
+          each_element(document) do |xml_element|
+            schema_def = resolver.resolve(
+              xml_element.name, xml_element.namespace_uri
+            )
+            rules.each do |rule|
+              argument = rule.schema_argument(schema_def, repository: resolver)
+              next if argument.nil? && !rule.runs_without_schema?
+
+              execute_rule(rule, xml_element, argument, resolver)
+            end
           end
         rescue ResultCollector::StopValidationError
           # Stop validation early if configured
@@ -72,16 +83,19 @@ module Lutaml
           # Stop validation early if configured
         end
 
-        # Execute a single rule
+        # Execute a single rule for one instance element
         #
         # @param rule [ValidationRule] The rule to execute
-        # @param document [XmlDocument] The XML document
-        # @param repository [SchemaRepository] The schema repository
+        # @param xml_element [XmlElement] The instance element
+        # @param schema_argument [Object, nil] What the rule validates against
+        # @param resolver [SchemaDefinitionResolver] Named-type resolver
         # @return [void]
-        def execute_rule(rule, document, repository)
+        def execute_rule(rule, xml_element, schema_argument, resolver)
           return unless rule.enabled?
 
-          rule.validate(document, repository, @collector)
+          rule.validate(
+            xml_element, schema_argument, @collector, repository: resolver
+          )
         rescue StandardError => e
           handle_rule_error(rule, e)
         end
@@ -106,16 +120,8 @@ module Lutaml
         # @param repository [SchemaRepository] The schema repository
         # @return [void]
         def execute_enabled(document, repository)
-          enabled_rules = @registry.all_rules(enabled_only: true)
-
-          # Group by category and execute in order
-          categories = ValidationRule::CATEGORIES
-
-          categories.each do |category|
-            category_rules = enabled_rules.select { |r| r.category == category }
-            category_rules.each do |rule|
-              execute_rule(rule, document, repository)
-            end
+          ValidationRule::CATEGORIES.each do |category|
+            execute_category(category, document, repository)
           end
         rescue ResultCollector::StopValidationError
           # Stop validation early if configured
@@ -164,6 +170,18 @@ module Lutaml
 
         private
 
+        # Depth-first walk over instance elements.
+        #
+        # @param node [XmlDocument, XmlElement] Start node
+        # @yieldparam element [XmlElement]
+        def each_element(node, &)
+          element = node.is_a?(XmlDocument) ? node.root_element : node
+          return unless element
+
+          yield element
+          element.children.each { |child| each_element(child, &) }
+        end
+
         # Handle errors that occur during rule execution
         #
         # @param rule [ValidationRule] The rule that failed

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

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 require_relative "validation_rule"
+require_relative "rules/element_structure_rule"
+require_relative "rules/type_validation_rule"
+require_relative "rules/attribute_validation_rule"
+require_relative "rules/occurrence_validation_rule"
+require_relative "rules/content_model_validation_rule"
+require_relative "rules/identity_constraints_rule"
 
 module Lutaml
   module Xsd
@@ -11,6 +17,9 @@ module Lutaml
       # It organizes rules by category and provides methods to register,
       # retrieve, and filter rules based on configuration.
       #
+      # {RuleRegistry.default} builds the production rule set that the
+      # Validator and the conformance harness share.
+      #
       # @example Create and populate a registry
       #   registry = RuleRegistry.new(config)
       #   registry.register(ElementStructureRule.new)
@@ -31,6 +40,31 @@ module Lutaml
           @rules_by_category = Hash.new { |h, k| h[k] = [] }
         end
 
+        # Production rule set, gated by the validation feature flags.
+        #
+        # @param config [ValidationConfiguration]
+        # @return [RuleRegistry]
+        def self.default(config)
+          registry = new(config)
+          registry.register(Rules::ElementStructureRule.new)
+          if config.feature_enabled?(:validate_types)
+            registry.register(Rules::TypeValidationRule.new)
+          end
+          if config.feature_enabled?(:validate_attributes)
+            registry.register(Rules::AttributeValidationRule.new)
+          end
+          if config.feature_enabled?(:validate_occurrences)
+            registry.register(Rules::OccurrenceValidationRule.new)
+          end
+          if config.feature_enabled?(:validate_content_models)
+            registry.register(Rules::ContentModelValidationRule.new)
+          end
+          if config.feature_enabled?(:validate_identity_constraints)
+            registry.register(Rules::IdentityConstraintsRule.new)
+          end
+          registry
+        end
+
         # Register a validation rule
         #
         # @param rule [ValidationRule] The rule to register

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

@@ -22,6 +22,9 @@ module Lutaml
         #
         # @see docs/JING_ALGORITHM_PORTING_GUIDE.md Attribute Validation
         class AttributeValidationRule < ValidationRule
+          CONTENT_KINDS = %i[complex_content simple_content].freeze
+          CONTENT_PART_KINDS = %i[extension restriction].freeze
+
           # Rule category
           #
           # @return [Symbol] :constraint
@@ -47,11 +50,14 @@ module Lutaml
           #   The schema definition
           # @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
 
-            schema_attributes = collect_schema_attributes(schema_element)
+            schema_attributes =
+              collect_schema_attributes(schema_element, repository)
             xml_attributes = xml_element.attributes
+            wildcard = collect_any_attribute(schema_element, repository)
 
             # Step 1: Check required attributes are present
             validate_required_attributes(xml_element, schema_attributes,
@@ -63,7 +69,9 @@ module Lutaml
 
             # Step 3: Check for unexpected attributes
             validate_no_unexpected_attributes(xml_element, schema_attributes,
-                                              xml_attributes, collector)
+                                              xml_attributes, collector,
+                                              wildcard: wildcard,
+                                              repository: repository)
           end
 
           private
@@ -73,13 +81,13 @@ module Lutaml
           # @param schema_def [Lutaml::Xsd::Element, Lutaml::Xsd::ComplexType]
           #   Schema definition
           # @return [Array<Lutaml::Xsd::Attribute>]
-          def collect_schema_attributes(schema_def)
+          def collect_schema_attributes(schema_def, repository = nil)
             attributes = []
 
             # For elements, get attributes from type
             if schema_def.is_a?(Lutaml::Xml::Schema::Xsd::Element)
-              type_def = resolve_type(schema_def)
-              return collect_schema_attributes(type_def) if type_def
+              type_def = resolve_type(schema_def, repository)
+              return collect_schema_attributes(type_def, repository) if type_def
             end
 
             # For complex types, collect attributes
@@ -113,11 +121,12 @@ module Lutaml
           #
           # @param element [Lutaml::Xsd::Element] Schema element
           # @return [Lutaml::Xsd::ComplexType, nil]
-          def resolve_type(element)
+          def resolve_type(element, repository = nil)
             return element.complex_type if element.complex_type
+            return nil unless element.type
 
-            # TODO: Resolve type reference from repository
-            nil
+            resolved = repository&.resolve_type(element)
+            resolved if resolved.is_a?(Lutaml::Xml::Schema::Xsd::ComplexType)
           end
 
           # Expand attribute group reference
@@ -301,9 +310,12 @@ module Lutaml
           # @param schema_attrs [Array<Lutaml::Xsd::Attribute>] Schema attrs
           # @param xml_attrs [Array<XmlAttribute>] XML attributes
           # @param collector [ResultCollector] Result collector
+          # @param wildcard [AnyAttribute, nil] xs:anyAttribute declaration
+          # @param repository [SchemaDefinitionResolver, nil]
           # @return [void]
           def validate_no_unexpected_attributes(xml_element, schema_attrs,
-                                                xml_attrs, collector)
+                                                xml_attrs, collector,
+                                                wildcard: nil, repository: nil)
             xml_attrs.each do |xml_attr|
               # Skip xmlns attributes
               next if xml_attr.name == "xmlns" ||
@@ -316,8 +328,23 @@ module Lutaml
               schema_attr = find_schema_attribute(schema_attrs, xml_attr)
               next if schema_attr
 
-              # Check for wildcard (anyAttribute)
-              next if has_any_attribute?(schema_attrs)
+              if wildcard &&
+                  wildcard_permits_attribute?(wildcard, xml_element,
+                                              xml_attr, repository)
+                if wildcard.process_contents.to_s == "strict" &&
+                    !attribute_declared?(xml_attr, repository)
+                  report_error(
+                    collector,
+                    code: "wildcard_undeclared_attribute",
+                    message: "Attribute '#{xml_attr.qualified_name}' " \
+                             "matches xs:anyAttribute with " \
+                             "processContents=strict but is not declared",
+                    location: xml_element.xpath,
+                    context: { attribute: xml_attr.qualified_name },
+                  )
+                end
+                next
+              end
 
               report_error(
                 collector,
@@ -334,13 +361,95 @@ module Lutaml
             end
           end
 
-          # Check if schema allows any attribute (wildcard)
+          # The xs:anyAttribute wildcard declared on this type, where the
+          # parse layer exposes one (attribute groups and content-model
+          # extension/restriction do). complexType-level wildcards are not
+          # mapped upstream yet, so types carrying one keep the
+          # pre-wildcard behavior for undeclared attributes.
+          #
+          # @param schema_def [Lutaml::Xml::Schema::Xsd::Element,
+          #   Lutaml::Xsd::ComplexType, nil]
+          # @param repository [SchemaDefinitionResolver, nil]
+          # @return [AnyAttribute, nil]
+          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)
+              return collect_any_attribute(type_def, repository) if type_def
+            end
+            return nil unless schema_def
+
+            Array(schema_def.attribute_group).each do |group|
+              wildcard = Array(group.any_attribute).first
+              return wildcard if wildcard
+            end
+
+            CONTENT_KINDS.each do |content_kind|
+              content = schema_def.public_send(content_kind)
+              next unless content
+
+              CONTENT_PART_KINDS.each do |part_kind|
+                part = Array(content.public_send(part_kind)).first
+                next unless part.respond_to?(:any_attribute)
+
+                wildcard = Array(part.any_attribute).first
+                return wildcard if wildcard
+              end
+            end
+
+            nil
+          end
+
+          # Whether an xs:anyAttribute wildcard's namespace constraint
+          # admits the attribute (attributes default to unqualified, so
+          # ##local is the common admission).
           #
-          # @param schema_attrs [Array<Lutaml::Xsd::Attribute>] Schema attrs
           # @return [Boolean]
-          def has_any_attribute?(_schema_attrs)
-            # TODO: Check for anyAttribute in schema
-            false
+          def wildcard_permits_attribute?(wildcard, parent, xml_attr,
+                                          repository)
+            ns = xml_attr.namespace_uri.to_s
+            target = content_target_namespace(parent, repository).to_s
+            case wildcard.namespace.to_s
+            when "##any", ""
+              true
+            when "##other"
+              !ns.empty? && ns != target
+            when "##local"
+              ns.empty?
+            when "##targetNamespace"
+              ns == target
+            else
+              # space-separated namespace list (##targetNamespace ##local
+              # allowed)
+              wildcard.namespace.to_s.split(/\s+/).any? do |entry|
+                case entry
+                when "##local" then ns.empty?
+                when "##targetNamespace" then ns == target
+                else entry == ns
+                end
+              end
+            end
+          end
+
+          # Whether a strict-wildcard attribute resolves to a global
+          # declaration in the repository.
+          #
+          # @return [Boolean]
+          def attribute_declared?(xml_attr, repository)
+            return true if repository.nil?
+
+            !repository.resolve_attribute(xml_attr.name,
+                                          xml_attr.namespace_uri).nil?
+          end
+
+          # Target namespace of the schema owning the parent's declaration.
+          #
+          # @return [String, nil]
+          def content_target_namespace(parent, repository)
+            return nil unless repository
+
+            declaration = repository.resolve(parent.name,
+                                             parent.namespace_uri)
+            repository.target_namespace_for(declaration) if declaration
           end
 
           # Suggest similar attribute name