moxml 0.1.21 → 0.1.23

data/lib/moxml/adapter/ox.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+return if RUBY_ENGINE == "opal"
+
 require_relative "base"
 require "ox"
 require "stringio"
 require_relative "customized_ox"
+require_relative "../sax/namespace_splitter"
 
 # insert :parent methods to all Ox classes inherit the Node class
 Ox::Node.attr_accessor :parent
@@ -16,7 +19,17 @@ module Moxml
         end
 
         def set_root(doc, element)
-          replace_children(doc, [element])
+          existing_root = root(doc)
+          if existing_root
+            # Replace the existing root element, preserving other children
+            element.parent = doc if element.is_a?(::Ox::Node)
+            idx = doc.nodes.index(existing_root)
+            doc.nodes[idx] = element
+          else
+            # No root yet, just append the element
+            element.parent = doc if element.is_a?(::Ox::Node)
+            doc << element
+          end
         end
 
         def parse(xml, options = {}, _context = nil)
@@ -98,9 +111,14 @@ module Moxml
         end
 
         def create_native_doctype(name, external_id, system_id)
-          ::Ox::DocType.new(
-            "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\"",
-          )
+          value = if external_id
+                    "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\""
+                  elsif system_id
+                    "#{name} SYSTEM \"#{system_id}\""
+                  else
+                    "#{name}"
+                  end
+          ::Ox::DocType.new(value)
         end
 
         def create_native_processing_instruction(target, content)
@@ -188,7 +206,7 @@ module Moxml
           when ::Ox::Element then :element
           when ::Ox::DocType then :doctype
           when ::Moxml::Adapter::CustomizedOx::EntityReference then :entity_reference
-          when ::Moxml::Adapter::CustomizedOx::Namespace then :banespace
+          when ::Moxml::Adapter::CustomizedOx::Namespace then :namespace
           when ::Moxml::Adapter::CustomizedOx::Attribute then :attribute
           else :unknown
           end
@@ -367,25 +385,27 @@ module Moxml
         def add_child(element, child)
           # Special handling for declarations on Ox documents
           if element.is_a?(::Ox::Document) && child.is_a?(::Ox::Instruct) && child.target == "xml"
-            # Transfer declaration attributes to document
             element.attributes ||= {}
-            if child.attributes["version"]
-              element.attributes[:version] =
-                child.attributes["version"]
-            end
-            if child.attributes["encoding"]
-              element.attributes[:encoding] =
-                child.attributes["encoding"]
-            end
-            if child.attributes["standalone"]
-              element.attributes[:standalone] =
-                child.attributes["standalone"]
-            end
+            element.attributes[:version] = child.attributes["version"] if child.attributes["version"]
+            element.attributes[:encoding] = child.attributes["encoding"] if child.attributes["encoding"]
+            element.attributes[:standalone] = child.attributes["standalone"] if child.attributes["standalone"]
+            return
           end
 
           child.parent = element if child.is_a?(::Ox::Node)
           element.nodes ||= []
-          element.nodes << child
+
+          # Insert doctype before root element in document
+          if element.is_a?(::Ox::Document) && child.is_a?(::Ox::DocType)
+            root_idx = element.nodes.index { |n| n.is_a?(::Ox::Element) }
+            if root_idx
+              element.nodes.insert(root_idx, child)
+            else
+              element.nodes << child
+            end
+          else
+            element.nodes << child
+          end
 
           # Mark document if EntityReference is added (avoids tree scan in serialize)
           if child.is_a?(::Moxml::Adapter::CustomizedOx::EntityReference)
@@ -903,6 +923,8 @@ module Moxml
     #
     # @private
     class OxSAXBridge
+      include Moxml::SAX::NamespaceSplitter
+
       def initialize(handler)
         @handler = handler
         @pending_attrs = {}
@@ -972,28 +994,8 @@ module Moxml
       private
 
       def finalize_pending_element
-        # Separate namespace declarations from regular attributes
-        attr_hash = {}
-        namespaces_hash = {}
-
-        @pending_attrs.each do |attr_name, attr_value|
-          if attr_name.to_s.start_with?("xmlns")
-            # Namespace declaration
-            prefix = if attr_name.to_s == "xmlns"
-                       nil
-                     else
-                       attr_name.to_s.sub(
-                         "xmlns:", ""
-                       )
-                     end
-            namespaces_hash[prefix] = attr_value
-          else
-            attr_hash[attr_name.to_s] = attr_value
-          end
-        end
-
-        @handler.on_start_element(@pending_element_name, attr_hash,
-                                  namespaces_hash)
+        attr_hash, ns_hash = split_attributes_and_namespaces(@pending_attrs)
+        @handler.on_start_element(@pending_element_name, attr_hash, ns_hash)
 
         # Clear for next element
         @pending_attrs = {}

