moxml 0.5.175 → 0.5.177

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14463613d8081db0efee985379ddcae7740f8044d9f0f7a8192f5f1828337a27
-  data.tar.gz: 7fcb65b5d65fedc5d9766d31f409441eafba5f78b8212478a854bcd17ffdf167
+  metadata.gz: 021a0d5d25cfe9e12a0a29968649a0801d0379e30b4f6aefe349d86a8959149b
+  data.tar.gz: 197a8e2c303f7fa1e29e7f25b8d64502d6c3d3179ca342af4b02dda168e7fa89
 SHA512:
-  metadata.gz: b7c402c813be0883260893a9e47290653e61104cf870702d7d46b155299d87752f8ec5662455ebb0b75c4b776d8962502d7ed223a3b5fca0764fb2600ae67488
-  data.tar.gz: cc0a50d550e12d1496c0f31a623c9e1c3a7569fe1d65b7796b97a1a30d63d994812d02c28cd6cfcfd22352a11d0fc9ed25d4a2488bda768ac0898342dad7837a
+  metadata.gz: cddcf3bb2b304e5d78779cba12b3f57514b783336642a8e40ca7d8894ba47485ef6ffff114b9f8a1430e6b9669067c86f4de2bbd53aac6d18ed8ffef52828d5f
+  data.tar.gz: 6d88eb872c4a876d9f387af3e006eb8247935ff58f70c6d3249d6b3afba7809e3485c117fbeaa3dc61103ab9858997b98c230efc870e0dac0a914971bb20e49e

data/Rakefile

@@ -355,13 +355,44 @@ namespace :conformance do
   task :export do
     require "json"
     require_relative "lib/moxml"
-    dataset = Moxml::XSD::BuiltinLexical::CONFORMANCE_CASES
+    lexical = Moxml::XSD::BuiltinLexical::CONFORMANCE_CASES
+    regex = Moxml::XSD::SchemaRules::XsdRegex::CONFORMANCE_CASES
+    wildcards = Moxml::XSD::SchemaRules::Wildcard::WILDCARD_CASES
+    entities = Moxml::EntityRegistry::ENTITY_CONFORMANCE_CASES
     payload = {
-      schema: 1,
+      schema: 3,
       generator: "moxml #{Moxml::VERSION}",
       cases: {
-        "builtin_lexical" => dataset.map do |type, lexical, expected|
-          { "type" => type, "lexical" => lexical, "valid" => expected }
+        "builtin_lexical" => lexical.map do |type, lexical_value, expected|
+          { "type" => type, "lexical" => lexical_value, "valid" => expected }
+        end,
+        "xsd_regex_translation" => regex.map do |pattern, value, matches, translatable|
+          {
+            "pattern" => pattern, "value" => value,
+            "matches" => matches, "translatable" => translatable
+          }
+        end,
+        "schema_wildcards" => wildcards.map do |row|
+          constraint, process, not_namespace, not_qname, item_ns, item_qname,
+            defined, sibling_names, covers, exclusion = row
+          {
+            "constraint" => constraint, "process" => process,
+            "not_namespace" => not_namespace, "not_qname" => not_qname,
+            "item_namespace" => item_ns, "item_qname" => item_qname,
+            "defined" => defined, "sibling_names" => sibling_names,
+            "covers" => covers, "exclusion" => exclusion
+          }
+        end,
+        "entity_registry" => entities.map do |row|
+          seed, qname, qcp, restore_entities, mode, declared, codepoint,
+            names, primary, standard, restore = row
+          {
+            "seed" => seed, "qname" => qname, "qcp" => qcp,
+            "restore_entities" => restore_entities, "mode" => mode,
+            "declared" => declared, "codepoint" => codepoint,
+            "names" => names, "primary" => primary,
+            "standard" => standard, "restore" => restore
+          }
         end,
       },
     }
@@ -369,7 +400,8 @@ namespace :conformance do
     FileUtils.mkdir_p(dir)
     target = File.join(dir, "moxml-conformance.json")
     File.write(target, "#{JSON.pretty_generate(payload)}\n")
-    puts "conformance: exported #{dataset.size} cases to #{target}"
+    total = lexical.size + regex.size + wildcards.size + entities.size
+    puts "conformance: exported #{total} cases to #{target}"
   end
 end
 

data/conformance/moxml-conformance.json

