moxml 0.5.91 → 0.5.93

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b290a2b707e7aec576eabf853e5e8434cb070369477d5ebc41735cadf8a0582
-  data.tar.gz: 1dd022ba5bd37967027aecaee876750134fb65086d595671c42f6dbebcdc3f8e
+  metadata.gz: 92d24efac79874e02cbfa26e20fc8135e2a714020a727896cdf2a460fa7d0508
+  data.tar.gz: 91f18637388f6983c2c75c606e95e93f15919b3099fbdc0c8e59ebf9aca93d5e
 SHA512:
-  metadata.gz: 1ecefd8a5388a448cc018b53b00ae11a5c91786f7641d40da11a5bcb46c957031da1a44d7b00bdb0fc086246750bb6a74af267f7cada75380ca5514a44d897b3
-  data.tar.gz: d344520c29067fb740f3372c2c2ea16791f9d9e88a7c7faea7e033943852af9a2e40e7e4404e0a7eb9dc9dd223c41d0ff68d2cdab1538f1f1d62c5347ab0fac1
+  metadata.gz: 91cd7d93def6717a7eedf675e871ff7d05d3dfb5378f8ddbe8f839daa68d0d1dbe0e1bdf6bdb939704bb03f673950c9faa858265321e2a209fbcb2042224a3cd
+  data.tar.gz: c973d0559eb5fcc42f45dfb824758cdbec8758ec0dc378a4ce4034d918b3b50fcdada1120cd9f18b47c39a42055d4cd810225588dbcf598346c920a2a510e0c7

data/lib/moxml/adapter/base.rb

@@ -184,6 +184,12 @@ module Moxml
           one == other
         end
 
+        # Owner element native for an attribute native, where the
+        # engine exposes it (nil elsewhere).
+        def attribute_element(_attribute)
+          nil
+        end
+
         # Backends without a native subtree digest answer nil —
         # the wrapper contract Node#digest gates on (issue #173).
         def digest(*)

data/lib/moxml/adapter/customized_libxml/node.rb

@@ -26,12 +26,17 @@ module Moxml
           @native = fresh
         end
 
-        # Compare wrappers based on their native nodes
+        # Compare wrappers based on their native nodes. Either side
+        # may arrive double-wrapped (a Customized node stored as
+        # another wrapper's native); LibXML's eql? raises on the
+        # class mismatch, so unwrap both before comparing.
         def ==(other)
           return false unless other
 
-          other_native = other.is_a?(self.class) ? other.native : other
-          @native == other_native
+          mine = @native.is_a?(CustomizedLibxml::Node) ? @native.native : @native
+          theirs = other.is_a?(self.class) ? other.native : other
+          theirs = theirs.native while theirs.is_a?(CustomizedLibxml::Node)
+          mine == theirs
         end
 
         alias eql? ==

data/lib/moxml/adapter/leptris.rb

@@ -1140,9 +1140,14 @@ module Moxml
               (prefix = node.prefix || prefix_part(node.name))
             resolved = resolve_prefix_ns(node.element, prefix)
             return resolved if resolved
+            # The xml prefix is reserved (Namespaces in XML 1.0 §2.10):
+            # bound to its URI on every element, never in
+            # namespace_definitions, so the scope walk always misses.
+            return implicit_xml_namespace(node) if prefix == "xml"
           end
 
           ns = node.namespace
+          return implicit_xml_namespace(node) if reserved_xml_uri?(ns)
           return ns unless ns.nil?
 
           # Set-side namespaces (created attributes, renamed elements)
@@ -1174,6 +1179,30 @@ module Moxml
           nil
         end
 
