moxml 0.5.157 → 0.5.158

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87300d8760e99b65ddda1dd2163c09eeef602885700b8bf7159ee8cb06f708f5
-  data.tar.gz: 2bcf6f9deb2fd3bef73234ca9d2e9cac11771efc37e8339ecd2cbc82a2a9cb15
+  metadata.gz: a173c6faca10ad59c37096bc873999f16f7e5b05ae7afb9f2eba6041ec8147a2
+  data.tar.gz: e430658fbe932063794a0a04d2c05224a367da83ebc2f55c9eef8d7e67e431af
 SHA512:
-  metadata.gz: bfa9a5c9582fc99bae9aed8888c653ce3bdca81a3a5a3b32ed5be598eea5f0900793d9ef1f453cf8185a6838912a4f6393ae43038f1db2e6a9d1ca3a99c34dd6
-  data.tar.gz: e07cd31013b48ec143ef5840097c32cba6f00dff10141ca6f2e6371c98bde6ab98bdf920dc1e8701d5d2bea26d961d09d5c35d3229864beffa26e5066dc98e7c
+  metadata.gz: a68cad1dab561fa57921867cf856f9222e21f0413e7e4611dce3fa7f91e23b6ae52dc260921e03c8a0f83185ce1d7a6bd66f26e394151c55d08fe63b1b310686
+  data.tar.gz: 63ffc8a538f79c85bbc3179875d489f0ee20b8c36ae2498eac1694f0e1538e0ecf07e796a8364613fbe54d9a656da34965e87e9c1165960bd7815c19939e0669

data/benchmark/README.md

@@ -92,16 +92,16 @@ rewrites this block and `docs/_pages/performance.adoc`):
 <!-- SCOREBOARD:BEGIN -->
 | Row | Ratio | Kind | Status |
 | --- | ----- | ---- | ------ |
-| `parse` | 4.62x | parity | met |
-| `serialize` | 1.72x | parity | met |
-| `xpath //field (count)` | 0.70x | structural | tracked (below parity) |
-| `xpath //field (each)` | 0.36x | structural | tracked (below parity) |
-| `attr pairs listing` | 7.92x | parity | met |
-| `build add_element` | 0.60x | structural | tracked (below parity) |
-| `walk+read (warm)` | 0.54x | structural | tracked (below parity) |
-| `walk+read (cold)` | 0.21x | structural | tracked (below parity) |
-| `children recursion (cold)` | 0.18x | structural | tracked (below parity) |
-| `plan records (typed)` | 1.13x | data | informational |
+| `parse` | 3.59x | parity | met |
+| `serialize` | 1.83x | parity | met |
+| `xpath //field (count)` | 4.79x | parity | met |
+| `xpath //field (each)` | 0.44x | structural | tracked (below parity) |
+| `attr pairs listing` | 7.46x | parity | met |
+| `build add_element` | 0.57x | structural | tracked (below parity) |
+| `walk+read (warm)` | 0.64x | structural | tracked (below parity) |
+| `walk+read (cold)` | 0.17x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression) |
+| `children recursion (cold)` | 0.13x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression) |
+| `plan records (typed)` | 1.14x | data | informational |
 <!-- SCOREBOARD:END -->
 
 The open rows are the known structural gap: every node the facade

data/benchmark/scoreboard.json

