RubyGems - moxml - Versions diffs - 0.5.161 → 0.5.163 - Mend

moxml 0.5.161 → 0.5.163

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

checksums.yaml +4 -4
data/benchmark/README.md +10 -10
data/benchmark/scoreboard.json +33 -33
data/docs/_pages/model-coverage.adoc +1 -0
data/docs/_pages/performance.adoc +11 -11
data/docs/_references/processing-model.adoc +10 -4
data/lib/moxml/version.rb +1 -1
data/lib/moxml/xsd/schema_rules.rb +174 -41
data/lib/moxml/xsd.rb +9 -0
data/spec/moxml/xsd_underdetection_spec.rb +171 -5
data/spec/moxml/xsd_version_spec.rb +82 -0
data/spec/support/model_coverage.rb +4 -0
metadata +3 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39e75ce66c66f3b1d5c72e8ba103dd2a4e6a2eb14d3e7fc9b016672e35a8759b
-  data.tar.gz: d502f9d3c5c739d6d86c68d79d2486d40b1a85747d3ef5b8503d1f1e9fc0d17c
+  metadata.gz: 66e9a76f3fb1a9a8e41d39d3f49c6ea97536a1d08a7aaf145169eb2ca8b2e72e
+  data.tar.gz: 5190677a144235ce163990b3cd3f7f6ef2a123ef4e02b1b81626e2467d74bcaf
 SHA512:
-  metadata.gz: 9ae62f4b5b1cef0b4f84c0a12b640292d762d110004dc0fd2bbadf4af5a374ace336d30e9aef7cd9e8e151590de5b67f07d9cf1e31afc7e82b8de1b2f01ebda2
-  data.tar.gz: 819a5bade9e79d666087a4a302484e0f88653f3a77db26585c2d370c70cd388e774b685bf5499ee1dbff2cb7307f5476aee3153acbf098db61e6e0c3bb010fcb
+  metadata.gz: 8dae5f5b85c572bf5f31efff0dcd1694854a5fffcf03feb066997136b53a44e2423a8208c08944c2159cd28ecdf83954cfe9856ed8354597d8ae8a664d7c434f
+  data.tar.gz: 0347c21ed0aecc388117e2c69632f9be715f0f1a073b5ac1dfad06fc8a0760cf07d652fc7cb39b0641ff5358b8a0d075f22de71befa72bdd687e24bf9ea1f2b4

data/benchmark/README.md CHANGED Viewed

@@ -92,16 +92,16 @@ rewrites this block and `docs/_pages/performance.adoc`):
 <!-- SCOREBOARD:BEGIN -->
 | Row | Ratio | Kind | Status |
 | --- | ----- | ---- | ------ |
-| `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 |
+| `parse` | 4.61x | parity | met |
+| `serialize` | 1.65x | parity | met |
+| `xpath //field (count)` | 3.39x | parity | met |
+| `xpath //field (each)` | 0.34x | structural | tracked (below parity) |
+| `attr pairs listing` | 8.48x | parity | met |
+| `build add_element` | 0.74x | structural | tracked (below parity) |
+| `walk+read (warm)` | 0.54x | structural | tracked (below parity) |
+| `walk+read (cold)` | 0.37x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression) |
+| `children recursion (cold)` | 0.45x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression) |
+| `plan records (typed)` | 1.13x | data | informational |
 <!-- SCOREBOARD:END -->
 The open rows are the known structural gap: every node the facade

data/benchmark/scoreboard.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "protocol": {
-    "measured": "2026-10-23T15:54:45Z",
+    "measured": "2026-10-24T05:26:53Z",
     "ruby": "3.3.13",
     "adapter": "leptris",
     "adapter_version": "1.9.381.0",
@@ -8,16 +8,16 @@
     "reps": 9,
     "warmup": 2,
     "clock": "CLOCK_PROCESS_CPUTIME_ID",
-    "load": 1.87
+    "load": 1.74
   },
   "rows": [
     {
       "row": "parse",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 1027.8,
-      "candidate_us": 286.6,
-      "ratio": 3.586,
+      "baseline_us": 1075.7,
+      "candidate_us": 233.6,
+      "ratio": 4.606,
       "baseline_allocs": 7,
       "candidate_allocs": 18
     },
@@ -25,9 +25,9 @@
       "row": "serialize",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 517.0,
-      "candidate_us": 281.9,
-      "ratio": 1.834,
+      "baseline_us": 457.0,
+      "candidate_us": 277.6,
+      "ratio": 1.646,
       "baseline_allocs": 30,
       "candidate_allocs": 14
     },
