moxml 0.5.35 → 0.5.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f80e7825989e8653fcc4037f6e6a538ca28da7c6637d6bb941985bcc98d4dabf
-  data.tar.gz: 974854c0f42279c86e404e48920a2fd6e92cebbac22a7c6781bae023fa017fde
+  metadata.gz: 9d5b785cac911c3289013e8ad7f3a41a0608498b6389098a80b58a6693f1a063
+  data.tar.gz: 73f7938818ebcc02059f1396d776e9db477f924ceefcce3680b14a2c3c26aca7
 SHA512:
-  metadata.gz: 7749417f017a166425fb18e896e6c0346475dd78cb32792fe725153512b64c384f60cf026e5d8503e7fb0878f22a3e6f92221126f98f08550a7b58ba1e65e2a4
-  data.tar.gz: 6545711a0dec77522f2965c5239c7cb8632878170e0fd6ea024be4d64515e49cd26550cf40b9dab7dda1ed2faa5e98caa0e076e0fda6781f7cc64463c520fd59
+  metadata.gz: 00ac1feeeb5e1f4e407d4ccdb3afb29580f85300c1daca678de547079db791488d7d792d15b95381ae3488fe6e1f9e73f782376af6a09078fd4101f523218e93
+  data.tar.gz: be6be6adfe05ad94ecc36b1dfea8f295683478243d46301f261a6a9caecb09ac59b836342f79e124f75855c4864757a341687ef51377c9aaa252d7316fb5f141

data/docs/_pages/performance.adoc

@@ -253,6 +253,30 @@ read cache materializes lazily). The remaining cold-walk gap is
 binding-side (its per-node Ruby wrapper construction) — tracked
 upstream as the TypedData work.
 
+=== Native read layer (leptris >= 1.9.162.6)
+
+The leptris adapter adopts the binding's opt-in native read layer
+(leptris-ruby#185): TypedData node wrappers with C-bound hot reads
+and bulk children construction — one wrapper-cache round-trip for a
+whole child list, zero per-node FFI. Element natives minted from
+`#root` and `children` are native-layer nodes; the C tree is shared
+with the binding, so writes made through the bridged binding nodes
+(a `to_binding` wrap over the same pointer) are visible to native
+reads. Engines without the layer, or ruby-platform installs without
+the compiled bundle, stay on the binding path unchanged.
+
+| path | binding path | native layer |
+| Consumer pipeline (parse + typed walk) | 6112µs (0.50x nokogiri) | **3380µs (1.00-1.04x)** |
+| Pipeline allocations | 13564 | **9813 (0.69x nokogiri)** |
+| Cold walk (parse + mint) | 738µs | **509µs** |
+| Raw walk (binding vs native, upstream's fixture) | 64.3µs/doc | 22.8µs/doc |
+
+Entity-marker documents fall back to the binding children path (the
+marker split materializes TextSegments); the wrapper's
+`entity_bearing?` memo decides, so the check costs no per-call
+climb. `Node#==` and the adapter protocol's `same_node?` compare
+C-node addresses — two wrapper classes over one node compare equal.
+
 === Prefer bulk paths for per-node conversion
 
 Per-node Ruby iteration pays the wrapper tax per element. When the

data/lib/moxml/adapter/base.rb

@@ -116,6 +116,13 @@ module Moxml
           )
         end
 
+        # Protocol-level native equality; engines with more than one
+        # wrapper class over one C node override (leptris native
+        # read layer). Shared adapter examples compare through this.
+        def same_node?(one, other)
+          one == other
+        end
+
         # Backends without a native subtree digest answer nil —
         # the wrapper contract Node#digest gates on (issue #173).
         def digest(*)
@@ -272,7 +279,7 @@ namespace_validation_mode: :strict)
         # Marker-tracking adapters override this so the post-serialize
         # restore can skip its full-output scans on marker-free
         # documents; the default stays conservative.
-        def entity_bearing?(_native)
+        def entity_bearing?(_native, _doc = nil)
           true
         end
 