@@ -1,6 +1,6 @@
 {
-  "schema": 1,
-  "generator": "moxml 0.5.171",
+  "schema": 3,
+  "generator": "moxml 0.5.175",
   "cases": {
     "builtin_lexical": [
       {
@@ -408,6 +408,631 @@
         "lexical": "a:b",
         "valid": false
       }
+    ],
+    "xsd_regex_translation": [
+      {
+        "pattern": "\\p{IsBasicLatin}+",
+        "value": "abc",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "\\p{IsBasicLatin}+",
+        "value": "€",
+        "matches": false,
+        "translatable": true
+      },
+      {
+        "pattern": "\\P{IsLatin-1Supplement}",
+        "value": "a",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "\\P{IsLatin-1Supplement}",
+        "value": "é",
+        "matches": false,
+        "translatable": true
+      },
+      {
+        "pattern": "\\p{IsGreek}",
+        "value": "α",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "\\p{IsGreek}",
+        "value": "a",
+        "matches": false,
+        "translatable": true
+      },
+      {
+        "pattern": "\\p{L}",
+        "value": "a",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "\\p{L}",
+        "value": "1",
+        "matches": false,
+        "translatable": true
+      },
+      {
+        "pattern": "\\p{Nd}{1,3}",
+        "value": "5",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "\\p{Nd}{1,3}",
+        "value": "abc",
+        "matches": false,
+        "translatable": true
+      },
+      {
+        "pattern": "\\d{1,3}",
+        "value": "5",
+        "matches": false,
+        "translatable": false
+      },
+      {
+        "pattern": "\\d{1,3}",
+        "value": "abc",
+        "matches": false,
+        "translatable": false
+      },
+      {
+        "pattern": "[0-9]{1,3}",
+        "value": "42",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "[a-z]*",
+        "value": "",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "a|b",
+        "value": "b",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "a|b",
+        "value": "c",
+        "matches": false,
+        "translatable": true
+      },
+      {
+        "pattern": "a.c",
+        "value": "abc",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "a\\.c",
+        "value": "a.c",
+        "matches": true,
+        "translatable": true
+      },
+      {
+        "pattern": "\\i\\c*",
+        "value": "x",
+        "matches": false,
+        "translatable": false
+      },
+      {
+        "pattern": "[\\p{IsBasicLatin}-[abc]]+",
+        "value": "a",
+        "matches": false,
+        "translatable": false
+      },
+      {
+        "pattern": "\\p{IsNoSuchBlock}",
+        "value": "a",
+        "matches": false,
+        "translatable": false
+      }
+    ],
+    "schema_wildcards": [
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "tns",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##other",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": false,
+        "exclusion": null
+      },
+      {
+        "constraint": "##other",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "tns",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": false,
+        "exclusion": null
+      },
+      {
+        "constraint": "##other",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "urn:other",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##local",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##local",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "urn:b",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": false,
+        "exclusion": null
+      },
+      {
+        "constraint": "##targetNamespace urn:b",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "tns",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##targetNamespace urn:b",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": false,
+        "exclusion": null
+      },
+      {
+        "constraint": "urn:a urn:b",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "urn:a",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "urn:a urn:b",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "urn:c",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": false,
+        "exclusion": null
+      },
+      {
+        "constraint": "urn:a",
+        "process": "lax",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "urn:a",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "urn:a",
+        "process": "skip",
+        "not_namespace": null,
+        "not_qname": [],
+        "item_namespace": "urn:a",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [
+          "x"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": "not_qname"
+      },
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [
+          "x"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}y",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##any",
+        "process": "lax",
+        "not_namespace": null,
+        "not_qname": [
+          "x"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": true,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": "not_qname"
+      },
+      {
+        "constraint": "##any",
+        "process": "skip",
+        "not_namespace": null,
+        "not_qname": [
+          "x"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": true,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": "not_qname"
+      },
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [
+          "##defined"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [
+          "##defined"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": true,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": "not_qname"
+      },
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [
+          "##definedSibling"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [
+          "{}y"
+        ],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "##any",
+        "process": "strict",
+        "not_namespace": null,
+        "not_qname": [
+          "##definedSibling"
+        ],
+        "item_namespace": "local",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [
+          "{}x"
+        ],
+        "covers": true,
+        "exclusion": "not_qname"
+      },
+      {
+        "constraint": "urn:a",
+        "process": "strict",
+        "not_namespace": "urn:z",
+        "not_qname": [],
+        "item_namespace": "urn:a",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": true,
+        "exclusion": null
+      },
+      {
+        "constraint": "urn:a",
+        "process": "strict",
+        "not_namespace": "urn:z",
+        "not_qname": [],
+        "item_namespace": "urn:z",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": false,
+        "exclusion": "not_namespace"
+      },
+      {
+        "constraint": "urn:a",
+        "process": "lax",
+        "not_namespace": "urn:z",
+        "not_qname": [],
+        "item_namespace": "urn:z",
+        "item_qname": "{}x",
+        "defined": false,
+        "sibling_names": [],
+        "covers": false,
+        "exclusion": "not_namespace"
+      }
+    ],
+    "entity_registry": [
+      {
+        "seed": {
+          "amp": "&"
+        },
+        "qname": "amp",
+        "qcp": 38,
+        "restore_entities": false,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 38,
+        "names": [
+          "amp"
+        ],
+        "primary": "amp",
+        "standard": true,
+        "restore": true
+      },
+      {
+        "seed": {
+          "NonBreakingSpace": " ",
+          "nbsp": " "
+        },
+        "qname": "nbsp",
+        "qcp": 160,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 160,
+        "names": [
+          "NonBreakingSpace",
+          "nbsp"
+        ],
+        "primary": "nbsp",
+        "standard": false,
+        "restore": true
+      },
+      {
+        "seed": {
+          "nbsp": " "
+        },
+        "qname": "nbsp",
+        "qcp": 160,
+        "restore_entities": false,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 160,
+        "names": [
+          "nbsp"
+        ],
+        "primary": "nbsp",
+        "standard": false,
+        "restore": false
+      },
+      {
+        "seed": {
+          "nbsp": " "
+        },
+        "qname": "nbsp",
+        "qcp": 160,
+        "restore_entities": true,
+        "mode": "strict",
+        "declared": true,
+        "codepoint": 160,
+        "names": [
+          "nbsp"
+        ],
+        "primary": "nbsp",
+        "standard": false,
+        "restore": true
+      },
+      {
+        "seed": {
+          "AElig": "Æ"
+        },
+        "qname": "AElig",
+        "qcp": 198,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 198,
+        "names": [
+          "AElig"
+        ],
+        "primary": "AElig",
+        "standard": false,
+        "restore": true
+      },
+      {
+        "seed": {
+          "fjlig": "fj"
+        },
+        "qname": "fjlig",
+        "qcp": 102,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 102,
+        "names": [
+          "fjlig"
+        ],
+        "primary": "fjlig",
+        "standard": false,
+        "restore": true
+      },
+      {
+        "seed": {
+          "DotDot": " ⃜"
+        },
+        "qname": "DotDot",
+        "qcp": 32,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 32,
+        "names": [
+          "DotDot"
+        ],
+        "primary": "DotDot",
+        "standard": false,
+        "restore": true
+      },
+      {
+        "seed": {
+          "NotEqualTilde": "≂̸"
+        },
+        "qname": "NotEqualTilde",
+        "qcp": 8770,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 8770,
+        "names": [
+          "NotEqualTilde"
+        ],
+        "primary": "NotEqualTilde",
+        "standard": false,
+        "restore": true
+      },
+      {
+        "seed": {
+          "esc": "\\u00A0"
+        },
+        "qname": "esc",
+        "qcp": 160,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": true,
+        "codepoint": 160,
+        "names": [
+          "esc"
+        ],
+        "primary": "esc",
+        "standard": false,
+        "restore": true
+      },
+      {
+        "seed": {
+          "bad": ""
+        },
+        "qname": "bad",
+        "qcp": 0,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": false,
+        "codepoint": null,
+        "names": [],
+        "primary": null,
+        "standard": false,
+        "restore": false
+      },
+      {
+        "seed": {
+          "nbsp": " "
+        },
+        "qname": "nope",
+        "qcp": 9999,
+        "restore_entities": true,
+        "mode": "lenient",
+        "declared": false,
+        "codepoint": null,
+        "names": [],
+        "primary": null,
+        "standard": false,
+        "restore": false
+      }
     ]
   }
 }

data/lib/moxml/context.rb

@@ -214,9 +214,10 @@ module Moxml
     # 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).
+    # The #452 rule index reads this document only; a document
+    # that composes others (include/import/redefine/override)
+    # turns the strict re-checks off (#510) — included parts stay
+    # engine-validated and the index can only under-report.
     def xsd_file(path)
       handle = config.adapter.xsd_compile_file(path.to_s)
       source = File.read(path.to_s)
@@ -229,7 +230,10 @@ module Moxml
     # types) are visible to the head's content models — the
     # single-document faces cannot see them (#483 item 4). The
     # Schema's #version / SchemaRules index read the HEAD document
-    # (the first path); engine-set semantics cover the rest.
+    # (the first path); engine-set semantics cover the rest. A set
+    # is composition-shaped by contract, so the strict re-checks
+    # stay off (#510): the index under-reports instead of
+    # false-reporting components that live in a member.
     # Adapters without a set-capable engine raise
     # Moxml::NotImplementedError.
     def xsd_set(*paths)
@@ -238,7 +242,7 @@ module Moxml
 
       handle = config.adapter.xsd_compile_set(paths.map(&:to_s))
       source = File.read(paths.first.to_s)
-      Moxml::XSD::Schema.new(handle, self, source)
+      Moxml::XSD::Schema.new(handle, self, source, self_contained: false)
     end
 
     # Compile a RELAX NG schema from source or from a file path (the

data/lib/moxml/entity_registry.rb

@@ -30,6 +30,58 @@ module Moxml
     # Standard XML predefined entities (XML spec §4.6)
     STANDARD_CODEPOINTS = Set[0x26, 0x3C, 0x3E, 0x22, 0x27].freeze
 
+    # The entity-registry conformance dataset (#496): lookup and
+    # restoration answers as data, pinned BY the Ruby suite
+    # (spec/moxml/entity_registry_conformance_spec.rb) and exported
+    # for the Rust/TS runners. Row shape: [seed, qname, qcp,
+    # restore_entities, restoration_mode, declared, codepoint, names,
+    # primary, standard, restore]. Each row seeds a fresh :custom
+    # registry through the public provider path — so the seed values
+    # are LEXICAL forms (raw characters, multi-character sequences,
+    # "\\uXXXX" escapes), exercising parse_codepoint exactly as a
+    # custom provider does — then queries one name and one codepoint
+    # and pins every face answer:
+    #
+    #   * declared?/codepoint_for_name on qname
+    #   * names_for_codepoint/primary_name_for_codepoint on qcp
+    #   * standard_entity?/should_restore? on qcp under the row's config
+    #
+    # The committed semantics the rows pin: a multi-character lexical
+    # (an entity naming a sequence, e.g. "fjlig" -> "fj") maps to its
+    # FIRST character's codepoint; an empty lexical is dropped; the
+    # reverse map keeps insertion order with the lowercase name
+    # preferred as primary (falling back to the first name); the five
+    # predefined entities restore regardless of config; every other
+    # known codepoint restores only with restore_entities on (the
+    # strict mode answers as lenient until DTD parsing exists); an
+    # unknown codepoint never restores.
+    ENTITY_CONFORMANCE_CASES = [
+      [{ "amp" => "&" }, "amp", 38, false, "lenient",
+       true, 38, ["amp"], "amp", true, true],
+      [{ "NonBreakingSpace" => "\u00A0", "nbsp" => "\u00A0" },
+       "nbsp", 160, true, "lenient",
+       true, 160, ["NonBreakingSpace", "nbsp"], "nbsp", false, true],
+      [{ "nbsp" => "\u00A0" }, "nbsp", 160, false, "lenient",
+       true, 160, ["nbsp"], "nbsp", false, false],
+      [{ "nbsp" => "\u00A0" }, "nbsp", 160, true, "strict",
+       true, 160, ["nbsp"], "nbsp", false, true],
+      [{ "AElig" => "Æ" }, "AElig", 198, true, "lenient",
+       true, 198, ["AElig"], "AElig", false, true],
+      [{ "fjlig" => "fj" }, "fjlig", 102, true, "lenient",
+       true, 102, ["fjlig"], "fjlig", false, true],
+      [{ "DotDot" => "\u0020\u20DC" }, "DotDot", 32, true, "lenient",
+       true, 32, ["DotDot"], "DotDot", false, true],
+      [{ "NotEqualTilde" => "≂̸" }, "NotEqualTilde", 8770, true,
+       "lenient",
+       true, 8770, ["NotEqualTilde"], "NotEqualTilde", false, true],
+      [{ "esc" => "\\u00A0" }, "esc", 160, true, "lenient",
+       true, 160, ["esc"], "esc", false, true],
+      [{ "bad" => "" }, "bad", 0, true, "lenient",
+       false, nil, [], nil, false, false],
+      [{ "nbsp" => "\u00A0" }, "nope", 9999, true, "lenient",
+       false, nil, [], nil, false, false],
+    ].map(&:freeze).freeze
+
     class << self
       # Get the raw entity data from the bundled JSON source
       # @return [Hash{String => String}] entity name to character mapping

data/lib/moxml/version.rb

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

data/lib/moxml/xsd/schema_rules.rb

@@ -78,17 +78,83 @@ module Moxml
           nil
         end
 
+        # The wildcard-face conformance dataset (#496): admission and
+        # negative-exclusion answers as data, pinned BY the Ruby suite
+        # (spec/moxml/wildcard_conformance_spec.rb) and exported for
+        # the Rust/TS runners. Row shape: [constraint, process,
+        # not_namespace, not_qname tokens, item_namespace, item_qname,
+        # defined, sibling_names, covers, exclusion]. Disallowed
+        # entries keep the pre-resolution token forms the constructor
+        # receives; item qnames are in the Clark form the face
+        # receives; item namespaces use the face's spellings
+        # ("local", "tns", or the URI).
+        WILDCARD_CASES = [
+          ["##any", "strict", nil, [], "local", "{}x", false, [], true, nil],
+          ["##any", "strict", nil, [], "tns", "{}x", false, [], true, nil],
+          ["##other", "strict", nil, [], "local", "{}x", false, [], false, nil],
+          ["##other", "strict", nil, [], "tns", "{}x", false, [], false, nil],
+          ["##other", "strict", nil, [], "urn:other", "{}x", false, [], true, nil],
+          ["##local", "strict", nil, [], "local", "{}x", false, [], true, nil],
+          ["##local", "strict", nil, [], "urn:b", "{}x", false, [], false, nil],
+          ["##targetNamespace urn:b", "strict", nil, [], "tns", "{}x", false, [],
+           true, nil],
+          ["##targetNamespace urn:b", "strict", nil, [], "local", "{}x", false,
+           [], false, nil],
+          ["urn:a urn:b", "strict", nil, [], "urn:a", "{}x", false, [], true,
+           nil],
+          ["urn:a urn:b", "strict", nil, [], "urn:c", "{}x", false, [], false,
+           nil],
+          ["urn:a", "lax", nil, [], "urn:a", "{}x", false, [], true, nil],
+          ["urn:a", "skip", nil, [], "urn:a", "{}x", false, [], true, nil],
+          ["##any", "strict", nil, ["x"], "local", "{}x", false, [], true,
+           "not_qname"],
+          ["##any", "strict", nil, ["x"], "local", "{}y", false, [], true, nil],
+          ["##any", "lax", nil, ["x"], "local", "{}x", true, [], true,
+           "not_qname"],
+          ["##any", "skip", nil, ["x"], "local", "{}x", true, [], true,
+           "not_qname"],
+          ["##any", "strict", nil, ["##defined"], "local", "{}x", false, [],
+           true, nil],
+          ["##any", "strict", nil, ["##defined"], "local", "{}x", true, [],
+           true, "not_qname"],
+          ["##any", "strict", nil, ["##definedSibling"], "local", "{}x", false,
+           ["{}y"], true, nil],
+          ["##any", "strict", nil, ["##definedSibling"], "local", "{}x", false,
+           ["{}x"], true, "not_qname"],
+          ["urn:a", "strict", "urn:z", [], "urn:a", "{}x", false, [], true,
+           nil],
+          ["urn:a", "strict", "urn:z", [], "urn:z", "{}x", false, [], false,
+           "not_namespace"],
+          ["urn:a", "lax", "urn:z", [], "urn:z", "{}x", false, [], false,
+           "not_namespace"],
+        ].map(&:freeze).freeze
+
         private
 
         def namespace_constraint(value, not_namespace)
           if not_namespace
-            [:not, not_namespace.split(/\s+/).reject(&:empty?)]
+            [:not, namespace_entries(not_namespace)]
           elsif value.nil? || value == "##any" || value == ""
             [:any, []]
           elsif value == "##other"
             [:other, []]
           else
-            [:list, value.split(/\s+/).reject(&:empty?)]
+            [:list, namespace_entries(value)]
+          end
+        end
+
+        # Namespace entries carry one internal convention: the
+        # special tokens keep their string spellings (entry_covers?
+        # maps them to :tns/:local); real URIs become Symbols, the
+        # same shape covers? receives. A String entry would never
+        # equal a Symbol namespace — the comparison would silently
+        # under-report on every :list and :not wildcard.
+        def namespace_entries(value)
+          value.to_s.split(/\s+/).reject(&:empty?).map do |entry|
+            case entry
+            when "##targetNamespace", "##local" then entry
+            else entry.to_sym
+            end
           end
         end
 
@@ -131,7 +197,7 @@ module Moxml
                                :attribute_default, :elements,
                                :attributes, :contents, :version,
                                :element_patterns, :attribute_patterns,
-                               :substitution_members)
+                               :substitution_members, :self_contained)
 
       # Resolves a QName token against an element's in-scope
       # bindings. node.namespaces is adapter-divergent (some