@@ -1,23 +1,23 @@
 {
   "protocol": {
-    "measured": "2026-10-22T09:33:49Z",
-    "ruby": "3.3.12",
+    "measured": "2026-10-23T15:54:45Z",
+    "ruby": "3.3.13",
     "adapter": "leptris",
-    "adapter_version": "1.9.380.1",
+    "adapter_version": "1.9.381.0",
     "nokogiri": "1.19.4",
     "reps": 9,
     "warmup": 2,
     "clock": "CLOCK_PROCESS_CPUTIME_ID",
-    "load": 1.81
+    "load": 1.87
   },
   "rows": [
     {
       "row": "parse",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 1051.8,
-      "candidate_us": 227.7,
-      "ratio": 4.619,
+      "baseline_us": 1027.8,
+      "candidate_us": 286.6,
+      "ratio": 3.586,
       "baseline_allocs": 7,
       "candidate_allocs": 18
     },
@@ -25,39 +25,39 @@
       "row": "serialize",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 469.2,
-      "candidate_us": 272.1,
-      "ratio": 1.724,
+      "baseline_us": 517.0,
+      "candidate_us": 281.9,
+      "ratio": 1.834,
       "baseline_allocs": 30,
       "candidate_allocs": 14
     },
     {
       "row": "xpath //field (count)",
-      "kind": "structural",
-      "parity": false,
-      "baseline_us": 69.1,
-      "candidate_us": 98.0,
-      "ratio": 0.705,
+      "kind": "parity",
+      "parity": true,
+      "baseline_us": 121.9,
+      "candidate_us": 25.4,
+      "ratio": 4.791,
       "baseline_allocs": 13,
-      "candidate_allocs": 3
+      "candidate_allocs": 8
     },
     {
       "row": "xpath //field (each)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 263.3,
-      "candidate_us": 734.3,
-      "ratio": 0.359,
+      "baseline_us": 361.9,
+      "candidate_us": 822.7,
+      "ratio": 0.44,
       "baseline_allocs": 1213,
-      "candidate_allocs": 4
+      "candidate_allocs": 10
     },
     {
       "row": "attr pairs listing",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 488.8,
-      "candidate_us": 61.7,
-      "ratio": 7.92,
+      "baseline_us": 502.0,
+      "candidate_us": 67.3,
+      "ratio": 7.458,
       "baseline_allocs": 3300,
       "candidate_allocs": 0
     },
@@ -65,9 +65,9 @@
       "row": "build add_element",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 5572.7,
-      "candidate_us": 9372.9,
-      "ratio": 0.595,
+      "baseline_us": 5532.8,
+      "candidate_us": 9658.2,
+      "ratio": 0.573,
       "baseline_allocs": 20358,
       "candidate_allocs": 11363
     },
@@ -75,9 +75,9 @@
       "row": "walk+read (warm)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 1548.6,
-      "candidate_us": 2867.0,
-      "ratio": 0.54,
+      "baseline_us": 1805.4,
+      "candidate_us": 2797.9,
+      "ratio": 0.645,
       "baseline_allocs": 4503,
       "candidate_allocs": 2
     },
@@ -85,9 +85,9 @@
       "row": "walk+read (cold)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 2913.9,
-      "candidate_us": 13771.8,
-      "ratio": 0.212,
+      "baseline_us": 2938.6,
+      "candidate_us": 17354.2,
+      "ratio": 0.169,
       "baseline_allocs": 6011,
       "candidate_allocs": 10232
     },
@@ -95,9 +95,9 @@
       "row": "children recursion (cold)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 3381.3,
-      "candidate_us": 18658.1,
-      "ratio": 0.181,
+      "baseline_us": 3346.5,
+      "candidate_us": 25949.4,
+      "ratio": 0.129,
       "baseline_allocs": 5711,
       "candidate_allocs": 8732
     },
@@ -105,9 +105,9 @@
       "row": "plan records (typed)",
       "kind": "data",
       "parity": false,
-      "baseline_us": 3063.0,
-      "candidate_us": 2721.5,
-      "ratio": 1.126,
+      "baseline_us": 2901.1,
+      "candidate_us": 2554.9,
+      "ratio": 1.136,
       "baseline_allocs": 8112,
       "candidate_allocs": 13232
     }

data/docs/_pages/performance.adoc

@@ -12,28 +12,26 @@ the marked block below from a live measurement; see
 `benchmark/README.md` for the protocol and row definitions.
 
 // SCOREBOARD:BEGIN
-Generated from the gate-passed CI measurement (pinned ubuntu-24.04, settled runner, `benchmark:lock`). Protocol: CPU-time medians of an interleaved A/B run (raw nokogiri vs moxml on leptris); the ratio is baseline / candidate, so > 1.0 means the facade is faster. Warmups discarded, GC between samples.
+Generated by `SCORE_PUBLISH=1 bundle exec ruby benchmark/scoreboard.rb`. Protocol: CPU-time medians of an interleaved A/B run (raw nokogiri vs moxml on leptris); the ratio is baseline / candidate, so > 1.0 means the facade is faster. Warmups discarded, GC between samples.
 
