moxml 0.5.113 → 0.5.115

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61331ea3536aa41170080eb6233643b3b48da707d268da9185ed11fbdcad87d
-  data.tar.gz: ef1765b2e2651438c8d38012ea374e2a8b9fe6ebcaff63d2afaf476eb0f727ab
+  metadata.gz: 3269b76bcc581101e3b7f6219c58fc5010752ab1af4f4bb35b8e505989f08e04
+  data.tar.gz: 1c255835027897f446de2bb88b175a5b71432636b2a7ab3810480323865a4dac
 SHA512:
-  metadata.gz: 2058949ca13a105d38f86b5c38acf3fb974ca9445faedda64ea7d857bf8f10561d5b6df42d7b56ede501d0fcb9186f0347349faee29dd66868b83ec47a94ac4c
-  data.tar.gz: c7c7b4f0b0d529ec793e790072d2115fe6ff7c17a389e08a84abadc2ab324e058f4f49d1e5d5a6e1143b0f688ac893b5ebae083638f1482b9b526b99d7c636fd
+  metadata.gz: 12d97fd4ae488aee81c5e04e5b55be1336bea7bad60f14fc2481ee9fdd80689edac7dfc3113a6dc65be605a555d388d10e89566a206993c84438d0fcbd9e8d41
+  data.tar.gz: 1bf50772dde870a02dd80c1d4d686d2d47149b1d4b9210113bed8e2732dec6c48291105ee26969c92c1d46d6f7086931516c0f6110ce868d662cb2bfa1ea2871

data/.rubocop.yml

@@ -23,6 +23,10 @@ AllCops:
 # the zero-allocation streaming form (issue #143). One parameter per
 # record key is the interface; a shorter list would need a wrapper
 # object, which is the allocation the API exists to avoid.
+Metrics/BlockLength:
+  Exclude:
+    - 'Rakefile'
+
 Metrics/ParameterLists:
   Exclude:
     - 'lib/moxml/materializer.rb'

data/Rakefile

@@ -190,7 +190,12 @@ namespace :spec do
 
   desc "Run unit tests only"
   RSpec::Core::RakeTask.new(:unit) do |t|
-    t.pattern = "spec/unit/**/*_spec.rb"
+    # Unit specs live under spec/moxml/ — the stale glob matched
+    # nothing (spec/unit/ holds only the rexml_isolated_test.rb
+    # entity-era investigation artifact), so this leg ran zero
+    # examples and hid the moxml suite from the fast gate.
+    t.pattern = "spec/moxml/**/*_spec.rb"
+    t.exclude_pattern = "spec/moxml/adapter/**/*_spec.rb"
   end
 
   desc "Run adapter tests only"

data/lib/moxml/adapter/base.rb

@@ -13,6 +13,18 @@ module Moxml
       class << self
         include XmlUtils
 
+        # Binding-level markup-accumulating builder face
+        # (leptris 1.9.313, #374 lever 2): nil = the adapter has no
+        # face and the Builder takes the per-node tree path.
+        def builder_face(_native_document)
+          nil
+        end
+
+        # A built subtree carried entity references as marker text —
+        # arm the document's marker restoration (the entity
+        # preservation contract).
+        def mark_entity_markers(_native_document); end
+
         def preprocess_entities(xml)
           Entity.preprocess_entities(xml)
         end

data/lib/moxml/adapter/leptris.rb

@@ -161,6 +161,16 @@ module Moxml
         ::Leptris::XML::Document.method_defined?(:absorb) &&
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.311.3")
 
+      # Markup-accumulating builder face (leptris-ruby#374 lever 2,
+      # binding 1.9.313): the DSL accumulates markup in a plain
+      # String and ONE native crossing (parse + attach) flushes the
+      # whole subtree. See Adapter::Base#builder_face.
+      NATIVE_BUILDER =
+        defined?(::Leptris::XML::Builder) &&
+        defined?(::Leptris::XML::Document) &&
+        ::Leptris::XML::Document.method_defined?(:build) &&
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.313.0")
+
       # XSLT 1.0/2.0/3.0 through the engine's compiled-stylesheet
       # faces (Moxml::XSLT contract). Top-level parameters are not
       # threaded through the faces yet (leptris-ruby#360) — non-empty
@@ -208,6 +218,27 @@ module Moxml
         # (and on installs without the native layer — the constant
         # check short-circuits), a Node.wrap over the shared C
         # pointer for NativeNodes.