@@ -189,6 +255,35 @@ module Moxml
           nil
         end
 
+        # The cross-language conformance dataset (#496): the
+        # translator's answers as data, pinned BY the Ruby suite
+        # (spec/moxml/xsd_regex_conformance_spec.rb) and exported to
+        # conformance/moxml-conformance.json for the Rust/TS runners.
+        # Each row: [pattern, value, matches, translatable].
+        CONFORMANCE_CASES = [
+          ["\\p{IsBasicLatin}+", "abc", true, true],
+          ["\\p{IsBasicLatin}+", "€", false, true],
+          ["\\P{IsLatin-1Supplement}", "a", true, true],
+          ["\\P{IsLatin-1Supplement}", "é", false, true],
+          ["\\p{IsGreek}", "α", true, true],
+          ["\\p{IsGreek}", "a", false, true],
+          ["\\p{L}", "a", true, true],
+          ["\\p{L}", "1", false, true],
+          ["\\p{Nd}{1,3}", "5", true, true],
+          ["\\p{Nd}{1,3}", "abc", false, true],
+          ["\\d{1,3}", "5", false, false],
+          ["\\d{1,3}", "abc", false, false],
+          ["[0-9]{1,3}", "42", true, true],
+          ["[a-z]*", "", true, true],
+          ["a|b", "b", true, true],
+          ["a|b", "c", false, true],
+          ["a.c", "abc", true, true],
+          ["a\\.c", "a.c", true, true],
+          ["\\i\\c*", "x", false, false],
+          ["[\\p{IsBasicLatin}-[abc]]+", "a", false, false],
+          ["\\p{IsNoSuchBlock}", "a", false, false],
+        ].map(&:freeze).freeze
+
         def scan(pattern)
           out = +""
           index = 0
