moxml 0.5.4 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9c1c880ebd136229eb81109ecbfc504a27b9bc101805688231525587a1601e8
-  data.tar.gz: c09ed1d4c857d7a78006f4c2ade2bcb662bac233578858e7aeb0ca0b0d2f09f7
+  metadata.gz: 7f2b8ff3a745345a5d0462bd246f0ee8b463713fcad2dcf99590813ffd49aa27
+  data.tar.gz: 8930bcdaee831095c3a5b576d4f19a36591fd1a3884e0fb1f0aebb1c4c91485f
 SHA512:
-  metadata.gz: d334d7e9789817b8891a78b77cf2bbaab05af83252a432cdc4bffb6728c37938a9f430098561ab8a8fa2db77f9ec0f089fc563922a1ceab046f26e7b2a1e01ed
-  data.tar.gz: 1feb278e326095475c68bea001bd68f3ac76e8423fdf021bc3a54b765b4e9069ec5cf403c282687fb3843b6ca6411868d9208e6a50a5ea071ca5e443485358f0
+  metadata.gz: d7c64568fa5c5a013bee81b37e9329590817c5d0db567c6f8c609de48e6782d75544e10bfe00929d0768e04a10591eef54c3a79e1ed3acfab2aa34dc1a11eb64
+  data.tar.gz: 6eebca4d31617a36da0df9f471bafc7085556b7216af8bb6138df0c9e5c2d8982fdfd6bd8ad897a3c88bdc06367c30fef9ccc9418575480ce0b97546a40af38c

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/base.rb

@@ -173,6 +173,14 @@ namespace_validation_mode: :strict)
           node
         end
 
+        # Whether children() results need per-child patch_node
+        # rewriting. Adapters whose natives arrive pre-wrapped (all but
+        # ox and libxml) answer false so the wrapper layer can skip
+        # the identity map over every child list.
+        def patches_children?
+          false
+        end
+
         # Whether the subtree at native can contain entity markers.
         # Marker-tracking adapters override this so the post-serialize
         # restore can skip its full-output scans on marker-free

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
@@ -270,7 +274,13 @@ module Moxml
           when ::Leptris::XML::Document
             assemble_document_children(node)
           when CustomizedLeptris::Declaration, CustomizedLeptris::Doctype,
-               CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment
+               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,
+               ::Leptris::XML::CDATA, ::Leptris::XML::ProcessingInstruction,
+               ::Leptris::XML::Attr
             []
           else
             natives = node.children.to_a
@@ -316,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
@@ -442,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
@@ -736,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)
@@ -858,9 +875,7 @@ module Moxml
           native = native_doctype_xml(doc)
           parts << native 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 }
 
           parts << raw_serialize(doc.root, options) if doc.root
 
@@ -930,6 +945,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 = []
 
@@ -939,6 +969,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)
@@ -961,7 +1000,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/adapter/libxml.rb

@@ -1134,6 +1134,10 @@ module Moxml
           end
         end
 
+        def patches_children?
+          true
+        end
+
         def patch_node(node, _parent = nil)
           # Wrap native LibXML nodes in our wrapper classes
           return node if node.nil?

data/lib/moxml/adapter/ox.rb

@@ -243,6 +243,10 @@ module Moxml
           Marshal.load(Marshal.dump(node))
         end
 
+        def patches_children?
+          true
+        end
+
         def patch_node(node, parent = nil)
           new_node =
             case node

data/lib/moxml/config.rb

@@ -11,10 +11,13 @@ module Moxml
     # when the installed leptris supports programmatic document
     # construction (Leptris::XML::Document.create); otherwise moxml
     # falls back to FALLBACK_ADAPTER so released-gem environments keep
-    # working. Oga remains the Opal default (pure Ruby).
+    # working. Under Opal the default is oga only when the vendored
+    # pure-Ruby fork was compiled into the bundle — stock oga requires
+    # its C extension and cannot load there; otherwise rexml.
     PREFERRED_ADAPTER = :leptris
     FALLBACK_ADAPTER = :nokogiri
     OPAL_DEFAULT_ADAPTER = :oga
+    OPAL_FALLBACK_ADAPTER = :rexml
 
     # Entity loading modes:
     # - :required - Must load entities, raise error if unavailable (default)
@@ -35,13 +38,26 @@ module Moxml
       end
 
       def runtime_default_adapter
-        return OPAL_DEFAULT_ADAPTER if RUBY_ENGINE == "opal"
+        return opal_runtime_adapter if RUBY_ENGINE == "opal"
 
         return PREFERRED_ADAPTER if leptris_preferred_available?
 
         detect_loaded_adapter || FALLBACK_ADAPTER
       end
 
+      # Stock oga requires its C extension, so under Opal the oga
+      # adapter can only come from the vendored pure-Ruby fork — a
+      # repo-only artifact the released gem does not ship. Bundles
+      # that compiled it in (moxml's own harness) keep oga; everyone
+      # else gets the rexml adapter, whose Opal compat ships in-gem.
+      # `defined?` is safe here: this branch never runs under MRI,
+      # where it would trigger autoload resolution.
+      def opal_runtime_adapter
+        return OPAL_DEFAULT_ADAPTER if defined?(Moxml::Adapter::Oga)
+
+        OPAL_FALLBACK_ADAPTER
+      end
+
       # True when the leptris gem is installed AND new enough for the
       # adapter (it needs programmatic document construction, which
       # released 1.1.x lacks). Memoized: the require probe runs once.

data/lib/moxml/node.rb

@@ -38,11 +38,11 @@ module Moxml
     end
 
     def children
-      @children ||= NodeSet.new(
-        adapter.children(@native).map { adapter.patch_node(_1, @native) },
-        context,
-        self,
-      )
+      @children ||= begin
+        natives = adapter.children(@native)
+        natives = natives.map { adapter.patch_node(_1, @native) } if adapter.patches_children?
+        NodeSet.new(natives, context, self)
+      end
     end
 
     def next_sibling

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -81,6 +81,54 @@ 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
+      from_document = doc.to_xml.sub(%r{\A<\?xml[^>]*\?>}, "")
+
+      expect(from_document).to start_with(from_children)
+    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.4
+  version: 0.5.6
 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