+        def builder_face(native_document)
+          return nil unless NATIVE_BUILDER && NATIVE_READ_LAYER
+
+          doc = if native_document.is_a?(NN)
+                  to_binding(native_document)
+                else
+                  native_document
+                end
+          ::Leptris::XML::Builder.new(doc)
+        end
+
+        def mark_entity_markers(native_document)
+          doc = if native_document.is_a?(NN)
+                  to_binding(native_document)
+                else
+                  native_document
+                end
+          attachments.set(doc, :entity_markers, true)
+          bump_serialize_generation
+        end
+
         def to_binding(node)
           return node unless NATIVE_READ_LAYER &&
             node.is_a?(::Leptris::XML::NativeNode)
@@ -1900,6 +1931,16 @@ module Moxml
         # contract); every other kind carries no cross-document
         # identity worth preserving, so reconstruct it in the parent's
         # document through the binding's create faces.
+        def contains_foreign_child?(parent_nn, children)
+          parent_doc = NN_DOCUMENT.bind_call(parent_nn)
+          return false if parent_doc.nil?
+
+          children.any? do |child|
+            child_doc = NN_DOCUMENT.bind_call(child)
+            child_doc && !child_doc.equal?(parent_doc)
+          end
+        end
+
         def rebuild_foreign_child(parent_nn, child_nn)
           doc = NN_DOCUMENT.bind_call(parent_nn)
           rebuilt =
@@ -2348,6 +2389,32 @@ module Moxml
           Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.290.0")
 
         def replace_children(node, new_children)
+          # Cross-pool children: the binding's bulk face adopts per
+          # node and fails on mixed kinds (inner_xml= with
+          # text+elements died with Memory allocation failed —
+          # pre-existing). Rebuild foreign children in this pool
+          # after the clear — fragment children carry no identity
+          # worth preserving; same-document children keep the plain
+          # add, in order.
+          if NATIVE_MUTATIONS_COHERENT && node.is_a?(NN) &&
+              new_children.all?(NN) &&
+              contains_foreign_child?(node, new_children)
+            ::Leptris::XML::FFI.check_status(
+              ::Leptris::XML::FFI.leptris_element_remove_children(
+                ::FFI::Pointer.new(node.address),
+              ),
+            )
+            node_doc = NN_DOCUMENT.bind_call(node)
+            new_children.each do |child|
+              child_doc = NN_DOCUMENT.bind_call(child)
+              if child_doc && !child_doc.equal?(node_doc)
+                rebuild_foreign_child(node, child)
+              else
+                NN_ADD_CHILD.bind_call(node, child)
+              end
+            end
+            return node
+          end
           if NATIVE_READ_LAYER
             node = to_binding(node)
             new_children = new_children.map { |child| to_binding(child) }

data/lib/moxml/builder.rb

@@ -11,14 +11,40 @@ module Moxml
       @context = context
       @current = @document = context.create_document
       @namespaces = {}
+      # Markup-accumulating face (leptris 1.9.313, #374 lever 2):
+      # leaf DSL ops write markup into one String and a single
+      # native crossing flushes the whole subtree at build end.
+      # Tree-only ops (declaration/doctype/PI/entity/namespace)
+      # flush first and run on the document; the face retires after
+      # its first flush.
+      @face = context.config.adapter.builder_face(@document.native)
+      @face_stack = []
+      @face_counts = Hash.new(0)
+      @face_deferred = []
+      @face_entity_markers = false
     end
 
     def build(&block)
       instance_eval(&block)
+      flush_face
       @document
     end
 
+    # Element ops inside a face-accumulated subtree cannot touch the
+    # tree yet (nothing exists until the flush): PIs ride the raw
+    # hatch in exact position; namespace/entity/declaration/doctype
+    # defer to the flush and re-target their element by position (an
+    # element's namespace set is unordered, so deferral is exact;
+    # deferred children land at their element's end).
+    def face_defer(operation, args)
+      @face_deferred << [operation, args, @face_stack.dup]
+    end
+
     def declaration(version: "1.0", encoding: "UTF-8", standalone: nil)
+      args = [version, encoding, standalone]
+      return face_defer(:declaration, args) if @face && @face_stack.any?
+
+      flush_face
       @current.add_child(
         @document.create_declaration(version, encoding, standalone),
       )
@@ -41,34 +67,65 @@ module Moxml
     end
 
     def text(content)
+      return face_content { @face.text(content) } if @face
+
       @current.add_child(@document.create_text(content))
     end
 
     def cdata(content)
+      return face_content { @face.cdata(content) } if @face
+
       @current.add_child(@document.create_cdata(content))
     end
 
     def comment(content)
+      return face_content { @face.comment(content) } if @face
+
       @current.add_child(@document.create_comment(content))
     end
 
     def entity_reference(name)
+      # In-position through the marker face: the reference lands as
+      # marker text exactly where the DSL puts it, and the flush
+      # arms the document's entity-marker restoration.
+      if @face && @face_stack.any?
+        @face.raw("#{Entity::MARKER}#{name};")
+        @face_entity_markers = true
+        return
+      end
+
+      flush_face
       @current.add_child(@document.create_entity_reference(name))
     end
 
     def processing_instruction(target, content)