-Measurement: Ruby 3.3.12, leptris leptris 1.9.380.1, nokogiri 1.19.4, 2026-10-22T09:33:49Z, 1-minute load 1.81, 9 repetitions.
+Measurement: Ruby 3.3.13, leptris 1.9.381.0, nokogiri 1.19.4, 2026-10-23T15:54:45Z, 1-minute load 1.87, 9 repetitions.
 
 [cols="2,1,1,1",options="header"]
 |===
 | Row | Ratio | Kind | Status
-| `parse` | 4.62x | parity | met
-| `serialize` | 1.72x | parity | met
-| `xpath //field (count)` | 0.70x | structural | tracked (below parity)
-| `xpath //field (each)` | 0.36x | structural | tracked (below parity)
-| `attr pairs listing` | 7.92x | parity | met
-| `build add_element` | 0.60x | structural | tracked (below parity)
-| `walk+read (warm)` | 0.54x | structural | tracked (below parity)
-| `walk+read (cold)` | 0.21x | structural | tracked (below parity)
-| `children recursion (cold)` | 0.18x | structural | tracked (below parity)
-| `plan records (typed)` | 1.13x | data | informational
+| `parse` | 3.59x | parity | met
+| `serialize` | 1.83x | parity | met
+| `xpath //field (count)` | 4.79x | parity | met
+| `xpath //field (each)` | 0.44x | structural | tracked (below parity)
+| `attr pairs listing` | 7.46x | parity | met
+| `build add_element` | 0.57x | structural | tracked (below parity)
+| `walk+read (warm)` | 0.64x | structural | tracked (below parity)
+| `walk+read (cold)` | 0.17x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression)
+| `children recursion (cold)` | 0.13x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression)
+| `plan records (typed)` | 1.14x | data | informational
 |===
 
