moxml 0.5.55 → 0.5.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ded5e928e12262125965a33ed378e35d8ecc85c3e65de4d514a1fefe0ddd9458
-  data.tar.gz: b86296c3c0402915fc455696b9bd76b7892a08f58ec8fa9d8ac043fcd36784f4
+  metadata.gz: d4db82d82671fd5cc6189294198abf6d019cd9a719dd25eff901227ebd6c411e
+  data.tar.gz: 34611277972cb9687a3b1350ee4a9d5d3036c432fb2ed89409492a2bae812821
 SHA512:
-  metadata.gz: 8a29c038b4e5290a47acab859cf99796e9b653eb991f12e34539871e3dc8f02a6d3e2c66b312db64d87488a308bbb93f365dd5e4294e75fa329a5bfcb77bb174
-  data.tar.gz: ddfecce2232d70546ed2ac42c9ba5eb000e1d98cee79a00047f0a2927fcb47e40b27b4b35fb282f8086b805428062e664a3652673195e67a6fa7596907579063
+  metadata.gz: 22ee802575e1c85d3f2a03981ed0fce5ed24e23576d005bbf08861e06051026b23276977a8cdedc3340709ea617fcd8a01cade368f74083d4a05728b6dd5f9f0
+  data.tar.gz: 43b6109e181270728559005b64e7e8b728a38403b2230f2c868b125def432ceddc5e9e1e468ad6afebcb2a073c9d5e9f69da48acae2499218dbe7c12a81a61aa

data/Gemfile

@@ -9,7 +9,7 @@ gemspec
 gem "benchmark"
 gem "benchmark-ips"
 gem "get_process_mem"
-gem "leptris", "~> 1.9.174.1"
+gem "leptris", "~> 1.9.174"
 gem "libxml-ruby", ">= 5.0"
 gem "nokogiri", "~> 1.18"
 gem "openssl", "~> 3.0"

data/lib/moxml/adapter/base.rb

@@ -164,6 +164,14 @@ module Moxml
           nil
         end
 
+        # Source position {line, col_start, col_end} for a node where
+        # the engine exposes it (leptris 1.9.181+ source_position);
+        # nil elsewhere and for nodes without a position (created
+        # nodes answer zeros upstream — pass those through as-is).
+        def source_position(_native)
+          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

data/lib/moxml/adapter/leptris.rb

@@ -103,6 +103,12 @@ module Moxml
         NN_ADD_CHILD = NN.instance_method(:add_child)
       end
 
+      # 1.9.181 (lockstep): Node#source_position — {line, col_start,
+      # col_end} from the engine's source-position API (upstream
+      # #1124); created nodes report zeros.
+      NATIVE_SOURCE_POSITION =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.181")
+
       # Entity-reference preservation (leptris-ruby#212 / upstream
       # #1094): 1.9.177 ships ParseOptions.keep_entity_refs plus
       # first-class EntityReference nodes — the marker machinery
@@ -592,7 +598,21 @@ module Moxml
         # entity-marker splitting applies.
         def parse_fragment(xml, _context = nil)
           doc = parse("<m>#{xml}</m>")
-          children(doc.native.root)
+          # Lifetime seam (#245): the fragment's natives live in the
+          # parse document's C tree, and the binding Document is the
+          # sole owner with a GC finalizer. The parent_node chain
+          # (fragment -> synthetic <m> -> Document wrapper) keeps the
+          # owning wrappers strongly reachable from every returned
+          # node; the wrappers are minted HERE and returned as-is —
+          # re-wrapping at the caller would race the context map's
+          # weak values and silently drop the chain.
+          root_wrapper = doc.root
+          root_wrapper.parent_node = doc
+          children(root_wrapper.native).map do |child|
+            wrapped = Node.wrap(child, doc.context)
+            wrapped.parent_node = root_wrapper
+            wrapped
+          end
         end
 
         def iterparse(xml, mode = :top_level, _context = nil, &block)
@@ -788,6 +808,10 @@ module Moxml
 
           element = node
           if namespace.nil?
+            # Supported un-prefix (#245, relaton migration): rename
+            # the node to its local part (name = local) — the
+            # serializer re-attaches the old prefix after namespace=
+            # nil on prefixed elements until leptris-ruby#244 lands.
             # Nil-clear contract (issue #164): undeclare the default
             # namespace (xmlns="") and drop any name prefix — the
             # element then reports no namespace, matching the other
@@ -1238,6 +1262,12 @@ module Moxml
           r
         end
 
+        def source_position(node)
+          return nil unless NATIVE_SOURCE_POSITION
+
+          to_binding(node).source_position
+        end
+
         def line_number(node)
           if NATIVE_MUTATIONS_COHERENT &&
               node.is_a?(::Leptris::XML::NativeNode)
@@ -1347,7 +1377,17 @@ module Moxml
             node.document.add_pi(new_node.target, new_node.content.to_s)
             return new_node
           end
