canon 0.1.7 → 0.1.9

data/lib/canon/diff_formatter/by_line/html_formatter.rb

@@ -45,7 +45,7 @@ module Canon
             return ""
           end
 
-          require_relative "../../xml/data_model"
+          require_relative "../../html/data_model"
           require_relative "../../xml/element_matcher"
           require_relative "../../xml/line_range_mapper"
           require_relative "../../pretty_printer/html"
@@ -54,10 +54,10 @@ module Canon
 
           begin
             # Parse to DOM using HTML parser
-            root1 = Canon::Xml::DataModel.from_html(doc1,
-                                                    version: @html_version)
-            root2 = Canon::Xml::DataModel.from_html(doc2,
-                                                    version: @html_version)
+            root1 = Canon::Html::DataModel.from_html(doc1,
+                                                     version: @html_version)
+            root2 = Canon::Html::DataModel.from_html(doc2,
+                                                     version: @html_version)
 
             # Match elements semantically
             matcher = Canon::Xml::ElementMatcher.new
@@ -78,22 +78,8 @@ module Canon
             lines1 = pretty1.split("\n")
             lines2 = pretty2.split("\n")
 
-            # DEBUG
-            warn "DEBUG: HTML Formatter - lines1.length=#{lines1.length}, lines2.length=#{lines2.length}"
-            warn "DEBUG: HTML Formatter - matches.length=#{matches.length}"
-            warn "DEBUG: HTML Formatter - map1.size=#{map1.size}, map2.size=#{map2.size}"
-            warn "DEBUG: Mapped elements in map1: #{map1.keys.map(&:name).join(', ')}"
-            warn "DEBUG: Match types: matched=#{matches.count do |m|
-              m.status == :matched
-            end}, deleted=#{matches.count do |m|
-              m.status == :deleted
-            end}, inserted=#{matches.count do |m|
-                             m.status == :inserted
-                           end}"
-
             # Display diffs based on element matches
             result = format_element_matches(matches, map1, map2, lines1, lines2)
-            warn "DEBUG: HTML Formatter - result.length=#{result.length}"
             output << result
           rescue StandardError => e
             # Fall back to simple diff on error
@@ -271,30 +257,6 @@ module Canon
 
         private
 
-        # Check if diff display should be skipped
-        # Returns true when:
-        # 1. show_diffs is :normative AND there are no normative differences
-        # 2. show_diffs is :informative AND there are no informative differences
-        def should_skip_diff_display?
-          return false if @differences.nil? || @differences.empty?
-
-          case @show_diffs
-          when :normative
-            # Skip if no normative diffs
-            @differences.none? do |diff|
-              diff.is_a?(Canon::Diff::DiffNode) && diff.normative?
-            end
-          when :informative
-            # Skip if no informative diffs
-            @differences.none? do |diff|
-              diff.is_a?(Canon::Diff::DiffNode) && diff.informative?
-            end
-          else
-            # :all or other - never skip
-            false
-          end
-        end
-
         # Format element matches for display
         def format_element_matches(matches, map1, map2, lines1, lines2)
           output = []
@@ -321,11 +283,6 @@ module Canon
                                                 lines2, elements_to_skip,
                                                 children_of_matched_parents)
 
-          # DEBUG
-          warn "DEBUG: format_element_matches - diff_sections.length=#{diff_sections.length}"
-          warn "DEBUG: format_element_matches - elements_to_skip.size=#{elements_to_skip.size}"
-          warn "DEBUG: format_element_matches - children_of_matched_parents.size=#{children_of_matched_parents.size}"
-
           # Sort by line number
           diff_sections.sort_by! do |section|
             section[:start_line1] || section[:start_line2] || 0
@@ -335,14 +292,13 @@ module Canon
           formatted_diffs = if @diff_grouping_lines
                               groups = group_diff_sections(diff_sections,
                                                            @diff_grouping_lines)
-                              format_diff_groups(groups, lines1, lines2)
+                              format_diff_groups(groups)
                             else
                               diff_sections.map do |s|
                                 s[:formatted]
                               end.compact.join("\n\n")
                             end
 
-          warn "DEBUG: format_element_matches - formatted_diffs.length=#{formatted_diffs.length}"
           output << formatted_diffs
           output.join("\n")
         end
