moxml 0.5.5 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cc1ee5cd198e8016cd259e62eec132ef73863dbb91125cca55349c8847df01c
-  data.tar.gz: 9b3db2921b1acaebaaeccfa6dbba82c78184443c6338e79952e334da0a837b0c
+  metadata.gz: c0d0117dfa9a9f81f628f2200d09b21d93d148a1dd4d0614c98749c90cdb569e
+  data.tar.gz: 85de05e0fe6d7d596b8e39508adbcd98c312b63d16d10eb146caab8f147cdb08
 SHA512:
-  metadata.gz: 4a4ccdd2949f15fedf7bee4bc2c41b9340250ec58d2d4583e7be7a0a14c397749e034f1ec3e15193c7a2ad93d43de7126338fecf2142ad1180ea50b3de25a97a
-  data.tar.gz: 9e4abee61c92cb0a3390804af398e6baaf593107e8bbc9b33b10d5bc40675f9f0b92ef5ded27f0b8948edd8c930b5188496c4c644529a277d8dd71b49f3bae57
+  metadata.gz: a57ef921cc44f3706e541abce2bef21b5b9f91066d9bc3528be802a373d57a488fb36825bf13dcf083aa88572fe1d2618ddbbb0d4ebec9a3de93515006698974
+  data.tar.gz: db325b0220a05b14bc2e037250c75319a60be30e652d05a1519ea0d26b5ff3afa55031d467312e81388442cb4f172513ef64cfb42be37ddca4c9da4d46704e97

data/.github/workflows/release.yml

@@ -30,6 +30,8 @@ jobs:
     with:
       next_version: ${{ github.event.inputs.next_version }}
       gated: ${{ inputs.gated == true }}
+    # No rubygems-api-key: the gem publishes through its configured
+    # RubyGems OIDC trusted publisher. pat_token covers the version
+    # bump push to main.
     secrets:
-      rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
       pat_token: ${{ secrets.GITHUB_TOKEN }}

data/lib/moxml/adapter/customized_leptris/document_pi.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    module CustomizedLeptris
+      # Document-level processing instruction. libleptris stores these
+      # outside the element tree (a flat, document-ordered list with no
+      # prolog/epilog anchoring — its serializer emits them all before
+      # the root), reachable through Document#processing_instructions
+      # as [target, data] pairs. This pseudo-native gives the pairs a
+      # node identity so the moxml contract can list them as document
+      # children.
+      class DocumentPI
+        attr_accessor :target, :data, :parent_doc
+        alias content data
+        alias content= data=
+
+        def initialize(target, data = "", parent_doc = nil)
+          @target = target
+          @data = data.to_s
+          @parent_doc = parent_doc
+        end
+
+        def to_xml
+          data.empty? ? "<?#{target}?>" : "<?#{target} #{data}?>"
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && target == other.target && data == other.data
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/customized_leptris.rb

@@ -3,7 +3,8 @@
 module Moxml
   module Adapter
     # Pure-Ruby node kinds that libleptris has no native representation
-    # for: XML declarations, programmatic DOCTYPEs, and entity references.
+    # for: XML declarations, programmatic DOCTYPEs, entity references,
+    # and document-level processing instructions.
     # The adapter stores them via NativeAttachment and serializes them
     # from #to_xml.
     module CustomizedLeptris
@@ -11,6 +12,7 @@ module Moxml
       autoload :Doctype, "moxml/adapter/customized_leptris/doctype"
       autoload :EntityReference, "moxml/adapter/customized_leptris/entity_reference"
       autoload :TextSegment, "moxml/adapter/customized_leptris/text_segment"
+      autoload :DocumentPI, "moxml/adapter/customized_leptris/document_pi"
     end
   end
 end

data/lib/moxml/adapter/leptris.rb

@@ -215,7 +215,8 @@ module Moxml
         def entity_bearing?(native)
           case native
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
-               CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment
+               CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
+               CustomizedLeptris::DocumentPI
             true
           else
             doc = native.document
@@ -231,7 +232,7 @@ module Moxml
           when CustomizedLeptris::EntityReference then :entity_reference
           when ::Leptris::XML::CDATA then :cdata
           when ::Leptris::XML::Comment then :comment
-          when ::Leptris::XML::ProcessingInstruction then :processing_instruction
+          when ::Leptris::XML::ProcessingInstruction, CustomizedLeptris::DocumentPI then :processing_instruction
           when ::Leptris::XML::Text, CustomizedLeptris::TextSegment then :text
           when ::Leptris::XML::Element then :element
           when ::Leptris::XML::Attr then :attribute
@@ -241,13 +242,14 @@ module Moxml
 
         def node_name(node)
           return node.root_name if node.is_a?(::Leptris::XML::DocType)
