canon 0.1.23 → 0.2.1

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

@@ -11,8 +11,10 @@ module Canon
         #
         # @param diff [DiffNode, Hash] Difference node
         # @param use_color [Boolean] Whether to use colors
+        # @param compact [Boolean] Whether to serialize element nodes as compact XML
         # @return [String] Formatted dimension details
-        def self.format_dimension_details(diff, use_color)
+        def self.format_dimension_details(diff, use_color, compact: false,
+expand_difference: false)
           dimension = extract_dimension(diff)
 
           case dimension
@@ -21,7 +23,8 @@ module Canon
           when :namespace_declarations
             format_namespace_declarations_details(diff, use_color)
           when :element_structure
-            format_element_structure_details(diff, use_color)
+            format_element_structure_details(diff, use_color,
+                                             expand_difference: expand_difference)
           when :attribute_presence
             format_attribute_presence_details(diff, use_color)
           when :attribute_values
@@ -29,7 +32,7 @@ module Canon
           when :attribute_order
             format_attribute_order_details(diff, use_color)
           when :text_content
-            format_text_content_details(diff, use_color)
+            format_text_content_details(diff, use_color, compact: compact)
           when :structural_whitespace
             format_structural_whitespace_details(diff, use_color)
           when :comments
@@ -37,7 +40,7 @@ module Canon
           when :hash_diff
             format_hash_diff_details(diff, use_color)
           else
-            format_fallback_details(diff, use_color)
+            format_fallback_details(diff, use_color, compact: compact)
           end
         end
 
@@ -163,7 +166,8 @@ module Canon
         # @param diff [DiffNode, Hash] Difference node
         # @param use_color [Boolean] Whether to use colors
         # @return [Array] Tuple of [detail1, detail2, changes]
-        def self.format_element_structure_details(diff, use_color)
+        def self.format_element_structure_details(diff, use_color,
+expand_difference: false)
           require_relative "color_helper"
           require_relative "node_utils"
 
@@ -173,8 +177,15 @@ module Canon
           name1 = NodeUtils.get_element_name_for_display(node1)
           name2 = NodeUtils.get_element_name_for_display(node2)
 
-          detail1 = "<#{ColorHelper.colorize(name1, :red, use_color)}>"
-          detail2 = "<#{ColorHelper.colorize(name2, :green, use_color)}>"
+          if expand_difference
+            display1 = NodeUtils.serialize_node_compact(node1)
+            display2 = NodeUtils.serialize_node_compact(node2)
+            detail1 = ColorHelper.colorize(display1, :red, use_color)
+            detail2 = ColorHelper.colorize(display2, :green, use_color)
+          else
+            detail1 = "<#{ColorHelper.colorize(name1, :red, use_color)}>"
+            detail2 = "<#{ColorHelper.colorize(name2, :green, use_color)}>"
+          end
 
           changes = "Element differs: #{ColorHelper.colorize(name1, :red,
                                                              use_color)} → " \
@@ -311,8 +322,9 @@ module Canon
         #
         # @param diff [DiffNode, Hash] Difference node
         # @param use_color [Boolean] Whether to use colors
+        # @param compact [Boolean] Whether to serialize element nodes as compact XML
         # @return [Array] Tuple of [detail1, detail2, changes]
-        def self.format_text_content_details(diff, use_color)
+        def self.format_text_content_details(diff, use_color, compact: false)
           require_relative "color_helper"
           require_relative "node_utils"
           require_relative "text_utils"
@@ -320,15 +332,15 @@ module Canon
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
-          text1 = NodeUtils.get_node_text(node1)
-          text2 = NodeUtils.get_node_text(node2)
+          text1 = NodeUtils.node_to_display(node1, compact: compact)
+          text2 = NodeUtils.node_to_display(node2, compact: compact)
 
           # Handle cases where one node is missing (e.g. text added or removed)
           if node1.nil? || node2.nil?
             if node1.nil?