data/lib/moxml/adapter/leptris/markers.rb

@@ -8,7 +8,16 @@ module Moxml
         # the ER builder path flips it, and the split/restore scans
         # consult it. Customized natives only exist as split products
         # of marker-bearing text, so they always report true.
-        def entity_bearing?(native)
+        # doc is the binding document when the wrapper could resolve
+        # it through its parent chain; the C climb is the fallback.
+        def entity_bearing?(native, doc = nil)
+          if NATIVE_READ_LAYER && native.is_a?(::Leptris::XML::NativeNode)
+            doc ||= doc_for(native)
+            return false if doc.nil?
+
+            return attachments.get(doc, :entity_markers) != false
+          end
+
           case native
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
              CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,

data/lib/moxml/adapter/leptris/serialize.rb

@@ -30,6 +30,7 @@ module Moxml
         EMPTY_ELEMENT_RE = %r{<([A-Za-z_][\w.:-]*+)((?:"[^"]*+"|'[^']*+'|[^<>"'/]++)*+)/>}
 
         def serialize(node, options = {})
+          node = to_binding(node) if NATIVE_READ_LAYER
           # Entity restoration belongs to the wrapper layer
           # (Node#to_xml runs adapter.restore_entities for every
           # adapter); doing it here scanned the output a second time.

data/lib/moxml/adapter/leptris.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ffi"
+
 return if RUBY_ENGINE == "opal"
 
 require "stringio"
@@ -40,6 +42,87 @@ module Moxml
       DIGEST_SUPPORTED =
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.99")
 
+      # Opt-in native read layer (leptris-ruby#185, bindings >= 1.9.162.6):
+      # TypedData node wrappers with C-bound hot reads and bulk
+      # children construction. Minted from #root downward; the C
+      # tree is shared with the binding, so writes made through the
+      # bridged binding nodes are visible to native reads. Installs
+      # without the compiled bundle (ruby-platform gem) simply stay
+      # on the binding path.
+      begin
+        require "leptris/xml/native_layer"
+      rescue LoadError, StandardError
+        nil
+      end
+      NATIVE_READ_LAYER =
+        defined?(::Leptris::XML::NativeNode) &&
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.162.6")
+
+      # The binding's scratch-buffer growth truncates bulk children
+      # at 512 on 1.9.163.x (leptris-ruby#202) — the engine copies
+      # any buffer size correctly and its count query is exact, so
+      # moxml fetches with its own grow-to-fit scratch (correct on
+      # every binding version; the binding's own Node#children is
+      # not trusted for large lists).
+
+      if NATIVE_READ_LAYER
+        # root NativeNode -> binding document (recorded at #root mint;
+        # NativeNode exposes no document accessor).
+        @native_doc_roots = ObjectSpace::WeakMap.new
+
+        class << self
+          def record_native_doc(root_native, doc)
+            @native_doc_roots[root_native] = doc
+          end
+
+          # Protocol-level node equality: one engine can hand out
+          # two wrapper classes over the same C node (native layer +
+          # binding), so raw == is not identity across the seam.
+          def same_node?(one, other)
+            return true if one.equal?(other)
+
+            if NATIVE_READ_LAYER
+              native_one = one.is_a?(::Leptris::XML::NativeNode)
+              native_other = other.is_a?(::Leptris::XML::NativeNode)
+              if native_one || native_other
+                address_one = native_one ? one.address : one.c_ptr.address
+                address_other = native_other ? other.address : other.c_ptr.address
+                return address_one == address_other
+              end
+            end
+
+            one == other
+          end
+
+          # Binding node for any native: identity for binding nodes,
+          # a Node.wrap over the shared C pointer for NativeNodes.
+          def to_binding(node)
+            return node unless NATIVE_READ_LAYER &&
+              node.is_a?(::Leptris::XML::NativeNode)
+
+            doc = doc_for(node)
+            ptr = ::FFI::Pointer.new(node.address)
+            return ::Leptris::XML::Node.wrap(ptr, doc) if doc
+
+            ::Leptris::XML::Node.wrap(ptr, nil)
+          end
+
+          # Binding document for a NativeNode subtree: climb parents
+          # to the root (C-bound reads) and look the doc up in the
+          # root registry. Detached subtrees answer nil.
+          def doc_for(node)
+            current = node
+            current = current.parent while current&.parent
+            @native_doc_roots[current]
+          end
+        end
+      end
+
+      # Binding node for any native: identity for binding nodes, a
+      # Node.wrap over the shared C pointer for NativeNodes (used by
+      # the write/serialize/namespace paths the native layer does
+      # not carry).
+
       # Native C14N delegation probe: the engine's C14N must
       # byte-match the Ruby reference (ported from canon) on a
       # namespace-sorting + attributes + comments shape before
@@ -191,7 +274,14 @@ module Moxml
         # document-plus-attachment probe here cost more than the
         # read itself).
         def bare_attr_value(element, name)
-          element[name.to_s]
+          value = element[name.to_s]
+          if NATIVE_READ_LAYER &&
+              element.is_a?(::Leptris::XML::NativeNode) &&
+              value.is_a?(String)
+            return value.dup.force_encoding(Encoding::UTF_8)
+          end
+
+          value
         end
 
         def native_identity_stable?
@@ -428,10 +518,12 @@ module Moxml
         end
 
         def create_native_namespace(element, prefix, uri)
+          element = to_binding(element) if NATIVE_READ_LAYER
           element.add_namespace_definition(prefix, uri)
         end
 
         def set_namespace(node, namespace)
+          node = to_binding(node) if NATIVE_READ_LAYER
           return set_attribute_namespace(node, namespace) if node.is_a?(::Leptris::XML::Attr)
 
           element = node
@@ -498,6 +590,8 @@ module Moxml
         end
 
         def namespace(node)
+          node = to_binding(node) if NATIVE_READ_LAYER
+
           # The binding resolves Attr#namespace to the declaration but
           # without the prefix; when the qualified name carries one,
           # prefer the in-scope declaration that binds it so wrappers
@@ -549,6 +643,16 @@ module Moxml
         end
 
         def node_type(node)
+          if NATIVE_READ_LAYER &&
+              node.is_a?(::Leptris::XML::NativeNode)
+            type = node.node_type
+            # The native layer spells PIs :pi; the wrapper contract
+            # (node_type_map) says :processing_instruction.
+            return :processing_instruction if type == :pi
+
+            return type
+          end
+
           # Frequency-ordered: elements and text dominate every real
           # document, and Node.wrap dispatches here once per cold
           # wrap. CDATA must precede Text (CDATA < Text in the
@@ -574,6 +678,9 @@ module Moxml
         # lightweight Attr triples answer nil.
         def digest(node, drop_ws_text: false)
           return nil unless DIGEST_SUPPORTED
+          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            return to_binding(node).digest(drop_ws: drop_ws_text)
+          end
           return nil unless node.is_a?(::Leptris::XML::Node) &&
             !node.is_a?(::Leptris::XML::ResultAttr)
 
@@ -584,10 +691,19 @@ module Moxml
           return node.root_name if node.is_a?(::Leptris::XML::DocType)
           return node.target if node.is_a?(CustomizedLeptris::DocumentPI)
 
+          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            # Native strings arrive ASCII-8BIT; PIs expose no name
+            # through the native layer.
+            return to_binding(node).target.to_s if node.node_type == :pi
+
+            return node.name.dup.force_encoding(Encoding::UTF_8)
+          end
+
           node.name.to_s.dup.force_encoding("UTF-8")
         end
 
         def set_node_name(node, name)
+          node = to_binding(node) if NATIVE_READ_LAYER
           case node
           when ::Leptris::XML::ProcessingInstruction, CustomizedLeptris::DocumentPI then node.target = name
           else node.name = name
@@ -595,6 +711,7 @@ module Moxml
         end
 
         def duplicate_node(node)
+          node = to_binding(node) if NATIVE_READ_LAYER
           case node
           when CustomizedLeptris::Declaration
             CustomizedLeptris::Declaration.new(node.version, node.encoding, node.standalone)
@@ -609,12 +726,38 @@ module Moxml
           end
         end
 
-        def children(node)
+        def children(node, entity_bearing: false)
+          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            # Bulk C children through moxml's own scratch (see
+            # NATIVE_READ_LAYER note above). Entity-marker documents
+            # bridge each child for the marker split — the
+            # TextSegment reconstruction reads binding text nodes;
+            # the wrapper's memo supplies the flag, so deriving it
+            # here costs no C parent climb per call.
+            natives = bulk_native_children(node)
+            return natives unless entity_bearing
+
+            # Entity-marker documents: bridge for the marker split
+            # (TextSegment reconstruction reads binding text nodes).
+            doc = doc_for(node)
+            bound_children = natives.map { |child| to_binding(child) }
+            if doc && attachments.get(doc, :entity_markers) == false
+              return bound_children
+            end
+
+            return split_entity_markers(bound_children, to_binding(node))
+          end
           # Frequency-ordered: elements dominate every walk and paid
           # ten failed compares to reach the else arm.
           case node
           when ::Leptris::XML::Element
             natives = node.children.to_a
+            if NATIVE_READ_LAYER && natives.size == 512
+              # Binding scratch truncation (leptris-ruby#202): a
+              # full batch is ambiguous — refetch through moxml's
+              # own buffers to be sure.
+              natives = bulk_binding_children(node)
+            end
             # Parse records whether the preprocessed source held any
             # entity markers, and the ER builder path flips the flag
             # when it mints one. A false flag lets traversal skip the
@@ -643,6 +786,16 @@ module Moxml
         end
 
         def parent(node)
+          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            parent = node.parent
+            return parent if parent
+
+            doc = doc_for(node)
+            return doc if doc&.root && doc.root.c_ptr.address == node.address
+
+            return nil
+          end
+
           # Frequency-ordered: elements dominate navigation and paid
           # three failed compares to reach the else arm.
           case node
@@ -657,6 +810,66 @@ module Moxml
           end
         end
 
+        # The binding-node twin of bulk_native_children (identity via
+        # the binding's wrap cache).
+        def bulk_binding_children(node)
+          copied, pointers = bulk_child_buffers(node.c_ptr)
+          return node.children.to_a if copied.zero?
+
+          doc = node.document
+          Array.new(copied) do |i|
+            ::Leptris::XML::Node.wrap(pointers.get_pointer(i * 8), doc)
+          end
+        end
+
+        # Bulk child fetch with moxml's own grow-to-fit thread-local
+        # scratch: count first (exact), size the buffers to it, wrap
+        # each pointer as a native-layer node. Correct on every
+        # binding version — the binding's own scratch truncates at
+        # 512 on 1.9.163.x (leptris-ruby#202).
+        def bulk_native_children(node)
+          copied, pointers = bulk_child_buffers(::FFI::Pointer.new(node.address))
+          return [] if copied.zero?
+
+          doc = doc_for(node)
+          return to_binding(node).children.to_a if doc.nil?
+
+          # Share the layer's per-document identity cache (keyed by
+          # node address): NativeNode.from alone mints fresh objects
+          # per call on 1.9.163.x, which would fork moxml wrappers.
+          cache = doc.native_cache
+          Array.new(copied) do |i|
+            child_ptr = pointers.get_pointer(i * 8)
+            cache[child_ptr.address] ||=
+              ::Leptris::XML::NativeNode.from(doc, child_ptr)
+          end
+        end
+
+        # Shared count-then-copy fetch over moxml's grow-to-fit
+        # thread-local scratch — the layer above the binding's
+        # (buggy on 1.9.163.x) own buffers. Returns [copied, pointers].
+        def bulk_child_buffers(ptr)
+          total = ::Leptris::XML::FFI.leptris_node_children_ex(ptr, nil, nil, 0)
+          return [0, nil] if total.zero?
+
+          scratch = (Thread.current[:moxml_leptris_children] ||= {})
+          pointers = scratch[:pointers]
+          if pointers.nil? || pointers.size / 8 < total
+            pointers&.free
+            pointers = scratch[:pointers] =
+              ::FFI::MemoryPointer.new(:pointer, total)
+          end
+          kinds = scratch[:kinds]
+          if kinds.nil? || kinds.size / 4 < total
+            kinds&.free
+            kinds = scratch[:kinds] = ::FFI::MemoryPointer.new(:int, total)
+          end
+          copied = ::Leptris::XML::FFI.leptris_node_children_ex(
+            ptr, pointers, kinds, total
+          )
+          [copied, pointers]
+        end
+
         # The binding reports the root element as parentless; the
         # moxml contract roots at the document.
         def root_parent(node)
@@ -664,14 +877,25 @@ module Moxml
         end
 
         def next_sibling(node)
+          return node.next_sibling if NATIVE_READ_LAYER &&
+            node.is_a?(::Leptris::XML::NativeNode)
+
           node.next_sibling if node.is_a?(::Leptris::XML::Node)
         end
 
         def previous_sibling(node)
+          # Bridged, not the native sibling walk: the native layer
+          # exposes next_sibling only, and its children batch
+          # truncates at 512 — the predecessor beyond that would be
+          # wrong.
+          node = to_binding(node)
           node.previous_sibling if node.is_a?(::Leptris::XML::Node)
         end
 
         def document(node)
+          return doc_for(node) if NATIVE_READ_LAYER &&
+            node.is_a?(::Leptris::XML::NativeNode)
+
           case node
           when ::Leptris::XML::Document then node
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype then node.parent_doc
@@ -680,7 +904,15 @@ module Moxml
         end
 
         def root(document)
-          document.root
+          r = document.root
+          return nil if r.nil?
+
+          if NATIVE_READ_LAYER
+            native = document.native_node
+            record_native_doc(native, document)
+            return native
+          end
+          r
         end
 
         def line_number(node)
@@ -691,6 +923,7 @@ module Moxml
         end
 
         def attributes(element)
+          element = to_binding(element)
           element.attribute_nodes
         end
 
@@ -707,6 +940,7 @@ module Moxml
         end
 
         def set_attribute(element, name, value)
+          element = to_binding(element) if NATIVE_READ_LAYER
           element[name.to_s] = value.to_s
         end
 
@@ -726,14 +960,17 @@ module Moxml
         end
 
         def get_attribute(element, name)
+          element = to_binding(element)
           element.attribute_nodes.find { |attr| attr.name == name.to_s }
         end
 
         def get_attribute_value(element, name)
+          element = to_binding(element)
           element[name.to_s]
         end
 
         def remove_attribute(element, name)
+          element = to_binding(element)
           element.remove_attribute(name.to_s)
         end
 
@@ -743,6 +980,10 @@ module Moxml
         end
 
         def add_child(parent, child)
+          if NATIVE_READ_LAYER
+            parent = to_binding(parent)
+            child = to_binding(child)
+          end
           case parent
           when ::Leptris::XML::Document then add_document_child(parent, child)
           else
@@ -759,6 +1000,7 @@ module Moxml
         end
 
         def add_previous_sibling(node, new_node)
+          node = to_binding(node) if NATIVE_READ_LAYER
           # A PI inserted before the root lives at document level in
           # libleptris's model, not in the element tree.
           if new_node.is_a?(::Leptris::XML::ProcessingInstruction) &&
@@ -770,10 +1012,12 @@ module Moxml
         end
 
         def add_next_sibling(node, new_node)
+          node = to_binding(node) if NATIVE_READ_LAYER
           node.add_next_sibling(new_node)
         end
 
         def remove(node)
+          node = to_binding(node) if NATIVE_READ_LAYER
           case node
           when CustomizedLeptris::Declaration
             remove_declaration(node.parent_doc) if node.parent_doc
@@ -793,6 +1037,10 @@ module Moxml
         end
 
         def replace(node, new_node)
+          if NATIVE_READ_LAYER
+            node = to_binding(node)
+            new_node = to_binding(new_node)
+          end
           return node.replace(new_node) if node.is_a?(::Leptris::XML::Element)
 
           # libleptris only offers element-anchored insertion, so a
@@ -817,10 +1065,18 @@ module Moxml
         end
 
         def replace_children(node, new_children)
+          if NATIVE_READ_LAYER
+            node = to_binding(node)
+            new_children = new_children.map { |child| to_binding(child) }
+          end
           node.children = new_children
         end
 
         def text_content(node)
+          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            return node.content.dup.force_encoding(Encoding::UTF_8)
+          end
+
           # Frequency-ordered: elements dominate reads; they paid
           # three failed compares to reach the else arm. The
           # duplicated branch bodies are the point.
@@ -837,6 +1093,7 @@ module Moxml
         end
 
         def inner_text(node)
+          node = to_binding(node) if NATIVE_READ_LAYER
           # moxml semantic: direct text children only — no descendant
           # text (that is #text), no comments. Entity references
           # contribute their serialized form.
@@ -851,6 +1108,7 @@ module Moxml
         end
 
         def set_text_content(node, content)
+          node = to_binding(node) if NATIVE_READ_LAYER
           case node
           when ::Leptris::XML::Document
             node.root&.content = content.to_s
@@ -899,6 +1157,7 @@ module Moxml
         end
 
         def namespace_definitions(element)
+          element = to_binding(element) if NATIVE_READ_LAYER
           element.namespace_definitions
         end
 
@@ -929,6 +1188,7 @@ module Moxml
         NATIVE_GATE_CACHE = XPath::Cache.new(100)
 
         def xpath(node, expression, namespaces = {})
+          node = to_binding(node) if NATIVE_READ_LAYER
           native = native_xpath(node, expression, namespaces)
           return native unless native.nil?
 

data/lib/moxml/adapter/libxml.rb

@@ -312,7 +312,7 @@ module Moxml
           # Native documents are read-only, do nothing for them
         end
 
-        def children(node)
+        def children(node, **_entity_bearing)
           native_node = unpatch_node(node)
           return [] unless native_node
 

data/lib/moxml/adapter/nokogiri.rb

@@ -248,7 +248,7 @@ module Moxml
           node.name = name
         end
 
-        def children(node)
+        def children(node, **_entity_bearing)
           node.children
         end
 

data/lib/moxml/adapter/oga.rb

@@ -232,7 +232,7 @@ module Moxml
           node.name = name
         end
 
-        def children(node)
+        def children(node, **_entity_bearing)
           all_children = []
 
           if node.is_a?(::Oga::XML::Document)

data/lib/moxml/adapter/ox.rb

@@ -298,7 +298,7 @@ module Moxml
           end
         end
 
-        def children(node)
+        def children(node, **_entity_bearing)
           return [] unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
           result = node.nodes || []

data/lib/moxml/adapter/rexml.rb

@@ -188,7 +188,7 @@ module Moxml
           end
         end
 
-        def children(node)
+        def children(node, **_entity_bearing)
           return [] unless node.is_a?(::REXML::Parent)
 
           # Return all children preserving whitespace text nodes

data/lib/moxml/c14n.rb

@@ -66,7 +66,7 @@ module Moxml
       return nil unless adapter == Moxml::Adapter::Leptris &&
         Moxml::Adapter::Leptris.native_c14n_byte_safe?
 
-      node_or_xml.native.canonicalize(
+      Moxml::Adapter::Leptris.to_binding(node_or_xml.native).canonicalize(
         ::Leptris::XML::FFI::C14N_1_0, nil,
         mode: ::Leptris::XML::FFI::C14N_MODE_CANONICAL
       )

data/lib/moxml/node.rb

@@ -54,7 +54,10 @@ module Moxml
 
     def children
       @children ||= begin
-        natives = adapter.children(@native)
+        # The wrapper's entity memo decides the marker split; the
+        # adapter would otherwise re-derive it per call (a C parent
+        # climb on the native layer).
+        natives = adapter.children(@native, entity_bearing: entity_bearing?)
         natives = natives.map { adapter.patch_node(_1, @native) } if adapter.patches_children?
         NodeSet.new(natives, context, self)
       end
@@ -150,10 +153,24 @@ module Moxml
         @entity_bearing
       else
         @entity_bearing_gen = gen
-        @entity_bearing = adapter.entity_bearing?(@native)
+        @entity_bearing = adapter.entity_bearing?(@native, document_native_for_markers)
       end
     end
 
+    # Binding document through the wrapper parent chain — pure Ruby
+    # attr reads; the native-layer fallback climbs C parents per
+    # call (the doc_for walk was the largest wrapper-layer cost on
+    # the consumer pipeline after the native adoption).
+    def document_native_for_markers
+      node = self
+      while node
+        return node.native if node.document?
+
+        node = node.parent_node
+      end
+      nil
+    end
+
     def xpath(expression, namespaces = {})
       result = adapter.xpath(@native, expression, namespaces)
       # Adapter contract: Array<native> | LazyNodeSet | scalar.
@@ -384,7 +401,11 @@ module Moxml
     end
 
     def ==(other)
-      self.class == other.class && @native == other.native
+      # Native equality goes through the adapter: engines with a
+      # native read layer hand out two wrapper classes over one C
+      # node, and raw native == is false across that seam.
+      self.class == other.class &&
+        adapter.same_node?(@native, other.native)
     end
 
     TYPES.each do |node_type|
@@ -447,7 +468,7 @@ module Moxml
     # Internal: Set the parent node for cache invalidation tracking.
     # Called by NodeSet, Document, Element when establishing parent-child
     # relationships. Public to allow cross-class usage within Moxml internals.
-    attr_writer :parent_node
+    attr_accessor :parent_node
 
     def adapter
       # A context's adapter object is fixed for its lifetime; the

data/lib/moxml/version.rb

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

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

@@ -43,7 +43,7 @@ RSpec.shared_examples "Moxml::NodeSet" do
       it "compares nodes" do
         xpath_results = doc.xpath("//child")
         element_children = doc.root.children.grep(Moxml::Element)
-        expect(xpath_results.map(&:native)).to eq(element_children.map(&:native))
+        expect(xpath_results.to_a).to eq(element_children)
       end
     end
 

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -79,22 +79,20 @@ RSpec.shared_examples "xml adapter" do
       first = children[0]
       second = children[1]
 
-      expect(described_class.next_sibling(first)).to eq(second)
-      expect(described_class.previous_sibling(second)).to eq(first)
+      expect(described_class.same_node?(described_class.next_sibling(first), second)).to be(true)
+      expect(described_class.same_node?(described_class.previous_sibling(second), first)).to be(true)
     end
 
     it "adds child" do
       element = described_class.create_element("new")
       described_class.add_child(root, element)
-      expect(described_class.children(root).last).to eq(element)
+      expect(described_class.same_node?(described_class.children(root).last, element)).to be(true)
     end
 
     it "adds text child" do
       described_class.add_child(root, "text")
-      # a workaround for Rexml until we convert tests to work with Moxml wrappers
       last_child = described_class.children(root).last
-      last_text = last_child.respond_to?(:text) ? last_child.text : last_child.to_s
-      expect(last_text).to eq("text")
+      expect(described_class.text_content(last_child)).to eq("text")
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.35
+  version: 0.5.36
 platform: ruby
 authors:
 - Ribose Inc.