canon 0.1.5 → 0.1.7

data/lib/canon/diff_formatter/legend.rb

@@ -88,6 +88,48 @@ module Canon
         output.join("\n")
       end
 
+      # Build diff symbol legend
+      #
+      # @param use_color [Boolean] Whether to use colors
+      # @return [String] Formatted diff symbol legend
+      def self.build_diff_symbol_legend(use_color: true)
+        output = []
+        separator = "━" * 60
+
+        output << colorize("Diff Symbol Legend:", :cyan, :bold, use_color)
+        output << colorize(separator, :cyan, :bold, use_color)
+
+        # Formatting-only changes
+        output << colorize("Formatting Changes (cosmetic only):", :yellow,
+                           :bold, use_color)
+        output << "  #{colorize('[', :black, :bold,
+                                use_color)}: Line removed (formatting only - dark gray)"
+        output << "  #{colorize(']', :white, :bold,
+                                use_color)}: Line added (formatting only - light gray)"
+        output << ""
+
+        # Informative changes
+        output << colorize("Informative Changes (do not affect equivalence):",
+                           :yellow, :bold, use_color)
+        output << "  #{colorize('<', :blue, :bold,
+                                use_color)}: Line removed (informative - blue)"
+        output << "  #{colorize('>', :cyan, :bold,
+                                use_color)}: Line added (informative - cyan)"
+        output << ""
+
+        # Normative changes
+        output << colorize("Normative Changes (affect equivalence):", :yellow,
+                           :bold, use_color)
+        output << "  #{colorize('-', :red, :bold,
+                                use_color)}: Line removed (normative difference - red)"
+        output << "  #{colorize('+', :green, :bold,
+                                use_color)}: Line added (normative difference - green)"
+        output << ""
+
+        output << colorize(separator, :cyan, :bold, use_color)
+        output.join("\n")
+      end
+
       # Format character name for display
       #
       # @param name [String] Unicode character name

data/lib/canon/diff_formatter.rb

@@ -300,6 +300,18 @@ module Canon
 
       output = []
 
+      # Display the algorithm being used
+      if comparison_result.is_a?(Canon::Comparison::ComparisonResult)
+        algorithm_name = case comparison_result.algorithm
+                         when :semantic
+                           "SEMANTIC TREE DIFF"
+                         else
+                           "DOM DIFF"
+                         end
+        output << colorize("Algorithm: #{algorithm_name}", :cyan, :bold)
+        output << "" # Blank line for spacing
+      end
+
       # 1. CANON VERBOSE tables (ONLY if CANON_VERBOSE=1)
       verbose_tables = DebugOutput.verbose_tables_only(
         comparison_result,
@@ -317,12 +329,21 @@ module Canon
         )
       end
 
+      # 2.5. Original Input Strings (ONLY if verbose_diff is enabled)
+      if @verbose_diff && comparison_result.is_a?(Canon::Comparison::ComparisonResult)
+        original1, original2 = comparison_result.original_strings
+        if original1 && original2
+          output << format_original_strings(original1, original2)
+        end
+      end
+
       # 3. Main diff output (by-line or by-object) - ALWAYS
 
       # Check if comparison result is a ComparisonResult object
       if comparison_result.is_a?(Canon::Comparison::ComparisonResult)
-        # Use preprocessed strings from comparison - avoids re-preprocessing
-        doc1, doc2 = comparison_result.preprocessed_strings
+        # Use original strings for line diff to show actual formatting/namespace differences
+        # Use preprocessed strings for semantic comparison only
+        doc1, doc2 = comparison_result.original_strings
         differences = comparison_result.differences
         html_version = comparison_result.html_version
       elsif comparison_result.is_a?(Hash) && comparison_result[:preprocessed]
@@ -361,7 +382,7 @@ module Canon
             /></, ">\n<"
           ),
           Canon::Xml::C14n.canonicalize(actual, with_comments: false).gsub(
-            /></, ">\n<"
+            />\s+$/, ""
           ),
         ]
       when :html
@@ -407,6 +428,43 @@ module Canon
       html.to_s
     end
 
