png_conform 0.1.0

data/lib/png_conform/reporters/palette_reporter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "base_reporter"
+
+module PngConform
+  module Reporters
+    # Palette reporter - outputs palette details (-p flag)
+    # Matches pngcheck -p output format
+    # Prints PLTE, tRNS, hIST, sPLT and PPLT chunk contents
+    class PaletteReporter < BaseReporter
+      def report(file_analysis)
+        # File header (similar to verbose mode)
+        write_line("File: #{file_analysis.file_path} (#{file_analysis.file_size} bytes)")
+
+        # Find and output palette-related chunks
+        file_analysis.chunks&.each do |chunk|
+          case chunk.type
+          when "PLTE"
+            output_plte_chunk(chunk)
+          when "tRNS", "hIST", "sPLT", "PPLT"
+            output_palette_chunk(chunk)
+          end
+        end
+
+        # Standard summary line
+        write_line(file_analysis.summary_line)
+      end
+
+      private
+
+      def output_plte_chunk(chunk)
+        return unless chunk.decoded_data.is_a?(PngConform::Models::PlteData)
+
+        write_line("  PLTE chunk: #{chunk.decoded_data.summary}")
+        chunk.decoded_data.detailed_entries.each do |entry_line|
+          write_line("    #{entry_line}")
+        end
+      end
+
+      def output_palette_chunk(chunk)
+        write_line("  #{chunk.type} chunk at offset #{chunk.offset_hex}, length #{chunk.length}")
+        return unless chunk.decoded_data
+
+        write_line("    #{chunk.decoded_data.summary}")
+      end
+    end
+  end
+end

data/lib/png_conform/reporters/quiet_reporter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base_reporter"
+
+module PngConform
+  module Reporters
+    # Quiet reporter - outputs only errors (-q flag)
+    # Matches pngcheck -q output format
+    class QuietReporter < BaseReporter
+      def report(file_analysis)
+        # Only output if there are errors
+        return if file_analysis.valid?
+
+        write_line(file_analysis.validation_result.error_summary)
+      end
+    end
+  end
+end

