png_conform 0.1.2 → 0.1.3

data/lib/png_conform/cli.rb

@@ -36,6 +36,10 @@ module PngConform
               --metrics               Show detailed metrics (JSON/YAML)
               --resolution            Show resolution and Retina analysis
               --mobile-ready          Check mobile and Retina readiness
+              --batch                 Enable batch chunk validation (default: enabled)
+              --no-batch              Disable batch chunk validation
+              --parallel, -j         Enable parallel processing for multiple files
+              --jobs, -j NUM         Number of parallel threads (default: CPU count)
 
             Examples:
               png_conform check image.png
@@ -72,6 +76,14 @@ module PngConform
                         desc: "Show resolution and Retina/DPI analysis"
     option :mobile_ready, type: :boolean, default: false,
                           desc: "Check mobile and Retina readiness"
+    option :batch, type: :boolean, default: true,
+                   desc: "Enable batch chunk validation (faster for files with many chunks)"
+    option :no_batch, type: :boolean, default: false,
+                      desc: "Disable batch chunk validation"
+    option :parallel, type: :boolean, default: false, aliases: "-j",
+                      desc: "Enable parallel processing for multiple files"
+    option :jobs, type: :numeric, default: nil, aliases: "-j",
+                  desc: "Number of parallel threads (default: CPU count)"
     def check(*files)
       Commands::CheckCommand.new(files, options).run
     end

data/lib/png_conform/commands/check_command.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../services/validation_service"
+require_relative "../container"
+require_relative "../utils/colorizer"
 require_relative "../services/profile_manager"
 require_relative "../reporters/reporter_factory"
-require_relative "../readers/streaming_reader"
 
 module PngConform
   module Commands
@@ -11,6 +11,7 @@ module PngConform
     #
     # Coordinates between readers, validators, and reporters to analyze
     # PNG files according to specified options and profiles.
+    #
     class CheckCommand
       attr_reader :files, :options
 
@@ -61,14 +62,105 @@ module PngConform
       end
 
       # Validate all specified files.
+      #
+      # Uses parallel validation if --parallel flag is set with multiple files.
+      # Otherwise processes files sequentially.
       def validate_files
         reporter = create_reporter
 
+        # Use parallel validation if enabled and multiple files
+        if files.length > 1 && @options[:parallel]
+          validate_files_parallel(reporter)
+        else
+          validate_files_sequential(reporter)
+        end
+      end
+
+      # Validate files sequentially (original behavior)
+      #
+      # @param reporter [Reporters::BaseReporter] Reporter for output
+      def validate_files_sequential(reporter)
         files.each do |file_path|
           validate_single_file(file_path, reporter)
         end
       end
 
+      # Validate files in parallel for better performance
+      #
+      # @param reporter [Reporters::BaseReporter] Reporter for output
+      def validate_files_parallel(reporter)
+        require_relative "../services/parallel_validator"
+
+        parallel_validator = Services::ParallelValidator.new(files, @options)
+        results = parallel_validator.validate_all
+
+        # Process results and report
+        results.each do |result|
+          if result.key?(:error)
+            handle_validation_error(result)
+            next
+          end
+
+          @errors_found = true unless result.valid?
+          reporter.report(result)
+
+          # Show additional analysis for text format
+          show_additional_analysis(result) if should_show_analysis?
+        end
+      rescue Interrupt
+        # Handle Ctrl+C gracefully
+        puts "\nValidation interrupted by user."
+        raise
+      rescue StandardError => e
+        puts "Error during parallel validation: #{e.message}"
+        puts e.backtrace.join("\n") if @options[:verbose]
+        @errors_found = true
+      end
+
+      # Handle validation error from parallel processing
+      #
+      # @param error_result [Hash] Error result from parallel validation
+      def handle_validation_error(error_result)
+        puts "Error: #{error_result[:error]}"
+        @errors_found = true
+
+        if error_result[:backtrace] && @options[:verbose]
+          puts "Backtrace:"
+          error_result[:backtrace].each { |line| puts "  #{line}" }
+        end
+      end
+
+      # Check if additional analysis should be shown
+      #
+      # @return [Boolean] True if analysis should be shown
+      def should_show_analysis?
+        return false if @options[:quiet]
+        return true if @options[:metrics] || @options[:mobile_ready] || @options[:resolution] || @options[:optimize]
+
+        # Text format shows analysis by default (unless quiet)
+        @options[:format].nil? || @options[:format] == "text"
+      end
+
+      # Show additional analysis (resolution, optimization, metrics)
+      #
+      # @param file_analysis [FileAnalysis] File analysis results
+      def show_additional_analysis(file_analysis)
+        show_resolution_analysis(file_analysis) if @options[:resolution] || @options[:mobile_ready]
+        show_optimization_suggestions(file_analysis) if @options[:optimize]
+        show_metrics(file_analysis) if @options[:metrics]
+        show_mobile_readiness(file_analysis) if @options[:mobile_ready]
+
+        # Default: show resolution and optimization for text format (unless quiet)
+        if (@options[:format].nil? || @options[:format] == "text") &&
+            !@options[:quiet] &&
+            !@options[:resolution] &&
+            !@options[:mobile_ready] &&
+            !@options[:optimize]
+          show_resolution_analysis(file_analysis)
+          show_optimization_suggestions(file_analysis)
+        end
+      end
+
       # Validate a single PNG file.
       #
       # @param file_path [String] Path to the PNG file
