canon 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24f79ae4b9b6817104e388a5bef96d24677f797db5d13bd6f009a26a04170137
-  data.tar.gz: 3b8260af8e2157f2f449421b3d40649521ba64495a15f7667e64c3e343b6d3b7
+  metadata.gz: 4f9d0e9c0c1bc9f213d837f480d3d9a26ce11505691ff48b63907e7a4abd530e
+  data.tar.gz: aa591a7682cede5f23a8dcb8b8eb8f7616d849bc5f9cad1aa2038463ee9c52b0
 SHA512:
-  metadata.gz: 971daa53fd96c5c46b5c37c2175f12875e7e36f658cc4186848f1df90ab3db9ceff06af69320e5004d1da1d6b2dc4b35d800c5aca1b1522ac05cf14c73025c21
-  data.tar.gz: 02f5160a42bf651db2a252909966cbc7dea43239cbbae2a53d155c55c4e09709eddc34e599496bfc5cda14705931f24efbebd267b9acc8700b834fb859d8096f
+  metadata.gz: 6c0af5461fff1d1cd1347ba57681bc671cda71d55d62efd328ac9424ef10b8329ec877ccf43f9ff78e83a54ca03df1026e160b259396caac7bd2704227ef01b1
+  data.tar.gz: 8803713442225ae16c0c6c9c03c9cff55dd27dc6b96f5254ee5f814a29b7ad7b5ef6eafd0cd6a58d17f070a2609154476215147d595a01a69586ca7de8608a7f

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-01-20 02:18:38 UTC using RuboCop version 1.81.7.
+# on 2026-01-21 01:26:28 UTC using RuboCop version 1.81.7.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -12,70 +12,51 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'canon.gemspec'
 
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyleAlignWith.
-# SupportedStylesAlignWith: either, start_of_block, start_of_line
-Layout/BlockAlignment:
-  Exclude:
-    - 'spec/canon/rspec_matchers_spec.rb'
-
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-Layout/BlockEndNewline:
-  Exclude:
-    - 'spec/canon/rspec_matchers_spec.rb'
-
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: AllowForAlignment.
-Layout/CommentIndentation:
-  Exclude:
-    - 'lib/canon/comparison/xml_comparator.rb'
-
-# Offense count: 1
+# Offense count: 16
 # This cop supports safe autocorrection (--autocorrect).
-Layout/ElseAlignment:
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: with_first_argument, with_fixed_indentation
+Layout/ArgumentAlignment:
   Exclude:
     - 'lib/canon/comparison/xml_comparator.rb'
+    - 'lib/canon/diff/xml_serialization_formatter.rb'
+    - 'spec/canon/diff/xml_serialization_formatter_spec.rb'
 
 # Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyleAlignWith, Severity.
-# SupportedStylesAlignWith: keyword, variable, start_of_line
-Layout/EndAlignment:
+# Configuration parameters: AllowMultipleStyles, EnforcedHashRocketStyle, EnforcedColonStyle, EnforcedLastArgumentHashStyle.
+# SupportedHashRocketStyles: key, separator, table
+# SupportedColonStyles: key, separator, table
+# SupportedLastArgumentHashStyles: always_inspect, always_ignore, ignore_implicit, ignore_explicit
+Layout/HashAlignment:
   Exclude:
-    - 'lib/canon/comparison/xml_comparator.rb'
+    - 'test_verify_equivalent.rb'
 
-# Offense count: 1
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: normal, indented_internal_methods
-Layout/IndentationConsistency:
-  Exclude:
-    - 'lib/canon/comparison/xml_comparator.rb'
-
-# Offense count: 4
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: Width, AllowedPatterns.
-Layout/IndentationWidth:
-  Exclude:
-    - 'spec/canon/rspec_matchers_spec.rb'
-
-# Offense count: 655
+# Offense count: 709
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, IgnoreCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 3
+# Offense count: 4
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyle, IndentationWidth.
 # SupportedStyles: aligned, indented
 Layout/MultilineOperationIndentation:
   Exclude:
     - 'lib/canon/diff/diff_classifier.rb'
+    - 'lib/canon/diff/xml_serialization_formatter.rb'
+
+# Offense count: 17
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowInHeredoc.
+Layout/TrailingWhitespace:
+  Exclude:
+    - 'lib/canon/comparison/xml_comparator.rb'
+    - 'lib/canon/diff/xml_serialization_formatter.rb'
+    - 'spec/canon/diff/xml_serialization_formatter_spec.rb'
+    - 'test_verify_equivalent.rb'
 
 # Offense count: 48
 # Configuration parameters: IgnoreLiteralBranches, IgnoreConstantBranches, IgnoreDuplicateElseBranch.
@@ -117,7 +98,7 @@ Lint/UnusedMethodArgument:
     - 'lib/canon/diff_formatter/by_line/xml_formatter.rb'
     - 'lib/canon/diff_formatter/by_object/base_formatter.rb'
 
-# Offense count: 194
+# Offense count: 207
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -128,12 +109,12 @@ Metrics/AbcSize:
 Metrics/BlockLength:
   Max: 84
 
-# Offense count: 164
+# Offense count: 176
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 346
+# Offense count: 360
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 110
@@ -143,7 +124,7 @@ Metrics/MethodLength:
 Metrics/ParameterLists:
   Max: 9
 
-# Offense count: 131
+# Offense count: 142
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
@@ -167,13 +148,15 @@ Naming/PredicatePrefix:
   Exclude:
     - 'lib/canon/comparison/html_comparator.rb'
 
-# Offense count: 2
+# Offense count: 6
 # Configuration parameters: EnforcedStyle, CheckMethodNames, CheckSymbols, AllowedIdentifiers, AllowedPatterns.
 # SupportedStyles: snake_case, normalcase, non_integer
 # AllowedIdentifiers: TLS1_1, TLS1_2, capture3, iso8601, rfc1123_date, rfc822, rfc2822, rfc3339, x86_64
 Naming/VariableNumber:
   Exclude:
     - 'lib/canon/comparison/json_comparator.rb'
