moxml 0.1.21 → 0.1.23

data/lib/compat/opal/rexml_compat.rb

@@ -0,0 +1,77 @@
+# 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)
+    `return self + #{str}.to_s`
+  end
+
+  def chomp!(sep = nil)
+    `
+      var r = #{chomp(sep)};
+      return r === self ? nil : r;
+    `
+  end
+
+  def gsub!(pattern, replacement, &block)
+    `
+      var r = #{gsub(pattern, replacement, &block)};
+      return r === self ? nil : r;
+    `
+  end
+
+  def squeeze!(*sets)
+    `
+      var r = #{squeeze(*sets)};
+      return r === self ? nil : r;
+    `
+  end
+
+  def strip!
+    `
+      var r = #{strip};
+      return r === self ? nil : r;
+    `
+  end
+end
+
+class StringIO
+  def <<(str)
+    write(str)
+    self
+  end
+end

data/lib/moxml/adapter/customized_oga/xml_declaration.rb

@@ -8,10 +8,17 @@ module Moxml
       class XmlDeclaration < ::Oga::XML::XmlDeclaration
         def initialize(options = {})
           @version    = options[:version] || "1.0"
-          # encoding is optional, but Oga sets it to UTF-8 by default
           @encoding   = options[:encoding]
           @standalone = options[:standalone]
         end
+
+        def to_xml
+          parts = ["<?xml"]
+          parts << %( version="#{version}") if version
+          parts << %( encoding="#{encoding}") if encoding
+          parts << %( standalone="#{standalone}") if standalone
+          "#{parts.join}?>"
+        end
       end
     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/entity_ref_registry.rb

@@ -9,7 +9,8 @@ module Moxml
         ENTITY_REFS_KEY = :_entity_ref_pairs
         CHILD_SEQUENCE_KEY = :_child_seq_pairs
         NON_WHITESPACE_RE = /\S/
-        private_constant :ENTITY_REFS_KEY, :CHILD_SEQUENCE_KEY, :NON_WHITESPACE_RE
+        private_constant :ENTITY_REFS_KEY, :CHILD_SEQUENCE_KEY,
+                         :NON_WHITESPACE_RE
 
         def initialize(attachments, doc)
           @attachments = attachments
@@ -34,7 +35,8 @@ module Moxml
           if existing
             existing << :eref
           else
-            seq_by_path[path] = Array.new(count_native_children(element), :native)
+            seq_by_path[path] =
+              Array.new(count_native_children(element), :native)
             seq_by_path[path] << :eref
             @attachments.set(@doc, CHILD_SEQUENCE_KEY, seq_by_path)
           end

data/lib/moxml/adapter/libxml/entity_restorer.rb

@@ -76,7 +76,9 @@ module Moxml
         def append_chunk(parent, type, payload)
           case type
           when :text
