moxml 0.5.32 → 0.5.34

data/lib/moxml/attribute.rb

@@ -2,8 +2,11 @@
 
 module Moxml
   class Attribute < Node
+    # Immutable between name= writes (which clear it via
+    # clear_native_memo!), unlike element names that can change via
+    # native adoption; the memo removes an adapter read per access.
     def name
-      adapter.attribute_name(@native)
+      @name ||= adapter.attribute_name(@native)
     end
 
     def name=(new_name)
@@ -11,6 +14,7 @@ module Moxml
       # to keep tracking — same object for in-place adapters, fresh
       # object for value-object adapters (leptris).
       context.bump_namespace_scope_generation
+      @name = nil
       @native = adapter.set_attribute_name(@native, new_name)
     end
 
@@ -22,7 +26,16 @@ module Moxml
 
     def value
       val = @native.value.to_s
-      adapter.restore_entities(val)
+      # Same guard as Element#text: entity-free documents skip the
+      # marker restore scans. The memo rides the owning element's
+      # (attr natives have no entity probe); a detached attribute
+      # wrapper falls back to the unconditional restore.
+      parent = @parent_node
+      if parent.nil? || parent.entity_bearing?
+        adapter.restore_entities(val)
+      else
+        val
+      end
     end
 
     alias content value
@@ -33,7 +46,13 @@ module Moxml
     end
 
     def value=(new_value)
-      context.bump_namespace_scope_generation
+      name = self.name
+      if name == "xmlns" || name.start_with?("xmlns:")
+        # Declaration rewrite — namespace scope changed
+        context.bump_namespace_scope_generation
+      else
+        @parent_node&.invalidate_attribute_value_cache!
+      end
       adapter.set_attribute_value(@native, new_value)
     end
 
@@ -58,10 +77,26 @@ module Moxml
       native_elem && Moxml::Node.wrap(native_elem, context)
     end
 
+    # The wrapper's parent tracking is authoritative for attributes
+    # (set at materialization by Element#attributes): the generic
+    # adapter read raises on engines whose Attr natives expose no
+    # #parent (leptris), and the tracked value needs no wrap.
+    def parent
+      @parent_node
+    end
+
     def remove
+      # The name must be read before the removal — engines free the
+      # attribute native, and post-removal reads are use-after-free.
+      name = self.name
+      declaration = name == "xmlns" || name.start_with?("xmlns:")
       adapter.remove_attribute_native(@native)
       if @parent_node.is_a?(Moxml::Element)
-        @parent_node.invalidate_attribute_cache!
+        if declaration
+          @parent_node.invalidate_attribute_cache!
+        else
+          @parent_node.invalidate_local_attribute_cache!
+        end
       end
       self
     end

data/lib/moxml/attribute_resolver.rb

@@ -41,7 +41,7 @@ module Moxml
       uri = prefix_uri(element, prefix)
       return nil if uri.nil?
 
-      adapter = element.context.config.adapter
+      adapter = element.adapter
       if adapter.is_a?(Moxml::Adapter::Leptris)
         return adapter.expanded_attr_value(element.native, uri, local)
       end
@@ -105,8 +105,12 @@ module Moxml
     # @return [String] the assigned value
     def assign(element, name, value)
       name = name.to_s
-      adapter = element.context.config.adapter
-      if name == "xmlns" || name.start_with?("xmlns:")
+      adapter = element.adapter
+      # One probe covers both spellings ("xmlns" and "xmlns:*"); a
+      # plain attribute literally starting with "xmlns" would only
+      # over-invalidate (global bump instead of local) — a no-op
+      # for correctness.
+      if name.start_with?("xmlns")
         adapter.set_attribute(element.native, name, value)
         element.invalidate_attribute_cache!
         return value
@@ -122,7 +126,7 @@ module Moxml
       # writes.
       if !name.include?(":") && adapter.bare_set_qname_safe?
         adapter.set_attribute(element.native, name, value)
-        element.invalidate_attribute_cache!
+        element.invalidate_local_attribute_cache!
         return value
       end
 
@@ -133,7 +137,7 @@ module Moxml
       end
 
       adapter.set_attribute(element.native, name, value)
-      element.invalidate_attribute_cache!
+      element.invalidate_local_attribute_cache!
       value
     end
 
