moxml 0.5.147 → 0.5.149

data/spec/support/input_generator.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Seeded XML input generator (TODO.sota/02): composes the 01
+# taxonomy's vocabulary into fresh inputs, deterministically from a
+# seed. CI legs run a fixed seed — identical cases every run; the
+# nightly fuzz leg passes a random one (MOXML_FUZZ_SEED). Every case
+# id carries its provenance ("gen <seed>/<i> <malform>"), so a
+# failure reproduces at that seed and index.
+module InputGenerator
+  # Generated inputs record the divergence-relevant features they use
+  # so the differential exempts exactly those cells, never silently —
+  # every value is a register ID (docs/_pages/divergences.adoc).
+  FEATURE_EXEMPT = {
+    inter_element_ws: {
+      nodes: { ox: "D-13", headed_ox: "D-13" },
+      text: { ox: "D-13", headed_ox: "D-13" },
+    },
+    pi_in_content: { text: { oga: "D-14" } },
+    pre_root_ws: { nodes: { rexml: "D-15" }, text: { rexml: "D-15" } },
+    adjacent_cdata: {
+      nodes: { oga: "D-19", rexml: "D-19", ox: "D-19", headed_ox: "D-19",
+               leptris: "D-19" },
+    },
+  }.freeze
+
+  # malform is one of the three guaranteed-breaking structural
+  # mutations; oga's strict lane is lexer-strict (D-17) and is
+  # exempted for all of them in the strict-raise property.
+  Case = Struct.new(:id, :xml, :well_formed, :features, :voids, :malform)
+
+  ELEMENTS = %w[a b sec p].freeze
+  VOIDS = %w[br img hr].freeze
+  ATTR_VALUES = [
+    "1", "x y", "a &amp; b", "&lt;tag&gt;", "&#65;&#x42;", "taillé"
+  ].freeze
+  TEXTS = [
+    "plain text", "  spaced  ", "a &amp; b &lt; c", "&#65;&#x42;",
+    "café &#160; NBSP", "word"
+  ].freeze
+  NAMESPACES = [
+    'xmlns="urn:t"', 'xmlns:ns="urn:n"', 'xmlns="urn:r"'
+  ].freeze
+  XML_ATTRS = ['xml:space="preserve"', 'xml:lang="en"'].freeze
+  MALFORMS = %i[unclosed stray attr_quote].freeze
+
+  module_function
+
+  # mode: :fuzz mixes the three structural malformations into roughly
+  # a third of the cases (the strict-raise property consumes those);
+  # :well_formed answers pure compositions.
+  def cases(seed:, count:, mode: :fuzz)
+    rng = Random.new(seed)
+    Array.new(count) do |i|
+      body, features, voids = compose(rng)
+      id = "gen #{seed}/#{i}"
+      if mode == :fuzz && rng.rand(3).zero?
+        malform = MALFORMS[rng.rand(MALFORMS.length)]
+        Case.new("#{id} #{malform}", mutate(body, malform), false,
+                 features, voids, malform)
+      else
+        Case.new(id, body, true, features, voids, nil)
+      end
+    end
+  end
+
+  def compose(rng)
+    features = []
+    voids = []
+    pre = +""
+    draw = rng.rand(6)
+    if draw.zero?
+      pre << "<!--pre-root-->"
+    elsif draw == 1
+      pre << "<?prep root?>"
+    elsif draw == 2
+      pre << "  "
+      features << :pre_root_ws
+    end
+
+    attrs = +'<r id="root"'
+    attrs << " #{NAMESPACES[rng.rand(NAMESPACES.length)]}" if rng.rand(2).zero?
+    attrs << " #{XML_ATTRS[rng.rand(XML_ATTRS.length)]}" if rng.rand(3).zero?
+    attrs << ' ns:x="v"' if rng.rand(3).zero?
+    attrs << ">"
+
+    body = +""
+    depth = 1 + rng.rand(4)
+    (1 + rng.rand(4)).times { body << child(rng, 0, depth, features, voids) }
+    # a whitespace-only run between two constructs is a dropped-text
+    # divergence cell (D-13 on ox/headed_ox)
+    features << :inter_element_ws if body.match?(%r{>\s+<})
+
+    xml = "#{pre}#{attrs}#{body}</r>"
+    # a default-namespace declaration scopes XPath name tests away
+    # from generated a/b elements (XPath 1.0, processing model
+    # "Names and namespaces")
+    features << :default_ns if xml.include?('xmlns="')
+    # adjacent text-like leaves — CDATA next to CDATA/text — coalesce
+    # on the libxml2 lane (D-19)
+    if xml.match?(/]\]>\s*<!\[CDATA\[/) || xml.match?(/]\]>\s*[^<\s]/) ||
+        xml.match?(/[^<\s]\s*<!\[CDATA\[/)
+      features << :adjacent_cdata
+    end
+    [xml, features.uniq, voids.uniq]
+  end
+
+  def child(rng, level, max_depth, features, voids)
+    if level < max_depth && rng.rand(8) < 5
+      inner = +""
+      (1 + rng.rand(3)).times do
+        inner << child(rng, level + 1, max_depth, features, voids)
+      end
+      name = ELEMENTS[rng.rand(ELEMENTS.length)]
+      extra = +""
+      extra << " #{NAMESPACES[rng.rand(NAMESPACES.length)]}" if rng.rand(4).zero?
+      extra << " #{XML_ATTRS[rng.rand(XML_ATTRS.length)]}" if rng.rand(4).zero?
+      extra << " ns:x=\"#{ATTR_VALUES[rng.rand(ATTR_VALUES.length)]}\"" if rng.rand(3).zero?
+      "<#{name}#{extra}>#{inner}</#{name}>"
+    else
+      leaf(rng, features, voids)
+    end
+  end
+
+  def leaf(rng, features, voids)
+    case rng.rand(6)
+    when 0, 1
+      TEXTS[rng.rand(TEXTS.length)]
+    when 2
+      "<!--comment #{rng.rand(9)}-->"
+    when 3
+      features << :pi_in_content
+      "<?inst data-#{rng.rand(9)}?>"
+    when 4
+      "<![CDATA[x < #{rng.rand(9)} & more]]>"
+    else
+      v = VOIDS[rng.rand(VOIDS.length)]
+      voids << v
+      "<#{v}/>"
+    end
+  end
+
+  # Each mutation is guaranteed to break well-formedness (the root
+  # close and the root id attribute always exist in composed bodies).
+  def mutate(xml, malform)
+    case malform
+    when :unclosed
+      xml.sub(%r{</[a-z]+>}, "")
+    when :stray
+      "#{xml}</r>"
+    when :attr_quote
+      xml.sub('id="root"', 'id="root')
+    end
+  end
+end

data/spec/support/input_taxonomy.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+# The canonical input-class taxonomy (TODO.sota/01-totality): every
+# class of input the processing model touches, as shared fixture data
+# the differential suites consume. Adding a class here automatically
+# extends the whole-class differential; a class without a stable
+# cross-adapter answer must cite a registered divergence (D-ID) or a
+# named raise in the consuming suite.
+module InputTaxonomy
+  Input = Struct.new(:id, :klass, :xml, :well_formed, :note) do
+    def well_formed? = well_formed
+  end
+
+  WELL_FORMED = "well-formed"
+  MALFORMED = "malformed"
+
+  def self.all
+    @all ||= inputs.freeze
+  end
+
+  def self.well_formed
+    all.select(&:well_formed?)
+  end
+
+  def self.malformed
+    all.reject(&:well_formed?)
+  end
+
+  def self.by_klass(klass)
+    all.select { |i| i.klass == klass }
+  end
+
+  CLASSES = [
+    "empty/minimal",
+    "deep nesting",
+    "huge text/attributes",
+    "entities",
+    "namespaces",
+    "mixed content",
+    "pi/comment/cdata edges",
+    "malformed",
+  ].freeze
+
+  # Registered per-input exemptions for the cross-adapter
+  # differential: input id => { face => { adapter => D-NN } }. The
+  # values are register IDs (docs/_pages/divergences.adoc) enforced
+  # by the coverage audit.
+  EXEMPT = {
+    "mixed content: whitespace runs" => {
+      nodes: { ox: "D-13", headed_ox: "D-13" },
+      text: { ox: "D-13", headed_ox: "D-13" },
+    },
+    "mixed content: CRLF text normalizes to LF" => {
+      text: { oga: "D-02" },
+    },
+    "mixed content: bare CR text normalizes to LF" => {
+      text: { oga: "D-02" },
+    },
+    "mixed content: character-ref CR survives" => {
+      text: { oga: "D-02", ox: "D-03", headed_ox: "D-03" },
+    },
+    "pi/comment/cdata: pi inside content" => {
+      text: { oga: "D-14" },
+      pi_content: { ox: "D-05", headed_ox: "D-05" },
+    },
+    "pi/comment/cdata: pi multi-space separator" => {
+      text: { oga: "D-14" },
+      pi_content: { ox: "D-05", headed_ox: "D-05" },
+    },
+    "huge text with entities" => {
+      text: { rexml: "D-16" },
+      serialize: { rexml: "D-16" },
+    },
+    "pi/comment/cdata: pi before root" => {
+      nodes: { rexml: "D-15" },
+      text: { rexml: "D-15" },
+      pi_content: { ox: "D-05", headed_ox: "D-05" },
+    },
+    "pi/comment/cdata: comment before and after root" => {
+      comment_content: { ox: "D-06", headed_ox: "D-06" },
+    },
+    "pi/comment/cdata: comment inside content" => {
+      comment_content: { ox: "D-06", headed_ox: "D-06" },
+    },
+  }.freeze
+
+  # Engines whose strict lane cannot see a class of malformedness are
+  # registered: oga's strict is lexer-strict, not well-formedness-
+  # strict (D-17). leptris raises through the facade guard (D-18,
+  # leptris-ruby#514) and is therefore verified, not exempt; entity
+  # and prefix classes are engine-variant by design (entity modes,
+  # namespace validation).
+  STRICT_EXEMPT = {
+    "malformed: bad nesting" => { oga: "D-17" },
+    "malformed: invalid utf-8 byte" => { oga: "D-18", ox: "D-18",
+                                         headed_ox: "D-18" },
+  }.freeze
+
+  def self.inputs
+    [
+      # -- empty/minimal --
+      Input.new("empty/minimal: empty string", "empty/minimal", "", false,
+                "no root: parse must fail loudly or per contract"),
+      Input.new("empty/minimal: whitespace only", "empty/minimal", "  \n\t ", false,
+                "whitespace-only: no root"),
+      Input.new("empty/minimal: bare root", "empty/minimal", "<r/>", true, nil),
+      Input.new("empty/minimal: empty paired root", "empty/minimal", "<r></r>", true, nil),
+      Input.new("empty/minimal: declaration only", "empty/minimal",
+                '<?xml version="1.0"?>', false, "declaration without root"),
+
+      # -- deep nesting --
+      Input.new("deep nesting: 200 levels", "deep nesting",
+                "<r>#{'<d>' * 200}leaf#{'</d>' * 200}</r>", true, nil),
+      Input.new("deep nesting: siblings at depth", "deep nesting",
+                "<r>#{'<a><b>' * 50}#{'</b></a>' * 50}</r>", true, nil),
+
+      # -- huge text/attributes --
+      Input.new("huge text: 100k chars", "huge text/attributes",
+                "<r>#{'x' * 100_000}</r>", true, nil),
+      Input.new("huge attribute: 10k chars", "huge text/attributes",
+                %(<r a="#{'y' * 10_000}"/>), true, nil),
+      Input.new("huge text with entities", "huge text/attributes",
+                "<r>#{'&amp;' * 20_000}</r>", true, nil),
+
+      # -- entities: built-in --
+      Input.new("entities: all five built-ins", "entities",
+                "<r>&amp;&lt;&gt;&quot;&apos;</r>", true, nil),
+      # -- entities: numeric --
+      Input.new("entities: decimal numeric", "entities",
+                "<r>&#65;&#233;</r>", true, nil),
+      Input.new("entities: hex numeric", "entities",
+                "<r>&#x41;&#xE9;</r>", true, nil),
+      # -- entities: custom (DTD-declared) --
+      Input.new("entities: custom DTD entity", "entities",
+                '<!DOCTYPE r [<!ENTITY x "expanded">]><r>&x;</r>', true, nil),
+      # -- entities: undefined (disabled context) --
+      Input.new("entities: undefined reference", "entities",
+                "<r>&undefinedEntity;</r>", false,
+                "undefined entity: malformed without a DTD"),
+      Input.new("entities: NBSP char ref", "entities",
+                "<r>&#160;</r>", true, "U+00A0 survives as content"),
+
+      # -- namespaces: default --
+      Input.new("namespaces: default", "namespaces",
+                '<r xmlns="urn:a"><c/></r>', true, nil),
+      # -- namespaces: prefixed --
+      Input.new("namespaces: prefixed", "namespaces",
+                '<r xmlns:p="urn:a"><p:c/></r>', true, nil),
+      # -- namespaces: undeclared prefix --
+      Input.new("namespaces: undeclared prefix", "namespaces",
+                "<p:c/>", false,
+                "undeclared prefix: malformed in strict parsing"),
+      # -- namespaces: redeclared --
+      Input.new("namespaces: redeclared", "namespaces",
+                '<r xmlns:p="urn:a"><s xmlns:p="urn:b"><p:c/></s></r>', true, nil),
+      # -- namespaces: reserved xml --
+      Input.new("namespaces: reserved xml prefix", "namespaces",
+                '<r xml:lang="en"/>', true, nil),
+      # -- namespaces: xmlns attribute --
+      Input.new("namespaces: xmlns declaration attribute", "namespaces",
+                '<r xmlns="urn:a" xmlns:p="urn:b"/>', true, nil),
+
+      # -- mixed content --
+      Input.new("mixed content: text and inline", "mixed content",
+                "<r>text <b>bold</b> tail</r>", true, nil),
+      Input.new("mixed content: whitespace runs", "mixed content",
+                "<r>\n  <b>x</b>\n  <b>y</b>\n</r>", true, nil),
+      Input.new("mixed content: attribute entities in text", "mixed content",
+                '<r a="&lt;&amp;">&lt;tag&gt;</r>', true, nil),
+      Input.new("mixed content: CRLF text normalizes to LF", "mixed content",
+                "<r>a\r\nb</r>", true, "XML 1.0 §2.11"),
+      Input.new("mixed content: bare CR text normalizes to LF", "mixed content",
+                "<r>a\rb</r>", true, "XML 1.0 §2.11"),
+      Input.new("mixed content: character-ref CR survives", "mixed content",
+                "<r>a&#xD;b</r>", true, "&#xD; is not normalized"),
+
+      # -- pi/comment/cdata edges --
+      Input.new("pi/comment/cdata: pi before root", "pi/comment/cdata edges",
+                '<?xml-stylesheet href="a"?> <r/>', true, nil),
+      Input.new("pi/comment/cdata: comment before and after root", "pi/comment/cdata edges",
+                "<!-- lead --><r/><!-- trail -->", true, nil),
+      Input.new("pi/comment/cdata: cdata with markup", "pi/comment/cdata edges",
+                "<r><![CDATA[<notmarkup> & raw]]></r>", true, nil),
+      Input.new("pi/comment/cdata: empty cdata", "pi/comment/cdata edges",
+                "<r><![CDATA[]]></r>", true, nil),
+      Input.new("pi/comment/cdata: comment inside content", "pi/comment/cdata edges",
+                "<r>a<!-- mid -->b</r>", true, nil),
+      Input.new("pi/comment/cdata: pi inside content", "pi/comment/cdata edges",
+                "<r>a<?pi data?>b</r>", true,
+                "PI content must not contribute to text (D-14 on oga)"),
+      Input.new("pi/comment/cdata: pi multi-space separator", "pi/comment/cdata edges",
+                "<r><?pi   data?></r>", true,
+                "separator whitespace is not PI content (uniform)"),
+      Input.new("pi/comment/cdata: empty pi", "pi/comment/cdata edges",
+                "<r><?pi?></r>", true, nil),
+
+      # -- malformed: unclosed --
+      Input.new("malformed: unclosed element", "malformed", "<r><c>", false, nil),
+      # -- malformed: bad nest --
+      Input.new("malformed: bad nesting", "malformed", "<r><a><b></a></b></r>", false, nil),
+      # -- malformed: bad attribute --
+      Input.new("malformed: unterminated attribute", "malformed",
+                '<r a="x>', false, nil),
+      # -- malformed: stray closing --
+      Input.new("malformed: stray closing tag", "malformed", "</r>", false, nil),
+      # -- malformed: invalid encoding bytes --
+      Input.new("malformed: invalid utf-8 byte", "malformed",
+                "<r>\xC3\x28</r>", false,
+                "0xC3 0x28 is not valid UTF-8"),
+    ].freeze
+  end
+end

data/spec/support/xml_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Seeded XML generator (TODO.sota/02): composes random
+# taxonomy-class documents — elements, text, attributes, namespaces,
+# comments, PIs, CDATA — deterministic per seed. The metamorphic
+# suite runs its properties over generated docs; a failing seed is a
+# reproducible regression.
+module XmlGenerator
+  ELEMENT_NAMES = %w[r a b node item entry rec child leaf].freeze
+  ATTR_NAMES = %w[id name kind type ref value flag].freeze
+  TEXT_POOL = [
+    "plain text", "text with spaces  ", "entities & <tags>",
+    "unicode déjà vu", "numbers 12345", "", "  ", "tail  "
+  ].freeze
+  PI_TARGETS = %w[render probe].freeze
+
+  module_function
+
+  # Deterministic RNG: Ruby's Mersenne with an explicit seed.
+  def generate(seed)
+    rng = Random.new(seed)
+    depth = rng.rand(1..5)
+    body = compose(rng, depth)
+    %(<root#{attrs(rng, depth)}>#{body}</root>)
+  end
+
+  def compose(rng, depth)
+    parts = []
+    rng.rand(1..4).times do
+      case rng.rand(depth.zero? ? 5 : 10)
+      when 0..4 then parts << element(rng, depth)
+      when 5 then parts << TEXT_POOL.sample(random: rng)
+      when 6 then parts << "<!-- #{format('%04x', rng.rand(65_536))} -->"
+      when 7 then parts << "<?#{PI_TARGETS.sample(random: rng)} d#{format('%02x', rng.rand(256))}?>"
+      when 8 then parts << "<![CDATA[raw #{format('%04x', rng.rand(65_536))} <stuff>]]>"
+      when 9 then parts << format("<e n=\"%d\"/>", rng.rand(100))
+      end
+    end
+    parts.join
+  end
+
+  def element(rng, depth)
+    name = ELEMENT_NAMES.sample(random: rng)
+    ns = rng.rand(4).zero? ? %( xmlns="urn:g#{rng.rand(3)}") : ""
+    body = depth.positive? ? compose(rng, depth - 1) : TEXT_POOL.sample(random: rng)
+    "<#{name}#{ns}#{attrs(rng, depth)}>#{body}</#{name}>"
+  end
+
+  def attrs(rng, _depth)
+    (0...rng.rand(0..3)).map do |i|
+      %( #{ATTR_NAMES.sample(random: rng)}#{i}="v#{rng.rand(100)}")
+    end.join
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.147
+  version: 0.5.149
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -24,6 +24,7 @@ files:
 - ".github/workflows/dependent-repos.json"
 - ".github/workflows/dependent-tests.yml"
 - ".github/workflows/docs.yml"
+- ".github/workflows/nightly-fuzz.yml"
 - ".github/workflows/opal.yml"
 - ".github/workflows/rake.yml"
 - ".github/workflows/release.yml"
@@ -227,6 +228,10 @@ files:
 - lib/moxml/node_set.rb
 - lib/moxml/plan.rb
 - lib/moxml/processing_instruction.rb
+- lib/moxml/reference.rb
+- lib/moxml/reference/normalizer.rb
+- lib/moxml/reference/parser.rb
+- lib/moxml/reference/writer.rb
 - lib/moxml/sax.rb
 - lib/moxml/sax/block_handler.rb
 - lib/moxml/sax/element_handler.rb
@@ -297,6 +302,7 @@ files:
 - lib/moxml/xpath/engine.rb
 - lib/moxml/xpath/errors.rb
 - lib/moxml/xpath/lexer.rb
+- lib/moxml/xpath/ordering.rb
 - lib/moxml/xpath/parser.rb
 - lib/moxml/xpath/ruby/generator.rb
 - lib/moxml/xpath/ruby/node.rb
@@ -312,12 +318,16 @@ files:
 - sig/moxml.rbs
 - spec/consistency/README.md
 - spec/consistency/adapter_parity_spec.rb
+- spec/consistency/differential_taxonomy_spec.rb
 - spec/consistency/divergence_register_spec.rb
 - spec/consistency/document_text_spec.rb
 - spec/consistency/eol_normalization_spec.rb
 - spec/consistency/html_doctype_spec.rb
 - spec/consistency/loud_degradation_spec.rb
+- spec/consistency/metamorphic_properties_spec.rb
+- spec/consistency/metamorphic_spec.rb
 - spec/consistency/model_coverage_audit_spec.rb
+- spec/consistency/reference_differential_spec.rb
 - spec/consistency/round_trip_spec.rb
 - spec/consistency/spec_constant_uniqueness_spec.rb
 - spec/consistency/xpath_idioms_spec.rb
@@ -548,6 +558,8 @@ files:
 - spec/moxml/processing_instruction_spec.rb
 - spec/moxml/readonly_parse_spec.rb
 - spec/moxml/recover_mode_spec.rb
+- spec/moxml/reference_opal_spec.rb
+- spec/moxml/reference_spec.rb
 - spec/moxml/sax/namespace_splitter_spec.rb
 - spec/moxml/sax_entity_parity_spec.rb
 - spec/moxml/sax_spec.rb
@@ -609,8 +621,11 @@ files:
 - spec/performance/xpath_benchmark_spec.rb
 - spec/spec_helper.rb
 - spec/support/allocation_helper.rb
+- spec/support/input_generator.rb
+- spec/support/input_taxonomy.rb
 - spec/support/opal.rb
 - spec/support/w3c_namespace_helpers.rb
+- spec/support/xml_generator.rb
 - spec/support/xml_matchers.rb
 - spec/unit/rexml_isolated_test.rb
 homepage: https://github.com/lutaml/moxml