@@ -35,9 +35,9 @@
       "row": "xpath //field (count)",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 121.9,
-      "candidate_us": 25.4,
-      "ratio": 4.791,
+      "baseline_us": 64.4,
+      "candidate_us": 19.0,
+      "ratio": 3.387,
       "baseline_allocs": 13,
       "candidate_allocs": 8
     },
@@ -45,9 +45,9 @@
       "row": "xpath //field (each)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 361.9,
-      "candidate_us": 822.7,
-      "ratio": 0.44,
+      "baseline_us": 256.4,
+      "candidate_us": 744.4,
+      "ratio": 0.344,
       "baseline_allocs": 1213,
       "candidate_allocs": 10
     },
@@ -55,9 +55,9 @@
       "row": "attr pairs listing",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 502.0,
-      "candidate_us": 67.3,
-      "ratio": 7.458,
+      "baseline_us": 503.6,
+      "candidate_us": 59.4,
+      "ratio": 8.484,
       "baseline_allocs": 3300,
       "candidate_allocs": 0
     },
@@ -65,19 +65,19 @@
       "row": "build add_element",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 5532.8,
-      "candidate_us": 9658.2,
-      "ratio": 0.573,
+      "baseline_us": 5607.1,
+      "candidate_us": 7620.4,
+      "ratio": 0.736,
       "baseline_allocs": 20358,
-      "candidate_allocs": 11363
+      "candidate_allocs": 10163
     },
     {
       "row": "walk+read (warm)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 1805.4,
-      "candidate_us": 2797.9,
-      "ratio": 0.645,
+      "baseline_us": 1631.1,
+      "candidate_us": 3005.5,
+      "ratio": 0.543,
       "baseline_allocs": 4503,
       "candidate_allocs": 2
     },
@@ -85,9 +85,9 @@
       "row": "walk+read (cold)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 2938.6,
-      "candidate_us": 17354.2,
-      "ratio": 0.169,
+      "baseline_us": 3094.4,
+      "candidate_us": 8308.1,
+      "ratio": 0.372,
       "baseline_allocs": 6011,
       "candidate_allocs": 10232
     },
@@ -95,9 +95,9 @@
       "row": "children recursion (cold)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 3346.5,
-      "candidate_us": 25949.4,
-      "ratio": 0.129,
+      "baseline_us": 3414.5,
+      "candidate_us": 7574.2,
+      "ratio": 0.451,
       "baseline_allocs": 5711,
       "candidate_allocs": 8732
     },
@@ -105,9 +105,9 @@
       "row": "plan records (typed)",
       "kind": "data",
       "parity": false,
-      "baseline_us": 2901.1,
-      "candidate_us": 2554.9,
-      "ratio": 1.136,
+      "baseline_us": 3056.3,
+      "candidate_us": 2700.7,
+      "ratio": 1.132,
       "baseline_allocs": 8112,
       "candidate_allocs": 13232
     }

data/docs/_pages/model-coverage.adoc CHANGED Viewed

@@ -41,6 +41,7 @@ Generated by `bundle exec rake docs:coverage` from the coverage matrix and the d
 | materialization | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | validation | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | validation under-detections | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
+| validation version reporting | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | loud capability contracts | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 |===

data/docs/_pages/performance.adoc CHANGED Viewed

@@ -14,21 +14,21 @@ the marked block below from a live measurement; see
 // SCOREBOARD:BEGIN
 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.13, leptris 1.9.381.0, nokogiri 1.19.4, 2026-10-23T15:54:45Z, 1-minute load 1.87, 9 repetitions.
+Measurement: Ruby 3.3.13, leptris 1.9.381.0, nokogiri 1.19.4, 2026-10-24T05:26:53Z, 1-minute load 1.74, 9 repetitions.
 [cols="2,1,1,1",options="header"]
 |===
 | Row | Ratio | Kind | Status
