canon 0.1.2 → 0.1.5

data/lib/canon/xml/line_range_mapper.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "../pretty_printer/xml"
+
+module Canon
+  module Xml
+    # Maps DOM elements to line ranges in pretty-printed XML
+    #
+    # This class builds a mapping between DOM elements and their corresponding
+    # line numbers in pretty-printed XML output. This enables line-accurate
+    # diff display that can highlight specific elements even when the XML
+    # structure is complex.
+    #
+    # == How it works
+    #
+    # 1. Pretty-prints the XML with consistent indentation
+    # 2. Traverses the DOM tree depth-first
+    # 3. For each element, finds its opening and closing tags in the pretty-printed output
+    # 4. Records the line range (start_line..end_line) for that element
+    # 5. Returns a Hash mapping element → LineRange
+    #
+    # == Usage
+    #
+    #   mapper = LineRangeMapper.new(indent: 2)
+    #   root = Canon::Xml::DataModel.from_xml(xml_string)
+    #   line_map = mapper.build_map(root, xml_string)
+    #
+    #   # Look up line range for an element
+    #   range = line_map[element]
+    #   puts "Element spans lines #{range.start_line} to #{range.end_line}"
+    #
+    # == Line Range Format
+    #
+    # Each LineRange contains:
+    # - start_line: First line of the element (0-indexed)
+    # - end_line: Last line of the element (0-indexed)
+    # - elem: Reference to the DOM element
+    #
+    class LineRangeMapper
+      # Line range for an element
+      LineRange = Struct.new(:start_line, :end_line, :elem) do
+        def contains?(line_num)
+          line_num >= start_line && line_num <= end_line
+        end
+
+        def length
+          end_line - start_line + 1
+        end
+      end
+
+      def initialize(indent: 2)
+        @indent = indent
+        @ranges = []
+      end
+
+      # Build line range map for a DOM tree
+      #
+      # @param root [Canon::Xml::Nodes::RootNode] DOM tree
+      # @param xml_string [String] Original XML (for pretty-printing)
+      # @return [Hash] Map of element => LineRange
+      def build_map(root, xml_string)
+        @ranges = []
+        @map = {}
+
+        # Pretty-print to get consistent formatting
+        pretty_xml = Canon::PrettyPrinter::Xml.new(indent: @indent).format(xml_string)
+        @lines = pretty_xml.split("\n")
+
+        # Track current line number
+        @current_line = 0
+
+        # Build map recursively
+        root.children.each do |child|
+          map_node(child)
+        end
+
+        @map
+      end
+
+      private
+
+      # Map a node to its line range
+      def map_node(node)
+        return unless node.node_type == :element
+
+        # Find opening tag line
+        opening_tag = find_opening_tag(node)
+        return unless opening_tag
+
+        start_line = opening_tag[:line]
+        @current_line = start_line
+
+        # Map children recursively
+        node.children.each do |child|
+          map_node(child)
+        end
+
+        # Find closing tag line
+        closing_tag = find_closing_tag(node, start_line)
+        if closing_tag
+          @current_line = closing_tag[:line]
+        end
+
+        # Create range
+        end_line = @current_line
+        range = LineRange.new(start_line, end_line, node)
+        @map[node] = range
+        @ranges << range
+
+        # Move to next line after this element
+        @current_line = end_line + 1
+      end
+
+      # Find opening tag line for element
+      def find_opening_tag(elem)
+        tag_pattern = if elem.prefix && !elem.prefix.empty?
+                        /<#{Regexp.escape(elem.prefix)}:#{Regexp.escape(elem.name)}[\s>\/]/
+                      else
+                        /<#{Regexp.escape(elem.name)}[\s>\/]/
+                      end
+
+        (@current_line...@lines.length).each do |i|
+          line = @lines[i]
+          if line.match?(tag_pattern)
+            return { line: i, content: line }
+          end
+        end
+
+        nil
+      end
+
+      # Find closing tag line for element
+      def find_closing_tag(elem, start_line)
+        tag_pattern = if elem.prefix && !elem.prefix.empty?
+                        /<\/#{Regexp.escape(elem.prefix)}:#{Regexp.escape(elem.name)}>/
+                      else
+                        /<\/#{Regexp.escape(elem.name)}>/
+                      end
+
+        # Check if self-closing
+        start_content = @lines[start_line]
+        if start_content&.include?("/>")
+          return { line: start_line, content: start_content }
+        end
+
+        # Find closing tag
+        (start_line...@lines.length).each do |i|
+          line = @lines[i]
+          if line.match?(tag_pattern)
+            return { line: i, content: line }
+          end
+        end
+
+        { line: start_line, content: start_content }
+      end
+    end
+  end
+end