@@ -243,7 +338,7 @@ module Moxml
         # 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)
+        def index(schema_source, context, self_contained: nil)
           root = context.parse(schema_source).root
           return nil unless root&.name == "schema"
 
@@ -251,7 +346,8 @@ module Moxml
             root["targetNamespace"].to_s,
             root["elementFormDefault"] == "qualified",
             root["attributeFormDefault"] == "qualified",
-            {}, {}, {}, schema_version(root), {}, {}, {}
+            {}, {}, {}, schema_version(root), {}, {}, {},
+            self_contained.nil? ? composition_free?(root) : self_contained
           )
           child_elements(root).each do |decl|
             case decl.name
@@ -265,6 +361,24 @@ module Moxml
           nil
         end
 
+        COMPOSITION_ELEMENTS = %w[include import redefine override].freeze
+
+        # A schema document that composes other documents
+        # (include/import/redefine/override) declares only part of
+        # the compiled declaration surface in its own source — the
+        # engine resolves the members, and a strict re-check run
+        # against this index alone would answer "not declared" for
+        # components that live in a member (#510): a false report,
+        # which the one-directional contract forbids. Composition
+        # therefore turns the strict re-checks off — the index
+        # under-reports instead. Schema sets (xsd_set) are always
+        # composition-shaped: any member may carry declarations.
+        def composition_free?(root)
+          child_elements(root).none? do |decl|
+            COMPOSITION_ELEMENTS.include?(decl.name)
+          end
+        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
@@ -511,12 +625,18 @@ module Moxml
           model = index.contents[root_qname]
           findings = []
           findings << nil_finding(root, declaration) if declaration
