png_conform 0.1.0

data/lib/png_conform/commands/list_command.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../services/profile_manager"
+
+module PngConform
+  module Commands
+    # Command to list available validation profiles.
+    #
+    # Displays information about all available profiles including
+    # their requirements and restrictions.
+    class ListCommand
+      attr_reader :options
+
+      # @param options [Hash] Command-line options
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Execute the list command.
+      #
+      # @return [Integer] Exit code (always 0)
+      def run
+        profiles = Services::ProfileManager.available_profiles
+
+        puts "Available Validation Profiles:"
+        puts
+
+        profiles.each do |profile_name|
+          display_profile(profile_name)
+          puts
+        end
+
+        0
+      end
+
+      private
+
+      # Display information about a single profile.
+      #
+      # @param profile_name [String] Name of the profile to display
+      def display_profile(profile_name)
+        profile = Services::ProfileManager.get_profile(profile_name)
+
+        puts "  #{profile_name.upcase}"
+        puts "  #{'-' * (profile_name.length + 2)}"
+
+        puts "  Description: #{profile[:description]}" if profile[:description]
+
+        if profile[:required_chunks] && !profile[:required_chunks].empty?
+          puts "  Required chunks: #{profile[:required_chunks].join(', ')}"
+        end
+
+        if profile[:optional_chunks] && !profile[:optional_chunks].empty?
+          puts "  Optional chunks: #{profile[:optional_chunks].join(', ')}"
+        end
+
+        if profile[:prohibited_chunks] && !profile[:prohibited_chunks].empty?
+          puts "  Prohibited chunks: #{profile[:prohibited_chunks].join(', ')}"
+        end
+
+        return unless profile[:strict_mode]
+
+        puts "  Strict mode: enabled"
+      end
+    end
+  end
+end

data/lib/png_conform/models/chunk.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Models
+    # Domain model representing a PNG/MNG/JNG chunk
+    # This is the business logic representation, separate from binary parsing
+    class Chunk < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :length, :integer
+      attribute :data, :string
+      attribute :crc, :integer
+      attribute :offset, :integer
+      attribute :valid_crc, :boolean, default: -> { false }
+      attribute :crc_expected, :string
+      attribute :crc_actual, :string
+
+      # Create from BinData chunk structure
+      def self.from_bindata(bindata_chunk, offset = 0)
+        new(
+          type: bindata_chunk.type,
+          length: bindata_chunk.length,
+          data: bindata_chunk.data,
+          crc: bindata_chunk.crc,
+          offset: offset,
+          # valid_crc will be set by ValidationService
+        )
+      end
+
+      # Check if chunk is critical (uppercase first letter)
+      def critical?
+        type[0] == type[0].upcase
+      end
+
+      # Check if chunk is ancillary (lowercase first letter)
+      def ancillary?
+        !critical?
+      end
+
+      # Check if chunk is public (uppercase second letter)
+      def public?
+        type[1] == type[1].upcase
+      end
+
+      # Check if chunk is private (lowercase second letter)
+      def private?
+        !public?
+      end
+
+      # Check if chunk is reserved (uppercase third letter)
+      def reserved?
+        type[2] == type[2].upcase
+      end
+
+      # Check if chunk is safe to copy (lowercase fourth letter)
+      def safe_to_copy?
+        type[3] == type[3].downcase
+      end
+
+      # Get chunk type as symbol
+      def type_symbol
+        type.to_sym
+      end
+
+      # Get total size including all fields
+      def total_size
+        4 + 4 + length + 4
+      end
+
+      # Format offset as hex
+      def offset_hex
+        format("0x%05x", offset)
+      end
+
+      # Alias methods for CRC validation (compatibility with validators and specs)
+      def crc_valid?
+        valid_crc
+      end
+
+      def valid_crc?
+        valid_crc
+      end
+    end
+  end
+end

