moxml 0.1.19 → 0.1.21

data/lib/moxml/adapter/oga.rb

@@ -470,7 +470,9 @@ module Moxml
           if node.is_a?(::Oga::XML::Document)
             # Check if we should include declaration
             # Priority: explicit option > existence of xml_declaration (native or attachment)
-            effective_xml_declaration = node.xml_declaration || attachments.get(node, :xml_declaration)
+            effective_xml_declaration = node.xml_declaration || attachments.get(
+              node, :xml_declaration
+            )
             should_include_decl = if options.key?(:no_declaration)
                                     !options[:no_declaration]
                                   elsif options.key?(:declaration)
@@ -519,7 +521,9 @@ module Moxml
 
           # Default: use XmlGenerator
           # But first check if we need to handle declaration specially
-          effective_xml_declaration = node.is_a?(::Oga::XML::Document) && (node.xml_declaration || attachments.get(node, :xml_declaration))
+          effective_xml_declaration = node.is_a?(::Oga::XML::Document) && (node.xml_declaration || attachments.get(
+            node, :xml_declaration
+          ))
           if node.is_a?(::Oga::XML::Document) && effective_xml_declaration
             # Document has declaration - use custom handling to avoid duplicates
             output = []

data/lib/moxml/adapter/ox.rb

@@ -74,8 +74,7 @@ module Moxml
         end
 
         def create_native_element(name, _owner_doc = nil)
-          element = ::Ox::Element.new(name)
-          element
+          ::Ox::Element.new(name)
         end
 
         def create_native_text(content, _owner_doc = nil)
@@ -622,6 +621,12 @@ module Moxml
         end
 
         def serialize(node, options = {})
+          # CustomizedOx::Text subclasses ::Ox::Node so it can carry a @parent
+          # back-reference, but that makes it unknown to Ox.dump's XML emitter,
+          # which then falls back to generic object marshalling. Short-circuit
+          # here with proper XML escaping.
+          return escape_xml_text(node.value) if node.is_a?(CustomizedOx::Text)
+
           needs_custom = needs_custom_serialize?(node)
 
           unless needs_custom
@@ -643,7 +648,7 @@ module Moxml
             return true if attachments.get(node, :has_entity_refs)
             return true if attachments.get(node, :has_cdata_end_markers)
             return false if attachments.key?(node, :has_entity_refs) &&
-                            attachments.key?(node, :has_cdata_end_markers)
+              attachments.key?(node, :has_cdata_end_markers)
           end
 
           # Only scan tree on first call — short-circuit on first hit
@@ -694,9 +699,8 @@ module Moxml
             encoding: options[:encoding],
             no_empty: options[:expand_empty],
           }
-          result = output + ::Ox.dump(node, ox_options)
+          output + ::Ox.dump(node, ox_options)
           # Fix CDATA ]]> end markers that Ox doesn't escape
-          result
         end
 
         def tree_has_entity_references?(node)
@@ -721,9 +725,13 @@ module Moxml
           when ::Ox::CData
             node.value&.include?("]]>") || false
           when ::Ox::Element
-            node.nodes&.any? { |child| tree_has_cdata_end_markers?(child) } || false
+            node.nodes&.any? do |child|
+              tree_has_cdata_end_markers?(child)
+            end || false
           when ::Ox::Document
-            node.nodes&.any? { |child| tree_has_cdata_end_markers?(child) } || false
+            node.nodes&.any? do |child|
+              tree_has_cdata_end_markers?(child)
+            end || false
           else
             false
           end
@@ -814,7 +822,6 @@ module Moxml
           end
         end
 
-
         # Translate a subset of XPath to Ox locate() syntax
         # Supports: //element, /path/to/element, .//element, element[@attr]
         # Note: Ox locate() doesn't support namespace prefixes in the path

data/lib/moxml/builder.rb

@@ -30,12 +30,14 @@ module Moxml
     # and a valid XML tag name (XSD/RelaxNG).
     def element(name_or_attrs = nil, attributes = {}, &block)
       if name_or_attrs.is_a?(Hash)