-          findings.concat(attribute_findings(root, model, index))
-          if model
+          # The strict wildcard/attribute re-checks answer "not
+          # declared" against this index's declaration sets — they
+          # vouch only when the index saw the whole declaration
+          # surface (no composition, #510).
+          if model && index.self_contained
             child_elements(root).each do |child|
               findings.concat(child_findings(child, model, index))
             end
           end
+          if index.self_contained
+            findings.concat(attribute_findings(root, model, index))
+          end
           findings.compact
         end
 

data/lib/moxml/xsd.rb

@@ -96,11 +96,15 @@ module Moxml
               "schema released (deterministic drop); compile a new one"
       end
 
-      def initialize(handle, context, schema_source = nil)
+      def initialize(handle, context, schema_source = nil,
+                     self_contained: nil)
         @handle = handle
         @context = context
         @rules_index =
-          schema_source && SchemaRules.index(schema_source, context)
+          if schema_source
+            SchemaRules.index(schema_source, context,
+                              self_contained: self_contained)
+          end
         assert_adapter_matches_handle!
       end
 

data/lib/moxml.rb

@@ -101,7 +101,7 @@ module Moxml
   autoload :Adapter, "moxml/adapter"
   autoload :XPath, "moxml/xpath"
   autoload :SAX, "moxml/sax"
