moxml 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51298c0a0ce4ed7c7868e294dc8174ada558b4a1c36c168bc18cdcfe2f728aec
-  data.tar.gz: a5e5ffce0b817e397bf98852aecfd9bb341d5154a94540f486432ea32dee8788
+  metadata.gz: d2a6cac576f8bc4819d27a22825f7ab11fd35a004113c70d6c4986adf542d844
+  data.tar.gz: 8f7cbfa869296d65002a6d2b74399ede57b16c2bcc25f4c4c7e9ccab611f5be6
 SHA512:
-  metadata.gz: bf7d542cb81a21f1cfa517fafa2c07bdd996b9b7665ebf98e91c4e3f87ce79a1e1fa07f0d8f19837f6f45c73c36663ee54d602b70d72228a8de6e1ccb201a764
-  data.tar.gz: b971104eebb5bb3383bdacbc895d6cd54f0b4df400126f83f9e8002d80ec3e75c0afc1d3369d2c1277732b64326a2c0c044bb156078fdb6c3bb81a1c9c9fdeab
+  metadata.gz: e5b6bf4775a56f4d4fd18cea369d84463085c4df14bdef0ee0ad818ff734864e658bfc41c81bf0e6989cdff2b4ffdff69c74bfc512a7b2debecadd7a892432b6
+  data.tar.gz: daf1b85571460bbde0553a52603f255577918dd9eb2e9faf37cb156738277bef51d5bfadc207b74d17177d3f281d9ae4ce4b2db571e22ad112bb595291d124c8

data/lib/moxml/adapter/base.rb

@@ -215,6 +215,16 @@ namespace_validation_mode: :strict)
           child_native
         end
 
+        # Whether `Node.wrap` may safely memoize the wrapper for this
+        # native across calls. Adapters whose parser hands back the
+        # same Ruby object for the same logical node (nokogiri, ox,
+        # oga, rexml, leptris) opt in (default true). Adapters that
+        # mint a new Ruby object per access (libxml) opt out so the
+        # identity map does not accumulate dead entries.
+        def wrappers_recyclable?
+          true
+        end
+
         # Returns all namespaces in scope for this element, including
         # inherited from ancestors. Adapters with native support (Nokogiri)
         # override this. Default walks the ancestor chain.

data/lib/moxml/adapter/leptris.rb

@@ -559,8 +559,16 @@ 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)
-          return nil unless node.is_a?(::Leptris::XML::Document)
+          return nil unless native_context_node?(node)
           return nil unless native_expression?(expression)
+          # The binding reports the root element parentless while moxml
+          # roots it at the document, so parent-axis queries from the
+          # root element keep the Ruby engine.
+          if node.is_a?(::Leptris::XML::Element) &&
+              node.document&.root.equal?(node) &&
+              expression_uses_parent_axis?(expression)
+            return nil
+          end
 
           compiled = NATIVE_XPATH_CACHE.get_or_set(expression) do
             ::Leptris::XML::XPath.compile(expression)
@@ -584,6 +592,27 @@ module Moxml
           nil
         end
 
+        def native_context_node?(node)
+          node.is_a?(::Leptris::XML::Document) ||
+            node.is_a?(::Leptris::XML::Element)
+        end
+
+        def expression_uses_parent_axis?(expression)
+          ast = XPath::Parser.parse_with_cache(expression)
+          contains_parent_axis?(ast)
+        rescue XPath::SyntaxError
+          true
+        end
+
+        def contains_parent_axis?(ast)
+          return true if ast.type == :parent
+          return true if ast.type == :axis && ast.children.first == "parent"
+
+          ast.children.any? do |child|
+            child.is_a?(XPath::AST::Node) && contains_parent_axis?(child)
+          end
+        end
+
         # Document-context queries without variable references,
         # attribute-node results, or the nokogiri-compat xmlns:
         # reserved prefix convention.

data/lib/moxml/adapter/libxml.rb

@@ -67,6 +67,13 @@ module Moxml
           doc.root = element
         end
 
+        # libxml-ruby mints a fresh Ruby object for the same C node on
+        # each access; the wrapper identity map would accumulate dead
+        # entries without bound at full mutation throughput.
+        def wrappers_recyclable?
+          false
+        end
+
         def parse(xml, options = {}, _context = nil)
           # LibXML doesn't preserve DOCTYPE during parsing, so we need to extract it manually
           xml_string = if xml.is_a?(String)
@@ -1006,18 +1013,17 @@ module Moxml
 
             if native_node.root
               indent_size = options[:indent].is_a?(Integer) && options[:indent].positive? ? options[:indent] : 0
