moxml 0.5.48 → 0.5.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbe45e0b5017c94650ed10dde4e726843ad5a820005ac4a1f653d5747ef04f71
-  data.tar.gz: 14f003f4f15ff1b9a40429654a7435485cb20ca62e88f6b9dc21e1120e9c85dd
+  metadata.gz: '0188508b255f1adb8c622a2965a91352c7ffc63afd79d53796ad48c708d479eb'
+  data.tar.gz: 16f4ce7dfbd8a335dfd535bca051288f8a5645a273d7aea9be8fa2d245073482
 SHA512:
-  metadata.gz: b6bcf2d9d9b6a34bbd56afc5076421c22e107ac33e9a8adc06ebe0329b7cab59e038ace45e0cb2d14debe8ba16c8cd606af49d8994bf59137e51d2679487295d
-  data.tar.gz: 22ea33b5bc99974709cc8cbcf670dc39fdce033fcce310353cda9aa15568129a283055a8e8975f211d67a8167fa6f87597db0d81e4935f77864a6d58ccc1a9dd
+  metadata.gz: 13d1a513fecc2d4e23ee833929b05b2c93d77b4567623246f22f4ddb8f3461a2661f69a1cc73b091b08ab6474b40f929ecf4272ba54112f313ba936598761b81
+  data.tar.gz: 76ef5828a376dd566c1945a8655e71fe5d8a68f7a8a007a1260855a05ebcec442034712370e3e9decc5d07490ea2f9ce534b49c5c036df41e6b291868698927f

data/lib/moxml/adapter/base.rb

@@ -141,6 +141,14 @@ module Moxml
           nil
         end
 
+        # Subtree walk capability: an adapter with a C-side pre-order
+        # traversal (leptris >= 1.9.174.6 visit) walks descendants in
+        # one dispatch; nil keeps the recursive children walk. Self
+        # is not yielded (each_node semantics).
+        def walk_descendants(_native, _context)
+          nil
+        end
+
         def same_node?(one, other)
           one == other
         end

data/lib/moxml/adapter/leptris.rb

@@ -159,21 +159,116 @@ module Moxml
           # 3-4 Ruby frames collapse to the module call over the C
           # method. @native is self; every adapter method that accepts
           # a native already handles NativeNode receivers.