data/lib/png_conform/reporters/reporter_factory.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "summary_reporter"
+require_relative "verbose_reporter"
+require_relative "very_verbose_reporter"
+require_relative "quiet_reporter"
+require_relative "palette_reporter"
+require_relative "text_reporter"
+require_relative "color_reporter"
+require_relative "yaml_reporter"
+require_relative "json_reporter"
+
+module PngConform
+  module Reporters
+    # Factory for creating reporter instances based on options.
+    #
+    # Implements the Factory pattern to provide a clean interface for
+    # creating reporters with various combinations of options.
+    class ReporterFactory
+      # Create a reporter based on the specified options.
+      #
+      # @param format [String] Output format ("text", "yaml", "json")
+      # @param verbose [Boolean] Whether to use verbose output
+      # @param quiet [Boolean] Whether to use quiet output
+      # @param verbosity [Symbol] Verbosity level (:quiet, :summary, :verbose, :very_verbose)
+      # @param colorize [Boolean] Whether to colorize output (default: true)
+      # @param show_palette [Boolean] Whether to show palette details
+      # @param show_text [Boolean] Whether to show text chunk contents
+      # @param seven_bit [Boolean] Whether to escape characters >= 128
+      # @return [BaseReporter] Reporter instance
+      def self.create(format: "text", verbose: false, quiet: false,
+                      verbosity: nil, colorize: true, show_palette: false,
+                      show_text: false, seven_bit: false, escape_mode: :none)
+        # Format takes priority over verbosity
+        case format
+        when "yaml"
+          return YamlReporter.new
+        when "json"
+          return JsonReporter.new
+        end
+
+        # Text reporters with verbosity levels
+        reporter = if verbosity
+                     case verbosity
+                     when :quiet
+                       QuietReporter.new($stdout, colorize: colorize)
+                     when :verbose
+                       VerboseReporter.new($stdout, colorize: colorize)
+                     when :very_verbose
+                       VeryVerboseReporter.new($stdout, colorize: colorize)
+                     when :summary
+                       SummaryReporter.new($stdout, colorize: colorize)
+                     else
+                       SummaryReporter.new($stdout, colorize: colorize)
+                     end
+                   elsif quiet
+                     QuietReporter.new($stdout, colorize: colorize)
+                   elsif verbose
+                     VerboseReporter.new($stdout, colorize: colorize)
+                   else
+                     SummaryReporter.new($stdout, colorize: colorize)
+                   end
+
+        # Wrap with additional reporters based on options
+        reporter = wrap_with_palette(reporter) if show_palette
+
+        reporter = wrap_with_text(reporter, seven_bit, escape_mode) if show_text
+
+        reporter = wrap_with_color(reporter) if colorize
+
+        reporter
+      end
+
+      # Wrap a reporter with palette display functionality.
+      #
+      # @param reporter [BaseReporter] Reporter to wrap
+      # @return [PaletteReporter] Wrapped reporter
+      def self.wrap_with_palette(reporter)
+        PaletteReporter.new(reporter)
+      end
+
+      # Wrap a reporter with text chunk display functionality.
+      #
+      # @param reporter [BaseReporter] Reporter to wrap
+      # @param seven_bit [Boolean] Whether to escape characters >= 128
+      # @param escape_mode [Symbol] Explicit escape mode setting
+      # @return [TextReporter] Wrapped reporter
+      def self.wrap_with_text(reporter, seven_bit, escape_mode)
+        mode = if escape_mode == :none
+                 (seven_bit ? :seven_bit : :none)
+               else
+                 escape_mode
+               end
+        TextReporter.new(reporter, escape_mode: mode)
+      end
+
+      # Wrap a reporter with color functionality.
+      #
+      # @param reporter [BaseReporter] Reporter to wrap
+      # @return [ColorReporter] Wrapped reporter
+      def self.wrap_with_color(reporter)
+        ColorReporter.new(reporter)
+      end
+
+      private_class_method :wrap_with_palette, :wrap_with_text, :wrap_with_color
+    end
+  end
+end

