moxml 0.5.17 → 0.5.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6de47d8ce88e56853b7523dfbcb2049e61d586878dca573d13bacd85138b4a4e
-  data.tar.gz: 520a050794c1275e5bc519454319a34fd059b9bbcf3f0efd0f5d8e0876bb7e97
+  metadata.gz: 62f62c2c744354f3dc8c6436cd5404eac78738bc3da00509c1daed9e827d5195
+  data.tar.gz: 25cddfe9066c8ebda91925a47834fb3180aaefc2b7be5f74b32409a3bdd44ffb
 SHA512:
-  metadata.gz: 6b197e6da24e0b40ead4fa25ee944b242ee3484475b2927a16e126faa208f8ff4bb7709795b1d2830b1394fbb0fad8d28f99ed32ec9dbf902710752286965e7c
-  data.tar.gz: 89b1ae523cf06687e67e4d07a088cdef2f942a1b4dcff8ba56f468fb887b1ac3bba936b10145c057eb0f6cf767c9e7ba35e86fb753854ee391f29951f2e17485
+  metadata.gz: 4598f34a5af3aa247349f0bf0cd5ea99fceb2a60c02412b31b3e6ecc391f0e5292668b5ca9c8bb2be304dee1cc7e3706e932ffe3c73ceaa9e0f9d45476c4fa24
+  data.tar.gz: e7c39fcc1a5dad848d9b4484e6065b3af1a890a8b4085a5d7cf731d20010a480d6ef0e2c6f8cbd7a579cc9c524360364475c2fb29c1704632fa7472a25a2eabc

data/.github/workflows/rake.yml

@@ -53,3 +53,8 @@ jobs:
 
       - name: Run rubocop
         run: bundle exec rubocop
+
+      - name: Run performance gates
+        env:
+          RUN_PERFORMANCE: "1"
+        run: bundle exec rake spec:performance

data/Rakefile

@@ -222,8 +222,9 @@ namespace :spec do
     t.pattern = "spec/examples/**/*_spec.rb"
   end
 
-  desc "Run performance benchmarks"
+  desc "Run performance benchmarks (sets RUN_PERFORMANCE=1)"
   RSpec::Core::RakeTask.new(:performance) do |t|
+    ENV["RUN_PERFORMANCE"] = "1"
     t.pattern = "spec/performance/**/*_spec.rb"
     t.rspec_opts = "--tag performance"
   end
@@ -288,4 +289,4 @@ namespace :opal do
   end
 end
 
-task default: %i[spec rubocop]
+task default: :spec

data/docs/_pages/adapter-protocol.adoc

@@ -18,7 +18,9 @@ code disagree.
 == Method groups
 
 Parse and document lifecycle::
