moxml 0.5.104 → 0.5.106

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bbf00c0bac03066dd77a5bb5f952ac786a893d51dd0b18365a67500bdad7a15
-  data.tar.gz: 79d1609f628fcf8b69044ee5a9c990ae347cf0ff11c8b5e2ed2f812bee80ae0e
+  metadata.gz: 28a815d79bd0bc2f356a01f0a4f5337e111ab6bce63f7e8c2f7247efac096b4c
+  data.tar.gz: b0a75eb438464fe9327fdb0420f14be0e8b19fea4252fe8abc995e295a6c6449
 SHA512:
-  metadata.gz: 756a39e9fc200fc4b1a9880f820489684169c3206739d02bb44aad987bfa9b20140a65ae923b29745609fd47407927be9d369f4ed4a64d4129e0f3168f3aec56
-  data.tar.gz: 6efc68d693d8c3b12f90ee4bfed2bf801162b89c7f3a5b0b1fc21eed45183a1ea962d4f2916a30932314208cd5099245a4977a0020b28892a83f4f019b40e03e
+  metadata.gz: 33363ebc463f8e46fbd955ad3adb8f43b01775c27cc72ddaf356e62761e9a7b1917c1c15de36716806a1c306c111368fa0705ec1e37a11fd386f6183c274f291
+  data.tar.gz: aef109c340cdcb4f30a76f87ef05e2568091e01c3dcf815fa2c945ff1cc49a961a0c36e1541f32873cca0226af2bd43a019c7cdac0c5f89b195558c2090a621a

data/lib/moxml/adapter/base.rb

@@ -131,11 +131,29 @@ module Moxml
         def children_accepts_entity_flag?
           return @children_accepts_entity_flag unless @children_accepts_entity_flag.nil?
 
-          kinds = %i[key keyrest keyreq]
+          # Opal records parameter data only when compiling with arity
+          # checking, which is off by default (opal-rspec turns it on, so
+          # the Opal spec run never sees this). Without it
+          # Method#parameters returns a bare JS undefined, which answers no
+          # method call (not even nil?), so it is matched with `case`,
+          # whose Module#=== tolerates it. Without the data the keyword is
+          # assumed: every built-in adapter's #children accepts it.
           @children_accepts_entity_flag =
-            method(:children).parameters.any? do |kind, _name|
-              kinds.include?(kind)
-            end
+            children_params_flag(method(:children).parameters)
+        end
+
+        # The decision over a parameters VALUE, so the Opal shape (a
+        # bare JS undefined, matched by `case`) is spec-able with real
+        # values. Without parameter data the keyword is assumed: every
+        # built-in adapter's #children accepts it.
+        KEYWORD_PARAM_KINDS = %i[key keyrest keyreq].freeze
+
+        def children_params_flag(params)
+          case params
+          when Array
+            params.any? { |kind, _| KEYWORD_PARAM_KINDS.include?(kind) }
+          else true
+          end
         end
 
         # Protocol-level native equality; engines with more than one
@@ -157,6 +175,14 @@ module Moxml
           node
         end
 
+        # Cross-document root adoption: adapters whose engine deep-copies
+        # a foreign root into the target document natively answer the
+        # installed native here (leptris >= 1.9.292, engine #1495);
+        # nil keeps the Ruby splice.
+        def adopt_root(_doc, _element)
+          nil
+        end
+
         # Element-only children: adapters whose engine carries the
         # face override (leptris C filter, nokogiri native); the
         # default type-filters the native child list so non-element

data/lib/moxml/adapter/leptris.rb

@@ -1437,6 +1437,23 @@ module Moxml
           end
         end
 
+        NATIVE_ROOT_ADOPT =
+          NATIVE_READ_LAYER &&
+          Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.292.0")
+
+        # The engine deep-copies the foreign subtree into the target
+        # document's pool (leptris#1495) and the binding memoizes the
+        # INSTALLED handle — a fresh pointer distinct from the consumed
+        # source. Answer the installed binding element; callers re-point
+        # wrappers at it.
+        def adopt_root(doc, element)
+          return nil unless NATIVE_ROOT_ADOPT
+
+          binding_doc = to_binding(doc)
+          binding_doc.root = to_binding(element)
+          binding_doc.root
+        end
+
         # Element-only children through the engine-level filter: the
         # C face mints element-kind natives directly (klass-children),
         # so interleaved text/comment nodes cost nothing. Entity

data/lib/moxml/attribute.rb

@@ -27,19 +27,28 @@ module Moxml
     end
 
     def value
