moxml 0.1.21 → 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.21"
+  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/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

data/spec/moxml/sax/namespace_splitter_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::SAX::NamespaceSplitter do
+  let(:bridge_class) do
+    Class.new do
+      include Moxml::SAX::NamespaceSplitter
+
+      attr_reader :last_attrs, :last_ns
+
+      def split(attributes)
+        @last_attrs, @last_ns = split_attributes_and_namespaces(attributes)
+      end
+    end
+  end
+
+  let(:splitter) { bridge_class.new }
+
+  describe "#split_attributes_and_namespaces" do
+    it "splits hash attributes into attrs and namespaces" do
+      attrs, ns = splitter.split({
+                                   "xmlns" => "http://default.ns",
+                                   "xmlns:foo" => "http://foo.ns",
+                                   "id" => "123",
+                                   "class" => "bar",
+                                 })
+
+      expect(attrs).to eq("id" => "123", "class" => "bar")
+      expect(ns).to eq(nil => "http://default.ns", "foo" => "http://foo.ns")
+    end
+
+    it "splits array-of-pairs attributes" do
+      attrs, ns = splitter.split([
+                                   ["xmlns:prefix", "http://example.com"],
+                                   ["name", "value"],
+                                 ])
+
+      expect(attrs).to eq("name" => "value")
+      expect(ns).to eq("prefix" => "http://example.com")
+    end
+
+    it "returns empty hashes when all attributes are namespaces" do
+      attrs, ns = splitter.split({ "xmlns" => "http://default.ns" })
+      expect(attrs).to be_empty
+      expect(ns).to eq(nil => "http://default.ns")
+    end
+
+    it "returns empty hashes when there are no namespaces" do
+      attrs, ns = splitter.split({ "id" => "1", "name" => "test" })
+      expect(attrs).to eq("id" => "1", "name" => "test")
+      expect(ns).to be_empty
+    end
+
+    it "handles nil attributes" do
+      attrs, ns = splitter.split(nil)
+      expect(attrs).to be_empty
+      expect(ns).to be_empty
+    end
+
+    it "handles empty hash" do
+      attrs, ns = splitter.split({})
+      expect(attrs).to be_empty
+      expect(ns).to be_empty
+    end
+  end
+end

data/spec/moxml/text_spec.rb

@@ -34,7 +34,7 @@ RSpec.describe Moxml::Text do
     end
 
     it "is consistent across adapters" do
-      Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
         ctx = Moxml.new(adapter_name)
         d = ctx.parse("<root>hello world</root>")
         text = d.root.children.first

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # SimpleCov must be loaded before application code
-if ENV.fetch("COVERAGE", nil) == "true"
+if ENV.fetch("COVERAGE", nil) == "true" && RUBY_ENGINE != "opal"
   require "simplecov"
 
   SimpleCov.start do
@@ -25,20 +25,25 @@ if ENV.fetch("COVERAGE", nil) == "true"
 end
 
 require "moxml"
-require "nokogiri"
+require "nokogiri" unless RUBY_ENGINE == "opal"
 
-# Load shared examples from new locations
-Dir[File.expand_path("integration/shared_examples/**/*.rb",
-                     __dir__)].each do |f|
-  require f
-end
-Dir[File.expand_path("moxml/adapter/shared_examples/**/*.rb",
-                     __dir__)].each do |f|
-  require f
+unless RUBY_ENGINE == "opal"
+  # Load shared examples from new locations
+  Dir[File.expand_path("integration/shared_examples/**/*.rb",
+                       __dir__)].each do |f|
+    require f
+  end
+  Dir[File.expand_path("moxml/adapter/shared_examples/**/*.rb",
+                       __dir__)].each do |f|
+    require f
+  end
 end
 Dir[File.expand_path("support/**/*.rb", __dir__)].each { |f| require f }
-Dir[File.expand_path("performance/*.rb", __dir__)].each { |f| require f }
-Dir[File.expand_path("examples/*.rb", __dir__)].each { |f| require f }
+
+unless RUBY_ENGINE == "opal"
+  Dir[File.expand_path("performance/*.rb", __dir__)].each { |f| require f }
+  Dir[File.expand_path("examples/*.rb", __dir__)].each { |f| require f }
+end
 
 # Clear XPath caches immediately to ensure fresh compilation
 # This is critical when code changes affect compiled XPath expressions
@@ -78,12 +83,26 @@ RSpec.configure do |config|
   # Configure to skip examples unless explicitly run
   config.filter_run_excluding examples: true unless ENV["RUN_EXAMPLES"]
 
+  # Under Opal, exclude specs that require native-only adapters or filesystem
+  if RUBY_ENGINE == "opal"
+    config.filter_run_excluding(
+      :native_adapter,
+      :native_fs,
+      :subprocess,
+      :xpath_native,
+      :performance,
+      :examples,
+      :consistency,
+    )
+  end
+
   config.order = :random
   Kernel.srand config.seed
 end
 
 Moxml.configure do |config|
-  config.adapter = :nokogiri
+  config.adapter = RUBY_ENGINE == "opal" ? :rexml : :nokogiri
   config.strict_parsing = true
   config.default_encoding = "UTF-8"
+  config.entity_load_mode = :optional if RUBY_ENGINE == "opal"
 end

data/spec/support/opal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Opal runtime patches for moxml specs.
+#
+# Moxml already handles Opal-specific behavior internally
+# (NativeAttachment::Opal, Config::OPAL_DEFAULT_ADAPTER, EntityRegistry::OPAL_ENTITY_DATA).
+# This file is loaded only under Opal for any additional test-environment patches.
+
+# Under Opal, moxml uses REXML adapter (Opal reimplements strscan/stringio
+# in its stdlib, enabling REXML to compile to JavaScript).
+Moxml.configure do |config|
+  config.adapter = :rexml
+  config.strict_parsing = false
+  config.default_encoding = "UTF-8"
+  config.entity_load_mode = :optional
+end