+    - 'lib/canon/comparison/markup_comparator.rb'
+    - 'lib/canon/comparison/xml_comparator/diff_node_builder.rb'
 
 # Offense count: 2
 # Configuration parameters: MinSize.
@@ -199,7 +182,7 @@ RSpec/DescribeMethod:
     - 'spec/canon/comparison/multiple_differences_spec.rb'
     - 'spec/canon/diff_formatter/character_map_customization_spec.rb'
 
-# Offense count: 663
+# Offense count: 675
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 67
@@ -250,7 +233,7 @@ RSpec/MultipleDescribes:
   Exclude:
     - 'spec/canon/comparison/match_options_spec.rb'
 
-# Offense count: 515
+# Offense count: 518
 RSpec/MultipleExpectations:
   Max: 15
 
@@ -296,26 +279,16 @@ RSpec/SpecFilePathFormat:
     - 'spec/canon/yaml/formatter_spec.rb'
     - 'spec/xml_c14n_spec.rb'
 
-# Offense count: 95
+# Offense count: 120
 # Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
 RSpec/VerifiedDoubles:
   Exclude:
     - 'spec/canon/comparison/whitespace_sensitivity_spec.rb'
     - 'spec/canon/diff/diff_classifier_spec.rb'
     - 'spec/canon/diff/path_builder_spec.rb'
+    - 'spec/canon/diff/xml_serialization_formatter_spec.rb'
     - 'spec/canon/tree_diff/operation_converter_spec.rb'
 
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, ProceduralMethods, FunctionalMethods, AllowedMethods, AllowedPatterns, AllowBracesOnProceduralOneLiners, BracesRequiredMethods.
-# SupportedStyles: line_count_based, semantic, braces_for_chaining, always_braces
-# ProceduralMethods: benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
-# FunctionalMethods: let, let!, subject, watch
-# AllowedMethods: lambda, proc, it
-Style/BlockDelimiters:
-  Exclude:
-    - 'spec/canon/rspec_matchers_spec.rb'
-
 # Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyle, AllowComments.
@@ -331,14 +304,21 @@ Style/HashLikeCase:
     - 'lib/canon/diff/diff_block_builder.rb'
     - 'lib/canon/xml/character_encoder.rb'
 
-# Offense count: 6
+# Offense count: 4
 # This cop supports unsafe autocorrection (--autocorrect-all).
 Style/IdenticalConditionalBranches:
   Exclude:
-    - 'lib/canon/comparison/xml_comparator.rb'
     - 'lib/canon/diff_formatter/by_object/base_formatter.rb'
     - 'lib/canon/diff_formatter/legend.rb'
 
+# Offense count: 2
+# This cop supports unsafe autocorrection (--autocorrect-all).
+# Configuration parameters: InverseMethods, InverseBlocks.
+Style/InverseMethods:
+  Exclude:
+    - 'lib/canon/comparison/markup_comparator.rb'
+    - 'lib/canon/comparison/xml_comparator/diff_node_builder.rb'
+
 # Offense count: 1
 # Configuration parameters: AllowedMethods.
 # AllowedMethods: respond_to_missing?
@@ -346,26 +326,20 @@ Style/OptionalBooleanParameter:
   Exclude:
     - 'lib/canon/diff_formatter/debug_output.rb'
 
-# Offense count: 6
+# Offense count: 3
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyle, ConsistentQuotesInMultiline.
 # SupportedStyles: single_quotes, double_quotes
 Style/StringLiterals:
   Exclude:
-    - 'spec/canon/rspec_matchers_spec.rb'
+    - 'lib/canon/comparison/markup_comparator.rb'
+    - 'lib/canon/comparison/xml_comparator/diff_node_builder.rb'
+    - 'test_verify_equivalent.rb'
 
-# Offense count: 5
+# Offense count: 12
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyleForMultiline.
 # SupportedStylesForMultiline: comma, consistent_comma, diff_comma, no_comma
 Style/TrailingCommaInArguments:
   Exclude:
-    - 'spec/canon/rspec_matchers_spec.rb'
-
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyleForMultiline.
-# SupportedStylesForMultiline: comma, consistent_comma, diff_comma, no_comma
-Style/TrailingCommaInHashLiteral:
-  Exclude:
-    - 'spec/canon/rspec_matchers_spec.rb'
+    - 'spec/canon/diff/xml_serialization_formatter_spec.rb'

data/docs/advanced/diff-classification.adoc

@@ -80,14 +80,20 @@ Classification depends on `attribute_order` setting:
 │                                                                   │
 │ DiffClassifier examines each DiffNode:                           │
 │                                                                   │
-│ For each dimension:                                               │
-│   behavior = match_options.behavior_for(dimension)                │
+│ 1. Serialization-level formatting (XmlSerializationFormatter)    │
+│    → XML syntax differences: <tag/> vs <tag></tag>               │
+│    → ALWAYS formatting-only (non-normative)                      │
 │                                                                   │