+    # Format original input strings for display (RSpec-style)
+    # Shows the actual strings that were passed in before any preprocessing
+    #
+    # @param original1 [String] First original input string
+    # @param original2 [String] Second original input string
+    # @return [String] Formatted display of original strings
+    def format_original_strings(original1, original2)
+      return "" if original1.nil? || original2.nil?
+
+      output = []
+      output << ""
+      output << colorize("=" * 70, :cyan, :bold)
+      output << colorize("  ORIGINAL INPUT STRINGS", :cyan, :bold)
+      output << colorize("=" * 70, :cyan, :bold)
+      output << ""
+
+      # Format expected
+      output << colorize("Expected (as string):", :yellow, :bold)
+      original1.each_line.with_index do |line, idx|
+        output << "  #{colorize(sprintf('%4d', idx + 1),
+                                :blue)} | #{line.chomp}"
+      end
+      output << ""
+
+      # Format actual
+      output << colorize("Actual (as string):", :yellow, :bold)
+      original2.each_line.with_index do |line, idx|
+        output << "  #{colorize(sprintf('%4d', idx + 1),
+                                :blue)} | #{line.chomp}"
+      end
+      output << ""
+      output << colorize("=" * 70, :cyan, :bold)
+      output << ""
+
+      output.join("\n")
+    end
+
     # Build the final visualization map from various customization options
     #
     # @param visualization_map [Hash, nil] Complete custom visualization map
@@ -455,19 +513,25 @@ module Canon
     # Generate by-object diff with tree visualization
     # Delegates to format-specific by-object formatters
     def by_object_diff(differences, format)
-      require_relative "diff_formatter/by_object/base_formatter"
-
       output = []
       output << colorize("Visual Diff:", :cyan, :bold)
 
+      # Extract differences array from ComparisonResult if needed
+      diffs_array = if differences.is_a?(Canon::Comparison::ComparisonResult)
+                      differences.differences
+                    else
+                      differences
+                    end
+
       # Delegate to format-specific formatter
       formatter = ByObject::BaseFormatter.for_format(
         format,
         use_color: @use_color,
         visualization_map: @visualization_map,
+        show_diffs: @show_diffs,
       )
 
-      output << formatter.format(differences, format)
+      output << formatter.format(diffs_array, format)
 
       output.join("\n")
     end
@@ -476,8 +540,6 @@ module Canon
     # Delegates to format-specific by-line formatters
     def by_line_diff(doc1, doc2, format: :xml, html_version: nil,
 differences: [])
-      require_relative "diff_formatter/by_line/base_formatter"
-
       # For HTML format, use html_version if provided, otherwise default to :html4
       if format == :html && html_version
         format = html_version # Use :html4 or :html5
@@ -492,6 +554,13 @@ differences: [])
 
       return output.join("\n") if doc1.nil? || doc2.nil?
 
+      # Extract differences array from ComparisonResult if needed
+      diffs_array = if differences.is_a?(Canon::Comparison::ComparisonResult)
+                      differences.differences
+                    else
+                      differences
+                    end
+
       # Delegate to format-specific formatter
       formatter = ByLine::BaseFormatter.for_format(
         format,
@@ -500,7 +569,7 @@ differences: [])
         diff_grouping_lines: @diff_grouping_lines,
         visualization_map: @visualization_map,
         show_diffs: @show_diffs,
-        differences: differences,
+        differences: diffs_array,
       )
 
       output << formatter.format(doc1, doc2)

data/lib/canon/errors.rb

@@ -53,4 +53,60 @@ module Canon
       parts.join("\n")
     end
   end
+
+  # Error raised when input exceeds size limits
+  #
+  # This error is raised when input files or trees exceed configured size
+  # limits to prevent performance issues or hangs.
+  class SizeLimitExceededError < Error
+    attr_reader :limit_type, :actual, :limit
+
+    # Initialize a new SizeLimitExceededError
+    #
+    # @param limit_type [Symbol] The type of limit exceeded (:file_size,
+    #   :node_count, :diff_lines)
+    # @param actual [Integer] The actual size that exceeded the limit
+    # @param limit [Integer] The configured limit
+    def initialize(limit_type, actual, limit)
+      @limit_type = limit_type
+      @actual = actual
+      @limit = limit
+      super(build_message)
+    end
+
+    private
+
+    # Build a descriptive error message
+    #
+    # @return [String] The formatted error message
+    def build_message
+      case limit_type
+      when :file_size
+        "File size (#{format_bytes(actual)}) exceeds limit (#{format_bytes(limit)}). " \
+          "Increase limit via CANON_MAX_FILE_SIZE or config.diff.max_file_size"
+      when :node_count
+        "Tree node count (#{actual}) exceeds limit (#{limit}). " \
+          "Increase limit via CANON_MAX_NODE_COUNT or config.diff.max_node_count"
+      when :diff_lines
+        "Diff output (#{actual} lines) exceeds limit (#{limit} lines). " \
+          "Output truncated. Increase limit via CANON_MAX_DIFF_LINES or config.diff.max_diff_lines"
+      else
+        "Size limit exceeded: #{limit_type} (#{actual} > #{limit})"
+      end
+    end
+
+    # Format bytes into human-readable size
+    #
+    # @param bytes [Integer] Size in bytes
+    # @return [String] Formatted size string
+    def format_bytes(bytes)
+      if bytes < 1024
+        "#{bytes} bytes"
+      elsif bytes < 1_048_576
+        "#{(bytes / 1024.0).round(2)} KB"
+      else
+        "#{(bytes / 1_048_576.0).round(2)} MB"
+      end
+    end
+  end
 end