data/lib/canon/xml/namespace_handler.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # Namespace handler for C14N 1.1
+    # Handles namespace declaration processing per spec
+    class NamespaceHandler
+      def initialize(encoder)
+        @encoder = encoder
+      end
+
+      # Process namespace axis of an element
+      # rubocop:disable Metrics/MethodLength
+      def process_namespaces(element, output, parent_element = nil)
+        return unless element.in_node_set?
+
+        namespaces = element.sorted_namespace_nodes.select(&:in_node_set?)
+
+        # Check if we need to emit xmlns="" for empty default namespace
+        if should_emit_empty_default_namespace?(element, namespaces,
+                                                parent_element)
+          output << ' xmlns=""'
+        end
+
+        # Process each namespace node
+        namespaces.each do |ns|
+          next if should_skip_namespace?(ns, element, parent_element)
+
+          output << " "
+          output << if ns.default_namespace?
+                      "xmlns"
+                    else
+                      "xmlns:#{ns.prefix}"
+                    end
+          output << '="'
+          output << @encoder.encode_attribute(ns.uri)
+          output << '"'
+        end
+      end
+
+      private
+
+      # Check if we should emit xmlns="" for empty default namespace
+      # Per spec: emit if and only if:
+      # 1. The element E is in the node-set
+      # 2. The first namespace node is not the default namespace node
+      # 3. The nearest ancestor element of E in the node-set has a
+      #    default namespace node in the node-set with non-empty value
+      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
+
+        # Check if parent has non-empty default namespace
+        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
+
+      # Check if a namespace node should be skipped
+      def should_skip_namespace?(ns, _element, parent_element)
+        # Skip xml namespace with standard URI
+        return true if ns.xml_namespace?
+
+        # Skip if an ancestor already declared this namespace
+        return true if namespace_declared_by_ancestor?(ns, parent_element)
+
+        false
+      end
+
+      # Check if a namespace is already declared by an ancestor
+      def namespace_declared_by_ancestor?(ns, parent_element)
+        return false unless parent_element
+
+        parent_ns = parent_element.namespace_nodes.find do |parent_ns|
+          parent_ns.prefix == ns.prefix && parent_ns.in_node_set?
+        end
+
+        parent_ns && parent_ns.uri == ns.uri
+      end
+    end
+  end
+end

data/lib/canon/xml/node.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # Base class for all XPath data model nodes
+    class Node
+      attr_reader :parent, :children
+
+      def initialize
+        @parent = nil
+        @children = []
+      end
+
+      def add_child(child)
+        child.parent = self
+        @children << child
+      end
+
+      def in_node_set?
+        @in_node_set ||= true
+      end
+
+      def in_node_set=(value)
+        @in_node_set = value
+      end
+
+      protected
+
+      attr_writer :parent
+    end
+  end
+end