-            parent.add_child(::Moxml::Text.new(@adapter.create_native_text(payload), @ctx))
+            parent.add_child(::Moxml::Text.new(
+                               @adapter.create_native_text(payload), @ctx
+                             ))
           when :eref
             parent.add_child(
               ::Moxml::EntityReference.new(

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
@@ -1179,7 +1182,8 @@ module Moxml
         end
 
         ESCAPE_XML_RE = /[&<>"]/
-        ESCAPE_XML_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;" }.freeze
+        ESCAPE_XML_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
+                           '"' => "&quot;" }.freeze
         private_constant :ESCAPE_XML_RE, :ESCAPE_XML_MAP
 
         def escape_xml(text)
@@ -1275,7 +1279,13 @@ module Moxml
           # attachment query that otherwise fires for every element under
           # Monitor#synchronize.
           eref_active = doc_eref_active?(elem.doc) if eref_active.nil?
-          entity_refs, child_sequence = eref_active ? lookup_entity_ref_serialization(elem) : [nil, nil]
+          entity_refs, child_sequence = if eref_active
+                                          lookup_entity_ref_serialization(elem)
+                                        else
+                                          [
+                                            nil, nil
+                                          ]
+                                        end
 
           # Always use verbose format <tag></tag> for consistency with other adapters
           output << ">"
@@ -1619,8 +1629,14 @@ module Moxml
         # duplicated — callers that need the subtree use deep_duplicate_node.
         def shallow_duplicate_element(native_node)
           new_node = ::LibXML::XML::Node.new(native_node.name)
-          copy_element_namespaces(native_node, new_node) if native_node.is_a?(::LibXML::XML::Node)
-          copy_element_attributes(native_node, new_node) if native_node.attributes?
+          if native_node.is_a?(::LibXML::XML::Node)
+            copy_element_namespaces(native_node,
+                                    new_node)
+          end
+          if native_node.attributes?
+            copy_element_attributes(native_node,
+                                    new_node)
+          end
           new_node
         end
 
@@ -1656,6 +1672,7 @@ module Moxml
       # @private
       class LibXMLSAXBridge
         include ::LibXML::XML::SaxParser::Callbacks
+        include Moxml::SAX::NamespaceSplitter
 
         def initialize(handler)
           @handler = handler
@@ -1672,26 +1689,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
@@ -242,25 +245,22 @@ module Moxml
         end
 
         def add_child(element, child)
-          # Special handling for declarations on Nokogiri documents
           if element.is_a?(::Nokogiri::XML::Document) &&
               child.is_a?(::Nokogiri::XML::ProcessingInstruction) &&
               child.name == "xml"
-            # Set document's xml_decl property
             version = declaration_attribute(child, "version") || "1.0"
             encoding = declaration_attribute(child, "encoding")
             standalone = declaration_attribute(child, "standalone")
 
-            # Store declaration state in attachment map
             attachments.set(element, :xml_decl, {
               version: version,
               encoding: encoding,
               standalone: standalone,
             }.compact)
+            return
           end
 
           if node_type(child) == :doctype
-            # avoid exceptions: cannot reparent Nokogiri::XML::DTD there
             element.create_internal_subset(
               child.name, child.external_id, child.system_id
             )
@@ -394,23 +394,28 @@ module Moxml
             save_options |= ::Nokogiri::XML::Node::SaveOptions::FORMAT
           end
 
-          # Handle declaration option
-          # Priority:
-          # 1. Explicit no_declaration option
-          # 2. Check attachment-stored xml_decl (when remove is called, this becomes nil)
-          if options.key?(:no_declaration)
-            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if options[:no_declaration]
-          elsif attachments.key?(node, :xml_decl)
-            # State stored in attachment - if nil, declaration was removed
-            xml_decl = attachments.get(node, :xml_decl)
-            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if xml_decl.nil?
+          custom_decl = nil
+          if options[:no_declaration]
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+          elsif attachments.key?(node, :xml_decl) && (xml_decl = attachments.get(node, :xml_decl))
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+            attrs = ["version=\"#{xml_decl[:version]}\""]
+            attrs << "encoding=\"#{xml_decl[:encoding]}\"" if xml_decl[:encoding]
+            attrs << "standalone=\"#{xml_decl[:standalone]}\"" if xml_decl[:standalone]
+            custom_decl = "<?xml #{attrs.join(' ')}?>"
           end
 
-          node.to_xml(
+          result = node.to_xml(
             indent: options[:indent],
             encoding: options[:encoding],
             save_with: save_options,
           )
+
+          if custom_decl
+            result = "#{custom_decl}\n#{result}"
+          end
+
+          result
         end
 
         def has_declaration?(native_doc, wrapper)
@@ -446,6 +451,8 @@ module Moxml
       #
       # @private
       class NokogiriSAXBridge < ::Nokogiri::XML::SAX::Document
+        include Moxml::SAX::NamespaceSplitter
+
         def initialize(handler)
           super()
           @handler = handler
@@ -462,24 +469,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
@@ -288,11 +289,25 @@ module Moxml
               child_or_text
             end
 
-          # Special handling for declarations on Oga documents
           if element.is_a?(::Oga::XML::Document) &&
               child.is_a?(::Oga::XML::XmlDeclaration)
-            # Track declaration state in attachment map
             attachments.set(element, :xml_declaration, child)
+            return
+          end
+
+          # Insert doctype before root element in document
+          if element.is_a?(::Oga::XML::Document) && child.is_a?(::Oga::XML::Doctype)
+            root_idx = nil
+            element.children.each_with_index do |n, i|
+              if n.is_a?(::Oga::XML::Element)
+                root_idx = i
+                break
+              end
+            end
+            if root_idx
+              element.children.insert(root_idx, child)
+              return
+            end
           end
 
           element.children << child
@@ -464,86 +479,53 @@ module Moxml
 
         private
 
+        def declaration_to_xml(decl)
+          parts = ["<?xml"]
+          parts << %( version="#{decl.version}") if decl.version
+          parts << %( encoding="#{decl.encoding}") if decl.encoding
+          parts << %( standalone="#{decl.standalone}") if decl.standalone
+          "#{parts.join}?>"
+        end
+
         def serialize_without_entity_processing(node, options = {})
-          # Oga's XmlGenerator doesn't support options directly
-          # We need to handle declaration options ourselves for Document nodes
           if node.is_a?(::Oga::XML::Document)
-            # Check if we should include declaration
-            # Priority: explicit option > existence of xml_declaration (native or attachment)
-            effective_xml_declaration = node.xml_declaration || attachments.get(
-              node, :xml_declaration
-            )
+            effective_xml_declaration = attachments.get(node, :xml_declaration)
+
             should_include_decl = if options.key?(:no_declaration)
                                     !options[:no_declaration]
                                   elsif options.key?(:declaration)
                                     options[:declaration]
                                   else
-                                    # Default: include if document has xml_declaration
-                                    effective_xml_declaration ? true : false
+                                    effective_xml_declaration || node.xml_declaration ? true : false
                                   end
 
-            # Fix: Check if declaration already exists in children
-            # This prevents duplicate declarations when document already has one
-            has_existing_declaration = node.children.any?(::Oga::XML::XmlDeclaration)
-
-            if should_include_decl && !effective_xml_declaration && !has_existing_declaration
-              # Need to add declaration - create default one
-              output = []
-              output << '<?xml version="1.0" encoding="UTF-8"?>'
-              output << "\n"
-
-              # Serialize doctype if present
-              output << node.doctype.to_xml << "\n" if node.doctype
-
-              # Serialize children
-              node.children.each do |child|
-                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
-              end
-
-              return output.join
-            elsif !should_include_decl
-              # Skip xml_declaration
-              output = []
-
-              # Serialize doctype if present
-              output << node.doctype.to_xml << "\n" if node.doctype
-
-              # Serialize root and other children
-              node.children.each do |child|
-                next if child.is_a?(::Oga::XML::XmlDeclaration)
+            output = []
 
-                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
+            if should_include_decl
+              decl = effective_xml_declaration || node.xml_declaration
+              if decl
+                output << declaration_to_xml(decl)
+              else
+                output << '<?xml version="1.0" encoding="UTF-8"?>'
               end
-
-              return output.join
+              output << "\n"
             end
-          end
 
-          # Default: use XmlGenerator
-          # But first check if we need to handle declaration specially
-          effective_xml_declaration = node.is_a?(::Oga::XML::Document) && (node.xml_declaration || attachments.get(
-            node, :xml_declaration
-          ))
-          if node.is_a?(::Oga::XML::Document) && effective_xml_declaration
-            # Document has declaration - use custom handling to avoid duplicates
-            output = []
-            xml_declaration_serialized = false
+            if node.doctype
+              output << node.doctype.to_xml
+              output << "\n"
+            end
 
-            # Serialize children, but skip XmlDeclaration if it would cause duplication
             node.children.each do |child|
-              xml_declaration = child.is_a?(::Oga::XML::XmlDeclaration)
-              next if xml_declaration && xml_declaration_serialized
-
-              xml_declaration_serialized = true if xml_declaration
+              next if child.is_a?(::Oga::XML::XmlDeclaration)
 
               output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
             end
 
-            output.join
-          else
-            # Normal case - use XmlGenerator directly
-            ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
+            return output.join
           end
+
+          ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
         end
       end
     end
@@ -555,6 +537,8 @@ module Moxml
     #
     # @private
     class OgaSAXBridge
+      include Moxml::SAX::NamespaceSplitter
+
       def initialize(handler)
         @handler = handler
       end
@@ -563,29 +547,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