@@ -86,12 +178,12 @@ module PngConform
           return
         end
 
-        # Read and validate the file using streaming reader
-        Readers::StreamingReader.open(file_path) do |reader|
-          # Perform validation - pass options for conditional analyzers (Phase 1.1 + 1.2)
-          validator = Services::ValidationService.new(reader, file_path,
-                                                      options)
-          file_analysis = validator.validate
+        # Use container to create reader and orchestrator
+        Container.open_reader(:streaming, file_path) do |reader|
+          options_with_path = @options.merge(filepath: file_path)
+          orchestrator = Container.validation_orchestrator(reader, file_path,
+                                                           options_with_path)
+          file_analysis = orchestrator.validate
 
           # Track if any errors were found
           @errors_found = true unless file_analysis.valid?
@@ -99,15 +191,8 @@ module PngConform
           # Use reporter to output result
           reporter.report(file_analysis)
 
-          # For text output (default), show additional analysis unless quiet
-          if (options[:format].nil? || options[:format] == "text") && !options[:quiet]
-            show_resolution_analysis(file_analysis)
-            show_optimization_suggestions(file_analysis)
-          end
-
-          # Explicit flags always show
-          show_metrics(file_analysis) if options[:metrics]
-          show_mobile_readiness(file_analysis) if options[:mobile_ready]
+          # Show additional analysis
+          show_additional_analysis(file_analysis) if should_show_analysis?
         end
       rescue StandardError => e
         puts "Error processing #{file_path}: #{e.message}"
@@ -119,7 +204,7 @@ module PngConform
       #
       # @return [Reporters::BaseReporter] Reporter instance
       def create_reporter
-        Reporters::ReporterFactory.create(
+        Container.reporter(
           format: options[:format] || "text",
           verbose: options[:verbose] || options[:very_verbose],
           quiet: options[:quiet],
@@ -136,13 +221,10 @@ module PngConform
         return unless analysis && analysis[:suggestions]
         return if analysis[:suggestions].empty?
 
-        puts "\n#{colorize('OPTIMIZATION SUGGESTIONS:', :bold)}"
+        puts "\n#{Utils::Colorizer.bold('OPTIMIZATION SUGGESTIONS:')}"
         analysis[:suggestions].each_with_index do |suggestion, index|
-          priority_color = priority_color(suggestion[:priority])
-          priority_label = suggestion[:priority].to_s.upcase
-
-          puts "  #{index + 1}. [#{colorize(priority_label,
-                                            priority_color)}] #{suggestion[:description]}"
+          puts "  #{index + 1}. #{Utils::Colorizer.priority(suggestion[:description],
+                                                            suggestion[:priority])}"
           if suggestion[:savings_bytes]&.positive?
             puts "     Savings: #{format_bytes(suggestion[:savings_bytes])}"
           end