-  autoload :Signature, "moxml/signature"
+  autoload :Signature, "moxml/signature" unless RUBY_ENGINE == "opal"
   autoload :C14n, "moxml/c14n"
   autoload :Reference, "moxml/reference"
   autoload :XSLT, "moxml/xslt"

data/spec/moxml/entity_registry_conformance_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Processing model §Entities (normative): pinned here.
+
+require "spec_helper"
+
+# The entity-registry conformance dataset (#496): lookup and
+# restoration answers AS DATA, pinned by the Ruby suite and exported
+# for the Rust/TS runners. A row failing here breaks the
+# cross-language contract. Rows seed a fresh :custom registry through
+# the public provider path — seed values are lexical forms — then pin
+# every face answer for one name and one codepoint query.
+RSpec.describe "entity-registry conformance dataset" do
+  it "carries the dataset" do
+    expect(Moxml::EntityRegistry::ENTITY_CONFORMANCE_CASES.size).to be >= 10
+  end
+
+  it "answers every row exactly as the dataset expects" do
+    Moxml::EntityRegistry::ENTITY_CONFORMANCE_CASES.each do |row|
+      seed, qname, qcp, restore_entities, restoration_mode, declared,
+        codepoint, names, primary, standard, restore = row
+      registry = Moxml::EntityRegistry.new(
+        mode: :custom,
+        entity_provider: -> { seed },
+      )
+
+      label = "seed #{seed.inspect}, qname #{qname.inspect}, qcp #{qcp}"
+
+      expect(registry.declared?(qname)).to eql(declared),
+                                           "declared?(#{qname.inspect}) [#{label}]"
+      expect(registry.codepoint_for_name(qname)).to eql(codepoint),
+                                                    "codepoint_for_name(" \
+                                                    "#{qname.inspect}) " \
+                                                    "[#{label}]"
+      expect(registry.names_for_codepoint(qcp)).to eql(names),
+                                                   "names_for_codepoint(" \
+                                                   "#{qcp}) [#{label}]"
+      expect(registry.primary_name_for_codepoint(qcp)).to eql(primary),
+                                                          "primary_name_" \
+                                                          "for_codepoint(" \
+                                                          "#{qcp}) [#{label}]"
+      expect(registry.standard_entity?(qcp)).to eql(standard),
+                                                "standard_entity?(#{qcp}) " \
+                                                "[#{label}]"
+      config = Moxml::Config.new
+      config.restore_entities = restore_entities
+      config.entity_restoration_mode = restoration_mode.to_sym
+      expect(registry.should_restore?(qcp, config: config)).to eql(restore),
+                                                               "should_restore?(" \
+                                                               "#{qcp}) " \
+                                                               "[#{label}]"
+    end
+  end
+end