@@ -391,57 +347,6 @@ module Canon
           elements_to_skip
         end
 
-        # Check if an element or its children have semantic diffs
-        def has_semantic_diff_in_subtree?(element, elements_with_semantic_diffs)
-          # Check the element itself
-          return true if elements_with_semantic_diffs.include?(element)
-
-          # Check all descendants
-          if element.respond_to?(:children)
-            element.children.any? do |child|
-              has_semantic_diff_in_subtree?(child, elements_with_semantic_diffs)
-            end
-          else
-            false
-          end
-        end
-
-        # Build set of individual elements (not pairs) that have semantic diffs
-        def build_elements_with_semantic_diffs_set
-          elements = Set.new
-
-          return elements if @differences.nil? || @differences.empty?
-
-          @differences.each do |diff|
-            next unless diff.is_a?(Canon::Diff::DiffNode)
-
-            # Add both nodes if they exist
-            elements.add(diff.node1) if diff.node1
-            elements.add(diff.node2) if diff.node2
-          end
-
-          elements
-        end
-
-        # Build set of children of matched parents
-        def build_children_set(matches)
-          children = Set.new
-
-          matches.each do |match|
-            next unless match.status == :matched
-
-            [match.elem1, match.elem2].compact.each do |elem|
-              next unless elem.respond_to?(:children)
-
-              elem.children.each do |child|
-                children.add(child) if child.respond_to?(:name)
-              end
-            end
-          end
-
-          children
-        end
-
         # Collect diff sections with metadata
         def collect_diff_sections(matches, map1, map2, lines1, lines2,
                                    elements_to_skip, _children_of_matched_parents)
@@ -473,7 +378,6 @@ module Canon
               range2 = map2[match.elem2]
               if !range1 || !range2
                 no_range_count += 1
-                warn "DEBUG: No range for #{match.elem1.name} (path: #{match.path.join('/')})" if no_range_count <= 5
               end
 
               section = format_matched_element_with_metadata(match, map1,
@@ -481,7 +385,6 @@ module Canon
                                                              lines2)
               if range1 && range2 && !section
                 no_diff_count += 1
-                warn "DEBUG: No diff for #{match.elem1.name} (path: #{match.path.join('/')})" if no_diff_count <= 5
               end
               diff_sections << section if section
             when :deleted
@@ -497,67 +400,9 @@ module Canon
             end
           end
 
-          warn "DEBUG: collect_diff_sections - no_range_count=#{no_range_count}, no_diff_count=#{no_diff_count}"
           diff_sections
         end
 
-        # Format matched element with metadata
-        def format_matched_element_with_metadata(match, map1, map2, lines1,
-                                                  lines2)
-          range1 = map1[match.elem1]
-          range2 = map2[match.elem2]
-          return nil unless range1 && range2
-
-          formatted = format_matched_element(match, map1, map2, lines1,
-                                             lines2)
-          return nil unless formatted
-
-          {
-            formatted: formatted,
-            start_line1: range1.start_line,
-            end_line1: range1.end_line,
-            start_line2: range2.start_line,
-            end_line2: range2.end_line,
-            path: match.path.join("/"),
-          }
-        end
-
-        # Format deleted element with metadata
-        def format_deleted_element_with_metadata(match, map1, lines1)
-          range1 = map1[match.elem1]
-          return nil unless range1
-
-          formatted = format_deleted_element(match, map1, lines1)
-          return nil unless formatted
-
-          {
-            formatted: formatted,
-            start_line1: range1.start_line,
-            end_line1: range1.end_line,
-            start_line2: nil,
-            end_line2: nil,
-            path: match.path.join("/"),
-          }
-        end
-
-        # Format inserted element with metadata
-        def format_inserted_element_with_metadata(match, map2, lines2)
-          range2 = map2[match.elem2]
-          return nil unless range2
-
-          formatted = format_inserted_element(match, map2, lines2)
-          return nil unless formatted
-
-          {
-            formatted: formatted,
-            start_line1: nil,
-            end_line1: nil,
-            start_line2: range2.start_line,
-            end_line2: range2.end_line,
-            path: match.path.join("/"),
-          }
-        end
-
         # Format a matched element showing differences
         def format_matched_element(match, map1, map2, lines1, lines2)
           range1 = map1[match.elem1]
