moxml 0.5.162 → 0.5.165

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3ff9c9a02aad66036e51b20f9dd72fb17adb09b51dbe3950bb5a5174a2f2158
-  data.tar.gz: b4924b020e3b4738e08197d918594df3269d5206fda86ab0f582b27e801a1dbf
+  metadata.gz: 8dae9d144ec375224efd389406ed2cdb06c5409ae91d985e95221a972a1158ac
+  data.tar.gz: 308da2c1430d4f7f6b195eeec3d4ba9f651c9664f30c2a6c1381923572409fbd
 SHA512:
-  metadata.gz: dcb4225b3f662a656232b4e4bccdaefeb261a186d9c01d5369ee54ec28829678202e69349372842e470dcd21bed702f6f28c0e58dc9e45b6c262fffab1ed937a
-  data.tar.gz: 22fa41a31b5a8541e2c3f5fa2c8eb088975f173902ff8c046e325ec55c28246e3c459df5e49d004fb2e89ea1d1d8f9adb841d71cae8e4fe8bfaea14cd25c5d7c
+  metadata.gz: 794455e01d1021344dd5f792802d10403cc35a57b4fd167dee967d59c8079f2e3467a392433dff45c9959919569d2e3fc68b4f0db8535257bb646ce9f48821ea
+  data.tar.gz: a2e777a2b636b71432ee8baa0610254cb2b464b33843f57063d31a6688974394cfc25e8c6e91851448c97f563acd80261833c5542d5b9b962aa2dae240c8aa27

data/docs/_pages/model-coverage.adoc

@@ -42,6 +42,7 @@ Generated by `bundle exec rake docs:coverage` from the coverage matrix and the d
 | 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
+| validation regex dismissal | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 | loud capability contracts | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent | equivalent
 |===
 

data/docs/_references/processing-model.adoc

@@ -255,7 +255,7 @@ semantics.
 
 === Validation
 
-Pins:: `spec/moxml/xsd_spec.rb`, `spec/moxml/xsd_underdetection_spec.rb`, `spec/moxml/xsd_version_spec.rb`
+Pins:: `spec/moxml/xsd_regex_spec.rb`, `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,22 @@ 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. A compiled schema reports the
+`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. Engine lexical findings
+that the source's own `pattern` facets refute are dismissed: an
+engine that cannot evaluate a dialect construct (e.g. the
+`\p{Is...}` block escapes) rejects every occurrence of the facet,
+so the facade re-checks the value against the facet translated to
+the host regex dialect — only whitelisted constructs translate
+(block escapes with Unicode-rename aliases, general categories,
+single-character escapes; subtraction, `\i`, `\c` do not), an
+engine finding is dropped only when every same-named instance
+matches the facet, and anything untranslatable keeps the engine's
+answer, so a dismissal can only remove false rejections, never
+create false acceptances. 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).

data/lib/moxml/version.rb

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

data/lib/moxml/xsd/schema_rules.rb

@@ -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,12 +143,94 @@ module Moxml
                                 :declared_attributes, :any_attribute)
       SchemaIndex = Struct.new(:target_namespace, :element_default,
                                :attribute_default, :elements,
-                               :attributes, :contents, :version)
+                               :attributes, :contents, :version,
+                               :element_patterns, :attribute_patterns)
 
       # 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"
 