data/spec/moxml/signature_autoload_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "open3"
+require "rbconfig"
+require "tempfile"
+require "opal"
+
+RSpec.describe "Signature autoload boundary", :native_fs do
+  let(:lib) { File.expand_path("../../lib", __dir__) }
+
+  it "keeps the native signature module lazy and usable on Ruby" do
+    source = <<~RUBY_CODE
+      require "moxml"
+      abort "signature was loaded eagerly" if $LOADED_FEATURES.any? { |path| path.end_with?("moxml/signature.rb") }
+      abort "signature autoload missing" unless Moxml.autoload?(:Signature) == "moxml/signature"
+      abort "signature module unavailable" unless Moxml::Signature::DSIG_NS == "http://www.w3.org/2000/09/xmldsig#"
+      abort "OpenSSL unavailable" unless defined?(OpenSSL::PKey::RSA)
+      puts "native signature available"
+    RUBY_CODE
+    output, error, status = Open3.capture3(RbConfig.ruby, "-I", lib, "-e", source)
+    expect(status.success?).to be(true), error
+    expect(output).to include("native signature available")
+  end
+
+  it "does not compile the native OpenSSL dependency into Opal" do
+    # Compile the actual entrypoint declaration. This isolates the optional
+    # signature boundary from the other modules loaded by the Opal boot file.
+    declaration = File.readlines(File.join(lib, "moxml.rb"))
+      .find { |line| line.include?('autoload :Signature, "moxml/signature"') }
+    expect(declaration).not_to be_nil
+
+    builder = Opal::Builder.new
+    builder.append_paths(lib)
+    builder.build("opal")
+    builder.build_str(<<~RUBY_CODE, "signature-autoload-boundary")
+      module Moxml
+        #{declaration}
+      end
+      raise "native Signature loaded under Opal" if Moxml.const_defined?(:Signature, false)
+      puts "Opal signature boundary passed"
+    RUBY_CODE
+
+    Tempfile.create(["moxml-signature-boundary", ".js"]) do |file|
+      file.write(builder.to_s)
+      file.flush
+      output, error, status = Open3.capture3("node", file.path)
+      expect(status.success?).to be(true), error
+      expect(output).to include("Opal signature boundary passed")
+    end
+  end
+end

data/spec/moxml/wildcard_conformance_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Processing model §Validation (normative): pinned here.
+
+require "spec_helper"
+
+# The wildcard-face conformance dataset (#496): admission (covers?)
+# and negative-exclusion answers AS DATA, pinned by the Ruby suite
+# and exported for the Rust/TS runners. A row failing here breaks the
+# cross-language contract. Rows drive the real Wildcard through its
+# public constructor — disallowed entries in their pre-resolution
+# token form, item qnames in the Clark form the face receives.
+RSpec.describe "wildcard-face conformance dataset" do
+  it "carries the dataset" do
+    expect(Moxml::XSD::SchemaRules::Wildcard::WILDCARD_CASES.size).to be >= 20
+  end
+
+  it "answers every row exactly as the dataset expects" do
+    Moxml::XSD::SchemaRules::Wildcard::WILDCARD_CASES.each do |row|
+      constraint, process, not_namespace, not_qname, item_ns, item_qname,
+        defined, sibling_names, covers, exclusion = row
+      wildcard = Moxml::XSD::SchemaRules::Wildcard.new(
+        constraint, process,
+        not_namespace: not_namespace, not_qname: not_qname.join(" "),
+        element: nil
+      )
+
+      covers_answer = wildcard.covers?(item_ns.to_sym)
+      expect(covers_answer).to eql(covers),
+                               "covers?(#{item_ns.inspect}) under " \
+                               "#{constraint.inspect}: got " \
+                               "#{covers_answer.inspect}, dataset expects " \
+                               "#{covers.inspect}"
+
+      exclusion_answer = wildcard.negative_exclusion(
+        item_qname, item_ns.to_sym,
+        defined: defined, sibling_names: sibling_names
+      )
+      expected_exclusion = exclusion&.to_sym
+      expect(exclusion_answer).to eql(expected_exclusion),
+                                  "negative_exclusion(#{item_qname.inspect}, " \
+                                  "#{item_ns.inspect}) under " \
+                                  "#{constraint.inspect}: got " \
+                                  "#{exclusion_answer.inspect}, dataset expects " \
+                                  "#{expected_exclusion.inspect}"
+    end
+  end
+end

data/spec/moxml/xsd_regex_conformance_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Processing model §Validation (normative): pinned here.
+
+require "spec_helper"
+
+# The regex-translator conformance dataset (#496): the translator's
+# answers AS DATA — translatable-or-not, and what the translated
+# regex does to sample values — pinned by the Ruby suite and exported
+# for the Rust/TS runners. A row failing here breaks the
+# cross-language contract.
+RSpec.describe "XSD-regex translator conformance dataset" do
+  let(:translator) { Moxml::XSD::SchemaRules::XsdRegex }
+
+  it "carries the dataset" do
+    expect(translator::CONFORMANCE_CASES.size).to be >= 20
+  end
+
+  it "answers every row exactly as the dataset expects" do
+    translator::CONFORMANCE_CASES.each do |pattern, value, matches, translatable|
+      regex = translator.translate(pattern)
+      if translatable
+        expect(regex).not_to be_nil,
+                             "#{pattern.inspect}: dataset says translatable, got nil"
+        answer = regex.match?(value)
+        expect(answer).to eql(matches),
+                          "#{pattern.inspect} on #{value.inspect}: got " \
+                          "#{answer.inspect}, dataset expects #{matches.inspect}"
+      else
+        expect(regex).to be_nil,
+                         "#{pattern.inspect}: dataset says NOT translatable, " \
+                         "got #{regex.inspect}"
+      end
+    end
+  end
+end

