png_conform 0.1.1 → 0.1.3

data/lib/png_conform/readers/streaming_reader.rb

@@ -27,15 +27,19 @@ module PngConform
         .pack("C*")
         .freeze
 
-      attr_reader :io, :signature
+      attr_reader :io, :signature, :total_bytes_read
 
       # Initialize a new streaming reader
       #
       # @param io [IO] IO object to read from (must be opened in binary mode)
-      def initialize(io)
+      # @param options [Hash] Options for reading behavior
+      # @option options [Boolean] :validate_crc (true) Calculate CRC during reading
+      def initialize(io, options = {})
         @io = io
         @signature = nil
         @chunks_read = 0
+        @total_bytes_read = 0
+        @validate_crc = options.fetch(:validate_crc, true)
       end
 
       # Read and validate the PNG signature
@@ -71,6 +75,15 @@ module PngConform
         return nil if @io.eof?
 
         chunk = BinData::ChunkStructure.read(@io)
+
+        # Track total bytes read (8 byte header + data + 4 byte CRC)
+        @total_bytes_read += (12 + chunk.data_length)
+
+        # Validate CRC during reading if enabled and cache result
+        if @validate_crc
+          chunk.instance_variable_set(:@_crc_valid, chunk.crc_valid?)
+        end
+
         @chunks_read += 1
         chunk
       rescue EOFError
@@ -135,6 +148,18 @@ module PngConform
         @io.rewind
         @signature = nil
         @chunks_read = 0
+        @total_bytes_read = 0
+      end
+
+      # Get file size from total bytes tracked during reading
+      #
+      # Returns the total file size including signature and all chunks.
+      # This is cached during reading to avoid O(n) recalculation.
+      #
+      # @return [Integer] File size in bytes (0 if no chunks read yet)
+      def file_size
+        # 8 bytes signature + total chunk bytes
+        8 + @total_bytes_read
       end
 
       # Get the current position in the file

data/lib/png_conform/reporters/color_reporter.rb

@@ -1,23 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "base_reporter"
+require_relative "../utils/colorizer"
 
 module PngConform
   module Reporters
     # Color reporter - wraps another reporter to add ANSI color support (-c flag)
     # Decorator pattern to add color to any reporter
     class ColorReporter < BaseReporter
-      # ANSI color codes
-      COLORS = {
-        red: "\e[31m",
-        green: "\e[32m",
-        yellow: "\e[33m",
-        blue: "\e[34m",
-        magenta: "\e[35m",
-        cyan: "\e[36m",
-        reset: "\e[0m",
-      }.freeze
-
       attr_reader :wrapped_reporter
 
       # @param wrapped_reporter [BaseReporter] The reporter to wrap with colors
@@ -41,12 +31,25 @@ module PngConform
 
       protected
 
-      # Override colorize to actually apply colors
+      # Override colorize to use Colorizer class
       def colorize(text, color)
         return text unless @colorize_enabled
-        return text unless COLORS.key?(color)
 
-        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+        case color
+        when :red
+          Utils::Colorizer.error(text, bold: false)
+        when :green
+          Utils::Colorizer.success(text, bold: false)
+        when :yellow
+          Utils::Colorizer.warning(text, bold: false)
+        when :blue
+          Utils::Colorizer.info(text, bold: false)
+        when :cyan, :magenta
+          # Use cyan as a neutral color for other cases
+          Utils::Colorizer.colorize(text, :cyan, bold: false)
+        else
+          text
+        end
       end
 
       # Determine color based on validation status

data/lib/png_conform/reporters/reporter_factory.rb

@@ -1,21 +1,12 @@
 # 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.
+    # Uses lazy loading to only require reporters when actually needed.
     class ReporterFactory
       # Create a reporter based on the specified options.
       #
@@ -34,30 +25,43 @@ module PngConform
         # Format takes priority over verbosity
         case format
         when "yaml"
+          require_relative "yaml_reporter" unless defined?(YamlReporter)
           return YamlReporter.new
         when "json"
+          require_relative "json_reporter" unless defined?(JsonReporter)
           return JsonReporter.new
         end
 
-        # Text reporters with verbosity levels
+        # Text reporters with verbosity levels - lazy load base and visual elements
+        require_relative "visual_elements" unless defined?(VisualElements)
+        require_relative "base_reporter" unless defined?(BaseReporter)
+
         reporter = if verbosity
                      case verbosity
                      when :quiet
+                       require_relative "quiet_reporter" unless defined?(QuietReporter)
                        QuietReporter.new($stdout, colorize: colorize)
                      when :verbose
