canon 0.1.22 → 0.2.0

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

@@ -19,8 +19,14 @@ module Canon
         #
         # @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 +37,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 +50,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 +59,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 +76,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 +92,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
@@ -120,7 +135,7 @@ module Canon
 
           # 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,

data/lib/canon/diff_formatter/theme.rb

@@ -497,22 +497,9 @@ module Canon
 
         private
 
-        # Deep dup a hash, handling nested hashes and arrays
+        # Delegate to module-level deep_dup
         def deep_dup(obj)
-          case obj
-          when Hash
-            obj.transform_values { |v| deep_dup(v) }
-          when Array
-            obj.map { |v| deep_dup(v) }
-          when String, Symbol, Numeric, TrueClass, FalseClass, NilClass
-            obj
-          else
-            begin
-              obj.dup
-            rescue StandardError
-              obj
-            end
-          end
+          Theme.deep_dup(obj)
         end
 
         def deep_merge!(target, source)
@@ -606,9 +593,29 @@ module Canon
       # @param name [Symbol] Theme name
       # @return [Hash] Theme hash
       # @raise [ArgumentError] if theme not found
+      # Deep copy a value, handling nested hashes and arrays
+      def self.deep_dup(obj)
+        case obj
+        when Hash
+          obj.transform_values { |v| deep_dup(v) }
+        when Array
+          obj.map { |v| deep_dup(v) }
+        when String, Symbol, Numeric, TrueClass, FalseClass, NilClass
+          obj
+        else
+          begin
+            obj.dup
+          rescue StandardError
+            obj
+          end
+        end
+      end
+
       def self.[](name)
-        THEMES[name] || raise(ArgumentError,
-                              "Unknown theme: #{name}. Valid: #{THEMES.keys}")
+        theme = THEMES[name] || raise(ArgumentError,
+                                      "Unknown theme: #{name}. Valid: #{THEMES.keys}")
+        # Return a deep copy to prevent mutation of theme constants
+        deep_dup(theme)
       end
 
       # List available theme names