RubyGems - moxml - Versions diffs - 0.5.175 → 0.5.176 - Mend

moxml 0.5.175 → 0.5.176

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 (12) hide show

checksums.yaml +4 -4
data/Rakefile +37 -5
data/conformance/moxml-conformance.json +627 -2
data/lib/moxml/entity_registry.rb +52 -0
data/lib/moxml/version.rb +1 -1
data/lib/moxml/xsd/schema_rules.rb +97 -2
data/lib/moxml.rb +1 -1
data/spec/moxml/entity_registry_conformance_spec.rb +54 -0
data/spec/moxml/signature_autoload_spec.rb +52 -0
data/spec/moxml/wildcard_conformance_spec.rb +48 -0
data/spec/moxml/xsd_regex_conformance_spec.rb +36 -0
metadata +5 -1

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14463613d8081db0efee985379ddcae7740f8044d9f0f7a8192f5f1828337a27
-  data.tar.gz: 7fcb65b5d65fedc5d9766d31f409441eafba5f78b8212478a854bcd17ffdf167
+  metadata.gz: b00ba396700e1ee797651d8db90cc283733f062021e05d8c807c751a07442414
+  data.tar.gz: f0f35b75c740842a6bb4a21c0fde3b944e5994c2935a1de0e57b6671d02eb2fe
 SHA512:
-  metadata.gz: b7c402c813be0883260893a9e47290653e61104cf870702d7d46b155299d87752f8ec5662455ebb0b75c4b776d8962502d7ed223a3b5fca0764fb2600ae67488
-  data.tar.gz: cc0a50d550e12d1496c0f31a623c9e1c3a7569fe1d65b7796b97a1a30d63d994812d02c28cd6cfcfd22352a11d0fc9ed25d4a2488bda768ac0898342dad7837a
+  metadata.gz: 8302fa56d49d9e6965559bf2be0db79afc61b5d6696cbe34aa5f6ff07381af94261b2988f858d76d5625cb7796b84c70999a6e899e7d5b5c61cdd58134dba462
+  data.tar.gz: 349a9bf1e50540698ee21572f29c93db127d206bca9ab622fed3c989ed601af0109181b9b107ac06c27f17432cf98402ab2118d3ba6f8b0976b8ee7542fd74d8

data/Rakefile CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/entity_registry.rb CHANGED Viewed

@@ -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 CHANGED Viewed

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

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

@@ -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
@@ -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

data/lib/moxml.rb CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.175
+  version: 0.5.176
 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