-| `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
+| `parse` | 4.61x | parity | met
+| `serialize` | 1.65x | parity | met
+| `xpath //field (count)` | 3.39x | parity | met
+| `xpath //field (each)` | 0.34x | structural | tracked (below parity)
+| `attr pairs listing` | 8.48x | parity | met
+| `build add_element` | 0.74x | structural | tracked (below parity)
+| `walk+read (warm)` | 0.54x | structural | tracked (below parity)
+| `walk+read (cold)` | 0.37x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression)
+| `children recursion (cold)` | 0.45x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression)
+| `plan records (typed)` | 1.13x | 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: per-node wrapper minting costs (#312 endgame) and engine construction. *Data API* rows are informational.

data/docs/_references/processing-model.adoc CHANGED Viewed

@@ -255,7 +255,7 @@ semantics.
 === Validation
-Pins:: `spec/moxml/xsd_spec.rb`, `spec/moxml/xsd_underdetection_spec.rb`
+Pins:: `spec/moxml/xsd_spec.rb`, `spec/moxml/xsd_underdetection_spec.rb`, `spec/moxml/xsd_version_spec.rb`
 XSD validation through engines that ship a validator (libxml2;
 leptris tier-1: recognized roots, one-level content descent, lexical
@@ -263,9 +263,15 @@ checks). `validate` returns accumulated `ValidationError` entries —
 message always; line/column/path where the engine reports them, nil
 where it does not; `[]` means valid. Documents outside the engine's
 scope validate laxly, except that strict `xs:any` /
-`xs:anyAttribute` wildcard matches and `xsi:nil` are re-checked from
-the schema source on every adapter — the re-check can only
-under-report, never false-report. Unsupported adapters raise
+`xs:anyAttribute` wildcard matches, `xsi:nil`, and the XSD 1.1
+negative wildcards (`notQName` / `notNamespace` — an item excluded
+by them has no particle and the content model cannot accept it) are
+re-checked from the schema source on every adapter — the re-check
+can only under-report, never false-report. A compiled schema reports the
+version its source declares: root `vc:minVersion="1.1"` scopes the
+document to 1.1, anything else is 1.0 (consumers scope 1.0-only
+checks with it; applying 1.1 semantics is the engine-side program).
+Unsupported adapters raise
 `Moxml::NotImplementedError` at compile; `Moxml::XSD.supported?`
 answers without raising. RELAX NG rides engines with an RNG face
 (the same shapes).

data/lib/moxml/version.rb CHANGED Viewed

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

data/lib/moxml/xsd/schema_rules.rb CHANGED Viewed

@@ -8,7 +8,11 @@ module Moxml
     #
     #   * 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.
+    #   * `xsi:nil` on an element whose declaration is not nillable,
+    #   * the XSD 1.1 negative wildcards — `notQName` /
+    #     `notNamespace` on `xs:any` / `xs:anyAttribute` (#460):
+    #     engines that compile them without enforcing them absorb
+    #     excluded items the content model cannot accept.
     #
     # The rules run from an index of the schema SOURCE (this gem's
     # own XML machinery — no engine involvement) and merge with the
@@ -20,22 +24,18 @@ module Moxml
     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.
+      # A wildcard's namespace constraint and disallowed names, per
+      # XML Schema Structures §3.10.1–3.10.2 (##any default;
+      # processContents default strict; notNamespace / notQName are
+      # XSD 1.1). :tns / :local are resolved against the indexed
+      # schema at check time; notQName QNames are resolved against
+      # the schema element's in-scope bindings at index time.
       class Wildcard
-        def initialize(value, process)
+        def initialize(value, process, not_namespace: nil, not_qname: nil,
+                       element: nil)
           @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
+          @mode, @namespaces = namespace_constraint(value, not_namespace)
+          @disallowed = disallowed_names(not_qname, element).freeze
         end
         def strict?
@@ -47,13 +47,89 @@ module Moxml
           when :any then true
           when :other
             namespace != :local && namespace != :tns
+          when :not
+            @namespaces.none? { |entry| entry_covers?(entry, namespace) }
           else
             @namespaces.any? { |entry| entry_covers?(entry, namespace) }
           end
         end
+        # Why the wildcard refuses an item outright (Structures
+        # §3.10.4.1 Item Valid): a refusal is a match-level failure,
+        # so it applies at every processContents — the content model
+        # has no particle for the item and cannot accept it. 1.0
+        # namespace lists stay the engine's enforcement and never
+        # name an exclusion here.
+        def negative_exclusion(qname, namespace, defined:,
+                               sibling_names: [])
+          @disallowed.each do |entry|
+            case entry
+            when :defined
+              return :not_qname if defined
+            when :sibling
+              return :not_qname if sibling_names.include?(qname)
+            else
+              return :not_qname if entry == qname
+            end
+          end
+          return :not_namespace if @mode == :not &&
+            @namespaces.any? { |entry| entry_covers?(entry, namespace) }
+          nil
+        end
         private
+        def namespace_constraint(value, not_namespace)
+          if not_namespace
+            [:not, not_namespace.split(/\s+/).reject(&:empty?)]
+          elsif value.nil? || value == "##any" || value == ""
+            [:any, []]
+          elsif value == "##other"
+            [:other, []]
+          else
+            [:list, value.split(/\s+/).reject(&:empty?)]
+          end
+        end
+        # notQName entries (§3.10.2): QName | ##defined |
+        # ##definedSibling (xs:any; ##defined only on
+        # xs:anyAttribute). Prefixed QNames resolve against the
+        # wildcard element's in-scope bindings; unprefixed QNames
+        # carry no namespace — XSD QName values take no default
+        # namespace. Unresolvable prefixes are dropped: the index
+        # under-reports, never false-reports.
+        def disallowed_names(not_qname, element)
+          not_qname.to_s.split(/\s+/).reject(&:empty?).filter_map do |token|
+            case token
+            when "##defined" then :defined
+            when "##definedSibling" then :sibling
+            when /\A([^:]+):(.+)\z/
+              uri = prefix_uri(Regexp.last_match(1), element)
+              "{#{uri}}#{Regexp.last_match(2)}" unless uri.empty?
+            else
+              "{}#{token}"
+            end
+          end
+        end
+        # node.namespaces is adapter-divergent (some engines return
+        # in-scope bindings, others own-node declarations only), so
+        # the in-scope map is walked out by hand — per-node
+        # definitions merged along the ancestor axis, deeper
+        # overriding shallower, identically on every adapter.
+        def prefix_uri(prefix, element)
+          bindings = {}
+          node = element
+          while node
+            node.namespaces.each do |namespace|
+              bindings[namespace.prefix] = namespace.uri
+            end
+            node = node.parent&.element? ? node.parent : nil
+          end
+          bindings[prefix].to_s
+        end
         def entry_covers?(entry, namespace)
           namespace == case entry
                        when "##targetNamespace" then :tns
@@ -67,7 +143,11 @@ module Moxml
                                 :declared_attributes, :any_attribute)
       SchemaIndex = Struct.new(:target_namespace, :element_default,
                                :attribute_default, :elements,
-                               :attributes, :contents)
+                               :attributes, :contents, :version)
+      # The XSD 1.1 version-tagging namespace (Structures §C.3):
+      # vc:minVersion / vc:maxVersion gate 1.1 constructs.
+      VC_NS = "http://www.w3.org/2001/XMLSchema-versioning"
       class << self
         # Index one schema document. Returns nil when the source