+      # XSD pattern-facet dialect → Ruby regex, bounded to the
+      # subset the facade vouches for (Datatypes Appendix F). Block
+      # escapes \p{Is…}/\P{Is…} map to Ruby's In-prefixed blocks
+      # (a few Unicode-renamed blocks carry an alias); general
+      # categories and the single-character escapes pass through;
+      # \i, \c and class subtraction are NOT translated. Anything
+      # unrecognized — or a translation Ruby itself rejects —
+      # returns nil: the engine's answer then stands.
+      module XsdRegex
+        BLOCK_ALIASES = {
+          "Greek" => "GreekandCoptic",
+          "CombiningMarksforSymbols" =>
+            "CombiningDiacriticalMarksforSymbols",
+          "Turkish" => "Latin-1Supplement",
+        }.freeze
+
+        PASS_THROUGH_ESCAPES = %w[
+          n r t \\ . | ? * + ( ) [ ] { } ^ $ -
+        ].freeze
+
+        module_function
+
+        def translate(pattern)
+          translated = scan(pattern.to_s)
+          return nil unless translated
+
+          Regexp.new("\\A(?:#{translated})\\z")
+        rescue RegexpError
+          nil
+        end
+
+        def scan(pattern)
+          out = +""
+          index = 0
+          while index < pattern.length
+            char = pattern[index]
+            if char == "\\"
+              consumed = escape(pattern, index, out)
+              return nil unless consumed
+
+              index += consumed
+            else
+              return nil if char == "-" && pattern[index + 1] == "["
+
+              out << char
+              index += 1
+            end
+          end
+          out
+        end
+
+        # Appends the translation of the escape at index to out and
+        # returns the chars consumed, or nil when unrecognized.
+        def escape(pattern, index, out)
+          kind = pattern[index + 1]
+          case kind
+          when "p", "P"
+            close = pattern.index("}", index)
+            return nil unless close
+
+            body = pattern[index + 3, close - index - 3]
+            if body&.start_with?("Is")
+              mapped = body.delete_prefix("Is")
+              mapped = BLOCK_ALIASES.fetch(mapped, mapped)
+              begin
+                Regexp.new("\\p{In#{mapped}}")
+              rescue RegexpError
+                return nil
+              end
+              out << "\\#{kind}{In#{mapped}}"
+            else
+              out << pattern[index..close]
+            end
+            close - index + 1
+          when *PASS_THROUGH_ESCAPES
+            out << pattern[index, 2]
+            2
+          end
+        end
+      end
+
       class << self
         # Index one schema document. Returns nil when the source
         # cannot be indexed — the engine's answer then stands alone
@@ -85,7 +243,7 @@ module Moxml
             root["targetNamespace"].to_s,
             root["elementFormDefault"] == "qualified",
             root["attributeFormDefault"] == "qualified",
-            {}, {}, {}, schema_version(root)
+            {}, {}, {}, schema_version(root), {}, {}
           )
           child_elements(root).each do |decl|
             case decl.name
@@ -93,6 +251,7 @@ module Moxml
             when "attribute" then index_global_attribute(decl, index)
             end
           end
+          index_patterns(root, index)
           index
         rescue StandardError
           nil
@@ -112,6 +271,142 @@ module Moxml
           declared.to_s.start_with?("1.1") ? "1.1" : "1.0"
         end
 
