png_conform 0.1.1 → 0.1.3

data/lib/png_conform/analyzers/resolution_analyzer.rb

@@ -1,22 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "../configuration"
+
 module PngConform
   module Analyzers
     # Analyzes PNG resolution and DPI for various use cases
     class ResolutionAnalyzer
-      # Standard DPI values
-      SCREEN_DPI = 72
-      PRINT_DPI_LOW = 150
-      PRINT_DPI_STANDARD = 300
-      PRINT_DPI_HIGH = 600
-
-      # Retina display densities
-      RETINA_1X = 1.0
-      RETINA_2X = 2.0
-      RETINA_3X = 3.0
-
-      def initialize(result)
+      def initialize(result, config: Configuration.instance)
         @result = result
+        @config = config
         ihdr = result.ihdr_chunk
         @width = ihdr ? get_width(ihdr) : 0
         @height = ihdr ? get_height(ihdr) : 0
@@ -63,9 +55,9 @@ module PngConform
       def retina_analysis
         analysis = {
           is_retina_ready: check_retina_ready,
-          at_1x: calculate_physical_size(RETINA_1X),
-          at_2x: calculate_physical_size(RETINA_2X),
-          at_3x: calculate_physical_size(RETINA_3X),
+          at_1x: calculate_physical_size(@config.retina_scalers["1x"]),
+          at_2x: calculate_physical_size(@config.retina_scalers["2x"]),
+          at_3x: calculate_physical_size(@config.retina_scalers["3x"]),
         }
 
         analysis[:recommended_density] = recommend_density
@@ -82,7 +74,7 @@ module PngConform
         height_inches = @height.to_f / @dpi
 
         {
-          capable: @dpi >= PRINT_DPI_LOW,
+          capable: @dpi >= @config.print_dpi_thresholds[:minimum],
           dpi: @dpi,
           physical_size: {
             width_inches: width_inches.round(2),
@@ -97,9 +89,11 @@ module PngConform
 
       def web_analysis
         {
-          suitable_for_web: @width <= 4096 && @height <= 4096,
+          suitable_for_web: @width <= @config.size_thresholds[:large_for_web] &&
+            @height <= @config.size_thresholds[:large_for_web],
           typical_screen_size: calculate_screen_coverage,
-          mobile_friendly: @width <= 1920 && @height <= 1920,
+          mobile_friendly: @width <= @config.size_thresholds[:large_for_mobile] &&
+            @height <= @config.size_thresholds[:large_for_mobile],
           retina_optimized: @width >= 1000 && @height >= 1000,
           load_time_estimate: estimate_load_time,
         }
@@ -119,15 +113,15 @@ module PngConform
       end
 
       def check_retina_ready
-        @width >= 88 && @height >= 88
+        @width >= @config.size_thresholds[:retina_ready_min] &&
+          @height >= @config.size_thresholds[:retina_ready_min]
       end
 
       def calculate_physical_size(density)
-        css_reference_dpi = 163
-        effective_dpi = css_reference_dpi * density
+        effective_dpi = @config.css_reference_dpi * density
 
-        width_points = (@width.to_f / effective_dpi * 72).round(1)
-        height_points = (@height.to_f / effective_dpi * 72).round(1)
+        width_points = (@width.to_f / effective_dpi * @config.screen_dpi).round(1)
+        height_points = (@height.to_f / effective_dpi * @config.screen_dpi).round(1)
 
         {
           width_points: width_points,
@@ -181,15 +175,19 @@ module PngConform
         return "Unknown" unless @dpi
 
         case @dpi
-        when 0...PRINT_DPI_LOW then "Not suitable"
-        when PRINT_DPI_LOW...PRINT_DPI_STANDARD then "Acceptable"
-        when PRINT_DPI_STANDARD...PRINT_DPI_HIGH then "Good"
-        else "Excellent"
+        when 0...@config.print_dpi_thresholds[:minimum]
+          "Not suitable"
+        when @config.print_dpi_thresholds[:minimum]...@config.print_dpi_thresholds[:good]
+          "Acceptable"
+        when @config.print_dpi_thresholds[:good]...@config.print_dpi_thresholds[:excellent]
+          "Good"
+        else
+          "Excellent"
         end
       end
 
       def suitable_print_sizes
-        return [] unless @dpi && @dpi >= PRINT_DPI_LOW
+        return [] unless @dpi && @dpi >= @config.print_dpi_thresholds[:minimum]
 
         width_in = @width.to_f / @dpi
         height_in = @height.to_f / @dpi
@@ -227,8 +225,7 @@ module PngConform
 
       def estimate_load_time
         file_size = @result.file_size
-        mbps = 5
-        bytes_per_second = (mbps * 1_000_000 / 8).to_i
+        bytes_per_second = @config.network_speeds[:fast]
         seconds = file_size.to_f / bytes_per_second
 
         if seconds < 0.1
@@ -243,7 +240,8 @@ module PngConform
       def generate_recommendations
         recs = []
 
-        if @width < 100 && @height < 100
+        if @width < @config.size_thresholds[:retina_ready_min] &&
+            @height < @config.size_thresholds[:retina_ready_min]
           recs << {
             category: :retina,
             priority: :high,
@@ -259,7 +257,8 @@ module PngConform
           }
         end
 
-        if @width > 3000 || @height > 3000
+        if @width > @config.size_thresholds[:very_large] ||
+            @height > @config.size_thresholds[:very_large]
           recs << {
             category: :web,
             priority: :high,

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,11 +178,12 @@ module PngConform
           return
         end
 
-        # Read and validate the file using streaming reader
-        Readers::StreamingReader.open(file_path) do |reader|
-          # Perform validation
-          validator = Services::ValidationService.new(reader, file_path)
-          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?
@@ -98,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}"
@@ -118,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],
@@ -135,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
@@ -149,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
@@ -168,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"
@@ -183,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]
@@ -191,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})"
@@ -210,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]}\" " \
@@ -220,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
@@ -234,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]
@@ -242,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}"
 
@@ -275,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)
@@ -297,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