@@ -150,7 +232,7 @@ module PngConform
 
         total_savings = analysis[:potential_savings_bytes]
         if total_savings.positive?
-          puts "\n  #{colorize('Total Potential Savings:', :bold)} " \
+          puts "\n  #{Utils::Colorizer.bold('Total Potential Savings:')} " \
                "#{format_bytes(total_savings)} (#{analysis[:potential_savings_percent]}%)"
         end
       end
@@ -169,7 +251,7 @@ module PngConform
           puts metrics.to_yaml
         else
           # Text format with colored output
-          puts "\n#{colorize('METRICS:', :bold)}"
+          puts "\n#{Utils::Colorizer.bold('METRICS:')}"
           puts "  File: #{metrics[:file][:filename]} (#{metrics[:file][:size_kb]} KB)"
           puts "  Image: #{metrics[:image][:dimensions]}, #{metrics[:image][:color_type_name]}, " \
                "#{metrics[:image][:bit_depth]}-bit"
@@ -184,7 +266,7 @@ module PngConform
         analysis = file_analysis.resolution_analysis
         return unless analysis
 
-        puts "\n#{colorize('RESOLUTION ANALYSIS:', :bold)}"
+        puts "\n#{Utils::Colorizer.bold('RESOLUTION ANALYSIS:')}"
 
         # Basic info
         res = analysis[:resolution]
@@ -192,7 +274,7 @@ module PngConform
         puts "  DPI: #{res[:dpi] || 'Not specified'}"
 
         # Retina analysis
-        puts "\n  #{colorize('Retina Analysis:', :bold)}"
+        puts "\n  #{Utils::Colorizer.bold('Retina Analysis:')}"
         retina = analysis[:retina]
         puts "    @1x: #{retina[:at_1x][:dimensions_pt]} (#{retina[:at_1x][:suitable_for].first})"
         puts "    @2x: #{retina[:at_2x][:dimensions_pt]} (#{retina[:at_2x][:suitable_for].first})"
@@ -211,7 +293,7 @@ module PngConform
         # Print analysis if DPI available
         if analysis[:print][:capable]
           print_info = analysis[:print]
-          puts "\n  #{colorize('Print Analysis:', :bold)}"
+          puts "\n  #{Utils::Colorizer.bold('Print Analysis:')}"
           puts "    Quality: #{print_info[:quality]} (#{print_info[:dpi]} DPI)"
           phys = print_info[:physical_size]
           puts "    Physical Size: #{phys[:width_inches]}\" x #{phys[:height_inches]}\" " \
@@ -221,11 +303,10 @@ module PngConform
         # Recommendations
         recommendations = analysis[:recommendations]
         if recommendations && !recommendations.empty?
-          puts "\n  #{colorize('Recommendations:', :bold)}"
+          puts "\n  #{Utils::Colorizer.bold('Recommendations:')}"
           recommendations.each do |rec|
-            priority_color = priority_color(rec[:priority])
-            puts "    [#{colorize(rec[:priority].to_s.upcase,
-                                  priority_color)}] #{rec[:message]}"
+            puts "    #{Utils::Colorizer.priority(rec[:message],
+                                                  rec[:priority])}"
           end
         end
       end
@@ -235,7 +316,7 @@ module PngConform
         analysis = file_analysis.resolution_analysis
         return unless analysis
 
-        puts "\n#{colorize('MOBILE & RETINA READINESS:', :bold)}"
+        puts "\n#{Utils::Colorizer.bold('MOBILE & RETINA READINESS:')}"
 
         retina = analysis[:retina]
         web = analysis[:web]
@@ -243,10 +324,9 @@ module PngConform
         # Overall readiness
         is_ready = retina[:is_retina_ready] && web[:mobile_friendly]
         status = if is_ready
-                   colorize("✓ READY",
-                            :green)
+                   Utils::Colorizer.success("✓ READY")
                  else
-                   colorize("✗ NOT READY", :red)
+                   Utils::Colorizer.error("✗ NOT READY")
                  end
         puts "  Status: #{status}"
 
