moxml 0.5.22 → 0.5.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d5a6ef9ddc86140c162e868d05587e8e70552bcfb17f7964024063856b60b5f
-  data.tar.gz: 664be87c9b0e0b00757a696ae49d7c97a67994bc225fbde8e224c20a642133ba
+  metadata.gz: b1181803fec34397cfd858d8671e2dcd6a02a88418dc5848a5ea9c7a44d7bc64
+  data.tar.gz: b9809e6ed48ae4a5a946ed9487fe61d0a89d333b51921de70b50dd271956ba0a
 SHA512:
-  metadata.gz: 8f9927536fa366b63c1673a7f7721ec772e0964f653d2c4c71861e58ddfc3d3c46855fe1fc288471045357416e40f908de9c60f1b2adf12849e44438f60df22b
-  data.tar.gz: 7cf7c5a05eed212702b2a58b18e4deecae8e474e2f9ff74483188fc353fec8320465695e843f8aec0663f9e67130b6f5fa66b01992b6ac1e903dc88e35f3000b
+  metadata.gz: 26df2786fe6a81b696fe2273c2d5f36151bb6af9daf2ce10f057662f7df3ce8ca75970f883a832dbc0c4741e7262be87d79a6eac143298dc9c398ba198f6ba43
+  data.tar.gz: d7d155e11b4d1718e072ad5d2eabcb3aad8c2875753eea571bde7e710deee1c88a8acb3244cb01b4055b4c7e648384f91410c42ad576d600ab4c49ffcb39b895

data/docs/_pages/adapters/leptris.adoc

@@ -71,9 +71,8 @@ implementation over one `leptris_node_traverse` call.
 
 * Tab indentation honors the indent-unit string on leptris >= 1.9.45
   (`indent_text:`), byte-identical to Nokogiri including