-      val = @native.value.to_s
-      # 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
+      # Engines allocate a fresh String per read (Nokogiri attr.value);
+      # hydration walks re-read the same wrappers, so the value is
+      # memoized. A held wrapper recomputes when its owner element's
+      # value generation moves (element-side writes bump it locally —
+      # a context-wide bump would evict every wrapper per bulk-build
+      # write). Parentless wrappers (xpath ResultAttrs) are immutable
+      # captures and memo unconditionally.
+      if @parent_node
+        generation = @parent_node.attribute_value_generation
+        @value = nil if @value_gen != generation
+        @value_gen = generation
+      end
+      @value ||= begin
+        val = @native.value.to_s
+        parent = @parent_node
+        if parent.nil? || parent.entity_bearing?
+          adapter.restore_entities(val)
+        else
+          val
+        end
       end
     end
-
     alias content value
 
     # Returns raw native value without entity marker restoration.
@@ -55,6 +64,7 @@ module Moxml
       else
         @parent_node&.invalidate_attribute_value_cache!
       end
+      @value = nil
       adapter.set_attribute_value(@native, new_value)
     end
 

data/lib/moxml/document.rb

@@ -29,6 +29,21 @@ module Moxml
         (owner.is_a?(Document) && owner.root.equal?(element))
       if owner.is_a?(Document) && attached &&
           !owner.equal?(self) && element.context.equal?(context)
+        installed = adapter.adopt_root(@native, element.native)
+        if installed
+          # The engine deep-copies the foreign subtree into this
+          # document's pool (leptris >= 1.9.292, engine #1495) and the
+          # binding memoizes the INSTALLED handle — a fresh pointer.
+          # Re-point the source wrapper so later writes reach the live
+          # tree, and recompute its scope-derived memos.
+          unless installed.equal?(element.native)
+            element.refresh_native!(Moxml::Node.wrap(installed, context).native)
+            element.invalidate_namespace_cache!
+          end
+          context.bump_children_generation
+          invalidate_children_cache!
+          return
+        end
         # libleptris refuses a root owned by another document (the
         # engine's set_root ownership check), while Nokogiri adopts.
         # Cross-document CHILD attaches are supported, so build the

data/lib/moxml/element.rb

@@ -189,6 +189,7 @@ module Moxml
                   raise ArgumentError, "children= accepts String, Node, or Array"
                 end
       adapter.replace_children(@native, natives)
+      @text = nil
       context.bump_children_generation
       invalidate_children_cache!
     end
@@ -329,25 +330,48 @@ module Moxml
     end
 
     def text
-      val = adapter.text_content(@native)
-      # 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
+      # Generation-gated memo: engines allocate a fresh String per read
+      # (Nokogiri node.text), and hydration walks re-read the same
+      # wrappers — Element#text was a top string allocation site in
+      # large-document metanorma compiles. Text only changes through
+      # this wrapper's writers (text=/children=), all of which clear
+      # the memo.
+      @text = nil if @text_gen != context.children_generation
+      @text_gen = context.children_generation
+      @text ||= begin
+        val = adapter.text_content(@native)
+        # 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
     end
 
     alias content text
 
     def text=(content)
+      @text = nil
+      # A text write replaces the whole child list; the generation
+      # bump also retires @elements/@children memos across wrappers.
+      context.bump_children_generation
       adapter.set_text_content(@native, normalize_xml_value(content))
       invalidate_children_cache!
     end
 
     alias content= text=
 
+    # Generation-gated memo (the #321 shape): the native read
+    # allocates a fresh String per call and hydration walks re-read
+    # the same wrappers — 122k births over 10 passes of 2,000
+    # elements before this memo, 5 after. All inner-text writers are
+    # children mutations, which bump the children generation.
     def inner_text
-      text = raw_inner_text
-      entity_bearing? ? adapter.restore_entities(text) : text
+      @inner_text = nil if @inner_text_gen != context.children_generation
+      @inner_text_gen = context.children_generation
+      @inner_text ||= begin
+        text = raw_inner_text
+        entity_bearing? ? adapter.restore_entities(text) : text
+      end
     end
 
     # Returns inner text without entity marker restoration.
@@ -363,6 +387,11 @@ module Moxml
     def inner_xml=(xml)
       wrapper = "_moxml_inner_#{Process.pid}_#{object_id}"
       doc = context.parse("<#{wrapper}>#{xml}</#{wrapper}>")
+      @text = nil
+      # Whole-list replacement rides the children generation like
+      # children= does (moxml#310) — text and elements memos across
+      # wrappers recompute on next read.
+      context.bump_children_generation
       adapter.replace_children(@native, doc.root.children.map(&:native))
       invalidate_children_cache!
     end
@@ -415,13 +444,23 @@ module Moxml
     # 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.
+    # Local counter for held Attribute wrappers: value writes bump it
+    # (no context-wide bump — bulk builds would evict every wrapper's
+    # caches per write), and Attribute#value recomputes when its
+    # owner's counter moves.
+    def attribute_value_generation
+      @attribute_value_generation ||= 0
+    end
+
     def invalidate_attribute_value_cache!
       @attribute_cache = nil