-              text2 = NodeUtils.get_node_text(node2)
+              text2 = NodeUtils.node_to_display(node2, compact: compact)
             else
-              text1 = NodeUtils.get_node_text(node1)
+              text1 = NodeUtils.node_to_display(node1, compact: compact)
             end
           end
 
@@ -339,6 +351,13 @@ module Canon
             detail2 = ColorHelper.colorize(
               TextUtils.visualize_whitespace(text2), :green, use_color
             )
+          elsif compact && (node1.is_a?(Canon::Xml::Nodes::ElementNode) ||
+                           node2.is_a?(Canon::Xml::Nodes::ElementNode))
+            # In compact mode with element nodes, display as raw XML without
+            # JSON-string quoting.  In normal mode (or for plain text), apply
+            # the standard escaping/quoting logic.
+            detail1 = ColorHelper.colorize(text1, :red, use_color)
+            detail2 = ColorHelper.colorize(text2, :green, use_color)
           else
             # Escape non-ASCII characters for better terminal display
             # JSON.generate doesn't escape chars like NBSP (U+00A0) or em-dash (U+2014)
@@ -453,18 +472,30 @@ module Canon
         #
         # @param diff [DiffNode, Hash] Difference node
         # @param use_color [Boolean] Whether to use colors
+        # @param compact [Boolean] Whether to serialize element nodes as compact XML
         # @return [Array] Tuple of [detail1, detail2, changes]
-        def self.format_fallback_details(diff, use_color)
+        def self.format_fallback_details(diff, use_color, compact: false)
           require_relative "color_helper"
           require_relative "node_utils"
 
           node1 = extract_node1(diff)
           node2 = extract_node2(diff)
 
-          detail1 = ColorHelper.colorize(NodeUtils.format_node_brief(node1),
-                                         :red, use_color)
-          detail2 = ColorHelper.colorize(NodeUtils.format_node_brief(node2),
-                                         :green, use_color)
+          raw1 = if compact
+                   NodeUtils.node_to_display(node1,
+                                             compact: true)
+                 else
+                   NodeUtils.format_node_brief(node1)
+                 end
+          raw2 = if compact
+                   NodeUtils.node_to_display(node2,
+                                             compact: true)
+                 else
+                   NodeUtils.format_node_brief(node2)
+                 end
+
+          detail1 = ColorHelper.colorize(raw1, :red, use_color)
+          detail2 = ColorHelper.colorize(raw2, :green, use_color)
 
           dimension = extract_dimension(diff)
           changes = "#{dimension.to_s.capitalize} differs: #{detail1} → #{detail2}"

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

@@ -260,6 +260,64 @@ module Canon
           end
         end
 