data/lib/canon/formatters/html_formatter_base.rb

@@ -49,6 +49,12 @@ module Canon
         header hgroup hr li main nav ol p pre section table tbody
         td tfoot th thead tr ul
       ].freeze
+
+      # HTML elements where whitespace is semantically significant
+      # and should NOT be normalized
+      WHITESPACE_SENSITIVE_ELEMENTS = %w[
+        pre code textarea script style
+      ].freeze
       # Format HTML using canonical form
       # @param html [String] HTML document to canonicalize
       # @return [String] Canonical form of HTML
@@ -108,6 +114,13 @@ module Canon
         doc.traverse do |node|
           next unless node.text?
 
+          # CRITICAL: Skip normalization for whitespace-sensitive elements
+          # In elements like <pre>, <code>, etc., whitespace is semantically
+          # significant and must be preserved exactly as-is
+          if whitespace_sensitive_element?(node.parent)
+            next
+          end
+
           # Handle whitespace-only text nodes
           if node.text.strip.empty? && node.parent&.element?
             # Check if this text node is between block-level elements
@@ -156,8 +169,29 @@ module Canon
         node&.element? && BLOCK_ELEMENTS.include?(node.name.downcase)
       end
 
+      # Check if a node is a whitespace-sensitive element
+      # @param node [Nokogiri::XML::Node, nil] Node to check
+      # @return [Boolean] true if node is whitespace-sensitive
+      def self.whitespace_sensitive_element?(node)
+        return false unless node&.element?
+
+        # Check if this element or any ancestor is whitespace-sensitive
+        current = node
+        while current
+          if current.element? && WHITESPACE_SENSITIVE_ELEMENTS.include?(current.name.downcase)
+            return true
+          end
+          # Stop at document root - documents don't have parents
+          break if current.is_a?(Nokogiri::XML::Document) || current.is_a?(Nokogiri::HTML5::Document)
+
+          current = current.parent
+        end
+        false
+      end
+
       private_class_method :sort_attributes, :normalize_whitespace,
-                           :ensure_block_element_spacing, :block_element?
+                           :ensure_block_element_spacing, :block_element?,
+                           :whitespace_sensitive_element?
     end
   end
 end

data/lib/canon/formatters/json_formatter.rb

@@ -15,6 +15,9 @@ module Canon
       def self.parse(json)
         # Validate before parsing
         Canon::Validators::JsonValidator.validate!(json)
+        # Return as-is if already parsed
+        return json if json.is_a?(Hash) || json.is_a?(Array)
+
         JSON.parse(json)
       end
 

data/lib/canon/formatters/yaml_formatter.rb

@@ -15,6 +15,9 @@ module Canon
       def self.parse(yaml)
         # Validate before parsing
         Canon::Validators::YamlValidator.validate!(yaml)
+        # Return as-is if already parsed
+        return yaml if yaml.is_a?(Hash) || yaml.is_a?(Array)
+
         YAML.safe_load(yaml, permitted_classes: [Symbol, Date, Time])
       end
 

