moxml 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 837d647ac39dac23aae2389b6150eafbecf405788f5c62e09af616aa0644715c
-  data.tar.gz: c7a427e0cf685dd3121e0e5afdfcf388a0d18c52766f22717c8bb8b7d02cecf2
+  metadata.gz: 566f12c7bcda29e079d0fd5b496a6becff643b9c15afd328d5f99fb7ef70d35c
+  data.tar.gz: a4d7858218db7d38300b963b11d5e40b5aec176d2072a177c4e5448f839b8671
 SHA512:
-  metadata.gz: 2e59a3705d492b273708e0d82fa10078be543c4aca86daa7fe7c7c1e90b13ecc774ac89934458b3373d46045e4a2f3fa7eef46172045bbe8ae4fd5105c03030c
-  data.tar.gz: c8f15cc1577514a368e551444f0e0759170e77e5969a383e0b43025d733e75be8ec99869e43f9fd459f2ac1c0d0c422b26d9e98c73823d76fd18d585d11ebdff
+  metadata.gz: 45cf69a5c753718d3bcef44580ef2e8e0dcfa536033537602952e8cbeb73e8bb59e68ad365fdc72c6b7422a998c50e623a1f7b894ed5e7da3cd8e129ff40c703
+  data.tar.gz: 0fd18d4891bd29ce56ab1174aa494f8dddc251d298067a0290bf84df41f6854d61bdeedf6e9fd813c32669a9a550419865a637633ddd6e558e84ff0d9f6eca2e

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)
@@ -540,6 +546,10 @@ module Moxml
         # returns those without name accessors). Both engines resolve
         # expression prefixes against document-declared namespaces.
         NATIVE_XPATH_CACHE = XPath::Cache.new(100)
+        # The gate decision is expression-intrinsic; re-walking the
+        # cached AST three times per xpath call cost ~23% of repeated
+        # selective queries, so the boolean caches beside it.
+        NATIVE_GATE_CACHE = XPath::Cache.new(100)
 
         def xpath(node, expression, namespaces = {})
           native = native_xpath(node, expression, namespaces)
@@ -617,11 +627,13 @@ module Moxml
         # attribute-node results, or the nokogiri-compat xmlns:
         # reserved prefix convention.
         def native_expression?(expression)
-          ast = XPath::Parser.parse_with_cache(expression)
-          return false if ast_contains_type?(ast, :variable)
-          return false if uses_xmlns_prefix?(ast)
+          NATIVE_GATE_CACHE.get_or_set(expression) do
+            ast = XPath::Parser.parse_with_cache(expression)
+            next false if ast_contains_type?(ast, :variable)
+            next false if uses_xmlns_prefix?(ast)
 
-          !selects_attribute_results?(ast)
+            !selects_attribute_results?(ast)
+          end
         rescue XPath::SyntaxError
           false
         end
@@ -862,8 +874,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

@@ -7,6 +7,11 @@ require "libxml"
 module Moxml
   module Adapter
     class Libxml < Base
+      # DOCTYPE prolog sniffer; see parse for the index-then-match
+      # strategy that keeps this off the hot path.
+      DOCTYPE_RE = /<!DOCTYPE\s+([^\s>]+)(?:\s+PUBLIC\s+"([^"]+)"\s+"([^"]+)"|\s+SYSTEM\s+"([^"]+)")?\s*>/i
+      private_constant :DOCTYPE_RE
+
       autoload :EntityRefRegistry, "moxml/adapter/libxml/entity_ref_registry"
 
       # Wrapper class to store DOCTYPE information
@@ -89,8 +94,15 @@ module Moxml
           # parameter or XML declaration for byte interpretation.
           xml_string = preprocess_entities(xml_string)
 
-          # Extract DOCTYPE before parsing
-          doctype_match = xml_string.match(/<!DOCTYPE\s+([^\s>]+)(?:\s+PUBLIC\s+"([^"]+)"\s+"([^"]+)"|\s+SYSTEM\s+"([^"]+)")?\s*>/i)
+          # Extract DOCTYPE before parsing. Locate the literal first:
+          # a plain memscan is ~2x cheaper than the regex's literal
+          # prefix scan on doctype-less documents (the common case),
+          # and matching from the found offset keeps captures
+          # identical.
+          doctype_idx = xml_string.index("<!DOCTYPE")
+          doctype_match = if doctype_idx
+                            xml_string.match(DOCTYPE_RE, doctype_idx)
+                          end
 
           native_doc = begin
             # Handle both string and file inputs

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.2"
 end

metadata

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