@@ -143,8 +147,8 @@ module Moxml
     # @return [Moxml::Attribute, nil] the removed attribute
     def remove(element, name)
       name = name.to_s
-      adapter = element.context.config.adapter
-      if name == "xmlns" || name.start_with?("xmlns:")
+      adapter = element.adapter
+      if name.start_with?("xmlns")
         adapter.remove_attribute(element.native, name)
         element.invalidate_attribute_cache!
         return nil
@@ -154,7 +158,7 @@ module Moxml
       return nil unless attr
 
       adapter.remove_attribute_native(attr.native)
-      element.invalidate_attribute_cache!
+      element.invalidate_local_attribute_cache!
       attr
     end
 

data/lib/moxml/c14n/exclusive.rb

@@ -139,7 +139,7 @@ module Moxml
 
       def bindings_declared_on(element)
         bindings = {}
-        element.namespaces.each do |ns|
+        element.namespace_definitions.each do |ns|
           prefix = ns.prefix
           prefix = "" if prefix.nil? || prefix == "xmlns"
           bindings[prefix] = ns.uri

data/lib/moxml/context.rb

@@ -24,6 +24,13 @@ module Moxml
       # up to the old 65,536 wholesale-clear valve which also
       # destroyed identity for live wrappers when it fired.
       @wrappers = WEAK_WRAPPERS ? ObjectSpace::WeakMap.new : {}.compare_by_identity
+      # Static per context (the registry flavor never changes).
+      @wrappers_strong = !WEAK_WRAPPERS
+      # Resolved on first registration — the adapter-resolution
+      # chain ran per mint and the decision never changes for a
+      # context's adapter (re-configuring an adapter mid-context is
+      # unsupported: minted wrappers already carry the old one).
+      @register_wrappers = nil
     end
 
     def wrapper_for(native)
@@ -31,15 +38,19 @@ module Moxml
     end
 
     def register_wrapper(native, wrapper)
-      # Adapter opt-in. Adapters whose natives are recreated per
-      # access (libxml mints fresh Ruby objects for the same C node)
-      # opt out so the map does not accumulate dead entries; the
-      # default is opt-in.
-      return if @config&.adapter&.wrappers_recyclable? == false
+      # Adapter opt-in, resolved once (see initialize): adapters
+      # whose natives are recreated per access (libxml mints fresh
+      # Ruby objects for the same C node) opt out so the map does
+      # not accumulate dead entries; the default is opt-in.
+      if @register_wrappers.nil?
+        @register_wrappers =
+          @config&.adapter&.wrappers_recyclable? != false
+      end
+      return unless @register_wrappers
 
       # The strong fallback (Opal) needs the wholesale-clear valve;
       # the WeakMap registry is self-cleaning.
-      @wrappers.clear if @wrappers.is_a?(Hash) && @wrappers.size >= 65_536
+      @wrappers.clear if @wrappers_strong && @wrappers.size >= 65_536
       @wrappers[native] = wrapper
     end
 
@@ -106,6 +117,18 @@ module Moxml
     # Memory stays bounded by the largest subtree, not the document
     # (iterparse_file streams the file C-side). Yielded elements are
     # parentless and valid only inside the block.
+    # Parse an XML fragment: returns its top-level nodes as an
+    # Array of wrappers, uniformly across adapters (issue #188 —
+    # fragment: true was Nokogiri-only). Engines without a fragment
+    # node type parse inside a synthetic root; the fragment's nodes
+    # are the result either way.
+    def parse_fragment(xml)
+      adapter = config.adapter
+      adapter.parse_fragment(xml, self).map do |native|
+        Moxml::Node.wrap(native, self)
+      end
+    end
+
     def iterparse(xml, mode: :top_level, &block)
       config.adapter.iterparse(xml, mode, self, &block)
     end

data/lib/moxml/document.rb

@@ -4,7 +4,7 @@ module Moxml
   class Document < Node
     attr_accessor :has_xml_declaration
 
-    def initialize(native, context)
+    def initialize(native, context, adapter = nil, node_type = nil)
       super
       @has_xml_declaration = false
     end

data/lib/moxml/element.rb

@@ -63,7 +63,16 @@ module Moxml
       # names, where resolution is real work.
       adapter = self.adapter
       if !key.include?(":") && adapter.bare_get_qname_safe?
