moxml 0.1.21 → 0.1.22

data/lib/compat/opal/rexml_compat.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+# backtick_javascript: true
+
+require 'corelib/array/pack'
+
+unless defined?(StringScanner::Version)
+  class StringScanner
+    Version = "3.0.8"
+  end
+end
+
+unless String.method_defined?(:force_encoding)
+  class String
+    def force_encoding(*)
+      self
+    end
+  end
+end
+
+unless defined?(::Encoding)
+  module ::Encoding
+    UTF_8 = "UTF-8"
+    ASCII_8BIT = "ASCII-8BIT"
+  end
+end
+
+unless String.method_defined?(:encode)
+  class String
+    def encode(*)
+      self
+    end
+  end
+end
+
+# Opal defines mutable String methods as raising NotImplementedError.
+# Override with functional equivalents that return new strings.
+class String
+  def <<(str)
+    %x{return self + #{str}.to_s}
+  end
+
+  def chomp!(sep = nil)
+    %x{
+      var r = #{chomp(sep)};
+      return r === self ? nil : r;
+    }
+  end
+
+  def gsub!(pattern, replacement, &block)
+    %x{
+      var r = #{gsub(pattern, replacement, &block)};
+      return r === self ? nil : r;
+    }
+  end
+
+  def squeeze!(*sets)
+    %x{
+      var r = #{squeeze(*sets)};
+      return r === self ? nil : r;
+    }
+  end
+
+  def strip!
+    %x{
+      var r = #{strip};
+      return r === self ? nil : r;
+    }
+  end
+end
+
+class StringIO
+  def <<(str)
+    write(str)
+    self
+  end
+end

data/lib/moxml/adapter/customized_rexml/formatter.rb

@@ -27,8 +27,11 @@ module Moxml
           end
         end
 
+        def indented?
+          !@indentation.empty?
+        end
+
         def write_element(node, output)
-          # output << ' ' * @level
           output << "<#{node.expanded_name}"
           write_attributes(node, output)
 
@@ -45,18 +48,16 @@ module Moxml
 
           output << ">"
 
-          # Check for mixed content
           has_text = node.children.any? { |c| c.is_a?(::REXML::Text) && !c.to_s.strip.empty? }
           has_elements = node.children.any?(::REXML::Element)
-          mixed = has_text && has_elements
+          indent_children = indented? && has_elements && !has_text
 
           # Handle children based on content type
           all_children_empty = node.children.empty? && !(entity_refs && !entity_refs.empty?)
           unless all_children_empty
-            @level += @indentation.length unless mixed
+            @level += @indentation.length if indent_children
 
             if entity_refs && !entity_refs.empty? && child_sequence
-              # Interleave native children with entity refs using tracked sequence
               eref_idx = 0
               native_idx = 0
               child_sequence.each do |type|
@@ -69,10 +70,12 @@ module Moxml
                       child.to_s.strip.empty? &&
                       !(child.next_sibling.nil? && child.previous_sibling.nil?)
 
+                    output << "\n" << (' ' * @level) if indent_children
                     write(child, output)
                   end
                 when :eref
                   if eref_idx < entity_refs.size
+                    output << "\n" << (' ' * @level) if indent_children
                     write(entity_refs[eref_idx], output)
                     eref_idx += 1
                   end
@@ -80,24 +83,22 @@ module Moxml
               end
             else
               node.children.each_with_index do |child, _index|
-                # Skip insignificant whitespace
                 next if child.is_a?(::REXML::Text) &&
                   child.to_s.strip.empty? &&
                   !(child.next_sibling.nil? && child.previous_sibling.nil?)
 
+                output << "\n" << (' ' * @level) if indent_children
                 write(child, output)
               end
             end
 
-            # Reset indentation for closing tag in non-mixed content
-            unless mixed
+            if indent_children
               @level -= @indentation.length
-              # output << ' ' * @level
+              output << "\n" << (' ' * @level)
             end
           end
 
           output << "</#{node.expanded_name}>"
-          # output << "\n" unless mixed
         end
 
         def write_text(node, output)

data/lib/moxml/adapter/headed_ox.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+return if RUBY_ENGINE == "opal"
+
 require_relative "ox"
 require_relative "../xpath"
 # Force load XPath modules (autoload doesn't work well with relative requires in examples)
@@ -66,14 +68,8 @@ module Moxml
         # @param [Hash] namespaces Namespace prefix mappings
         # @return [Array, Object] Native node array or scalar value
         def xpath(node, expression, namespaces = {})
-          # If we receive a native node, wrap it first
-          # Document#xpath passes @native, but our compiled XPath needs Moxml nodes
           unless node.is_a?(Moxml::Node)
-            # Determine the context from the node if possible
-            # For now, create a basic context for wrapped nodes
             ctx = Context.new(:headed_ox)
-
-            # Wrap the native node - don't rebuild the whole document
             node = Moxml::Node.wrap(node, ctx)
           end
 

data/lib/moxml/adapter/libxml.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+return if RUBY_ENGINE == "opal"
+
 require_relative "base"
 require "libxml"
 require_relative "customized_libxml"
+require_relative "../sax/namespace_splitter"
 
 module Moxml
   module Adapter
@@ -1656,6 +1659,7 @@ module Moxml
       # @private
       class LibXMLSAXBridge
         include ::LibXML::XML::SaxParser::Callbacks
+        include Moxml::SAX::NamespaceSplitter
 
         def initialize(handler)
           @handler = handler
@@ -1672,26 +1676,7 @@ module Moxml
         end
 
         def on_start_element(name, attributes)
-          # Convert LibXML attributes hash to separate attrs and namespaces
-          attr_hash = {}
-          ns_hash = {}
-
-          attributes&.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
-              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(name.to_s, attr_hash, ns_hash)
         end
 

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)