moxml 0.5.43 → 0.5.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c8fd5df5889694c9d7a3ee99c4caad866ddc40edd13ba46945f55e4e9f77a9b
-  data.tar.gz: ce14f6e9199e22576c0c5149e716a672efb9e44ef3a9b68d1b78abad02754a92
+  metadata.gz: f552fee96842dca761f5e88ba1f5074e6cfdaef32411b012e2bf30a6736a16c4
+  data.tar.gz: 68c734aa63688134b897a1e29e8abfa292a02534daefd278b727122ad952e4e3
 SHA512:
-  metadata.gz: 93ac1cd541ed454ac89c10179e5e56f919a4cd309ae8f16abe02950ea5a6fedfdb03c53a7a8c23520616cd202a2b8f5384616ac8cd7b9e884d9f127c1d38bd98
-  data.tar.gz: ed75757fec960bd181921f9562650f4f3d44f2261fa0eb41a09437906d26581ad07c8b5446d0719a1d26b5308de2e1e25c60d2f0013da6861d144692d53eada4
+  metadata.gz: ff775d10b05c5e60fcbf59c66e49284b841e4148b7da7766393b351b47bb626697a34bb5f30cf0d697d8a578ed07c1a9b8b7987507364c436c7c274be380843f
+  data.tar.gz: 7bbaef0118ea13de356dc95041dca057d59373f96eec6a4621a38d1cce07b283ca682b3fd2db77eea34f8d9252aaca821cf2651cbbbebbf0e7e171dd0d51f0f5

data/Gemfile

@@ -9,7 +9,7 @@ gemspec
 gem "benchmark"
 gem "benchmark-ips"
 gem "get_process_mem"
-gem "leptris", "~> 1.9.32"
+gem "leptris", "~> 1.9.174"
 gem "libxml-ruby", "~> 5.0"
 gem "nokogiri", "~> 1.18"
 gem "openssl", "~> 3.0"

data/lib/moxml/adapter/leptris/document_parts.rb

@@ -139,27 +139,43 @@ module Moxml
         # facade's canonical form (checked post-hoc: a source
         # declaration carrying standalone or another version would
         # diverge).
+        # 1.9.174 attached leptris_document_first_child (libleptris
+        # 1.9.174): pointer probe for the single-child document
+        # shape without wrapping the child chain.
+        DOCUMENT_CHILD_PTRS =
+          ::Leptris::XML::FFI.respond_to?(:leptris_document_first_child)
+
         def fast_document_output(doc, options)
           return nil unless LIBXML2_LAYOUT_PARITY
-          return nil if attachments.get(doc, :declaration) ||
-            attachments.get(doc, :doctype) ||
-            attachments.get(doc, :document_text) ||
-            attachments.get(doc, :entity_markers)
+          return nil unless attachments.none_set?(
+            doc, %i[declaration doctype document_text entity_markers]
+          )
 
           include_decl = !options[:no_declaration] && options.fetch(:declaration) do
             document_has_declaration?(doc)
           end
 
-          root_seen = false
-          doc.children.each do |child|
-            if child.is_a?(::Leptris::XML::Element)
-              return nil if root_seen
-
-              root_seen = true
-            elsif root_seen
-              # Epilog parts glue directly to the root in the engine's
-              # document output — compose those.
-              return nil
+          # Exactly one document child — the root — is the common
+          # parsed shape; pointer probes decide it without wrapping
+          # the child chain. Anything else (prolog/epilog parts,
+          # multi-root) falls back to the scan.
+          root = doc.root
+          single_child = DOCUMENT_CHILD_PTRS && root &&
+            ::Leptris::XML::FFI.leptris_document_first_child(doc.c_ptr)
+              .address == root.c_ptr.address &&
+            root.next_sibling.nil?
+          unless single_child
+            root_seen = false
+            doc.children.each do |child|
+              if child.is_a?(::Leptris::XML::Element)
+                return nil if root_seen
+
+                root_seen = true
+              elsif root_seen
+                # Epilog parts glue directly to the root in the engine's
+                # document output — compose those.
+                return nil
+              end
             end
           end
 

data/lib/moxml/adapter/leptris.rb

@@ -42,6 +42,17 @@ module Moxml
       DIGEST_SUPPORTED =
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.99")
 