+        # The binding reports an attribute's namespace as a bare URI
+        # String; when no prefix can be recovered from the qualified
+        # name, the reserved xml binding must still answer for xml:*
+        # attributes.
+        RESERVED_XML_URI = "http://www.w3.org/XML/1998/namespace"
+
+        def reserved_xml_uri?(namespace)
+          case namespace
+          when ::Leptris::XML::Namespace
+            namespace.prefix.to_s.empty? && namespace.href == RESERVED_XML_URI
+          when String
+            namespace == RESERVED_XML_URI
+          else
+            false
+          end
+        end
+
+        def implicit_xml_namespace(node)
+          owner = node.is_a?(::Leptris::XML::Attr) ? node.element : node
+          return nil unless owner.is_a?(::Leptris::XML::Element)
+
+          ::Leptris::XML::Namespace.new(owner, RESERVED_XML_URI, prefix: "xml")
+        end
+
         def prefix_part(name)
           name.include?(":") ? name.split(":", 2)[0] : nil
         end
@@ -1609,7 +1638,13 @@ module Moxml
         end
 
         def attribute_element(attr)
-          attr.element
+          # XPath results mint ResultAttr (parent-backed); document
+          # attributes are binding Attr (element-backed).
+          if attr.is_a?(::Leptris::XML::ResultAttr)
+            attr.parent
+          else
+            attr.element
+          end
         end
 
         def attribute_name(attr)
@@ -1889,7 +1924,14 @@ module Moxml
         end
 
         def comment_content(node)
-          return NN_CONTENT.bind_call(node) if NATIVE_READ_LAYER && node.is_a?(NN)
+          if NATIVE_READ_LAYER && node.is_a?(NN)
+            content = NN_CONTENT.bind_call(node)
+            # NativeNode#content answers nil for comment-kind nodes
+            # (leptris-ruby#313); the shared-pointer bridge has it.
+            return to_binding(node).content if content.nil?
+
+            return content
+          end
 
           node.content
         end

data/lib/moxml/adapter/libxml.rb

@@ -421,7 +421,10 @@ module Moxml
         end
 
         def attribute_element(attr)
-          attr&.parent
+          # Customized nodes wrap raw LibXML nodes one level deep;
+          # callers of this face expect the raw native.
+          parent = attr&.parent
+          parent.is_a?(::Moxml::Adapter::CustomizedLibxml::Node) ? parent.native : parent
         end
 
         def attribute_namespace(attr)

data/lib/moxml/adapter/nokogiri.rb

@@ -50,6 +50,35 @@ module Moxml
           true
         end
 
+        # libxml2-native inclusive C14N: delegated for the default
+        # shape (Inclusive 1.0, no comments, no InclusiveNamespaces
+        # prefix list) when the probe below proves libxml2's output
+        # byte-identical to the Ruby reference (ported from canon).
+        # Every other combination keeps the Ruby engine.
+        # Lazy, not load-time: the probe exercises the wrapper layer
+        # (Document/C14n), which is circular while THIS adapter file
+        # is still loading.
+        def native_inclusive10(native)
+          return nil unless native_c14n_byte_safe?
+
+          native.canonicalize(::Nokogiri::XML::XML_C14N_1_0)
+        end
+
+        def native_c14n_byte_safe?
+          return @native_c14n_byte_safe unless @native_c14n_byte_safe.nil?
+
+          @native_c14n_byte_safe = begin
+            probe_xml = %(<?xml version="1.0"?><doc xmlns:p="urn:p" xmlns="urn:d" b="2" a="1"><e p:x="v" z="w">t &amp; u</e><!-- c --></doc>)
+            native_doc = ::Nokogiri::XML(probe_xml) { |c| c.strict.nonet }
+            native = native_doc.root.canonicalize(::Nokogiri::XML::XML_C14N_1_0)
+            wrapper = Wrappers::Document.new(native_doc, Context.new(:nokogiri))
+            reference = Moxml::C14n::Inclusive10.new.canonicalize(wrapper.root)
+            native == reference
+          rescue StandardError
+            false
+          end
+        end
+
         def set_root(doc, element)
           doc.root = element
         end

data/lib/moxml/adapter/rexml.rb

@@ -278,6 +278,9 @@ module Moxml
           result = []
           element.attributes.each_attribute do |attr|
             next if attr.prefix.to_s.start_with?("xmlns")
+            # REXML yields the default declaration with an empty prefix
+            # and name "xmlns"; treat it like any other declaration.
+            next if attr.name == "xmlns" && attr.prefix.to_s.empty?
 
             result << attr
           end