-│   if behavior == :ignore                                          │
-│     → INFORMATIVE (difference doesn't matter)                     │
-│   else  # :strict or :normalize                                   │
-│     → NORMATIVE (difference matters)                              │
+│ 2. Content-level formatting (text_content: :normalize)           │
+│    → Whitespace differences in content                           │
+│    → Formatting-only when normalized content matches             │
 │                                                                   │
+│ 3. CompareProfile policy (normative vs informative)              │
+│    → behavior == :ignore → INFORMATIVE                           │
+│    → behavior == :strict → NORMATIVE                             │
+│    → behavior == :normalize → Check content normalization        │
+│                                                                   │
+│ Sets diff_node.formatting = true/false                           │
 │ Sets diff_node.normative = true/false                            │
 └───────────────────────────────────┬───────────────────────────────┘
                                     ↓
@@ -102,6 +108,27 @@ Classification depends on `attribute_order` setting:
 └──────────────────────────────────────────────────────────────────┘
 ----
 
+=== Three-Level Classification System
+
+Canon distinguishes between **three distinct kinds of differences**:
+
+| Kind | `formatting:` | `normative:` | Meaning | Examples |
+|------|---------------|--------------|---------|----------|
+| **Serialization formatting** | `true` | `false` | XML syntax differences | `<tag/>` vs `<tag></tag>` |
+| **Content formatting** | `true` | `false` | Whitespace in content | `Hello  world` vs `Hello world` |
+| **Informative** | `false` | `false` | Tracked but doesn't affect equivalence | Attribute order (when `:ignore`) |
+| **Normative** | `false` | `true` | Affects equivalence | Different words, missing elements |
+
+**Key distinction**:
+
+* **Serialization-level formatting**: XML syntax differences that are ALWAYS non-normative regardless of match options, because they represent different valid serializations of the same semantic content. Detected by `XmlSerializationFormatter`.
+
+* **Content-level formatting**: Whitespace differences in document content. These are formatting-only (non-normative) when normalized content matches (using `text_content: :normalize`).
+
+* **Informative**: Differences tracked for reference but don't affect equivalence (when behavior is `:ignore`).
+
+* **Normative**: Semantic content differences that affect equivalence (when behavior is `:strict` or when normalized content differs).
+
 == CompareProfile-Based Classification
 
 === Overview
@@ -120,22 +147,42 @@ DiffNode → DiffClassifier → CompareProfile → normative?
 
 === Classification Hierarchy
 
-Canon uses a three-level hierarchy for classifying differences:
+Canon uses a **multi-level hierarchy** for classifying differences:
 
-1. **Formatting-only** (lowest priority)
-   - Pure whitespace/formatting differences
-   - Normalized content is identical
-   - Markers: `[` and `]` in diff output
+[source]
+----
+DiffNode → DiffClassifier → XmlSerializationFormatter → serialization formatting?
+                                       ↓
+                                  CompareProfile → normative dimension?
+                                       ↓
+                                  FormattingDetector → formatting-only?
+                                       ↓
+                                  Final classification
+----
+
+**Classification priority (from highest to lowest specificity)**:
+
+1. **Serialization-level formatting** (highest priority)
+   - XML syntax differences: `<tag/>` vs `<tag></tag>`
+   - Detected by `XmlSerializationFormatter`
+   - **ALWAYS** `formatting: true, normative: false`
+   - Bypasses all other classification logic
 
-2. **Informative** (medium priority)
+2. **Content-level formatting**
+   - Whitespace differences in document content
+   - Detected by `FormattingDetector` when `text_content: :normalize`
+   - `formatting: true, normative: false` when normalized content matches
+   - Respects element-level whitespace sensitivity
+
+3. **Informative** (based on `:ignore` behavior)
    - Tracked but doesn't affect equivalence
-   - Based on behavior `:ignore`
-   - Markers: `<` and `>` in diff output
+   - `formatting: false, normative: false`
+   - Example: Attribute order when `attribute_order: :ignore`
 
-3. **Normative** (highest priority)
+4. **Normative** (based on `:strict` behavior or content mismatch)
    - Affects equivalence
-   - Based on behavior `:strict`
-   - Markers: `-` and `+` in diff output
+   - `formatting: false, normative: true`
+   - Example: Different words, missing elements
 
 === Format-Specific Policies
 
@@ -292,6 +339,34 @@ Canon::Comparison.equivalent?(html1, html2, format: :html)
 ----
 ====
 
+.Self-closing vs explicit closing tags
+====
+Per XML standards, `<tag/>` and `<tag></tag>` are semantically equivalent (both represent empty elements). Canon classifies differences in serialisation format as **formatting-only** (non-normative):
+
+[source,ruby]
+----
+# Self-closing vs explicit closing - always equivalent
+xml1 = '<svg><rect x="10" y="10"/></svg>'
+xml2 = '<svg><rect x="10" y="10"></rect></svg>'
+
+Canon::Comparison.equivalent?(xml1, xml2, format: :xml)
+# => true
+
+# Empty/whitespace-only text nodes from serialisation are formatting-only
+result = Canon::Comparison.equivalent?(xml1, xml2, format: :xml, verbose: true)
+result.differences.each do |diff|
+  if diff.dimension == :text_content
+    puts "Normative: #{diff.normative?}"  # => false
+    puts "Formatting: #{diff.formatting?}"  # => true
+  end
+end
+----
+
+This applies regardless of `text_content` behavior setting, as these differences are purely serialisation format variations (similar to attribute order).
+
+The key insight: empty or whitespace-only text nodes created by different serialisation styles (`<tag/>` vs `<tag></tag>`) are always classified as **formatting-only**, not normative.
+====
+
 === FormattingDetector Integration
 
 For dimensions that support it (`:text_content`, `:structural_whitespace`),
@@ -319,19 +394,35 @@ With `:normalize` mode:
 
 === Implementation Details
 
-The [`CompareProfile`](../../lib/canon/comparison/compare_profile.rb) class provides:
+The classification system uses three main classes:
 
-* `normative_dimension?(dimension)` - Is this dimension normative?
-* `affects_equivalence?(dimension)` - Does this dimension affect equivalence?
-* `supports_formatting_detection?(dimension)` - Can this dimension have formatting-only diffs?
+* **`XmlSerializationFormatter`** - Detects XML serialization-level formatting differences
+  - Self-closing vs explicit closing tags: `<tag/>` vs `<tag></tag>`
+  - Always returns `formatting: true, normative: false`
+  - These differences are ALWAYS non-normative regardless of match options
 
-The [`DiffClassifier`](../../lib/canon/diff/diff_classifier.rb) uses CompareProfile to classify differences, with special handling for `text_content: :normalize`:
+* **`CompareProfile`** - Determines dimension behavior and policy
+  - `normative_dimension?(dimension)` - Is this dimension normative?
+  - `affects_equivalence?(dimension)` - Does this dimension affect equivalence?
+  - `supports_formatting_detection?(dimension)` - Can this dimension have formatting-only diffs?
+
+* **`DiffClassifier`** - Orchestrates classification using the above
+  - First checks `XmlSerializationFormatter` for serialization formatting
+  - Then handles content-level formatting (text_content: :normalize)
+  - Finally applies `CompareProfile` policy for normative vs informative
 
 [source,ruby]
 ----
 def classify(diff_node)
-  # SPECIAL CASE: text_content with :normalize behavior
-  # Formatting-only differences (whitespace-only) are marked as non-normative
+  # FIRST: Check for XML serialization-level formatting differences
+  # These are ALWAYS non-normative (formatting-only) regardless of match options
+  if XmlSerializationFormatter.serialization_formatting?(diff_node)
+    diff_node.formatting = true
+    diff_node.normative = false
+    return diff_node
+  end
+
+  # SECOND: Handle content-level formatting for text_content with :normalize
   if diff_node.dimension == :text_content &&
       profile.send(:behavior_for, :text_content) == :normalize &&
       !inside_whitespace_sensitive_element?(diff_node) &&
@@ -341,10 +432,10 @@ def classify(diff_node)
     return diff_node
   end
 
-  # Standard classification flow
+  # THIRD: Apply CompareProfile policy
   is_normative = profile.normative_dimension?(diff_node.dimension)
 
-  # Only check formatting for non-normative dimensions
+  # FOURTH: Check FormattingDetector for non-normative dimensions
   if !is_normative && profile.supports_formatting_detection?(diff_node.dimension)
     if formatting_only_diff?(diff_node)
       diff_node.formatting = true
@@ -353,6 +444,7 @@ def classify(diff_node)
     end
   end
 
+  # FIFTH: Apply normative determination
   diff_node.normative = is_normative
   diff_node
 end

data/lib/canon/comparison/markup_comparator.rb

@@ -239,9 +239,116 @@ module Canon
         # @param diff2 [Symbol] Difference type for node2
         # @param dimension [Symbol] The dimension of the difference
         # @return [String] Human-readable reason
-        def build_difference_reason(_node1, _node2, diff1, diff2, dimension)
+        def build_difference_reason(node1, node2, diff1, diff2, dimension)
+          # For attribute presence differences, show what attributes differ
+          if dimension == :attribute_presence
+            attrs1 = extract_attributes(node1)
+            attrs2 = extract_attributes(node2)
+            return build_attribute_difference_reason(attrs1, attrs2)
+          end
+
+          # For text content differences, show the actual text (truncated if needed)
+          if dimension == :text_content
+            text1 = extract_text_content_from_node(node1)
+            text2 = extract_text_content_from_node(node2)
+            return build_text_difference_reason(text1, text2)
+          end
+
           # Default reason - can be overridden in subclasses
-          "Difference in #{dimension}: #{diff1} vs #{diff2}"
+          "#{diff1} vs #{diff2}"
+        end
+
+        # Build a clear reason message for attribute presence differences
+        # Shows which attributes are only in node1, only in node2, or different values
+        #
+        # @param attrs1 [Hash, nil] First node's attributes
+        # @param attrs2 [Hash, nil] Second node's attributes
+        # @return [String] Clear explanation of the attribute difference
+        def build_attribute_difference_reason(attrs1, attrs2)
+          return "#{attrs1&.keys&.size || 0} vs #{attrs2&.keys&.size || 0} attributes" unless attrs1 && attrs2
+
+          require "set"
+          keys1 = attrs1.keys.to_set
+          keys2 = attrs2.keys.to_set
+
+          only_in_1 = keys1 - keys2
+          only_in_2 = keys2 - keys1
+          common = keys1 & keys2
+
+          # Check if values differ for common keys
+          different_values = common.reject { |k| attrs1[k] == attrs2[k] }
+
+          parts = []
+          parts << "only in first: #{only_in_1.to_a.sort.join(', ')}" if only_in_1.any?
+          parts << "only in second: #{only_in_2.to_a.sort.join(', ')}" if only_in_2.any?
+          parts << "different values: #{different_values.sort.join(', ')}" if different_values.any?
+
+          if parts.empty?
+            "#{keys1.size} vs #{keys2.size} attributes (same names)"
+          else
+            parts.join("; ")
+          end
+        end
+
+        # Extract text content from a node for diff reason
+        #
+        # @param node [Object, nil] Node to extract text from
+        # @return [String, nil] Text content or nil
+        def extract_text_content_from_node(node)
+          return nil if node.nil?
+
+          # For Canon::Xml::Nodes::TextNode
+          return node.value if node.respond_to?(:value) && node.is_a?(Canon::Xml::Nodes::TextNode)
+
+          # For XML/HTML nodes with text_content method
+          return node.text_content if node.respond_to?(:text_content)
+
+          # For nodes with text method
+          return node.text if node.respond_to?(:text)
+
+          # For nodes with content method (Moxml::Text)
+          return node.content if node.respond_to?(:content)
+
+          # For nodes with value method (other types)
+          return node.value if node.respond_to?(:value)
+
+          # For simple text nodes or strings
+          return node.to_s if node.is_a?(String)
+
+          # For other node types, try to_s
+          node.to_s
+        rescue StandardError
+          nil
+        end
+
+        # Build a clear reason message for text content differences
+        # Shows the actual text content (truncated if too long)
+        #
+        # @param text1 [String, nil] First text content
+        # @param text2 [String, nil] Second text content
+        # @return [String] Clear explanation of the text difference
+        def build_text_difference_reason(text1, text2)
+          # Handle nil cases
+          return "missing vs '#{truncate_text(text2)}'" if text1.nil? && text2
+          return "'#{truncate_text(text1)}' vs missing" if text1 && text2.nil?
+          return "both missing" if text1.nil? && text2.nil?
+
+          # Both have content - show truncated versions
+          "'#{truncate_text(text1)}' vs '#{truncate_text(text2)}'"
+        end
+
+        # Truncate text for display in reason messages
+        #
+        # @param text [String] Text to truncate
+        # @param max_length [Integer] Maximum length
+        # @return [String] Truncated text
+        def truncate_text(text, max_length = 40)
+          return "" if text.nil?
+
+          text = text.to_s
+          return text if text.length <= max_length
+
+          "#{text[0...max_length]}..."
         end
 
         # Serialize an element node to string

data/lib/canon/comparison/xml_comparator/diff_node_builder.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require_relative "../../diff/diff_node"
 require_relative "../../diff/path_builder"
 require_relative "../../diff/node_serializer"
@@ -62,6 +63,21 @@ module Canon
           end
         end
 
+        # For attribute presence differences, show what attributes differ
+        if dimension == :attribute_presence
+          attrs1 = extract_attributes(node1)
+          attrs2 = extract_attributes(node2)
+          return build_attribute_difference_reason(attrs1, attrs2)
+        end
+
+        # For text content differences, show the actual text (truncated if needed)
+        if dimension == :text_content
+          text1 = extract_text_content(node1)
+          text2 = extract_text_content(node2)
+          return build_text_difference_reason(text1, text2)
+        end
+
+        # Default reason
         "#{diff1} vs #{diff2}"
       end
 
@@ -110,6 +126,98 @@ module Canon
 
         Canon::Diff::NodeSerializer.extract_attributes(node)
       end
+
+      # Build a clear reason message for attribute presence differences
+      # Shows which attributes are only in node1, only in node2, or different values
+      #
+      # @param attrs1 [Hash, nil] First node's attributes
+      # @param attrs2 [Hash, nil] Second node's attributes
+      # @return [String] Clear explanation of the attribute difference
+      def self.build_attribute_difference_reason(attrs1, attrs2)
+        return "#{attrs1&.keys&.size || 0} vs #{attrs2&.keys&.size || 0} attributes" unless attrs1 && attrs2
+
+        keys1 = attrs1.keys.to_set
+        keys2 = attrs2.keys.to_set
+
+        only_in_1 = keys1 - keys2
+        only_in_2 = keys2 - keys1
+        common = keys1 & keys2
+
+        # Check if values differ for common keys
+        different_values = common.reject { |k| attrs1[k] == attrs2[k] }
+
+        parts = []
+        parts << "only in first: #{only_in_1.to_a.sort.join(', ')}" if only_in_1.any?
+        parts << "only in second: #{only_in_2.to_a.sort.join(', ')}" if only_in_2.any?
+        parts << "different values: #{different_values.sort.join(', ')}" if different_values.any?
+
+        if parts.empty?
+          "#{keys1.size} vs #{keys2.size} attributes (same names)"
+        else
+          parts.join("; ")
+        end
+      end
+
+      # Extract text content from a node
+      #
+      # @param node [Object, nil] Node to extract text from
+      # @return [String, nil] Text content or nil
+      def self.extract_text_content(node)
+        return nil if node.nil?
+
+        # For Canon::Xml::Nodes::TextNode
+        return node.value if node.respond_to?(:value) && node.is_a?(Canon::Xml::Nodes::TextNode)
+
+        # For XML/HTML nodes with text_content method
+        return node.text_content if node.respond_to?(:text_content)
+
+        # For nodes with text method
+        return node.text if node.respond_to?(:text)
+
+        # For nodes with content method (Moxml::Text)
+        return node.content if node.respond_to?(:content)
+
+        # For nodes with value method (other types)
+        return node.value if node.respond_to?(:value)
+
+        # For simple text nodes or strings
+        return node.to_s if node.is_a?(String)
+
+        # For other node types, try to_s
+        node.to_s
+      rescue StandardError
+        nil
+      end
+
+      # Build a clear reason message for text content differences
+      # Shows the actual text content (truncated if too long)
+      #
+      # @param text1 [String, nil] First text content
+      # @param text2 [String, nil] Second text content
+      # @return [String] Clear explanation of the text difference
+      def self.build_text_difference_reason(text1, text2)
+        # Handle nil cases
+        return "missing vs '#{truncate(text2)}'" if text1.nil? && text2
+        return "'#{truncate(text1)}' vs missing" if text1 && text2.nil?
+        return "both missing" if text1.nil? && text2.nil?
+
+        # Both have content - show truncated versions
+        "'#{truncate(text1)}' vs '#{truncate(text2)}'"
+      end
+
+      # Truncate text for display in reason messages
+      #
+      # @param text [String] Text to truncate
+      # @param max_length [Integer] Maximum length
+      # @return [String] Truncated text
+      def self.truncate(text, max_length = 40)
+        return "" if text.nil?
+
+        text = text.to_s
+        return text if text.length <= max_length
+
+        "#{text[0...max_length]}..."
+      end
     end
   end
 end

data/lib/canon/comparison/xml_comparator.rb

@@ -568,9 +568,201 @@ differences)
             end
           end
 