+      @attribute_value_generation = attribute_value_generation + 1
     end
 
     def invalidate_local_attribute_cache!
       @attributes = nil
       @attribute_cache = nil
+      @attribute_value_generation = attribute_value_generation + 1
     end
 
     # Called by the namespace-scoped attribute paths (xmlns writes

data/lib/moxml/text.rb

@@ -5,8 +5,14 @@ module Moxml
     include Node
 
     def content
-      text = raw_content
-      entity_bearing? ? adapter.restore_entities(text) : text
+      # Engines allocate a fresh String per read (Nokogiri
+      # node.text); hydration walks re-read the same text wrappers —
+      # this read was the single largest string allocation site in
+      # large-document metanorma compiles. Cleared by content=.
+      @content ||= begin
+        text = raw_content
+        entity_bearing? ? adapter.restore_entities(text) : text
+      end
     end
 
     # Returns raw content without entity marker restoration.
@@ -15,6 +21,7 @@ module Moxml
     end
 
     def content=(text)
+      @content = nil
       adapter.set_text_content(@native, normalize_xml_value(text))
     end
 

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/base_spec.rb

@@ -46,5 +46,19 @@ RSpec.describe Moxml::Adapter::Base do
       expect(Moxml::Adapter::Leptris.children_accepts_entity_flag?).to be(true)
       expect(Moxml::Adapter::Nokogiri.children_accepts_entity_flag?).to be(true)
     end
+
+    it "assumes the keyword when Method#parameters returns no data" do
+      # Opal without arity checking answers a bare JS undefined for
+      # parameters — not even nil?. Exercise the decision through the
+      # real values the probe can see.
+      probe = described_class.children_params_flag(nil)
+      expect(probe).to be(true)
+      expect(described_class.children_params_flag([%i[req node]])).to be(false)
+      expect(
+        described_class.children_params_flag(
+          [%i[req node], %i[key entity_bearing]],
+        ),
+      ).to be(true)
+    end
   end
 end

data/spec/moxml/at_search_spec.rb

@@ -312,6 +312,22 @@ RSpec.describe "Nokogiri-compatible node sugar" do
     end
   end
 
+  describe "Document#root= native adoption re-points the source wrapper" do
+    it "writes through the original wrapper reach the installed tree" do
+      ctx = Moxml.new(:leptris)
+      other = ctx.parse('<r xmlns="urn:x" a="1"><p>hi<b>t</b></p></r>')
+      doc = ctx.create_document
+      src_root = other.root
+      doc.root = src_root
+      # the engine deep-copies; the wrapper now addresses the installed
+      # handle — a later write must serialize into the new document
+      src_root["a"] = "2"
+      expect(doc.to_xml(indent: 0)).to include('a="2"')
+      expect(doc.root["a"]).to eq("2")
+      expect(doc.root.namespace_uri.to_s).to eq("urn:x")
+    end
+  end
+
   describe "Document#root= with a foreign root" do
     it "adopts the subtree from another document" do
       doc = Moxml.parse("<old><x/></old>")
@@ -396,4 +412,50 @@ RSpec.describe "Nokogiri-compatible node sugar" do
       expect(doc.at("//term/definition/p").text).to eq("a")
     end
   end
+
+  describe "wrapper read memos" do
+    it "Element#text memoizes and invalidates on text=/children=" do
+      doc = Moxml.parse("<r><a>x<b>y</b>z</a></r>")
+      a = doc.at("//a")
+      first = a.text
+      expect(a.text).to equal(first)
+      a.text = "new"
+      expect(a.text).to eq("new")
+      a.children = "<c>w</c>"
+      expect(a.text).to eq("w")
+    end
+
+    it "Element#inner_text memoizes and invalidates on child mutations" do
+      doc = Moxml.parse("<r><a>x<b>y</b>z</a></r>")
+      a = doc.at("//a")
+      first = a.inner_text
+      expect(a.inner_text).to equal(first)
+      a.add_child(doc.create_element("c"))
+      expect(a.inner_text).not_to equal(first)
+      a.text = "plain"
+      expect(a.inner_text).to eq("plain")
+    end
+
+    it "Attribute#value memoizes and invalidates on value=" do
+      doc = Moxml.parse(%(<r a="1"/>))
+      attr = doc.root.attributes.first
+      first = attr.value
+      expect(attr.value).to equal(first)
+      attr.value = "2"
+      expect(attr.value).to eq("2")
+      expect(doc.root["a"]).to eq("2")
+    end
+  end
+
+  describe "Text#content memo" do
+    it "memoizes and invalidates on content=" do
+      doc = Moxml.parse("<r>hello</r>")
+      t = doc.root.children.first
+      first = t.content
+      expect(t.content).to equal(first)
+      expect(t.text).to equal(first)
+      t.content = "bye"
+      expect(t.content).to eq("bye")
+    end
+  end
 end

metadata

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