-        return create_element_node("element", name_or_attrs, block: block, eval_block: false)
+        return create_element_node("element", name_or_attrs, block: block,
+                                                             eval_block: false)
       end
 
       raise ArgumentError, "element requires a tag name" if name_or_attrs.nil?
 
-      create_element_node(name_or_attrs, attributes, block: block, eval_block: true)
+      create_element_node(name_or_attrs, attributes, block: block,
+                                                     eval_block: true)
     end
 
     def text(content)
@@ -101,10 +103,14 @@ module Moxml
       text_content = args.first.is_a?(String) ? args.shift : nil
       attrs = args.first.is_a?(Hash) ? args.shift : {}
 
-      raise ArgumentError, "unexpected arguments for #{method_name}: #{args.inspect}" unless args.empty?
+      unless args.empty?
+        raise ArgumentError,
+              "unexpected arguments for #{method_name}: #{args.inspect}"
+      end
 
       if text_content && block
-        raise ArgumentError, "#{method_name}: cannot combine text content with a block"
+        raise ArgumentError,
+              "#{method_name}: cannot combine text content with a block"
       end
 
       # Strip trailing underscore to allow reserved Ruby method names as tags
@@ -126,7 +132,8 @@ module Moxml
     # 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)
+    def create_element_node(tag_name, attrs = {}, text_content: nil,
+block: nil, eval_block: true)
       el = @document.create_element(tag_name)
 
       attrs.each do |key, value|

data/lib/moxml/entity_registry.rb

@@ -156,6 +156,7 @@ module Moxml
     def primary_name_for_codepoint(codepoint)
       names = @by_codepoint[codepoint]
       return nil unless names&.any?
+
       # Prefer lowercase names (e.g., "amp" over "AMP") for XML compatibility
       names.find { |n| n == n.downcase } || names.first
     end

data/lib/moxml/text.rb

@@ -15,5 +15,9 @@ module Moxml
     def content=(text)
       adapter.set_text_content(@native, normalize_xml_value(text))
     end
+
+    def to_s
+      content
+    end
   end
 end

data/lib/moxml/version.rb

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

data/lib/moxml/xpath/compiler.rb

@@ -1758,7 +1758,8 @@ module Moxml
           current = visit.pop
 
           # Function name is stored in :value field, not children
-          if (current.type == :call || current.type == :function) && current.value == name
+          if %i[call
+                function].include?(current.type) && current.value == name
             return true
           end
 

data/spec/integration/shared_examples/edge_cases.rb

@@ -170,7 +170,9 @@ RSpec.shared_examples "Moxml Edge Cases" do
   describe "whitespace text node preservation" do
     # Ox/HeadedOx do not generate whitespace-only text nodes in their parser,
     # so these tests only apply to adapters that do (Nokogiri, OGA, REXML, LibXML)
-    let(:preserves_ws) { !%i[ox headed_ox].include?(context.config.adapter_name) }
+    let(:preserves_ws) do
+      !%i[ox headed_ox].include?(context.config.adapter_name)
+    end
 
     it "preserves whitespace-only text nodes between sibling elements" do
       unless preserves_ws
@@ -196,7 +198,7 @@ RSpec.shared_examples "Moxml Edge Cases" do
       expect(ws_nodes).not_to be_empty
 
       # Element children should still be accessible
-      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      elements = children.grep(Moxml::Element)
       expect(elements.map(&:name)).to eq(%w[a b c])
     end
 

data/spec/integration/shared_examples/entity_reference_whitespace.rb

@@ -116,7 +116,7 @@ RSpec.shared_examples "Entity Reference Whitespace Preservation" do
       children = doc.root.children
 
       # Whitespace text nodes between elements are preserved
-      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      elements = children.grep(Moxml::Element)
       expect(elements.length).to eq(2)
       expect(elements.map(&:name)).to eq(%w[child1 child2])
     end

data/spec/integration/shared_examples/high_level/document_builder_behavior.rb

@@ -38,7 +38,9 @@ RSpec.shared_examples "Moxml::DocumentBuilder" do
       expect(non_ws_children[1]).to be_a(Moxml::Element)
       expect(non_ws_children[1].name).to eq("child")
       expect(non_ws_children[1]["id"]).to eq("1")