+                       require_relative "verbose_reporter" unless defined?(VerboseReporter)
                        VerboseReporter.new($stdout, colorize: colorize)
                      when :very_verbose
+                       require_relative "very_verbose_reporter" unless defined?(VeryVerboseReporter)
                        VeryVerboseReporter.new($stdout, colorize: colorize)
                      when :summary
+                       require_relative "summary_reporter" unless defined?(SummaryReporter)
                        SummaryReporter.new($stdout, colorize: colorize)
                      else
+                       require_relative "summary_reporter" unless defined?(SummaryReporter)
                        SummaryReporter.new($stdout, colorize: colorize)
                      end
                    elsif quiet
+                     require_relative "quiet_reporter" unless defined?(QuietReporter)
                      QuietReporter.new($stdout, colorize: colorize)
                    elsif verbose
+                     require_relative "verbose_reporter" unless defined?(VerboseReporter)
                      VerboseReporter.new($stdout, colorize: colorize)
                    else
+                     require_relative "summary_reporter" unless defined?(SummaryReporter)
                      SummaryReporter.new($stdout, colorize: colorize)
                    end
 
@@ -76,6 +80,7 @@ module PngConform
       # @param reporter [BaseReporter] Reporter to wrap
       # @return [PaletteReporter] Wrapped reporter
       def self.wrap_with_palette(reporter)
+        require_relative "palette_reporter" unless defined?(PaletteReporter)
         PaletteReporter.new(reporter)
       end
 
@@ -86,6 +91,7 @@ module PngConform
       # @param escape_mode [Symbol] Explicit escape mode setting
       # @return [TextReporter] Wrapped reporter
       def self.wrap_with_text(reporter, seven_bit, escape_mode)
+        require_relative "text_reporter" unless defined?(TextReporter)
         mode = if escape_mode == :none
                  (seven_bit ? :seven_bit : :none)
                else
@@ -99,6 +105,7 @@ module PngConform
       # @param reporter [BaseReporter] Reporter to wrap
       # @return [ColorReporter] Wrapped reporter
       def self.wrap_with_color(reporter)
+        require_relative "color_reporter" unless defined?(ColorReporter)
         ColorReporter.new(reporter)
       end
 

data/lib/png_conform/reporters/visual_elements.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../utils/colorizer"
+
 module PngConform
   module Reporters
     # Module providing visual elements (emojis and colors) for CLI output
@@ -20,27 +22,31 @@ module PngConform
         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
+      # Colorize text with Colorizer class
       # @param text [String] The text to colorize
-      # @param color [Symbol] The color name from COLORS
+      # @param color [Symbol] The color name
       # @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]}"
+        case color
+        when :green
+          Utils::Colorizer.success(text, bold: false)
+        when :red
+          Utils::Colorizer.error(text, bold: false)
+        when :yellow
+          Utils::Colorizer.warning(text, bold: false)
+        when :blue
+          Utils::Colorizer.info(text, bold: false)
+        when :cyan
+          Utils::Colorizer.colorize(text, :cyan, bold: false)
+        when :gray
+          Utils::Colorizer.colorize(text, :gray, bold: false)
+        when :bold
+          Utils::Colorizer.bold(text)
+        else
+          text
+        end
       end
 
       # Get emoji for a given name