+          # For attribute presence differences, show what attributes differ
+          if dimension == :attribute_presence
+            attrs1 = extract_attributes(node1)
+            attrs2 = extract_attributes(node2)
+            return build_attribute_diff_reason(attrs1, attrs2)
+          end
+
+          # For text content differences, show the actual text (truncated if needed)
+          if dimension == :text_content
+            text1 = extract_text_from_node(node1)
+            text2 = extract_text_from_node(node2)
+            return build_text_diff_reason(text1, text2)
+          end
+
           "#{diff1} vs #{diff2}"
         end
 
+        # Build a clear reason message for attribute presence differences
+        #
+        # @param attrs1 [Hash, nil] First node's attributes
+        # @param attrs2 [Hash, nil] Second node's attributes
+        # @return [String] Clear explanation of the attribute difference
+        def build_attribute_diff_reason(attrs1, attrs2)
+          return "#{attrs1&.keys&.size || 0} vs #{attrs2&.keys&.size || 0} attributes" unless attrs1 && attrs2
+
+          require "set"
+          keys1 = attrs1.keys.to_set
+          keys2 = attrs2.keys.to_set
+
+          only_in_first = keys1 - keys2
+          only_in_second = keys2 - keys1
+          common = keys1 & keys2
+
+          # Check if values differ for common keys
+          different_values = common.reject { |k| attrs1[k] == attrs2[k] }
+
+          parts = []
+          parts << "only in first: #{only_in_first.to_a.sort.join(', ')}" if only_in_first.any?
+          parts << "only in second: #{only_in_second.to_a.sort.join(', ')}" if only_in_second.any?
+          parts << "different values: #{different_values.sort.join(', ')}" if different_values.any?
+
+          if parts.empty?
+            "#{keys1.size} vs #{keys2.size} attributes (same names)"
+          else
+            parts.join("; ")
+          end
+        end
+
+        # Extract text from a node for diff reason
+        #
+        # @param node [Object, nil] Node to extract text from
+        # @return [String, nil] Text content or nil
+        def extract_text_from_node(node)
+          return nil if node.nil?
+
+          # For Canon::Xml::Nodes::TextNode
+          return node.value if node.respond_to?(:value) && node.is_a?(Canon::Xml::Nodes::TextNode)
+
+          # For XML/HTML nodes with text_content method
+          return node.text_content if node.respond_to?(:text_content)
+
+          # For nodes with text method
+          return node.text if node.respond_to?(:text)
+
+          # For nodes with content method (Moxml::Text)
+          return node.content if node.respond_to?(:content)
+
+          # For nodes with value method (other types)
+          return node.value if node.respond_to?(:value)
+
+          # For simple text nodes or strings
+          return node.to_s if node.is_a?(String)
+
+          # For other node types, try to_s
+          node.to_s
+        rescue StandardError
+          nil
+        end
+
+        # Build a clear reason message for text content differences
+        #
+        # @param text1 [String, nil] First text content
+        # @param text2 [String, nil] Second text content
+        # @return [String] Clear explanation of the text difference
+        def build_text_diff_reason(text1, text2)
+          # Handle nil cases
+          return "missing vs '#{truncate_text(text2)}'" if text1.nil? && text2
+          return "'#{truncate_text(text2)}' vs missing" if text1 && text2.nil?
+          return "both missing" if text1.nil? && text2.nil?
+
+          # Check if both are whitespace-only
+          if whitespace_only?(text1) && whitespace_only?(text2)
+            return "whitespace: #{describe_whitespace(text1)} vs #{describe_whitespace(text2)}"
+          end
+
+          # Show text with visible whitespace markers
+          # Use escaped representations for clarity: \n for newline, \t for tab, · for spaces
+          vis1 = visualize_whitespace(text1)
+          vis2 = visualize_whitespace(text2)
+
+          "Text: \"#{vis1}\" vs \"#{vis2}\""
+        end
+
+        # Check if text is only whitespace
+        #
+        # @param text [String] Text to check
+        # @return [Boolean] true if whitespace-only
+        def whitespace_only?(text)
+          return false if text.nil?
+
+          text.to_s.strip.empty?
+        end
+
+        # Make whitespace visible in text content
+        # Uses the existing character visualization map from DiffFormatter (single source of truth)
+        #
+        # @param text [String] Text to visualize
+        # @return [String] Text with visible whitespace markers
+        def visualize_whitespace(text)
+          return "" if text.nil?
+
+          # Use the character map loader as the single source of truth
+          viz_map = character_visualization_map
+
+          # Replace each character with its visualization
+          text.chars.map { |char| viz_map[char] || char }.join
+        end
+
+        # Get the character visualization map (lazy-loaded to avoid circular dependency)
+        #
+        # @return [Hash] Character to visualization symbol mapping
+        def character_visualization_map
+          @character_visualization_map ||= begin
+            # Load the YAML file directly to avoid circular dependency
+            require "yaml"
+            lib_root = File.expand_path("../..", __dir__)
+            yaml_path = File.join(lib_root,
+                                  "canon/diff_formatter/character_map.yml")
+            data = YAML.load_file(yaml_path)
+
+            # Build visualization map from the YAML data
+            visualization_map = {}
+            data["characters"].each do |char_data|
+              # Get the character from either unicode code point or character field
+              char = if char_data["unicode"]
+                       # Convert hex string to character
+                       [char_data["unicode"].to_i(16)].pack("U")
+                     else
+                       # Use character field directly (handles \n, \t, etc.)
+                       char_data["character"]
+                     end
+
+              vis = char_data["visualization"]
+              visualization_map[char] = vis
+            end
+
+            visualization_map
+          end
+        end
+
+        # Describe whitespace content in a readable way
+        #
+        # @param text [String] Whitespace text
+        # @return [String] Description like "4 chars (2 newlines, 2 spaces)"
+        def describe_whitespace(text)
+          return "0 chars" if text.nil? || text.empty?
+
+          char_count = text.length
+          newline_count = text.count("\n")
+          space_count = text.count(" ")
+          tab_count = text.count("\t")
+
+          parts = []
+          parts << "#{newline_count} newlines" if newline_count.positive?
+          parts << "#{space_count} spaces" if space_count.positive?
+          parts << "#{tab_count} tabs" if tab_count.positive?
+
+          description = parts.join(", ")
+          "#{char_count} chars (#{description})"
+        end
+
+        # Truncate text for display in reason messages
+        #
+        # @param text [String] Text to truncate
+        # @param max_length [Integer] Maximum length
+        # @return [String] Truncated text
+        def truncate_text(text, max_length = 40)
+          return "" if text.nil?
+
+          text = text.to_s
+          return text if text.length <= max_length
+
+          "#{text[0...max_length]}..."
+        end
+
         # Compare namespace declarations (xmlns and xmlns:* attributes)
         # Delegates to XmlComparatorHelpers::NamespaceComparator
         def compare_namespace_declarations(n1, n2, opts, differences)