-        return adapter.bare_attr_value(@native, key)
+        # The entity-restore decision rides the wrapper's generation
+        # memo (as Element#text) — the adapter-level probe walks to
+        # the document and the attachment store on every read, which
+        # dominated the fast path.
+        value = adapter.bare_attr_value(@native, key)
+        if value.is_a?(String) && entity_bearing?
+          return adapter.restore_entities(value)
+        end
+
+        value
       end
 
       cache = attribute_read_cache
@@ -86,7 +95,11 @@ module Moxml
     # every attribute or namespace mutation anywhere bumps it.
     def attribute_read_cache
       generation = context.namespace_scope_generation
-      if @attribute_cache_generation != generation
+      # @attribute_cache.nil? covers the local invalidation clears —
+      # a value or list change without a scope bump (see
+      # invalidate_local_attribute_cache!) — so writes never allocate
+      # a replacement hash; the next read materializes one lazily.
+      if @attribute_cache.nil? || @attribute_cache_generation != generation
         @attribute_cache = {}
         @attribute_cache_generation = generation
       end
@@ -99,8 +112,11 @@ module Moxml
     end
 
     def attributes
+      # Primed like Node.wrap: the adapter and type are known at
+      # mint, so the first name/value/attribute? access skips the
+      # context hop and the adapter's type probe.
       @attributes ||= adapter.attributes(@native).map do |attr|
-        a = Attribute.new(attr, context)
+        a = Attribute.new(attr, context, adapter, :attribute)
         a.parent_node = self
         a
       end
@@ -180,12 +196,25 @@ module Moxml
       invalidate_namespace_cache!
     end
 
+    # All namespaces IN SCOPE for this element — its own
+    # declarations plus everything inherited from ancestors —
+    # matching the Nokogiri #namespaces contract consumers port
+    # against (issue #198: this returned only own declarations,
+    # losing ancestor scope under every backend).
     def namespaces
-      @namespaces ||= adapter.namespace_definitions(@native).map do |ns|
+      in_scope_namespaces
+    end
+
+    # The element's OWN namespace declarations only (not
+    # inherited). C14n's visibly-utilized calculation and the
+    # materializer's declaration pairs want exactly this shape.
+    def namespace_definitions
+      return @namespace_definitions unless @namespace_definitions.nil?
+
+      @namespace_definitions = adapter.namespace_definitions(@native).map do |ns|
         Namespace.new(ns, context)
       end
     end
-    alias namespace_definitions namespaces
 
     # The element's OWN namespace declarations as [prefix, uri]
     # pairs (nil prefix = default namespace) — not the inherited
@@ -217,7 +246,10 @@ module Moxml
 
     def text
       val = adapter.text_content(@native)
-      adapter.restore_entities(val)
+      # Entity-free documents (the common case) skip the marker
+      # restore scans entirely — the per-wrapper entity_bearing?
+      # memo rides the adapter's serialize generation.
+      entity_bearing? ? adapter.restore_entities(val) : val
     end
 
     alias content text
@@ -229,7 +261,7 @@ module Moxml
 
     def inner_text
       text = raw_inner_text
-      adapter.restore_entities(text)
+      entity_bearing? ? adapter.restore_entities(text) : text
     end
 
     # Returns inner text without entity marker restoration.
@@ -291,9 +323,25 @@ module Moxml
       children
     end
 
-    # Called by Attribute#remove and the attribute mutators. Clears
-    # the attribute list and the resolved-read cache, and bumps the
-    # context generation so cross-wrapper reads recompute.
+    # Attribute mutations that cannot change namespace scope (bare
+    # and non-xmlns prefixed names) invalidate locally: the
+    # resolved-read cache alone for value writes, the wrapper list
+    # too when the attribute set changes. No context generation
+    # bump — that would evict every wrapper's caches document-wide
+    # on each write of a bulk build.
+    def invalidate_attribute_value_cache!
+      @attribute_cache = nil
+    end
+
+    def invalidate_local_attribute_cache!
+      @attributes = nil
+      @attribute_cache = nil
+    end
+
+    # Called by the namespace-scoped attribute paths (xmlns writes
+    # and removals) and Attribute#name=. Clears the attribute list
+    # and the resolved-read cache, and bumps the context generation
+    # so cross-wrapper reads recompute.
     def invalidate_attribute_cache!
       @attributes = nil
       @attribute_cache = nil