data/lib/png_conform/services/analysis_manager.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "../configuration"
+
+module PngConform
+  module Services
+    # Manages conditional analysis execution
+    #
+    # The AnalysisManager handles:
+    # - Running resolution analysis (conditional)
+    # - Running optimization analysis (conditional)
+    # - Running metrics analysis (conditional)
+    #
+    # Analyzers are only run when needed based on options to improve performance.
+    # This class extracts analysis logic from ValidationService following
+    # Single Responsibility Principle.
+    #
+    class AnalysisManager
+      # Initialize analysis manager
+      #
+      # @param options [Hash] CLI options for controlling behavior
+      # @param config [Configuration] Configuration instance (optional)
+      def initialize(options = {}, config: Configuration.instance)
+        @options = options
+        @config = config
+      end
+
+      # Enrich FileAnalysis with conditional analyzer results
+      #
+      # Runs analyzers only when needed based on options:
+      # - Resolution analysis: unless quiet mode, or if --resolution or --mobile-ready
+      # - Optimization analysis: unless quiet mode, or if --optimize
+      # - Metrics analysis: if yaml/json format, or if --metrics
+      #
+      # @param file_analysis [FileAnalysis] File analysis to enrich
+      # @return [FileAnalysis] Enriched file analysis
+      def enrich(file_analysis)
+        validation_result = file_analysis.validation_result
+
+        if need_resolution_analysis?
+          file_analysis.resolution_analysis =
+            run_resolution_analysis(validation_result)
+        end
+
+        if need_optimization_analysis?
+          file_analysis.optimization_analysis =
+            run_optimization_analysis(validation_result)
+        end
+
+        if need_metrics_analysis?
+          file_analysis.metrics = run_metrics_analysis(validation_result)
+        end
+
+        file_analysis
+      end
+
+      private
+
+      # Run resolution analyzer
+      #
+      # @param result [ValidationResult] Validation result
+      # @return [Hash] Resolution analysis results
+      def run_resolution_analysis(result)
+        require_relative "../analyzers/resolution_analyzer" unless defined?(Analyzers::ResolutionAnalyzer)
+        Analyzers::ResolutionAnalyzer.new(result, config: @config).analyze
+      rescue StandardError => e
+        { error: "Resolution analysis failed: #{e.message}" }
+      end
+
+      # Run optimization analyzer
+      #
+      # @param result [ValidationResult] Validation result
+      # @return [Hash] Optimization analysis results
+      def run_optimization_analysis(result)
+        require_relative "../analyzers/optimization_analyzer" unless defined?(Analyzers::OptimizationAnalyzer)
+        Analyzers::OptimizationAnalyzer.new(result, config: @config).analyze
+      rescue StandardError => e
+        { error: "Optimization analysis failed: #{e.message}" }
+      end
+
+      # Run metrics analyzer
+      #
+      # @param result [ValidationResult] Validation result
+      # @return [Hash] Metrics analysis results
+      def run_metrics_analysis(result)
+        require_relative "../analyzers/metrics_analyzer" unless defined?(Analyzers::MetricsAnalyzer)
+        Analyzers::MetricsAnalyzer.new(result, config: @config).analyze
+      rescue StandardError => e
+        { error: "Metrics analysis failed: #{e.message}" }
+      end
+
+      # Check if resolution analysis is needed
+      #
+      # @return [Boolean] True if resolution analysis should be run
+      def need_resolution_analysis?
+        return true unless @options[:quiet]
+
+        @options[:resolution] || @options[:mobile_ready]
+      end
+
+      # Check if optimization analysis is needed
+      #
+      # @return [Boolean] True if optimization analysis should be run
+      def need_optimization_analysis?
+        return true unless @options[:quiet]
+
+        @options[:optimize]
+      end
+
+      # Check if metrics analysis is needed
+      #
+      # @return [Boolean] True if metrics analysis should be run
+      def need_metrics_analysis?
+        return true if ["yaml", "json"].include?(@options[:format])
+
+        @options[:metrics]
+      end
+    end
+  end
+end

