moxml 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 837d647ac39dac23aae2389b6150eafbecf405788f5c62e09af616aa0644715c
-  data.tar.gz: c7a427e0cf685dd3121e0e5afdfcf388a0d18c52766f22717c8bb8b7d02cecf2
+  metadata.gz: ca6fefbf114afcaf13d9c241b4df5081eef1e004019618ca12d31a655d89dd53
+  data.tar.gz: d361373f16dafff997d4ca53b5dbc23c332b09331e8f49ef5abed09f526bdea7
 SHA512:
-  metadata.gz: 2e59a3705d492b273708e0d82fa10078be543c4aca86daa7fe7c7c1e90b13ecc774ac89934458b3373d46045e4a2f3fa7eef46172045bbe8ae4fd5105c03030c
-  data.tar.gz: c8f15cc1577514a368e551444f0e0759170e77e5969a383e0b43025d733e75be8ec99869e43f9fd459f2ac1c0d0c422b26d9e98c73823d76fd18d585d11ebdff
+  metadata.gz: 0a2e61a613511970e4c6945c074a578aefcb12591def797a726bf0959796c43dbf2e71b77509271b1dad15b9f0f1e81f5ec3b8b0af0e384bccad35745bc2dbb6
+  data.tar.gz: 183964ef083c888b3b7d58b896a547acf25c0414d997040c10b805b8379088825c2ec996b149aa9e8fe51b6419135d1341d8ebe9c88ddb0656101e25d3291557

data/lib/moxml/adapter/leptris.rb

@@ -266,7 +266,13 @@ module Moxml
         def split_entity_markers(natives, parent)
           result = []
           natives.each do |child|
-            content = child.content.to_s.dup.force_encoding("UTF-8") if child.is_a?(::Leptris::XML::Text)
+            # FFI Text#content returns a fresh unfrozen BINARY string:
+            # retag in place (dup would be a throwaway allocation), but
+            # before include? — BINARY.include? with the UTF-8 marker raises
+            if child.is_a?(::Leptris::XML::Text)
+              content = child.content
+              content.force_encoding("UTF-8")
+            end
             if content&.include?(Entity::MARKER)
               content.scan(/([^#{Entity::MARKER}]*)(?:#{Entity::MARKER}([\w.:-]+);)?/o) do
                 text_part = Regexp.last_match(1)
@@ -862,8 +868,23 @@ module Moxml
 
         private
 
+        # The variable-length \s* gap after \A defeats Onigmo's anchor
+        # optimization, forcing a full-buffer scan — 6.5 ms on a 1 MB
+        # document without a declaration (the common case). Match a
+        # head slice instead; fall back to the full string only when
+        # the head is all whitespace (pathological prefixes).
+        SOURCE_DECLARATION_RE = /\A\s*<\?xml\b/
+        private_constant :SOURCE_DECLARATION_RE
+
         def record_source_declaration(native_doc, xml_string)
-          had = xml_string.match?(/\A\s*<\?xml\b/)
+          head = xml_string[0, 256]
+          had = if head.match?(SOURCE_DECLARATION_RE)
+                  true
+                elsif head.match?(/\A\s*\z/)
+                  xml_string.match?(SOURCE_DECLARATION_RE)
+                else
+                  false
+                end
           attachments.set(native_doc, :had_source_declaration, had)
         end
 

data/lib/moxml/adapter/ox.rb

@@ -717,28 +717,48 @@ module Moxml
           # Only documents/elements can contain entity refs or CDATA issues
           return false unless node.is_a?(::Ox::Document) || node.is_a?(::Ox::Element)
 
-          # Check cached flags on documents (most common case)
-          if node.is_a?(::Ox::Document)
-            return true if attachments.get(node, :has_entity_refs)
-            return true if attachments.get(node, :has_cdata_end_markers)
-            return false if attachments.key?(node, :has_entity_refs) &&
-              attachments.key?(node, :has_cdata_end_markers)
-          end
-
-          # Only scan tree on first call — short-circuit on first hit
-          has_er = tree_has_entity_references?(node)
-          if has_er
-            attachments.set(node, :has_entity_refs, true) if node.is_a?(::Ox::Document)
-            return true
-          end
-
-          has_cdata = tree_has_cdata_end_markers?(node)
-          if node.is_a?(::Ox::Document)
-            attachments.set(node, :has_entity_refs, false)
-            attachments.set(node, :has_cdata_end_markers, has_cdata)
+          # Element serializes consult the owning document's cached
+          # flags — a rescan per call made element to_xml ~30x slower
+          # than document to_xml on plain documents.
+          scan_root = node
+          if node.is_a?(::Ox::Element) && (doc = document(node))
+            return true if attachments.get(doc, :has_entity_refs)
+            return true if attachments.get(doc, :has_cdata_end_markers)
+            return false if attachments.key?(doc, :has_entity_refs) &&
+              attachments.key?(doc, :has_cdata_end_markers)
+
+            scan_root = doc
+          end
+
+          # One merged tree scan instead of two; flags cache on the
+          # document either way.
+          has_er, has_cdata = tree_scan_custom_needs(scan_root)
+          if scan_root.is_a?(::Ox::Document)
+            attachments.set(scan_root, :has_entity_refs, has_er)
+            attachments.set(scan_root, :has_cdata_end_markers, has_cdata)
+          end
+
+          has_er || has_cdata
+        end
+
+        # Single walk collecting both custom-serialize triggers.
+        def tree_scan_custom_needs(node)
+          has_er = false
+          has_cdata = false
+          stack = [node]
+          until stack.empty?
+            current = stack.pop
+            case current
+            when ::Moxml::Adapter::CustomizedOx::EntityReference
+              has_er = true
+            when ::Ox::CData
+              has_cdata = true if current.value&.include?("]]>")
+            when ::Ox::Element, ::Ox::Document
+              current.nodes&.each { |child| stack << child }
+            end
+            return [true, has_cdata] if has_er
           end
-
-          has_cdata
+          [has_er, has_cdata]
         end
 
         def has_declaration?(native_doc, _wrapper)

data/lib/moxml/adapter/rexml.rb

@@ -186,12 +186,16 @@ module Moxml
           # Return all children preserving whitespace text nodes
           result = node.children.dup
 
-          # Include any EntityReference wrappers stored alongside native children
+          # Include any EntityReference wrappers stored alongside native
+          # children. Native children are identity-unique; only this
+          # concat can duplicate (the same wrapper added twice), so the
+          # dedupe lives here and the common path stays scan-free.
           entity_refs = attachments.get(node, :entity_refs)
-          result.concat(entity_refs) if entity_refs
-
-          # Ensure uniqueness by object_id to prevent duplicates
-          result.uniq(&:object_id)
+          if entity_refs
+            result.concat(entity_refs).uniq!(&:object_id) || result
+          else
+            result
+          end
         end
 
         def parent(node)

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Ribose Inc.