-          node.add_previous_sibling(new_node)
+          return node.add_previous_sibling(new_node) if node.is_a?(::Leptris::XML::Element)
+
+          # Non-element receivers: raw-FFI anchor (issue #245, same
+          # shape as add_next_sibling).
+          adopt_for_sibling_insert(new_node, node)
+          ::Leptris::XML::FFI.check_status(
+            ::Leptris::XML::FFI.leptris_element_insert_before(
+              node.c_ptr, new_node.c_ptr
+            ),
+          )
+          new_node
         end
 
         def add_next_sibling(node, new_node)
@@ -1355,7 +1395,31 @@ module Moxml
             node = to_binding(node)
             new_node = to_binding(new_node)
           end
-          node.add_next_sibling(new_node)
+          return node.add_next_sibling(new_node) if node.is_a?(::Leptris::XML::Element)
+
+          # Non-element receivers (Text/Comment/CDATA): the binding's
+          # method is Element-only, but the C insert anchors on any
+          # node — route through the FFI entry directly, keeping the
+          # binding's namespace-lift adoption for element inserts
+          # (issue #245).
+          adopt_for_sibling_insert(new_node, node)
+          ::Leptris::XML::FFI.check_status(
+            ::Leptris::XML::FFI.leptris_element_insert_after(
+              node.c_ptr, new_node.c_ptr
+            ),
+          )
+          new_node
+        end
+
+        # The binding's add_*_ sibling methods lift an adopted
+        # element's namespace declarations into the target scope;
+        # the raw-FFI path above must preserve that.
+        def adopt_for_sibling_insert(new_node, anchor)
+          return unless new_node.is_a?(::Leptris::XML::Element)
+          return if ::Leptris::XML::Element.skip_adoption_lift?(new_node)
+
+          scope = anchor.parent.is_a?(::Leptris::XML::Element) ? anchor.parent.namespaces : {}
+          ::Leptris::XML::Element.lift_namespaces_for_adoption(new_node, scope)
         end
 
         def remove(node)

data/lib/moxml/context.rb

@@ -124,8 +124,11 @@ module Moxml
     # 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)
+      adapter.parse_fragment(xml, self).map do |node|
+        # Adapters that tie a parent_node lifetime chain (#245)
+        # return wrapped nodes — pass them through untouched;
+        # re-wrapping would race the weak wrapper map.
+        node.is_a?(Moxml::Node) ? node : Moxml::Node.wrap(node, self)
       end
     end
 

data/lib/moxml/node.rb

@@ -402,6 +402,14 @@ module Moxml
       adapter.line_number(@native)
     end
 
+    # {line, col_start, col_end} where the engine exposes source
+    # positions (leptris 1.9.181+); nil elsewhere. Created nodes
+    # answer zeros upstream — distinguishable from nil by callers
+    # that care.
+    def source_position
+      adapter.source_position(@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

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -672,6 +672,39 @@ RSpec.describe Moxml::Adapter::Leptris do
     end
   end
 
+  describe "adapter seams from the relaton migration (issue #245)" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "keeps parse_fragment nodes' owning document alive" do
+      nodes = ctx.parse_fragment("<em>x</em>")
+      element = nodes.first
+      expect(element.parent_node).not_to be_nil
+      GC.start
+      GC.start
+      expect(element.name).to eq("em")
+      expect(element.text).to eq("x")
+      document = element.document
+      expect(document.children.first.name).to eq("m")
+      expect(document.children.first.children.first.name).to eq("em")
+    end
+
+    it "inserts siblings after a text node" do
+      doc = ctx.parse("<root><p>a<!--c1-->b</p></root>")
+      paragraph = doc.root.children.first
+      cursor = paragraph.children.first
+      cursor.add_next_sibling(doc.create_text("Z"))
+      expect(paragraph.to_xml).to eq("<p>aZ<!--c1-->b</p>")
+    end
+
+    it "inserts siblings before a text node" do
+      doc = ctx.parse("<root><p><!--c1-->ab</p></root>")
+      paragraph = doc.root.children.first
+      cursor = paragraph.children.last
+      cursor.add_previous_sibling(doc.create_text("Y"))
+      expect(paragraph.to_xml).to eq("<p><!--c1-->Yab</p>")
+    end
+  end
+
   describe "to_binding is defined regardless of the native layer (issue #217)" do
     it "is the identity for binding nodes" do
       ctx = Moxml.new(:leptris)
@@ -694,6 +727,25 @@ RSpec.describe Moxml::Adapter::Leptris do
     end
   end
 
+  describe "source_position (leptris 1.9.181+, upstream #1124)" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "answers engine source positions for parsed nodes" do
+      skip "requires leptris 1.9.181" unless described_class::NATIVE_SOURCE_POSITION
+
+      doc = ctx.parse("<root>\n  <child>text</child>\n</root>")
+      expect(doc.root.source_position).to include(line: 1)
+      expect(doc.root.source_position).to be_a(Hash)
+    end
+
+    it "answers nil below the gate and on other adapters" do
+      expect(Moxml::Adapter::Base.source_position(nil)).to be_nil
+      expect(Moxml::Adapter::Nokogiri.source_position(nil)).to be_nil
+      noko = Moxml.new(:nokogiri).parse("<root><a/></root>")
+      expect(noko.root.children.first.source_position).to be_nil
+    end
+  end
+
   describe "subtree digest (issue #173, leptris#869)" do
     let(:ctx) { Moxml.new(:leptris) }
 

metadata

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