data/lib/png_conform/models/chunk_info.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module PngConform
+  module Models
+    # Domain model representing PNG chunk metadata
+    class ChunkInfo < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :offset, :integer
+      attribute :length, :integer
+      attribute :crc_valid, :boolean
+      attribute :critical, :boolean
+      attribute :private, :boolean
+      attribute :safe_to_copy, :boolean
+      attribute :decoded_data, DecodedChunkData
+
+      # Binary data - use attr_accessor to avoid Lutaml serialization corruption
+      attr_accessor :data, :crc
+
+      # Custom initializer to handle binary data fields
+      def initialize(attributes = {})
+        @data = attributes.delete(:data)
+        @crc = attributes.delete(:crc)
+        super(attributes)
+      end
+
+      # Format offset as hex for display
+      def offset_hex
+        format("0x%05x", offset)
+      end
+
+      # Chunk property summary
+      def properties
+        props = []
+        props << "critical" if critical
+        props << "ancillary" unless critical
+        props << "private" if private
+        props << "safe-to-copy" if safe_to_copy
+        props
+      end
+
+      # Format chunk for verbose output
+      # Example: "chunk IHDR at offset 0x0000c, length 13"
+      def summary
+        "chunk #{type} at offset #{offset_hex}, length #{length}"
+      end
+
+      # Format with decoded data
+      def detailed_summary
+        parts = [summary]
+        parts << decoded_data.summary if decoded_data
+        parts.join("\n    ")
+      end
+
+      # Aliases for compatibility with spec expectations
+      alias chunk_type type
+      alias abs_offset offset
+
+      # Force binary encoding for chunk data
+      def chunk_data
+        data&.b
+      end
+
+      # CRC validation method alias
+      def crc_valid?
+        crc_valid
+      end
+    end
+  end
+end

data/lib/png_conform/models/compression_info.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module PngConform
+  module Models
+    # Domain model representing PNG compression metadata
+    class CompressionInfo < Lutaml::Model::Serializable
+      attribute :uncompressed_size, :integer
+      attribute :compressed_size, :integer
+      attribute :compression_ratio, :float
+      attribute :window_bits, :integer
+      attribute :compression_level, :string
+
+      # Compression level constants
+      COMPRESSION_LEVELS = {
+        1 => "fastest",
+        6 => "default",
+        9 => "maximum",
+      }.freeze
+
+      # Calculate compression ratio from sizes
+      def self.calculate_ratio(uncompressed, compressed)
+        return 0.0 if uncompressed.zero?
+
+        ((compressed.to_f / uncompressed) - 1.0) * 100.0
+      end
+
+      # Get compression level name
+      def level_name
+        COMPRESSION_LEVELS[compression_level] || "custom"
+      end
+
+      # Format compression info for display
+      def summary
+        format("%.1f%%", compression_ratio)
+      end
+
+      # Format full details (for verbose mode)
+      def details
+        parts = []
+        parts << "deflated"
+        parts << "#{window_bits}K window" if window_bits
+        parts << "#{level_name} compression"
+        parts.join(", ")
+      end
+    end
+  end
+end

data/lib/png_conform/models/decoded_chunk_data.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module PngConform
+  module Models
+    # Base class for decoded chunk data
+    class DecodedChunkData < Lutaml::Model::Serializable
+      # Override in subclasses to provide formatted summary
+      def summary
+        ""
+      end
+    end
+
+    # IHDR chunk decoded data
+    class IhdrData < DecodedChunkData
+      attribute :width, :integer
+      attribute :height, :integer
+      attribute :bit_depth, :integer
+      attribute :color_type, :integer
+      attribute :compression_method, :integer
+      attribute :filter_method, :integer
+      attribute :interlace_method, :integer
+
+      COLOR_TYPE_NAMES = {
+        0 => "grayscale",
+        2 => "truecolor",
+        3 => "palette",
+        4 => "grayscale+alpha",
+        6 => "truecolor+alpha",
+      }.freeze
+
+      def color_type_name
+        COLOR_TYPE_NAMES[color_type] || "unknown"
+      end
+
+      def interlaced?
+        interlace_method == 1
+      end
+
+      def summary
+        parts = []
+        parts << "#{width} x #{height} image"
+        parts << "#{bit_depth}-bit #{color_type_name}"
+        parts << (interlaced? ? "interlaced" : "non-interlaced")
+        parts.join(", ")
+      end
+    end
+
+    # gAMA chunk decoded data
+    class GamaData < DecodedChunkData
+      attribute :gamma, :float
+
+      def summary
+        format("%.4f", gamma)
+      end
+    end
+
+    # IDAT chunk decoded data
+    class IdatData < DecodedChunkData
+      attribute :compression_method, :integer
+      attribute :window_bits, :integer
+      attribute :compression_level, :string
+      attribute :row_filters, :integer, collection: true
+
+      def summary
+        parts = []
+        parts << "zlib: deflated"
+        parts << "#{window_bits}K window" if window_bits
+        parts << "#{compression_level} compression" if compression_level
+        parts.join(", ")
+      end
+
+      # Format row filters for very verbose mode
+      def filter_summary
+        return nil if row_filters.nil? || row_filters.empty?
+
+        filter_names = {
+          0 => "none",
+          1 => "sub",
+          2 => "up",
+          3 => "avg",
+          4 => "paeth",
+        }
+        "row filters (#{filter_names.map do |k, v|
+          "#{k} #{v}"
+        end.join(', ')}):\n      #{row_filters.join(' ')}"
+      end
+    end
+
+    # Palette entry
+    class PaletteEntry < Lutaml::Model::Serializable
+      attribute :red, :integer
+      attribute :green, :integer
+      attribute :blue, :integer
+    end
+
+    # PLTE chunk decoded data
+    class PlteData < DecodedChunkData
+      attribute :entries, PaletteEntry, collection: true
+
+      def summary
+        "#{entries&.size || 0} palette entries"
+      end
+
+      # Format for palette printing mode
+      def detailed_entries
+        return [] unless entries
+
+        entries.each_with_index.map do |entry, index|
+          format("%3d:  (%3d,%3d,%3d) = (0x%02x,0x%02x,0x%02x)",
+                 index, entry.red, entry.green, entry.blue,
+                 entry.red, entry.green, entry.blue)
+        end
+      end
+    end
+
+    # tEXt chunk decoded data
+    class TextData < DecodedChunkData
+      attribute :keyword, :string
+      attribute :text, :string
+
+      def summary
+        "#{keyword}: #{text}"
+      end
+    end
+
+    # tIME chunk decoded data
+    class TimeData < DecodedChunkData
+      attribute :year, :integer
+      attribute :month, :integer
+      attribute :day, :integer
+      attribute :hour, :integer
+      attribute :minute, :integer
+      attribute :second, :integer
+
+      def summary
+        format("%04d-%02d-%02d %02d:%02d:%02d",
+               year, month, day, hour, minute, second)
+      end
+    end
+  end
+end