-      expect(non_ws_children[1].children.find { |c| c.is_a?(Moxml::Cdata) }).to be_a(Moxml::Cdata)
+      expect(non_ws_children[1].children.find do |c|
+        c.is_a?(Moxml::Cdata)
+      end).to be_a(Moxml::Cdata)
       expect(non_ws_children[2]).to be_a(Moxml::ProcessingInstruction)
     end
   end

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

@@ -129,16 +129,20 @@ RSpec.shared_examples "Moxml::EntityReference" do
 
   describe "entity restoration" do
     it "restores standard XML entities when enabled" do
-      ctx_restore = Moxml.new(context.config.adapter_name) { |c| c.restore_entities = true }
+      ctx_restore = Moxml.new(context.config.adapter_name) do |c|
+        c.restore_entities = true
+      end
       doc = ctx_restore.parse("<p>a&amp;b</p>")
       output = doc.to_xml
       expect(output).to include("&amp;")
     end
 
     it "does not create entity references when disabled" do
-      ctx_no_restore = Moxml.new(context.config.adapter_name) { |c| c.restore_entities = false }
+      ctx_no_restore = Moxml.new(context.config.adapter_name) do |c|
+        c.restore_entities = false
+      end
       doc = ctx_no_restore.parse("<p>text</p>")
-      refs = doc.root.children.select { |c| c.is_a?(Moxml::EntityReference) }
+      refs = doc.root.children.grep(Moxml::EntityReference)
       expect(refs).to be_empty
     end
   end
@@ -197,7 +201,9 @@ RSpec.shared_examples "Moxml::EntityReference" do
 
     it "rejects invalid modes" do
       cfg = Moxml::Config.new(context.config.adapter_name)
-      expect { cfg.entity_restoration_mode = :bogus }.to raise_error(ArgumentError)
+      expect do
+        cfg.entity_restoration_mode = :bogus
+      end.to raise_error(ArgumentError)
     end
 
     it "restores non-standard entities in lenient mode" do

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

@@ -42,7 +42,7 @@ RSpec.shared_examples "Moxml::NodeSet" do
 
       it "compares nodes" do
         xpath_results = doc.xpath("//child")
-        element_children = doc.root.children.select { |c| c.is_a?(Moxml::Element) }
+        element_children = doc.root.children.grep(Moxml::Element)
         expect(xpath_results.map(&:native)).to eq(element_children.map(&:native))
       end
     end

data/spec/moxml/adapter/headed_ox_spec.rb

@@ -145,7 +145,7 @@ RSpec.describe Moxml::Adapter::HeadedOx do
     it "returns first matching node" do
       result = adapter.at_xpath(doc, "//book")
 
-      expect(result).to be_a(::Ox::Element)
+      expect(result).to be_a(Ox::Element)
       expect(result.name).to eq("book")
     end
 