@@ -305,6 +353,7 @@ module Moxml
     # any children cache — recomputes on next read.
     def invalidate_namespace_cache!
       @namespaces = nil
+      @namespace_definitions = nil
       @in_scope_namespaces = nil
       context.bump_namespace_scope_generation
     end

data/lib/moxml/node.rb

@@ -12,10 +12,16 @@ module Moxml
 
     attr_reader :native, :context
 
-    def initialize(native, context)
+    # adapter/node_type are primed by Node.wrap, which resolves both
+    # before choosing the wrapper class — a fresh wrapper would
+    # otherwise pay the context hop and the type probe again on its
+    # first access.
+    def initialize(native, context, adapter = nil, node_type = nil)
       @context = context
       @native = native
       @parent_node = nil
+      @adapter = adapter
+      @node_type_cached = node_type
     end
 
     # Update native reference after identity-changing operations
@@ -349,6 +355,18 @@ module Moxml
       adapter.line_number(@native)
     end
 
+    # Content-defined Merkle digest of this subtree (issue #173,
+    # companion to leptris#869): a u64 Integer where the backend
+    # computes one, nil everywhere else. Consumers gate on nil and
+    # fall back to walking. Equal digests imply subtree equivalence
+    # under the flag set; unequal digests imply nothing (descend).
+    # +drop_ws_text+ skips whitespace-only text nodes.
+    #
+    # @return [Integer, nil]
+    def digest(drop_ws_text: false)
+      adapter.digest(@native, drop_ws_text: drop_ws_text)
+    end
+
     def outer_xml
       to_xml
     end
@@ -418,10 +436,12 @@ module Moxml
       cached = context.wrapper_for(node)
       return cached if cached
 
-      type = adapter(context).node_type(node)
+      adapter = adapter(context)
+      type = adapter.node_type(node)
       klass = node_type_map[type] || self
 
-      klass.new(node, context).tap { |wrapper| context.register_wrapper(node, wrapper) }
+      klass.new(node, context, adapter, type)
+        .tap { |wrapper| context.register_wrapper(node, wrapper) }
     end
 
     # Internal: Set the parent node for cache invalidation tracking.
@@ -429,14 +449,14 @@ module Moxml
     # relationships. Public to allow cross-class usage within Moxml internals.
     attr_writer :parent_node
 
-    protected
-
     def adapter
       # A context's adapter object is fixed for its lifetime; the
       # chain deref ran on every node access.
       @adapter ||= context.config.adapter
     end
 
+    protected
+
     def self.adapter(context)
       context.config.adapter
     end

data/lib/moxml/text.rb

@@ -4,7 +4,7 @@ module Moxml
   class Text < Node
     def content
       text = raw_content
-      adapter.restore_entities(text)
+      entity_bearing? ? adapter.restore_entities(text) : text
     end
 
     # Returns raw content without entity marker restoration.

data/lib/moxml/version.rb

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

