moxml 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2a6cac576f8bc4819d27a22825f7ab11fd35a004113c70d6c4986adf542d844
-  data.tar.gz: 8f7cbfa869296d65002a6d2b74399ede57b16c2bcc25f4c4c7e9ccab611f5be6
+  metadata.gz: ca6fefbf114afcaf13d9c241b4df5081eef1e004019618ca12d31a655d89dd53
+  data.tar.gz: d361373f16dafff997d4ca53b5dbc23c332b09331e8f49ef5abed09f526bdea7
 SHA512:
-  metadata.gz: e5b6bf4775a56f4d4fd18cea369d84463085c4df14bdef0ee0ad818ff734864e658bfc41c81bf0e6989cdff2b4ffdff69c74bfc512a7b2debecadd7a892432b6
-  data.tar.gz: daf1b85571460bbde0553a52603f255577918dd9eb2e9faf37cb156738277bef51d5bfadc207b74d17177d3f281d9ae4ce4b2db571e22ad112bb595291d124c8
+  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)
@@ -852,26 +858,6 @@ module Moxml
           XmlEmitter.doctype_xml(dt.root_name, dt.public_id, dt.system_id)
         end
 
-        def entity_refs?(element)
-          element.is_a?(::Leptris::XML::Element) &&
-            !attachments.get(element, :entity_refs).to_a.empty?
-        end
-
-        # Registry-based entity references are not in the native tree,
-        # so the native serializer cannot see them; compose the element
-        # from the wrapper-visible children instead.
-        def serialize_entity_bearing_element(element, options)
-          name = element.prefix ? "#{element.prefix}:#{element.name}" : element.name
-          attrs = element.attribute_nodes.map do |attr|
-            %( #{attr.name}="#{XmlEmitter.escape_attribute(attr.value)}")
-          end.join
-          decls = element.namespace_definitions.map do |ns|
-            ns.prefix ? %( xmlns:#{ns.prefix}="#{ns.href}") : %( xmlns="#{ns.href}")
-          end.join
-          inner = children(element).map { |child| raw_serialize(child, options) }.join
-          "<#{name}#{decls}#{attrs}>#{inner}</#{name}>"
-        end
-
         def sax_parse(xml, handler)
           bridge = LeptrisSAXBridge.new(handler)
           xml_string = xml.is_a?(IO) || xml.is_a?(::StringIO) ? xml.read : xml.to_s
@@ -882,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/libxml.rb

@@ -1060,6 +1060,11 @@ module Moxml
           # output keeps the walker.
           return nil if output.include?("xmlns")
 
+          # The native serializer escapes non-ASCII codepoints in
+          # attribute values as numeric character references
+          # (x="©"); the walker emits literal UTF-8
+          return nil if output.include?("&#x")
+
           # Layout: pull closing tags onto the last child's line
           output = output.gsub(/\n[ \t]*(<\/[\w.:-]+>)/, '\1')
 
@@ -1073,7 +1078,6 @@ module Moxml
 
           # Native escapes attribute apostrophes; moxml keeps them literal
           output.gsub("&apos;", "'")
-          
         end
 
         # Shallow duplication: copies the node itself (name, attrs, namespaces)

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.4.0"
+  VERSION = "0.5.1"
 end

data/lib/moxml/xpath/compiler.rb

@@ -95,10 +95,6 @@ module Moxml
         source = generator.process(proc_ast)
 
         CONTEXT.evaluate(source)
-      ensure
-        @literal_id = 0
-        @predicate_nodesets.clear
-        @predicate_indexes.clear
       end
 
       # Process a single XPath AST node

metadata

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