@@ -276,7 +356,7 @@ module PngConform
       # Helper methods for formatting
 
       def format_check(passed)
-        passed ? colorize("✓", :green) : colorize("✗", :red)
+        passed ? Utils::Colorizer.success("✓") : Utils::Colorizer.error("✗")
       end
 
       def format_bytes(bytes)
@@ -298,21 +378,6 @@ module PngConform
         end
       end
 
-      def colorize(text, color)
-        return text if options[:no_color]
-
-        codes = {
-          red: "\e[31m",
-          green: "\e[32m",
-          yellow: "\e[33m",
-          blue: "\e[34m",
-          bold: "\e[1m",
-          reset: "\e[0m",
-        }
-
-        "#{codes[color]}#{text}#{codes[:reset]}"
-      end
-
       # Determine the exit code based on whether errors were found.
       #
       # @return [Integer] Exit code (0 for success, 1 for errors)

data/lib/png_conform/configuration.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module PngConform
+  # Application configuration
+  #
+  # Centralized configuration for all hardcoded values across the codebase.
+  # Provides a single source of truth for constants and settings.
+  #
+  class Configuration
+    attr_accessor :retina_densities, :print_dpi_thresholds,
+                  :network_speeds, :optimization_thresholds,
+                  :color_enabled, :screen_dpi, :css_reference_dpi,
+                  :retina_scalers, :unnecessary_web_chunks,
+                  :text_chunks, :metadata_chunks,
+                  :optimization_percentages, :size_thresholds
+
+    class << self
+      # Get the singleton instance
+      #
+      # @return [Configuration] Configuration instance
+      def instance
+        @instance ||= new
+      end
+
+      # Reset configuration to defaults
+      #
+      # @return [void]
+      def reset!
+        @instance = new
+      end
+    end
+
+    # Initialize configuration with defaults
+    #
+    def initialize
+      # Retina display densities (Android buckets)
+      @retina_densities = {
+        mdpi: 160,
+        hdpi: 320,
+        xhdpi: 480,
+        xxhdpi: 640,
+      }
+
+      # Print DPI quality thresholds
+      @print_dpi_thresholds = {
+        minimum: 150,
+        good: 300,
+        excellent: 600,
+      }
+
+      # Network speeds for load time estimation (bytes per second)
+      @network_speeds = {
+        slow: 1_000_000, # 1 Mbps
+        fast: 10_000_000, # 10 Mbps
+      }
+
+      # Optimization percentage thresholds
+      @optimization_thresholds = {
+        high_savings: 30, # 30%
+        medium_savings: 10, # 10%
+      }
+
+      # Color output enabled
+      @color_enabled = true
+
+      # Screen DPI constants
+      @screen_dpi = 72
+
+      # CSS reference DPI for Retina calculations
+      @css_reference_dpi = 163
+
+      # Retina display scaling factors
+      @retina_scalers = {
+        "1x": 1.0,
+        "2x": 2.0,
+        "3x": 3.0,
+      }
+
+      # Chunks unnecessary for web/mobile use
+      @unnecessary_web_chunks = %w[tIME pHYs oFFs pCAL sCAL sTER].freeze
+
+      # Text chunk types
+      @text_chunks = %w[tEXt zTXt iTXt].freeze
+
+      # Metadata chunk types
+      @metadata_chunks = %w[tEXt zTXt iTXt tIME pHYs].freeze
+
+      # Optimization savings percentages
+      @optimization_percentages = {
+        bit_depth_reduction: 45, # % savings for 16->8 bit
+        palette_conversion: 30,    # % savings for RGB->palette
+        interlace_removal: 15,     # % savings for removing interlace
+        metadata_threshold: 10, # % of file size to flag excessive metadata
+      }
+
+      # Size thresholds
+      @size_thresholds = {
+        palette_opportunity: 10_000, # bytes - min file size to suggest palette
+        text_metadata: 500,          # bytes - min text metadata size to flag
+        small_file: 100_000,         # bytes - file size considered "small"
+        retina_ready_min: 88,        # pixels - min dimension for retina ready
+        very_large: 3000,            # pixels - dimension considered "very large"
+        large_for_mobile: 1920,      # pixels - max dimension for mobile friendly
+        large_for_web: 4096, # pixels - max dimension for web suitable
+      }
+    end
+
+    # Get density value by name
+    #
+    # @param name [Symbol] Density name (:mdpi, :hdpi, :xhdpi, :xxhdpi)
+    # @return [Integer] DPI value
+    def retina_density(name)
+      @retina_densities[name] || @retina_densities[:hdpi]
+    end
+
+    # Get print DPI threshold by name
+    #
+    # @param name [Symbol] Threshold name (:minimum, :good, :excellent)
+    # @return [Integer] DPI value
+    def print_dpi_threshold(name)
+      @print_dpi_thresholds[name] || @print_dpi_thresholds[:good]
+    end
+
+    # Get network speed by name
+    #
+    # @param name [Symbol] Speed name (:slow, :fast)
+    # @return [Integer] Bytes per second
+    def network_speed(name)
+      @network_speeds[name] || @network_speeds[:fast]
+    end
+
+    # Get optimization threshold by name
+    #
+    # @param name [Symbol] Threshold name (:high_savings, :medium_savings)
+    # @return [Integer] Percentage threshold
+    def optimization_threshold(name)
+      @optimization_thresholds[name] || @optimization_thresholds[:medium_savings]
+    end
+
+    # Check if colors are enabled
+    #
+    # @return [Boolean] true if colors are enabled
+    def color_enabled?
+      @color_enabled
+    end
+  end
+end