-          # Extend-in-place mint (#230 stage 2): disabled by
-          # measurement. Extending TypedData natives with the
-          # contract modules works correctly (full battery + lm
-          # 5422/0 under identity mode) but each extend allocates a
-          # singleton plus per-module iclasses — the consumer
-          # pipeline regressed 4017us -> 16350us with 6x the
-          # allocations on a 900-node walk. The per-read frame
-          # savings (~50ns) cannot repay that mint cost. Revisit
-          # when the binding grows klass-injection
-          # (NativeNode.from(doc, ptr, klass:) minting the
-          # contract-carrying subclass in C) — asked upstream in the
-          # #230 thread. Wrappers mint through the Wrappers:: shells
-          # meanwhile.
-          def wrap_native(_node, _type, _context)
-            nil
+          # Identity mode v2 (#230): wrapper classes SUBCLASS the
+          # TypedData native and include the contract modules, and
+          # NativeNode.from honors its receiver (klass-injection,
+          # 1.9.174.4+): the C wrap mints our class directly — no
+          # Ruby-level extend (the v1 extend mint regressed the
+          # pipeline 4x; this is the same TypedData wrap the base
+          # mint pays). @native is self; the adapter's C-surface
+          # bind_calls accept these receivers (they are NativeNode
+          # instances). The hot bare reads super into the C methods
+          # (exact-name = the bare-name contract).
+          module Identity
+            ELEMENT = Class.new(::Leptris::XML::NativeNode) do
+              include ::Moxml::Node
+              include ::Moxml::Element
+            end
+            TEXT = Class.new(::Leptris::XML::NativeNode) do
+              include ::Moxml::Node
+              include ::Moxml::Text
+            end
+            CDATA = Class.new(::Leptris::XML::NativeNode) do
+              include ::Moxml::Node
+              include ::Moxml::Cdata
+            end
+            COMMENT = Class.new(::Leptris::XML::NativeNode) do
+              include ::Moxml::Node
+              include ::Moxml::Comment
+            end
+            PROCESSING_INSTRUCTION = Class.new(::Leptris::XML::NativeNode) do
+              include ::Moxml::Node
+              include ::Moxml::ProcessingInstruction
+            end
+
+            TYPES = {
+              element: ELEMENT,
+              text: TEXT,
+              cdata: CDATA,
+              comment: COMMENT,
+              processing_instruction: PROCESSING_INSTRUCTION,
+            }.freeze
+
+            module Reads
+              # The C methods sit BELOW the contract modules in the
+              # ancestry (NativeNode is the superclass), so super
+              # from here would run the contract implementation and
+              # ADD frames. bind_call reaches the C surface
+              # directly; prefixed names take the contract path.
+              ELEMENT_CONTRACT_READ =
+                ::Moxml::ElementBehavior.instance_method(:[])
+
+              def [](key)
+                if key.is_a?(String) && !key.include?(":")
+                  value = NN_ATTRIBUTE.bind_call(self, key)
+                  return value unless value.is_a?(String) && entity_bearing?
+
+                  return ::Moxml::Adapter::Leptris.restore_entities(value)
+                end
+
+                ELEMENT_CONTRACT_READ.bind_call(self, key)
+              end
+
+              def text
+                value = NN_CONTENT.bind_call(self)
+                value.is_a?(String) && entity_bearing? ? ::Moxml::Adapter::Leptris.restore_entities(value) : value
+              end
+            end
+            ELEMENT.include(Reads)
+            TEXT.include(Reads)
+          end
+
+          NATIVE_IDENTITY =
+            NATIVE_MUTATIONS_COHERENT &&
+            Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.174.4")
+
+          def wrap_native(node, type, _context)
+            return nil unless NATIVE_IDENTITY &&
+              node.is_a?(::Leptris::XML::NativeNode)
+
+            # from() registers in the shared address-keyed native
+            # cache, so later canonical/bulk mints hand OUR instance
+            # back — a native already carrying the contract IS the
+            # wrapper; minting again would loop per access.
+            return node if node.is_a?(::Moxml::Node)
+
+            klass = Identity::TYPES[type]
+            return nil unless klass
+
+            doc = doc_for(node)
+            return nil unless doc
+
+            klass.from(doc, node)
+          end
+
+          NATIVE_C_WALK =
+            defined?(::Leptris::XML::NativeNode) &&
+            Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.174.6")
+
+          # One C visit walk (TODO.perf/27: post-order/abort state in
+          # the C callback, rb_yield direct — no FFI closure per
+          # node) instead of per-level children walks. Pre-order via
+          # entering; depth 0 is the receiver and stays unyielded.
+          def walk_descendants(native, context)
+            return nil unless NATIVE_C_WALK
+
+            root = to_binding(native)
+            return nil unless root.is_a?(::Leptris::XML::Element) ||
+              root.is_a?(::Leptris::XML::Document)
+
+            root.visit do |node, entering, depth|
+              yield Moxml::Node.wrap(node, context) if entering && depth.positive?
+            end
           end
 
           def record_native_doc(root_native, doc)

data/lib/moxml/node.rb

@@ -278,6 +278,19 @@ module Moxml
     # Recursively yield all descendant nodes
     # Used by XPath descendant-or-self and descendant axes
     def each_node(&block)
+      unless block
+        # Eager materialization: the leptris C-side walk rb_yields
+        # from the C callback and segfaults across fiber-suspended
+        # enumerator frames, so the no-block form never enters it.
+        nodes = []
+        each_node { |node| nodes << node }
+        return nodes.each
+      end
+
+      # Adapters with a C-side subtree walk take it in one
+      # dispatch; the recursive children walk stays the fallback.
+      return if adapter.walk_descendants(@native, context, &block)
+
       children.each do |child|
         yield child
         child.each_node(&block)

data/lib/moxml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.48
+  version: 0.5.50
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-15 00:00:00.000000000 Z
+date: 2026-09-16 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API