data/lib/png_conform/reporters/summary_reporter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "base_reporter"
+require_relative "visual_elements"
+
+module PngConform
+  module Reporters
+    # Summary reporter - outputs one-line summary per file with colors and emojis
+    # Default reporter matching pngcheck output format
+    # Example: "✅ OK: file.png (PNG, 164 bytes, 4 chunks 🗜️ -28.1%)"
+    class SummaryReporter < BaseReporter
+      include VisualElements
+
+      def initialize(output = $stdout, colorize: true)
+        super(output)
+        @colorize = colorize
+      end
+
+      def report(validation_result)
+        if validation_result.valid?
+          write_line(format_success(validation_result))
+        else
+          write_line(format_error(validation_result))
+        end
+      end
+
+      private
+
+      def format_success(result)
+        emoji_check = emoji(:success)
+        status = colorize("OK", :green)
+
+        parts = ["#{emoji_check} #{status}: #{result.filename}"]
+        parts << "(#{result.file_type}"
+        parts << "#{result.file_size} bytes"
+        parts << "#{result.chunk_count} chunks"
+
+        if result.compression_ratio
+          compression = "#{emoji(:compression)} #{colorize(
+            format('%.1f%%', result.compression_ratio), :cyan
+          )}"
+          parts << compression
+        end
+
+        "#{parts.join(', ')})"
+      end
+
+      def format_error(result)
+        emoji_err = emoji(:error)
+        status = colorize("ERROR", :red)
+
+        lines = ["#{emoji_err} #{status}: #{result.filename}"]
+
+        result.errors.each do |error|
+          severity_emoji = emoji(error.severity.to_sym)
+          severity_text = colorize(error.severity.upcase,
+                                   color_for_severity(error.severity))
+          lines << "  #{severity_emoji} #{severity_text}: #{error.message}"
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/png_conform/reporters/text_reporter.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "base_reporter"
+
+module PngConform
+  module Reporters
+    # Text reporter - extracts and displays text chunk contents (-t flag)
+    # Matches pngcheck -t output format
+    # Prints tEXt, zTXt, iTXt chunk contents
+    class TextReporter < BaseReporter
+      attr_reader :escape_mode
+
+      # @param output [IO] Output stream
+      # @param escape_mode [Symbol] :seven_bit for -7 flag, :none for -t flag
+      def initialize(output = $stdout, escape_mode: :none)
+        super(output)
+        @escape_mode = escape_mode
+      end
+
+      def report(file_analysis)
+        has_text_chunks = false
+
+        file_analysis.chunks&.each do |chunk|
+          next unless text_chunk?(chunk.type)
+
+          has_text_chunks = true
+          output_text_chunk(chunk)
+        end
+
+        # If no text chunks found, output standard summary
+        write_line(file_analysis.summary_line) unless has_text_chunks
+      end
+
+      private
+
+      def text_chunk?(type)
+        %w[tEXt zTXt iTXt].include?(type)
+      end
+
+      def output_text_chunk(chunk)
+        write_line("#{chunk.type} chunk:")
+        if chunk.decoded_data.respond_to?(:keyword) && chunk.decoded_data.respond_to?(:text)
+          text = format_text(chunk.decoded_data.text)
+          write_line("  #{chunk.decoded_data.keyword}: #{text}")
+        else
+          write_line("  <unable to decode>")
+        end
+      end
+
+      def format_text(text)
+        case escape_mode
+        when :seven_bit
+          escape_non_ascii(text)
+        else
+          text
+        end
+      end
+
+      def escape_non_ascii(text)
+        text.chars.map do |char|
+          char.ord >= 128 ? format("\\x%02x", char.ord) : char
+        end.join
+      end
+    end
+  end
+end

data/lib/png_conform/reporters/verbose_reporter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "base_reporter"
+require_relative "visual_elements"
+
+module PngConform
+  module Reporters
+    # Verbose reporter - outputs detailed chunk information with colors and emojis
+    # Matches pngcheck -v output format with visual enhancements
+    class VerboseReporter < BaseReporter
+      include VisualElements
+
+      def initialize(output = $stdout, colorize: true)
+        super(output)
+        @colorize = colorize
+      end
+
+      def report(validation_result)
+        write_line(format_file_header(validation_result))
+        write_line("")
+
+        validation_result.chunks.each do |chunk|
+          write_line(format_chunk(chunk))
+        end
+
+        if validation_result.errors.any?
+          write_line("")
+          write_line(colorize("VALIDATION ERRORS:", :red))
+          validation_result.errors.each do |error|
+            write_line(format_error(error))
+          end
+        end
+
+        write_line("")
+        write_line(format_summary(validation_result))
+      end
+
+      private
+
+      def format_file_header(result)
+        emoji_file = emoji(:file)
+        filename = colorize(result.filename, :bold)
+        "#{emoji_file} #{filename} (#{result.file_size} bytes)"
+      end
+
+      def format_chunk(chunk)
+        emoji_chunk = emoji(:chunk)
+
+        status = if chunk.valid_crc
+                   colorize(emoji(:valid_crc), :green)
+                 else
+                   colorize(emoji(:invalid_crc), :red)
+                 end
+
+        chunk_type = colorize(chunk.type, :cyan)
+        offset = colorize(chunk.offset_hex, :gray)
+
+        "  #{status} #{emoji_chunk} #{chunk_type} at #{offset} (#{chunk.length} bytes)"
+      end
+
+      def format_error(error)
+        severity_emoji = emoji(error.severity.to_sym)
+        severity_text = colorize(error.severity.upcase,
+                                 color_for_severity(error.severity))
+        "  #{severity_emoji} #{severity_text}: #{error.message}"
+      end
+
+      def format_summary(result)
+        status = if result.valid?
+                   colorize("#{emoji(:valid_crc)} No errors detected", :green)
+                 else
+                   colorize("#{emoji(:invalid_crc)} ERRORS DETECTED", :red)
+                 end
+
+        compression = if result.compression_ratio
+                        " #{emoji(:compression)} #{colorize(
+                          format('%.1f%%', result.compression_ratio), :cyan
+                        )}"
+                      else
+                        ""
+                      end
+
+        "#{status} in #{result.filename} (#{result.chunk_count} chunks#{compression})"
+      end
+    end
+  end
+end