@@ -631,93 +476,6 @@ module Canon
 
           output.join("\n")
         end
-
-        # Group diff sections by proximity
-        def group_diff_sections(sections, grouping_lines)
-          return [] if sections.empty?
-
-          groups = []
-          current_group = [sections[0]]
-
-          sections[1..].each do |section|
-            last_section = current_group.last
-
-            # Calculate gap
-            gap1 = if last_section[:end_line1] && section[:start_line1]
-                     section[:start_line1] - last_section[:end_line1] - 1
-                   else
-                     Float::INFINITY
-                   end
-
-            gap2 = if last_section[:end_line2] && section[:start_line2]
-                     section[:start_line2] - last_section[:end_line2] - 1
-                   else
-                     Float::INFINITY
-                   end
-
-            max_gap = [gap1, gap2].max
-
-            if max_gap <= grouping_lines
-              current_group << section
-            else
-              groups << current_group
-              current_group = [section]
-            end
-          end
-
-          groups << current_group unless current_group.empty?
-          groups
-        end
-
-        # Format groups of diffs
-        def format_diff_groups(groups, _lines1, _lines2)
-          output = []
-
-          groups.each_with_index do |group, group_idx|
-            output << "" if group_idx.positive?
-
-            if group.length > 1
-              output << colorize("Context block has #{group.length} diffs",
-                                 :yellow, :bold)
-              output << ""
-              group.each do |section|
-                output << section[:formatted] if section[:formatted]
-              end
-            elsif group[0][:formatted]
-              output << group[0][:formatted]
-            end
-          end
-
-          output.join("\n")
-        end
-
-        # Check if an element or its children have semantic diffs
-        def has_semantic_diff_in_subtree?(element, elements_with_semantic_diffs)
-          return true if elements_with_semantic_diffs.include?(element)
-
-          if element.respond_to?(:children)
-            element.children.any? do |child|
-              has_semantic_diff_in_subtree?(child, elements_with_semantic_diffs)
-            end
-          else
-            false
-          end
-        end
-
-        # Build set of individual elements that have semantic diffs
-        def build_elements_with_semantic_diffs_set
-          elements = Set.new
-          return elements if @differences.nil? || @differences.empty?
-
-          @differences.each do |diff|
-            next unless diff.is_a?(Canon::Diff::DiffNode)
-
-            elements.add(diff.node1) if diff.node1
-            elements.add(diff.node2) if diff.node2
-          end
-
-          elements
-        end
       end
     end
   end

data/lib/canon/diff_formatter/by_line/xml_formatter.rb

@@ -252,30 +252,6 @@ module Canon
 
         private
 
-        # Check if diff display should be skipped
-        # Returns true when:
-        # 1. show_diffs is :normative AND there are no normative differences
-        # 2. show_diffs is :informative AND there are no informative differences
-        def should_skip_diff_display?
-          return false if @differences.nil? || @differences.empty?
-
-          case @show_diffs
-          when :normative
-            # Skip if no normative diffs
-            @differences.none? do |diff|
-              diff.is_a?(Canon::Diff::DiffNode) && diff.normative?
-            end
-          when :informative
-            # Skip if no informative diffs
-            @differences.none? do |diff|
-              diff.is_a?(Canon::Diff::DiffNode) && diff.informative?
-            end
-          else
-            # :all or other - never skip
-            false
-          end
-        end
-
         # Format element matches for display
         def format_element_matches(matches, map1, map2, lines1, lines2)
           output = []
@@ -311,7 +287,7 @@ module Canon
           formatted_diffs = if @diff_grouping_lines
                               groups = group_diff_sections(diff_sections,
                                                            @diff_grouping_lines)
-                              format_diff_groups(groups, lines1, lines2)
+                              format_diff_groups(groups)
                             else
                               diff_sections.map do |s|
                                 s[:formatted]
@@ -322,101 +298,6 @@ module Canon
           output.join("\n")
         end
 