data/spec/integration/contract_parity_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# Cross-adapter contract parity (issue #198): every bundled adapter
+# runs the same behavioral battery, so parity is CI-enforced rather
+# than discovered by consumers.
+%w[nokogiri leptris ox oga rexml].each do |adapter_name|
+  begin
+    next unless Moxml::Adapter.load_available?(adapter_name.to_sym)
+  rescue StandardError
+    false
+  end
+
+  RSpec.describe "Contract parity: #{adapter_name}", :adapter do
+    around do |example|
+      Moxml.with_config(adapter_name.to_sym, true, "UTF-8") do
+        example.run
+      end
+    end
+
+    let(:ctx) { Moxml.new(adapter_name.to_sym) }
+
+    describe "fragment parsing (issue #188)" do
+      it "returns the fragment's top-level nodes uniformly" do
+        nodes = ctx.parse_fragment(%(<a x="1">t1</a><b/>tail))
+        expect(nodes.map(&:class)).to eq(
+          [Moxml::Element, Moxml::Element, Moxml::Text],
+        )
+        expect(nodes[0]["x"]).to eq("1")
+        expect(nodes[0].text).to eq("t1")
+        expect(nodes[2].content).to eq("tail")
+      end
+
+      it "round-trips entities inside fragments" do
+        nodes = ctx.parse_fragment(%(<p>caf&eacute; &amp; more</p>))
+        # The moxml XML contract preserves entity REFERENCES in
+        # text reads (the entity-preservation design) — uniform
+        # across adapters, fragments included.
+        expect(nodes.first.content).to include("&eacute;")
+        expect(nodes.first.to_xml).to include("&amp;")
+      end
+
+      it "returns [] for an empty fragment" do
+        expect(ctx.parse_fragment("")).to eq([])
+      end
+    end
+
+    describe "nil namespace clearing (issue #164 contract)" do
+      it "accepts namespace = nil without raising" do
+        doc = ctx.parse(%(<r xmlns="urn:d"><c>t</c></r>))
+        child = doc.root.children.first
+        expect { child.namespace = nil }.not_to raise_error
+      end
+    end
+
+    describe "namespace adoption on append" do
+      it "keeps a subtree's own declarations when appended" do
+        doc = ctx.parse(%(<root/>))
+        nodes = ctx.parse_fragment(%(<p:s xmlns:p="urn:p">x</p:s>))
+        doc.root.add_child(nodes.first)
+        out = doc.to_xml
+        expect(out).to include("urn:p")
+        expect(out).to include("x")
+      end
+    end
+
+    describe "qname create + namespace assignment (issue #208)" do
+      it "does not double the prefix when the name is already qualified" do
+        doc = ctx.parse(%(<r xmlns:p="urn:p"/>))
+        el = doc.create_element("p:c")
+        ns = doc.root.in_scope_namespaces.find { |n| n.prefix == "p" }
+        el.namespace = ns
+        doc.root.add_child(el)
+        out = doc.to_xml
+        expect(out).to include("p:c")
+        expect(out).not_to include("p:p:c")
+      end
+    end
+
+    describe "namespaces contract (issue #198 comment)" do
+      it "returns the in-scope map including ancestor declarations" do
+        doc = ctx.parse(%(<root xmlns:p="urn:p" xmlns="urn:d"><p:c plain="1"/></root>))
+        child = doc.root.children.first
+        map = child.namespaces.map { |n| [n.prefix, n.uri.to_s] }
+        expect(map).to contain_exactly(["p", "urn:p"], [nil, "urn:d"])
+      end
+
+      it "namespace_definitions stays the element's own declarations" do
+        doc = ctx.parse(%(<root xmlns:p="urn:p"><p:c/></root>))
+        child = doc.root.children.first
+        expect(child.namespace_definitions).to be_empty
+        expect(doc.root.namespace_definitions.map(&:prefix)).to eq(["p"])
+      end
+    end
+
+    describe "subtree digest channel (issue #173)" do
+      it "answers an Integer on digest-capable backends, nil elsewhere" do
+        doc = ctx.parse(%(<r><a x="1">t</a></r>))
+        digest = doc.root.digest
+        expect(digest).to be_nil.or be_a(Integer)
+        # Where non-nil, it is deterministic within the backend
+        doc2 = ctx.parse(%(<r><a x="1">t</a></r>))
+        expect(doc2.root.digest).to eq(digest) unless digest.nil?
+      end
+    end
+
+    describe "attribute channel semantics" do
+      it "reads and writes bare and prefixed attributes" do
+        doc = ctx.parse(%(<r xmlns:p="urn:p"><e a="1" p:b="2"/></r>))
+        e = doc.at_xpath("//e")
+        expect(e["a"]).to eq("1")
+        expect(e["p:b"]).to eq("2")
+        e["a"] = "changed"
+        expect(e["a"]).to eq("changed")
+        expect(e["p:b"]).to eq("2")
+      end
+
+      # Writes invalidate locally (no document-wide scope bump); a
+      # sibling's resolved reads must survive interleaved writes.
+      it "keeps sibling read caches coherent across interleaved writes" do
+        doc = ctx.parse(%(<r><a x="1"/><b x="2"/></r>))
+        first, second = doc.root.children.to_a
+        expect(first["x"]).to eq("1")
+        expect(second["x"]).to eq("2")
+        first["x"] = "one"
+        first["y"] = "fresh"
+        expect(second["x"]).to eq("2")
+        expect(first["x"]).to eq("one")
+        expect(first["y"]).to eq("fresh")
+        second["x"] = "two"
+        expect(first["x"]).to eq("one")
+        expect(first["y"]).to eq("fresh")
+        expect(second["x"]).to eq("two")
+      end
+    end
+  end
+end

