moxml 0.1.20 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0633c51783a25d02190769345f0c6a4af79c29665b180e5b46fc28f0b6eeee31
-  data.tar.gz: b3d9d706cc185c2d045ed8d3c9a62bb884196cc2cc520cd51fd17cecb07cd897
+  metadata.gz: cd873f36f1ee8d7799299cedbc4bfa7da00d588e311693be8b6e718b9e09fa8d
+  data.tar.gz: 2597df5af105dfcfdc84586b98473e99af95681fbf1ef24b0c2c6698280e6dbb
 SHA512:
-  metadata.gz: 6626a13b9dda295113caa1e1d99085afd20776b1d3d4f156bbdf63efcefccef59cd1ea37d14439aa7487f3f617ed65ac1003ec775b22e77614a4b0082c832307
-  data.tar.gz: 68b26d50fa35b206835f633dfd7b26f6c389fc3507a524a84784929b089e0c699d1361af8838d86e5fcec0e8031f81ca82e2e799b544737cc1616a3da5d15707
+  metadata.gz: b39f087ced4fc9ea76722e32c8b036ee7e4819798bec248af520f51bb20039cb76459837e1b5a65540f46bf7112ee5922eece22cac763ef25b3235a0c5ca60f6
+  data.tar.gz: 75847baca549e9cb0902203f2d8b9f8e4e764c048dc0cd57260d6995f1aa233c5db6ecdb6786344cdfb097b4ec73a088d1c12b4d79b2fcb5217c936ba4605ec1

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/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