+        # Serialize a Canon Xml node tree as compact XML for display.
+        #
+        # Produces a human-readable inline XML string without namespace
+        # declarations and without indentation — suitable for use in Semantic
+        # Diff Report entries.  Only handles Canon::Xml::Nodes types; for any
+        # other node (Nokogiri, etc.) falls back to +get_node_text+.
+        #
+        # @param node [Object] Node to serialize
+        # @return [String] Compact XML string
+        def self.serialize_node_compact(node)
+          require "cgi"
+          return "" unless node
+
+          case node
+          when Canon::Xml::Nodes::TextNode
+            CGI.escapeHTML(node.value.to_s)
+          when Canon::Xml::Nodes::ElementNode
+            tag = node.name.to_s
+            attrs = node.attribute_nodes.map do |attr|
+              attr_name  = attr.respond_to?(:name)  ? attr.name.to_s  : attr.to_s
+              attr_value = attr.respond_to?(:value) ? attr.value.to_s : ""
+              " #{attr_name}=\"#{CGI.escapeHTML(attr_value)}\""
+            end.join
+            children_xml = node.children.map do |c|
+              serialize_node_compact(c)
+            end.join
+            if children_xml.empty?
+              "<#{tag}#{attrs}/>"
+            else
+              "<#{tag}#{attrs}>#{children_xml}</#{tag}>"
+            end
+          when Canon::Xml::Nodes::CommentNode
+            text = node.respond_to?(:value) ? node.value.to_s : ""
+            "<!--#{CGI.escapeHTML(text)}-->"
+          else
+            # Nokogiri nodes or other unknown types — fall back to text extraction
+            get_node_text(node)
+          end
+        end
+
+        # Return the best display string for a node.
+        #
+        # When +compact: true+ and the node is a Canon ElementNode, returns a
+        # compact XML serialization (e.g. +<strong>Annex</strong>+) instead of
+        # the +node_info+ description string that +get_node_text+ would produce.
+        # In all other cases, delegates to +get_node_text+.
+        #
+        # @param node [Object] Node to display
+        # @param compact [Boolean] Whether to use compact XML for element nodes
+        # @return [String] Display string
+        def self.node_to_display(node, compact: false)
+          if compact && node.is_a?(Canon::Xml::Nodes::ElementNode)
+            serialize_node_compact(node)
+          else
+            get_node_text(node)
+          end
+        end
+
         # Check if node is inside a preserve-whitespace element
         #
         # @param node [Object] Node to check

data/lib/canon/diff_formatter/diff_detail_formatter.rb

@@ -14,13 +14,22 @@ module Canon
     # Formats dimension-specific detail for individual differences
     # Provides actionable, colorized output showing exactly what changed
     module DiffDetailFormatter
+      ANSI_ESCAPE = /\e\[[0-9;]*m/
+      COMPACT_DETAIL_MAX = 30
+
       class << self
         # Format all differences as a semantic diff report
         #
         # @param differences [Array<DiffNode>] Array of differences
         # @param use_color [Boolean] Whether to use colors
+        # @param show_diffs [Symbol] Filter: :all (default), :normative, :informative
+        # @param compact_semantic_report [Boolean] When true, serialize element nodes
+        #   as compact XML (e.g. <strong>Annex</strong>) instead of the verbose
+        #   node_info description (e.g. "name: strong namespace_uri: …")
         # @return [String] Formatted semantic diff report
-        def format_report(differences, use_color: true)
+        def format_report(differences, use_color: true, show_diffs: :all,
+                          compact_semantic_report: false,
+                          expand_difference: false)
           return "" if differences.empty?
 
           # Group differences by normative status
@@ -31,6 +40,10 @@ module Canon
             diff.respond_to?(:normative?) && !diff.normative?
           end
 
+          # Apply show_diffs filter — same semantics as the line-diff filter
+          show_normative   = show_diffs != :informative
+          show_informative = show_diffs != :normative
+
           output = []
           output << ""
           output << colorize("=" * 70, :cyan, use_color, bold: true)
@@ -40,7 +53,7 @@ module Canon
           output << colorize("=" * 70, :cyan, use_color, bold: true)
 
           # Show normative differences first
-          if normative.any?
+          if normative.any? && show_normative
             output << ""
             output << colorize(
               "┌─ NORMATIVE DIFFERENCES (#{normative.length}) ─┐", :green, use_color, bold: true
@@ -49,12 +62,14 @@ module Canon
             normative.each_with_index do |diff, i|
               output << ""
               output << format_single_diff(diff, i + 1, normative.length,
-                                           use_color, section: "NORMATIVE")
+                                           use_color, section: "NORMATIVE",
+                                                      compact: compact_semantic_report,
+                                                      expand_difference: expand_difference)
             end
           end
 
           # Show informative differences second
-          if informative.any?
+          if informative.any? && show_informative
             output << ""
             output << ""
             output << colorize(
@@ -64,7 +79,9 @@ module Canon
             informative.each_with_index do |diff, i|
               output << ""
               output << format_single_diff(diff, i + 1, informative.length,
-                                           use_color, section: "INFORMATIVE")
+                                           use_color, section: "INFORMATIVE",
+                                                      compact: compact_semantic_report,
+                                                      expand_difference: expand_difference)
             end
           end
 
@@ -78,7 +95,8 @@ module Canon
         private
 
         # Format a single difference with dimension-specific details
-        def format_single_diff(diff, number, total, use_color, section: nil)
+        def format_single_diff(diff, number, total, use_color, section: nil,
+compact: false, expand_difference: false)
           output = []
 
           # Header - handle both DiffNode and Hash
@@ -112,24 +130,16 @@ module Canon
 
           # show reason if available
           if diff.respond_to?(:reason) && diff.reason
-            output << "#{colorize('Reason:', :cyan, use_color,
-                                  bold: true)}  #{colorize(diff.reason,
-                                                           :yellow, use_color)}"
+            format_reason_line(output, diff.reason, use_color)
           end
           output << ""
 
           # Dimension-specific details
           detail1, detail2, changes = DiffDetailFormatterHelpers::DimensionFormatter.format_dimension_details(
-            diff, use_color
+            diff, use_color, compact: compact, expand_difference: expand_difference
           )
 