data/lib/png_conform/services/chunk_processor.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "../validators/chunk_registry"
+require_relative "validator_pool"
+
+module PngConform
+  module Services
+    # Processes chunks through validation pipeline
+    #
+    # The ChunkProcessor handles:
+    # - Iterating through chunks from the reader
+    # - Creating validators via ChunkRegistry
+    # - Collecting validation results
+    # - Handling unknown chunk types
+    #
+    # This class extracts chunk processing logic from ValidationService
+    # following Single Responsibility Principle.
+    #
+    class ChunkProcessor
+      # Initialize chunk processor
+      #
+      # @param reader [Object] File reader (StreamingReader or FullLoadReader)
+      # @param context [ValidationContext] Validation context for state
+      # @param options [Hash] CLI options for controlling behavior
+      def initialize(reader, context, options = {})
+        @reader = reader
+        @context = context
+        @options = options
+        @validator_pool = ValidatorPool.new(options.slice(:max_per_type))
+      end
+
+      # Process all chunks from the reader
+      #
+      # Uses batch validation by default for performance (groups chunks by type).
+      # Falls back to individual processing if batch_disabled option is set.
+      # Supports early termination if fail_fast option is enabled.
+      #
+      # @yield [chunk] Optional block to receive chunks as they're processed
+      # @return [void]
+      def process(&block)
+        # Use batch validation by default (faster for files with many chunks)
+        if @options[:batch_enabled] == false
+          process_individual(&block)
+        else
+          process_batch_inline(&block)
+        end
+      end
+
+      private
+
+      # Process chunks in batch inline (collecting from reader)
+      #
+      # Performance optimization: groups chunks by type and validates
+      # in batches to reduce validator instantiation overhead.
+      #
+      # @return [void]
+      def process_batch_inline
+        # Collect all chunks first
+        chunk_groups = Hash.new { |h, k| h[k] = [] }
+
+        @reader.each_chunk do |chunk|
+          chunk_groups[chunk.chunk_type.to_s] << chunk
+          yield chunk if block_given?
+        end
+
+        # Validate each group together
+        chunk_groups.each do |chunk_type, chunks|
+          validate_chunk_batch(chunk_type, chunks)
+
+          # Early termination check after each batch
+          break if @options[:fail_fast] && @context.has_errors?
+        end
+      end
+
+      # Process chunks individually (original behavior)
+      #
+      # @return [void]
+      def process_individual
+        @reader.each_chunk do |chunk|
+          validate_chunk(chunk)
+          yield chunk if block_given?
+
+          break if @options[:fail_fast] && @context.has_errors?
+        end
+      end
+
+      # Process chunks in batch (performance optimization)
+      #
+      # Groups chunks by type and validates in batches to reduce
+      # validator instantiation overhead.
+      #
+      # @param chunks [Array] Array of chunks to validate
+      # @return [void]
+      def process_batch(chunks)
+        grouped = chunks.group_by { |c| c.chunk_type.to_s }
+
+        grouped.each do |chunk_type, chunk_group|
+          validate_chunk_batch(chunk_type, chunk_group)
+        end
+      end
+
+      # Validate a single chunk
+      #
+      # Gets validator from pool for this chunk type from ChunkRegistry,
+      # executes validation, and handles unknown chunks.
+      #
+      # @param chunk [Object] Chunk to validate
+      # @return [void]
+      def validate_chunk(chunk)
+        chunk_type = chunk.chunk_type.to_s
+        validator_class = Validators::ChunkRegistry.validator_for(chunk_type)
+
+        if validator_class
+          validator = @validator_pool.acquire(chunk_type, validator_class,
+                                              chunk, @context)
+          begin
+            validator.validate
+          ensure
+            @validator_pool.release(chunk_type, validator)
+          end
+        else
+          handle_unknown_chunk(chunk)
+        end
+
+        # Mark chunk as seen AFTER validation
+        # This allows validators to check for duplicates before marking
+        @context.mark_chunk_seen(chunk_type, chunk)
+      end
+
+      # Validate a batch of chunks of the same type
+      #
+      # Performance optimization: reduces validator instantiation
+      # overhead by pooling validators for multiple chunks of same type.
+      #
+      # @param chunk_type [String] Type of chunks in batch
+      # @param chunks [Array] Array of chunks of same type
+      # @return [void]
+      def validate_chunk_batch(chunk_type, chunks)
+        validator_class = Validators::ChunkRegistry.validator_for(chunk_type)
+
+        unless validator_class
+          # No validator for this chunk type - handle as unknown
+          chunks.each do |chunk|
+            handle_unknown_chunk(chunk)
+            @context.mark_chunk_seen(chunk.chunk_type.to_s, chunk)
+          end
+          return
+        end
+
+        chunks.each do |chunk|
+          validator = @validator_pool.acquire(chunk_type, validator_class,
+                                              chunk, @context)
+          begin
+            validator.validate
+          ensure
+            @validator_pool.release(chunk_type, validator)
+          end
+          @context.mark_chunk_seen(chunk_type, chunk)
+        end
+      end
+
+      # Handle unknown chunk types
+      #
+      # Unknown chunks are checked for safety:
+      # - If ancillary (bit 5 of first byte = 1), it's safe to ignore
+      # - If critical (bit 5 = 0), it's an error
+      #
+      # @param chunk [Object] Unknown chunk
+      # @return [void]
+      def handle_unknown_chunk(chunk)
+        chunk_type = chunk.chunk_type.to_s
+        first_byte = chunk_type.bytes[0]
+
+        # Bit 5 (0x20) of first byte indicates ancillary vs critical
+        if (first_byte & 0x20).zero?
+          # Critical chunk - must be recognized
+          @context.add_error(
+            chunk_type: chunk_type,
+            message: "Unknown critical chunk type: #{chunk_type}",
+            severity: :error,
+            offset: chunk.abs_offset,
+          )
+        else
+          # Ancillary chunk - safe to ignore
+          @context.add_error(
+            chunk_type: chunk_type,
+            message: "Unknown ancillary chunk type: #{chunk_type} (ignored)",
+            severity: :info,
+            offset: chunk.abs_offset,
+          )
+        end
+      end
+    end
+  end
+end