-        # Build set of elements to skip (children with parents showing diffs)
-        def build_skip_set(matches, map1, map2, lines1, lines2)
-          elements_to_skip = Set.new
-          elements_with_diffs = Set.new
-
-          # Build set of element pairs that have semantic diffs
-          build_elements_with_semantic_diffs_set
-
-          # First pass: identify elements with line differences
-          # (semantic filtering happens in collect_diff_sections)
-          matches.each do |match|
-            next unless match.status == :matched
-
-            range1 = map1[match.elem1]
-            range2 = map2[match.elem2]
-            next unless range1 && range2
-
-            elem_lines1 = lines1[range1.start_line..range1.end_line]
-            elem_lines2 = lines2[range2.start_line..range2.end_line]
-
-            # Add if there are line diffs
-            # Semantic filtering is done in collect_diff_sections
-            if elem_lines1 != elem_lines2
-              elements_with_diffs.add(match.elem1)
-            end
-          end
-
-          # Second pass: skip children of elements with diffs
-          elements_with_diffs.each do |elem|
-            if elem.respond_to?(:parent)
-              current = elem.parent
-              while current
-                if current.respond_to?(:name) && elements_with_diffs.include?(current)
-                  elements_to_skip.add(elem)
-                  break
-                end
-                current = current.respond_to?(:parent) ? current.parent : nil
-              end
-            end
-          end
-
-          elements_to_skip
-        end
-
-        # Check if an element or its children have semantic diffs
-        def has_semantic_diff_in_subtree?(element, elements_with_semantic_diffs)
-          # Check the element itself
-          return true if elements_with_semantic_diffs.include?(element)
-
-          # Check all descendants
-          if element.respond_to?(:children)
-            element.children.any? do |child|
-              has_semantic_diff_in_subtree?(child, elements_with_semantic_diffs)
-            end
-          else
-            false
-          end
-        end
-
-        # Build set of individual elements (not pairs) that have semantic diffs
-        def build_elements_with_semantic_diffs_set
-          elements = Set.new
-
-          return elements if @differences.nil? || @differences.empty?
-
-          @differences.each do |diff|
-            next unless diff.is_a?(Canon::Diff::DiffNode)
-
-            # Add both nodes if they exist
-            elements.add(diff.node1) if diff.node1
-            elements.add(diff.node2) if diff.node2
-          end
-
-          elements
-        end
-
-        # Build set of children of matched parents
-        def build_children_set(matches)
-          children = Set.new
-
-          matches.each do |match|
-            next unless match.status == :matched
-
-            [match.elem1, match.elem2].compact.each do |elem|
-              next unless elem.respond_to?(:children)
-
-              elem.children.each do |child|
-                children.add(child) if child.respond_to?(:name)
-              end
-            end
-          end
-
-          children
-        end
-
         # Collect diff sections with metadata
         def collect_diff_sections(matches, map1, map2, lines1, lines2,
                                    elements_to_skip, children_of_matched_parents)
@@ -463,61 +344,48 @@ module Canon
           diff_sections
         end
 
-        # Format matched element with metadata
-        def format_matched_element_with_metadata(match, map1, map2, lines1,
-                                                  lines2)
-          range1 = map1[match.elem1]
-          range2 = map2[match.elem2]
-          return nil unless range1 && range2
+        # Build set of elements to skip (children with parents showing diffs)
+        def build_skip_set(matches, map1, map2, lines1, lines2)
+          elements_to_skip = Set.new
+          elements_with_diffs = Set.new
 
-          formatted = format_matched_element(match, map1, map2, lines1,
-                                             lines2)
-          return nil unless formatted
-
-          {
-            formatted: formatted,
-            start_line1: range1.start_line,
-            end_line1: range1.end_line,
-            start_line2: range2.start_line,
-            end_line2: range2.end_line,
-            path: match.path.join("/"),
-          }
-        end
+          # Build set of element pairs that have semantic diffs
+          build_elements_with_semantic_diffs_set
 
-        # Format deleted element with metadata
-        def format_deleted_element_with_metadata(match, map1, lines1)
-          range1 = map1[match.elem1]
-          return nil unless range1
+          # First pass: identify elements with line differences
+          # (semantic filtering happens in collect_diff_sections)
+          matches.each do |match|
+            next unless match.status == :matched
 