data/lib/png_conform/container.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "readers/streaming_reader"
+require_relative "services/profile_manager"
+require_relative "services/analysis_manager"
+
+module PngConform
+  # Dependency Injection Container
+  #
+  # Centralized dependency management for the application.
+  # Provides factory methods for creating readers, validators, reporters,
+  # and other services with proper dependency injection.
+  #
+  # This makes testing easier by allowing mock injection and provides
+  # a single source of truth for object creation.
+  #
+  class Container
+    class << self
+      # Create a reader for the given type and filepath
+      #
+      # @param type [Symbol] Reader type (:streaming or :full_load)
+      # @param filepath [String] Path to PNG file
+      # @param options [Hash] Additional options for the reader
+      # @return [Object] Reader instance
+      def reader(type, filepath, options = {})
+        case type
+        when :streaming
+          io = File.open(filepath, "rb")
+          Readers::StreamingReader.new(io, options)
+        when :full_load
+          Readers::FullLoadReader.new(filepath, options)
+        else
+          raise ArgumentError, "Unknown reader type: #{type}"
+        end
+      end
+
+      # Open a reader with automatic file closing
+      #
+      # @param type [Symbol] Reader type (:streaming or :full_load)
+      # @param filepath [String] Path to PNG file
+      # @param options [Hash] Additional options for the reader
+      # @yield [reader] Reader instance
+      # @return [Object] Result of the block
+      def open_reader(type, filepath, _options = {}, &block)
+        case type
+        when :streaming
+          Readers::StreamingReader.open(filepath, &block)
+        when :full_load
+          Readers::FullLoadReader.open(filepath, &block)
+        else
+          raise ArgumentError, "Unknown reader type: #{type}"
+        end
+      end
+
+      # Create a validator for a chunk
+      #
+      # Delegates to ChunkRegistry for validator creation
+      #
+      # @param chunk [Object] Chunk object
+      # @param context [ValidationContext] Validation context
+      # @return [Object] Validator instance or nil
+      def validator(chunk, context)
+        require_relative "validators/chunk_registry"
+        Validators::ChunkRegistry.create_validator(chunk, context)
+      end
+
+      # Create a reporter based on options
+      #
+      # Delegates to ReporterFactory for reporter creation
+      #
+      # @param options [Hash] Reporter options
+      # @return [Object] Reporter instance
+      def reporter(options)
+        require_relative "reporters/reporter_factory"
+        Reporters::ReporterFactory.create(**options)
+      end
+
+      # Get the profile manager singleton
+      #
+      # @return [ProfileManager] Profile manager instance
+      def profile_manager
+        @profile_manager ||= Services::ProfileManager.new
+      end
+
+      # Create an analysis manager
+      #
+      # @param options [Hash] Analysis options
+      # @return [AnalysisManager] Analysis manager instance
+      def analysis_manager(options = {})
+        Services::AnalysisManager.new(options)
+      end
+
+      # Create a validation orchestrator
+      #
+      # @param reader [Object] File reader
+      # @param filepath [String] File path
+      # @param options [Hash] Validation options
+      # @return [ValidationOrchestrator] Orchestrator instance
+      def validation_orchestrator(reader, filepath = nil, options = {})
+        require_relative "services/validation_orchestrator"
+        Services::ValidationOrchestrator.new(reader, filepath, options)
+      end
+      alias_method :validation_service, :validation_orchestrator
+
+      # Reset container state
+      #
+      # Clears cached instances (useful for testing)
+      def reset!
+        @profile_manager = nil
+      end
+    end
+  end
+end

