canon 0.2.3 → 0.2.5

data/lib/canon/diff_formatter.rb

@@ -7,6 +7,9 @@ require_relative "diff/diff_block"
 require_relative "diff/diff_context"
 require_relative "diff/diff_report"
 require_relative "diff_formatter/debug_output"
+require_relative "diff_formatter/by_line_formatter"
+require_relative "diff_formatter/by_object_formatter"
+require_relative "diff_formatter/pretty_diff_formatter"
 
 module Canon
   # Formatter for displaying semantic differences with color support
@@ -301,17 +304,26 @@ module Canon
     # @param html_version [Symbol, nil] HTML version (:html4 or :html5)
     # @return [String] Formatted output
     def format(differences, format, doc1: nil, doc2: nil, html_version: nil)
-      # In by-line mode, always use by-line diff
+      # In by-line mode with both docs present, always use by-line diff
       if @mode == :by_line && doc1 && doc2
-        return by_line_diff(doc1, doc2, format: format,
-                                        html_version: html_version,
-                                        differences: differences)
+        doc1, doc2 = apply_display_preprocessing(doc1, doc2, format)
+        # rubocop:disable Layout/HashAlignment
+        return by_line_formatter.format(doc1, doc2, format: format,
+                                                  html_version: html_version,
+                                                  differences: differences)
+        # rubocop:enable Layout/HashAlignment
       end
 
       # In pretty_diff mode, always use text-LCS diff (bypasses DiffNodeMapper).
-      # pretty_diff_format handles nil doc1/doc2 itself (emits header only).
       if @mode == :pretty_diff
-        return pretty_diff_format(doc1, doc2, format: format)
+        d1, d2 = if doc1 && doc2
+                   apply_display_preprocessing(doc1, doc2,
+                                               format)
+                 else
+                   [doc1,
+                    doc2]
+                 end
+        return pretty_diff_formatter.format(d1, d2, format: format)
       end
 
       no_diffs = if differences.respond_to?(:equivalent?)
@@ -323,12 +335,26 @@ module Canon
 
       case @mode
       when :by_line
-        by_line_diff(doc1, doc2, format: format, html_version: html_version,
-                                 differences: differences)
+        if doc1 && doc2
+          doc1, doc2 = apply_display_preprocessing(doc1, doc2,
+                                                   format)
+        end
+        # rubocop:disable Layout/HashAlignment
+        by_line_formatter.format(doc1, doc2, format: format,
+                                               html_version: html_version,
+                                               differences: differences)
+        # rubocop:enable Layout/HashAlignment
       when :pretty_diff
-        pretty_diff_format(doc1, doc2, format: format)
+        d1, d2 = if doc1 && doc2
+                   apply_display_preprocessing(doc1, doc2,
+                                               format)
+                 else
+                   [doc1,
+                    doc2]
+                 end
+        pretty_diff_formatter.format(d1, d2, format: format)
       else
-        by_object_diff(differences, format)
+        by_object_formatter.format(differences, format)
       end
     end
 
@@ -340,8 +366,13 @@ module Canon
     # @param actual [Object] Actual value
     # @return [String] Formatted diff output
     def format_comparison_result(comparison_result, expected, actual)