data/lib/canon/diff/diff_classifier.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "formatting_detector"
+require_relative "xml_serialization_formatter"
 require_relative "../comparison/compare_profile"
 require_relative "../comparison/whitespace_sensitivity"
 
@@ -8,6 +9,11 @@ module Canon
   module Diff
     # Classifies DiffNodes as normative (affects equivalence) or informative (doesn't affect equivalence)
     # based on the match options in effect
+    #
+    # Classification hierarchy (three distinct kinds of differences):
+    # 1. Serialization formatting: XML syntax differences (always non-normative)
+    # 2. Content formatting: Whitespace differences in content (non-normative when normalized)
+    # 3. Normative: Semantic content differences (affect equivalence)
     class DiffClassifier
       attr_reader :match_options, :profile
 
@@ -25,11 +31,20 @@ module Canon
 
       # Classify a single DiffNode as normative or informative
       # Hierarchy: formatting-only < informative < normative
-      # CompareProfile determines base classification, FormattingDetector refines informative differences
+      # CompareProfile determines base classification, XmlSerializationFormatter handles serialization formatting
       # @param diff_node [DiffNode] The diff node to classify
       # @return [DiffNode] The same diff node with normative/formatting attributes set
       def classify(diff_node)
-        # SPECIAL CASE: text_content with :normalize behavior
+        # FIRST: Check for XML serialization-level formatting differences
+        # These are ALWAYS non-normative (formatting-only) regardless of match options
+        # Examples: self-closing tags (<tag/>) vs explicit closing tags (<tag></tag>)
+        if XmlSerializationFormatter.serialization_formatting?(diff_node)
+          diff_node.formatting = true
+          diff_node.normative = false
+          return diff_node
+        end
+
+        # SECOND: Handle content-level formatting for text_content with :normalize behavior
         # When text_content is :normalize and the difference is formatting-only,
         # it should be marked as non-normative (informative)
         # This ensures that verbose and non-verbose modes give consistent results
