moxml 0.5.147 → 0.5.148

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e5797a825682b992d84b5ab9155d74f81fdeca24293b40ad7b9e58860c407f0
-  data.tar.gz: 11accb2da9da7cf656d28ab7e128da698f1702120332d94d06b4a20ea39ad112
+  metadata.gz: 1b51347e90c3dae3f4b0b41268b4ee8cd92fa91a4210a17b1ea75da85db0f82a
+  data.tar.gz: d251705fd512baed6295dad6a56c12e7db531dfa4845b2f77983c9c305bfaffd
 SHA512:
-  metadata.gz: 2b8980eb872815020ed2b6d582172ffd62c08a426c2fa2104bd891cd5e2f1e69392fd82d9573215383399087cb686852c47fb10e1d93e812c1641f8eb5e4eeef
-  data.tar.gz: 924b76844411af051e0a9b02ea55788dbc4f5d0e6ec0be31ade4ded2c17c6c6e58356f687ef42e2d7934a4a8f684720f77b0d7688e108437aa64c68a41b68d06
+  metadata.gz: 8ffcc8a80a304b656005d171627c40a982ba1b1594bbd2cb9090f390150f799b69041e338a54d2e79245a3fdf526639406938f4fdd82b290f55092c43ac20f34
+  data.tar.gz: 764dd4cd2fa5346a701224b7841ff0fb7cfced542b68ad914f4200acda168c5060813cb737429a5bcfd67eca12e74870b8bc4449bc83214678f5c86beaf3aa8c

data/lib/moxml/adapter/leptris.rb

@@ -105,6 +105,9 @@ module Moxml
         ::Leptris::XML::Document.method(:parse)
           .parameters.any? { |_, key| key == :strict }
 
+      ADD_CHILD_NATIVE =
+        NATIVE_READ_LAYER && NN.method_defined?(:add_child_native)
+
       if NATIVE_READ_LAYER
         NN_ATTRIBUTE = NN.instance_method(:attribute)
         NN_NAME = NN.instance_method(:name)
@@ -624,6 +627,31 @@ module Moxml
               end
               TEXT.include(TextContractReads)
             end
+
+            # leptris-ruby#507: children_read joins the alias set. The
+            # generation-checked memo STAYS — re-walks of the same
+            # document are the common harness/consumer shape and the
+            # memo serves them allocation-free (dropping it regressed
+            # the walk 2x in GC). Only the MISS gets cheaper: the
+            # klass-children face plain-dispatches and returns the
+            # already-minted wrappers, so the adapter crossing
+            # (bind_call + to_a + keep-refs probe) drops out, and
+            # entity-marker documents take super for the split.
+            if NN.method_defined?(:children_read)
+              module ChildReads
+                def children
+                  @children = nil if @children_gen != context.children_generation
+                  @children_gen = context.children_generation
+                  @children ||= if doc_entity_bearing?
+                                  super
+                                else
+                                  NodeSet.new(children_read, context, self)
+                                end
+                end
+              end
+              ELEMENT.include(ChildReads)
+              TEXT.include(ChildReads)
+            end
           end
 
           # leptris-ruby#246 klass-propagating reads: the read
@@ -1464,6 +1492,14 @@ module Moxml
           count = ffi.leptris_document_parse_diag_count(doc)
           return [] if count.zero?
 
+          # leptris#1771: one face carries the diag's machine-readable
+          # code plus line/column with the entry (nil when the engine
+          # has no token code — pre-#1771 records). The face probe
+          # keeps older bindings on kind+message (issue #408).
+          lint_code = if ffi.respond_to?(:leptris_document_parse_diag_code)
+                        ffi.method(:leptris_document_parse_diag_code)
+                      end
+
           kind_ptr = ::FFI::MemoryPointer.new(:int)
           diagnostics = []
           count.times do |i|
@@ -1473,7 +1509,19 @@ module Moxml
             ) == 1
 
             kind = DIAG_KINDS[kind_ptr.read_int] || :unknown