-          formatted = format_deleted_element(match, map1, lines1)
-          return nil unless formatted
-
-          {
-            formatted: formatted,
-            start_line1: range1.start_line,
-            end_line1: range1.end_line,
-            start_line2: nil,
-            end_line2: nil,
-            path: match.path.join("/"),
-          }
-        end
+            range1 = map1[match.elem1]
+            range2 = map2[match.elem2]
+            next unless range1 && range2
 
-        # Format inserted element with metadata
-        def format_inserted_element_with_metadata(match, map2, lines2)
-          range2 = map2[match.elem2]
-          return nil unless range2
+            elem_lines1 = lines1[range1.start_line..range1.end_line]
+            elem_lines2 = lines2[range2.start_line..range2.end_line]
 
-          formatted = format_inserted_element(match, map2, lines2)
-          return nil unless formatted
-
-          {
-            formatted: formatted,
-            start_line1: nil,
-            end_line1: nil,
-            start_line2: range2.start_line,
-            end_line2: range2.end_line,
-            path: match.path.join("/"),
-          }
+            # Add if there are line diffs
+            # Semantic filtering is done in collect_diff_sections
+            if elem_lines1 != elem_lines2
+              elements_with_diffs.add(match.elem1)
+            end
+          end
+
+          # Second pass: skip children of elements with diffs
+          elements_with_diffs.each do |elem|
+            if elem.respond_to?(:parent)
+              current = elem.parent
+              while current
+                if current.respond_to?(:name) && elements_with_diffs.include?(current)
+                  elements_to_skip.add(elem)
+                  break
+                end
+                current = current.respond_to?(:parent) ? current.parent : nil
+              end
+            end
+          end
+
+          elements_to_skip
         end
 
         # Format a matched element showing differences
@@ -746,65 +614,6 @@ module Canon
           output.join("\n")
         end
 
-        # Group diff sections by proximity
-        def group_diff_sections(sections, grouping_lines)
-          return [] if sections.empty?
-
-          groups = []
-          current_group = [sections[0]]
-
-          sections[1..].each do |section|
-            last_section = current_group.last
-
-            # Calculate gap
-            gap1 = if last_section[:end_line1] && section[:start_line1]
-                     section[:start_line1] - last_section[:end_line1] - 1
-                   else
-                     Float::INFINITY
-                   end
-
-            gap2 = if last_section[:end_line2] && section[:start_line2]
-                     section[:start_line2] - last_section[:end_line2] - 1
-                   else
-                     Float::INFINITY
-                   end
-
-            max_gap = [gap1, gap2].max
-
-            if max_gap <= grouping_lines
-              current_group << section
-            else
-              groups << current_group
-              current_group = [section]
-            end
-          end
-
-          groups << current_group unless current_group.empty?
-          groups
-        end
-
-        # Format groups of diffs
-        def format_diff_groups(groups, _lines1, _lines2)
-          output = []
-
-          groups.each_with_index do |group, group_idx|
-            output << "" if group_idx.positive?
-
-            if group.length > 1
-              output << colorize("Context block has #{group.length} diffs",
-                                 :yellow, :bold)
-              output << ""
-              group.each do |section|
-                output << section[:formatted] if section[:formatted]
-              end
-            elsif group[0][:formatted]
-              output << group[0][:formatted]
-            end
-          end
-
-          output.join("\n")
-        end
-
         # Format a unified diff line
         def format_unified_line(old_num, new_num, marker, content, color = nil,
 informative: false, formatting: false)

data/lib/canon/diff_formatter/diff_detail_formatter/color_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "paint"
+
+module Canon
+  class DiffFormatter
+    module DiffDetailFormatterHelpers
+      # Color helper for diff formatting
+      #
+      # Provides consistent colorization for diff output.
+      module ColorHelper
+        # Colorize text with optional bold formatting
+        #
+        # @param text [String] Text to colorize
+        # @param color [Symbol] Color name
+        # @param use_color [Boolean] Whether to use colors
+        # @param bold [Boolean] Whether to make text bold
+        # @return [String] Colorized text (or plain text if use_color is false)
+        def self.colorize(text, color, use_color, bold: false)
+          return text unless use_color
+
+          args = [color]
+          args << :bold if bold
+
+          Paint[text, *args]
+        end
+      end
+    end
+  end
+end