moxml 0.5.92 → 0.5.93

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e9550ec966450192384ac9f4059a182a52107fac47420010517fe2fff7c8d1c
-  data.tar.gz: ca3e1a10e2a0669991391ce82909360a66fd17cbd98e454aff99f5d1f1bcb4d4
+  metadata.gz: 92d24efac79874e02cbfa26e20fc8135e2a714020a727896cdf2a460fa7d0508
+  data.tar.gz: 91f18637388f6983c2c75c606e95e93f15919b3099fbdc0c8e59ebf9aca93d5e
 SHA512:
-  metadata.gz: b5de2cfb1875e9947b25cabd166f2f1e2c3ec6994d9ea8376a3b42ae5afd7bfe450ae3fed1306e25748cfdedc6223cf46848c5202e1d4cf898d6df2ac04f2abd
-  data.tar.gz: 1f5922e2968fdc796df5a183bbd1d876b2c66618eef068c08005c528cf735df0b193b7143f856abe381aa2ec37224c6302359b7f188eb6c3342b680a729c0475
+  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

@@ -1638,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)

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/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.
@@ -41,6 +113,7 @@ module Moxml
           # adapters mint fresh wrappers per children call, so wrapper
           # identity cannot locate it.
           seen_root = false
+          idx = 0
           document.children.each do |child|
             if child.is_a?(::Moxml::Element)
               next if seen_root
@@ -48,40 +121,48 @@ module Moxml
               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)) unless seen_root
+          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::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)
-        when ::Moxml::Comment then build_comment_node(moxml_node)
-        when ::Moxml::ProcessingInstruction then build_pi_node(moxml_node)
+        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
@@ -101,8 +182,8 @@ 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
           # The xml prefix is reserved: any attribute bound to the XML
           # namespace URI renders (and sorts) as prefix "xml" regardless
@@ -113,30 +194,36 @@ module Moxml
             prefix = "xml"
             uri = XML_URI
           end
-          element.add_attribute(
-            Nodes::AttributeNode.new(
-              name: attr.name,
-              value: attr.value,
-              namespace_uri: uri,
-              prefix: prefix,
-            ),
+          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)
@@ -144,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

@@ -75,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.92"
+  VERSION = "0.5.93"
 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.92
+  version: 0.5.93
 platform: ruby
 authors:
 - Ribose Inc.
@@ -463,6 +463,7 @@ files:
 - 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