-            diagnostics << { kind: kind, message: buffer.read_string }
+            diag = { kind: kind, message: buffer.read_string }
+            if lint_code
+              code_buf = ::FFI::MemoryPointer.new(:char, 128)
+              line_ptr = ::FFI::MemoryPointer.new(:int)
+              column_ptr = ::FFI::MemoryPointer.new(:int)
+              lint_code.call(doc, i, code_buf, 128, line_ptr, column_ptr)
+              code = code_buf.read_string
+              diag[:code] = code.empty? ? nil : code
+              diag[:line] = line_ptr.read_int.zero? ? nil : line_ptr.read_int
+              diag[:column] =
+                column_ptr.read_int.zero? ? nil : column_ptr.read_int
+            end
+            diagnostics << diag
           end
           diagnostics
         end
@@ -2496,6 +2544,27 @@ module Moxml
         end
 
         def add_child(parent, child)
+          # Same-document Identity append — the builder hot path. One
+          # document pair decides the verdict: the pin, the absorb
+          # checks and the binding bridges only exist for
+          # cross-document work, and the plain C append (version bump
+          # inside) is the whole job. bind_call, not dispatch — the
+          # contract modules shadow add_child on Identity receivers
+          # (moxml#2560 note below).
+          if NATIVE_MUTATIONS_COHERENT && parent.is_a?(NN) && child.is_a?(NN) &&
+              !child.is_a?(CustomizedLeptris::EntityReference)
+            parent_doc = NN_DOCUMENT.bind_call(parent)
+            if parent_doc
+              child_doc = NN_DOCUMENT.bind_call(child)
+              if child_doc && parent_doc.equal?(child_doc)
+                # add_child_native (leptris-ruby#509) plain-dispatches
+                # on Identity receivers — one frame, no bind_call.
+                return parent.add_child_native(child) if ADD_CHILD_NATIVE
+
+                return NN_ADD_CHILD.bind_call(parent, child)
+              end
+            end
+          end
           # 1.9.311: binding-family children (created PIs, texts...) —
           # a DIRECT absorb makes the binding add below move the node
           # by reference. A source already owned elsewhere would need

data/lib/moxml/document.rb

@@ -163,11 +163,21 @@ module Moxml
     end
 
     def create_element(name)
-      Wrappers::Element.new(adapter.create_element(name, owner_doc: @native), context)
+      native = adapter.create_element(name, owner_doc: @native)
+      # leptris-ruby#508 mints registered klasses at create: the node
+      # IS a contract-carrying identity (@native is self) — prime it
+      # in place instead of shelling a second wrapper (a raw mint
+      # reaching ==/adapter dies on the nil @context).
+      return native.prime_contract(native, context, adapter) if native.is_a?(Moxml::Node)
+
+      Wrappers::Element.new(native, context)
     end
 
     def create_text(content)
-      Wrappers::Text.new(adapter.create_text(content, owner_doc: @native), context)
+      native = adapter.create_text(content, owner_doc: @native)
+      return native.prime_contract(native, context, adapter) if native.is_a?(Moxml::Node)
+
+      Wrappers::Text.new(native, context)
     end
 
     def create_cdata(content)
@@ -227,9 +237,13 @@ module Moxml
         raise Error, "Document already has a root element"
       else
         adapter.add_child(@native, node.native)
-        # Refresh native for adapters where identity changes (e.g., LibXML doc.root=)
+        # Refresh native for adapters where identity changes (e.g., LibXML doc.root=).
+        # Native equality via the adapter, not wrapper !=: re-mints can
+        # arrive without context primed (1.9.373 actual_native), and
+        # wrapper == dispatches through the adapter (issue #409-class).
         refreshed = adapter.actual_native(node.native, @native)
-        node.refresh_native!(refreshed) if refreshed && refreshed != node.native
+        node.refresh_native!(refreshed) if refreshed &&
+          !adapter.same_node?(refreshed, node.native)
       end
       node.parent_node = self
       invalidate_children_cache!

data/lib/moxml/node.rb

@@ -847,6 +847,18 @@ module Moxml
     def self.wrap_with(node, context, adapter)
       return nil if node.nil?
 