data/lib/moxml/adapter/rexml.rb

@@ -3,8 +3,10 @@
 require_relative "base"
 require "rexml/document"
 require "rexml/xpath"
-require "set"
+require "set" unless RUBY_ENGINE == "opal"
+require "stringio" if RUBY_ENGINE == "opal"
 require_relative "customized_rexml"
+require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
@@ -45,9 +47,13 @@ module Moxml
         end
 
         def extract_encoding_from_xml(xml)
-          # Match XML declaration pattern: <?xml version="..." encoding="..."?>
-          # Use atomic group (?>) to prevent polynomial backtracking ReDoS
-          match = xml.match(/<\?xml(?>[^>]*)\bencoding\s*=\s*["']([^"']+)["']/i)
+          return "UTF-8" unless xml.start_with?("<?xml")
+
+          decl_end = xml.index("?>")
+          return "UTF-8" unless decl_end
+
+          decl = xml[0...decl_end]
+          match = decl.match(/encoding\s*=\s*["']([^"']+)["']/i)
           match ? match[1] : "UTF-8"
         end
 
@@ -195,21 +201,19 @@ module Moxml
         def next_sibling(node)
           current = node.next_sibling
 
-          # Skip empty text nodes and duplicates
-          seen = Set.new
+          seen = {}
           while current
             if current.is_a?(::REXML::Text) && current.to_s.strip.empty?
               current = current.next_sibling
               next
             end
 
-            # Check for duplicates
-            if seen.include?(current.object_id)
+            if seen[current.object_id]
               current = current.next_sibling
               next
             end
 
-            seen.add(current.object_id)
+            seen[current.object_id] = true
             break
           end
 
@@ -219,21 +223,19 @@ module Moxml
         def previous_sibling(node)
           current = node.previous_sibling
 
-          # Skip empty text nodes and duplicates
-          seen = Set.new
+          seen = {}
           while current
             if current.is_a?(::REXML::Text) && current.to_s.strip.empty?
               current = current.previous_sibling
               next
             end
 
-            # Check for duplicates
-            if seen.include?(current.object_id)
+            if seen[current.object_id]
               current = current.previous_sibling
               next
             end
 
-            seen.add(current.object_id)
+            seen[current.object_id] = true
             break
           end
 
@@ -546,8 +548,12 @@ module Moxml
           ns
         end
 