+        # Index the pattern facets the dismissal may vouch with
+        # (#464): named simpleTypes resolve through one type-ref
+        # hop, inline simpleTypes directly; keys are local names.
+        # A name declared twice with different pattern sets is
+        # ambiguous for name-based matching and is removed — an
+        # ambiguous vouch could mask a real violation.
+        def index_patterns(root, index)
+          named = {}
+          collect_named_patterns(root, named)
+          collect_decl_patterns(root, index, named)
+        end
+
+        def collect_named_patterns(node, named)
+          child_elements(node).each do |child|
+            if child.name == "simpleType" && child["name"] &&
+                (patterns = restriction_patterns(child))
+              named[child["name"]] = patterns
+            else
+              collect_named_patterns(child, named)
+            end
+          end
+        end
+
+        def collect_decl_patterns(node, index, named)
+          child_elements(node).each do |child|
+            case child.name
+            when "element"
+              register_pattern(index.element_patterns, child["name"],
+                               decl_patterns(child, named))
+            when "attribute"
+              register_pattern(index.attribute_patterns, child["name"],
+                               decl_patterns(child, named))
+            end
+            collect_decl_patterns(child, index, named)
+          end
+        end
+
+        def decl_patterns(decl, named)
+          inline = child_elements(decl).find do |child|
+            child.name == "simpleType"
+          end
+          if inline
+            restriction_patterns(inline)
+          elsif decl["type"]
+            named[decl["type"].split(":").last]
+          end
+        end
+
+        def restriction_patterns(simple_type)
+          restriction = child_elements(simple_type).find do |child|
+            child.name == "restriction"
+          end
+          return nil unless restriction
+
+          patterns = child_elements(restriction)
+            .select { |facet| facet.name == "pattern" }
+            .map { |facet| XsdRegex.translate(facet["value"].to_s) }
+          return nil if patterns.any?(&:nil?)
+
+          patterns
+        end
+
+        def register_pattern(sink, name, patterns)
+          return unless name && patterns && !patterns.empty?
+
+          sink[name] = sink.key?(name) ? nil : patterns
+        end
+
+        # Dismisses engine lexical findings the source's own
+        # pattern facets refute (#464): an engine that cannot
+        # evaluate a dialect construct rejects every occurrence of
+        # the facet — including values the facet accepts. A
+        # finding is dropped only when every same-named instance
+        # in the document matches; one non-matching value keeps
+        # the engine's answer, so a dismissal can only remove
+        # false rejections, never create false acceptances.
+        def dismiss(engine_errors, doc, index)
+          return engine_errors unless index
+
+          vouched = vouch_table(doc, index)
+          engine_errors.reject do |error|
+            subject = lexical_subject(error.message)
+            subject && vouched[subject]
+          end
+        end
+
+        LEXICAL_MESSAGE = /\A(?:element|attribute) '([^']+)' @\d+:\d+: (element|attribute) '([^']+)': lexical value does not match its type\z/
+
+        private_constant :LEXICAL_MESSAGE
+
+        def lexical_subject(message)
+          match = LEXICAL_MESSAGE.match(message.to_s)
+          return unless match
+
+          [match[2], match[3]]
+        end
+
+        def vouch_table(doc, index)
+          root = doc.root
+          return {} unless root
+
+          elements = Hash.new { |hash, key| hash[key] = [] }
+          attributes = Hash.new { |hash, key| hash[key] = [] }
+          collect_witnesses(root, index, elements, attributes)
+          vouched = {}
+          elements.each do |name, matches|
+            vouched[["element", name]] = !matches.empty? && matches.all?
+          end
+          attributes.each do |name, matches|
+            vouched[["attribute", name]] = !matches.empty? && matches.all?
+          end
+          vouched
+        end
+
+        def collect_witnesses(node, index, elements, attributes)
+          child_elements(node).each do |child|
+            if (patterns = index.element_patterns[child.name])
+              elements[child.name] << (text_only?(child) &&
+                patterns.any? { |regex| regex.match?(child.text.to_s) })
+            end
+            child.attributes.each do |attribute|
+              next if attribute.namespace&.uri == XSI_NS
+
+              if (patterns = index.attribute_patterns[attribute.name])
+                attributes[attribute.name] <<
+                  patterns.any? { |regex| regex.match?(attribute.value.to_s) }
+              end
+            end
+            collect_witnesses(child, index, elements, attributes)
+          end
+        end
+
+        def text_only?(element)
+          child_elements(element).empty?
+        end
+
         # Post-validation findings for one instance document.
         def findings(doc, index)
           return [] unless index
@@ -193,12 +488,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
@@ -234,19 +526,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),
@@ -254,13 +552,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)
@@ -271,14 +590,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 " \
@@ -288,6 +612,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

@@ -157,9 +157,11 @@ module Moxml
         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 +
+        # documents the engine accepted; the #464 dismissal removes
+        # only engine lexical findings the source's own pattern
+        # facets refute. Exact duplicates are dropped for engines
+        # that already detect them.
+        (SchemaRules.dismiss(engine_errors, doc, @rules_index) +
           SchemaRules.findings(doc, @rules_index)).uniq
       end
 