+      if @face
+        if @face_stack.empty?
+          flush_face
+        else
+          @face.raw("<?#{target} #{content}?>")
+          return
+        end
+      end
       @current.add_child(
         @document.create_processing_instruction(target, content),
       )
     end
 
     def namespace(prefix, uri)
+      return face_defer(:namespace, [prefix, uri]) if @face && @face_stack.any?
+
+      flush_face
       @current.add_namespace(prefix, uri)
       @namespaces[prefix] = uri
     end
 
     # Convenience method for DOCTYPE
     def doctype(name, external_id = nil, system_id = nil)
+      args = [name, external_id, system_id]
+      return face_defer(:doctype, args) if @face && @face_stack.any?
+
+      flush_face
       @current.add_child(
         @document.create_doctype(name, external_id, system_id),
       )
@@ -109,13 +166,139 @@ module Moxml
       true
     end
 
+    FACE_NAME = /\A[a-zA-Z_][\w.-]*\z/
+    FACE_ESCAPE = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
+                    '"' => "&quot;" }.freeze
+    FACE_ESCAPE_RE = /[&<>"]/
+
     private
 
+    # One face.element per DSL element — the face opens/closes the
+    # markup around the block itself, so nesting is free. Prefixed
+    # names (p:tag) fall outside the face's name shape and ride the
+    # raw hatch with manual escaping. Returns no wrapper: nothing
+    # exists until the flush.
+    def face_element(tag_name, attrs, text_content, block, eval_block)
+      unless FACE_NAME.match?(tag_name)
+        return face_raw_element(tag_name, attrs, text_content, block,
+                                eval_block)
+      end
+
+      face_attrs = {}
+      attrs.each do |key, value|
+        k = key.to_s
+        if k == "xmlns" || k.start_with?("xmlns:")
+          face_attrs[k] = value.to_s
+          @namespaces[k.delete_prefix("xmlns:")] = value.to_s
+        else
+          face_attrs[k] = value
+        end
+      end
+      ordinal = @face_counts[@face_stack.length]
+      @face_counts[@face_stack.length] = ordinal + 1
+      @face_stack << ordinal
+      begin
+        @face.element(tag_name, face_attrs) do
+          @face.text(text_content) if text_content
+          run_builder_block(block, eval_block) if block
+        end
+      ensure
+        @face_stack.pop
+        @face_counts.delete(@face_stack.length + 1)
+      end
+    end
+
+    def face_raw_element(tag_name, attrs, text_content, block, eval_block)
+      open = "<#{tag_name}"
+      attrs.each do |key, value|
+        k = key.to_s
+        if k == "xmlns" || k.start_with?("xmlns:")
+          @namespaces[k.delete_prefix("xmlns:")] = value.to_s
+        end
+        open << " " << k << '="' << face_escape(value) << '"'
+      end
+      ordinal = @face_counts[@face_stack.length]
+      @face_counts[@face_stack.length] = ordinal + 1
+      @face_stack << ordinal
+      begin
+        if block || text_content
+          @face.raw("#{open}>")
+          @face.text(text_content) if text_content
+          run_builder_block(block, eval_block) if block
+          @face.raw("</#{tag_name}>")
+        else
+          @face.raw("#{open}/>")
+        end
+      ensure
+        @face_stack.pop
+        @face_counts.delete(@face_stack.length + 1)
+      end
+    end
+
+    # Content at document level has no root to attach to and the
+    # Document face flush demands exactly one root — retire the face
+    # and take the tree path (legacy semantics: doc-level text is a
+    # document child). Inside a subtree the text accumulates in
+    # position; @current never leaves the document in face mode, so
+    # the face stack is the nesting test.
+    def face_content
+      return yield if @face && @face_stack.any?
+
+      flush_face if @face
+    end
+
+    def run_builder_block(block, eval_block)
+      eval_block ? instance_eval(&block) : block.call
+    end
+
+    def face_escape(value)
+      value.to_s.gsub(FACE_ESCAPE_RE, FACE_ESCAPE)
+    end
+
+    def flush_face
+      return unless @face
+
+      face = @face
+      @face = nil
+      face.flush
+      if @face_entity_markers
+        @context.config.adapter.mark_entity_markers(@document.native)
+      end
+      apply_face_deferred
+    end
+
+    # Deferred tree-ops re-target their element by position: the
+    # stack records each element's ordinal among its parent's
+    # elements, and the flushed tree preserves markup order.
+    def apply_face_deferred
+      @face_deferred.each do |op, args, stack|
+        target = @document.root
+        stack[1..].each do |ordinal|
+          target = target.elements.to_a[ordinal]
+        end
+        case op
+        when :namespace
+          target.add_namespace(*args)
+          @namespaces[args[0]] = args[1]
+        when :declaration
+          target.add_child(@document.create_declaration(*args))
+        when :doctype
+          target.add_child(@document.create_doctype(*args))
+        end
+      end
+      @face_deferred = []
+    end
+
     # Single method for all element creation.
     # eval_block: true  → instance_eval (build DSL context)
     # eval_block: false → yield (preserves caller's self)
     def create_element_node(tag_name, attrs = {}, text_content: nil,
 block: nil, eval_block: true)
+      if @face
+        face_element(tag_name, attrs, text_content, block, eval_block)
+        return nil
+      end
+
       el = @document.create_element(tag_name)
 
       attrs.each do |key, value|

data/lib/moxml/element.rb

@@ -400,14 +400,17 @@ module Moxml
     end
 
     def inner_xml=(xml)
-      wrapper = "_moxml_inner_#{Process.pid}_#{object_id}"
-      doc = context.parse("<#{wrapper}>#{xml}</#{wrapper}>")
+      # Fragment parse, not a wrapper element around interpolated
+      # input (TODO.refactor/03): the fragment face is the same one
+      # add_child(String) uses, so semantics match and no wrapper
+      # name can collide with content.
+      nodes = context.parse_fragment(xml).to_a
       @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))
