moxml 0.1.20 → 0.1.22

data/lib/moxml/node.rb

@@ -135,19 +135,6 @@ module Moxml
       children.last
     end
 
-    # Returns the text content of this node
-    # For elements, returns concatenated text of all text children
-    # For text nodes, returns the content if available
-    def text
-      if respond_to?(:content)
-        content
-      elsif respond_to?(:children)
-        children.grep(Text).map(&:content).join
-      else
-        ""
-      end
-    end
-
     # Returns the text content of this node
     # Subclasses should override this method
     # Element and Text have their own implementations
@@ -220,22 +207,28 @@ module Moxml
       nil
     end
 
+    # Registry mapping node type symbols to wrapper classes.
+    # Built lazily to avoid load-order issues with subclasses.
+    def self.node_type_map
+      @node_type_map ||= {
+        element: Element,
+        text: Text,
+        cdata: Cdata,
+        comment: Comment,
+        processing_instruction: ProcessingInstruction,
+        document: Document,
+        declaration: Declaration,
+        doctype: Doctype,
+        attribute: Attribute,
+        entity_reference: EntityReference,
+      }.freeze
+    end
+
     def self.wrap(node, context)
       return nil if node.nil?
 
-      klass = case adapter(context).node_type(node)
-              when :element then Element
-              when :text then Text
-              when :cdata then Cdata
-              when :comment then Comment
-              when :processing_instruction then ProcessingInstruction
-              when :document then Document
-              when :declaration then Declaration
-              when :doctype then Doctype
-              when :attribute then Attribute
-              when :entity_reference then EntityReference
-              else self
-              end
+      type = adapter(context).node_type(node)
+      klass = node_type_map[type] || self
 
       klass.new(node, context)
     end

data/lib/moxml/sax/namespace_splitter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Moxml
+  module SAX
+    # Splits a flat attribute hash into regular attributes and namespace declarations.
+    #
+    # Every adapter SAX bridge performs the same split: attributes whose names
+    # start with "xmlns" are namespace declarations, everything else is a regular
+    # attribute. This module provides a single implementation.
+    module NamespaceSplitter
+      # @param attributes [Hash, Array<Array>] attributes as a hash or array of pairs
+      # @return [Array(Hash, Hash)] [regular_attrs, namespaces]
+      def split_attributes_and_namespaces(attributes)
+        attrs = {}
+        ns = {}
+
+        each_attribute(attributes) do |name, value|
+          name_s = name.to_s
+          if name_s == "xmlns" || name_s.start_with?("xmlns:")
+            prefix = name_s == "xmlns" ? nil : name_s.sub("xmlns:", "")
+            ns[prefix] = value
+          else
+            attrs[name_s] = value
+          end
+        end
+
+        [attrs, ns]
+      end
+
+      private
+
+      def each_attribute(attributes, &block)
+        case attributes
+        when Hash
+          attributes.each(&block)
+        when Array
+          attributes.each { |pair| yield pair[0], pair[1] }
+        when nil
+          # nothing
+        else
+          if attributes.respond_to?(:each)
+            attributes.each do |item|
+              if item.is_a?(Array) && item.size >= 2
+                yield item[0], item[1]
+              elsif item.respond_to?(:name) && item.respond_to?(:value)
+                yield item.name, item.value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/version.rb

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

data/lib/moxml/xml_utils.rb

@@ -75,7 +75,15 @@ module Moxml
       # (W3C Namespaces in XML, https://www.w3.org/TR/xml-names/).
       # Use split instead of parse to avoid scheme-specific validation
       # that rejects valid opaque URIs like "mailto:bar".
-      URI::RFC3986_PARSER.split(uri)
+      if defined?(URI::RFC3986_PARSER)
+        URI::RFC3986_PARSER.split(uri)
+      elsif uri.match?(/\A[a-zA-Z][a-zA-Z0-9+\-.]*:[^\x00-\x20]*\z/)
+        # Minimal URI validation for Opal (no RFC3986_PARSER available)
+      else
+        # Accept relative references and bare paths
+        return unless uri.match?(/[\x00-\x08\x0B\x0C\x0E-\x1F]/)
+        raise ValidationError, "Invalid URI: #{uri}"
+      end
     rescue URI::InvalidURIError
       raise ValidationError, "Invalid URI: #{uri}"
     end

data/spec/consistency/adapter_parity_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe "Adapter Examples" do
   describe "Serialization consistency" do
     it "produces equivalent XML across adapters",
        skip: "No easy way to exclude the declaration from Nokogiri documents" do
-      docs = Moxml::Adapter::AVALIABLE_ADAPTERS.map do |adapter|
+      docs = Moxml::Adapter::AVAILABLE_ADAPTERS.map do |adapter|
         Moxml.new(adapter).parse(xml, fragment: true)
       end
 

data/spec/integration/all_adapters_spec.rb

@@ -32,7 +32,7 @@ RSpec.describe "Cross-adapter integration" do
     "Performance Examples",
   ]
 