+      # 1.9.163.7 added the XPath seams (TODO.perf/15+16):
+      # Searchable#at_xpath materializes nodeset entry 0 and frees
+      # the handle in one C dispatch — no NodeSet container, no
+      # AutoPointer (2.8x on repeat at_xpath) — and
+      # CompiledXPath#eval_ptrs runs the compiled handle against
+      # raw pointers, skipping the per-call EvaluationContext
+      # (~2us on every multi-result query).
+      NATIVE_XPATH_SEAMS =
+        defined?(::Leptris::XML::Native) &&
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.163.7")
+
       # Opt-in native read layer (leptris-ruby#185, bindings >= 1.9.162.6):
       # TypedData node wrappers with C-bound hot reads and bulk
       # children construction. Minted from #root downward; the C
@@ -1303,6 +1314,9 @@ module Moxml
         # 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)
+        # Root-context queries alone take the parent-axis guard; the
+        # AST walk is per-expression, so the verdict caches too.
+        PARENT_AXIS_CACHE = XPath::Cache.new(100)
 
         def xpath(node, expression, namespaces = {})
           node = to_binding(node) if NATIVE_READ_LAYER
@@ -1323,6 +1337,14 @@ module Moxml
         # @return [Array, Object, nil] native results, or nil when the
         #   query must run on the Ruby engine
         def native_xpath(node, expression, namespaces, first_only: false)
+          # Canonical natives (the #219 unification) are bare TypedData
+          # wrappers — no Searchable methods, no document handle for
+          # the gates below. The memoized bridge recovers the binding
+          # identity; without it every element-context query fell to
+          # the Ruby engine (a silent native-path loss since #219).
+          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            node = to_binding(node)
+          end
           return nil unless native_context_node?(node)
           return nil unless native_expression?(expression)
           # The binding reports the root element parentless while moxml
@@ -1330,27 +1352,70 @@ module Moxml
           # root element keep the Ruby engine.
           if node.is_a?(::Leptris::XML::Element) &&
               node.document&.root.equal?(node) &&
-              expression_uses_parent_axis?(expression)
+              PARENT_AXIS_CACHE.get_or_set(expression) do
+                expression_uses_parent_axis?(expression)
+              end
             return nil
           end
 
           compiled = NATIVE_XPATH_CACHE.get_or_set(expression) do
             ::Leptris::XML::XPath.compile(expression)
           end
-          result = if namespaces && !namespaces.empty?
-                     compiled.eval(node, namespaces)
+          document = node.is_a?(::Leptris::XML::Document) ? node : node.document
+
+          if namespaces && !namespaces.empty?
+            # Namespace-bound evaluation has no raw-pointer entry —
+            # Searchable resolves the ns set for both result shapes.
+            result = if first_only
+                       node.at_xpath(expression, namespaces)
+                     else
+                       compiled.eval(node, namespaces)
+                     end
+            return case result
+                   when ::Leptris::XML::NodeSet
+                     first_only ? result.first : result.extend(Moxml::LazyNodeSet)
                    else
-                     compiled.eval(node)
+                     result
                    end
-          case result
-          when ::Leptris::XML::NodeSet
-            # The binding's #to_a mints one Ruby wrapper per result
-            # node; hand the native set through so .size/.first stay
-            # native-side (LazyNodeSet holds it unmaterialized).
-            first_only ? result.first : result.extend(Moxml::LazyNodeSet)
-          else
-            result
           end
+
+          unless NATIVE_XPATH_SEAMS
+            result = compiled.eval(node)
+            return case result
+                   when ::Leptris::XML::NodeSet
+                     first_only ? result.first : result.extend(Moxml::LazyNodeSet)
+                   else
+                     result
+                   end
+          end
+
+          # eval_ptrs against raw pointers — the per-call
+          # EvaluationContext that #eval builds costs ~2us of Ruby
+          # on every query (leptris-ruby TODO.perf/15).
+          doc_ptr = node.is_a?(::Leptris::XML::Document) ? node.c_ptr : document.c_ptr
+          context_ptr = node.is_a?(::Leptris::XML::Document) ? nil : node.c_ptr
+          result_ptr = compiled.eval_ptrs(doc_ptr, context_ptr)
+          return nil if result_ptr.null?
+
+          if first_only
+            # The single-result seam: nodeset entry 0 materializes
+            # and frees in one C dispatch — no NodeSet container, no
+            # AutoPointer (leptris-ruby TODO.perf/16). The module
+            # object back means a scalar, whose wrap (and free)
+            # stays with wrap_xpath_first_result.
+            return ::Leptris::XML::Searchable.wrap_xpath_first_result(
+              document, result_ptr
+            )
+          end
+
+          # The binding's #to_a mints one Ruby wrapper per result
+          # node; hand the native set through so .size/.first stay
+          # native-side (LazyNodeSet holds it unmaterialized).
+          # Scalars pass through unwrapped-and-unextended.
+          result = ::Leptris::XML::Searchable.wrap_xpath_result(
+            document, result_ptr
+          )
+          result.is_a?(::Leptris::XML::NodeSet) ? result.extend(Moxml::LazyNodeSet) : result
         rescue ::Leptris::XML::XPathError
           # Not supported by the native engine — the Ruby engine is a
           # full XPath 1.0 implementation, including Moxml's syntax