+      adapter.replace_children(@native, nodes.map(&:native))
       invalidate_children_cache!
     end
 

data/lib/moxml/version.rb

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

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

@@ -89,6 +89,25 @@ RSpec.shared_examples "Moxml::Element" do
         expect(element.children.first.name).to eq("child")
         expect(element.children.first.text).to eq("text")
       end
+
+      it "sets inner XML with mixed top-level nodes" do
+        # Structure, not serialization spelling: Ox renders bare
+        # text as <s> nodes and rexml/oga expand empty tags.
+        element.inner_xml = "a<c1/>b<c2 v='1'/>c"
+        kids = element.children
+        expect(
+          kids.map { |c| c.element? ? :element : :content },
+        ).to eq(%i[content element content element content])
+        expect(kids[0].text).to eq("a")
+        expect(kids[2].text).to eq("b")
+        expect(kids[4].text).to eq("c")
+        expect(kids[3]["v"]).to eq("1")
+      end
+
+      it "sets inner XML containing element-like text and entities" do
+        element.inner_xml = "<c>&lt;/element&gt; &amp; &#65;</c>"
+        expect(element.children.first.text).to eq("</element> & A")
+      end
     end
 
     describe "node manipulation" do

data/spec/moxml/node_spec.rb

@@ -168,9 +168,10 @@ RSpec.describe Moxml::Node do
       end
     end
 
-    it "raises for node types without a path representation" do
+    it "locates non-element nodes through typed node tests" do
       text = doc.root.children.first.children.first
-      expect { text.path }.to raise_error(Moxml::NotImplementedError, /element and document/)
+      expect(text.path).to end_with("/text()")
+      expect(doc.at_xpath(text.path)).to eq(text)
     end
   end
 

data/spec/moxml/opal_oga_adapter_spec.rb

@@ -3,12 +3,18 @@
 require "spec_helper"
 require "moxml/adapter/shared_examples/adapter_contract"
 
-RSpec.describe Moxml::Adapter::Oga, if: RUBY_ENGINE == "opal" do
-  around do |example|
-    Moxml.with_config(:oga, true, "UTF-8") do
-      example.run
+# The describe resolves the adapter constant at load time — under
+# MRI nothing loads the Opal compat shim, so the whole describe must
+# sit behind the engine check (the `if:` metadata alone still
+# evaluates the constant reference).
+if RUBY_ENGINE == "opal"
+  RSpec.describe Moxml::Adapter::Oga do
+    around do |example|
+      Moxml.with_config(:oga, true, "UTF-8") do
+        example.run
+      end
     end
-  end
 
-  it_behaves_like "xml adapter"
+    it_behaves_like "xml adapter"
+  end
 end

data/spec/moxml/sax_entity_parity_spec.rb

@@ -164,7 +164,11 @@ RSpec.describe "SAX/DOM entity parity" do
         # double-escaping on round-trip.
         doc = ctx.create_document
         el = doc.create_element("doc")
-        el.add_child("a & b")
+        # Programmatically-built: a literal Text node, no markup parse.
+        # (add_child with a String operand is MARKUP since the nokogiri
+        # compat round — a bare "&" is ill-formed there and each
+        # engine recovers differently.)
+        el.add_child(doc.create_text("a & b"))
         doc.add_child(el)
 
         serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip

metadata

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