-  Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
+  Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
     context "with #{adapter_name}" do
       around do |example|
         Moxml.with_config(adapter_name) do

data/spec/integration/w3c_namespace_spec.rb

@@ -11,7 +11,7 @@
 #   invalid  - validity error; non-validating parsers should accept
 
 RSpec.describe "W3C XML Namespaces 1.0 test suite" do
-  Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
+  Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
     context "with #{adapter_name}" do
       around do |example|
         Moxml.with_config(adapter_name) do

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/adapter/ox_spec.rb

@@ -11,6 +11,14 @@ RSpec.describe Moxml::Adapter::Ox do
 
   it_behaves_like "xml adapter"
 
+  describe "node_type" do
+    it "returns :namespace for CustomizedOx::Namespace nodes" do
+      element = described_class.create_native_element("test")
+      ns = described_class.create_native_namespace(element, "ns", "http://example.com")
+      expect(described_class.node_type(ns)).to eq(:namespace)
+    end
+  end
+
   describe "text handling" do
     let(:doc) { described_class.create_document }
     let(:element) { described_class.create_native_element("test") }

data/spec/moxml/adapter/platform_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Adapter, ".platform_adapters" do
+  it "includes all known adapters under MRI" do
+    expect(described_class.platform_adapters).to include(:nokogiri, :oga, :rexml, :ox)
+  end
+
+  it "uses the AVAILABLE_ADAPTERS constant under MRI" do
+    expect(described_class.platform_adapters).to eq(Moxml::Adapter::AVAILABLE_ADAPTERS)
+  end
+end
+
+RSpec.describe Moxml::Adapter, ".available?" do
+  it "returns true for :oga" do
+    expect(described_class.available?(:oga)).to be true
+  end
+
+  it "returns true for :nokogiri under MRI" do
+    expect(described_class.available?(:nokogiri)).to be true
+  end
+
+  context "when Opal platform adapters are in effect" do
+    before do
+      allow(described_class).to receive(:platform_adapters)
+        .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+    end
+
+    it "returns false for :nokogiri" do
+      expect(described_class.available?(:nokogiri)).to be false
+    end
+
+    it "returns true for :rexml" do
+      expect(described_class.available?(:rexml)).to be true
+    end
+  end
+end
+
+RSpec.describe Moxml::Adapter, ".load" do
+  context "when Opal platform adapters are in effect" do
+    before do
+      allow(described_class).to receive(:platform_adapters)
+        .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+    end
+
+    it "raises AdapterError for :nokogiri" do
+      expect { described_class.load(:nokogiri) }.to raise_error(
+        Moxml::AdapterError, /not available on this platform/
+      )
+    end
+  end
+end
+
+RSpec.describe "Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS" do
+  it "contains only :rexml" do
+    expect(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS).to eq(%i[rexml])
+  end
+end
+
+RSpec.describe "Moxml::Adapter::CONST_NAME_MAP" do
+  it "maps :headed_ox to HeadedOx" do
+    expect(Moxml::Adapter::CONST_NAME_MAP[:headed_ox]).to eq("HeadedOx")
+  end
+
+  it "falls back to capitalize for unmapped adapters" do
+    expect(Moxml::Adapter::CONST_NAME_MAP[:nokogiri]).to be_nil
+  end
+end

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -159,9 +159,6 @@ RSpec.shared_examples "xml adapter" do
       if described_class.name.include?("Oga")
         pending("Oga does not support indentation settings")
       end
-      if described_class.name.include?("Rexml")
-        pending("Postponed for Rexml till better times")
-      end
       if described_class.name.include?("Libxml")
         skip("LibXML serialization does not support indentation (documented limitation)")
       end
@@ -219,9 +216,6 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        if described_class.name.include?("Rexml")
-          pending("Rexml does not respect ZPath namespaces")
-        end
         # Parse original XML
         doc = described_class.parse(xml).native
 

data/spec/moxml/entity_registry_spec.rb

@@ -180,6 +180,16 @@ RSpec.describe Moxml::EntityRegistry do
       registry = described_class.new
       expect(registry.load_all).to be(registry)
     end
+
+    it "emits deprecation warnings" do
+      registry = described_class.new
+      [-> { registry.load_html5 },
+       -> { registry.load_mathml },
+       -> { registry.load_iso },
+       -> { registry.load_all }].each do |callable|
+        expect { callable.call }.to output.to_stderr
+      end
+    end
   end
 
   describe "#standard_entity?" do

data/spec/moxml/native_attachment/opal_spec.rb

@@ -1,10 +1,47 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require_relative "shared_examples"
 
 RSpec.describe Moxml::NativeAttachment::Opal do