data/lib/png_conform/models/validation_result.rb

@@ -13,15 +13,26 @@ module PngConform
       attribute :compression_ratio, :float
       attribute :crc_errors_count, :integer, default: -> { 0 }
 
+      # Non-serialized hash map for fast chunk type lookup
+      attr_reader :chunks_by_type_map
+
       # File types
       FILE_TYPE_PNG = "PNG"
       FILE_TYPE_MNG = "MNG"
       FILE_TYPE_JNG = "JNG"
       FILE_TYPE_UNKNOWN = "UNKNOWN"
 
+      # Initialize with hash map for fast lookups
+      def initialize(*args)
+        super(*args)
+        @chunks_by_type_map = {}
+        rebuild_chunks_map
+      end
+
       # Add a chunk to the result
       def add_chunk(chunk)
         chunks << chunk
+        add_to_chunks_map(chunk)
       end
 
       # Add an error to the result
@@ -90,14 +101,14 @@ module PngConform
         chunks.count
       end
 
-      # Find chunks by type
+      # Find chunks by type (O(1) hash lookup)
       def chunks_by_type(type)
-        chunks.select { |chunk| chunk.type == type }
+        @chunks_by_type_map[type] || []
       end
 
-      # Check if file has specific chunk type
+      # Check if file has specific chunk type (O(1) hash lookup)
       def has_chunk?(type)
-        chunks.any? { |chunk| chunk.type == type }
+        @chunks_by_type_map.key?(type) && !@chunks_by_type_map[type].empty?
       end
 
       # Get IHDR chunk (PNG/JNG)
@@ -132,6 +143,21 @@ module PngConform
         end
         parts.join("\n")
       end
+
+      private
+
+      # Add chunk to hash map for fast lookup
+      def add_to_chunks_map(chunk)
+        chunk_type = chunk.type
+        @chunks_by_type_map[chunk_type] ||= []
+        @chunks_by_type_map[chunk_type] << chunk
+      end
+
+      # Rebuild hash map from chunks (for deserialization or external modification)
+      def rebuild_chunks_map
+        @chunks_by_type_map.clear
+        chunks.each { |chunk| add_to_chunks_map(chunk) }
+      end
     end
   end
 end

data/lib/png_conform/pipelines/pipeline_result.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Pipelines
+    # Result object for pipeline stages
+    #
+    # Carries state through the validation pipeline.
+    #
+    class PipelineResult
+      attr_accessor :ready_for_analysis
+      attr_reader :context, :chunks
+
+      # Initialize pipeline result
+      #
+      # @param context [ValidationContext] Validation context
+      # @param chunks [Array] Array of chunks
+      def initialize(context:, chunks: [])
+        @context = context
+        @chunks = chunks
+        @ready_for_analysis = false
+      end
+
+      # Check if validation has errors
+      #
+      # @return [Boolean] true if there are errors
+      def has_errors?
+        @context.has_errors?
+      end
+
+      # Check if validation should terminate early
+      #
+      # @param fail_fast [Boolean] Whether fail_fast is enabled
+      # @return [Boolean] true if should terminate
+      def should_terminate?(fail_fast: false)
+        fail_fast && has_errors?
+      end
+    end
+  end
+end