@@ -81,7 +161,7 @@ module Moxml
             root["targetNamespace"].to_s,
             root["elementFormDefault"] == "qualified",
             root["attributeFormDefault"] == "qualified",
-            {}, {}, {}
+            {}, {}, {}, schema_version(root)
           )
           child_elements(root).each do |decl|
             case decl.name
@@ -94,6 +174,20 @@ module Moxml
           nil
         end
+        # The effective schema version declared at the root
+        # (#460 item 2): vc:minVersion="1.1" on <xs:schema> scopes
+        # the document to 1.1 semantics; anything else reports
+        # 1.0. Conditional (subtree-level) vc: evaluation is the
+        # engine's conditional-assignment work — the facade reports
+        # the root declaration only.
+        def schema_version(root)
+          declared = root.attributes.find do |attribute|
+            attribute.namespace&.uri == VC_NS &&
+              attribute.name == "minVersion"
+          end&.value
+          declared.to_s.start_with?("1.1") ? "1.1" : "1.0"
+        end
         # Post-validation findings for one instance document.
         def findings(doc, index)
           return [] unless index
@@ -175,12 +269,9 @@ module Moxml
               add_particle(child, index, model,
                            model.declared_attributes)
             when "any"
-              model.any ||= Wildcard.new(child["namespace"],
-                                         child["processContents"])
+              model.any ||= wildcard_from(child)
             when "anyAttribute"