-*Parity rows* must stay at or above the 0.95 measurement floor. *Structural rows* are measured and trend-locked (10% regression tolerance) while their gaps remain open. *Data API* rows are informational.
-
-NOTE: the 1.9.380 engine line regressed the crossing-bound rows ~2x (and the XPath evaluator itself) against 1.9.37x — tracked as leptris-ruby#527; this baseline records the 380.1 reality the lock now guards.
+*Parity rows* must stay at or above the 0.95 measurement floor. *Structural rows* are measured and trend-locked (10% regression tolerance) while their gaps remain open: per-node wrapper minting costs (#312 endgame) and engine construction. *Data API* rows are informational.
 // SCOREBOARD:END
 
 === Memory management

data/lib/moxml/context.rb

@@ -207,15 +207,19 @@ module Moxml
     # @raise [Moxml::NotImplementedError] on adapters without a validator
     def xsd(schema_source)
       handle = config.adapter.xsd_compile(schema_source.to_s)
-      Moxml::XSD::Schema.new(handle, self)
+      Moxml::XSD::Schema.new(handle, self, schema_source.to_s)
     end
 
     # Compile an XSD schema from a file path — <xs:include href>
     # resolves relative to the file's directory (the engine
     # resolves it; reading the file into #xsd would lose that).
+    # The #452 rule index reads this document only; included
+    # schema parts stay engine-validated (the index can only
+    # under-report).
     def xsd_file(path)
       handle = config.adapter.xsd_compile_file(path.to_s)
-      Moxml::XSD::Schema.new(handle, self)
+      source = File.read(path.to_s)
+      Moxml::XSD::Schema.new(handle, self, source)
     end
 
     # Compile a RELAX NG schema from source or from a file path (the

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.157"
+  VERSION = "0.5.158"
 end

data/lib/moxml/xsd/schema_rules.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XSD
+    # Ruby-side post-validation rules closing the tier-1
+    # under-detections tracked in #452: an engine may accept, inside
+    # its recognized scope, instances that violate
+    #
+    #   * a strict `xs:any` wildcard with an undeclared element,
+    #   * a strict `xs:anyAttribute` with an undeclared attribute,
+    #   * `xsi:nil` on an element whose declaration is not nillable.
+    #
+    # The rules run from an index of the schema SOURCE (this gem's
+    # own XML machinery — no engine involvement) and merge with the
+    # engine's findings; exact duplicates are dropped. Findings are
+    # one-directional: the index covers one schema document at
+    # tier-1's one-level content depth, so a missing piece can only
+    # under-report, never false-report — the same lax-scope posture
+    # tier-1 already has.
+    module SchemaRules
+      XSI_NS = "http://www.w3.org/2001/XMLSchema-instance"
+
+      # A wildcard's namespace attribute, per XML Schema
+      # Structures §3.10.2 (##any default; processContents default
+      # strict). :tns / :local are resolved against the indexed
+      # schema at check time.
+      class Wildcard
+        def initialize(value, process)
+          @process = (process || "strict").to_sym
+          case value
+          when nil, "##any", ""
+            @mode = :any
+          when "##other"
+            @mode = :other
+          else
+            @mode = :list
+            @namespaces = value.split(/\s+/).reject(&:empty?).freeze
+          end
+        end
+
+        def strict?
+          @process == :strict
+        end
+
+        def covers?(namespace)
+          case @mode
+          when :any then true
+          when :other
+            namespace != :local && namespace != :tns
+          else
+            @namespaces.any? { |entry| entry_covers?(entry, namespace) }
+          end
+        end
+
+        private
+
+        def entry_covers?(entry, namespace)
+          namespace == case entry
+                       when "##targetNamespace" then :tns
+                       when "##local" then :local
+                       else entry
+                       end
+        end
+      end
+
+      ContentModel = Struct.new(:declared_children, :any,
+                                :declared_attributes, :any_attribute)
+      SchemaIndex = Struct.new(:target_namespace, :element_default,
+                               :attribute_default, :elements,
+                               :attributes, :contents)
+
+      class << self
+        # Index one schema document. Returns nil when the source
+        # cannot be indexed — the engine's answer then stands alone
+        # (today's behavior).
+        def index(schema_source, context)
+          root = context.parse(schema_source).root
+          return nil unless root&.name == "schema"
+
+          index = SchemaIndex.new(
+            root["targetNamespace"].to_s,
+            root["elementFormDefault"] == "qualified",
+            root["attributeFormDefault"] == "qualified",
+            {}, {}, {}
+          )
+          child_elements(root).each do |decl|
+            case decl.name
+            when "element" then index_global_element(decl, index)
+            when "attribute" then index_global_attribute(decl, index)
+            end
+          end
+          index
+        rescue StandardError
+          nil
+        end
+
+        # Post-validation findings for one instance document.
+        def findings(doc, index)
+          return [] unless index
+
+          root = doc.root
+          return [] unless root
+
+          root_qname = qname(root)
+          declaration = index.elements[root_qname]
+          model = index.contents[root_qname]
+          findings = []
+          findings << nil_finding(root, declaration) if declaration
+          findings.concat(attribute_findings(root, model, index))
+          if model
+            child_elements(root).each do |child|
+              findings.concat(child_findings(child, model, index))
+            end
+          end
+          findings.compact
+        end
+
+        private
+
+        def index_global_element(decl, index)
+          name = decl["name"] or return
+          qname = "{#{index.target_namespace}}#{name}"
+          index.elements[qname] = { nillable: decl["nillable"] == "true" }
+          type_attr = decl.attribute("type")
+          model = if type_attr.nil? || type_attr.value.empty?
+                    inline_model(decl, index)
+                  else
+                    named_model(decl, index)
+                  end
+          index.contents[qname] = model if model
+        end
+
+        def index_global_attribute(decl, index)
+          name = decl["name"] or return
+          index.attributes["{#{index.target_namespace}}#{name}"] = true
+        end
+
+        def inline_model(decl, index)
+          type_node = child_elements(decl).find do |child|
+            child.name == "complexType"
+          end
+          content_model(type_node, index) if type_node
+        end
+
+        # A named complexType reference, indexed only when the
+        # definition sits directly under this schema element.
+        def named_model(decl, index)
+          type_name = decl.attribute("type")&.value.to_s.split(":").last
+          return nil unless type_name
+
+          type_node = child_elements(decl.parent).find do |child|
+            child.name == "complexType" && child["name"] == type_name
+          end
+          content_model(type_node, index) if type_node
+        end
+
+        def content_model(type_node, index)
+          model = ContentModel.new([], nil, [], nil)
+          collect_model(type_node, index, model)
+          model
+        end
+
+        # Particle presence across the type's subtree (sequence /
+        # choice / all / complexContent wrappers flattened): we only
+        # ADD findings for strict-wildcard matches, so flattening
+        # can only under-report, never over-report. Cardinality and
+        # order stay the engine's job.
+        def collect_model(node, index, model)
+          child_elements(node).each do |child|
+            case child.name
+            when "element"
+              add_particle(child, index, model,
+                           model.declared_children)
+            when "attribute"
+              add_particle(child, index, model,
+                           model.declared_attributes)
+            when "any"
+              model.any ||= Wildcard.new(child["namespace"],
+                                         child["processContents"])
+            when "anyAttribute"
+              model.any_attribute ||=
+                Wildcard.new(child["namespace"],
+                             child["processContents"])
+            else
+              collect_model(child, index, model)
+            end
+          end
+        end
+
+        def add_particle(particle, index, _model, sink)
+          ref = particle["ref"]
+          name = ref&.split(":")&.last || particle["name"]
+          return unless name
+
+          sink << if ref
+                    "{#{index.target_namespace}}#{name}"
+                  else
+                    "{#{form_namespace(particle, index)}}#{name}"
+                  end
+        end
+
+        # Particles declare with form="qualified"/"unqualified",
+        # else the schema's elementFormDefault (elements) /
+        # attributeFormDefault (attributes) — both default
+        # unqualified.
+        def form_namespace(particle, index)
+          default = if particle.name == "element"
+                      index.element_default
+                    else
+                      index.attribute_default
+                    end
+          case particle["form"]
+          when "qualified" then index.target_namespace
+          when "unqualified" then ""
+          else default ? index.target_namespace : ""
+          end
+        end
+
+        def child_findings(child, model, index)
+          qname = qname(child)
+          findings = []
+          if model.declared_children.include?(qname)
+            declaration = index.elements[qname]
+            findings << nil_finding(child, declaration) if declaration
+          elsif undeclared_strict_wildcard_match?(child, model, index,
+                                                  qname)
+            findings << Moxml::XSD::ValidationError.new(
+              message: "element <#{local(qname)}> matches a strict " \
+                       "wildcard but is not declared",
+              path: path_of(child),
+            )
+          end
+          findings.concat(
+            attribute_findings(child, index.contents[qname], index),
+          )
+          findings
+        end
+
+        def undeclared_strict_wildcard_match?(_child, model, index, qname)
+          wildcard = model.any
+          return false unless wildcard&.strict?
+          return false if index.elements.key?(qname)
+
+          namespace = resolve_namespace(qname, index)
+          wildcard.covers?(namespace) && !index.elements.key?(qname)
+        end
+
+        def attribute_findings(element, model, index)
+          return [] unless model
+
+          any_attribute = model.any_attribute
+          element.attributes.filter_map do |attribute|
+            next if attribute.namespace&.uri == XSI_NS
+
+            qname = attribute_qname(attribute)
+            declared = model.declared_attributes.include?(qname) ||
+              index.attributes.key?(qname)
+            next if declared
+            next unless any_attribute&.strict?
+            next if index.attributes.key?(qname)
+            next unless any_attribute.covers?(
+              resolve_namespace(qname, index),
+            )
+
+            Moxml::XSD::ValidationError.new(
+              message: "attribute #{local(qname)} matches a strict " \
+                       "wildcard but is not declared",
+              path: path_of(element),
+            )
+          end
+        end
+
+        def nil_finding(element, declaration)
+          return if declaration[:nillable]
+
+          value = element.attributes.find do |attribute|
+            attribute.namespace&.uri == XSI_NS &&
+              attribute.name == "nil"
+          end&.value
+          return unless %w[true 1].include?(value)
+
+          Moxml::XSD::ValidationError.new(
+            message: "element <#{element.name}> is not nillable but " \
+                     "carries xsi:nil=\"#{value}\"",
+            path: path_of(element),
+          )
+        end
+
+        # {uri}local → the wildcard vocabulary: :tns when the
+        # namespace is the schema's target, :local when empty, the
+        # URI otherwise.
+        def resolve_namespace(qname, index)
+          namespace = namespace_of(qname)
+          if namespace.empty?
+            :local
+          elsif namespace == index.target_namespace
+            :tns
+          else
+            namespace
+          end
+        end
+
+        def qname(node)
+          "{#{node.namespace&.uri}}#{node.name}"
+        end
+
+        def attribute_qname(attribute)
+          "{#{attribute.namespace&.uri}}#{attribute.name}"
+        end
+
+        def namespace_of(qname)
+          qname[/^\{(.*)\}/, 1].to_s
+        end
+
+        def local(qname)
+          qname[/\}(.*)$/, 1].to_s
+        end
+
+        def child_elements(node)
+          node.children.select(&:element?)
+        end
+
+        def path_of(node)
+          segments = [node.name]
+          current = node
+          while (parent = current.parent)&.element?
+            segments.unshift(parent.name)
+            current = parent
+          end
+          segments.join("/")
+        end
+      end
+    end
+  end
+end