data/lib/moxml/c14n/data_model.rb

@@ -19,13 +19,85 @@ module Moxml
       end
 
       def self.from_node(moxml_node)
+        @source_map = {}
         return build_from_document(moxml_node) if moxml_node.is_a?(::Moxml::Document)
 
         root = Nodes::RootNode.new
-        root.add_child(build_node(moxml_node))
+        built = build_node(moxml_node, [0])
+        root.add_child(built) if built
         root
       end
 
+      # Position keys for subset selection: adapters mint fresh
+      # wrappers per traversal, so XPath-matched wrappers cannot be
+      # keyed by object identity. Both sides instead compute the same
+      # child-index path — the build walks dm children in order, the
+      # match side climbs parents counting buildable siblings (the
+      # same types build_node answers non-nil for).
+      class << self
+        attr_reader :source_map
+      end
+
+      BUILDABLE_TYPES = [::Moxml::Element, ::Moxml::Text, ::Moxml::Cdata,
+                         ::Moxml::Comment,
+                         ::Moxml::ProcessingInstruction].freeze
+
+      def self.buildable?(node)
+        BUILDABLE_TYPES.any? { |type| node.is_a?(type) }
+      end
+
+      # Path key of a matched wrapper relative to the source the data
+      # model was built from; nil when the wrapper is outside it.
+      # Attributes extend their owner's path with [:attribute, index].
+      # The adapter comes from the caller: the Attribute contract
+      # keeps its own adapter hop protected.
+      def self.path_key_for(wrapper, source, adapter)
+        case wrapper
+        when ::Moxml::Attribute
+          owner = wrapper.parent
+          unless owner.is_a?(::Moxml::Element)
+            # XPath results are re-wrapped from natives: attribute
+            # wrappers carry no minted parent. The adapter answers
+            # the owner element instead.
+            owner_native = adapter.attribute_element(wrapper.native)
+            owner = owner_native && ::Moxml::Node.wrap(owner_native, wrapper.context)
+          end
+          return nil unless owner.is_a?(::Moxml::Element)
+
+          owner_path = node_path(owner, source)
+          return nil unless owner_path
+
+          idx = owner.attributes.index { |a| a == wrapper }
+          return nil unless idx
+
+          owner_path + [:attribute, idx]
+        when *BUILDABLE_TYPES
+          node_path(wrapper, source)
+        end
+      end
+
+      def self.node_path(node, source)
+        parts = []
+        cur = node
+        loop do
+          if !source.is_a?(::Moxml::Document) && cur.equal?(source)
+            parts.unshift(0)
+            return parts
+          end
+
+          parent = cur.parent
+          return nil unless parent
+
+          idx = parent.children.select { |c| buildable?(c) }.index { |c| c == cur }
+          return nil unless idx
+
+          parts.unshift(idx)
+          return parts if source.is_a?(::Moxml::Document) && parent.is_a?(::Moxml::Document)
+
+          cur = parent
+        end
+      end
+
       # Build from a Moxml::Document. Matches canon's Nokogiri path:
       # the root element is added first, then all other document-level
       # children (PIs, comments) in document order.
@@ -33,45 +105,64 @@ module Moxml
         root = Nodes::RootNode.new
 
         if document.root
-          root.add_child(build_element_node(document.root))
-          # Iterate ALL document children — not just the root element.
-          # This captures PIs and comments that appear outside the
-          # document element, which are part of the canonical form.
+          # Document-level children (PIs and comments outside the
+          # document element) are part of the canonical form and must
+          # keep document order — a leading PI canonicalizes before the
+          # root element (spec §2.1; the native engines emit it there
+          # too). The document element is the first element child: some
+          # adapters mint fresh wrappers per children call, so wrapper
+          # identity cannot locate it.
+          seen_root = false
+          idx = 0
           document.children.each do |child|
-            next if child.equal?(document.root)
-            next if child.is_a?(::Moxml::Element)
+            if child.is_a?(::Moxml::Element)
+              next if seen_root
+
+              seen_root = true
+            end
 