@@ -38,7 +53,7 @@ module Canon
         # (like <pre>, <code>, <textarea> in HTML), don't apply formatting detection
         # because whitespace should be preserved in these elements
         #
-        # This check must come FIRST, before normative_dimension? is called,
+        # This check must come BEFORE normative_dimension? is called,
         # because normative_dimension? returns true for text_content: :normalize
         # (since the dimension affects equivalence), which would prevent formatting
         # detection from being applied.
@@ -51,11 +66,11 @@ module Canon
           return diff_node
         end
 
-        # FIRST: Determine if this dimension is normative based on CompareProfile
+        # THIRD: Determine if this dimension is normative based on CompareProfile
         # This respects the policy settings (strict/normalize/ignore)
         is_normative = profile.normative_dimension?(diff_node.dimension)
 
-        # SECOND: Check if FormattingDetector should be consulted
+        # FOURTH: Check if FormattingDetector should be consulted for non-normative dimensions
         # Only check for formatting-only when dimension is NOT normative
         # This ensures strict mode differences remain normative
         should_check_formatting = !is_normative &&
@@ -68,7 +83,7 @@ module Canon
           return diff_node
         end
 
-        # THIRD: Apply the normative determination from CompareProfile
+        # FIFTH: Apply the normative determination from CompareProfile
         diff_node.formatting = false
         diff_node.normative = is_normative
 