data/lib/canon/html/data_model.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "../data_model"
+require_relative "../xml/nodes/root_node"
+require_relative "../xml/nodes/element_node"
+require_relative "../xml/nodes/namespace_node"
+require_relative "../xml/nodes/attribute_node"
+require_relative "../xml/nodes/text_node"
+require_relative "../xml/nodes/comment_node"
+require_relative "../xml/nodes/processing_instruction_node"
+
+module Canon
+  module Html
+    # Builds XPath data model from HTML
+    # HTML-specific parsing with lowercase element/attribute names,
+    # whitespace-sensitive element handling, and fragment parsing
+    class DataModel < Canon::DataModel
+      # Build XPath data model from HTML string
+      #
+      # @param html_string [String] HTML content to parse
+      # @param version [Symbol] HTML version (:html4 or :html5)
+      # @return [Canon::Xml::Nodes::RootNode] Root of the data model tree
+      def self.from_html(html_string, version: :html4)
+        # Detect if this is a full document (has <html> tag) or fragment
+        # Full documents should use document parser to preserve structure
+        # Fragments should use fragment parser to avoid adding implicit wrappers
+        is_full_document = html_string.match?(/<html[\s>]/i)
+
+        # Parse with Nokogiri using appropriate parser
+        doc = if is_full_document
+                # Full document - use fragment parser to avoid Nokogiri's phantom tag insertion
+                # The fragment parser avoids auto-inserted meta tags in HTML4
+                if version == :html5
+                  Nokogiri::HTML5.fragment(html_string)
+                else
+                  Nokogiri::HTML4.fragment(html_string)
+                end
+              elsif version == :html5
+                # Fragment - use fragment parser to avoid implicit wrappers
+                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
+
+      # Alias for compatibility
+      def self.parse(html_string, version: :html4)
+        from_html(html_string, version: version)
+      end
+
+      # Serialize HTML node to string
+      def self.serialize(node)
+        # HTML nodes use the same serialization as XML
+        # Delegate to XML serialization implementation
+        require_relative "../xml/data_model"
+        Canon::Xml::DataModel.serialize(node)
+      end
+
+      # Build XPath data model from Nokogiri document or fragment
+      def self.build_from_nokogiri(nokogiri_doc)
+        root = Canon::Xml::Nodes::RootNode.new
+
+        if nokogiri_doc.respond_to?(:root) && nokogiri_doc.root
+          # For Documents (HTML4, HTML5): 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
+      def self.build_element_node(nokogiri_element)
+        element = Canon::Xml::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 = Canon::Xml::Nodes::NamespaceNode.new(
+            prefix: prefix,
+            uri: uri,
+          )
+          element.add_namespace(ns_node)
+        end
+      end
+
+      # Collect all in-scope namespaces for an element
+      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 = Canon::Xml::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
+      # HTML-specific: handles whitespace-sensitive elements (pre, code, textarea, script, style)
+      def self.build_text_node(nokogiri_text)
+        # Skip text nodes that are only whitespace between elements
+        # EXCEPT in whitespace-sensitive elements (pre, code, textarea, script, style)
+        # where whitespace is semantically significant
+        content = nokogiri_text.content
+
+        if content.strip.empty? && nokogiri_text.parent.is_a?(Nokogiri::XML::Element)
+          # Check if parent is whitespace-sensitive
+          parent_name = nokogiri_text.parent.name.downcase
+          whitespace_sensitive_tags = %w[pre code textarea script style]
+
+          # Skip whitespace-only text UNLESS in whitespace-sensitive element
+          return nil unless whitespace_sensitive_tags.include?(parent_name)
+        end
+
+        # Nokogiri already handles CDATA conversion and entity resolution
+        Canon::Xml::Nodes::TextNode.new(value: content)
+      end
+
+      # Build comment node from Nokogiri comment
+      def self.build_comment_node(nokogiri_comment)
+        Canon::Xml::Nodes::CommentNode.new(value: nokogiri_comment.content)
+      end
+
+      # Build PI node from Nokogiri PI
+      def self.build_pi_node(nokogiri_pi)
+        Canon::Xml::Nodes::ProcessingInstructionNode.new(
+          target: nokogiri_pi.name,
+          data: nokogiri_pi.content,
+        )
+      end
+
+      class << self
+        private :build_from_nokogiri, :build_node_from_nokogiri,
+                :build_element_node, :build_namespace_nodes,
+                :collect_in_scope_namespaces, :build_attribute_nodes,
+                :build_text_node, :build_comment_node, :build_pi_node
+      end
+    end
+  end
+end

data/lib/canon/html.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "html/data_model"
+
+module Canon
+  # HTML-specific functionality for Canon
+  module Html
+  end
+end

data/lib/canon/options/cli_generator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "registry"
+
+module Canon
+  module Options
+    # Generates Thor CLI options from the Options Registry
+    # This ensures CLI options stay in sync with the centralized registry
+    module CliGenerator
+      class << self
+        # Generate Thor method_option calls for diff command
+        def generate_diff_options
+          lambda do |thor_class|
+            Canon::Options::Registry.all_options.each do |opt|
+              add_thor_option(thor_class, opt)
+            end
+          end
+        end
+
+        private
+
+        # Add a single Thor option
+        def add_thor_option(thor_class, opt)
+          thor_opts = build_thor_opts(opt)
+
+          thor_class.method_option(
+            opt[:name],
+            **thor_opts,
+          )
+        end
+
+        # Build Thor option hash from registry option
+        def build_thor_opts(opt)
+          result = {}
+
+          # Add aliases if present
+          result[:aliases] = opt[:aliases] if opt[:aliases]
+
+          # Map type
+          result[:type] = map_type(opt[:type])
+
+          # Add enum values for enum types
+          result[:enum] = opt[:values] if opt[:type] == :enum
+
+          # Add default if present
+          result[:default] = opt[:default] if opt[:default]
+
+          # Add description
+          result[:desc] = opt[:description]
+
+          result
+        end
+
+        # Map registry type to Thor type
+        def map_type(registry_type)
+          case registry_type
+          when :enum
+            :string
+          when :numeric
+            :numeric
+          when :boolean
+            :boolean
+          else
+            :string
+          end
+        end
+      end
+    end
+  end
+end