+          return node.target if node.is_a?(CustomizedLeptris::DocumentPI)
 
           node.name.to_s.dup.force_encoding("UTF-8")
         end
 
         def set_node_name(node, name)
           case node
-          when ::Leptris::XML::ProcessingInstruction then node.target = name
+          when ::Leptris::XML::ProcessingInstruction, CustomizedLeptris::DocumentPI then node.target = name
           else node.name = name
           end
         end
@@ -260,6 +262,8 @@ module Moxml
             CustomizedLeptris::Doctype.new(node.name, node.external_id, node.system_id)
           when CustomizedLeptris::EntityReference
             CustomizedLeptris::EntityReference.new(node.name)
+          when CustomizedLeptris::DocumentPI
+            CustomizedLeptris::DocumentPI.new(node.target, node.data, node.parent_doc)
           else
             node.dup
           end
@@ -271,6 +275,7 @@ module Moxml
             assemble_document_children(node)
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
                CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
+               CustomizedLeptris::DocumentPI,
                # Terminal node kinds pay an FFI round trip for an empty
                # list; unfiltered recursions visit every text node.
                ::Leptris::XML::Text, ::Leptris::XML::Comment,
@@ -321,7 +326,8 @@ module Moxml
         def parent(node)
           case node
           when ::Leptris::XML::Document then nil
-          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype then node.parent_doc
+          when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
+               CustomizedLeptris::DocumentPI then node.parent_doc
           when CustomizedLeptris::TextSegment, CustomizedLeptris::EntityReference then node.parent
           else
             # The binding reports the root element as parentless; the
@@ -447,6 +453,12 @@ module Moxml
             attachments.delete(node.parent_doc, :doctype) if node.parent_doc
           when CustomizedLeptris::EntityReference
             marker_text_for(node.parent, node.name)&.unlink
+          when CustomizedLeptris::DocumentPI
+            raise Moxml::NotImplementedError.new(
+              "libleptris has no document-level PI removal",
+              adapter: :leptris,
+              feature: :remove,
+            )
           else
             node.unlink
           end
@@ -741,7 +753,7 @@ module Moxml
           # binding, so a Text branch first would swallow CDATA nodes.
           case node
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
-               CustomizedLeptris::EntityReference
+               CustomizedLeptris::EntityReference, CustomizedLeptris::DocumentPI
             return node.to_xml
           when ::Leptris::XML::CDATA
             return XmlEmitter.cdata(node.content)
@@ -847,6 +859,11 @@ 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)
+          # 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.
+          # Document-level text is content, not structure: no added
+          # newline.
           parts = []
 
           include_decl = !options[:no_declaration] && options.fetch(:declaration) do
@@ -854,20 +871,18 @@ module Moxml
           end
           if include_decl
             declaration = attachments.get(doc, :declaration)
-            parts << (declaration ? declaration.to_xml : default_declaration_xml(doc, options))
+            parts << (declaration ? declaration.to_xml : default_declaration_xml(doc, options)) << "\n"
           end
 
           doctype = attachments.get(doc, :doctype)
-          parts << doctype.to_xml if doctype
+          parts << doctype.to_xml << "\n" if doctype
 
           native = native_doctype_xml(doc)
-          parts << native if native
+          parts << native << "\n" if native
 
-          (doc.processing_instructions || []).each do |(target, data)|
-            parts << (data.to_s.empty? ? "<?#{target}?>" : "<?#{target} #{data}?>")
-          end
+          document_pi_nodes(doc).each { |pi| parts << pi.to_xml << "\n" }
 
-          parts << raw_serialize(doc.root, options) if doc.root
+          parts << raw_serialize(doc.root, options) << "\n" if doc.root
 
           texts = attachments.get(doc, :document_text)
           texts&.each { |text| parts << XmlEmitter.escape_text(text.content.to_s) }
@@ -935,6 +950,21 @@ module Moxml
           attachments.get(native, :had_source_declaration) ? true : false
         end
 
+        # Document-level PI pseudo-nodes, materialized once from the C
+        # list and cached per document: children and serialization read
+        # the same objects, so wrapper mutations round-trip. Build the
+        # cache BEFORE appending a PI with add_pi, or the C-side
+        # addition would be double-counted.
+        def document_pi_nodes(doc)
+          attachments.get(doc, :doc_pi_nodes) || begin
+            nodes = doc.processing_instructions.map do |(target, data)|
+              CustomizedLeptris::DocumentPI.new(target, data, doc)
+            end
+            attachments.set(doc, :doc_pi_nodes, nodes)
+            nodes
+          end
+        end
+
         def assemble_document_children(doc)
           children = []
 