data/lib/canon/xml/nodes/attribute_node.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Canon
+  module Xml
+    module Nodes
+      # Attribute node in the XPath data model
+      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
+
+        # Check if this is an xml:* attribute
+        def xml_attribute?
+          namespace_uri == "http://www.w3.org/XML/1998/namespace"
+        end
+
+        # Check if this is a simple inheritable attribute (xml:lang or xml:space)
+        def simple_inheritable?
+          xml_attribute? && ["lang", "space"].include?(name)
+        end
+
+        # Check if this is xml:id
+        def xml_id?
+          xml_attribute? && name == "id"
+        end
+
+        # Check if this is xml:base
+        def xml_base?
+          xml_attribute? && name == "base"
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/nodes/comment_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Canon
+  module Xml
+    module Nodes
+      # Comment node in the XPath data model
+      class CommentNode < Node
+        attr_reader :value
+
+        def initialize(value:)
+          super()
+          @value = value
+        end
+
+        def node_type
+          :comment
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/nodes/element_node.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Canon
+  module Xml
+    module Nodes
+      # Element node in the XPath 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
+
+        # Get namespace nodes in sorted order (lexicographically by local name)
+        def sorted_namespace_nodes
+          @namespace_nodes.sort_by do |ns|
+            ns.local_name.to_s
+          end
+        end
+
+        # Get attribute nodes in sorted order (by namespace URI then local name)
+        def sorted_attribute_nodes
+          @attribute_nodes.sort_by do |attr|
+            [attr.namespace_uri.to_s, attr.local_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/nodes/namespace_node.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Canon
+  module Xml
+    module Nodes
+      # Namespace node in the XPath data model
+      class NamespaceNode < Node
+        attr_reader :prefix, :uri
+
+        def initialize(prefix:, uri:)
+          super()
+          @prefix = prefix
+          @uri = uri
+        end
+
+        def node_type
+          :namespace
+        end
+
+        # Local name is the prefix (empty string for default namespace)
+        def local_name
+          prefix.to_s
+        end
+
+        def default_namespace?
+          prefix.nil? || prefix.empty?
+        end
+
+        # Check if this is the xml namespace
+        def xml_namespace?
+          prefix == "xml" && uri == "http://www.w3.org/XML/1998/namespace"
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/nodes/processing_instruction_node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Canon
+  module Xml
+    module Nodes
+      # Processing Instruction node in the XPath data model
+      class ProcessingInstructionNode < Node
+        attr_reader :target, :data
+
+        def initialize(target:, data: "")
+          super()
+          @target = target
+          @data = data
+        end
+
+        def node_type
+          :processing_instruction
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/nodes/root_node.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Canon
+  module Xml
+    module Nodes
+      # Root node representing the document root
+      class RootNode < Node
+        def node_type
+          :root
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/nodes/text_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Canon
+  module Xml
+    module Nodes
+      # Text node in the XPath data model
+      class TextNode < Node
+        attr_reader :value
+
+        def initialize(value:)
+          super()
+          @value = value
+        end
+
+        def node_type
+          :text
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/processor.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "character_encoder"
+require_relative "namespace_handler"
+require_relative "attribute_handler"
+require_relative "xml_base_handler"
+
+module Canon
+  module Xml
+    # C14N 1.1 processor
+    # Processes XPath data model and generates canonical form
+    class Processor
+      def initialize(with_comments: false)
+        @with_comments = with_comments
+        @encoder = CharacterEncoder.new
+        @namespace_handler = NamespaceHandler.new(@encoder)
+        @attribute_handler = AttributeHandler.new(@encoder)
+        @xml_base_handler = XmlBaseHandler.new
+      end
+
+      # Process a node-set and generate canonical form
+      def process(root_node)
+        output = String.new(encoding: "UTF-8")
+        process_node(root_node, output)
+        output
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def process_node(node, output, parent_element = nil,
+                       omitted_ancestors = [])
+        case node.node_type
+        when :root
+          process_root_node(node, output)
+        when :element
+          process_element_node(node, output, parent_element,
+                               omitted_ancestors)
+        when :text
+          process_text_node(node, output)
+        when :comment
+          process_comment_node(node, output, parent_element)
+        when :processing_instruction
+          process_pi_node(node, output, parent_element)
+        end
+      end
+
+      def process_root_node(node, output)
+        # Process children in document order
+        node.children.each do |child|
+          process_node(child, output)
+        end
+      end
+
+      def process_element_node(node, output, parent_element,
+                               omitted_ancestors)
+        if node.in_node_set?
+          # Element is in node-set, render it
+          render_element(node, output, parent_element, omitted_ancestors)
+        else
+          # Element is not in node-set, but process its children
+          new_omitted = omitted_ancestors + [node]
+          node.children.each do |child|
+            process_node(child, output, parent_element, new_omitted)
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def render_element(node, output, parent_element, omitted_ancestors)
+        # Opening tag
+        output << "<" << node.qname
+
+        # Process namespace axis
+        @namespace_handler.process_namespaces(node, output, parent_element)
+
+        # Process attribute axis with xml:base fixup if needed
+        process_element_attributes(node, output, omitted_ancestors)
+
+        output << ">"
+
+        # Process children
+        node.children.each do |child|
+          process_node(child, output, node, [])
+        end
+
+        # Closing tag
+        output << "</" << node.qname << ">"
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def process_element_attributes(node, output, omitted_ancestors)
+        # First process regular attributes
+        @attribute_handler.process_attributes(node, output,
+                                              omitted_ancestors)
+
+        # Then handle xml:base fixup if needed
+        if omitted_ancestors.any?
+          fixed_base = @xml_base_handler.fixup_xml_base(node,
+                                                        omitted_ancestors)
+          if fixed_base && !fixed_base.empty?
+            # Check if element already has xml:base
+            has_base = node.attribute_nodes.any?(&:xml_base?)
+            unless has_base
+              output << ' xml:base="'
+              output << @encoder.encode_attribute(fixed_base)
+              output << '"'
+            end
+          end
+        end
+      end
+
+      def process_text_node(node, output)
+        return unless node.in_node_set?
+
+        output << @encoder.encode_text(node.value)
+      end
+
+      def process_comment_node(node, output, parent_element)
+        return unless @with_comments
+        return unless node.in_node_set?
+
+        # Add line break before comment if it's outside document element
+        output << "\n" if parent_element.nil? && output.length.positive?
+
+        output << "<!--" << node.value << "-->"
+
+        # Add line break after comment if it's outside document element
+        output << "\n" if parent_element.nil?
+      end
+
+      def process_pi_node(node, output, parent_element)
+        return unless node.in_node_set?
+
+        # Add line break before PI if it's outside document element
+        output << "\n" if parent_element.nil? && output.length.positive?
+
+        output << "<?" << node.target
+
+        unless node.data.empty?
+          output << " " << node.data
+        end
+
+        output << "?>"
+
+        # Add line break after PI if it's outside document element
+        output << "\n" if parent_element.nil?
+      end
+    end
+  end
+end