moxml 0.1.20 → 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/base.rb

@@ -46,6 +46,11 @@ module Moxml
                 else
                   xml.encode("UTF-8")
                 end
+          # Fast path: no `&` means no entity references to mark — skip
+          # the regex scan and string allocation entirely. The vast
+          # majority of XML payloads contain no entity references.
+          return str unless str.include?("&")
+
           str.gsub(ENTITY_NAME_RE) do |match|
             STANDARD_ENTITIES.include?(::Regexp.last_match(1)) ? match : "#{ENTITY_MARKER}#{::Regexp.last_match(1)};"
           end

data/lib/moxml/adapter/customized_libxml/node.rb

@@ -8,6 +8,9 @@ module Moxml
       # This wrapper hides LibXML's strict document ownership model,
       # allowing nodes to be moved between documents transparently.
       # Similar pattern to Ox adapter's customized classes.
+      #
+      # The Libxml adapter owns wrapper type mapping in one place so the
+      # wrapper classes do not duplicate node-type knowledge.
       class Node
         attr_reader :native
 

data/lib/moxml/adapter/customized_libxml/text.rb

@@ -19,7 +19,12 @@ module Moxml
         # LibXML's .content already contains escaped text, but it over-escapes
         # quotes which don't need escaping in text nodes (only in attributes)
         def to_xml
-          @native.content.gsub(""", '"')
+          content = @native.content
+          # Skip the gsub allocation entirely when there's nothing to undo —
+          # the common case for parsed text without literal quotes.
+          return content unless content.include?(""")
+
+          content.gsub(""", '"')
         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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Libxml < Base
+      # Tracks entity-reference insertions that cannot live in LibXML's native
+      # node tree, plus the child sequence needed to serialize them in order.
+      class EntityRefRegistry
+        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
+
+        def initialize(attachments, doc)
+          @attachments = attachments
+          @doc = doc
+        end
+
+        def active?
+          @doc ? @attachments.key?(@doc, ENTITY_REFS_KEY) : false
+        end
+
+        def register(element, ref)
+          return unless @doc && element
+
+          path = path_for(element)
+
+          refs_by_path = @attachments.get(@doc, ENTITY_REFS_KEY) || {}
+          (refs_by_path[path] ||= []) << ref
+          @attachments.set(@doc, ENTITY_REFS_KEY, refs_by_path)
+
+          seq_by_path = @attachments.get(@doc, CHILD_SEQUENCE_KEY) || {}
+          existing = seq_by_path[path]
+          if existing
+            existing << :eref
+          else
+            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
+        end
+
+        def append_native(element)
+          return unless @doc && element
+
+          seq_by_path = @attachments.get(@doc, CHILD_SEQUENCE_KEY)
+          return unless seq_by_path
+
+          seq = seq_by_path[path_for(element)]
+          return unless seq
+
+          seq << :native
+        end
+
+        def refs_for(element)
+          return nil unless @doc && element
+
+          refs_by_path = @attachments.get(@doc, ENTITY_REFS_KEY)
+          refs_by_path && refs_by_path[path_for(element)]
+        end
+
+        def sequence_for(element)
+          return nil unless @doc && element
+
+          seq_by_path = @attachments.get(@doc, CHILD_SEQUENCE_KEY)
+          seq_by_path && seq_by_path[path_for(element)]
+        end
+
+        def serialization_for(element)
+          refs = refs_for(element)
+          return [nil, nil] unless refs && !refs.empty?
+
+          seq = sequence_for(element)
+          return [nil, nil] unless seq
+
+          [refs, seq]
+        end
+
+        private
+
+        def path_for(element)
+          element.path
+        end
+
+        def count_native_children(element)
+          return 0 unless element.is_a?(::LibXML::XML::Node) && element.children?
+
+          count = 0
+          element.each_child do |child|
+            count += 1 unless blank_text_node?(child)
+          end
+          count
+        end
+
+        def blank_text_node?(child)
+          child.text? && blank_content?(child.content)
+        end
+
+        def blank_content?(content)
+          content.nil? || !content.match?(NON_WHITESPACE_RE)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Libxml < Base
+      # Restores configured character entities into explicit Moxml
+      # EntityReference nodes after LibXML has parsed the native tree.
+      class EntityRestorer
+        def initialize(doc, adapter: Libxml)
+          @doc = doc
+          @ctx = doc.context
+          @registry = @ctx.entity_registry
+          @config = @ctx.config
+          @adapter = adapter
+        end
+
+        def run
+          return unless @registry && @doc.root
+
+          walk(@doc.root)
+        end
+
+        private
+
+        def walk(element)
+          # Snapshot because we may add/remove siblings during the walk.
+          element.children.to_a.each do |child|
+            if child.is_a?(::Moxml::Text)
+              restore_text_node(child)
+            elsif child.is_a?(::Moxml::Element)
+              walk(child)
+            end
+          end
+        end
+
+        # Matches DocumentBuilder's previous behavior, including the libxml
+        # limitation that adjacent native text nodes get merged.
+        def restore_text_node(text_node)
+          content = text_node.content
+          return unless content
+
+          chunks = chunk_text(content)
+          return if chunks.size == 1 && chunks.first.first == :text
+
+          parent = text_node.parent
+          return unless parent
+
+          text_node.remove
+          chunks.each { |type, payload| append_chunk(parent, type, payload) }
+        end
+
+        def chunk_text(content)
+          chunks = []
+          buffer = +""
+          restorable = @registry.restorable_codepoints
+
+          content.each_char do |char|
+            cp = char.ord
+            if restorable.include?(cp) &&
+                (name = @registry.primary_name_for_codepoint(cp)) &&
+                @registry.should_restore?(cp, config: @config)
+              unless buffer.empty?
+                chunks << [:text, buffer.dup]
+                buffer.clear
+              end
+              chunks << [:eref, name]
+            else
+              buffer << char
+            end
+          end
+
+          chunks << [:text, buffer.dup] unless buffer.empty?
+          chunks
+        end
+
+        def append_chunk(parent, type, payload)
+          case type
+          when :text
+            parent.add_child(::Moxml::Text.new(@adapter.create_native_text(payload), @ctx))
+          when :eref
+            parent.add_child(
+              ::Moxml::EntityReference.new(
+                @adapter.create_native_entity_reference(payload),
+                @ctx,
+              ),
+            )
+          end
+        end
+      end
+    end
+  end
+end