moxml 0.5.91 → 0.5.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b290a2b707e7aec576eabf853e5e8434cb070369477d5ebc41735cadf8a0582
-  data.tar.gz: 1dd022ba5bd37967027aecaee876750134fb65086d595671c42f6dbebcdc3f8e
+  metadata.gz: 4e9550ec966450192384ac9f4059a182a52107fac47420010517fe2fff7c8d1c
+  data.tar.gz: ca3e1a10e2a0669991391ce82909360a66fd17cbd98e454aff99f5d1f1bcb4d4
 SHA512:
-  metadata.gz: 1ecefd8a5388a448cc018b53b00ae11a5c91786f7641d40da11a5bcb46c957031da1a44d7b00bdb0fc086246750bb6a74af267f7cada75380ca5514a44d897b3
-  data.tar.gz: d344520c29067fb740f3372c2c2ea16791f9d9e88a7c7faea7e033943852af9a2e40e7e4404e0a7eb9dc9dd223c41d0ff68d2cdab1538f1f1d62c5347ab0fac1
+  metadata.gz: b5de2cfb1875e9947b25cabd166f2f1e2c3ec6994d9ea8376a3b42ae5afd7bfe450ae3fed1306e25748cfdedc6223cf46848c5202e1d4cf898d6df2ac04f2abd
+  data.tar.gz: 1f5922e2968fdc796df5a183bbd1d876b2c66618eef068c08005c528cf735df0b193b7143f856abe381aa2ec37224c6302359b7f188eb6c3342b680a729c0475

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
@@ -1889,7 +1918,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/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

@@ -33,17 +33,25 @@ 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
           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
           end
+          root.add_child(build_element_node(document.root)) unless seen_root
         end
 
         root
@@ -52,7 +60,9 @@ module Moxml
       def self.build_node(moxml_node)
         case moxml_node
         when ::Moxml::Element then build_element_node(moxml_node)
-        when ::Moxml::Text then build_text_node(moxml_node)
+        # 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)
         end
@@ -94,12 +104,21 @@ module Moxml
       def self.build_attribute_nodes(moxml_element, element)
         moxml_element.attributes.each do |attr|
           ns = attr.namespace
+          # 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
           element.add_attribute(
             Nodes::AttributeNode.new(
               name: attr.name,
               value: attr.value,
-              namespace_uri: ns&.uri,
-              prefix: ns&.prefix,
+              namespace_uri: uri,
+              prefix: prefix,
             ),
           )
         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)
 

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.91"
+  VERSION = "0.5.92"
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.91
+  version: 0.5.92
 platform: ruby
 authors:
 - Ribose Inc.
@@ -457,6 +457,7 @@ 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