data/spec/moxml/xsd_set_spec.rb

@@ -82,6 +82,84 @@ RSpec.describe "Schema-set compilation" do
     end
   end
 
+  # #510: the strict re-check answers "not declared" against the
+  # head document's own declaration index; composition (a set, or a
+  # single document carrying include/import/redefine/override)
+  # means declarations may live in a member the index never saw —
+  # the re-check must stay silent (under-report, never
+  # false-report) and let the engine's set-wide answer stand.
+  describe "strict re-check across composed schemas (#510)" do
+    def write_wildcard_set(dir)
+      File.write(File.join(dir, "headw.xsd"), <<~XSD)
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   xmlns="urn:W" targetNamespace="urn:W">
+          <xs:import namespace="urn:D" schemaLocation="decl.xsd"/>
+          <xs:element name="foo">
+            <xs:complexType>
+              <xs:sequence>
+                <xs:any namespace="##other" processContents="strict"/>
+              </xs:sequence>
+            </xs:complexType>
+          </xs:element>
+        </xs:schema>
+      XSD
+      File.write(File.join(dir, "decl.xsd"), <<~XSD)
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   xmlns="urn:D" targetNamespace="urn:D">
+          <xs:element name="bar" type="xs:string"/>
+        </xs:schema>
+      XSD
+      [File.join(dir, "headw.xsd"), File.join(dir, "decl.xsd")]
+    end
+
+    def wildcard_instance
+      '<foo xmlns="urn:W" xmlns:d="urn:D"><d:bar>hi</d:bar></foo>'
+    end
+
+    it "does not false-report a member-declared admission on a set" do
+      skip "requires the leptris compile_set face (binding 1.9.386.0+)" unless
+        set_capable?
+
+      Dir.mktmpdir do |dir|
+        paths = write_wildcard_set(dir)
+        schema = ctx.xsd_set(*paths)
+        expect(schema.validate(wildcard_instance)).to be_empty
+      end
+    end
+
+    it "does not false-report on a single composing document" do
+      Dir.mktmpdir do |dir|
+        write_wildcard_set(dir)
+        schema = ctx.xsd_file(File.join(dir, "headw.xsd"))
+        expect(schema.validate(wildcard_instance)).to be_empty
+      end
+    end
+
+    it "keeps the re-check on a self-contained schema" do
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "solo.xsd")
+        File.write(path, <<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                     xmlns="urn:S" targetNamespace="urn:S">
+            <xs:element name="solo">
+              <xs:complexType>
+                <xs:sequence>
+                  <xs:any namespace="##other" processContents="strict"/>
+                </xs:sequence>
+              </xs:complexType>
+            </xs:element>
+          </xs:schema>
+        XSD
+        schema = ctx.xsd_file(path)
+        errors = schema.validate(
+          '<solo xmlns="urn:S"><u:x xmlns:u="urn:U"/></solo>',
+        )
+        expect(errors.first.message)
+          .to include("matches a strict wildcard but is not declared")
+      end
+    end
+  end
+
   it "raises on an empty set" do
     expect { ctx.xsd_set }.to raise_error(ArgumentError)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.175
+  version: 0.5.177
 platform: ruby
 authors:
 - Ribose Inc.
@@ -557,6 +557,7 @@ files:
 - spec/moxml/element_spec.rb
 - spec/moxml/entity_preservation_spec.rb
 - spec/moxml/entity_reference_spec.rb
+- spec/moxml/entity_registry_conformance_spec.rb
 - spec/moxml/entity_registry_spec.rb
 - spec/moxml/entity_spec.rb
 - spec/moxml/error_spec.rb
@@ -606,11 +607,13 @@ files:
 - spec/moxml/signature/key_extractor_spec.rb
 - spec/moxml/signature/model_spec.rb
 - spec/moxml/signature/round_trip_spec.rb
+- spec/moxml/signature_autoload_spec.rb
 - spec/moxml/struct_plan_spec.rb
 - spec/moxml/struct_plan_typed_spec.rb
 - spec/moxml/text_spec.rb
 - spec/moxml/to_html_spec.rb
 - spec/moxml/version_spec.rb
+- spec/moxml/wildcard_conformance_spec.rb
 - spec/moxml/xhtml_output_spec.rb
 - spec/moxml/xml_emitter_spec.rb
 - spec/moxml/xml_utils/.gitkeep
@@ -643,6 +646,7 @@ files:
 - spec/moxml/xsd_engine_meta_spec.rb
 - spec/moxml/xsd_error_contract_spec.rb
 - spec/moxml/xsd_handle_mismatch_spec.rb
+- spec/moxml/xsd_regex_conformance_spec.rb
 - spec/moxml/xsd_regex_spec.rb
 - spec/moxml/xsd_release_spec.rb
 - spec/moxml/xsd_set_spec.rb