data/spec/integration/shared_examples/node_wrappers/namespace_behavior.rb

@@ -134,7 +134,10 @@ RSpec.shared_examples "Moxml::Namespace" do
         child.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
         root.add_child(child)
 
-        ns_defs = child.namespaces
+        # Own declarations (the #namespaces name moved to the
+        # in-scope Nokogiri contract — issue #198; this assertion
+        # pins own-declarations, which is what it always meant).
+        ns_defs = child.namespace_definitions
         prefixes = ns_defs.map(&:prefix)
 
         expect(prefixes).to contain_exactly("dc")

data/spec/moxml/adapter/leptris_spec.rb

@@ -634,4 +634,57 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(doc.at_xpath("//a").children.to_a.map(&:class)).to include(Moxml::EntityReference)
     end
   end
+
+  describe "subtree digest (issue #173, leptris#869)" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "answers equal integers for identical subtrees parsed separately" do
+      xml = %(<r xmlns:p="urn:p"><a x="1" p:y="2">t</a><b><c/></b></r>)
+      d1 = ctx.parse(xml)
+      d2 = ctx.parse(xml)
+      expect(d1.root.digest).to be_a(Integer)
+      expect(d1.root.digest).to eq(d2.root.digest)
+    end
+
+    it "answers unequal integers when content differs" do
+      d1 = ctx.parse(%(<r><a x="1"/></r>))
+      d2 = ctx.parse(%(<r><a x="2"/></r>))
+      expect(d1.root.digest).not_to eq(d2.root.digest)
+    end
+
+    it "skips whitespace-only text with drop_ws_text" do
+      spaced = ctx.parse(%(<r>\n  <a/>\n</r>))
+      tight = ctx.parse(%(<r><a/></r>))
+      expect(spaced.root.digest).not_to eq(tight.root.digest)
+      expect(spaced.root.digest(drop_ws_text: true))
+        .to eq(tight.root.digest(drop_ws_text: true))
+    end
+
+    it "hashes the prefix as well as the resolved namespace" do
+      same = ctx.parse(%(<r xmlns:p="urn:p"><p:a/></r>))
+      mirror = ctx.parse(%(<r xmlns:p="urn:p"><p:a/></r>))
+      renamed = ctx.parse(%(<r xmlns:q="urn:p"><q:a/></r>))
+      other_uri = ctx.parse(%(<r xmlns:p="urn:z"><p:a/></r>))
+      base = same.root.digest
+      expect(mirror.root.digest).to eq(base)
+      # prefix participates (leptris#869: hash(prefix, URI, local))
+      expect(renamed.root.digest).not_to eq(base)
+      expect(other_uri.root.digest).not_to eq(base)
+    end
+
+    it "answers nil for nodes without a C handle" do
+      doc = ctx.parse(%(<r a="1"><!-- c --><p/><?p instr?></r>))
+      expect(doc.digest).to be_nil
+      expect(doc.root.attributes.first.digest).to be_nil
+      doc.children.select(&:declaration?).each do |decl|
+        expect(decl.digest).to be_nil
+      end
+      # comments and PIs hash in C
+      kinds = doc.root.children.map { |n| [n.class, n.digest] }
+      comment = kinds.find { |n, _| n == Moxml::Comment }
+      pi = kinds.find { |n, _| n == Moxml::ProcessingInstruction }
+      expect(comment[1]).to be_a(Integer)
+      expect(pi[1]).to be_a(Integer)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.32
+  version: 0.5.34
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-09-14 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -38,6 +38,7 @@ files:
 - LICENSE.md
 - README.adoc
 - Rakefile
+- benchmark/pipeline_bench.rb
 - benchmarks/.gitignore
 - benchmarks/generate_report.rb
 - bin/console
@@ -395,6 +396,7 @@ files:
 - spec/fixtures/xmldsig/sign3-result.xml
 - spec/integration/README.md
 - spec/integration/all_adapters_spec.rb
+- spec/integration/contract_parity_spec.rb
 - spec/integration/headed_ox_integration_spec.rb
 - spec/integration/sax_parity_spec.rb
 - spec/integration/shared_examples/edge_cases.rb