-            built = build_node(child)
-            root.add_child(built) if built
+            built = build_node(child, [idx])
+            next unless built
+
+            root.add_child(built)
+            idx += 1
           end
+          root.add_child(build_element_node(document.root, [idx])) unless seen_root
         end
 
         root
       end
 
-      def self.build_node(moxml_node)
+      def self.build_node(moxml_node, path)
         case moxml_node
-        when ::Moxml::Element then build_element_node(moxml_node)
-        when ::Moxml::Text then build_text_node(moxml_node)
-        when ::Moxml::Comment then build_comment_node(moxml_node)
-        when ::Moxml::ProcessingInstruction then build_pi_node(moxml_node)
+        when ::Moxml::Element then build_element_node(moxml_node, path)
+        # CDATA sections are character data to canonicalization: their
+        # content is emitted as escaped text (spec §3.1 "text nodes").
+        when ::Moxml::Text, ::Moxml::Cdata then build_text_node(moxml_node, path)
+        when ::Moxml::Comment then build_comment_node(moxml_node, path)
+        when ::Moxml::ProcessingInstruction then build_pi_node(moxml_node, path)
         end
       end
 
-      def self.build_element_node(moxml_element)
+      def self.build_element_node(moxml_element, path)
         ns = moxml_element.namespace
         element = Nodes::ElementNode.new(
           name: moxml_element.name,
           namespace_uri: ns&.uri,
           prefix: ns&.prefix,
         )
+        source_map[path] = element
 
         build_namespace_nodes(moxml_element, element)
-        build_attribute_nodes(moxml_element, element)
+        build_attribute_nodes(moxml_element, element, path)
 
+        idx = 0
         moxml_element.children.each do |child|
-          built = build_node(child)
-          element.add_child(built) if built
+          built = build_node(child, path + [idx])
+          next unless built
+
+          element.add_child(built)
+          idx += 1
         end
 
         element
@@ -91,33 +182,48 @@ module Moxml
         )
       end
 
-      def self.build_attribute_nodes(moxml_element, element)
-        moxml_element.attributes.each do |attr|
+      def self.build_attribute_nodes(moxml_element, element, path)
+        moxml_element.attributes.each_with_index do |attr, idx|
           ns = attr.namespace
