png_conform 0.1.0

data/lib/png_conform/validators/ancillary/text_validator.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG tEXt (Textual Data) chunk
+      #
+      # tEXt contains textual information as keyword/text pairs:
+      # - Keyword (1-79 bytes, Latin-1)
+      # - Null separator (1 byte)
+      # - Text (0+ bytes, Latin-1)
+      #
+      # Validation rules from PNG spec:
+      # - Keyword must be 1-79 characters
+      # - Keyword must contain only Latin-1 printable characters
+      # - Keyword must not have leading/trailing spaces
+      # - Keyword must not have consecutive spaces
+      # - Null separator must be present
+      # - Multiple tEXt chunks allowed with different keywords
+      class TextValidator < BaseValidator
+        # Maximum keyword length
+        MAX_KEYWORD_LENGTH = 79
+
+        # Latin-1 printable characters (space to tilde + high ASCII)
+        PRINTABLE_LATIN1 = (32..126).to_a + (161..255).to_a
+
+        # Validate tEXt chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_structure
+          return false unless check_keyword
+
+          store_text_info
+          true
+        end
+
+        private
+
+        # Check tEXt chunk structure
+        def check_structure
+          data = chunk.chunk_data
+
+          # Must contain at least keyword + null
+          if data.length < 2
+            add_error("tEXt chunk too short (minimum 2 bytes)")
+            return false
+          end
+
+          # Must contain null separator
+          null_pos = data.index("\0")
+          unless null_pos
+            add_error("tEXt chunk missing null separator")
+            return false
+          end
+
+          true
+        end
+
+        # Check keyword validity
+        def check_keyword
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          keyword = data[0, null_pos]
+
+          # Check keyword length
+          if keyword.empty?
+            add_error("tEXt chunk has empty keyword")
+            return false
+          end
+
+          if keyword.length > MAX_KEYWORD_LENGTH
+            add_error("tEXt keyword too long (#{keyword.length}, " \
+                      "max #{MAX_KEYWORD_LENGTH})")
+            return false
+          end
+
+          # Check for Latin-1 printable characters
+          keyword.bytes.each do |byte|
+            next if PRINTABLE_LATIN1.include?(byte)
+
+            add_error("tEXt keyword contains non-printable character " \
+                      "(0x#{byte.to_s(16)})")
+            return false
+          end
+
+          # Check for leading/trailing spaces
+          if keyword.start_with?(" ")
+            add_error("tEXt keyword has leading space")
+            return false
+          end
+
+          if keyword.end_with?(" ")
+            add_error("tEXt keyword has trailing space")
+            return false
+          end
+
+          # Check for consecutive spaces
+          if keyword.include?("  ")
+            add_error("tEXt keyword has consecutive spaces")
+            return false
+          end
+
+          true
+        end
+
+        # Store text information in context
+        def store_text_info
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          keyword = data[0, null_pos]
+          text = data[(null_pos + 1)..] || ""
+
+          # Store in context (allow multiple text chunks)
+          texts = context.retrieve(:text_chunks) || []
+          texts << { keyword: keyword, text: text, compressed: false }
+          context.store(:text_chunks, texts)
+
+          # Add info about the text chunk
+          text_preview = text.length > 40 ? "#{text[0, 40]}..." : text
+          add_info("tEXt: #{keyword} = \"#{text_preview}\"")
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/ancillary/time_validator.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG tIME (Image Last-Modification Time) chunk
+      #
+      # tIME specifies the time of the last image modification:
+      # - Year (2 bytes, complete; e.g., 1995, not 95)
+      # - Month (1 byte, 1-12)
+      # - Day (1 byte, 1-31)
+      # - Hour (1 byte, 0-23)
+      # - Minute (1 byte, 0-59)
+      # - Second (1 byte, 0-60, to allow for leap seconds)
+      #
+      # Validation rules from PNG spec:
+      # - Must be exactly 7 bytes
+      # - Only one tIME chunk allowed
+      # - Month must be 1-12
+      # - Day must be 1-31
+      # - Hour must be 0-23
+      # - Minute must be 0-59
+      # - Second must be 0-60 (60 for leap seconds)
+      class TimeValidator < BaseValidator
+        # Validate tIME chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_length(7)
+          return false unless check_uniqueness
+          return false unless check_datetime
+
+          store_time_info
+          true
+        end
+
+        private
+
+        # Check that only one tIME chunk is present
+        def check_uniqueness
+          if context.seen?("tIME")
+            add_error("duplicate tIME chunk")
+            return false
+          end
+          true
+        end
+
+        # Check date and time values
+        def check_datetime
+          data = chunk.chunk_data
+          year = data[0, 2].unpack1("n")
+          month = data[2].unpack1("C")
+          day = data[3].unpack1("C")
+          hour = data[4].unpack1("C")
+          minute = data[5].unpack1("C")
+          second = data[6].unpack1("C")
+
+          valid = true
+
+          # PNG was created in 1996, so years before that are invalid
+          if year < 1996
+            add_error("invalid tIME year (before PNG existed!) (#{year})")
+            valid = false
+          end
+
+          valid &= check_range(month, 1, 12, "month")
+          valid &= check_range(day, 1, 31, "day")
+          valid &= check_range(hour, 0, 23, "hour")
+          valid &= check_range(minute, 0, 59, "minute")
+          valid &= check_range(second, 0, 60, "second")
+
+          # Additional day validation based on month
+          if valid && !valid_day_for_month?(year, month, day)
+            add_error("invalid day (#{day}) for month #{month}")
+            valid = false
+          end
+
+          valid
+        end
+
+        # Check if day is valid for given month and year
+        def valid_day_for_month?(year, month, day)
+          days_in_month = case month
+                          when 2
+                            leap_year?(year) ? 29 : 28
+                          when 4, 6, 9, 11
+                            30
+                          else
+                            31
+                          end
+
+          day <= days_in_month
+        end
+
+        # Check if year is a leap year
+        def leap_year?(year)
+          (year % 4).zero? && ((year % 100 != 0) || (year % 400).zero?)
+        end
+
+        # Store time information in context
+        def store_time_info
+          data = chunk.chunk_data
+          year = data[0, 2].unpack1("n")
+          month = data[2].unpack1("C")
+          day = data[3].unpack1("C")
+          hour = data[4].unpack1("C")
+          minute = data[5].unpack1("C")
+          second = data[6].unpack1("C")
+
+          timestamp = {
+            year: year,
+            month: month,
+            day: day,
+            hour: hour,
+            minute: minute,
+            second: second,
+          }
+
+          context.store(:modification_time, timestamp)
+
+          # Format as ISO 8601
+          iso_time = format("%04d-%02d-%02d %02d:%02d:%02d UTC",
+                            year, month, day, hour, minute, second)
+          add_info("tIME: #{iso_time}")
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/ancillary/trns_validator.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG tRNS (Transparency) chunk
+      #
+      # tRNS specifies transparency information:
+      # - For grayscale: 2-byte gray sample value
+      # - For truecolor: 6-byte RGB sample values
+      # - For indexed-color: alpha values for palette entries
+      #
+      # Validation rules from PNG spec:
+      # - Must appear before IDAT
+      # - Only one tRNS chunk allowed
+      # - For indexed-color, must appear after PLTE
+      # - For indexed-color, length must not exceed palette size
+      # - Not allowed for grayscale+alpha or truecolor+alpha
+      class TrnsValidator < BaseValidator
+        # Validate tRNS chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_position
+          return false unless check_uniqueness
+          return false unless check_color_type_compatibility
+          return false unless check_length_for_color_type
+
+          store_transparency_info
+          true
+        end
+
+        private
+
+        # Check tRNS position relative to other chunks
+        def check_position
+          valid = true
+
+          # tRNS must appear before IDAT
+          if context.seen?("IDAT")
+            add_error("tRNS chunk after IDAT (must be before)")
+            valid = false
+          end
+
+          # For indexed-color, tRNS must appear after PLTE
+          color_type = context.retrieve(:color_type)
+          if color_type == 3 && !context.seen?("PLTE")
+            add_error("tRNS chunk before PLTE for indexed-color image")
+            valid = false
+          end
+
+          valid
+        end
+
+        # Check that only one tRNS chunk is present
+        def check_uniqueness
+          if context.retrieve(:has_transparency)
+            add_error("duplicate tRNS chunk")
+            return false
+          end
+          true
+        end
+
+        # Check tRNS compatibility with color type
+        def check_color_type_compatibility
+          color_type = context.retrieve(:color_type)
+          return true unless color_type # IHDR not validated yet
+
+          case color_type
+          when 0, 2, 3
+            # Grayscale, truecolor, indexed-color: tRNS allowed
+            true
+          when 4, 6
+            # Grayscale+alpha, truecolor+alpha: tRNS forbidden
+            add_error("tRNS chunk not allowed for color type with " \
+                      "alpha channel")
+            false
+          else
+            add_warning("tRNS chunk present but color type unknown")
+            true
+          end
+        end
+
+        # Check tRNS length for color type
+        def check_length_for_color_type
+          color_type = context.retrieve(:color_type)
+          return true unless color_type
+
+          length = chunk.chunk_data.length
+
+          case color_type
+          when 0
+            # Grayscale: must be 2 bytes
+            check_length(2)
+          when 2
+            # Truecolor: must be 6 bytes (RGB)
+            check_length(6)
+          when 3
+            # Indexed-color: 1-256 bytes (alpha for each palette entry)
+            palette_entries = context.retrieve(:palette_entries)
+
+            # Check if palette exists
+            unless context.retrieve(:has_palette)
+              add_error("tRNS chunk for indexed-color without PLTE chunk")
+              return false
+            end
+
+            # Check length doesn't exceed palette size
+            if palette_entries && length > palette_entries
+              add_error("tRNS has more entries than palette " \
+                        "(#{length} > #{palette_entries})")
+              return false
+            end
+
+            return true if length >= 1 && length <= 256
+
+            add_error("invalid tRNS length for indexed-color " \
+                      "(#{length}, must be 1-256)")
+            false
+          else
+            true
+          end
+        end
+
+        # Store transparency information in context
+        def store_transparency_info
+          context.store(:has_transparency, true)
+
+          color_type = context.retrieve(:color_type)
+          data = chunk.chunk_data
+
+          case color_type
+          when 0
+            # Grayscale: store gray value
+            gray = data.unpack1("n")
+            context.store(:transparent_gray, gray)
+          when 2
+            # Truecolor: store RGB values
+            r, g, b = data.unpack("nnn")
+            context.store(:transparent_color, { r: r, g: g, b: b })
+          when 3
+            # Indexed-color: store alpha values
+            alphas = data.unpack("C*")
+            context.store(:palette_alphas, alphas)
+            context.store(:transparent_entries, alphas.length)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/ancillary/ztxt_validator.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+require "zlib"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG zTXt (Compressed Textual Data) chunk
+      #
+      # zTXt contains compressed textual information as keyword/text pairs:
+      # - Keyword (1-79 bytes, Latin-1)
+      # - Null separator (1 byte)
+      # - Compression method (1 byte, must be 0)
+      # - Compressed text (0+ bytes, deflate compressed)
+      #
+      # Validation rules from PNG spec:
+      # - Keyword must be 1-79 characters
+      # - Keyword must contain only Latin-1 printable characters
+      # - Keyword must not have leading/trailing spaces
+      # - Keyword must not have consecutive spaces
+      # - Compression method must be 0 (deflate)
+      # - Text must be successfully decompressible
+      # - Multiple zTXt chunks allowed with different keywords
+      class ZtxtValidator < BaseValidator
+        # Maximum keyword length
+        MAX_KEYWORD_LENGTH = 79
+
+        # Latin-1 printable characters (space to tilde + high ASCII)
+        PRINTABLE_LATIN1 = (32..126).to_a + (161..255).to_a
+
+        # Valid compression method
+        COMPRESSION_DEFLATE = 0
+
+        # Validate zTXt chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_structure
+          return false unless check_keyword
+          return false unless check_compression_method
+          return false unless check_decompression
+
+          store_text_info
+          true
+        end
+
+        private
+
+        # Check zTXt chunk structure
+        def check_structure
+          data = chunk.chunk_data
+
+          # Must contain at least keyword + null + compression method
+          if data.length < 3
+            add_error("zTXt chunk too short (minimum 3 bytes)")
+            return false
+          end
+
+          # Must contain null separator
+          null_pos = data.index("\0")
+          unless null_pos
+            add_error("zTXt chunk missing null separator")
+            return false
+          end
+
+          true
+        end
+
+        # Check keyword validity
+        def check_keyword
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          keyword = data[0, null_pos]
+
+          # Check keyword length
+          if keyword.empty?
+            add_error("zTXt chunk has empty keyword")
+            return false
+          end
+
+          if keyword.length > MAX_KEYWORD_LENGTH
+            add_error("zTXt keyword too long (#{keyword.length}, " \
+                      "max #{MAX_KEYWORD_LENGTH})")
+            return false
+          end
+
+          # Check for Latin-1 printable characters
+          keyword.bytes.each do |byte|
+            next if PRINTABLE_LATIN1.include?(byte)
+
+            add_error("zTXt keyword contains non-printable character " \
+                      "(0x#{byte.to_s(16)})")
+            return false
+          end
+
+          # Check for leading/trailing spaces
+          if keyword.start_with?(" ")
+            add_error("zTXt keyword has leading space")
+            return false
+          end
+
+          if keyword.end_with?(" ")
+            add_error("zTXt keyword has trailing space")
+            return false
+          end
+
+          # Check for consecutive spaces
+          if keyword.include?("  ")
+            add_error("zTXt keyword has consecutive spaces")
+            return false
+          end
+
+          true
+        end
+
+        # Check compression method
+        def check_compression_method
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          compression_method = data[null_pos + 1].ord
+
+          unless compression_method == COMPRESSION_DEFLATE
+            add_error("zTXt invalid compression method " \
+                      "(#{compression_method}, must be 0)")
+            return false
+          end
+
+          true
+        end
+
+        # Check that compressed data can be decompressed
+        def check_decompression
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          compressed_data = data[(null_pos + 2)..] || ""
+
+          # Try to decompress
+          begin
+            Zlib::Inflate.inflate(compressed_data)
+          rescue Zlib::Error => e
+            add_error("zTXt decompression failed: #{e.message}")
+            return false
+          end
+
+          true
+        end
+
+        # Store text information in context
+        def store_text_info
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          keyword = data[0, null_pos]
+          compressed_data = data[(null_pos + 2)..] || ""
+
+          # Decompress text
+          text = Zlib::Inflate.inflate(compressed_data)
+
+          # Store in context (allow multiple text chunks)
+          texts = context.retrieve(:text_chunks) || []
+          texts << { keyword: keyword, text: text, compressed: true }
+          context.store(:text_chunks, texts)
+
+          # Add info about the text chunk
+          text_preview = text.length > 40 ? "#{text[0, 40]}..." : text
+          add_info("zTXt: #{keyword} = \"#{text_preview}\" " \
+                   "(compressed from #{compressed_data.length} bytes)")
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/apng/actl_validator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Apng
+      # Validator for acTL (Animation Control) chunk
+      #
+      # The acTL chunk is an ancillary chunk that contains information about
+      # the animation: the number of frames and the number of times to loop.
+      #
+      # Structure:
+      # - num_frames (4 bytes): Number of frames (unsigned int)
+      # - num_plays (4 bytes): Number of times to loop (0 = infinite)
+      #
+      # Constraints:
+      # - Must appear before IDAT
+      # - Must appear before any fcTL chunks
+      # - num_frames must be > 0
+      # - If present, at least one fcTL chunk must exist
+      #
+      class ActlValidator < BaseValidator
+        CHUNK_TYPE = "acTL"
+        EXPECTED_LENGTH = 8
+
+        def validate
+          return unless check_crc
+          return unless check_length(EXPECTED_LENGTH)
+
+          validate_structure
+          validate_ordering
+          validate_animation_parameters
+        end
+
+        private
+
+        def validate_structure
+          data = chunk.chunk_data
+
+          # Extract fields
+          num_frames = data[0..3].unpack1("N")
+          num_plays = data[4..7].unpack1("N")
+
+          # Store in context for cross-chunk validation
+          context.store(:actl_num_frames, num_frames)
+          context.store(:actl_num_plays, num_plays)
+
+          # Validate num_frames
+          if num_frames.zero?
+            add_error("acTL num_frames must be > 0")
+            return false
+          end
+
+          # num_plays can be 0 (infinite) or any positive number
+          true
+        end
+
+        def validate_ordering
+          # acTL must appear before IDAT
+          if context.seen?("IDAT")
+            add_error("acTL must appear before IDAT")
+            return false
+          end
+
+          # acTL must appear before any fcTL
+          if context.seen?("fcTL")
+            add_error("acTL must appear before first fcTL")
+            return false
+          end
+
+          true
+        end
+
+        def validate_animation_parameters
+          # Check if this is truly an animated PNG
+          # (will be validated after all chunks are processed)
+          true
+        end
+      end
+    end
+  end
+end