data/lib/png_conform/models/file_analysis.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module PngConform
+  module Models
+    # Top-level domain model for PNG file analysis
+    class FileAnalysis < Lutaml::Model::Serializable
+      attribute :file_path, :string
+      attribute :file_size, :integer
+      attribute :file_type, :string # 'PNG', 'MNG', 'JNG'
+      attribute :validation_result, ValidationResult
+      attribute :image_info, ImageInfo
+      attribute :compression_info, CompressionInfo
+
+      # Analyzer results (proper Model → Formatter pattern)
+      attribute :resolution_analysis, :hash
+      attribute :optimization_analysis, :hash
+      attribute :metrics, :hash
+
+      # Total chunk count
+      def chunk_count
+        chunks.size
+      end
+
+      # Get chunks (either from direct attribute or validation_result)
+      def chunks
+        validation_result&.chunks || []
+      end
+
+      # Check if file is valid
+      def valid?
+        validation_result&.valid? || false
+      end
+
+      # Get validation status text
+      def status
+        valid? ? "OK" : "ERROR"
+      end
+
+      # Format file header line (for verbose mode)
+      # Example: "File: file.png (164 bytes)"
+      def file_header
+        "File: #{file_path} (#{file_size} bytes)"
+      end
+
+      # Format summary line (default output mode)
+      # Example: "OK: file.png (32x32, 1-bit grayscale, non-interlaced, -28.1%)."
+      def summary_line
+        parts = []
+        parts << "#{status}:"
+        parts << file_path
+        if image_info
+          info_parts = []
+          info_parts << image_info.summary
+          info_parts << compression_info.summary if compression_info
+          parts << "(#{info_parts.join(', ')})"
+        end
+        "#{parts.join(' ')}."
+      end
+
+      # Format validation summary (for verbose mode)
+      # Example: "No errors detected in file.png (4 chunks, -28.1% compression)."
+      def validation_summary
+        return validation_result.error_summary if validation_result && !valid?
+
+        parts = []
+        parts << "No errors detected in #{file_path}"
+        detail_parts = []
+        detail_parts << "#{chunk_count} chunks" if chunk_count.positive?
+        if compression_info
+          detail_parts << "#{compression_info.summary} compression"
+        end
+        parts << "(#{detail_parts.join(', ')})" unless detail_parts.empty?
+        "#{parts.join(' ')}."
+      end
+
+      # Alias for compatibility with reporters
+      alias filename file_path
+
+      # Delegate to validation_result for API compatibility
+      def errors
+        validation_result&.errors || []
+      end
+
+      def error_messages
+        validation_result&.error_messages || []
+      end
+
+      def error_count
+        validation_result&.error_count || 0
+      end
+
+      def warning_count
+        validation_result&.warning_count || 0
+      end
+
+      def info_count
+        validation_result&.info_count || 0
+      end
+
+      # Delegate to compression_info
+      def compression_ratio
+        compression_info&.compression_ratio
+      end
+
+      # Convert to complete hash for serialization
+      # This provides a single source of truth for all output formats
+      def to_h
+        hash = {
+          "filename" => file_path,
+          "file_type" => file_type,
+          "file_size" => file_size,
+          "compression_ratio" => compression_ratio,
+          "crc_errors_count" => validation_result&.crc_errors_count || 0,
+          "valid" => valid?,
+        }
+
+        # Add image info if available
+        hash["image"] = image_info.to_h if image_info
+
+        # Add chunks info
+        if chunks.any?
+          hash["chunks"] = {
+            "total" => chunk_count,
+            "types" => chunks.map(&:type).uniq.sort,
+          }
+        end
+
+        # Add errors if any
+        if validation_result&.errors&.any?
+          hash["errors"] = validation_result.errors.map do |error|
+            error_hash = {
+              "severity" => error.severity,
+              "message" => error.message,
+            }
+            error_hash["chunk_type"] = error.chunk_type if error.chunk_type
+            error_hash["expected"] = error.expected if error.expected
+            error_hash["actual"] = error.actual if error.actual
+            error_hash
+          end
+        end
+
+        # Add resolution analysis if available
+        if resolution_analysis && !resolution_analysis.empty?
+          hash["resolution"] =
+            resolution_analysis
+        end
+
+        # Add optimization if available
+        if optimization_analysis && optimization_analysis[:suggestions]&.any?
+          hash["optimization"] = {
+            "suggestions" => optimization_analysis[:suggestions],
+            "total_savings_bytes" => optimization_analysis[:potential_savings_bytes],
+            "total_savings_percent" => optimization_analysis[:potential_savings_percent],
+          }
+        end
+
+        # Add recommendations
+        recs = extract_recommendations
+        hash["recommendations"] = recs if recs&.any?
+
+        hash
+      end
+
+      # Extract recommendations from analyzers
+      def extract_recommendations
+        recs = []
+
+        # From resolution analysis
+        if resolution_analysis && resolution_analysis[:recommendations]
+          recs.concat(resolution_analysis[:recommendations].map do |r|
+            r[:message]
+          end)
+        end
+
+        recs.empty? ? nil : recs
+      end
+    end
+  end
+end