data/lib/moxml/native_attachment/native.rb

@@ -43,6 +43,13 @@ module Moxml
         end
       end
 
+      def none_set?(native, keys)
+        h = @data[native.object_id]
+        return true if h.nil?
+
+        keys.none? { |key| h.key?(key) }
+      end
+
       def key?(native, key)
         h = @data[native.object_id]
         !h.nil? && h.key?(key)

data/lib/moxml/native_attachment/opal.rb

@@ -13,6 +13,10 @@ module Moxml
         native.instance_variable_set(attachment_ivar_name(key), value)
       end
 
+      def none_set?(native, keys)
+        keys.none? { |key| native.instance_variable_defined?(attachment_ivar_name(key)) }
+      end
+
       def key?(native, key)
         native.instance_variable_defined?(attachment_ivar_name(key))
       end

data/lib/moxml/native_attachment.rb

@@ -20,6 +20,12 @@ module Moxml
       @backend.get(native, key)
     end
 
+    # One probe for "none of these keys are set" — the document
+    # serialize gate asks about four keys per call.
+    def none_set?(native, keys)
+      @backend.none_set?(native, keys)
+    end
+
     def set(native, key, value)
       @backend.set(native, key, value)
     end

data/lib/moxml/version.rb

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

data/lib/moxml/xpath/cache.rb

@@ -11,8 +11,12 @@ module Moxml
       # @param [Integer] max_size Maximum number of entries to cache
       def initialize(max_size = DEFAULT_SIZE)
         @max_size = max_size
-        @cache = {}
-        @access_order = []
+        # One insertion-ordered hash: re-inserting a key on access
+        # makes the first entry the least-recently-used. An
+        # Array-backed order list cost ~600ns per hit in O(n)
+        # deletes — the adapter's xpath path hits three caches per
+        # call.
+        @entries = {}
       end
 
       # Gets a value from the cache or sets it using the provided block.
@@ -21,11 +25,9 @@ module Moxml
       # @yield Block to execute if key is not in cache
       # @return [Object] Cached or newly computed value
       def get_or_set(key)
-        if @cache.key?(key)
-          # Move to end (most recently used)
-          @access_order.delete(key)
-          @access_order.push(key)
-          @cache[key]
+        if @entries.key?(key)
+          value = @entries.delete(key)
+          @entries[key] = value
         else
           value = yield
           set(key, value)
@@ -39,16 +41,9 @@ module Moxml
       # @param [Object] value
       # @return [Object] The value
       def set(key, value)
-        if @cache.key?(key)
-          @access_order.delete(key)
-        elsif @cache.size >= @max_size
-          # Remove least recently used
-          lru_key = @access_order.shift
-          @cache.delete(lru_key)
-        end
-
-        @cache[key] = value
-        @access_order.push(key)
+        @entries.delete(key)
+        @entries[key] = value
+        @entries.shift if @entries.size > @max_size
         value
       end
 
@@ -57,26 +52,24 @@ module Moxml
       # @param [Object] key
       # @return [Object, nil]
       def get(key)
-        return unless @cache.key?(key)
+        return unless @entries.key?(key)
 
-        @access_order.delete(key)
-        @access_order.push(key)
-        @cache[key]
+        value = @entries.delete(key)
+        @entries[key] = value
       end
 
       # Clears the cache.
       #
       # @return [void]
       def clear
-        @cache.clear
-        @access_order.clear
+        @entries.clear
       end
 
       # Returns the current size of the cache.
       #
       # @return [Integer]
       def size
-        @cache.size
+        @entries.size
       end
 
       # Checks if a key exists in the cache.
@@ -84,7 +77,7 @@ module Moxml
       # @param [Object] key
       # @return [Boolean]
       def key?(key)
-        @cache.key?(key)
+        @entries.key?(key)
       end
     end
   end

metadata

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