-`parse(xml, options, context)`, `create_document`, `create` factories
+`parse(xml, options, context)` — `noblanks: true` drops
+whitespace-only text nodes where the engine has the flag
+(Nokogiri, leptris), `create_document`, `create` factories
 (`create_native_element`, `create_native_text`, `create_native_cdata`,
 `create_native_comment`, `create_native_processing_instruction`,
 `create_native_declaration`, `create_native_doctype`,
@@ -56,8 +58,9 @@ the tracked native; wrappers re-key through `refresh_native!`.
 Serialization::
 `serialize(node, options)`. Options: `indent`, `encoding`,
 `declaration`, `no_declaration`, `expand_empty`, `line_ending`,
-`indent_text` (the indent-unit string — honored where the engine
-has it, e.g. Nokogiri; leptris waits on leptris-ruby#109).
+`indent_text` (the indent-unit string — Nokogiri and
+leptris >= 1.9.45; its element unit path
+drops comments — leptris-ruby#115).
 Entity-marker restoration is owned by the wrapper layer
 (`Node#to_xml`), guarded by `entity_bearing?`.
 

data/docs/_pages/adapters/leptris.adoc

@@ -30,6 +30,13 @@ ctx.config.adapter_name        # => :leptris / :nokogiri / :rexml (Opal)
 
 == Parse options
 
+`noblanks: true`::
+Drop whitespace-only text nodes — libxml2 `XML_PARSE_NOBLANKS`
+semantics (issues #153/#156): boundary spaces of text-bearing
+nodes survive. Implemented moxml-side (the engine flag trims
+boundaries too — leptris/leptris/#677); requires a mutable
+document, so `readonly: true` + `noblanks: true` raises.
+
 `readonly: true`::
 The binding memoizes every read and refuses mutations — the
 parse-and-read lifecycle for multi-pass consumers (comparison, diff,
@@ -62,13 +69,14 @@ implementation over one `leptris_node_traverse` call.
 
 == Known limitations (tracked upstream)
 
+* 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).
 * A PI preceding the DOCTYPE reorders on serialization — libleptris
   normalizes DOCTYPE-first and the document node does not record its
   relative position.
-* Tab indentation: the binding's `indent_text` is the display-form
-  boolean, not Nokogiri's indent-unit string — the unit ask is
-  leptris-ruby#109. moxml forwards `indent_text:` to Nokogiri
-  meanwhile.
 
 Resolved with leptris-ruby 1.9.42 (leptris/leptris#636/#612): child
 PIs serialize on their own indented lines, DOCTYPE internal subsets

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

@@ -63,11 +63,15 @@ module Moxml
           include_decl = options.fetch(:declaration) do
             options[:no_declaration] ? false : document_has_declaration?(node)
           end
-          xml = node.to_xml(
+          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
+          xml = node.to_xml(**kwargs)
           # 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

data/lib/moxml/adapter/leptris.rb

@@ -40,6 +40,15 @@ module Moxml
       LIBXML2_LAYOUT_PARITY =
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.42")
 
+      # leptris-ruby#109 (1.9.45): Element#to_xml takes the
+      # indent-unit string, so moxml's per-child document composition
+      # can carry `indent_text:` through. Text-bearing leaves still
+      # emit spaces until the engine fix (leptris/leptris#658); the
+      # boolean display form stays document-level and is never
+      # forwarded (the element face raises on it).
+      INDENT_UNIT_SUPPORTED =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.45")
+
       NO_PARSE_ERRORS = [].freeze
       private_constant :NO_PARSE_ERRORS
 
@@ -81,7 +90,7 @@ module Moxml
             ::Leptris::XML::Document.parse(
               processed,
               readonly: options[:readonly] == true,
-              options: dtdattr_parse_options(options),
+              options: parse_flags(options),
             )
           rescue ::Leptris::XML::ParseError => e
             # libleptris has no recovery mode that survives unclosed
@@ -97,6 +106,18 @@ module Moxml
           ctx = _context || Context.new(:leptris)
           doc = Document.new(native_doc, ctx)
 
+          if options[:noblanks]
+            # 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.
+            if options[:readonly] == true
+              raise ArgumentError,
+                    "noblanks: true requires a mutable document (readonly: true freezes the tree at parse)"
+            end
+
+            strip_blank_text_nodes!(native_doc)
+          end
+
           record_source_declaration(native_doc, processed)
           attachments.set(native_doc, :entity_markers, entity_markers)
           attachments.set(native_doc, :parse_errors, recover_errors) if recover_errors
@@ -104,11 +125,58 @@ module Moxml
           doc
         end
 
-        # nil unless DTDATTR is requested — the binding treats a nil
-        # options hash as plain defaults (defaults exclude ATTLIST
-        # defaults, matching libxml2/Nokogiri semantics).
-        def dtdattr_parse_options(options)
-          options[:dtdattr] == true ? ::Leptris::XML::ParseOptions.dtdattr : nil
+        # 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!.
+        def parse_flags(options)
+          flags = 0
+          flags |= ::Leptris::XML::ParseOptions::DTDATTR if options[:dtdattr] == true
+          flags.zero? ? nil : ::Leptris::XML::ParseOptions.new(flags)
+        end
+
+        # XML whitespace exactly — \v and \f are not XML space.
+        BLANK_TEXT_RE = /\A[ \t\r\n]*\z/
+
+        # libxml2's XML_PARSE_NOBLANKS semantics (issues #153/#156):
+        # drop WHOLLY-whitespace text nodes; the boundary spaces of
+        # text-bearing nodes stay (mixed content cannot be
+        # re-indented). Raw-pointer walk over the root subtree — the
+        # same batch child-pointer pattern the materializer uses.
+        def strip_blank_text_nodes!(doc)
+          binding_ffi = ::Leptris::XML::FFI
+          root = binding_ffi.leptris_document_root(doc.c_ptr)
+          return unless root && !root.null?
+
+          strip_blanks_under(root, binding_ffi, ::FFI::MemoryPointer.new(:pointer, 64), 64)
+        end
+
+        def strip_blanks_under(ptr, binding_ffi, buf, capacity)
+          count = binding_ffi.leptris_node_children(ptr, buf, capacity)
+          while count == capacity
+            capacity *= 4
+            buf = ::FFI::MemoryPointer.new(:pointer, capacity)
+            count = binding_ffi.leptris_node_children(ptr, buf, capacity)
+          end
+
+          # Snapshot before unlinking or recursing — both reuse the
+          # buffer for the next level.
+          children = buf.read_array_of_pointer(count)
+          children.each do |child|
+            case binding_ffi.leptris_node_get_type(child)
+            when ::Leptris::XML::FFI::NODE_ELEMENT
+              strip_blanks_under(child, binding_ffi, buf, capacity)
+            when ::Leptris::XML::FFI::NODE_TEXT
+              content = binding_ffi.leptris_text_node_get_content(child)
+              next unless content.match?(BLANK_TEXT_RE)
+
+              binding_ffi.check_status(binding_ffi.leptris_node_unlink(child))
+            end
+          end
         end
 
         def parse_errors(native_doc)

data/lib/moxml/adapter/nokogiri.rb

@@ -26,11 +26,13 @@ module Moxml
               ::Nokogiri::XML::DocumentFragment.parse(processed_xml) do |config|
                 config.strict.nonet
                 config.recover unless options[:strict]
+                config.noblanks if options[:noblanks]
               end
             else
               ::Nokogiri::XML(processed_xml, nil, "UTF-8") do |config|
                 config.strict.nonet
                 config.recover unless options[:strict]
+                config.noblanks if options[:noblanks]
               end
             end
           rescue ::Nokogiri::XML::SyntaxError => e

data/lib/moxml/document.rb

@@ -104,7 +104,12 @@ module Moxml
       node = prepare_node(node)
 
       if node.is_a?(Declaration)
-        # Mark that document now has a declaration
+        # A proper XML document carries at most one declaration
+        # (issue #23).
+        if @has_xml_declaration || adapter.has_declaration?(@native, self)
+          raise Moxml::ValidationError, "Document already has an XML declaration"
+        end
+
         @has_xml_declaration = true
         adapter.add_child(@native, node.native)
       elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment) && !node.is_a?(Doctype)

data/lib/moxml/node_set.rb

@@ -4,7 +4,7 @@ module Moxml
   class NodeSet
     include Enumerable
 
-    attr_reader :nodes, :context
+    attr_reader :context
 
     def initialize(nodes, context, parent_node = nil)
       @nodes = Array(nodes)
@@ -13,6 +13,13 @@ module Moxml
       @parent_node = parent_node
     end
 
+    # The raw native nodes — adapter-internal work only (issue #26).
+    # The public surface is wrapper-only: every Enumerable access
+    # goes through #each/#[]/#to_a, which wrap.
+    def native_nodes
+      @nodes
+    end
+
     def each
       return to_enum(:each) unless block_given?
 
@@ -64,7 +71,7 @@ module Moxml
     end
 
     def +(other)
-      self.class.new(@nodes + other.nodes, @context, @parent_node)
+      self.class.new(@nodes + other.native_nodes, @context, @parent_node)
     end
 
     def <<(node)

data/lib/moxml/version.rb

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

data/spec/integration/all_adapters_spec.rb

@@ -59,7 +59,15 @@ RSpec.describe "Cross-adapter integration" do
       end
 
       all_shared_examples.each do |shared_example_name|
-        it_behaves_like shared_example_name
+        # The performance battery runs only under RUN_PERFORMANCE /
+        # `rake spec:performance` (issue #45) - tagged at inclusion:
+        # definition-site metadata on the shared group does not
+        # propagate through this indirection.
+        if shared_example_name == "Performance Examples"
+          it_behaves_like shared_example_name, performance: true
+        else
+          it_behaves_like shared_example_name
+        end
       end
     end
   end

data/spec/integration/shared_examples/node_wrappers/declaration_behavior.rb

@@ -101,5 +101,11 @@ RSpec.shared_examples "Moxml::Declaration" do
       declaration.remove
       expect(doc.to_xml).not_to include("<?xml")
     end
+
+    it "rejects a second declaration (issue #23)" do
+      doc.add_child(doc.create_declaration("1.0"))
+      expect { doc.add_child(doc.create_declaration("1.0")) }
+        .to raise_error(Moxml::ValidationError, /already has an XML declaration/)
+    end
   end
 end

data/spec/moxml/adapter/leptris_spec.rb

@@ -185,6 +185,62 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(doc.to_xml).to include("<?renamed changed?>")
     end
 
+    it "matches raw Nokogiri with tab units" do
+      skip "requires the indent unit (leptris 1.9.45+)" unless described_class::INDENT_UNIT_SUPPORTED
+
+      # Text-bearing children included since the engine fix for
+      # leptris/leptris#658 (leptris 1.9.46). Comment children are
+      # excluded: the binding's element+unit path drops them
+      # (leptris-ruby#115).
+      sources = [
+        %(<r><a><b/></a><c><d/><e/></c></r>),
+        %(<root><child>content</child><empty/></root>),
+        %(<r>text <b>bold</b> tail</r>),
+      ]
+      sources.each do |source|
+        target = Nokogiri::XML(source).to_xml(indent: 1, indent_text: "\t", encoding: "UTF-8")
+        output = ctx.parse(source).to_xml(
+          indent: 1, declaration: true, expand_empty: false,
+          encoding: "UTF-8", indent_text: "\t"
+        )
+        expect(output).to eq(target), "tab parity failed for #{source}"
+      end
+    end
+
+    it "drops space-only text nodes with noblanks and matches Nokogiri (issues #153/#156)" do
+      sources = [
+        %(<a><t>1</t>    <n/></a>), # blank filler between tags
+        %(<p> leading</p>),                 # boundary space must survive
+        %(<p><b>b</b> after</p>),           # element-to-text space must survive
+        %(<p>trailing </p>),                # trailing space must survive
+        %(<r>\n  <a>x <b>y</b> z</a>\n  <c/>\n</r>),
+      ]
+      recipe = {
+        indent: 2, declaration: true, expand_empty: false, encoding: "UTF-8"
+      }
+
+      sources.each do |source|
+        target = Nokogiri::XML(source, &:noblanks).to_xml(indent: 2, encoding: "UTF-8")
+
+        doc = ctx.parse(source, noblanks: true)
+        expect(doc.to_xml(recipe)).to eq(target), "noblanks parity failed for #{source}"
+
+        via_nokogiri = Moxml.new(:nokogiri).parse(source, noblanks: true).to_xml(recipe)
+        expect(via_nokogiri).to eq(target)
+      end
+    end
+
+    it "leaves no text nodes on a noblanks tree of blank filler" do
+      doc = ctx.parse(%(<a><t>1</t>    <n/></a>), noblanks: true)
+      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.
+      expect { ctx.parse("<a/>", noblanks: true, readonly: true) }
+        .to raise_error(ArgumentError, /noblanks.*mutable/)
+    end
+
     it "reports the tracked native for a re-added document PI" do
       doc = ctx.parse("<?pi-src orig?><root/>")
       moved = doc.children.to_a[0]

data/spec/moxml/adapter/oga_spec.rb

@@ -13,12 +13,13 @@ RSpec.describe Moxml::Adapter::Oga do
   it_behaves_like "xml adapter"
 
   describe "serialization" do
-    it "does not duplicate XML declarations when declaration nodes repeat" do
+    it "rejects a repeated XML declaration instead of duplicating it (issue #23)" do
       context = Moxml::Context.new(:oga)
       doc = context.create_document
 
       doc.add_child(doc.create_declaration("1.0", "UTF-8"))
-      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+      expect { doc.add_child(doc.create_declaration("1.0", "UTF-8")) }
+        .to raise_error(Moxml::ValidationError)
       doc.add_child(doc.create_element("root"))
 
       serialized = doc.to_xml

data/spec/moxml/node_set_spec.rb

@@ -36,4 +36,16 @@ RSpec.describe Moxml::NodeSet do
       expect(nodes).to be_empty
     end
   end
+
+  describe "public surface (issue #26)" do
+    it "exposes raw natives only through native_nodes" do
+      children = doc.root.children
+      expect(children.native_nodes).not_to include(a_kind_of(Moxml::Node))
+      expect(children).not_to respond_to(:nodes)
+    end
+
+    it "wraps through the Enumerable surface" do
+      expect(doc.root.children.map(&:class).uniq).to eq([Moxml::Element])
+    end
+  end
 end

data/spec/performance/benchmark_spec.rb

@@ -4,9 +4,13 @@ require "benchmark"
 require "benchmark/ips"
 
 RSpec.shared_examples "Performance Examples" do
-  if ENV["SKIP_BENCHMARKS"]
-    it "skips benchmarks when SKIP_BENCHMARKS is set" do
-      skip "Benchmarks skipped. To run benchmarks, unset SKIP_BENCHMARKS"
+  # Issue #45: benchmarks never run inside the default suites - only
+  # under RUN_PERFORMANCE=1 (the CI perf step and
+  # rake spec:performance). RSpec tag exclusion proved unreliable
+  # through the shared-example indirection, so this is a hard env gate.
+  if ENV["SKIP_BENCHMARKS"] || !ENV["RUN_PERFORMANCE"]
+    it "skips benchmarks unless RUN_PERFORMANCE is set" do
+      skip "Benchmarks run only with RUN_PERFORMANCE=1 (rake spec:performance)"
     end
   else
     let(:context) { Moxml.new }
@@ -41,7 +45,7 @@ RSpec.shared_examples "Performance Examples" do
         }
       end
 
-      it "meets Parser performance threshold" do
+      it "meets Parser performance threshold", :performance do
         result = nil
         report = Benchmark.ips do |x|
           x.config(time: 5, warmup: 2)
@@ -54,7 +58,7 @@ RSpec.shared_examples "Performance Examples" do
         expect(ips).to be >= threshold, message
       end
 
-      it "meets Serializer performance threshold" do
+      it "meets Serializer performance threshold", :performance do
         report = Benchmark.ips do |x|
           x.config(time: 5, warmup: 2)
           x.report("Serializer") { _ = doc.to_xml }

metadata

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