@@ -127,33 +142,6 @@ module Canon
         normalized1 == normalized2 && text1 != text2
       end
 
-      # Check if a node is a text node
-      # @param node [Object] The node to check
-      # @return [Boolean] true if the node is a text node
-      def text_node?(node)
-        return false if node.nil?
-
-        # Canon::Xml::Nodes::TextNode
-        return true if node.is_a?(Canon::Xml::Nodes::TextNode)
-
-        # Nokogiri text nodes (node_type returns integer constant like 3)
-        return true if node.respond_to?(:node_type) &&
-                       node.node_type.is_a?(Integer) &&
-                       node.node_type == Nokogiri::XML::Node::TEXT_NODE
-
-        # Moxml text nodes (node_type returns symbol)
-        return true if node.respond_to?(:node_type) && node.node_type == :text
-
-        # String
-        return true if node.is_a?(String)
-
-        # Test doubles or objects with text node-like interface
-        # Check if it has a value method (contains text content)
-        return true if node.respond_to?(:value)
-
-        false
-      end
-
       # Check if the text node is inside a whitespace-sensitive element
       # @param diff_node [DiffNode] The diff node to check
       # @return [Boolean] true if inside a whitespace-sensitive element
@@ -200,6 +188,33 @@ module Canon
         # If extraction fails, return nil (not formatting-only)
         nil
       end
+
+      # Check if a node is a text node
+      # @param node [Object] The node to check
+      # @return [Boolean] true if the node is a text node
+      def text_node?(node)
+        return false if node.nil?
+
+        # Canon::Xml::Nodes::TextNode
+        return true if node.is_a?(Canon::Xml::Nodes::TextNode)
+
+        # Nokogiri text nodes (node_type returns integer constant like 3)
+        return true if node.respond_to?(:node_type) &&
+          node.node_type.is_a?(Integer) &&
+          node.node_type == Nokogiri::XML::Node::TEXT_NODE
+
+        # Moxml text nodes (node_type returns symbol)
+        return true if node.respond_to?(:node_type) && node.node_type == :text
+
+        # String
+        return true if node.is_a?(String)
+
+        # Test doubles or objects with text node-like interface
+        # Check if it has a value method (contains text content)
+        return true if node.respond_to?(:value)
+
+        false
+      end
     end
   end
 end