data/spec/moxml/xsd_regex_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Processing model §Validation (normative): pinned here.
+# #464: an engine that cannot evaluate an XSD pattern-facet
+# dialect construct (e.g. the \p{Is...} block escapes) rejects
+# every occurrence of the facet — including values the facet
+# accepts — false-positiving valid documents. The Ruby-side
+# SchemaRules dismissal removes such engine findings only when the
+# schema source's own pattern facets vouch for every same-named
+# instance: one non-matching value keeps the engine's answer, so
+# a dismissal can only remove false rejections, never create
+# false acceptances. Constructs outside the translated dialect
+# subset keep the engine's answer.
+RSpec.describe "Moxml::XSD pattern-facet dismissal (#464)" do
+  describe "bounded dialect translator" do
+    let(:translator) { Moxml::XSD::SchemaRules::XsdRegex }
+
+    it "translates block escapes and categories" do
+      expect(translator.translate('\p{IsBasicLatin}+').source)
+        .to eq("\\A(?:\\p{InBasicLatin}+)\\z")
+      expect(translator.translate('\P{IsLatin-1Supplement}').source)
+        .to eq("\\A(?:\\P{InLatin-1Supplement})\\z")
+      expect(translator.translate('\p{IsGreek}').source)
+        .to eq("\\A(?:\\p{InGreekandCoptic})\\z")
+      expect(translator.translate('\p{L}').source)
+        .to eq("\\A(?:\\p{L})\\z")
+    end
+
+    it "refuses constructs outside the translated subset" do
+      expect(translator.translate('\i\c*')).to be_nil
+      expect(translator.translate('[\p{IsBasicLatin}-[abc]]+'))
+        .to be_nil
+      expect(translator.translate('\p{IsNoSuchBlock}')).to be_nil
+    end
+  end
+
+  %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 "block-escape pattern on an element" do
+        let(:schema) do
+          ctx.xsd(<<~'XSD')
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:element name="doc">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:element name="elem" type="regex"
+                                minOccurs="1" maxOccurs="unbounded"/>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+              <xs:simpleType name="regex">
+                <xs:restriction base="xs:string">
+                  <xs:pattern value="\p{IsBasicLatin}+"/>
+                </xs:restriction>
+              </xs:simpleType>
+            </xs:schema>
+          XSD
+        end
+
+        it "accepts the value the facet accepts" do
+          doc = ctx.parse(
+            "<doc><elem>&#x9;&#xA;&#xD;&#x20;&#x7F;</elem></doc>",
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+
+        it "rejects the value the facet rejects" do
+          doc = ctx.parse(
+            "<doc><elem>abc</elem><elem>ab&#233;c</elem></doc>",
+          )
+          expect(schema.valid?(doc)).to be(false)
+        end
+      end
+
+      describe "negated block escape" do
+        let(:schema) do
+          ctx.xsd(<<~'XSD')
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:element name="doc">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:element name="elem" type="nonbasic"
+                                minOccurs="1"/>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+              <xs:simpleType name="nonbasic">
+                <xs:restriction base="xs:string">
+                  <xs:pattern value="\P{IsBasicLatin}"/>
+                </xs:restriction>
+              </xs:simpleType>
+            </xs:schema>
+          XSD
+        end
+
+        it "accepts a value outside the negated block" do
+          doc = ctx.parse("<doc><elem>&#233;</elem></doc>")
+          expect(schema.valid?(doc)).to be(true)
+        end
+      end
+
+      describe "block-escape pattern on an attribute" do
+        let(:schema) do
+          ctx.xsd(<<~'XSD')
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:element name="doc">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:element name="elem" minOccurs="1"
+                                maxOccurs="unbounded">
+                      <xs:complexType>
+                        <xs:simpleContent>
+                          <xs:extension base="xs:string">
+                            <xs:attribute name="code">
+                              <xs:simpleType>
+                                <xs:restriction base="xs:string">
+                                  <xs:pattern
+                                      value="\p{IsBasicLatin}{2}"/>
+                                </xs:restriction>
+                              </xs:simpleType>
+                            </xs:attribute>
+                          </xs:extension>
+                        </xs:simpleContent>
+                      </xs:complexType>
+                    </xs:element>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+            </xs:schema>
+          XSD
+        end
+
+        it "accepts when every instance matches the facet" do
+          doc = ctx.parse(
+            '<doc><elem code="ab">x</elem><elem code="z9">y</elem></doc>',
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+
+        it "rejects when one instance mismatches" do
+          doc = ctx.parse(
+            '<doc><elem code="ab">x</elem><elem code="1">y</elem></doc>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+        end
+      end
+
+      describe "class subtraction rides the engine unchanged" do
+        let(:schema) do
+          ctx.xsd(<<~'XSD')
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:element name="doc">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:element name="elem" type="latinish"
+                                minOccurs="1"/>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+              <xs:simpleType name="latinish">
+                <xs:restriction base="xs:string">
+                  <xs:pattern value="[\p{IsBasicLatin}-[abc]]+"/>
+                </xs:restriction>
+              </xs:simpleType>
+            </xs:schema>
+          XSD
+        end
+
+        it "keeps the engine's answer" do
+          # The translation refuses subtraction, so the dismissal
+          # never fires: both engines answer per their own
+          # dialect coverage, unmodified by the facade.
+          doc = ctx.parse("<doc><elem>xyz</elem></doc>")
+          expect(schema.valid?(doc)).to be(true)
+        end
+      end
+    end
+  end
+end

data/spec/moxml/xsd_underdetection_spec.rb

@@ -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/support/model_coverage.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.162
+  version: 0.5.165
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -631,6 +631,7 @@ files:
 - spec/moxml/xpath_spec.rb
 - spec/moxml/xsd_error_contract_spec.rb
 - spec/moxml/xsd_handle_mismatch_spec.rb
+- spec/moxml/xsd_regex_spec.rb
 - spec/moxml/xsd_release_spec.rb
 - spec/moxml/xsd_spec.rb
 - spec/moxml/xsd_underdetection_spec.rb