data/lib/moxml/xsd.rb

@@ -28,6 +28,8 @@ module Moxml
   module XSD
     SUPPORTED_ADAPTERS = %i[leptris nokogiri].freeze
 
+    autoload :SchemaRules, "moxml/xsd/schema_rules"
+
     # One validation finding, harmonized across adapters (#362.2):
     # +message+ always present; +line+ / +column+ when the engine
     # reports them; +path+ (the element path) when the engine
@@ -89,9 +91,11 @@ module Moxml
               "schema released (deterministic drop); compile a new one"
       end
 
-      def initialize(handle, context)
+      def initialize(handle, context, schema_source = nil)
         @handle = handle
         @context = context
+        @rules_index =
+          schema_source && SchemaRules.index(schema_source, context)
         assert_adapter_matches_handle!
       end
 
@@ -143,7 +147,16 @@ module Moxml
                   parsed
                 end
               end
-        @context.config.adapter.xsd_validate(@handle, doc.native)
+        engine_errors = @context.config.adapter.xsd_validate(
+          @handle, doc.native
+        )
+        return engine_errors unless @rules_index
+
+        # The #452 post-validation rules only ever add findings for
+        # documents the engine accepted; exact duplicates are
+        # dropped for engines that already detect them.
+        (engine_errors +
+          SchemaRules.findings(doc, @rules_index)).uniq
       end
 
       def valid?(node_or_xml)