-        def xpath(node, expression, _namespaces = {})
-          node.get_elements(expression).to_a
+        def xpath(node, expression, namespaces = {})
+          if namespaces && !namespaces.empty?
+            ::REXML::XPath.match(node, expression, namespaces)
+          else
+            node.get_elements(expression).to_a
+          end
         rescue ::REXML::ParseException => e
           raise Moxml::XPathError.new(
             e.message,
@@ -563,7 +569,8 @@ module Moxml
         end
 
         def serialize(node, options = {})
-          output = +""
+          output = StringIO.new("") if RUBY_ENGINE == "opal"
+          output ||= +""
 
           if node.is_a?(::REXML::Document)
             # Check if we should include declaration
@@ -606,7 +613,8 @@ module Moxml
             write_with_formatter(node, output, options[:indent] || 2)
           end
 
-          output.strip
+          result = output.is_a?(StringIO) ? output.string : output
+          result.strip
         end
 
         def has_declaration?(native_doc, wrapper)
@@ -641,27 +649,15 @@ module Moxml
     #
     # @private
     class REXMLSAX2Bridge
+      include Moxml::SAX::NamespaceSplitter
+
       def initialize(handler)
         @handler = handler
       end
 
       # REXML splits element name into uri/localname/qname
       def start_element(_uri, _localname, qname, attributes)
-        # Convert REXML attributes to hash
-        attr_hash = {}
-        ns_hash = {}
-
-        attributes.each do |name, value|
-          if name.to_s.start_with?("xmlns")
-            # Namespace declaration
-            prefix = name.to_s == "xmlns" ? nil : name.to_s.sub("xmlns:", "")
-            ns_hash[prefix] = value
-          else
-            attr_hash[name.to_s] = value
-          end
-        end
-
-        # Use qname (qualified name) for element name
+        attr_hash, ns_hash = split_attributes_and_namespaces(attributes)
         @handler.on_start_element(qname, attr_hash, ns_hash)
       end
 

data/lib/moxml/adapter.rb

@@ -4,18 +4,25 @@ require_relative "adapter/base"
 
 module Moxml
   module Adapter
-    AVALIABLE_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
+    AVAILABLE_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
+
+    # Adapters that work under the Opal (JavaScript) runtime.
+    # REXML is pure Ruby and Opal reimplements strscan/stringio in its stdlib,
+    # enabling REXML to compile cleanly to JavaScript.
+    OPAL_AVAILABLE_ADAPTERS = %i[rexml].freeze
+
+    # Registry mapping adapter names to their class name suffixes.
+    # Special cases (like :headed_ox → "HeadedOx") live here instead of
+    # a case statement, keeping the dispatch open for extension.
+    CONST_NAME_MAP = {
+      headed_ox: "HeadedOx",
+    }.freeze
 
     class << self
       def load(name)
+        validate_platform!(name)
         require_adapter(name)
-        # Handle special case for headed_ox -> HeadedOx
-        const_name = case name
-                     when :headed_ox
-                       "HeadedOx"
-                     else
-                       name.to_s.capitalize
-                     end
+        const_name = const_name_for(name)
         const_get(const_name)
       rescue LoadError => e
         raise Moxml::AdapterError.new(
@@ -26,8 +33,31 @@ module Moxml
         )
       end
 
+      def available?(name)
+        platform_adapters.include?(name.to_sym)
+      end
+
+      def platform_adapters
+        RUBY_ENGINE == "opal" ? OPAL_AVAILABLE_ADAPTERS : AVAILABLE_ADAPTERS
+      end
+
       private
 
+      def validate_platform!(name)
+        return if platform_adapters.include?(name.to_sym)
+
+        available = platform_adapters.join(", ")
+        raise Moxml::AdapterError.new(
+          "The '#{name}' adapter is not available on this platform. Available: #{available}",
+          adapter: name,
+          operation: "platform_check",
+        )
+      end
+
+      def const_name_for(name)
+        CONST_NAME_MAP[name.to_sym] || name.to_s.capitalize
+      end
+
       def require_adapter(name)
         require "#{__dir__}/adapter/#{name}"
       rescue LoadError

data/lib/moxml/config.rb

@@ -2,9 +2,12 @@
 
 module Moxml
   class Config
+    LINE_ENDING_LF = "\n"
+    LINE_ENDING_CRLF = "\r\n"
+    VALID_LINE_ENDINGS = [LINE_ENDING_LF, LINE_ENDING_CRLF].freeze
     VALID_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
     DEFAULT_ADAPTER = :nokogiri
-    OPAL_DEFAULT_ADAPTER = :oga
+    OPAL_DEFAULT_ADAPTER = :rexml
 
     # Entity loading modes:
     # - :required - Must load entities, raise error if unavailable (default)
@@ -46,7 +49,7 @@ module Moxml
     # - :strict — only restore DTD-declared entities (falls back to lenient until DTD parsing is implemented)
     ENTITY_RESTORATION_MODES = %i[strict lenient].freeze
 
-    attr_reader :adapter_name
+    attr_reader :adapter_name, :default_line_ending
     attr_accessor :strict_parsing,
                   :default_encoding,
                   :entity_encoding,
@@ -58,13 +61,23 @@ module Moxml
                   :namespace_validation_mode,
                   :entity_restoration_mode
 
+    def default_line_ending=(value)
+      unless VALID_LINE_ENDINGS.include?(value)
+        raise ArgumentError,
+              "Invalid line_ending: #{value.inspect}. " \
+              "Must be Config::LINE_ENDING_LF or Config::LINE_ENDING_CRLF"
+      end
+
+      @default_line_ending = value
+    end
+
     def initialize(adapter_name = nil, strict_parsing = nil,
                    default_encoding = nil)
       self.adapter = adapter_name || Config.default.adapter_name
       @strict_parsing = strict_parsing || Config.default.strict_parsing
       @default_encoding = default_encoding || Config.default.default_encoding
-      # reserved for future use
       @default_indent = 2
+      @default_line_ending = LINE_ENDING_LF
       @entity_encoding = :basic
       @restore_entities = false
       @preload_entity_sets = []

data/lib/moxml/document.rb

@@ -81,14 +81,8 @@ module Moxml
       if node.is_a?(Declaration)
         # Mark that document now has a declaration
         @has_xml_declaration = true
-
-        if children.empty?
-          adapter.add_child(@native, node.native)
-        else
-          adapter.add_previous_sibling(adapter.children(@native).first,
-                                       node.native)
-        end
-      elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment)
+        adapter.add_child(@native, node.native)
+      elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment) && !node.is_a?(Doctype)
         raise Error, "Document already has a root element"
       else
         adapter.add_child(@native, node.native)

