moxml 0.1.25 → 0.1.26

data/lib/moxml/c14n/data_model.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Builds a C14N data model from a Moxml::Node tree (or XML string).
+    #
+    # The data model exists because canonicalization needs:
+    #   - sorted namespace and attribute axes (spec §2.3, §2.4)
+    #   - in_node_set flags for subset canonicalization (spec §3)
+    #   - xml:* inheritable attribute resolution
+    #
+    # Ported from canon (lutaml/canon) — adapted to build directly from
+    # Moxml::Node rather than via a separate Nokogiri pass. Matches
+    # canon's document-level node iteration (PIs and comments outside
+    # the document root element).
+    class DataModel
+      def self.from_xml(xml_string)
+        from_node(::Moxml.parse(xml_string))
+      end
+
+      def self.from_node(moxml_node)
+        return build_from_document(moxml_node) if moxml_node.is_a?(::Moxml::Document)
+
+        root = Nodes::RootNode.new
+        root.add_child(build_node(moxml_node))
+        root
+      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.
+      def self.build_from_document(document)
+        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.children.each do |child|
+            next if child.equal?(document.root)
+            next if child.is_a?(::Moxml::Element)
+
+            built = build_node(child)
+            root.add_child(built) if built
+          end
+        end
+
+        root
+      end
+
+      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)
+        when ::Moxml::Comment then build_comment_node(moxml_node)
+        when ::Moxml::ProcessingInstruction then build_pi_node(moxml_node)
+        end
+      end
+
+      def self.build_element_node(moxml_element)
+        ns = moxml_element.namespace
+        element = Nodes::ElementNode.new(
+          name: moxml_element.name,
+          namespace_uri: ns&.uri,
+          prefix: ns&.prefix,
+        )
+
+        build_namespace_nodes(moxml_element, element)
+        build_attribute_nodes(moxml_element, element)
+
+        moxml_element.children.each do |child|
+          built = build_node(child)
+          element.add_child(built) if built
+        end
+
+        element
+      end
+
+      def self.build_namespace_nodes(moxml_element, element)
+        moxml_element.in_scope_namespaces.each do |ns|
+          element.add_namespace(
+            Nodes::NamespaceNode.new(prefix: ns.prefix || "", uri: ns.uri),
+          )
+        end
+
+        return if element.namespace_nodes.any? { |n| n.prefix == "xml" }
+
+        element.add_namespace(
+          Nodes::NamespaceNode.new(prefix: "xml", uri: XML_URI),
+        )
+      end
+
+      def self.build_attribute_nodes(moxml_element, element)
+        moxml_element.attributes.each do |attr|
+          ns = attr.namespace
+          element.add_attribute(
+            Nodes::AttributeNode.new(
+              name: attr.name,
+              value: attr.value,
+              namespace_uri: ns&.uri,
+              prefix: ns&.prefix,
+            ),
+          )
+        end
+      end
+
+      def self.build_text_node(moxml_text)
+        Nodes::TextNode.new(value: moxml_text.content)
+      end
+
+      def self.build_comment_node(moxml_comment)
+        Nodes::CommentNode.new(value: moxml_comment.content)
+      end
+
+      def self.build_pi_node(moxml_pi)
+        Nodes::ProcessingInstructionNode.new(
+          target: moxml_pi.target || moxml_pi.name,
+          data: moxml_pi.content || "",
+        )
+      end
+
+      def self.mark_all(node, value)
+        node.in_node_set = value
+        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
+      end
+
+      def self.mark_node_and_descendants(node)
+        node.in_node_set = true
+        node.children.each { |child| mark_node_and_descendants(child) }
+      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
+    end
+  end
+end