data/lib/png_conform/reporters/very_verbose_reporter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "verbose_reporter"
+
+module PngConform
+  module Reporters
+    # Very verbose reporter - adds row filter information (-vv flag)
+    # Matches pngcheck -vv output format
+    class VeryVerboseReporter < VerboseReporter
+      def report(file_analysis)
+        # File header
+        write_line(file_analysis.file_header)
+
+        # Chunk details with filter information
+        file_analysis.chunks&.each do |chunk|
+          write_line("  #{chunk.summary}")
+          next unless chunk.decoded_data
+
+          write_line("    #{chunk.decoded_data.summary}")
+
+          # Add filter summary for IDAT chunks
+          if chunk.decoded_data.respond_to?(:filter_summary)
+            filter_info = chunk.decoded_data.filter_summary
+            write_line("    #{filter_info}") if filter_info
+          end
+        end
+
+        # Validation summary
+        write_line(file_analysis.validation_summary)
+      end
+    end
+  end
+end

data/lib/png_conform/reporters/visual_elements.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Reporters
+    # Module providing visual elements (emojis and colors) for CLI output
+    # Text reporters include this module to add visual appeal
+    # Structured reporters (YAML/JSON) do not use these elements
+    module VisualElements
+      # Emoji definitions for consistent visual representation
+      EMOJI = {
+        success: "✅",
+        error: "❌",
+        warning: "⚠️",
+        info: "ℹ️",
+        chunk: "📦",
+        file: "📄",
+        valid_crc: "✓",
+        invalid_crc: "✗",
+        compression: "🗜️",
+        image: "🖼️",
+      }.freeze
+
+      # ANSI color codes for terminal output
+      COLORS = {
+        green: "\e[32m",
+        red: "\e[31m",
+        yellow: "\e[33m",
+        blue: "\e[34m",
+        cyan: "\e[36m",
+        gray: "\e[90m",
+        reset: "\e[0m",
+        bold: "\e[1m",
+      }.freeze
+
+      # Colorize text with ANSI color codes
+      # @param text [String] The text to colorize
+      # @param color [Symbol] The color name from COLORS
+      # @return [String] Colorized text or original if colorization disabled
+      def colorize(text, color)
+        return text unless @colorize
+        return text unless COLORS.key?(color)
+
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      end
+
+      # Get emoji for a given name
+      # @param name [Symbol] The emoji name from EMOJI
+      # @return [String] The emoji character or empty string
+      def emoji(name)
+        EMOJI[name] || ""
+      end
+
+      # Get color code for severity level
+      # @param severity [String] The severity level ("error", "warning", "info")
+      # @return [Symbol] The color symbol
+      def color_for_severity(severity)
+        case severity
+        when "error" then :red
+        when "warning" then :yellow
+        when "info" then :blue
+        else :gray
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/reporters/yaml_reporter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base_reporter"
+require "yaml"
+
+module PngConform
+  module Reporters
+    # YAML reporter - outputs complete file analysis in YAML format
+    # Proper Model → Formatter pattern
+    # Receives FileAnalysis model and formats it (no analysis done here)
+    class YamlReporter < BaseReporter
+      def report(file_analysis)
+        # Simple formatting - model knows how to serialize itself
+        write_line(file_analysis.to_h.to_yaml)
+      end
+    end
+  end
+end