data/spec/moxml/adapter/libxml_internals_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+begin
+  require "libxml"
+rescue LoadError
+  return
+end
+
+require "moxml/adapter/libxml"
+
+# Targeted tests for private helpers extracted during the perf refactor.
+# The public `serialize` path covers them transitively, but a future
+# refactor of those helpers benefits from fine-grained safety nets.
+RSpec.describe Moxml::Adapter::Libxml do
+  describe ".emit_children_with_layout" do
+    let(:adapter) { described_class }
+
+    def parse_root(xml)
+      doc = LibXML::XML::Parser.string(xml).parse
+      doc.root
+    end
+
+    def emit(root, indent_size: 2, depth: 0, eref_active: false)
+      output = +""
+      adapter.send(:emit_children_with_layout, output, root, indent_size, depth,
+                   eref_active: eref_active)
+      output
+    end
+
+    context "with all-element children" do
+      it "emits a newline + per-level padding before each child" do
+        root = parse_root("<root><a/><b/></root>")
+        expect(emit(root)).to eq("\n  <a></a>\n  <b></b>")
+      end
+
+      it "emits no padding when indent_size is zero" do
+        root = parse_root("<root><a/><b/></root>")
+        expect(emit(root, indent_size: 0)).to eq("\n<a></a>\n<b></b>")
+      end
+
+      it "scales padding with depth" do
+        root = parse_root("<root><a/></root>")
+        expect(emit(root, depth: 2)).to eq("\n      <a></a>")
+      end
+    end
+
+    context "with mixed text + element content" do
+      it "does not emit newlines (text suppresses block layout)" do
+        root = parse_root("<p>hello<b>world</b>!</p>")
+        expect(emit(root)).to eq("hello<b>world</b>!")
+      end
+
+      it "emits a newline only before the first element when text follows" do
+        root = parse_root("<p><b>world</b>!</p>")
+        # First child is element, prev_block starts true → newline before it.
+        # Then text "!" sets prev_block false; no further block-level
+        # children follow, so no additional newlines.
+        expect(emit(root)).to eq("\n  <b>world</b>!")
+      end
+    end
+
+    context "with CDATA + element children" do
+      it "treats cdata as text-like and suppresses surrounding newlines" do
+        cdata_xml = "<r><![CDATA[X]]><a/></r>"
+        root = parse_root(cdata_xml)
+        # CDATA is text-like → no newline before it, prev_block goes false,
+        # then <a/> follows but prev_block was set false by CDATA, so no \n.
+        expect(emit(root)).to eq("<![CDATA[X]]><a></a>")
+      end
+    end
+
+    context "with comment + element children" do
+      it "treats comment as block-level and emits newlines between siblings" do
+        root = parse_root("<x><!-- c --><y/></x>")
+        expect(emit(root)).to eq("\n  <!-- c -->\n  <y></y>")
+      end
+    end
+
+    context "with whitespace-only text children" do
+      it "skips them and produces the same layout as a doc without them" do
+        with_ws = emit(parse_root("<root>   <a/>   <b/>   </root>"))
+        without_ws = emit(parse_root("<root><a/><b/></root>"))
+        expect(with_ws).to eq(without_ws)
+      end
+    end
+
+    context "with no children" do
+      it "appends nothing" do
+        root = parse_root("<empty/>")
+        expect(emit(root)).to eq("")
+      end
+    end
+  end
+
+  describe ".lookup_entity_ref_serialization" do
+    let(:adapter) { described_class }
+    let(:context) { Moxml.new(:libxml) }
+
+    # `lookup_entity_ref_serialization` is called from the recursive
+    # serialize path with a raw libxml ::Node (not the wrapper), so we
+    # unwrap to match the call-site contract.
+    def libxml_native(moxml_node)
+      adapter.send(:unpatch_node, moxml_node.native)
+    end
+
+    it "returns [nil, nil] when the document has no entity-ref attachments" do
+      root = libxml_native(context.parse("<root><a/></root>").root)
+      expect(adapter.send(:lookup_entity_ref_serialization, root)).to eq([nil, nil])
+    end
+
+    it "returns [nil, nil] for an element with no entity refs even when the doc has erefs elsewhere" do
+      doc = context.parse("<root><a/><b/></root>")
+      a = doc.root.children.first
+      b = doc.root.children.last
+      eref = Moxml::EntityReference.new(
+        adapter.create_native_entity_reference("amp"), context
+      )
+      a.add_child(eref)
+
+      expect(adapter.send(:lookup_entity_ref_serialization, libxml_native(b)))
+        .to eq([nil, nil])
+    end
+
+    it "returns [refs, sequence] when both are registered for the element" do
+      doc = context.parse("<root><a>text</a></root>")
+      a = doc.root.children.first
+      eref = Moxml::EntityReference.new(
+        adapter.create_native_entity_reference("amp"), context
+      )
+      a.add_child(eref)
+
+      refs, seq = adapter.send(:lookup_entity_ref_serialization, libxml_native(a))
+      expect(refs).to be_an(Array).and(satisfy { |r| !r.empty? })
+      expect(seq).to be_an(Array).and(include(:eref))
+    end
+  end
+
+  describe "entity-ref interleaved serialization" do
+    let(:adapter) { described_class }
+    let(:context) { Moxml.new(:libxml) }
+
+    it "preserves normal child indentation when entity refs are present" do
+      doc = context.parse("<root><a><b/></a></root>")
+      a = doc.root.children.first
+      eref = Moxml::EntityReference.new(
+        adapter.create_native_entity_reference("amp"), context
+      )
+      a.add_child(eref)
+
+      expect(doc.to_xml(no_declaration: true, indent: 2))
+        .to eq("<root>\n  <a>\n    <b></b>&amp;</a></root>")
+    end
+  end
+
+  describe Moxml::Adapter::Libxml::EntityRestorer do
+    let(:context) { Moxml.new(:libxml) }
+
+    it "restores entities through its public entry point" do
+      doc = context.parse("<p>\u00A9</p>")
+      context.config.restore_entities = true
+
+      described_class.new(doc).run
+
+      expect(doc.to_xml(no_declaration: true)).to eq("<p>&copy;</p>")
+    end
+  end
+end

