moxml 0.1.25 → 0.2.0

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

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    module Nodes
+      # Element node in the C14N data model.
+      class ElementNode < Node
+        attr_reader :name, :namespace_uri, :prefix, :namespace_nodes,
+                    :attribute_nodes
+
+        def initialize(name:, namespace_uri: nil, prefix: nil)
+          super()
+          @name = name
+          @namespace_uri = namespace_uri
+          @prefix = prefix
+          @namespace_nodes = []
+          @attribute_nodes = []
+        end
+
+        def node_type
+          :element
+        end
+
+        def qname
+          prefix.nil? || prefix.empty? ? name : "#{prefix}:#{name}"
+        end
+
+        def add_namespace(namespace_node)
+          namespace_node.parent = self
+          @namespace_nodes << namespace_node
+        end
+
+        def add_attribute(attribute_node)
+          attribute_node.parent = self
+          @attribute_nodes << attribute_node
+        end
+
+        # Namespace nodes sorted lexicographically by local name (prefix).
+        # Per W3C C14N 1.0 §2.3 / 1.1 §2.3, default namespace sorts first.
+        def sorted_namespace_nodes
+          @namespace_nodes.sort_by { |ns| ns.local_name.to_s }
+        end
+
+        # Attribute nodes sorted by namespace URI then local name
+        # (W3C C14N 1.0 §2.4 / 1.1 §2.4).
+        def sorted_attribute_nodes
+          @attribute_nodes.sort_by do |attr|
+            [attr.namespace_uri.to_s, attr.local_name]
+          end
+        end
+
+        def text_content
+          children.map(&:text_content).join
+        end
+
+        def to_s
+          "<#{qname}>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    module Nodes
+      # Namespace node. Prefix is empty string for the default namespace.
+      class NamespaceNode < Node
+        attr_reader :prefix, :uri
+
+        def initialize(prefix:, uri:)
+          super()
+          @prefix = prefix
+          @uri = uri
+        end
+
+        def name
+          prefix.to_s
+        end
+
+        def node_type
+          :namespace
+        end
+
+        # Local name is the prefix (empty string for default namespace).
+        # Used by ElementNode#sorted_namespace_nodes for sort order.
+        def local_name
+          prefix.to_s
+        end
+
+        def default_namespace?
+          prefix.nil? || prefix.empty?
+        end
+
+        # The `xml` namespace is implicit and never rendered.
+        def xml_namespace?
+          prefix == "xml" && uri == Moxml::C14n::XML_URI
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    module Nodes
+      # Processing Instruction node.
+      class ProcessingInstructionNode < Node
+        attr_reader :target, :data
+
+        def initialize(target:, data: "")
+          super()
+          @target = target
+          @data = data
+        end
+
+        def name
+          target
+        end
+
+        def node_type
+          :processing_instruction
+        end
+
+        def text_content
+          ""
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    module Nodes
+      # Root node representing the document root.
+      class RootNode < Node
+        def name
+          "#document"
+        end
+
+        def node_type
+          :root
+        end
+
+        def children=(new_children)
+          @children = new_children
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Moxml
+  module C14n
+    module Nodes
+      # Text node. Stores the decoded value (entity refs resolved).
+      class TextNode < Node
+        attr_accessor :value
+
+        def initialize(value:)
+          super()
+          @value = value
+        end
+
+        def name
+          "#text"
+        end
+
+        def node_type
+          :text
+        end
+
+        def text_content
+          @value
+        end
+      end
+    end
+  end
+end