moxml 0.5.10 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0307f3c9e6060b1ca344c69633788790dc899121f213be74870be3cd2c2600ac
-  data.tar.gz: 22135905e79bcb1099a04809bedb69c734b1893ee4fa4749761427641bfcf9b2
+  metadata.gz: 7f702d6c51c5df49bdb2bf0ac5189d3fe0716d94093ced7decdb743dcf87fa5d
+  data.tar.gz: 56316b016c8865d6290033873477d9dcc92b04e1e16ae77716626398bd976ad3
 SHA512:
-  metadata.gz: 50413c5cddd8680fc5c6cf4bd67dcf75e54e0cbf202b45f1ff5b985648ff948286b92c0a4efc9ef725d9fd0af677e0239eefb7fec37f27e43ece9795240a5db7
-  data.tar.gz: 696949b3fb51358b4841e2a2fdeb68824659a7ffefdbb6ac4a2006758006d649ddb64127728cd2b5b653cc54dd888e14566d012d5d6b6c382ce012f3b0ea0112
+  metadata.gz: a1e503460e2b5d645cd4147d4164d2a67c254e8e2174b145fbf4f17dab222d1eae03216b7a35dca18a800684c3c904daf9633140f262195f212d9dd235ccc675
+  data.tar.gz: 4cf7957e370339230fc4d184a7fd6b9312bd3f5e8f9e843984ed4e56967e33597d18abef6479de69cde47af781a65703427349cdaff16eaf317cdb39ba8cd135

data/lib/moxml/adapter/base.rb

@@ -198,6 +198,14 @@ namespace_validation_mode: :strict)
           false
         end
 
+        # Deterministic native-memory release for adapters backed by
+        # C trees (issue #134). GC-managed engines no-op; released
+        # documents raise the engine's use-after-free error on
+        # further access.
+        def free_document(_native)
+          nil
+        end
+
         # Check if the native document has an XML declaration
         # @param native_doc the native document object
         # @param wrapper [Moxml::Document] the wrapper with has_xml_declaration flag

data/lib/moxml/adapter/leptris.rb

@@ -23,6 +23,16 @@ module Moxml
       # the libxml2-model document node — prolog/epilog parts in
       # document order. Older bindings keep the flat pre-root PI path.
       DOC_NODE_SUPPORTED = ::Leptris::XML::Document.method_defined?(:node)
+      # libleptris 1.9.8 (leptris-ruby 1.9.30): plain parse excludes
+      # DTD ATTLIST defaults, matching libxml2/Nokogiri semantics;
+      # ParseOptions::DTDATTR opts in (leptris/leptris#606).
+      DTDATTR_SUPPORTED = ::Leptris::XML::ParseOptions.const_defined?(:DTDATTR)
+      # leptris-ruby 1.9.32 (#89): traverse is subtree-bounded again —
+      # earlier 1.9.x walks followed the document chain and swept
+      # following siblings, so element materialize had to fall back
+      # to the generic wrapper walk.
+      TRAVERSE_SUBTREE_BOUNDED =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.32")
 
       class << self
         def attachments
@@ -42,8 +52,14 @@ module Moxml
           # readonly: true (issue #133): the binding memoizes reads and
           # refuses mutations — the parse-and-read lifecycle for
           # multi-pass consumers (comparison, diff, signature).
+          # dtdattr: true opts into DTD ATTLIST default materialization
+          # (off by default since libleptris 1.9.8, matching libxml2).
           native_doc = begin
-            ::Leptris::XML::Document.parse(processed, readonly: options[:readonly] == true)
+            ::Leptris::XML::Document.parse(
+              processed,
+              readonly: options[:readonly] == true,
+              options: dtdattr_parse_options(options),
+            )
           rescue ::Leptris::XML::ParseError => e
             # libleptris has no recovery mode that survives unclosed
             # tags; non-strict callers get an empty document, matching
@@ -61,6 +77,30 @@ module Moxml
           doc
         end
 
+        # nil when DTDATTR is unsupported or not requested — the
+        # binding treats a nil options hash as plain defaults.
+        def dtdattr_parse_options(options)
+          return nil unless DTDATTR_SUPPORTED && options[:dtdattr] == true
+
+          ::Leptris::XML::ParseOptions.dtdattr
+        end
+
+        # Issue #134: deterministic release of the C tree. The binding
+        # clears its wrapper cache and raises UseAfterFreeError on
+        # later access; moxml-side attachments for the document are
+        # swept too (the context wrapper identity map self-cleans via
+        # its size valve).
+        DOCUMENT_ATTACHMENT_KEYS = %i[
+          entity_markers doc_pi_nodes declaration doctype
+          had_source_declaration document_text
+        ].freeze
+
+        def free_document(native)
+          DOCUMENT_ATTACHMENT_KEYS.each { |key| attachments.delete(native, key) }
+          native.free
+          nil
+        end
+
         def create_document(_native_doc = nil)
           ::Leptris::XML::Document.create
         end