data/lib/canon/diff/xml_serialization_formatter.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Canon
+  module Diff
+    # Detects and classifies XML serialization-level formatting differences.
+    #
+    # Serialization-level formatting differences are differences in XML syntax
+    # that do not affect the semantic content of the document. These differences
+    # arise from different valid ways to serialize the same semantic content.
+    #
+    # These differences are ALWAYS non-normative (formatting-only) regardless
+    # of match options, because they are purely syntactic variations.
+    #
+    # Examples:
+    # - Self-closing vs explicit closing tags: <tag/> vs <tag></tag>
+    # - Attribute quote style: attr="value" vs attr='value' (parser-normalized)
+    # - Whitespace within tags: <tag a="1" b="2"> vs <tag a="1"  b="2"> (parser-normalized)
+    #
+    # Note: Some serialization differences are normalized away by XML parsers
+    # (attribute quotes, tag spacing). This class focuses on differences that
+    # survive parsing and comparison, such as self-closing vs explicit closing.
+    class XmlSerializationFormatter
+      # Detect if a diff node represents an XML serialization formatting difference.
+      #
+      # Serialization formatting differences are ALWAYS non-normative because they
+      # represent different valid serializations of the same semantic content.
+      #
+      # @param diff_node [DiffNode] The diff node to check
+      # @return [Boolean] true if this is a serialization formatting difference
+      def self.serialization_formatting?(diff_node)
+        # Currently only handles text_content dimension
+        # Future: add detection for other dimensions
+        return false unless diff_node.dimension == :text_content
+
+        empty_text_content_serialization_diff?(diff_node)
+      end
+
+      # Check if a text_content difference is from XML serialization format.
+      #
+      # Specifically detects self-closing tags (<tag/>) vs explicit closing tags
+      # (<tag></tag>), which create different text node structures:
+      # - Self-closing: no text node (nil)
+      # - Explicit closing: empty or whitespace-only text node ("", " ", "\n", etc.)
+      #
+      # Per XML standards, these forms are semantically equivalent.
+      #
+      # @param diff_node [DiffNode] The diff node to check
+      # @return [Boolean] true if this is a serialization formatting difference
+      def self.empty_text_content_serialization_diff?(diff_node)
+        return false unless diff_node.dimension == :text_content
+
+        node1 = diff_node.node1
+        node2 = diff_node.node2
+
+        # Both nodes are nil - no actual difference, not a serialization formatting diff
+        return false if node1.nil? && node2.nil?
+
+        # Only one is nil (e.g., one doc has self-closing, other has text)
+        # If the non-nil one is blank, it's still serialization formatting
+        if node1.nil? || node2.nil?
+          non_nil = node1 || node2
+          return false unless text_node?(non_nil)
+
+          text = extract_text_content(non_nil)
+          return blank?(text)
+        end
+
+        # Both must be text nodes
+        return false unless text_node?(node1) && text_node?(node2)
+
+        text1 = extract_text_content(node1)
+        text2 = extract_text_content(node2)
+
+        # Check if both texts are blank/whitespace-only
+        # This indicates self-closing vs explicit closing tag syntax
+        blank?(text1) && blank?(text2)
+      end
+
+      # Check if a value is blank (nil or whitespace-only)
+      # @param value [String, nil] Value to check
+      # @return [Boolean] true if blank
+      def self.blank?(value)
+        value.nil? ||
+          (value.respond_to?(:empty?) && value.empty?) ||
+          (value.respond_to?(:strip) && value.strip.empty?)
+      end
+
+      # Check if a node is a text node
+      # @param node [Object] The node to check
+      # @return [Boolean] true if the node is a text node
+      def self.text_node?(node)
+        return false if node.nil?
+
+        # Canon::Xml::Nodes::TextNode
+        return true if node.is_a?(Canon::Xml::Nodes::TextNode)
+
+        # Moxml::Text (check before generic node_type check)
+        return true if node.is_a?(Moxml::Text)
+
+        # Nokogiri text nodes (node_type returns integer constant like 3)
+        return true if node.respond_to?(:node_type) &&
+          node.node_type.is_a?(Integer) &&
+          node.node_type == Nokogiri::XML::Node::TEXT_NODE
+
+        # Moxml text nodes (node_type returns symbol) - for when using Moxml adapters
+        return true if node.respond_to?(:node_type) && node.node_type == :text
+
+        # String
+        return true if node.is_a?(String)
+
+        # Test doubles or objects with text node-like interface
+        # Check if it has a value method (contains text content)
+        return true if node.respond_to?(:value)
+
+        false
+      end
+
+      # Extract text content from a node
+      # @param node [Object] The node to extract text from
+      # @return [String, nil] The text content or nil
+      def self.extract_text_content(node)
+        return nil if node.nil?
+
+        # For TextNode with value attribute (Canon::Xml::Nodes::TextNode)
+        return node.value if node.respond_to?(:value) && node.is_a?(Canon::Xml::Nodes::TextNode)
+
+        # For XML/HTML nodes with text_content method
+        return node.text_content if node.respond_to?(:text_content)
+
+        # For nodes with content method (try before text, as Moxml::Text.text returns "")
+        return node.content if node.respond_to?(:content)
+
+        # For nodes with text method
+        return node.text if node.respond_to?(:text)
+
+        # For nodes with value method (other types)
+        return node.value if node.respond_to?(:value)
+
+        # For simple text nodes or strings
+        return node.to_s if node.is_a?(String)
+
+        # For other node types, try to_s
+        node.to_s
+      rescue StandardError
+        # If extraction fails, return nil (not a serialization difference)
+        nil
+      end
+
+      private_class_method :blank?, :text_node?, :extract_text_content,
+                           :empty_text_content_serialization_diff?
+    end
+  end
+end

data/lib/canon/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-20 00:00:00.000000000 Z
+date: 2026-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -257,6 +257,7 @@ files:
 - lib/canon/diff/formatting_detector.rb
 - lib/canon/diff/node_serializer.rb
 - lib/canon/diff/path_builder.rb
+- lib/canon/diff/xml_serialization_formatter.rb
 - lib/canon/diff_formatter.rb
 - lib/canon/diff_formatter/by_line/base_formatter.rb
 - lib/canon/diff_formatter/by_line/html_formatter.rb