-  text-bearing children since the engine fix (leptris/leptris#658,
-  1.9.46); comment children still diverge on the element unit path
-  (leptris-ruby#115).
+  text-bearing children and comment children alike
+  (leptris/leptris#658 at 1.9.46; leptris-ruby#115 at 1.9.50).
 * A PI preceding the DOCTYPE reorders on serialization — libleptris
   normalizes DOCTYPE-first and the document node does not record its
   relative position.

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

@@ -147,10 +147,11 @@ module Moxml
           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.
+          # after the first (leptris/leptris#687) — moxml's own
+          # formatter is correct, so those compose until the probe
+          # says the engine is fixed.
           dt = doc.doctype
-          if dt&.class&.method_defined?(:internal_subset) &&
+          if !ENGINE_MULTI_DECL_SUBSET_OK && dt&.class&.method_defined?(:internal_subset) &&
               (subset = dt.internal_subset) && subset.scan("<!").size > 1
             return nil
           end

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

@@ -75,27 +75,34 @@ module Moxml
           # Element output always ends with the close tag — but the
           # engine's serializer appends a stray trailing newline when
           # the element's last text child is non-ASCII (fixed engine
-          # side in 1.9.42; kept for older floor bindings). Note: the
-          # binding's indent_text kwarg is the display-form boolean,
-          # not Nokogiri's indent-unit string — do not forward it.
+          # side in 1.9.42; kept for older floor bindings).
           xml.sub(/\n+\z/, "")
         end
 
+        # A bare ampersand — not starting a named or numeric entity
+        # reference. Some engine builds (observed: the Linux 1.9.50
+        # platform gem) emit text-content ampersands unescaped; the
+        # detection below is a no-op on correct builds.
+        RAW_AMP_RE = /&(?!#{Entity::NAME_PATTERN};|#\d+;|#x[0-9A-Fa-f]+;)/
+
         def normalize_serialization(xml, options)
-          needs_apos = xml.include?("'")
+          # The libxml2-layout serializer (>= 1.9.42) keeps attribute
+          # apostrophes literal; older engines escaped them.
+          needs_apos = !LIBXML2_LAYOUT_PARITY && xml.include?("'")
           needs_expand = options[:expand_empty] && xml.include?("/>")
-          return xml unless needs_apos || needs_expand
+          needs_amp = xml.include?("&") && xml.match?(RAW_AMP_RE)
+          return xml unless needs_apos || needs_expand || needs_amp
 
           out = +""
           pos = 0
           while pos < xml.length
             opener_at, terminator = next_literal_region(xml, pos)
             if opener_at.nil?
-              out << normalize_markup(xml[pos..], needs_apos, needs_expand)
+              out << normalize_markup(xml[pos..], needs_apos, needs_expand, needs_amp: needs_amp)
               break
             end
 
-            out << normalize_markup(xml[pos...opener_at], needs_apos, needs_expand)
+            out << normalize_markup(xml[pos...opener_at], needs_apos, needs_expand, needs_amp: needs_amp)
             search_from = opener_at + opener_at_offset(terminator)
             close = xml.index(terminator, search_from)
             close_end = close.nil? ? xml.length : close + terminator.length
@@ -127,13 +134,16 @@ module Moxml
           terminator == "-->" ? 4 : 0
         end
 
-        def normalize_markup(markup, needs_apos, needs_expand)
+        def normalize_markup(markup, needs_apos, needs_expand, needs_amp: false)
           markup = markup.gsub("&apos;", "'") if needs_apos
           if needs_expand
             markup = markup.gsub(EMPTY_ELEMENT_RE) do
               "<#{Regexp.last_match(1)}#{Regexp.last_match(2)}></#{Regexp.last_match(1)}>"
             end
           end
+          # Segment-aware: this never sees CDATA/comment/PI content,
+          # where a bare & is literal data.
+          markup = markup.gsub(RAW_AMP_RE, "&amp;") if needs_amp
           markup
         end
       end

data/lib/moxml/adapter/leptris.rb

@@ -49,6 +49,39 @@ module Moxml
       INDENT_UNIT_SUPPORTED =
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.45")
 
+      # leptris-ruby#115 (fixed 1.9.50): the element unit path keeps
+      # child comments.
+      ELEMENT_UNIT_COMMENTS =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.50")
+
+      # leptris/leptris#677: the engine's DROP_WS_TEXT trims boundary
+      # whitespace of non-blank text nodes. Probed at load rather
+      # than version-gated so the C fix is adopted the moment a fixed
+      # binding installs — no moxml release needed. While the probe
+      # fails, noblanks drops blanks moxml-side after parse.
+      ENGINE_NOBLANKS_SAFE = begin
+        doc = ::Leptris::XML::Document.parse(
+          "<r> x</r>", options: ::Leptris::XML::ParseOptions.noblanks
+        )
+        text = doc.root.children.first
+        text.is_a?(::Leptris::XML::Text) && text.content == " x"
+      rescue StandardError
+        false
+      end
+
+      # leptris/leptris#687: the engine's subset serializer mangles
+      # every internal-subset declaration after the first. Probed for
+      # the same reason — once fixed, the whole-document fast path
+      # serves multi-declaration subsets too.
+      ENGINE_MULTI_DECL_SUBSET_OK = begin
+        doc = ::Leptris::XML::Document.parse(
+          %(<?xml version="1.0"?><!DOCTYPE r [<!ELEMENT r (#PCDATA)><!ATTLIST e a CDATA "d">]><r/>),
+        )
+        doc.to_xml.include?("<!ATTLIST")
+      rescue StandardError
+        false
+      end
+
       NO_PARSE_ERRORS = [].freeze
       private_constant :NO_PARSE_ERRORS
 
@@ -106,10 +139,10 @@ module Moxml
           ctx = _context || Context.new(:leptris)
           doc = Document.new(native_doc, ctx)
 
-          if options[:noblanks]
+          if options[:noblanks] && !ENGINE_NOBLANKS_SAFE
             # The engine's DROP_WS_TEXT trims boundary whitespace of
             # NON-blank text nodes at parse (leptris/leptris#677), so
-            # the flag is never forwarded — blanks drop here instead.
+            # the flag is not forwarded — blanks drop here instead.
             if options[:readonly] == true
               raise ArgumentError,
                     "noblanks: true requires a mutable document (readonly: true freezes the tree at parse)"
@@ -128,14 +161,12 @@ module Moxml
         # nil when no parse flag is requested — the binding treats a
         # nil options hash as plain defaults (matching libxml2/
         # Nokogiri semantics: blanks kept, no ATTLIST defaults).
-        # noblanks is deliberately absent: the engine's
-        # LEPTRIS_PARSE_DROP_WS_TEXT trims boundary whitespace of
-        # non-blank text nodes too (leptris/leptris#677), so moxml
-        # implements it itself after parse — see
-        # strip_blank_text_nodes!.
+        # noblanks forwards only once the engine flag is libxml2-safe
+        # (see ENGINE_NOBLANKS_SAFE); otherwise it is moxml-side.
         def parse_flags(options)
           flags = 0
           flags |= ::Leptris::XML::ParseOptions::DTDATTR if options[:dtdattr] == true
+          flags |= ::Leptris::XML::ParseOptions::NOBLANKS if options[:noblanks] == true && ENGINE_NOBLANKS_SAFE
           flags.zero? ? nil : ::Leptris::XML::ParseOptions.new(flags)
         end
 

data/lib/moxml/attribute.rb

@@ -10,6 +10,7 @@ module Moxml
       # Mutation return contract (Adapter::Base): returns the native
       # to keep tracking — same object for in-place adapters, fresh
       # object for value-object adapters (leptris).
+      context.bump_namespace_scope_generation
       @native = adapter.set_attribute_name(@native, new_name)
     end
 
@@ -32,6 +33,7 @@ module Moxml
     end
 
     def value=(new_value)
+      context.bump_namespace_scope_generation
       adapter.set_attribute_value(@native, new_value)
     end
 

data/lib/moxml/element.rb

@@ -3,10 +3,14 @@
 module Moxml
   class Element < Node
     def name
-      adapter.node_name(@native)
+      # The adapter read is an FFI call plus (on several adapters) a
+      # defensive string copy; names only change through name= and
+      # native adoption, both of which clear this.
+      @name ||= adapter.node_name(@native)
     end
 
     def name=(value)
+      @name = nil
       adapter.set_node_name(@native, value)
     end
 
@@ -42,6 +46,7 @@ module Moxml
     # attributes only; prefixed names replace by namespace URI and
     # require a declared prefix. Cache coherence is the resolver's.
     def []=(name, value)
+      context.bump_namespace_scope_generation
       Moxml::AttributeResolver.assign(self, name, normalize_xml_value(value))
     end
 
@@ -49,13 +54,30 @@ module Moxml
     # bare names match only no-namespace attributes; prefixed names
     # resolve through in-scope declarations to expanded names.
     def [](name)
-      Moxml::AttributeResolver.resolve(self, name)&.value
+      cache = attribute_read_cache
+      key = name.to_s
+      unless cache.key?(key)
+        cache[key] = Moxml::AttributeResolver.resolve(self, key)
+      end
+      cache[key]&.value
     end
 
     def attribute(name)
       Moxml::AttributeResolver.resolve(self, name)
     end
 
+    # Resolution reads the element.s in-scope namespaces, so the
+    # cache rides the context.s namespace-scope generation clock —
+    # every attribute or namespace mutation anywhere bumps it.
+    def attribute_read_cache
+      generation = context.namespace_scope_generation
+      if @attribute_cache_generation != generation
+        @attribute_cache = {}
+        @attribute_cache_generation = generation
+      end
+      @attribute_cache
+    end
+
     # Returns attribute value by name (used by XPath engine)
     def get(attr_name)
       self[attr_name]
@@ -70,6 +92,7 @@ module Moxml
     end
 
     def remove_attribute(name)
+      context.bump_namespace_scope_generation
       Moxml::AttributeResolver.remove(self, name)
       self
     end
@@ -223,9 +246,13 @@ module Moxml
       children
     end
 
-    # Called by Attribute#remove to invalidate the cached attributes
+    # Called by Attribute#remove and the attribute mutators. Clears
+    # the attribute list and the resolved-read cache, and bumps the
+    # context generation so cross-wrapper reads recompute.
     def invalidate_attribute_cache!
       @attributes = nil
+      @attribute_cache = nil
+      context.bump_namespace_scope_generation
     end
 
     # Clear the namespace caches and bump the context's scope

data/lib/moxml/node.rb

@@ -25,10 +25,18 @@ module Moxml
         context.unregister_wrapper(@native)
         @native = new_native
         context.register_wrapper(new_native, self)
+        clear_native_memo!
       end
       self
     end
 
+    # Wrapper-local memos derived from the native (name, attribute
+    # reads) die with the native they were computed from.
+    def clear_native_memo!
+      @name = nil
+      @attribute_cache = nil
+    end
+
     def document
       Document.wrap(adapter.document(@native), context)
     end

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -175,6 +175,14 @@ RSpec.describe Moxml::Adapter::Leptris do
       end
     end
 
+    it "keeps comments in element serialization with tab units (leptris-ruby#115)" do
+      skip "requires the element unit fix (leptris 1.9.50+)" unless described_class::ELEMENT_UNIT_COMMENTS
+
+      doc = ctx.parse(%(<r><a/><!-- c --></r>))
+      expect(doc.root.to_xml(indent: 1, indent_text: "\t"))
+        .to eq("<r>\n\t<a></a>\n\t<!-- c -->\n</r>")
+    end
+
     it "round-trips document-level PI mutations through serialization" do
       # leptris/leptris#612: parse-created document PIs carry doc
       # linkage — the setters work and the tree round-trips.
@@ -235,8 +243,12 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(doc.root.children.to_a.select(&:text?)).to be_empty
     end
 
-    it "refuses noblanks on readonly parses" do
-      # The strip mutates the tree; readonly freezes it at parse.
+    it "refuses noblanks on readonly parses while the strip path is active" do
+      # The strip mutates the tree; readonly freezes it at parse. On
+      # bindings whose engine flag is libxml2-safe (probe), the flag
+      # forwards at parse and no mutability is needed.
+      skip "engine noblanks flag is libxml2-safe — no strip path" if described_class::ENGINE_NOBLANKS_SAFE
+
       expect { ctx.parse("<a/>", noblanks: true, readonly: true) }
         .to raise_error(ArgumentError, /noblanks.*mutable/)
     end

metadata

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