data/lib/png_conform/models/file_info.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Models
+    # Domain model representing file metadata
+    class FileInfo < Lutaml::Model::Serializable
+      attribute :filename, :string
+      attribute :file_size, :integer
+      attribute :file_type, :string
+      attribute :signature, :string
+      attribute :width, :integer
+      attribute :height, :integer
+      attribute :bit_depth, :integer
+      attribute :color_type, :integer
+      attribute :compression_method, :integer
+      attribute :filter_method, :integer
+      attribute :interlace_method, :integer
+
+      # File types
+      FILE_TYPE_PNG = "PNG"
+      FILE_TYPE_MNG = "MNG"
+      FILE_TYPE_JNG = "JNG"
+      FILE_TYPE_UNKNOWN = "UNKNOWN"
+
+      # Color type constants (PNG)
+      COLOR_TYPE_GRAYSCALE = 0
+      COLOR_TYPE_RGB = 2
+      COLOR_TYPE_INDEXED = 3
+      COLOR_TYPE_GRAYSCALE_ALPHA = 4
+      COLOR_TYPE_RGB_ALPHA = 6
+
+      # Color type names
+      COLOR_TYPE_NAMES = {
+        COLOR_TYPE_GRAYSCALE => "grayscale",
+        COLOR_TYPE_RGB => "RGB",
+        COLOR_TYPE_INDEXED => "indexed",
+        COLOR_TYPE_GRAYSCALE_ALPHA => "grayscale+alpha",
+        COLOR_TYPE_RGB_ALPHA => "RGB+alpha",
+      }.freeze
+
+      # Get color type name
+      def color_type_name
+        COLOR_TYPE_NAMES[color_type] || "unknown"
+      end
+
+      # Get interlace method name
+      def interlace_method_name
+        case interlace_method
+        when 0 then "non-interlaced"
+        when 1 then "Adam7 interlaced"
+        else "unknown"
+        end
+      end
+
+      # Check if image is interlaced
+      def interlaced?
+        interlace_method == 1
+      end
+
+      # Get image dimensions as string
+      def dimensions
+        "#{width}x#{height}"
+      end
+
+      # Get bit depth description
+      def bit_depth_description
+        "#{bit_depth}-bit #{color_type_name}"
+      end
+
+      # Format signature as hex
+      def signature_hex
+        signature&.unpack1("H*")
+      end
+
+      # Check if file is PNG
+      def png?
+        file_type == FILE_TYPE_PNG
+      end
+
+      # Check if file is MNG
+      def mng?
+        file_type == FILE_TYPE_MNG
+      end
+
+      # Check if file is JNG
+      def jng?
+        file_type == FILE_TYPE_JNG
+      end
+    end
+  end
+end