data/lib/moxml/c14n/exclusive.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Exclusive XML Canonicalization 1.0 (https://www.w3.org/TR/xml-exc-c14n/)
+    #
+    # Renders only the namespaces visibly utilized by each element's
+    # qualified name and attributes (plus any in the inclusive prefix
+    # list), as opposed to inclusive C14N which renders every in-scope
+    # namespace on every element.
+    #
+    # Output is UTF-8 octets with no BOM.
+    class Exclusive
+      # `node`: a Moxml::Node — element, document, text, comment, or PI.
+      # `with_comments:`: include comment nodes in output.
+      # `inclusive_namespaces`: list of prefixes to always include even if
+      #   not visibly utilized (InclusiveNamespacesPrefixList parameter).
+      def canonicalize(node, with_comments: false, inclusive_namespaces: [])
+        writer = Writer.new
+        context = NamespaceContext.new
+        render(node, writer, context, with_comments, inclusive_namespaces)
+        writer.output
+      end
+
+      private
+
+      def render(node, writer, context, with_comments, inclusive)
+        case node_type(node)
+        when :document
+          node.children.each { |c| render(c, writer, context, with_comments, inclusive) }
+        when :element
+          render_element(node, writer, context, with_comments, inclusive)
+        when :text, :cdata
+          writer.text(node.content)
+        when :comment
+          writer.comment(node.content) if with_comments
+        when :processing_instruction
+          target, content = pi_target_and_content(node)
+          writer.processing_instruction(target, content)
+        end
+      end
+
+      def render_element(element, writer, context, with_comments, inclusive)
+        declared = bindings_declared_on(element)
+        in_scope = bindings_in_scope_on(element)
+        context.push(in_scope)
+
+        prefix = element_namespace_prefix(element)
+        local = element_name(element)
+
+        visible_prefixes = visibly_used_prefixes(element, prefix)
+        inclusive.each { |p| visible_prefixes.add(p) }
+        visible_prefixes.add("xml") if visibly_uses_xml(element)
+
+        namespaces_to_render = visible_prefixes.map do |p|
+          [p, context.uri_for(p)]
+        end.reject { |(_, uri)| uri.nil? }
+
+        writer.open_rendered_frame(element)
+        writer.open_tag(prefix, local)
+        render_namespaces(writer, element, namespaces_to_render)
+        render_attributes(writer, element)
+        writer.close_tag_open
+
+        # Switch context from in-scope (apex lookup) to declared-only so
+        # children build their own in-scope view by pushing their declared
+        # set on top of the parent's declared set.
+        context.pop
+        context.push(declared)
+
+        element.children.each { |c| render(c, writer, context, with_comments, inclusive) }
+
+        writer.close_tag(prefix, local)
+        writer.close_rendered_frame
+        context.pop
+      end
+
+      def render_namespaces(writer, element, namespaces)
+        already_rendered = writer.rendered_namespaces_for(element)
+        sorted = namespaces
+          .reject { |(prefix, _)| already_rendered.include?(prefix) }
+          .sort_by { |(prefix, _)| prefix.to_s }
+        sorted.each do |(prefix, uri)|
+          writer.namespace(prefix, uri)
+          writer.mark_rendered(element, prefix, uri)
+        end
+      end
+
+      def render_attributes(writer, element)
+        attrs = collect_attributes(element)
+        sorted = attrs.sort_by { |a| [a[:ns_uri] || "", a[:local]] }
+        sorted.each { |a| writer.attribute(a[:expanded], a[:value]) }
+      end
+
+      def collect_attributes(element)
+        attrs = []
+        element.attributes.each do |attr|
+          ns = attr.namespace
+          attrs << {
+            ns_uri: ns&.uri,
+            ns_prefix: ns&.prefix,
+            local: attr.name,
+            expanded: attr_expanded_name(attr),
+            value: attr.value,
+          }
+        end
+        attrs
+      end
+
+      def attr_expanded_name(attr)
+        ns = attr.namespace
+        prefix = ns&.prefix
+        if prefix && !prefix.empty?
+          "#{prefix}:#{attr.name}"
+        else
+          attr.name
+        end
+      end
+
+      def visibly_used_prefixes(element, element_prefix)
+        set = Set.new
+        # The element's qualified name visibly uses its own namespace.
+        # Default namespace (prefix == "" or nil) is included so it gets
+        # rendered on the apex element when the apex uses default ns.
+        if element.namespace_uri
+          set.add(element_prefix || "")
+        end
+        element.attributes.each do |attr|
+          ns = attr.namespace
+          prefix = ns&.prefix
+          set.add(prefix || "") if ns&.uri
+        end
+        set
+      end
+
+      def visibly_uses_xml(element)
+        element.attributes.any? { |a| a.namespace&.prefix == "xml" }
+      end
+
+      def bindings_declared_on(element)
+        bindings = {}
+        element.namespaces.each do |ns|
+          prefix = ns.prefix
+          prefix = "" if prefix.nil? || prefix == "xmlns"
+          bindings[prefix] = ns.uri
+        end
+        bindings
+      end
+
+      # In-scope namespaces (declared + inherited from ancestors).
+      # Used at the apex to find URIs for visibly-used prefixes whose
+      # declarations live on ancestors.
+      def bindings_in_scope_on(element)
+        bindings = {}
+        element.in_scope_namespaces.each do |ns|
+          prefix = ns.prefix
+          prefix = "" if prefix.nil? || prefix == "xmlns"
+          bindings[prefix] = ns.uri
+        end
+        bindings
+      end
+
+      def element_namespace_prefix(element)
+        ns = element.namespace
+        ns&.prefix
+      end
+
+      def element_name(element)
+        element.name
+      end
+
+      def pi_target_and_content(node)
+        [node.name, node.text]
+      end
+
+      def node_type(node)
+        return :document if node.is_a?(::Moxml::Document)
+        return :element if node.is_a?(::Moxml::Element)
+        return :text if node.is_a?(::Moxml::Text)
+        return :cdata if node.is_a?(::Moxml::Cdata)
+        return :comment if node.is_a?(::Moxml::Comment)
+        return :processing_instruction if node.is_a?(::Moxml::ProcessingInstruction)
+
+        :unknown
+      end
+    end
+  end
+end

data/lib/moxml/c14n/inclusive_10.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Inclusive Canonical XML 1.0 (https://www.w3.org/TR/xml-c14n/)
+    #
+    # Unlike exclusive C14N, inclusive C14N "attracts" ancestor context:
+    # at the apex element, ALL in-scope namespaces are rendered, including
+    # those inherited from ancestors outside the canonicalization subset.
+    #
+    # xml:* inheritable attributes (xml:lang, xml:space) are also inherited
+    # from the nearest ancestor in which they are declared.
+    #
+    # Implementation: delegates to the canon-derived Processor pipeline
+    # (DataModel + NamespaceHandler + AttributeHandler + XmlBaseHandler).
+    class Inclusive10
+      # rubocop:disable Lint/UnusedMethodArgument -- signature must match Exclusive
+      def canonicalize(node_or_xml, with_comments: false, inclusive_namespaces: [])
+        # rubocop:enable Lint/UnusedMethodArgument
+        root = coerce_to_data_model(node_or_xml)
+        Processor.new(with_comments: with_comments).process(root)
+      end
+
+      private
+
+      def coerce_to_data_model(node_or_xml)
+        return node_or_xml if node_or_xml.is_a?(Nodes::RootNode)
+
+        case node_or_xml
+        when ::Moxml::Document, ::Moxml::Node
+          DataModel.from_node(node_or_xml)
+        when String
+          DataModel.from_xml(node_or_xml)
+        else
+          raise ArgumentError,
+                "Inclusive10#canonicalize expects a Moxml::Node, " \
+                "Moxml::Document, or XML String; got #{node_or_xml.class}"
+        end
+      end
+    end
+  end
+end

data/lib/moxml/c14n/inclusive_11.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Canonical XML 1.1 (https://www.w3.org/TR/xml-c14n11/).
+    #
+    # In this implementation, Inclusive11 is a thin alias of Inclusive10.
+    # Both delegate to the canon-derived Processor. The W3C 1.1 additions
+    # (notations, entity references in DTD internal subset, XML 1.1 line
+    # ending) are rarely encountered in modern XML signature practice.
+    class Inclusive11
+      def canonicalize(node_or_xml, with_comments: false, inclusive_namespaces: [])
+        Inclusive10.new.canonicalize(
+          node_or_xml,
+          with_comments: with_comments,
+          inclusive_namespaces: inclusive_namespaces,
+        )
+      end
+    end
+  end
+end

data/lib/moxml/c14n/namespace_context.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Tracks in-scope namespace URIs along the ancestor chain of the
+    # element currently being canonicalized. The canonicalizer pushes
+    # when entering an element and pops when leaving.
+    #
+    # `xml` prefix is always bound to the XML namespace per XML 1.0 spec.
+    class NamespaceContext
+      DEFAULT_XML_BINDING = { "xml" => C14n::XML_URI }.freeze
+
+      attr_reader :bindings
+
+      def initialize(initial = {})
+        @stack = []
+        @bindings = DEFAULT_XML_BINDING.dup
+        merge(initial)
+      end
+
+      def push(bindings_to_apply)
+        applied = {}
+        bindings_to_apply.each do |prefix, uri|
+          prev = @bindings[prefix]
+          applied[prefix] = prev
+          @bindings[prefix] = uri
+        end
+        @stack.push(applied)
+        self
+      end
+
+      def pop
+        applied = @stack.pop
+        applied.each do |prefix, prev|
+          if prev.nil?
+            @bindings.delete(prefix)
+            @bindings[prefix] = C14n::XML_URI if prefix == "xml"
+          else
+            @bindings[prefix] = prev
+          end
+        end
+        self
+      end
+
+      def uri_for(prefix)
+        @bindings[prefix]
+      end
+
+      def binding_for(prefix)
+        @bindings[prefix]
+      end
+
+      def include?(prefix)
+        @bindings.key?(prefix)
+      end
+
+      def to_h
+        @bindings.dup
+      end
+
+      private
+
+      def merge(hash)
+        hash.each { |prefix, uri| @bindings[prefix] = uri }
+      end
+    end
+  end
+end

data/lib/moxml/c14n/namespace_handler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Namespace axis handler for inclusive C14N.
+    # Implements W3C C14N 1.0 §2.3 / 1.1 §2.3 namespace rendering rules
+    # for the document subset (full and partial).
+    class NamespaceHandler
+      attr_reader :encoder
+
+      def initialize(encoder)
+        @encoder = encoder
+      end
+
+      def process_namespaces(element, output, parent_element = nil)
+        return unless element.in_node_set?
+
+        namespaces = element.sorted_namespace_nodes.select(&:in_node_set?)
+
+        if should_emit_empty_default_namespace?(element, namespaces, parent_element)
+          output << ' xmlns=""'
+        end
+
+        namespaces.each do |ns|
+          next if should_skip_namespace?(ns, parent_element)
+
+          output << " "
+          output << (ns.default_namespace? ? "xmlns" : "xmlns:#{ns.prefix}")
+          output << '="'
+          output << encoder.encode_attribute(ns.uri)
+          output << '"'
+        end
+      end
+
+      private
+
+      # Emit xmlns="" if the element's nearest in-set ancestor had a non-empty
+      # default namespace and this element does not.
+      def should_emit_empty_default_namespace?(element, namespaces, parent_element)
+        return false unless element.in_node_set?
+        return false if namespaces.first&.default_namespace?
+        return false unless parent_element
+
+        parent_default_ns = parent_element.namespace_nodes.find do |ns|
+          ns.default_namespace? && ns.in_node_set?
+        end
+
+        parent_default_ns && !parent_default_ns.uri.empty?
+      end
+
+      def should_skip_namespace?(namespace, parent_element)
+        # The xml namespace is implicit, never rendered.
+        return true if namespace.xml_namespace?
+        # Skip namespaces already declared (with same URI) by an ancestor.
+        return true if namespace_declared_by_ancestor?(namespace, parent_element)
+
+        false
+      end
+
+      def namespace_declared_by_ancestor?(namespace, parent_element)
+        return false unless parent_element
+
+        parent_ns = parent_element.namespace_nodes.find do |candidate|
+          candidate.prefix == namespace.prefix && candidate.in_node_set?
+        end
+
+        parent_ns && parent_ns.uri == namespace.uri
+      end
+    end
+  end
+end

data/lib/moxml/c14n/node.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    # Base class for all C14N data-model nodes.
+    # Ported from canon ( lutaml/canon ) — keeps the mature node-set
+    # semantics needed for subset canonicalization (spec §3).
+    class Node
+      attr_reader :parent, :children
+
+      def initialize
+        @parent = nil
+        @children = []
+        @in_node_set = true
+      end
+
+      def add_child(child)
+        child.parent = self
+        @children << child
+      end
+
+      def in_node_set?
+        @in_node_set
+      end
+
+      def in_node_set=(value)
+        @in_node_set = value
+      end
+
+      # Return the text content of this node and all descendants.
+      # ElementNode concatenates children's text_content; other nodes
+      # (TextNode, CommentNode, etc.) return their value.
+      def text_content
+        children.map(&:text_content).join
+      end
+
+      protected
+
+      attr_writer :parent
+    end
+  end
+end

data/lib/moxml/c14n/nodes/attribute_node.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    module Nodes
+      # Attribute node.
+      class AttributeNode < Node
+        attr_reader :name, :value, :namespace_uri, :prefix
+
+        def initialize(name:, value:, namespace_uri: nil, prefix: nil)
+          super()
+          @name = name
+          @value = value
+          @namespace_uri = namespace_uri
+          @prefix = prefix
+        end
+
+        def node_type
+          :attribute
+        end
+
+        def local_name
+          name
+        end
+
+        def qname
+          prefix.nil? || prefix.empty? ? name : "#{prefix}:#{name}"
+        end
+
+        # xml:* attributes (lang, space, base, id).
+        def xml_attribute?
+          namespace_uri == Moxml::C14n::XML_URI
+        end
+
+        # xml:lang and xml:space are inheritable per C14N 1.1 §2.4.
+        def simple_inheritable?
+          xml_attribute? && %w[lang space].include?(name)
+        end
+
+        def xml_id?
+          xml_attribute? && name == "id"
+        end
+
+        def xml_base?
+          xml_attribute? && name == "base"
+        end
+      end
+    end
+  end
+end

data/lib/moxml/c14n/nodes/comment_node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    module Nodes
+      # Comment node.
+      class CommentNode < Node
+        attr_reader :value
+
+        def initialize(value:)
+          super()
+          @value = value
+        end
+
+        def name
+          "comment"
+        end
+
+        def node_type
+          :comment
+        end
+
+        def text_content
+          @value
+        end
+      end
+    end
+  end
+end