-          output << colorize("⊖ Expected (File 1):", :red, use_color,
-                             bold: true)
-          output << "   #{detail1}"
-          output << ""
-          output << colorize("⊕ Actual (File 2):", :green, use_color,
-                             bold: true)
-          output << "   #{detail2}"
+          format_expected_actual(output, detail1, detail2, use_color)
 
           if changes && !changes.empty?
             output << ""
@@ -167,6 +177,52 @@ module Canon
           colorize(error_msg, :red, use_color, bold: true)
         end
 
+        # Format the Reason line. When the reason contains visualized
+        # spaces (░), split into two vertically-aligned lines so the
+        # before/after text can be compared visually.
+        def format_reason_line(output, reason_text, use_color)
+          if reason_text.include?("\u2591") &&
+              reason_text.match?(/\A(Text|whitespace): .*\bvs\b/)
+            parts = reason_text.split(" vs ", 2)
+            if parts.length == 2
+              output << "#{colorize('Reason:', :cyan, use_color,
+                                    bold: true)}  #{colorize(parts[0],
+                                                             :yellow, use_color)}"
+              output << "#{' ' * 10}#{colorize("vs.: #{parts[1]}",
+                                               :yellow, use_color)}"
+              return
+            end
+          end
+          output << "#{colorize('Reason:', :cyan, use_color,
+                                bold: true)}  #{colorize(reason_text,
+                                                         :yellow, use_color)}"
+        end
+
+        # Format the Expected/Actual block. Short values (both under 30
+        # chars) are rendered as compact single lines with aligned colons;
+        # longer values use the multi-line layout without a blank line gap.
+        def format_expected_actual(output, detail1, detail2, use_color)
+          plain1 = detail1.gsub(ANSI_ESCAPE, "")
+          plain2 = detail2.gsub(ANSI_ESCAPE, "")
+
+          if plain1.length < COMPACT_DETAIL_MAX &&
+              plain2.length < COMPACT_DETAIL_MAX
+            lbl1 = colorize("\u2296 Expected (File 1)", :red, use_color,
+                            bold: true)
+            lbl2 = colorize("\u2295 Actual (File 2)  ", :green, use_color,
+                            bold: true)
+            output << "#{lbl1}: #{detail1}"
+            output << "#{lbl2}: #{detail2}"
+          else
+            output << colorize("\u2296 Expected (File 1):", :red, use_color,
+                               bold: true)
+            output << "   #{detail1}"
+            output << colorize("\u2295 Actual (File 2):", :green, use_color,
+                               bold: true)
+            output << "   #{detail2}"
+          end
+        end
+
         # Helper: Colorize text
         def colorize(text, color, use_color, bold: false)
           DiffDetailFormatterHelpers::ColorHelper.colorize(text, color,