data/lib/moxml/entity_registry.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
+require "json" unless RUBY_ENGINE == "opal"
 require "set"
+require_relative "entity_registry_opal_data" if RUBY_ENGINE == "opal"
 
 module Moxml
   # EntityRegistry maintains a knowledge base of XML entity definitions.
@@ -55,6 +56,10 @@ module Moxml
       # Load entity data from bundled gem data or local file
       # @return [Hash{String => String}]
       def load_entity_data
+        if RUBY_ENGINE == "opal"
+          return OPAL_ENTITY_DATA
+        end
+
         # Try multiple paths in order of priority
         paths_to_try = []
 
@@ -216,33 +221,44 @@ module Moxml
       self
     end
 
-    # Load all entities from the W3C HTMLMathML entity set
-    # This is called automatically by initialize
+    # Load all entities from the W3C HTMLMathML entity set.
+    # All entities are loaded during initialize; this method is a no-op
+    # kept for backward compatibility.
     # @return [self]
     def load_html5
-      # All entities are loaded by default from initialize
+      warn "EntityRegistry#load_html5 is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
-    # Load MathML entity set (included in HTMLMathML)
+    # Load MathML entity set (included in HTMLMathML).
+    # All entities are loaded during initialize; this method is a no-op
+    # kept for backward compatibility.
     # @return [self]
     def load_mathml
-      # All entities are loaded by default from initialize
+      warn "EntityRegistry#load_mathml is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
-    # Load ISO entity sets (included in HTMLMathML)
+    # Load ISO entity sets (included in HTMLMathML).
+    # All entities are loaded during initialize; this method is a no-op
+    # kept for backward compatibility.
     # @param _set_name [Symbol] (ignored, all loaded together)
     # @return [self]
     def load_iso(_set_name = :iso8879)
-      # All entities are loaded by default from initialize
+      warn "EntityRegistry#load_iso is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
-    # Load all standard entity sets
+    # Load all standard entity sets.
+    # All entities are loaded during initialize; this method is a no-op
+    # kept for backward compatibility.
     # @return [self]
     def load_all
-      # All entities are loaded by default from initialize
+      warn "EntityRegistry#load_all is a no-op (all entities load during initialize)",
+           uplevel: 1
       self
     end
 
@@ -256,6 +272,17 @@ module Moxml
 
     private
 
+    def populate_from_hash(data)
+      data.each do |name, char_or_codepoint|
+        codepoint = char_or_codepoint.is_a?(Integer) ? char_or_codepoint : parse_codepoint(char_or_codepoint)
+        next unless codepoint
+
+        @by_name[name] = codepoint
+        @by_codepoint[codepoint] ||= []
+        @by_codepoint[codepoint] << name unless @by_codepoint[codepoint].include?(name)
+      end
+    end
+
     # Load entities from the centralized JSON data source
     # @raise [EntityDataError] if entity data is required but cannot be loaded
     # @return [void]
@@ -267,14 +294,7 @@ module Moxml
               "Entity data is not available. Set entity_load_mode to :optional or :disabled to skip entity loading."
       end
 
-      data.each do |name, char|
-        codepoint = parse_codepoint(char)
-        next unless codepoint
-
-        @by_name[name] = codepoint
-        @by_codepoint[codepoint] ||= []
-        @by_codepoint[codepoint] << name unless @by_codepoint[codepoint].include?(name)
-      end
+      populate_from_hash(data)
     end
 
     # Load entities from the centralized JSON data source (optional mode)
@@ -284,14 +304,7 @@ module Moxml
       data = self.class.entity_data
       return unless data
 
-      data.each do |name, char|
-        codepoint = parse_codepoint(char)
-        next unless codepoint
-
-        @by_name[name] = codepoint
-        @by_codepoint[codepoint] ||= []
-        @by_codepoint[codepoint] << name unless @by_codepoint[codepoint].include?(name)
-      end
+      populate_from_hash(data)
     rescue EntityDataError
       # Silently ignore - optional mode
     end
@@ -304,11 +317,7 @@ module Moxml
       entities = @entity_provider.call
       return unless entities
 
-      entities.each do |name, codepoint|
-        @by_name[name] = codepoint
-        @by_codepoint[codepoint] ||= []
-        @by_codepoint[codepoint] << name unless @by_codepoint[codepoint].include?(name)
-      end
+      populate_from_hash(entities)
     end
 
     # Parse a Unicode character escape to codepoint