data/spec/moxml/xsd_underdetection_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #452: tier-1 engines can accept, inside their recognized scope,
+# instances that violate strict wildcards or xsi:nil. The
+# Ruby-side SchemaRules post-validation closes those gaps from the
+# schema source; findings merge with the engine's (duplicates
+# dropped), so every adapter answers invalid for the four
+# corpus shapes.
+RSpec.describe "Moxml::XSD tier-1 under-detections (#452)" do
+  %i[nokogiri leptris].each do |adapter_name|
+    describe "on #{adapter_name}" do
+      let(:ctx) { Moxml.new(adapter_name) }
+
+      before do
+        skip "#{adapter_name} requires an XSD-capable engine" unless
+          Moxml::XSD.supported?(ctx)
+      end
+
+      describe "strict xs:any with an undeclared element" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/w"
+                elementFormDefault="qualified">
+              <xs:element name="container">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:any namespace="##targetNamespace"
+                            processContents="strict" minOccurs="0"/>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+              <xs:element name="known" type="xs:string"/>
+            </xs:schema>
+          XSD
+        end
+
+        it "rejects the undeclared wildcard match" do
+          doc = ctx.parse(
+            '<container xmlns="http://example.com/w"><unknown>x</unknown></container>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+          expect(schema.validate(doc).map(&:message)).to include(
+            /matches a strict wildcard but is not declared/,
+          )
+        end
+
+        it "accepts the declared wildcard match" do
+          doc = ctx.parse(
+            '<container xmlns="http://example.com/w"><known>x</known></container>',
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+
+        it "leaves lax wildcards to the engine" do
+          lax = ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/w"
+                elementFormDefault="qualified">
+              <xs:element name="container">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:any namespace="##targetNamespace"
+                            processContents="lax" minOccurs="0"/>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+            </xs:schema>
+          XSD
+          doc = ctx.parse(
+            '<container xmlns="http://example.com/w"><unknown>x</unknown></container>',
+          )
+          expect(lax.valid?(doc)).to be(true)
+        end
+      end
+
+      describe "strict xs:anyAttribute with an undeclared attribute" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/aa"
+                elementFormDefault="qualified">
+              <xs:element name="settings">
+                <xs:complexType>
+                  <xs:complexContent>
+                    <xs:restriction base="xs:anyType">
+                      <xs:attribute name="lang"/>
+                      <xs:anyAttribute namespace="##targetNamespace ##local"
+                                       processContents="strict"/>
+                    </xs:restriction>
+                  </xs:complexContent>
+                </xs:complexType>
+              </xs:element>
+            </xs:schema>
+          XSD
+        end
+
+        it "rejects the undeclared wildcard match" do
+          doc = ctx.parse(
+            '<settings xmlns="http://example.com/aa" lang="en" bogus="1">v</settings>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+          expect(schema.validate(doc).map(&:message)).to include(
+            /attribute bogus matches a strict wildcard but is not declared/,
+          )
+        end
+
+        it "accepts the declared attribute" do
+          # self-closing: the empty-content-type reading of the
+          # restriction is the engine's answer, not this rule's
+          doc = ctx.parse(
+            '<settings xmlns="http://example.com/aa" lang="en"/>',
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+      end
+
+      describe "xsi:nil on a non-nillable element" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                elementFormDefault="qualified">
+              <xs:element name="memo" type="xs:string" nillable="true"/>
+              <xs:element name="strict" type="xs:string"/>
+            </xs:schema>
+          XSD
+        end
+
+        it "rejects xsi:nil on the non-nillable declaration" do
+          doc = ctx.parse(
+            '<strict xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+          expect(schema.validate(doc).map(&:message)).to include(
+            /is not nillable but carries xsi:nil/,
+          )
+        end
+
+        it "accepts xsi:nil on the nillable declaration" do
+          doc = ctx.parse(
+            '<memo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>',
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+
+        it "accepts the element without xsi:nil" do
+          doc = ctx.parse("<strict>text</strict>")
+          expect(schema.valid?(doc)).to be(true)
+        end
+      end
+
+      describe "wrong-namespace root" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/q"
+                elementFormDefault="qualified">
+              <xs:element name="note" type="xs:string"/>
+            </xs:schema>
+          XSD
+        end
+
+        it "rejects the root in the wrong namespace" do
+          doc = ctx.parse(
+            '<note xmlns="http://example.com/other">hi</note>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.157
+  version: 0.5.158
 platform: ruby
 authors:
 - Ribose Inc.
@@ -318,6 +318,7 @@ files:
 - lib/moxml/xpath/ruby/generator.rb
 - lib/moxml/xpath/ruby/node.rb
 - lib/moxml/xsd.rb
+- lib/moxml/xsd/schema_rules.rb
 - lib/moxml/xslt.rb
 - lib/moxml/xslt/stylesheet.rb
 - moxml.gemspec
@@ -631,6 +632,7 @@ files:
 - spec/moxml/xsd_handle_mismatch_spec.rb
 - spec/moxml/xsd_release_spec.rb
 - spec/moxml/xsd_spec.rb
+- spec/moxml/xsd_underdetection_spec.rb
 - spec/moxml/xslt/stylesheet_spec.rb
 - spec/performance/README.md
 - spec/performance/benchmark_spec.rb