@@ -248,24 +288,37 @@ module Moxml
           # ER expansion); the bulk path has no marker handling.
           return nil if doc.nil? || attachments.get(doc, :entity_markers)
 
-          root = native.is_a?(::Leptris::XML::Document) ? native.root : native
+          # On bindings whose traverse follows the document chain
+          # (leptris 1.9.28–1.9.31), element materialize falls back to
+          # the generic wrapper walk — only document materialization
+          # can filter safely there (issue #140).
+          root = if native.is_a?(::Leptris::XML::Document)
+                   doc.root
+                 else
+                   return nil unless TRAVERSE_SUBTREE_BOUNDED
+
+                   native
+                 end
           return nil if root.nil?
 
           depth_memo = {}.compare_by_identity
           root.traverse do |node|
+            depth = material_depth_in_subtree(node, root, depth_memo)
+            next if depth.nil?
+
             record = case node
                      when ::Leptris::XML::Element
-                       element_material_record(node, depth_memo)
+                       element_material_record(node, depth)
                      when ::Leptris::XML::CDATA
                        # CDATA < Text in the binding: this arm must come
                        # first or CDATA content reports as text.
-                       text_material_record(:cdata, node.content, node, depth_memo)
+                       text_material_record(:cdata, node.content, depth)
                      when ::Leptris::XML::Text
-                       text_material_record(:text, node.content, node, depth_memo)
+                       text_material_record(:text, node.content, depth)
                      when ::Leptris::XML::Comment
-                       text_material_record(:comment, node.content, node, depth_memo)
+                       text_material_record(:comment, node.content, depth)
                      when ::Leptris::XML::ProcessingInstruction
-                       text_material_record(:processing_instruction, node.content, node, depth_memo)
+                       text_material_record(:processing_instruction, node.content, depth)
                          .merge(qname: node.target)
                      end
             yield(record) if record
@@ -273,7 +326,7 @@ module Moxml
           true
         end
 
-        def element_material_record(node, depth_memo)
+        def element_material_record(node, depth)
           attributes = node.each_attribute.map do |attr|
             # Local name + separate prefix, matching the generic
             # path's resolver semantics (moxml's canonical shape).
@@ -296,11 +349,11 @@ module Moxml
             end,
             attributes: attributes,
             text: nil,
-            depth: material_depth(node, depth_memo),
+            depth: depth,
           }
         end
 
-        def text_material_record(kind, text, node, depth_memo)
+        def text_material_record(kind, text, depth)
           {
             kind: kind,
             qname: nil,
@@ -309,18 +362,30 @@ module Moxml
             namespaces: Materializer::EMPTY_ATTRIBUTES,
             attributes: Materializer::EMPTY_ATTRIBUTES,
             text: text,
-            depth: material_depth(node, depth_memo),
+            depth: depth,
           }
         end
 
-        # Binding wrappers are address-stable and #parent is memoized,
-        # so each edge is fetched once; depths resolve through the
+        # Depth relative to the subtree root, or nil when the node
+        # lies outside it (traverse follows the document chain since
+        # leptris 1.9.28, so epilog siblings can appear in the
+        # stream). Binding wrappers are address-stable and #parent is
+        # memoized, so each edge resolves once through the
         # identity-keyed memo.
-        def material_depth(node, memo)
-          memo[node] ||= begin
-            parent = node.parent
-            parent.nil? || parent.is_a?(::Leptris::XML::Document) ? 0 : material_depth(parent, memo) + 1
-          end
+        def material_depth_in_subtree(node, root, memo)
+          memo[node] ||= if node.equal?(root)
+                           0
+                         else
+                           parent = node.parent
+                           if parent.nil? || parent.is_a?(::Leptris::XML::Document)
+                             nil
+                           else
+
+                             parent_depth = material_depth_in_subtree(parent, root, memo)
+                             parent_depth.nil? ? nil : parent_depth + 1
+
+                           end
+                         end
         end
 
         def node_type(node)
@@ -1025,7 +1090,8 @@ module Moxml
           dt = doc.doctype
           return nil unless dt
 
-          XmlEmitter.doctype_xml(dt.root_name, dt.public_id, dt.system_id)
+          subset = dt.internal_subset if dt.class.method_defined?(:internal_subset)
+          XmlEmitter.doctype_xml(dt.root_name, dt.public_id, dt.system_id, subset)
         end
 
         def sax_parse(xml, handler)

data/lib/moxml/document.rb

@@ -31,6 +31,17 @@ module Moxml
       root&.materialize(&block)
     end
 