-              model.any_attribute ||=
-                Wildcard.new(child["namespace"],
-                             child["processContents"])
+              model.any_attribute ||= wildcard_from(child)
             else
               collect_model(child, index, model)
             end
@@ -216,19 +307,25 @@ module Moxml
           end
         end
+        def wildcard_from(node)
+          Wildcard.new(
+            node["namespace"], node["processContents"],
+            not_namespace: node["notNamespace"],
+            not_qname: node["notQName"],
+            element: node
+          )
+        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),
-            )
+          elsif model.any &&
+              (finding = wildcard_child_finding(child, model, index,
+                                                qname))
+            findings << finding
           end
           findings.concat(
             attribute_findings(child, index.contents[qname], index),
@@ -236,13 +333,34 @@ module Moxml
           findings
         end
-        def undeclared_strict_wildcard_match?(_child, model, index, qname)
+        def wildcard_child_finding(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)
+          exclusion = wildcard.negative_exclusion(
+            qname, namespace,
+            defined: index.elements.key?(qname),
+            sibling_names: model.declared_children
+          )
+          return excluded_child_finding(child, qname, exclusion) if exclusion
+          return unless wildcard.covers?(namespace) && wildcard.strict?
+          return if index.elements.key?(qname)
+          Moxml::XSD::ValidationError.new(
+            message: "element <#{local(qname)}> matches a strict " \
+                     "wildcard but is not declared",
+            path: path_of(child),
+          )
+        end
+        def excluded_child_finding(child, qname, exclusion)
+          reason = exclusion == :not_namespace ? "notNamespace" : "notQName"
+          Moxml::XSD::ValidationError.new(
+            message: "element <#{local(qname)}> is disallowed by a " \
+                     "wildcard (#{reason}) and is not declared in the " \
+                     "content model",
+            path: path_of(child),
+          )
         end
         def attribute_findings(element, model, index)
@@ -253,14 +371,19 @@ module Moxml
             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),
+            next if model.declared_attributes.include?(qname)
+            next unless any_attribute
+            namespace = resolve_namespace(qname, index)
+            exclusion = any_attribute.negative_exclusion(
+              qname, namespace,
+              defined: index.attributes.key?(qname)
             )