data/spec/moxml/text_spec.rb

@@ -19,6 +19,29 @@ RSpec.describe Moxml::Text do
       text = doc.root.children.first
       expect(text.to_xml).to eq("plain text")
     end
+
+    it "escapes XML special characters" do
+      escaped_doc = context.parse("<root>a &lt; b &amp; c</root>")
+      text = escaped_doc.root.children.first
+      expect(text.to_xml).to eq("a &lt; b &amp; c")
+    end
+  end
+
+  describe "#to_s" do
+    it "returns text content" do
+      text = doc.root.children.first
+      expect(text.to_s).to eq("plain text")
+    end
+
+    it "is consistent across adapters" do
+      Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
+        ctx = Moxml.new(adapter_name)
+        d = ctx.parse("<root>hello world</root>")
+        text = d.root.children.first
+        expect(text.to_s).to eq("hello world"),
+                             "Text#to_s for #{adapter_name} adapter"
+      end
+    end
   end
 
   describe "creation" do

data/spec/moxml/xpath/functions/node_functions_spec.rb

@@ -127,7 +127,7 @@ RSpec.describe "XPath Node Functions" do
     it "inherits language from parent element" do
       ast = Moxml::XPath::Parser.parse('lang("en")')
       proc = Moxml::XPath::Compiler.compile_with_cache(ast)
-      child = doc_with_lang.root.children.select { |c| c.is_a?(Moxml::Element) }.first
+      child = doc_with_lang.root.children.grep(Moxml::Element).first
       result = proc.call(child)
 
       expect(result).to be true
@@ -136,7 +136,7 @@ RSpec.describe "XPath Node Functions" do
     it "uses closest xml:lang attribute" do
       ast = Moxml::XPath::Parser.parse('lang("fr")')
       proc = Moxml::XPath::Compiler.compile_with_cache(ast)
-      elements = doc_with_lang.root.children.select { |c| c.is_a?(Moxml::Element) }
+      elements = doc_with_lang.root.children.grep(Moxml::Element)
       other = elements[1]
       result = proc.call(other)
 

data/spec/performance/benchmark_spec.rb

@@ -30,7 +30,7 @@ RSpec.shared_examples "Performance Examples" do
           rexml: { parser: 0, serializer: 5 },
           ox: { parser: 2, serializer: 1000 },
           headed_ox: { parser: 2, serializer: 1000 },
-          libxml: { parser: 2, serializer: 3 },
+          libxml: { parser: 500, serializer: 60 },
         }
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.21
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-01 00:00:00.000000000 Z
+date: 2026-05-25 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -121,6 +121,8 @@ files:
 - lib/moxml/adapter/customized_rexml/formatter.rb
 - lib/moxml/adapter/headed_ox.rb
 - lib/moxml/adapter/libxml.rb
+- lib/moxml/adapter/libxml/entity_ref_registry.rb
+- lib/moxml/adapter/libxml/entity_restorer.rb
 - lib/moxml/adapter/nokogiri.rb
 - lib/moxml/adapter/oga.rb
 - lib/moxml/adapter/ox.rb
@@ -297,6 +299,7 @@ files:
 - spec/moxml/adapter/base_spec.rb
 - spec/moxml/adapter/entity_restoration_spec.rb
 - spec/moxml/adapter/headed_ox_spec.rb
+- spec/moxml/adapter/libxml_internals_spec.rb
 - spec/moxml/adapter/libxml_spec.rb
 - spec/moxml/adapter/nokogiri_spec.rb
 - spec/moxml/adapter/oga_spec.rb