-          element.add_attribute(
-            Nodes::AttributeNode.new(
-              name: attr.name,
-              value: attr.value,
-              namespace_uri: ns&.uri,
-              prefix: ns&.prefix,
-            ),
+          # The xml prefix is reserved: any attribute bound to the XML
+          # namespace URI renders (and sorts) as prefix "xml" regardless
+          # of how the adapter reports it (spec §2.3 attribute-axis key).
+          prefix = ns&.prefix
+          uri = ns&.uri
+          if prefix == "xml" || uri == XML_URI
+            prefix = "xml"
+            uri = XML_URI
+          end
+          node = Nodes::AttributeNode.new(
+            name: attr.name,
+            value: attr.value,
+            namespace_uri: uri,
+            prefix: prefix,
           )
+          source_map[path + [:attribute, idx]] = node
+          element.add_attribute(node)
         end
       end
 
-      def self.build_text_node(moxml_text)
-        Nodes::TextNode.new(value: moxml_text.content)
+      def self.build_text_node(moxml_text, path)
+        node = Nodes::TextNode.new(value: moxml_text.content)
+        source_map[path] = node
+        node
       end
 
-      def self.build_comment_node(moxml_comment)
-        Nodes::CommentNode.new(value: moxml_comment.content)
+      def self.build_comment_node(moxml_comment, path)
+        node = Nodes::CommentNode.new(value: moxml_comment.content)
+        source_map[path] = node
+        node
       end
 
-      def self.build_pi_node(moxml_pi)
-        Nodes::ProcessingInstructionNode.new(
+      def self.build_pi_node(moxml_pi, path)
+        node = Nodes::ProcessingInstructionNode.new(
           target: moxml_pi.target || moxml_pi.name,
           data: moxml_pi.content || "",
         )
+        source_map[path] = node
+        node
       end
 
       def self.mark_all(node, value)
@@ -125,21 +231,52 @@ module Moxml
         node.children.each { |child| mark_all(child, value) }
       end
 
-      def self.mark_subset(root_node, matched)
-        matched.each { |node| mark_node_and_descendants(node) }
-        root_node.in_node_set = true
+      # Mark an XPath-selected subset: reset the whole model, then
+      # flag each matched node by position path. Node-set semantics
+      # follow the enveloped-signature interop (libxml2/xmlsec): an
+      # included element renders with its namespaces, attributes and
+      # DIRECT character data, but child ELEMENTS render only if
+      # matched too — an unmatched Signature subtree stays out even
+      # though its ancestors are matched.
+      def self.mark_subset_paths(root_node, paths)
+        mark_all(root_node, false)
+        paths.each do |path|
+          node = lookup_path(root_node, path)
+          next unless node
+
+          if node.is_a?(Nodes::ElementNode)
+            node.in_node_set = true
+            node.namespace_nodes.each { |ns| ns.in_node_set = true }
+            node.attribute_nodes.each { |attr| attr.in_node_set = true }
+            node.children.each do |child|
+              child.in_node_set = true unless child.is_a?(Nodes::ElementNode)
+            end
+          else
+            node.in_node_set = true
+          end
+        end
       end
 
-      def self.mark_node_and_descendants(node)
-        node.in_node_set = true
-        node.children.each { |child| mark_node_and_descendants(child) }
+      def self.lookup_path(root_node, path)
+        cur = root_node
+        i = 0
+        while i < path.length && path[i].is_a?(Integer)
+          cur = cur.children[path[i]]
+          return nil unless cur
+
+          i += 1
+        end
+        return cur if i >= path.length
+        return nil unless path[i] == :attribute
+
+        cur.attribute_nodes[path[i + 1]]
       end
 
       private_class_method :build_from_document, :build_node,
                            :build_element_node, :build_namespace_nodes,
                            :build_attribute_nodes, :build_text_node,
                            :build_comment_node, :build_pi_node,
-                           :mark_node_and_descendants
+                           :mark_all, :lookup_path
     end
   end
 end

data/lib/moxml/c14n.rb

@@ -39,7 +39,7 @@ module Moxml
     #   :exclusive10  Exclusive C14N 1.0 (W3C REC-xml-exc-c14n-20020718)
     def self.canonicalize(node_or_xml, with_comments: false,
                           algorithm: :inclusive10, inclusive_namespaces: [])
-      if (native = native_inclusive10(node_or_xml, with_comments,
+      if (native = native_inclusive10(node_or_xml, algorithm, with_comments,
                                       inclusive_namespaces))
         return native
       end
@@ -52,13 +52,15 @@ module Moxml
     end
 
     # The leptris engine canonicalizes in C — 23x the Ruby reference.
-    # Delegated only for the exact default shape (Inclusive 1.0, no
-    # comments, no InclusiveNamespace prefix list) on wrappers whose
-    # adapter passed the NATIVE_C14N_BYTE_SAFE load probe; every
+    # Delegated only for the exact default shape (Inclusive 1.0
+    # algorithm, no comments, no InclusiveNamespace prefix list) on
+    # wrappers whose adapter passed the byte-safety probe; every
     # other combination keeps the Ruby engine (node-set subsets,
     # xml:base fixup, exclusive, 1.1 stay on the ported
     # implementation regardless).
-    def self.native_inclusive10(node_or_xml, with_comments, inclusive_namespaces)
+    def self.native_inclusive10(node_or_xml, algorithm, with_comments,
+                                inclusive_namespaces)
+      return nil unless algorithm.nil? || algorithm == :inclusive10
       return nil if with_comments || !inclusive_namespaces.empty?
       return nil unless algorithm_shape_inclusive10?(node_or_xml)
 
@@ -73,6 +75,23 @@ module Moxml
       Inclusive10.new.canonicalize(node_or_xml, with_comments: with_comments)
     end
 
+    # Canonicalize an XPath-selected subset of the document (spec §3).
+    # The node-set is whatever the expression matches (elements,
+    # attributes, text): matched elements render with their
+    # namespaces, attributes and descendants; matched attributes
+    # render on their owner element alone. Enveloped-signature flows
+    # use this to digest the document minus the Signature element
+    # without deep-copying.
+    def self.canonicalize_subset(node_or_xml, xpath, with_comments: false)
+      source = node_or_xml.is_a?(String) ? ::Moxml.parse(node_or_xml) : node_or_xml
+      root = DataModel.from_node(source)
+      adapter = source.context.config.adapter
+      matched = source.xpath(xpath).to_a
+      paths = matched.filter_map { |wrapper| DataModel.path_key_for(wrapper, source, adapter) }
+      DataModel.mark_subset_paths(root, paths)
+      Processor.new(with_comments: with_comments).process(root)
+    end
+
     def self.canonicalize_inclusive11(node_or_xml, with_comments: false)
       Inclusive11.new.canonicalize(node_or_xml, with_comments: with_comments)
     end

data/lib/moxml/version.rb

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

data/spec/moxml/c14n/adapter_delegation_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+CORPUS = {
+  "cdata content becomes escaped text" => [
+    "<doc><![CDATA[a < b]]>tail</doc>",
+    "<doc>a &lt; btail</doc>",
+  ],
+  "prefixed and unprefixed attributes" => [
+    %(<doc xmlns:p="urn:p"><e p:x="1" y="2"/></doc>),
+    %(<doc xmlns:p="urn:p"><e y="2" p:x="1"></e></doc>),
+  ],
+  "reserved xml:* attributes keep the xml prefix" => [
+    %(<doc xml:base="http://a/b/" xml:lang="en" xml:space="preserve"><e xml:id="i1"/></doc>),
+    %(<doc xml:base="http://a/b/" xml:lang="en" xml:space="preserve"><e xml:id="i1"></e></doc>),
+  ],
+  "default namespace transitions" => [
+    %(<doc xmlns="urn:a"><e xmlns=""/><e xmlns="urn:a"/></doc>),
+    %(<doc xmlns="urn:a"><e xmlns=""></e><e></e></doc>),
+  ],
+  "namespace redeclaration" => [
+    %(<doc xmlns:m="urn:m"><m:e xmlns:m="urn:m2"/></doc>),
+    %(<doc xmlns:m="urn:m"><m:e xmlns:m="urn:m2"></m:e></doc>),
+  ],
+  "prefixed namespace ordering" => [
+    %(<r xmlns:z="urn:z" xmlns:a="urn:a" b="2" a="1"/>),
+    %(<r xmlns:a="urn:a" xmlns:z="urn:z" a="1" b="2"></r>),
+  ],
+  "entities stay escaped" => [
+    "<doc>a &amp; b &lt; c</doc>",
+    "<doc>a &amp; b &lt; c</doc>",
+  ],
+}.freeze
+
+RSpec.describe "Moxml::C14n cross-adapter canonicalization" do
+  # Every installed adapter must answer identical canonical bytes: the
+  # Ruby reference path (Inclusive10) is shared, but attribute/namespace
+  # reporting differs per adapter, and two adapters additionally
+  # delegate the default shape to a native engine (leptris in C,
+  # nokogiri via libxml2).
+  describe "byte-identical canonical form across adapters" do
+    Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+      context "with the #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+
+        CORPUS.each do |label, (input, expected)|
+          it "canonicalizes #{label}" do
+            root = ctx.parse(input).root
+            expect(Moxml::C14n.canonicalize_inclusive10(root)).to eq(expected)
+            expect(Moxml::C14n.canonicalize(root)).to eq(expected)
+          end
+        end
+      end
+    end
+  end
+
+  describe "document-level nodes keep document order" do
+    # oga surfaces the XML declaration as a <?xml?> PI and keeps the
+    # separator space in PI content; ox/headed_ox drop PI content on
+    # parse. Both are pre-existing parse-layer divergences, out of
+    # scope here.
+    let(:adapters) { Moxml::Adapter::AVAILABLE_ADAPTERS - %i[oga ox headed_ox] }
+
+    it "canonicalizes a leading PI before the root element" do
+      adapters.each do |adapter_name|
+        doc = Moxml.new(adapter_name)
+          .parse(%(<?xml version="1.0"?><?render mode="x"?><doc><e/></doc>))
+        expect(Moxml::C14n.canonicalize(doc))
+          .to eq(%(<?render mode="x"?>\n<doc><e></e></doc>))
+      end
+    end
+  end
+
+  describe "native delegation" do
+    adapters_with_native = %i[leptris nokogiri].select do |name|
+      Moxml::Adapter::AVAILABLE_ADAPTERS.include?(name)
+    end
+
+    adapters_with_native.each do |adapter_name|
+      context "with the #{adapter_name} adapter" do
+        let(:adapter_class) do
+          Moxml::Adapter.const_get(adapter_name.to_s.split("_").map(&:capitalize).join)
+        end
+
+        it "passes the byte-safety probe" do
+          expect(adapter_class.native_c14n_byte_safe?).to be(true)
+        end
+
+        it "engages the native path for the default shape" do
+          doc = Moxml.new(adapter_name)
+            .parse(%(<doc xmlns="urn:d" a="1"><e>t</e></doc>))
+          native = Moxml::C14n.native_inclusive10(doc.root, :inclusive10, false, [])
+          expect(native).to be_a(String)
+        end
+
+        it "keeps exclusive on the Ruby engine" do
+          doc = Moxml.new(adapter_name)
+            .parse(%(<root xmlns:foo='urn:foo'><foo:a/></root>))
+          expect(Moxml::C14n.canonicalize(doc.root, algorithm: :exclusive10))
+            .to eq(Moxml::C14n.canonicalize_exclusive(doc.root))
+        end
+
+        it "keeps inclusive 1.1 on the Ruby engine" do
+          doc = Moxml.new(adapter_name).parse(%(<root a="1"/>))
+          expect(Moxml::C14n.canonicalize(doc.root, algorithm: :inclusive11))
+            .to eq(Moxml::C14n.canonicalize_inclusive11(doc.root))
+        end
+
+        it "keeps with_comments on the Ruby engine" do
+          doc = Moxml.new(adapter_name).parse(%(<doc><!-- c --><e/></doc>))
+          expect(Moxml::C14n.canonicalize(doc.root, with_comments: true))
+            .to eq(Moxml::C14n.canonicalize_inclusive10(doc.root,
+                                                        with_comments: true))
+        end
+      end
+    end
+  end
+end

data/spec/moxml/c14n/subset_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+SIG = "<Signature xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><SignedInfo>" \
+      "<m xmlns=\"urn:m\">x</m></SignedInfo><Object>o</Object></Signature>"
+ENVELOPED_DOC = %(<env><payload id="p1">data &amp; more</payload>#{SIG}<tail/></env>).freeze
+ENVELOPED_EXCLUDE = '//*[not(ancestor-or-self::*[local-name()="Signature"])]'
+SIGNATURE_XPATH = '//*[local-name()="Signature"]'
+
+CORPUS = [
+  ["apex attraction + text",
+   %(<a xml:lang="en"><b id="1"><c>t</c></b><d/></a>), "//b",
+   %(<b id="1" xml:lang="en"></b>)],
+  ["explicit descendant inclusion",
+   %(<a xml:lang="en"><b id="1"><c>t</c></b><d/></a>), "//b | //c",
+   %(<b id="1" xml:lang="en"><c>t</c></b>)],
+  ["direct character data of a matched element",
+   %(<a><b>t</b><d/></a>), "//b", "<b>t</b>"],
+  ["unmatched child element excluded",
+   %(<a><b><c>t</c></b></a>), "//b", "<b></b>"],
+  ["excluded sibling subtree",
+   %(<a><b><c/></b><d/></a>), "//*[not(self::d)]",
+   %(<a><b><c></c></b></a>)],
+  ["attribute-only selection renders nothing",
+   %(<a><b id="1"/></a>), "//@id", ""],
+  # C14N renders a text-only node-set without its omitted parents.
+  ["text selection", %(<a><b>t1</b><b>t2</b></a>), "//b/text()", "t1t2"],
+  ["empty result", %(<a><b/></a>), "//missing", ""],
+].freeze
+
+COMMENTS_CASE = [
+  "with_comments keeps matched comments only",
+  %(<a><!-- keep --><b><!-- in --><c/></b></a>), "//b",
+  %(<b><!-- in --></b>)
+].freeze
+
+COMMENTS_PADDING_LOSS = %i[ox headed_ox].freeze
+
+RSpec.describe "Moxml::C14n subset canonicalization" do
+  # Node-set semantics follow the enveloped-signature interop
+  # (libxml2/xmlsec): a matched element renders with its namespaces,
+  # attributes and non-element children; child ELEMENTS need their
+  # own match, so an excluded subtree stays excluded under matched
+  # ancestors. Inheritable xml:* attributes of omitted ancestors and
+  # apex namespace attraction still render (spec §2.3/§2.4/§3).
+  describe "byte-identical subset canonical form across adapters" do
+    Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+      context "with the #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+
+        CORPUS.each do |label, xml, xpath, expected|
+          next if label == "text selection" && adapter_name == :rexml
+
+          # rexml's adapter xpath does not return text nodes for
+          # text() node tests (pre-existing capability gap).
+
+          it "canonicalizes #{label}" do
+            doc = ctx.parse(xml)
+            expect(Moxml::C14n.canonicalize_subset(doc, xpath)).to eq(expected)
+          end
+        end
+
+        # ox/headed_ox strip comment content padding at the parse
+        # layer (pre-existing, same family as their PI content loss).
+        unless COMMENTS_PADDING_LOSS.include?(adapter_name)
+          it COMMENTS_CASE[0] do
+            doc = ctx.parse(COMMENTS_CASE[1])
+            expect(Moxml::C14n.canonicalize_subset(doc, COMMENTS_CASE[2],
+                                                   with_comments: true))
+              .to eq(COMMENTS_CASE[3])
+          end
+        end
+      end
+    end
+  end
+
+  describe "enveloped-signature oracle" do
+    it "equals canonicalizing the DOM with the Signature removed" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        subset = Moxml::C14n.canonicalize_subset(
+          Moxml.new(adapter_name).parse(ENVELOPED_DOC), ENVELOPED_EXCLUDE
+        )
+
+        doc = Moxml.new(adapter_name).parse(ENVELOPED_DOC)
+        doc.root.xpath(SIGNATURE_XPATH).to_a[0].remove
+        removed = Moxml::C14n.canonicalize(doc.root)
+
+        expect(subset).to eq(removed)
+      end
+    end
+  end
+
+  describe "input forms" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "accepts an XML string" do
+      expect(Moxml::C14n.canonicalize_subset(%(<a><b>t</b></a>), "//b"))
+        .to eq("<b>t</b>")
+    end
+
+    it "accepts an element source, paths relative to it" do
+      doc = ctx.parse(%(<a><b><c>t</c></b></a>))
+      b = doc.root.xpath("//b").to_a[0]
+      expect(Moxml::C14n.canonicalize_subset(b, ".//c")).to eq("<c>t</c>")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.91
+  version: 0.5.93
 platform: ruby
 authors:
 - Ribose Inc.
@@ -457,11 +457,13 @@ files:
 - spec/moxml/attribute_resolver_spec.rb
 - spec/moxml/attribute_spec.rb
 - spec/moxml/builder_spec.rb
+- spec/moxml/c14n/adapter_delegation_spec.rb
 - spec/moxml/c14n/api_spec.rb
 - spec/moxml/c14n/c14n_spec.rb
 - spec/moxml/c14n/comments_pis_spec.rb
 - spec/moxml/c14n/inclusive10_spec.rb
 - spec/moxml/c14n/namespace_edge_cases_spec.rb
+- spec/moxml/c14n/subset_spec.rb
 - spec/moxml/c14n/xml_attributes_spec.rb
 - spec/moxml/cdata_spec.rb
 - spec/moxml/comment_spec.rb