canon 0.1.3 → 0.1.5

data/lib/canon/validators/yaml_validator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "date"
+require "time"
+require_relative "base_validator"
+
+module Canon
+  module Validators
+    # Validator for YAML input
+    #
+    # Validates YAML input using Ruby's YAML parser.
+    # Raises detailed ValidationError with position information
+    # when malformed YAML is detected.
+    class YamlValidator < BaseValidator
+      # Validate YAML input
+      #
+      # @param input [String] The YAML string to validate
+      # @raise [Canon::ValidationError] If YAML is malformed
+      # @return [void]
+      def self.validate!(input)
+        return if input.nil? || input.strip.empty?
+
+        YAML.safe_load(input, permitted_classes: [Symbol, Date, Time])
+      rescue Psych::SyntaxError => e
+        location = extract_location(e)
+
+        raise Canon::ValidationError.new(
+          clean_error_message(e.message),
+          format: :yaml,
+          line: location[:line],
+          column: location[:column],
+          details: extract_context(input, e),
+        )
+      end
+
+      # Clean error message by removing file path details
+      #
+      # @param message [String] The raw error message
+      # @return [String] Cleaned error message
+      def self.clean_error_message(message)
+        # Remove file path and keep main message
+        message.gsub(/\(<unknown>\):\s*/, "").split("\n").first.strip
+      end
+
+      # Extract context around the error
+      #
+      # @param input [String] The input YAML string
+      # @param error [Psych::SyntaxError] The syntax error
+      # @return [String, nil] Context snippet around the error
+      def self.extract_context(input, error)
+        return nil unless error.line
+
+        lines = input.split("\n")
+        line_idx = error.line - 1
+        return nil if line_idx.negative? || line_idx >= lines.size
+
+        # Get the problematic line
+        problem_line = lines[line_idx]
+
+        # Add column indicator if available
+        if error.column
+          indicator = "#{' ' * (error.column - 1)}^"
+          "Line content: #{problem_line}\n#{indicator}"
+        else
+          "Line content: #{problem_line}"
+        end
+      end
+
+      private_class_method :clean_error_message, :extract_context
+    end
+  end
+end

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/lib/canon/xml/attribute_handler.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # Attribute handler for C14N 1.1
+    # Handles attribute processing per spec
+    class AttributeHandler
+      def initialize(encoder)
+        @encoder = encoder
+      end
+
+      # Process attribute axis of an element
+      # Includes handling of simple inheritable attributes for document subsets
+      # rubocop:disable Metrics/MethodLength
+      def process_attributes(element, output, omitted_ancestors = [])
+        return unless element.in_node_set?
+
+        # Collect attributes including inherited simple inheritable ones
+        attributes = collect_attributes(element, omitted_ancestors)
+
+        # Sort and process attributes
+        attributes.each do |attr|
+          output << " "
+          output << attr.qname
+          output << '="'
+          output << @encoder.encode_attribute(attr.value)
+          output << '"'
+        end
+      end
+
+      private
+
+      # Collect attributes including inherited simple inheritable attributes
+      def collect_attributes(element, omitted_ancestors)
+        attributes = element.sorted_attribute_nodes.select(&:in_node_set?)
+
+        # Add inherited simple inheritable attributes if needed
+        if omitted_ancestors.any?
+          inherited = collect_inherited_attributes(element, omitted_ancestors)
+          attributes = merge_attributes(attributes, inherited)
+        end
+
+        attributes
+      end
+
+      # Collect simple inheritable attributes from omitted ancestors
+      # rubocop:disable Metrics/MethodLength
+      def collect_inherited_attributes(element, omitted_ancestors)
+        inherited = []
+        seen = Set.new
+
+        # Track which simple inheritable attributes element already has
+        element.attribute_nodes.each do |attr|
+          seen.add(attr.name) if attr.simple_inheritable?
+        end
+
+        # Walk up omitted ancestors to find inheritable attributes
+        omitted_ancestors.reverse.each do |ancestor|
+          ancestor.attribute_nodes.each do |attr|
+            next unless attr.simple_inheritable?
+            next if seen.include?(attr.name)
+
+            inherited << attr
+            seen.add(attr.name)
+          end
+        end
+
+        inherited
+      end
+
+      # Merge and sort attributes
+      def merge_attributes(element_attrs, inherited_attrs)
+        all_attrs = element_attrs + inherited_attrs
+        all_attrs.sort_by do |attr|
+          [attr.namespace_uri.to_s, attr.local_name]
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/c14n.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "data_model"
+require_relative "processor"
+
+module Canon
+  module Xml
+    # XML Canonicalization 1.1 implementation
+    # Per W3C Recommendation: https://www.w3.org/TR/xml-c14n11/
+    class C14n
+      # Canonicalize an XML document
+      # @param xml [String] XML document as string
+      # @param with_comments [Boolean] Include comments in canonical form
+      # @return [String] Canonical form in UTF-8
+      def self.canonicalize(xml, with_comments: false)
+        # Build XPath data model
+        root_node = DataModel.from_xml(xml)
+
+        # Process to canonical form
+        processor = Processor.new(with_comments: with_comments)
+        processor.process(root_node)
+      end
+
+      # Canonicalize a document subset (for future implementation)
+      # @param xml [String] XML document as string
+      # @param xpath [String] XPath expression for subset selection
+      # @param with_comments [Boolean] Include comments in canonical form
+      # @return [String] Canonical form in UTF-8
+      def self.canonicalize_subset(xml, _xpath, with_comments: false)
+        # TODO: Implement XPath-based subset selection
+        # For now, just canonicalize the whole document
+        canonicalize(xml, with_comments: with_comments)
+      end
+    end
+  end
+end