-      # Detect format from expected content
-      format = Canon::Comparison::FormatDetector.detect(expected)
+      # Prefer the matcher-supplied format (e.g. :html4 from
+      # be_html4_equivalent_to). Auto-detection from the expected string
+      # cannot distinguish HTML from XML for fragments like
+      # `<div class="x"></div>` and would mis-route HTML fixtures
+      # through the XML pretty-printer (issue #135).
+      format = (comparison_result.is_a?(Canon::Comparison::ComparisonResult) && comparison_result.format) ||
+        Canon::Comparison::FormatDetector.detect(expected)
 
       formatter_options = {
         use_color: @use_color,
@@ -366,6 +397,18 @@ module Canon
         output << "" # Blank line for spacing
       end
 
+      # Parse-error banner.  When libxml flagged any errors during
+      # parsing, surface them at the top of the report so the user
+      # is not left chasing diffs that describe a partial tree.
+      # See lutaml/canon#130.
+      if comparison_result.is_a?(Canon::Comparison::ComparisonResult) &&
+          comparison_result.parse_errors?
+        output << format_parse_error_banner(
+          comparison_result.parse_errors_expected,
+          comparison_result.parse_errors_received,
+        )
+      end
+
       # 1. CANON VERBOSE tables (ONLY if CANON_VERBOSE=1)
       verbose_tables = DebugOutput.verbose_tables_only(
         comparison_result,
@@ -481,6 +524,53 @@ module Canon
 
     private
 
+    # Render the parse-error banner that appears at the top of the
+    # diff report when libxml flagged any errors during parsing.
+    # Names the offending side(s) and warns that the diff below
+    # describes the parsed tree, not the input.  See lutaml/canon#130.
+    #
+    # @param errors_expected [Array<String>] Errors from the expected side
+    # @param errors_received [Array<String>] Errors from the received side
+    # @return [String] Multi-line banner
+    def format_parse_error_banner(errors_expected, errors_received)
+      lines = []
+      rule = "=" * 70
+      lines << colorize(rule, :yellow, :bold)
+      lines << colorize("  ⚠️  PARSE ERRORS", :yellow, :bold)
+      lines << colorize(rule, :yellow, :bold)
+
+      if errors_expected.any?
+        lines << colorize("  Expected side:", :yellow, :bold)
+        errors_expected.each do |err|
+          lines << "    #{colorize(err, :red)}"
+        end
+      end
+
+      if errors_received.any?
+        lines << colorize("  Received side:", :yellow, :bold)
+        errors_received.each do |err|
+          lines << "    #{colorize(err, :red)}"
+        end
+      end
+
+      lines << ""
+      lines << colorize(
+        "  ⚠️  The diff below describes the parsed tree, not the input.",
+        :yellow,
+      )
+      lines << colorize(
+        "      Content that the parser could not represent has been",
+        :yellow,
+      )
+      lines << colorize(
+        "      dropped and may appear as \"missing\" in the report.",
+        :yellow,
+      )
+      lines << colorize(rule, :yellow, :bold)
+      lines << ""
+      lines.join("\n")
+    end
+
     # Normalize content for display in diffs
     #
     # @param expected [Object] Expected value
@@ -685,10 +775,8 @@ module Canon
       # false disables all visualization
       return {} if character_visualization == false
 
-      # :content_only currently behaves as true (full map)
-      # TODO: apply visualization at DOM text-node level pre-serialization,
-      # keeping structural indentation whitespace plain.
-      # See docs/features/diff-formatting/character-visualization.adoc
+      # :content_only builds the full map; the by_line formatter applies
+      # it only to content portions, leaving structural indentation plain.
 
       return visualization_map if visualization_map
 
@@ -723,177 +811,37 @@ module Canon
       colorize("#{emoji}#{message}\n", :green, :bold)
     end
 
-    # Generate by-object diff with tree visualization
-    # Delegates to format-specific by-object formatters
-    def by_object_diff(differences, format)
-      output = []
-      output << colorize("Visual Diff:", :cyan, :bold)
-
-      # Extract differences array from ComparisonResult if needed
-      diffs_array = if differences.is_a?(Canon::Comparison::ComparisonResult)
-                      differences.differences
-                    else
-                      differences
-                    end
-
-      # Delegate to format-specific formatter
-      formatter = ByObject::BaseFormatter.for_format(
-        format,
+    # Factory methods for mode-specific formatters
+
+    # @return [ByLineFormatter]
+    def by_line_formatter
+      @by_line_formatter ||= ByLineFormatter.new(
         use_color: @use_color,
         visualization_map: @visualization_map,
+        context_lines: @context_lines,
+        diff_grouping_lines: @diff_grouping_lines,
         show_diffs: @show_diffs,
+        character_visualization: @character_visualization,
+        legacy_terminal: @legacy_terminal,
+        diff_mode: @diff_mode,
       )
-
-      output << formatter.format(diffs_array, format)
-
-      output.join("\n")
     end
 
-    # Generate by-line diff
-    # Delegates to format-specific by-line formatters
-    def by_line_diff(doc1, doc2, format: :xml, html_version: nil,
-differences: [])
-      # For HTML format, use html_version if provided, otherwise default to :html4
-      if format == :html && html_version
-        format = html_version # Use :html4 or :html5
-      end
-
-      # Format display name for header
-      format_name = format.to_s.upcase
-
-      output = []
-      output << colorize("Line-by-line diff (#{format_name} mode):", :cyan,
-                         :bold)
-
-      return output.join("\n") if doc1.nil? || doc2.nil?
-
-      # Apply display preprocessing (format both sides identically before diff)
-      doc1, doc2 = apply_display_preprocessing(doc1, doc2, format)
-      # Extract differences array and equivalent status from ComparisonResult if needed
-      diffs_array = if differences.is_a?(Canon::Comparison::ComparisonResult)
-                      @comparison_equivalent = differences.equivalent?
-                      differences.differences
-                    else
-                      @comparison_equivalent = nil
-                      differences
-                    end
-
-      # Delegate to format-specific formatter
-      formatter = ByLine::BaseFormatter.for_format(
-        format,
+    # @return [ByObjectFormatter]
+    def by_object_formatter
+      @by_object_formatter ||= ByObjectFormatter.new(
         use_color: @use_color,
-        context_lines: @context_lines,
-        diff_grouping_lines: @diff_grouping_lines,
         visualization_map: @visualization_map,
         show_diffs: @show_diffs,
-        differences: diffs_array,
-        diff_mode: @legacy_terminal ? :separate : @diff_mode,
-        legacy_terminal: @legacy_terminal,
-        equivalent: @comparison_equivalent,
       )
-
-      output << formatter.format(doc1, doc2)
-
-      output.join("\n")
-    end
-
-    # Generate a text-LCS diff against preprocessed lines (pretty_diff mode).
-    #
-    # This mode bypasses DiffNodeMapper entirely: it applies display_preprocessing
-    # to both sides, then runs Diff::LCS.sdiff on the resulting plain-text lines.
-    # It is a reliable short-term workaround for #85 (normative changes invisible
-    # in :by_line mode when DiffNodeMapper's DOM-address correlation is off).
-    #
-    # Limitations:
-    # - show_diffs :normative / :informative filter is ignored (no DiffNodes)
-    # - No inline character highlighting (whole-line granularity only)
-    #
-    # @param doc1 [String] First document
-    # @param doc2 [String] Second document
-    # @param format [Symbol] Document format
-    # @return [String] Formatted diff output
-    def pretty_diff_format(doc1, doc2, format:)
-      require "diff/lcs"
-
-      resolved_format = format
-
-      format_name = resolved_format.to_s.upcase
-      output = []
-      output << colorize("Pretty diff (#{format_name} mode):", :cyan, :bold)
-
-      return output.join("\n") if doc1.nil? || doc2.nil?
-
-      # Apply display preprocessing — same transforms as by_line_diff
-      d1, d2 = apply_display_preprocessing(doc1, doc2, resolved_format)
-
-      lines1 = d1.lines.map(&:chomp)
-      lines2 = d2.lines.map(&:chomp)
-
-      hunks = ::Diff::LCS.sdiff(lines1, lines2)
-
-      output << render_pretty_diff(hunks)
-      output.join("\n")
     end
 
-    # Render sdiff hunks with context windowing and colorization.
-    #
-    # Uses the same context_lines setting as by_line_diff. Changed hunks
-    # (action !=  "=") are expanded by context_lines in each direction; nearby
-    # windows are merged; a separator is emitted between non-adjacent blocks.
-    #
-    # @param hunks [Array<Diff::LCS::ContextChange>] Output of Diff::LCS.sdiff
-    # @return [String] Rendered diff lines joined with "\n"
-    def render_pretty_diff(hunks)
-      # Identify positions of changed hunks
-      changed = hunks.each_index.reject { |i| hunks[i].action == "=" }
-
-      return colorize("  (no differences)", :green) if changed.empty?
-
-      ctx = [@context_lines || 3, 0].max
-
-      # Build expanded windows, then merge overlapping/adjacent ones
-      windows = changed.map do |pos|
-        [
-          [pos - ctx, 0].max,
-          [pos + ctx, hunks.length - 1].min,
-        ]
-      end
-
-      merged = []
-      windows.each do |lo, hi|
-        if merged.empty? || lo > merged.last[1] + 1
-          merged << [lo, hi]
-        else
-          merged.last[1] = [merged.last[1], hi].max
-        end
-      end
-
-      lines = []
-      merged.each_with_index do |(lo, hi), block_idx|
-        # Separator between non-adjacent blocks
-        if block_idx.positive?
-          lines << colorize("--- ---", :cyan)
-        elsif lo.positive?
-          lines << colorize("--- ---", :cyan)
-        end
-
-        (lo..hi).each do |i|
-          hunk = hunks[i]
-          case hunk.action
-          when "="
-            lines << (@use_color ? "\e[0m  #{hunk.old_element}" : "  #{hunk.old_element}")
-          when "-"
-            lines << colorize("- #{hunk.old_element}", :red)
-          when "+"
-            lines << colorize("+ #{hunk.new_element}", :green)
-          when "!"
-            lines << colorize("- #{hunk.old_element}", :red)
-            lines << colorize("+ #{hunk.new_element}", :green)
-          end
-        end
-      end
-
-      lines.join("\n")
+    # @return [PrettyDiffFormatter]
+    def pretty_diff_formatter
+      @pretty_diff_formatter ||= PrettyDiffFormatter.new(
+        use_color: @use_color,
+        context_lines: @context_lines,
+      )
     end
 
     # Apply display preprocessing to both documents before the line diff.
@@ -966,6 +914,7 @@ differences: [])
         collapse_whitespace_elements: @collapse_whitespace_elements,
         strip_whitespace_elements: @strip_whitespace_elements,
         sort_attributes: @pretty_printer_sort_attributes,
+        html_mode: %i[html html4 html5].include?(format),
       }
 
       printer_expected = Canon::PrettyPrinter::XmlNormalized.new(
@@ -1047,9 +996,13 @@ differences: [])
 
       if %i[html html4 html5].include?(format)
         require "canon/pretty_printer/html"
+        # Fixture-ready mode actually indents (libxml FORMAT save flag
+        # via AS_XHTML).  The default mode is structurally faithful but
+        # does not indent on HTML5 input -- see lutaml/canon#133.
         printer = Canon::PrettyPrinter::Html.new(
           indent: @pretty_printer_indent,
           indent_type: indent_type_str,
+          fixture_ready: true,
         )
       elsif format == :xml
         require "canon/pretty_printer/xml"

data/lib/canon/html/data_model.rb

@@ -208,19 +208,25 @@ module Canon
 
       # Build text node from Nokogiri text node
       # HTML-specific: handles whitespace-sensitive elements (pre, code, textarea, script, style)
+      # and preserves whitespace between inline element siblings.
       def self.build_text_node(nokogiri_text)
         # Skip text nodes that are only whitespace between elements
         # EXCEPT in whitespace-sensitive elements (pre, code, textarea, script, style)
-        # where whitespace is semantically significant
+        # and when whitespace is between inline element siblings (semantically significant)
         content = nokogiri_text.content
 
-        if content.strip.empty? && nokogiri_text.parent.is_a?(Nokogiri::XML::Element)
+        # NBSP (U+00A0) is never insignificant whitespace
+        if content.strip.empty? && nokogiri_text.parent.is_a?(Nokogiri::XML::Element) && !content.include?("\u00A0")
           # Check if parent is whitespace-sensitive
           parent_name = nokogiri_text.parent.name.downcase
           whitespace_sensitive_tags = %w[pre code textarea script style]
 
-          # Skip whitespace-only text UNLESS in whitespace-sensitive element
-          return nil unless whitespace_sensitive_tags.include?(parent_name)
+          # Check if whitespace is between inline siblings
+          require_relative "../comparison/whitespace_sensitivity"
+          unless whitespace_sensitive_tags.include?(parent_name) ||
+              Canon::Comparison::WhitespaceSensitivity.inline_whitespace_significant?(nokogiri_text)
+            return nil
+          end
         end
 
         # Nokogiri already handles CDATA conversion and entity resolution

data/lib/canon/pretty_printer/html.rb

@@ -1,19 +1,43 @@
 # frozen_string_literal: true
 
 require "nokogiri"
+require "stringio"
+require_relative "html_void_elements"
 
 module Canon
   module PrettyPrinter
-    # Pretty printer for HTML with consistent indentation
+    # Pretty printer for HTML with consistent indentation.
+    #
+    # Two modes:
+    #
+    # 1. Default mode (+fixture_ready: false+): retains the existing
+    #    behaviour for callers that use the pretty-printer as a
+    #    structural normaliser (the canon round-trip tests, the
+    #    diff-pipeline +apply_pretty_print+ stage, etc).  These callers
+    #    do not require actual indentation; they require structural
+    #    equivalence to the input.
+    #
+    # 2. Fixture-ready mode (+fixture_ready: true+): emits
+    #    actually-indented XHTML-shaped output via libxml's +FORMAT+
+    #    save flag.  Used by +DiffFormatter#prettyprint_for_display+
+    #    (the +CANON_<FORMAT>_DIFF_SHOW_PRETTYPRINT_RECEIVED+ surface)
+    #    so the user can read or paste the formatted output directly
+    #    into a fixture heredoc.  Output is XHTML-shaped (void
+    #    elements self-closed, non-void paired) via the +AS_XHTML+
+    #    save flag; the +NO_DECLARATION+ flag suppresses the
+    #    +<?xml ...?>+ prefix.
+    #
+    # See lutaml/canon#133, lutaml/canon#135.
     class Html
-      def initialize(indent: 2, indent_type: "space")
+      def initialize(indent: 2, indent_type: "space", fixture_ready: false)
         @indent = indent.to_i
         @indent_type = indent_type
+        @fixture_ready = fixture_ready
       end
 
-      # Pretty print HTML with consistent indentation
       def format(html_string)
-        # Detect if this is XHTML or HTML
+        return format_fixture_ready(html_string) if @fixture_ready
+
         if xhtml?(html_string)
           format_as_xhtml(html_string)
         else
@@ -24,34 +48,72 @@ module Canon
       private
 
       def xhtml?(html_string)
-        # Check for XHTML DOCTYPE or xmlns attribute
         html_string.include?("XHTML") ||
           html_string.include?('xmlns="http://www.w3.org/1999/xhtml"')
       end
 
       def format_as_xhtml(html_string)
-        # Parse as XML for XHTML
         doc = Nokogiri::XML(html_string, &:noblanks)
 
-        # Use Nokogiri's built-in pretty printing
-        if @indent_type == "tab"
-          doc.to_xml(indent: 1, indent_text: "\t", encoding: "UTF-8")
-        else
-          doc.to_xml(indent: @indent, encoding: "UTF-8")
-        end
+        out = if @indent_type == "tab"
+                doc.to_xml(indent: 1, indent_text: "\t", encoding: "UTF-8")
+              else
+                doc.to_xml(indent: @indent, encoding: "UTF-8")
+              end
+
+        expand_non_void_self_closing(out)
       end
 
       def format_as_html(html_string)
-        # Parse as HTML5
         doc = Nokogiri::HTML5(html_string)
 
-        # Use Nokogiri's built-in pretty printing
         if @indent_type == "tab"
           doc.to_html(indent: 1, indent_text: "\t", encoding: "UTF-8")
         else
           doc.to_html(indent: @indent, encoding: "UTF-8")
         end
       end
+
+      # Fixture-ready serialisation: parse with Nokogiri::HTML5 (so we
+      # get permissive recovery on real-world Word / XHTML5 / HTML5
+      # input shapes), then write through libxml's XML writer with
+      # +FORMAT+ + +AS_XHTML+ + +NO_DECLARATION+.  +FORMAT+ inserts
+      # indentation; +AS_XHTML+ produces well-shaped output (void
+      # elements self-closed, non-void paired); +NO_DECLARATION+
+      # suppresses the +<?xml ...?>+ prefix.
+      def format_fixture_ready(html_string)
+        doc = Nokogiri::HTML5(html_string)
+        io = StringIO.new
+        if @indent_type == "tab"
+          doc.write_to(io, save_with: fixture_ready_save_options,
+                           indent: 1, indent_text: "\t")
+        else
+          doc.write_to(io, save_with: fixture_ready_save_options,
+                           indent: @indent)
+        end
+        io.string
+      end
+
+      def fixture_ready_save_options
+        Nokogiri::XML::Node::SaveOptions::FORMAT |
+          Nokogiri::XML::Node::SaveOptions::AS_XHTML |
+          Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+      end
+
+      # Rewrite +<tag …/>+ into +<tag …></tag>+ for every element name
+      # that is not an HTML5 void element. +<a/>+ is illegal HTML;
+      # void tags like +<br/>+ and +<img …/>+ pass through unchanged.
+      def expand_non_void_self_closing(html)
+        html.gsub(%r{<([A-Za-z][A-Za-z0-9:_-]*)((?:\s+[^<>"]*(?:"[^"]*"[^<>"]*)*)?)/>}) do
+          name = ::Regexp.last_match(1)
+          attrs = ::Regexp.last_match(2)
+          if HtmlVoidElements.void?(name)
+            "<#{name}#{attrs}/>"
+          else
+            "<#{name}#{attrs}></#{name}>"
+          end
+        end
+      end
     end
   end
 end

data/lib/canon/pretty_printer/html_void_elements.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Canon
+  module PrettyPrinter
+    # The 14 HTML5 void elements — those whose start tag may stand alone
+    # (with no end tag) and which cannot have any content. Every other
+    # element with no children must be written as +<tag></tag>+ in HTML;
+    # writing +<a/>+ is illegal HTML and is parsed as +<a>+ (start tag only).
+    module HtmlVoidElements
+      VOID = Set.new(%w[area base br col embed hr img input link meta param
+                        source track wbr]).freeze
+
+      def self.void?(name)
+        VOID.include?(name.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/canon/pretty_printer/xml_normalized.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "nokogiri"
+require_relative "html_void_elements"
 
 module Canon
   module PrettyPrinter
@@ -133,12 +134,14 @@ module Canon
                      collapse_whitespace_elements: [],
                      strip_whitespace_elements: [],
                      pretty_printed: false,
-                     sort_attributes: false)
+                     sort_attributes: false,
+                     html_mode: false)
         @indent = indent.to_i
         @indent_char = indent_type == "tab" ? "\t" : " "
         @vis_map = visualization_map || default_vis_map
         @pretty_printed = pretty_printed
         @sort_attributes = sort_attributes
+        @html_mode = html_mode
 
         @strict_ws  = Set.new((preserve_whitespace_elements || []).map(&:to_s))
         @norm_ws    = Set.new((collapse_whitespace_elements || []).map(&:to_s))
@@ -151,10 +154,10 @@ module Canon
       # @return [String] Serialized XML, one node per line, with content
       #   whitespace visualized at line boundaries
       def format(xml_string)
-        doc = Nokogiri::XML(xml_string)
+        doc = @html_mode ? Nokogiri::HTML5(xml_string) : Nokogiri::XML(xml_string)
         lines = []
 
-        if doc.version
+        if !@html_mode && doc.version
           enc = doc.encoding ? " encoding=\"#{doc.encoding}\"" : ""
           lines << "<?xml version=\"#{doc.version}\"#{enc}?>"
         end
@@ -198,6 +201,10 @@ module Canon
         children = node.children.reject { |c| c.text? && c.content.empty? }
 
         if children.empty?
+          if @html_mode && !HtmlVoidElements.void?(node.name)
+            return "#{ind(depth)}#{open_tag(node)}</#{node.name}>"
+          end
+
           return "#{ind(depth)}#{open_tag(node,
                                           self_close: true)}"
         end