moxml 0.1.20 → 0.1.22

data/lib/moxml/adapter/nokogiri.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+return if RUBY_ENGINE == "opal"
+
 require_relative "base"
 require "nokogiri"
+require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
@@ -446,6 +449,8 @@ module Moxml
       #
       # @private
       class NokogiriSAXBridge < ::Nokogiri::XML::SAX::Document
+        include Moxml::SAX::NamespaceSplitter
+
         def initialize(handler)
           super()
           @handler = handler
@@ -462,24 +467,8 @@ module Moxml
         end
 
         def start_element(name, attributes = [])
-          # Convert Nokogiri attributes array to hash
-          attr_hash = {}
-          namespaces_hash = {}
-
-          attributes.each do |attr|
-            attr_name = attr[0]
-            attr_value = attr[1]
-
-            if attr_name.start_with?("xmlns")
-              # Namespace declaration
-              prefix = attr_name == "xmlns" ? nil : attr_name.sub("xmlns:", "")
-              namespaces_hash[prefix] = attr_value
-            else
-              attr_hash[attr_name] = attr_value
-            end
-          end
-
-          @handler.on_start_element(name, attr_hash, namespaces_hash)
+          attr_hash, ns_hash = split_attributes_and_namespaces(attributes)
+          @handler.on_start_element(name, attr_hash, ns_hash)
         end
 
         def end_element(name)

data/lib/moxml/adapter/oga.rb

@@ -3,6 +3,7 @@
 require_relative "base"
 require_relative "customized_oga"
 require "oga"
+require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
@@ -555,6 +556,8 @@ module Moxml
     #
     # @private
     class OgaSAXBridge
+      include Moxml::SAX::NamespaceSplitter
+
       def initialize(handler)
         @handler = handler
       end
@@ -563,29 +566,8 @@ module Moxml
       # namespace may be nil
       # attributes is an array of [name, value] pairs
       def on_element(namespace, name, attributes)
-        # Build full qualified name if namespace present
         element_name = namespace ? "#{namespace}:#{name}" : name
-
-        # Convert Oga attributes to hash
-        attr_hash = {}
-        ns_hash = {}
-
-        # Oga delivers attributes as array of [name, value] pairs
-        attributes.each do |attr_name, attr_value|
-          if attr_name.to_s.start_with?("xmlns")
-            prefix = if attr_name.to_s == "xmlns"
-                       nil
-                     else
-                       attr_name.to_s.sub(
-                         "xmlns:", ""
-                       )
-                     end
-            ns_hash[prefix] = attr_value
-          else
-            attr_hash[attr_name.to_s] = attr_value
-          end
-        end
-
+        attr_hash, ns_hash = split_attributes_and_namespaces(attributes)
         @handler.on_start_element(element_name, attr_hash, ns_hash)
       end
 

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
@@ -188,7 +191,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
@@ -903,6 +906,8 @@ module Moxml
     #
     # @private
     class OxSAXBridge
+      include Moxml::SAX::NamespaceSplitter
+
       def initialize(handler)
         @handler = handler
         @pending_attrs = {}
@@ -972,28 +977,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.map(&:to_s).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

@@ -4,7 +4,7 @@ module Moxml
   class Config
     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)

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,40 @@ 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 +268,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 +290,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 +300,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 +313,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