+    # Deterministically release the adapter's native memory for this
+    # document (issue #134) — batch workloads parsing thousands of
+    # documents otherwise hold C trees until GC finalizers run.
+    # GC-managed engines no-op. Further access raises the engine's
+    # use-after-free error; ordinary garbage-collected documents keep
+    # working via the finalizer either way.
+    def free
+      adapter.free_document(@native)
+      nil
+    end
+
     def create_element(name)
       Element.new(adapter.create_element(name, owner_doc: @native), context)
     end

data/lib/moxml/version.rb

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

data/lib/moxml/xml_emitter.rb

@@ -56,8 +56,9 @@ module Moxml
       output << "?>"
     end
 
-    # @return [String] a DOCTYPE with its external identifier
-    def doctype_xml(name, public_id, system_id)
+    # @return [String] a DOCTYPE with its external identifier and
+    #   optional internal subset
+    def doctype_xml(name, public_id, system_id, internal_subset = nil)
       output = "<!DOCTYPE #{name}"
       if public_id && !public_id.to_s.empty?
         output << %( PUBLIC "#{public_id}")
@@ -65,6 +66,9 @@ module Moxml
       elsif system_id && !system_id.to_s.empty?
         output << %( SYSTEM "#{system_id}")
       end
+      if internal_subset && !internal_subset.empty?
+        output << " [" << internal_subset << "]"
+      end
       output << ">"
     end
   end

data/spec/moxml/adapter/leptris_spec.rb

@@ -153,6 +153,31 @@ RSpec.describe Moxml::Adapter::Leptris do
     end
   end
 
+  describe "DTD ATTLIST defaults" do
+    # libleptris 1.9.8: plain parse excludes ATTLIST defaults,
+    # matching libxml2/Nokogiri/REXML; dtdattr: true opts in.
+    let(:ctx) { Moxml.new(:leptris) }
+    let(:dtd_xml) do
+      %(<?xml version="1.0"?><!DOCTYPE doc [<!ATTLIST e9 attr CDATA "default">]><doc><e9/></doc>)
+    end
+
+    it "excludes ATTLIST defaults on plain parse" do
+      skip "requires leptris with no-DTDATTR semantics" unless Moxml::Adapter::Leptris::DTDATTR_SUPPORTED
+
+      doc = ctx.parse(dtd_xml)
+      expect(doc.at_xpath("//e9")["attr"]).to be_nil
+      expect(doc.to_xml).not_to include("attr=")
+    end
+
+    it "materializes ATTLIST defaults with dtdattr: true" do
+      skip "requires leptris with ParseOptions::DTDATTR" unless Moxml::Adapter::Leptris::DTDATTR_SUPPORTED
+
+      doc = ctx.parse(dtd_xml, dtdattr: true)
+      expect(doc.at_xpath("//e9")["attr"]).to eq("default")
+      expect(doc.to_xml).to include(%(attr="default"))
+    end
+  end
+
   describe "entity-marker tracking" do
     let(:ctx) { Moxml.new(:leptris) }
 

data/spec/moxml/document_free_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Document#free" do
+  let(:xml) { '<r><a x="1">t</a></r>' }
+
+  it "frees native memory deterministically (issue #134)" do
+    doc = Moxml.new(:leptris).parse(xml)
+    expect(doc.root.name).to eq("r")
+
+    expect(doc.free).to be_nil
+    expect { doc.root }.to raise_error(Leptris::XML::UseAfterFreeError)
+  end
+
+  it "is a no-op on GC-managed engines" do
+    doc = Moxml.new(:nokogiri).parse(xml)
+
+    expect(doc.free).to be_nil
+    expect(doc.root.name).to eq("r")
+  end
+end

data/spec/moxml/materializer_spec.rb

@@ -60,6 +60,17 @@ RSpec.describe Moxml::Materializer do
     )
   end
 
+  it "scopes the document stream to the root subtree (issue #140)" do
+    scoped = %(<?xml version="1.0"?><!-- prolog c --><?pi b?><root>t</root><!-- epilog c --><?pi2 a?>)
+    leptris = Moxml.new(:leptris).materialize(scoped).to_a
+    nokogiri = Moxml.new(:nokogiri).materialize(scoped).to_a
+
+    expect(leptris).to eq(nokogiri)
+    expect(leptris.map { |r| [r[:kind], r[:depth]] }).to eq(
+      [[:text, 1], [:element, 0]],
+    )
+  end
+
   it "materializes from any element subtree" do
     doc = Moxml.new(:nokogiri).parse(xml)
     title = doc.at_xpath("//*[local-name()='title']")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 0.5.12
 platform: ruby
 authors:
 - Ribose Inc.
@@ -447,6 +447,7 @@ files:
 - spec/moxml/declaration_spec.rb
 - spec/moxml/doctype_spec.rb
 - spec/moxml/document_builder_spec.rb
+- spec/moxml/document_free_spec.rb
 - spec/moxml/document_spec.rb
 - spec/moxml/element_spec.rb
 - spec/moxml/entity_preservation_spec.rb