@@ -944,6 +974,15 @@ module Moxml
           doctype_wrapper = attachments.get(doc, :doctype)
           children << doctype_wrapper if doctype_wrapper
 
+          # Document-level PIs live outside the element tree in
+          # libleptris (a flat list; its serializer emits them before
+          # the root). Listed after the DOCTYPE to match the order
+          # serialize_document emits, so children and serialization
+          # agree. Epilog anchoring is not representable in the C
+          # model — a known divergence from the Nokogiri-shaped
+          # contract the other adapters expose.
+          children.concat(document_pi_nodes(doc))
+
           children << doc.root if doc.root
 
           texts = attachments.get(doc, :document_text)
@@ -966,7 +1005,15 @@ module Moxml
           when ::Leptris::XML::Element
             doc.root = child
           when ::Leptris::XML::ProcessingInstruction
+            document_pi_nodes(doc)
             doc.add_pi(child.target, child.content.to_s)
+            document_pi_nodes(doc) << CustomizedLeptris::DocumentPI.new(
+              child.target, child.content.to_s, doc
+            )
+          when CustomizedLeptris::DocumentPI
+            document_pi_nodes(doc)
+            doc.add_pi(child.target, child.data)
+            document_pi_nodes(doc) << child
           when ::Leptris::XML::Text
             texts = attachments.get(doc, :document_text) || []
             texts << child

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -81,6 +81,64 @@ RSpec.describe Moxml::Adapter::Leptris do
     end
   end
 
+  describe "document-level processing instructions" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "lists document PIs as children with the root" do
+      doc = ctx.parse('<?xml version="1.0"?><?pi-prolog before?><root/><?pi-epilog after?>')
+      kids = doc.children.to_a
+
+      expect(kids.map(&:class)).to eq(
+        [Moxml::ProcessingInstruction, Moxml::ProcessingInstruction, Moxml::Element],
+      )
+      expect(kids.select(&:processing_instruction?).map(&:target)).to eq(%w[pi-prolog pi-epilog])
+      expect(kids[0].content).to eq("before")
+    end
+
+    it "round-trips mutations and additions through serialization" do
+      doc = ctx.parse("<?pi-original x?><root/>")
+      pi = doc.children.to_a[0]
+      pi.target = "renamed"
+      pi.content = "changed"
+      expect(doc.to_xml).to include("<?renamed changed?>")
+
+      doc.add_child(doc.create_processing_instruction("added", "now"))
+      expect(doc.to_xml).to include("<?added now?>")
+      expect(doc.children.to_a.select(&:processing_instruction?).map(&:target)).to eq(%w[renamed added])
+    end
+
+    it "serializes children and document output in agreement" do
+      # libleptris stores document PIs as one flat pre-root list (no
+      # epilog anchoring); children and to_xml must at least agree.
+      doc = ctx.parse('<?xml version="1.0"?><?pi-a 1?><root/><?pi-b 2?>')
+      from_children = doc.children.to_a.select(&:processing_instruction?)
+        .map(&:to_xml).join("\n")
+      from_document = doc.to_xml.sub(%r{\A<\?xml[^>]*\?>\n}, "")
+
+      expect(from_document).to start_with(from_children)
+    end
+
+    it "matches raw Nokogiri byte-for-byte for pretty-printing (issue #129)" do
+      source = %(<root><a/><b>x</b></root>)
+      target = Nokogiri::XML(source).to_xml(indent: 2, encoding: "UTF-8")
+      output = ctx.parse(source).to_xml(
+        indent: 2, declaration: true, expand_empty: false, encoding: "UTF-8",
+      )
+
+      expect(output).to eq(target)
+    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]
+      target_doc = ctx.parse("<other/>")
+      target_doc.add_child(moved)
+
+      expect(target_doc.to_xml).to include("<?pi-src orig?>")
+      expect(target_doc.children.to_a.select(&:processing_instruction?).map(&:target)).to include("pi-src")
+    end
+  end
+
   describe "entity-marker tracking" do
     let(:ctx) { Moxml.new(:leptris) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.5.7
 platform: ruby
 authors:
 - Ribose Inc.
@@ -123,6 +123,7 @@ files:
 - lib/moxml/adapter/customized_leptris.rb
 - lib/moxml/adapter/customized_leptris/declaration.rb
 - lib/moxml/adapter/customized_leptris/doctype.rb
+- lib/moxml/adapter/customized_leptris/document_pi.rb
 - lib/moxml/adapter/customized_leptris/entity_reference.rb
 - lib/moxml/adapter/customized_leptris/text_segment.rb
 - lib/moxml/adapter/customized_libxml.rb