-  it_behaves_like "an attachment backend"
+  subject(:attachments) { described_class.new }
+
+  let(:native) { Object.new }
+  let(:other_native) { Object.new }
+
+  it "stores and reads attachments by native object and key" do
+    attachments.set(native, :entity_refs, ["amp"])
+    attachments.set(native, :doctype, "html")
+    attachments.set(other_native, :entity_refs, ["lt"])
+
+    aggregate_failures do
+      expect(attachments.get(native, :entity_refs)).to eq(["amp"])
+      expect(attachments.get(native, :doctype)).to eq("html")
+      expect(attachments.get(other_native, :entity_refs)).to eq(["lt"])
+      expect(attachments.key?(native, :entity_refs)).to be(true)
+      expect(attachments.key?(native, :missing)).to be(false)
+    end
+  end
+
+  it "preserves explicit nil attachments" do
+    attachments.set(native, :xml_declaration, nil)
+
+    aggregate_failures do
+      expect(attachments.get(native, :xml_declaration)).to be_nil
+      expect(attachments.key?(native, :xml_declaration)).to be(true)
+    end
+  end
+
+  it "deletes attachments" do
+    attachments.set(native, :entity_refs, ["amp"])
+
+    expect(attachments.delete(native, :entity_refs)).to eq(["amp"])
+
+    aggregate_failures do
+      expect(attachments.get(native, :entity_refs)).to be_nil
+      expect(attachments.key?(native, :entity_refs)).to be(false)
+      expect(attachments.delete(native, :entity_refs)).to be_nil
+    end
+  end
 
   it "stores attachments in Moxml-owned instance variables" do
     attachments = described_class.new

data/spec/moxml/node_type_map_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Node, "node_type_map" do
+  it "maps every type symbol to a Node subclass" do
+    described_class.node_type_map.each_value do |klass|
+      expect(klass < described_class).to be(true), "Expected #{klass} < Moxml::Node"
+    end
+  end
+
+  it "covers all standard node types" do
+    expected = %i[element text cdata comment processing_instruction
+                  document declaration doctype attribute entity_reference]
+    expect(described_class.node_type_map.keys).to match_array(expected)
+  end
+
+  it "is frozen to prevent modification" do
+    expect(described_class.node_type_map).to be_frozen
+  end
+
+  describe ".wrap" do
+    let(:ctx) { Moxml.new(:nokogiri) }
+
+    it "returns nil for nil input" do
+      expect(described_class.wrap(nil, ctx)).to be_nil
+    end
+
+    it "wraps native nodes using node_type_map" do
+      doc = ctx.parse("<root><child>text</child></root>")
+      root = doc.root
+      expect(root).to be_a(Moxml::Element)
+
+      text_node = root.children.first.children.first
+      expect(text_node).to be_a(Moxml::Text)
+    end
+
+    it "returns a Node for unknown types" do
+      node = described_class.wrap(Object.new, ctx)
+      expect(node).to be_a(described_class)
+    end
+  end
+end

data/spec/moxml/opal_rexml_adapter_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/adapter/shared_examples/adapter_contract"
+
+RSpec.describe Moxml::Adapter::Rexml, if: RUBY_ENGINE == "opal" do
+  around do |example|
+    Moxml.with_config(:rexml, true, "UTF-8") do
+      example.run
+    end
+  end
+
+  it_behaves_like "xml adapter"
+end

data/spec/moxml/opal_smoke_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Moxml Opal smoke test", if: RUBY_ENGINE == "opal" do
+  let(:context) { Moxml.new(:rexml) }
+
+  it "parses XML string to document" do
+    doc = context.parse("<root><child>text</child></root>")
+    expect(doc).not_to be_nil
+    root = doc.root
+    expect(root.name).to eq("root")
+    expect(root.children.first.name).to eq("child")
+  end
+
+  it "round-trips parse and serialize" do
+    xml = '<person name="Alice"><age>30</age></person>'
+    doc = context.parse(xml)
+    serialized = doc.to_xml
+    expect(serialized).to include("person")
+    expect(serialized).to include("Alice")
+    expect(serialized).to include("30")
+  end
+
+  it "builds XML document from scratch" do
+    doc = context.create_document
+    root = doc.create_element("root")
+    root["attr"] = "value"
+    text = doc.create_text("hello")
+    root.add_child(text)
+    doc.add_child(root)
+
+    expect(doc.to_xml).to include('attr="value"')
+    expect(doc.to_xml).to include("hello")
+  end
+
+  it "handles namespaces" do
+    xml = '<root xmlns:ns="http://example.com"><ns:child>data</ns:child></root>'
+    doc = context.parse(xml)
+    expect(doc.to_xml).to include("ns:child")
+  end
+
+  it "handles CDATA sections" do
+    xml = "<root><![CDATA[<script>alert('xss')</script>]]></root>"
+    doc = context.parse(xml)
+    expect(doc.to_xml).to include("<script>")
+  end
+
+  it "handles comments" do
+    xml = "<root><!-- a comment --><child/></root>"
+    doc = context.parse(xml)
+    expect(doc.to_xml).to include("a comment")
+  end
+
+  it "handles processing instructions" do
+    xml = '<?xml version="1.0"?><?pi-target pi-data?><root/>'
+    doc = context.parse(xml)
+    serialized = doc.to_xml
+    expect(serialized).to include("pi-target")
+  end
+end