data/lib/canon/xml/character_encoder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # Character encoder for C14N 1.1
+    # Handles UTF-8 encoding and character reference encoding per spec
+    class CharacterEncoder
+      # Encode text node content
+      # Replace: & → &amp;, < → &lt;, > → &gt;, #xD → &#xD;
+      def encode_text(text)
+        text.gsub(/[&<>\r]/) do |char|
+          case char
+          when "&" then "&amp;"
+          when "<" then "&lt;"
+          when ">" then "&gt;"
+          when "\r" then "&#xD;"
+          end
+        end
+      end
+
+      # Encode attribute value
+      # Replace: & → &amp;, < → &lt;, " → &quot;,
+      #          #x9 → &#x9;, #xA → &#xA;, #xD → &#xD;
+      def encode_attribute(value)
+        value.gsub(/[&<"\t\n\r]/) do |char|
+          case char
+          when "&" then "&amp;"
+          when "<" then "&lt;"
+          when '"' then "&quot;"
+          when "\t" then "&#x9;"
+          when "\n" then "&#xA;"
+          when "\r" then "&#xD;"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canon/xml/data_model.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "set"
+require_relative "nodes/root_node"
+require_relative "nodes/element_node"
+require_relative "nodes/namespace_node"
+require_relative "nodes/attribute_node"
+require_relative "nodes/text_node"
+require_relative "nodes/comment_node"
+require_relative "nodes/processing_instruction_node"
+
+module Canon
+  module Xml
+    # Builds XPath data model from XML
+    class DataModel
+      # Build XPath data model from XML string
+      def self.from_xml(xml_string)
+        # Parse with Nokogiri
+        doc = Nokogiri::XML(xml_string) do |config|
+          config.nonet     # Disable network access
+          config.strict    # Strict parsing
+        end
+
+        # Check for relative namespace URIs (prohibited by C14N 1.1)
+        check_for_relative_namespace_uris(doc)
+
+        # Convert to XPath data model
+        build_from_nokogiri(doc)
+      end
+
+      # Build XPath data model from HTML string
+      #
+      # @param html_string [String] HTML content to parse
+      # @param version [Symbol] HTML version (:html4 or :html5)
+      # @return [Nodes::RootNode] Root of the data model tree
+      def self.from_html(html_string, version: :html4)
+        # Parse with Nokogiri using appropriate HTML parser
+        doc = if version == :html5
+                Nokogiri::HTML5.fragment(html_string)
+              else
+                Nokogiri::HTML4.fragment(html_string)
+              end
+
+        # HTML doesn't have strict namespace requirements like XML,
+        # so skip the relative namespace URI check
+
+        # Convert to XPath data model (reuse XML infrastructure)
+        build_from_nokogiri(doc)
+      end
+
+      # Check for relative namespace URIs (prohibited by C14N 1.1)
+      # rubocop:disable Metrics/MethodLength
+      def self.check_for_relative_namespace_uris(doc)
+        doc.traverse do |node|
+          next unless node.is_a?(Nokogiri::XML::Element)
+
+          node.namespace_definitions.each do |ns|
+            next if ns.href.nil? || ns.href.empty?
+
+            # Check if URI is relative
+            if relative_uri?(ns.href)
+              raise Canon::Error,
+                    "Relative namespace URI not allowed: #{ns.href}"
+            end
+          end
+        end
+      end
+
+      # Check if a URI is relative
+      def self.relative_uri?(uri)
+        # A URI is relative if it doesn't have a scheme
+        uri !~ %r{^[a-zA-Z][a-zA-Z0-9+.-]*:}
+      end
+
+      # Build XPath data model from Nokogiri document or fragment
+      # rubocop:disable Metrics/MethodLength
+      def self.build_from_nokogiri(nokogiri_doc)
+        root = Nodes::RootNode.new
+
+        if nokogiri_doc.respond_to?(:root) && nokogiri_doc.root
+          # For Documents (XML, HTML4, HTML5, Moxml): process the root element
+          root.add_child(build_element_node(nokogiri_doc.root))
+
+          # Process PIs and comments outside doc element
+          nokogiri_doc.children.each do |child|
+            next if child == nokogiri_doc.root
+            next if child.is_a?(Nokogiri::XML::DTD)
+
+            node = build_node_from_nokogiri(child)
+            root.add_child(node) if node
+          end
+        else
+          # For DocumentFragments: process all children directly
+          # Fragments don't have a single .root, they contain multiple top-level nodes
+          nokogiri_doc.children.each do |child|
+            next if child.is_a?(Nokogiri::XML::DTD)
+
+            node = build_node_from_nokogiri(child)
+            root.add_child(node) if node
+          end
+        end
+
+        root
+      end
+
+      # Build node from Nokogiri node
+      def self.build_node_from_nokogiri(nokogiri_node)
+        case nokogiri_node
+        when Nokogiri::XML::Element
+          build_element_node(nokogiri_node)
+        when Nokogiri::XML::Text
+          build_text_node(nokogiri_node)
+        when Nokogiri::XML::Comment
+          build_comment_node(nokogiri_node)
+        when Nokogiri::XML::ProcessingInstruction
+          build_pi_node(nokogiri_node)
+        end
+      end
+
+      # Build element node from Nokogiri element
+      # rubocop:disable Metrics/MethodLength
+      def self.build_element_node(nokogiri_element)
+        element = Nodes::ElementNode.new(
+          name: nokogiri_element.name,
+          namespace_uri: nokogiri_element.namespace&.href,
+          prefix: nokogiri_element.namespace&.prefix,
+        )
+
+        # Build namespace nodes (includes inherited namespaces)
+        build_namespace_nodes(nokogiri_element, element)
+
+        # Build attribute nodes
+        build_attribute_nodes(nokogiri_element, element)
+
+        # Build child nodes
+        nokogiri_element.children.each do |child|
+          node = build_node_from_nokogiri(child)
+          element.add_child(node) if node
+        end
+
+        element
+      end
+
+      # Build namespace nodes for an element
+      def self.build_namespace_nodes(nokogiri_element, element)
+        # Collect all in-scope namespaces
+        namespaces = collect_in_scope_namespaces(nokogiri_element)
+
+        namespaces.each do |prefix, uri|
+          ns_node = Nodes::NamespaceNode.new(
+            prefix: prefix,
+            uri: uri,
+          )
+          element.add_namespace(ns_node)
+        end
+      end
+
+      # Collect all in-scope namespaces for an element
+      # rubocop:disable Metrics/MethodLength
+      def self.collect_in_scope_namespaces(nokogiri_element)
+        namespaces = {}
+
+        # Walk up the tree to collect all namespace declarations
+        current = nokogiri_element
+        while current && !current.is_a?(Nokogiri::XML::Document)
+          if current.is_a?(Nokogiri::XML::Element)
+            current.namespace_definitions.each do |ns|
+              prefix = ns.prefix || ""
+              # Only add if not already defined (child overrides parent)
+              unless namespaces.key?(prefix)
+                namespaces[prefix] = ns.href
+              end
+            end
+          end
+          current = current.parent
+        end
+
+        # Always include xml namespace
+        namespaces["xml"] ||= "http://www.w3.org/XML/1998/namespace"
+
+        namespaces
+      end
+
+      # Build attribute nodes for an element
+      def self.build_attribute_nodes(nokogiri_element, element)
+        nokogiri_element.attributes.each do |name, attr|
+          next if name.start_with?("xmlns")
+
+          attr_node = Nodes::AttributeNode.new(
+            name: attr.name,
+            value: attr.value,
+            namespace_uri: attr.namespace&.href,
+            prefix: attr.namespace&.prefix,
+          )
+          element.add_attribute(attr_node)
+        end
+      end
+
+      # Build text node from Nokogiri text node
+      def self.build_text_node(nokogiri_text)
+        # Skip text nodes that are only whitespace between elements
+        # unless they have significant content
+        content = nokogiri_text.content
+        return nil if content.strip.empty? && nokogiri_text.parent.is_a?(Nokogiri::XML::Element)
+
+        # Nokogiri already handles CDATA conversion and entity resolution
+        Nodes::TextNode.new(value: content)
+      end
+
+      # Build comment node from Nokogiri comment
+      def self.build_comment_node(nokogiri_comment)
+        Nodes::CommentNode.new(value: nokogiri_comment.content)
+      end
+
+      # Build PI node from Nokogiri PI
+      def self.build_pi_node(nokogiri_pi)
+        Nodes::ProcessingInstructionNode.new(
+          target: nokogiri_pi.name,
+          data: nokogiri_pi.content,
+        )
+      end
+    end
+  end
+end

data/lib/canon/xml/element_matcher.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # Matches XML elements semantically across two DOM trees
+    #
+    # This class implements intelligent element matching for XML diffs.
+    # Instead of naive line-by-line comparison, it semantically matches
+    # elements across documents using identity attributes and structural
+    # position.
+    #
+    # == Matching Strategy
+    #
+    # Elements are matched in two passes:
+    #
+    # 1. **Identity attribute matching**: Elements with same identity attribute
+    #    values are matched (e.g., id="foo" matches id="foo")
+    # 2. **Position-based matching**: Remaining elements matched by name and
+    #    document position
+    #
+    # This allows detecting when elements:
+    # - Move to different positions (matched by ID)
+    # - Have content changes (matched, diff shows changes)
+    # - Are added/deleted (no match found)
+    #
+    # == Identity Attributes
+    #
+    # By default, these attributes identify elements:
+    # - id
+    # - ref
+    # - name
+    # - key
+    #
+    # Custom identity attributes can be provided to the constructor.
+    #
+    # == Usage
+    #
+    #   matcher = ElementMatcher.new
+    #   root1 = Canon::Xml::DataModel.from_xml(xml1)
+    #   root2 = Canon::Xml::DataModel.from_xml(xml2)
+    #   matches = matcher.match_trees(root1, root2)
+    #
+    #   matches.each do |match|
+    #     case match.status
+    #     when :matched
+    #       # Elements found in both trees
+    #     when :deleted
+    #       # Element only in first tree
+    #     when :inserted
+    #       # Element only in second tree
+    #     end
+    #   end
+    #
+    class ElementMatcher
+      # Default attributes used to identify elements
+      DEFAULT_IDENTITY_ATTRS = %w[id ref name key].freeze
+
+      # Match result for an element
+      MatchResult = Struct.new(:status, :elem1, :elem2, :path) do
+        def matched?
+          status == :matched
+        end
+
+        def inserted?
+          status == :inserted
+        end
+
+        def deleted?
+          status == :deleted
+        end
+      end
+
+      def initialize(identity_attrs: DEFAULT_IDENTITY_ATTRS)
+        @identity_attrs = identity_attrs
+        @matches = []
+      end
+
+      # Match elements between two DOM trees
+      #
+      # @param root1 [Canon::Xml::Nodes::RootNode] First DOM tree
+      # @param root2 [Canon::Xml::Nodes::RootNode] Second DOM tree
+      # @return [Array<MatchResult>] Array of match results
+      def match_trees(root1, root2)
+        @matches = []
+        match_children(root1.children, root2.children, [])
+        @matches
+      end
+
+      private
+
+      # Match children recursively
+      def match_children(children1, children2, path)
+        # Filter to only element nodes
+        elems1 = children1.select { |n| n.node_type == :element }
+        elems2 = children2.select { |n| n.node_type == :element }
+
+        # Build identity maps for quick lookup
+        map1 = build_identity_map(elems1)
+        map2 = build_identity_map(elems2)
+
+        matched1 = Set.new
+        matched2 = Set.new
+
+        # Match by identity attributes
+        map1.each do |identity, elem1|
+          if map2.key?(identity)
+            elem2 = map2[identity]
+            elem_path = path + [elem1.name]
+            @matches << MatchResult.new(:matched, elem1, elem2, elem_path)
+            matched1.add(elem1)
+            matched2.add(elem2)
+
+            # Recursively match children
+            match_children(elem1.children, elem2.children, elem_path)
+          end
+        end
+
+        # Match remaining elements by name and position
+        unmatched1 = elems1.reject { |e| matched1.include?(e) }
+        unmatched2 = elems2.reject { |e| matched2.include?(e) }
+
+        match_by_position(unmatched1, unmatched2, path, matched1, matched2)
+
+        # Record unmatched as deleted/inserted
+        unmatched1.each do |elem1|
+          next if matched1.include?(elem1)
+
+          elem_path = path + [elem1.name]
+          @matches << MatchResult.new(:deleted, elem1, nil, elem_path)
+        end
+
+        unmatched2.each do |elem2|
+          next if matched2.include?(elem2)
+
+          elem_path = path + [elem2.name]
+          @matches << MatchResult.new(:inserted, nil, elem2, elem_path)
+        end
+      end
+
+      # Match remaining elements by name and position
+      def match_by_position(elems1, elems2, path, matched1, matched2)
+        # Group by element name
+        by_name1 = elems1.group_by(&:name)
+        by_name2 = elems2.group_by(&:name)
+
+        # For each name, match by position
+        by_name1.each do |name, list1|
+          next unless by_name2.key?(name)
+
+          list2 = by_name2[name]
+
+          # Match pairs by position
+          [list1.length, list2.length].min.times do |i|
+            elem1 = list1[i]
+            elem2 = list2[i]
+
+            next if matched1.include?(elem1) || matched2.include?(elem2)
+
+            elem_path = path + [name]
+            @matches << MatchResult.new(:matched, elem1, elem2, elem_path)
+            matched1.add(elem1)
+            matched2.add(elem2)
+
+            # Recursively match children
+            match_children(elem1.children, elem2.children, elem_path)
+          end
+        end
+      end
+
+      # Build map of identity → element
+      def build_identity_map(elements)
+        map = {}
+
+        elements.each do |elem|
+          identity = extract_identity(elem)
+          next unless identity
+
+          # Use element name + identity as key to handle multiple element types
+          key = "#{elem.name}##{identity}"
+          map[key] = elem
+        end
+
+        map
+      end
+
+      # Extract identity from element attributes
+      def extract_identity(elem)
+        @identity_attrs.each do |attr_name|
+          attr = elem.attribute_nodes.find { |a| a.name == attr_name }
+          return attr.value if attr
+        end
+        nil
+      end
+    end
+  end
+end