moxml 0.1.21 → 0.1.23

data/lib/moxml/node.rb

@@ -98,6 +98,7 @@ module Moxml
       serialize_options[:no_declaration] = !should_include_declaration?(options)
 
       result = adapter.serialize(@native, serialize_options)
+      result = apply_line_ending(result, serialize_options[:line_ending])
 
       # Restore entity markers to named entity references
       adapter.restore_entities(result)
@@ -135,19 +136,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 +208,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
@@ -286,6 +280,7 @@ module Moxml
       {
         encoding: context.config.default_encoding,
         indent: context.config.default_indent,
+        line_ending: context.config.default_line_ending,
         # The short format of empty tags in Oga and Nokogiri isn't configurable
         # Oga: <empty /> (with a space)
         # Nokogiri: <empty/> (without a space)
@@ -301,5 +296,11 @@ module Moxml
       # For Document nodes, delegate to adapter for native state check
       adapter.has_declaration?(@native, self)
     end
+
+    def apply_line_ending(xml, line_ending)
+      return xml if line_ending == Config::LINE_ENDING_LF || !xml.include?("\n")
+
+      xml.gsub(/\r?\n/, line_ending)
+    end
   end
 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.21"
+  VERSION = "0.1.23"
 end

data/lib/moxml/xml_utils.rb

@@ -75,7 +75,16 @@ 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/lib/moxml.rb

@@ -32,6 +32,13 @@ module Moxml
       end
       original_config = nil
     end
+    def preprocess_entities(xml)
+      Adapter::Base.preprocess_entities(xml)
+    end
+
+    def restore_entities(text)
+      Adapter::Base.restore_entities(text)
+    end
   end
 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

@@ -29,10 +29,11 @@ RSpec.describe "Cross-adapter integration" do
     "Memory Usage Examples",
     "Thread Safety Examples",
     "Entity Reference Whitespace Preservation",
+    "Moxml Line Ending",
     "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/shared_examples/line_ending_behavior.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml Line Ending" do
+  describe "Line ending configuration" do
+    let(:context) { Moxml.new }
+    let(:xml) { "<root><child>text</child></root>" }
+
+    it "produces no CRLF with LF default" do
+      doc = context.parse(xml)
+      expect(doc.to_xml).not_to include("\r\n")
+    end
+
+    it "produces no bare LF with CRLF configured" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      expect(doc.to_xml).not_to match(/(?<!\r)\n/)
+    end
+
+    it "allows per-call CRLF override producing no bare LF" do
+      doc = context.parse(xml)
+      output = doc.to_xml(line_ending: Moxml::Config::LINE_ENDING_CRLF)
+      expect(output).not_to match(/(?<!\r)\n/)
+    end
+
+    it "per-call LF override wins over config CRLF" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      expect(doc.to_xml(line_ending: Moxml::Config::LINE_ENDING_LF))
+        .not_to include("\r\n")
+    end
+
+    it "produces identical bytes on re-serialization with CRLF" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      first = doc.to_xml
+
+      ctx2 = Moxml.new
+      ctx2.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      result = ctx2.parse(first)
+      expect(result.to_xml).to eq(first)
+    end
+
+    it "preserves element structure through CRLF round-trip" do
+      doc = context.parse("<root><a>text</a><b>more</b></root>")
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      crlf_output = doc.to_xml
+
+      ctx2 = Moxml.new
+      result = ctx2.parse(crlf_output)
+      elements = result.root.children.select(&:element?)
+      expect(elements.map(&:name)).to eq(%w[a b])
+      expect(elements[0].children.first.content).to eq("text")
+      expect(elements[1].children.first.content).to eq("more")
+    end
+  end
+end

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

@@ -105,7 +105,8 @@ RSpec.describe Moxml::Adapter::Libxml do
 
     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])
+      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
@@ -129,7 +130,8 @@ RSpec.describe Moxml::Adapter::Libxml do
       )
       a.add_child(eref)
 
-      refs, seq = adapter.send(:lookup_entity_ref_serialization, libxml_native(a))
+      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

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,70 @@
+# 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/config_spec.rb

@@ -10,6 +10,7 @@ RSpec.describe Moxml::Config do
       expect(config.strict_parsing).to be true
       expect(config.default_encoding).to eq("UTF-8")
       expect(config.default_indent).to eq(2)
+      expect(config.default_line_ending).to eq("\n")
       expect(config.entity_encoding).to eq(:basic)
     end
 
@@ -89,6 +90,38 @@ RSpec.describe Moxml::Config do
     end
   end
 
+  describe "#default_line_ending=" do
+    it "accepts LINE_ENDING_LF" do
+      config.default_line_ending = Moxml::Config::LINE_ENDING_LF
+      expect(config.default_line_ending).to eq("\n")
+    end
+
+    it "accepts LINE_ENDING_CRLF" do
+      config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      expect(config.default_line_ending).to eq("\r\n")
+    end
+
+    it "rejects nil" do
+      expect { config.default_line_ending = nil }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+
+    it "rejects arbitrary strings" do
+      expect { config.default_line_ending = "BAD" }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+
+    it "rejects bare CR" do
+      expect { config.default_line_ending = "\r" }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+
+    it "rejects empty string" do
+      expect { config.default_line_ending = "" }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+  end
+
   describe "#adapter=" do
     it "sets valid adapter" do
       config.adapter = :ox

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