+            next excluded_attribute_finding(element, qname, exclusion) if exclusion
+            next unless any_attribute.covers?(namespace)
+            next unless any_attribute.strict?
+            next if index.attributes.key?(qname)
             Moxml::XSD::ValidationError.new(
               message: "attribute #{local(qname)} matches a strict " \
@@ -270,6 +393,16 @@ module Moxml
           end
         end
+        def excluded_attribute_finding(element, qname, exclusion)
+          reason = exclusion == :not_namespace ? "notNamespace" : "notQName"
+          Moxml::XSD::ValidationError.new(
+            message: "attribute #{local(qname)} is disallowed by a " \
+                     "wildcard (#{reason}) and is not declared in the " \
+                     "content model",
+            path: path_of(element),
+          )
+        end
         def nil_finding(element, declaration)
           return if declaration[:nillable]

data/lib/moxml/xsd.rb CHANGED Viewed

@@ -175,6 +175,15 @@ module Moxml
         @context.config.adapter.xsd_declarations(@handle)
       end
+      # The effective schema version the source declares (#460 item
+      # 2): "1.1" when the root carries vc:minVersion="1.1", else
+      # "1.0". Consumers (lutaml-xsd) scope 1.0-only checks with
+      # it; the engine's application of 1.1 semantics is the
+      # engine-side program.
+      def version
+        @rules_index ? @rules_index.version : "1.0"
+      end
       # Deterministic drop (#362.3): true when the adapter freed
       # the engine-side schema NOW; false when the adapter can only
       # wait for GC (documented per adapter). After a true release

data/spec/moxml/xsd_underdetection_spec.rb CHANGED Viewed

@@ -4,11 +4,11 @@ require "spec_helper"
 # Processing model §Validation (normative): pinned here.
 # #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.
+# instances that violate strict wildcards or xsi:nil. #460: engines
+# may compile the 1.1 negative wildcards without enforcing them.
+# 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 corpus shapes.
 RSpec.describe "Moxml::XSD tier-1 under-detections (#452)" do
   %i[nokogiri leptris].each do |adapter_name|
     describe "on #{adapter_name}" do
@@ -152,6 +152,172 @@ RSpec.describe "Moxml::XSD tier-1 under-detections (#452)" do
         end
       end
+      describe "negative wildcards (XSD 1.1, #460)" do
+        before do
+          if adapter_name == :nokogiri
+            skip "#{adapter_name} requires an XSD 1.1 wildcard-capable " \
+                 "engine"
+          end
+        end
+        describe "xs:any notQName naming an excluded element" do
+          let(:schema) do
+            ctx.xsd(<<~XSD)
+              <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                  xmlns:w="http://example.com/w"
+                  targetNamespace="http://example.com/w"
+                  elementFormDefault="qualified">
+                <xs:element name="container">
+                  <xs:complexType>
+                    <xs:sequence>
+                      <xs:any processContents="strict"
+                              notQName="w:banned" minOccurs="0"
+                              maxOccurs="unbounded"/>
+                    </xs:sequence>
+                  </xs:complexType>
+                </xs:element>
+                <xs:element name="banned" type="xs:string"/>
+                <xs:element name="known" type="xs:string"/>
+              </xs:schema>
+            XSD
+          end
+          it "rejects the excluded element although it is declared" do
+            doc = ctx.parse(
+              '<container xmlns="http://example.com/w"><banned>x</banned></container>',
+            )
+            expect(schema.valid?(doc)).to be(false)
+            expect(schema.validate(doc).map(&:message)).to include(
+              /disallowed by a wildcard \(notQName\)/,
+            )
+          end
+          it "accepts a wildcard-matched declared element" do
+            doc = ctx.parse(
+              '<container xmlns="http://example.com/w"><known>x</known></container>',
+            )
+            expect(schema.valid?(doc)).to be(true)
+          end
+        end
+        describe "xs:any notQName=##defined" 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 processContents="lax"
+                              notQName="##defined" minOccurs="0"
+                              maxOccurs="unbounded"/>
+                    </xs:sequence>
+                  </xs:complexType>
+                </xs:element>
+                <xs:element name="known" type="xs:string"/>
+              </xs:schema>
+            XSD
+          end
+          it "rejects a declared element the ##defined wildcard excludes" do
+            doc = ctx.parse(
+              '<container xmlns="http://example.com/w"><known>x</known></container>',
+            )
+            expect(schema.valid?(doc)).to be(false)
+            expect(schema.validate(doc).map(&:message)).to include(
+              /disallowed by a wildcard \(notQName\)/,
+            )
+          end
+          it "absorbs an undeclared element laxly" do
+            doc = ctx.parse(
+              '<container xmlns="http://example.com/w"><unknown>x</unknown></container>',
+            )
+            expect(schema.valid?(doc)).to be(true)
+          end
+        end
+        describe "xs:any notNamespace" 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 processContents="lax"
+                              notNamespace="##targetNamespace"
+                              minOccurs="0" maxOccurs="unbounded"/>
+                    </xs:sequence>
+                  </xs:complexType>
+                </xs:element>
+              </xs:schema>
+            XSD
+          end
+          it "rejects an element in the disallowed namespace" do
+            doc = ctx.parse(
+              '<container xmlns="http://example.com/w"><stray/></container>',
+            )
+            expect(schema.valid?(doc)).to be(false)
+            expect(schema.validate(doc).map(&:message)).to include(
+              /disallowed by a wildcard \(notNamespace\)/,
+            )
+          end
+          it "absorbs an element from an allowed namespace" do
+            doc = ctx.parse(
+              '<container xmlns="http://example.com/w">' \
+              '<stray xmlns="http://example.com/other"/></container>',
+            )
+            expect(schema.valid?(doc)).to be(true)
+          end
+        end
+        describe "xs:anyAttribute notQName=##defined" do
+          let(:schema) do
+            ctx.xsd(<<~XSD)
+              <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                  targetNamespace="http://example.com/w"
+                  elementFormDefault="qualified"
+                  attributeFormDefault="qualified">
+                <xs:element name="settings">
+                  <xs:complexType>
+                    <xs:complexContent>
+                      <xs:restriction base="xs:anyType">
+                        <xs:anyAttribute processContents="lax"
+                                         notQName="##defined"/>
+                      </xs:restriction>
+                    </xs:complexContent>
+                  </xs:complexType>
+                </xs:element>
+                <xs:attribute name="marked" type="xs:string"/>
+              </xs:schema>
+            XSD
+          end
+          it "rejects a declared attribute the ##defined wildcard excludes" do
+            doc = ctx.parse(
+              '<settings xmlns="http://example.com/w" ' \
+              'xmlns:w="http://example.com/w" w:marked="x"/>',
+            )
+            expect(schema.valid?(doc)).to be(false)
+            expect(schema.validate(doc).map(&:message)).to include(
+              /attribute marked is disallowed by a wildcard \(notQName\)/,
+            )
+          end
+          it "absorbs an undeclared attribute laxly" do
+            doc = ctx.parse(
+              '<settings xmlns="http://example.com/w" free="x"/>',
+            )
+            expect(schema.valid?(doc)).to be(true)
+          end
+        end
+      end
       describe "wrong-namespace root" do
         let(:schema) do
           ctx.xsd(<<~XSD)

data/spec/moxml/xsd_version_spec.rb ADDED Viewed

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require "spec_helper"
+# Processing model §Validation (normative): pinned here.
+# #460 item 2: a compiled schema reports the effective version its
+# source declares — vc:minVersion="1.1" on the root scopes the
+# document to 1.1 semantics; anything else reports 1.0. The
+# detection is namespace-based (vc: is a convention, not a
+# requirement) and reads the ROOT declaration; conditional
+# (subtree-level) vc: evaluation is the engine's program.
+RSpec.describe "Moxml::XSD::Schema#version (#460 item 2)" 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
+      it "reports 1.1 when the root declares vc:minVersion=1.1" do
+        schema = ctx.xsd(<<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+              xmlns:vc="http://www.w3.org/2001/XMLSchema-versioning"
+              vc:minVersion="1.1">
+            <xs:element name="note" type="xs:string"/>
+          </xs:schema>
+        XSD
+        expect(schema.version).to eq("1.1")
+      end
+      it "detects the versioning namespace, not the prefix" do
+        schema = ctx.xsd(<<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+              xmlns:vcx="http://www.w3.org/2001/XMLSchema-versioning"
+              vcx:minVersion="1.1">
+            <xs:element name="note" type="xs:string"/>
+          </xs:schema>
+        XSD
+        expect(schema.version).to eq("1.1")
+      end
+      it "reports 1.0 without a root version declaration" do
+        schema = ctx.xsd(<<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+            <xs:element name="note" type="xs:string"/>
+          </xs:schema>
+        XSD
+        expect(schema.version).to eq("1.0")
+      end
+      it "reports 1.0 for an explicit root vc:minVersion=1.0" do
+        schema = ctx.xsd(<<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+              xmlns:vc="http://www.w3.org/2001/XMLSchema-versioning"
+              vc:minVersion="1.0">
+            <xs:element name="note" type="xs:string"/>
+          </xs:schema>
+        XSD
+        expect(schema.version).to eq("1.0")
+      end
+      it "reports 1.0 when only a construct carries vc:minVersion" do
+        schema = ctx.xsd(<<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+              xmlns:vc="http://www.w3.org/2001/XMLSchema-versioning">
+            <xs:element name="note">
+              <xs:complexType>
+                <xs:sequence vc:minVersion="1.1">
+                  <xs:element name="a"/>
+                </xs:sequence>
+              </xs:complexType>
+            </xs:element>
+          </xs:schema>
+        XSD
+        expect(schema.version).to eq("1.0")
+      end
+    end
+  end
+end

data/spec/support/model_coverage.rb CHANGED Viewed

@@ -85,6 +85,10 @@ module ModelCoverage
       section: "Validation",
       pin: "spec/moxml/xsd_underdetection_spec.rb",
     },
+    "validation version reporting" => {
+      section: "Validation",
+      pin: "spec/moxml/xsd_version_spec.rb",
+    },
     "loud capability contracts" => {
       section: "Errors and loud degradation",
       pin: "spec/consistency/loud_degradation_spec.rb",

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.161
+  version: 0.5.163
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-10-25 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -634,6 +634,7 @@ files:
 - spec/moxml/xsd_release_spec.rb
 - spec/moxml/xsd_spec.rb
 - spec/moxml/xsd_underdetection_spec.rb
+- spec/moxml/xsd_version_spec.rb
 - spec/moxml/xslt/stylesheet_spec.rb
 - spec/performance/README.md
 - spec/performance/benchmark_spec.rb