-              # Custom serializer emits newlines AND indentation directly —
-              # no separate add_newlines_to_xml / indent_xml passes.
               # `eref_active` is computed once here and threaded through the
               # recursion so that the per-element `attachments.key?` Monitor
               # sync only fires for docs that actually have entity refs.
               eref_active = entity_ref_registry(native_node).active?
-              root_output = serialize_element_with_namespaces(
+              root_output = native_root_output(native_node, indent_size)
+              root_output ||= serialize_element_with_namespaces(
                 native_node.root,
-                true,
-                indent_size,
-                0,
-                eref_active: eref_active,
+                  true,
+                  indent_size,
+                  0,
+                  eref_active: eref_active,
               )
 
               output << "\n" << root_output unless output.empty?
@@ -1030,6 +1036,46 @@ module Moxml
           end
         end
 
+        # Possessive-quantifier form: no backtracking, so pathological
+        # attribute content cannot blow up the expansion pass.
+        EMPTY_ELEMENT_EXPANSION_RE = %r{
+          <([A-Za-z_][\w.:-]*+)
+          ((?:"[^"]*+"|'[^']*+'|[^<>"'/]++)*+)
+          />
+        }x
+        private_constant :EMPTY_ELEMENT_EXPANSION_RE
+
+        # Serialize the root subtree with libxml's C serializer plus
+        # moxml-canonical corrections — roughly 25x faster and ~2600x
+        # fewer allocations than the Ruby walker. Returns nil whenever
+        # a guard says the walker is still required.
+        def native_root_output(native_doc, indent_size)
+          return nil unless indent_size == 2
+          return nil if entity_ref_registry(native_doc).active?
+
+          output = native_doc.root.to_s
+
+          # The walker strips prefixed names on parsed namespaced
+          # children; that behavior is load-bearing, so namespaced
+          # output keeps the walker.
+          return nil if output.include?("xmlns")
+
+          # Layout: pull closing tags onto the last child's line
+          output = output.gsub(/\n[ \t]*(<\/[\w.:-]+>)/, '\1')
+
+          if output.include?("/>")
+            # A literal "/>" inside a comment or CDATA section would be
+            # falsely expanded — the segment-aware walker is correct here
+            return nil if output.include?("<!--") || output.include?("<![CDATA[")
+
+            output = output.gsub(EMPTY_ELEMENT_EXPANSION_RE, '<\1\2></\1>')
+          end
+
+          # Native escapes attribute apostrophes; moxml keeps them literal
+          output.gsub("&apos;", "'")
+          
+        end
+
         # Shallow duplication: copies the node itself (name, attrs, namespaces)
         # but NOT its descendants (deep duplication composes this).
         # walks the source tree and re-adds children one at a time via

data/lib/moxml/context.rb

@@ -22,9 +22,12 @@ module Moxml
     end
 
     def register_wrapper(native, wrapper)
-      # Safety valve: adapters whose natives are recreated per access
-      # (nokogiri mints new Ruby objects for the same C node) would
-      # grow the map without bound in pathological loops.
+      # Safety valve + adapter opt-in. Adapters whose natives are
+      # recreated per access (libxml mints fresh Ruby objects for the
+      # same C node) opt out so the map does not accumulate dead
+      # entries; the default is opt-in.
+      return if @config&.adapter&.wrappers_recyclable? == false
+
       @wrappers.clear if @wrappers.size >= 65_536
       @wrappers[native] = wrapper
     end

data/lib/moxml/version.rb

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

data/lib/moxml/xpath/compiler.rb

@@ -22,6 +22,7 @@ module Moxml
     class Compiler
       # Shared context for compiled Procs
       CONTEXT = Context.new
+      private_constant :CONTEXT
 
       # Expression cache
       CACHE = Cache.new
@@ -1834,7 +1835,7 @@ module Moxml
 
       # Helper: Check if AST node is a number
       def number?(ast)
-        %i[int float number].include?(ast.type)
+        ast.type == :number
       end
 
       # Helper: Check if AST contains a call node with given name

data/spec/moxml/adapter/leptris_spec.rb

@@ -58,8 +58,16 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(attrs.map(&:value)).to eq(%w[1 2])
     end
 
-    it "falls back to the Ruby engine for element-context queries" do
+    it "evaluates element-context queries on the native engine" do
       expect(doc.root.xpath(".//item").size).to eq(2)
+      first_item = doc.root.children.find(&:element?)
+      expect(first_item.xpath("following-sibling::*").map(&:name)).to eq(%w[item])
+    end
+
+    it "falls back to the Ruby engine for parent-axis queries from the root" do
+      # The binding reports the root element parentless; moxml roots
+      # it at the document
+      expect(doc.root.xpath("../*").size).to eq(1)
     end
 
     it "falls back to the Ruby engine for the xmlns: reserved prefix" do

metadata

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