+      # Identity natives ARE the canonical wrapper (leptris C-mint):
+      # @native is self, so canonicalization, the cache probes and
+      # the re-mint below all answer the receiver. One native ivar
+      # read decides; shells (@native != self) take the full path.
+      # The C mint leaves the node un-primed (@context unset) — prime
+      # on first wrap. Conditionally: an already-primed identity (a
+      # walked node) must not lose @parent_node to a re-prime.
+      if node.is_a?(Node) && node.instance_variable_get(:@native).equal?(node)
+        node.prime_contract(node, context, adapter) unless node.instance_variable_defined?(:@context)
+        return node
+      end
+
       # One C node may have several Ruby representations (leptris
       # native/binding duality, moxml#311); every wrap resolves to
       # the canonical one so memo holders share one invalidation

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_contract_reads_spec.rb

@@ -130,4 +130,33 @@ RSpec.describe "leptris Identity contract reads" do
       expect(el.text).to eq("v")
     end
   end
+
+  describe "children" do
+    it "answers without the adapter children crossing (children_read)" do
+      unless Leptris::XML::NativeNode.method_defined?(:children_read)
+        skip "binding #{Leptris::VERSION} has no children_read face"
+      end
+      doc = ctx.parse("<root><item>v</item></root>")
+      el = doc.root.children.first
+
+      singleton = Moxml::Adapter::Leptris.singleton_class
+      singleton.send(:alias_method, :children_without_walk, :children)
+      singleton.send(:define_method, :children) { |*| raise "adapter children crossing" }
+      begin
+        kids = el.children
+        expect(kids.to_a.map(&:name)).to eq(["text"])
+      ensure
+        singleton.send(:alias_method, :children, :children_without_walk)
+        singleton.send(:remove_method, :children_without_walk)
+      end
+    end
+
+    it "returns a NodeSet carrying the contract wrappers" do
+      doc = ctx.parse("<root><item>v</item></root>")
+      kids = doc.root.children.first.children
+      expect(kids).to be_a(Moxml::NodeSet)
+      expect(kids.to_a.first.name).to eq("text")
+      expect(kids.to_a.first.content).to eq("v")
+    end
+  end
 end

data/spec/moxml/adapter/leptris_detached_text_spec.rb

@@ -10,13 +10,20 @@ require "spec_helper"
 RSpec.describe "detached text content= names the cause" do
   let(:ctx) { Moxml.new(:leptris) }
 
-  it "raises a named Moxml error for a removed text node" do
+  it "answers removed text nodes: mutable on fixed engines (1.9.374+), named error before" do
     doc = ctx.parse("<r><a>x</a><b>y</b></r>")
     text = doc.root.children[0].children[0]
     text.remove
 
-    expect { text.content = "z" }
-      .to raise_error(Moxml::Error, /detached \(parentless\).*issue #401/)
+    if Gem::Version.new(Leptris::VERSION) >= Gem::Version.new("1.9.374")
+      # leptris/leptris#1785 fixed the engine root cause: detached
+      # text resolves its owning document, so the mutation succeeds.
+      text.content = "z"
+      expect(text.content).to eq("z")
+    else
+      expect { text.content = "z" }
+        .to raise_error(Moxml::Error, /detached \(parentless\).*issue #401/)
+    end
   end
 
   it "keeps created-unattached nodes mutable" do

data/spec/moxml/adapter/leptris_parse_lint_spec.rb

@@ -23,6 +23,18 @@ RSpec.describe "parse_html collect_errors forwarding" do
     expect(diags.first).to have_key(:message)
   end
 
+  # Issue #408: the #1771 reader fields ride the diag hash — the
+  # token code and position canon's HtmlValidator maps onto
+  # validation errors (nil where the engine has no token code).
+  it "carries the token code and position (issue #408)" do
+    doc = ctx.parse_html(src, collect_errors: true)
+    eof = doc.parse_diagnostics.find { |d| d[:message].include?("EOF") }
+    expect(eof).not_to be_nil
+    expect(eof[:code]).to eq("eof-in-tag")
+    expect(eof[:line]).to eq(1)
+    expect(eof[:column]).to eq(1)
+  end
+
   it "keeps the default lane silent (no option, no diagnostics)" do
     doc = ctx.parse_html(src)
     expect(doc.parse_diagnostics).to be_empty

metadata

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