moxml 0.5.19 → 0.5.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62f62c2c744354f3dc8c6436cd5404eac78738bc3da00509c1daed9e827d5195
-  data.tar.gz: 25cddfe9066c8ebda91925a47834fb3180aaefc2b7be5f74b32409a3bdd44ffb
+  metadata.gz: efd15ef624c00bcb6215f7a120272833f45f4c0f297d2a98b19507540878eec8
+  data.tar.gz: 640713084bd178087975387abca9cec4a681c2e94ce905ac16becb5514e25ca2
 SHA512:
-  metadata.gz: 4598f34a5af3aa247349f0bf0cd5ea99fceb2a60c02412b31b3e6ecc391f0e5292668b5ca9c8bb2be304dee1cc7e3706e932ffe3c73ceaa9e0f9d45476c4fa24
-  data.tar.gz: e7c39fcc1a5dad848d9b4484e6065b3af1a890a8b4085a5d7cf731d20010a480d6ef0e2c6f8cbd7a579cc9c524360364475c2fb29c1704632fa7472a25a2eabc
+  metadata.gz: 2d418bb84689e70721a4e9b16359136e94d781d7da0bc2c9b7374f58ff911d08fff0eb874a8ed31a6434b9d953381714ad8d1dad5911a6b457b8ae6143a53491
+  data.tar.gz: 6aca55287d55514bd1dfc52c4286909760fb2b9230c33989c21bda4b78d873977ca07ef30df165413d959a42cd7ffa052677aaae672dfe1884f6e84af3b270c5

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

@@ -76,6 +76,9 @@ module Moxml
         # only walks the root subtree, so declaration, DOCTYPE, PIs and
         # document-level text are assembled around it explicitly.
         def serialize_document(doc, options)
+          fast = fast_document_output(doc, options)
+          return fast if fast
+
           # Nokogiri's document shape: every top-level part is
           # newline-terminated, at any indent — declaration, DOCTYPE,
           # document PIs, the root element, trailing newline after it.
@@ -108,6 +111,69 @@ module Moxml
           parts.join
         end
 
+        # Issue #158: the engine's whole-document serializer is one C
+        # call; the composed path serializes the root through the
+        # element face, which copies the subtree into a fresh document
+        # on every call (~4.5x slower end to end). The engine's output
+        # is byte-identical to the composed one EXCEPT epilog parts
+        # glue directly to the root — so the fast path declines
+        # whenever anything follows the root, any attachment overrides
+        # a part, or the engine's declaration line differs from the
+        # facade's canonical form (checked post-hoc: a source
+        # declaration carrying standalone or another version would
+        # diverge).
+        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)
+
+          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
+            end
+          end
+
+          # The engine's subset serializer mangles every declaration
+          # after the first (loses its "<") — moxml's own formatter is
+          # correct, so multi-declaration subsets compose.
+          dt = doc.doctype
+          if dt&.class&.method_defined?(:internal_subset) &&
+              (subset = dt.internal_subset) && subset.scan("<!").size > 1
+            return nil
+          end
+
+          kwargs = {
+            indent: options.fetch(:indent, 0),
+            no_decl: !include_decl,
+            encoding: options[:encoding],
+          }
+          if INDENT_UNIT_SUPPORTED && options[:indent_text].is_a?(String)
+            kwargs[:indent_text] = options[:indent_text]
+          end
+          output = doc.to_xml(**kwargs)
+          return nil if output.nil? || output.empty?
+
+          if include_decl && !output.start_with?(default_declaration_xml(doc, options))
+            return nil
+          end
+
+          output << "\n" unless output.end_with?("\n")
+          output
+        end
+
         def native_doctype_xml(doc)
           dt = doc.doctype
           return nil unless dt

data/lib/moxml/entity.rb

@@ -43,6 +43,12 @@ module Moxml
     SERIALIZED_MARKER_RE = /(#{NAME_PATTERN});/
     STANDARD_ENTITIES = %w[amp lt gt quot apos].freeze
 
+    # One regex pass, no allocations: true when a NON-standard named
+    # entity exists somewhere. Documents carrying only the five
+    # predefined entities (the overwhelmingly common case) skip the
+    # marker gsub's full-buffer copy entirely.
+    NON_STANDARD_ENTITY_RE = /&(?!amp;|lt;|gt;|quot;|apos;)(#{NAME_PATTERN});/
+
     NAMED_DECODE_MAP = {
       "amp" => "&", "lt" => "<", "gt" => ">",
       "quot" => '"', "apos" => "'"
@@ -82,6 +88,10 @@ module Moxml
       # the regex scan and string allocation entirely. The vast
       # majority of XML payloads contain no entity references.
       return [str, false] unless str.include?("&")
+      # Second fast path: only predefined entities — the gsub would
+      # pass every match through unchanged, so skip its full-buffer
+      # copy too.
+      return [str, false] unless str.match?(NON_STANDARD_ENTITY_RE)
 
       marked = false
       processed = str.gsub(NAME_RE) do |match|

data/lib/moxml/node.rb

@@ -339,10 +339,18 @@ module Moxml
 
     TYPES.each do |node_type|
       define_method "#{node_type}?" do
-        adapter.node_type(native) == node_type
+        node_type_cached == node_type
       end
     end
 
+    # The adapter's type probe is an FFI call per invocation; the
+    # type is fixed for a node's lifetime, so the first answer is
+    # memoized on the wrapper.
+    def node_type_cached
+      @node_type_cached ||= adapter.node_type(@native)
+    end
+    private :node_type_cached
+
     # Returns the primary identifier for this node type
     # For Element: the tag name
     # For Attribute: the attribute name
@@ -392,7 +400,9 @@ module Moxml
     protected
 
     def adapter
-      context.config.adapter
+      # A context's adapter object is fixed for its lifetime; the
+      # chain deref ran on every node access.
+      @adapter ||= context.config.adapter
     end
 
     def self.adapter(context)

data/lib/moxml/node_set.rb

@@ -23,9 +23,16 @@ module Moxml
     def each
       return to_enum(:each) unless block_given?
 
-      @nodes.each_with_index do |node, i|
-        @wrapped[i] ||= wrap_with_parent(node)
-        yield @wrapped[i]
+      wrapped = @wrapped
+      index = 0
+      @nodes.each do |node|
+        wrapper = wrapped[index]
+        unless wrapper
+          wrapper = wrap_with_parent(node)
+          wrapped[index] = wrapper
+        end
+        yield wrapper
+        index += 1
       end
       self
     end

data/lib/moxml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.19
+  version: 0.5.21
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-31 00:00:00.000000000 Z
+date: 2026-09-01 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API