active_storage_validations 1.3.4 → 1.4.0

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -1,118 +1,150 @@
-# frozen_string_literal: true
-
-require_relative 'shared/asv_active_storageable'
-require_relative 'shared/asv_attachable'
-require_relative 'shared/asv_errorable'
-require_relative 'shared/asv_optionable'
-require_relative 'shared/asv_symbolizable'
-
-module ActiveStorageValidations
-  class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
-    include ASVActiveStorageable
-    include ASVAttachable
-    include ASVErrorable
-    include ASVOptionable
-    include ASVSymbolizable
-
-    AVAILABLE_CHECKS = %i[with].freeze
-    NAMED_ASPECT_RATIOS = %i[square portrait landscape].freeze
-    ASPECT_RATIO_REGEX = /is_([1-9]\d*)_([1-9]\d*)/.freeze
-    ERROR_TYPES = %i[
-      image_metadata_missing
-      aspect_ratio_not_square
-      aspect_ratio_not_portrait
-      aspect_ratio_not_landscape
-      aspect_ratio_is_not
-    ].freeze
-    PRECISION = 3.freeze
-
-    def check_validity!
-      ensure_at_least_one_validator_option
-      ensure_aspect_ratio_validity
-    end
-
-    def validate_each(record, attribute, _value)
-      return if no_attachments?(record, attribute)
-
-      validate_changed_files_from_metadata(record, attribute)
-    end
-
-    private
-
-    def is_valid?(record, attribute, attachable, metadata)
-      flat_options = set_flat_options(record)
-
-      return if image_metadata_missing?(record, attribute, attachable, flat_options, metadata)
-
-      case flat_options[:with]
-      when :square then validate_square_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      when :portrait then validate_portrait_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      when :landscape then validate_landscape_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      when ASPECT_RATIO_REGEX then validate_regex_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      end
-    end
-
-    def image_metadata_missing?(record, attribute, attachable, flat_options, metadata)
-      return false if metadata[:width].to_i > 0 && metadata[:height].to_i > 0
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :image_metadata_missing, **errors_options)
-      true
-    end
-
-    def validate_square_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      return if metadata[:width] == metadata[:height]
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :aspect_ratio_not_square, **errors_options)
-    end
-
-    def validate_portrait_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      return if metadata[:width] < metadata[:height]
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :aspect_ratio_not_portrait, **errors_options)
-    end
-
-    def validate_landscape_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      return if metadata[:width] > metadata[:height]
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = flat_options[:with]
-      add_error(record, attribute, :aspect_ratio_not_landscape, **errors_options)
-    end
-
-    def validate_regex_aspect_ratio(record, attribute, attachable, flat_options, metadata)
-      flat_options[:with] =~ ASPECT_RATIO_REGEX
-      x = $1.to_i
-      y = $2.to_i
-
-      return if x > 0 && y > 0 && (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
-
-      errors_options = initialize_error_options(options, attachable)
-      errors_options[:aspect_ratio] = "#{x}:#{y}"
-      add_error(record, attribute, :aspect_ratio_is_not, **errors_options)
-    end
-
-    def ensure_at_least_one_validator_option
-      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass :with to the validator'
-      end
-    end
-
-    def ensure_aspect_ratio_validity
-      return true if options[:with]&.is_a?(Proc)
-
-      unless NAMED_ASPECT_RATIOS.include?(options[:with]) || options[:with] =~ ASPECT_RATIO_REGEX
-        raise ArgumentError, <<~ERROR_MESSAGE
-          You must pass a valid aspect ratio to the validator
-          It should either be a named aspect ratio (#{NAMED_ASPECT_RATIOS.join(', ')})
-          Or an aspect ratio like 'is_16_9' (matching /#{ASPECT_RATIO_REGEX.source}/)
-        ERROR_MESSAGE
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
+require_relative 'shared/asv_attachable'
+require_relative 'shared/asv_errorable'
+require_relative 'shared/asv_optionable'
+require_relative 'shared/asv_symbolizable'
+
+module ActiveStorageValidations
+  class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
+    include ASVActiveStorageable
+    include ASVAnalyzable
+    include ASVAttachable
+    include ASVErrorable
+    include ASVOptionable
+    include ASVSymbolizable
+
+    AVAILABLE_CHECKS = %i[with in].freeze
+    NAMED_ASPECT_RATIOS = %i[square portrait landscape].freeze
+    ASPECT_RATIO_REGEX = /is_([1-9]\d*)_([1-9]\d*)/.freeze
+    ERROR_TYPES = %i[
+      aspect_ratio_not_square
+      aspect_ratio_not_portrait
+      aspect_ratio_not_landscape
+      aspect_ratio_is_not
+      aspect_ratio_invalid
+      image_metadata_missing
+    ].freeze
+    PRECISION = 3.freeze
+
+    def check_validity!
+      ensure_at_least_one_validator_option
+      ensure_aspect_ratio_validity
+    end
+
+    def validate_each(record, attribute, _value)
+      return if no_attachments?(record, attribute)
+
+      flat_options = set_flat_options(record)
+      @authorized_aspect_ratios = authorized_aspect_ratios_from_options(flat_options).compact
+      return if @authorized_aspect_ratios.empty?
+
+      validate_changed_files_from_metadata(record, attribute)
+    end
+
+    private
+
+    def is_valid?(record, attribute, attachable, metadata)
+      !image_metadata_missing?(record, attribute, attachable, metadata) &&
+        authorized_aspect_ratio?(record, attribute, attachable, metadata)
+    end
+
+    def authorized_aspect_ratio?(record, attribute, attachable, metadata)
+      attachable_aspect_ratio_is_authorized = @authorized_aspect_ratios.any? do |authorized_aspect_ratio|
+        case authorized_aspect_ratio
+        when :square then valid_square_aspect_ratio?(metadata)
+        when :portrait then valid_portrait_aspect_ratio?(metadata)
+        when :landscape then valid_landscape_aspect_ratio?(metadata)
+        when ASPECT_RATIO_REGEX then valid_regex_aspect_ratio?(authorized_aspect_ratio, metadata)
+        end
+      end
+
+      return true if attachable_aspect_ratio_is_authorized
+
+      errors_options = initialize_error_options(options, attachable)
+      errors_options[:aspect_ratio] = string_aspect_ratios
+      add_error(record, attribute, aspect_ratio_error_mapping, **errors_options)
+      false
+    end
+
+    def aspect_ratio_error_mapping
+      return :aspect_ratio_invalid unless @authorized_aspect_ratios.one?
+
+      aspect_ratio = @authorized_aspect_ratios.first
+      NAMED_ASPECT_RATIOS.include?(aspect_ratio) ? :"aspect_ratio_not_#{aspect_ratio}" : :aspect_ratio_is_not
+    end
+
+    def image_metadata_missing?(record, attribute, attachable, metadata)
+      return false if metadata[:width].to_i > 0 && metadata[:height].to_i > 0
+
+      errors_options = initialize_error_options(options, attachable)
+      errors_options[:aspect_ratio] = string_aspect_ratios
+      add_error(record, attribute, :image_metadata_missing, **errors_options)
+      true
+    end
+
+    def valid_square_aspect_ratio?(metadata)
+      metadata[:width] == metadata[:height]
+    end
+
+    def valid_portrait_aspect_ratio?(metadata)
+      metadata[:width] < metadata[:height]
+    end
+
+    def valid_landscape_aspect_ratio?(metadata)
+      metadata[:width] > metadata[:height]
+    end
+
+    def valid_regex_aspect_ratio?(aspect_ratio, metadata)
+      aspect_ratio =~ ASPECT_RATIO_REGEX
+      x = ::Regexp.last_match(1).to_i
+      y = ::Regexp.last_match(2).to_i
+
+      x > 0 && y > 0 && (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
+    end
+
+    def ensure_at_least_one_validator_option
+      return if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+
+      raise ArgumentError, 'You must pass either :with or :in to the validator'
+    end
+
+    def ensure_aspect_ratio_validity
+      return true if options[:with]&.is_a?(Proc) || options[:in]&.is_a?(Proc)
+
+      authorized_aspect_ratios_from_options(options).each do |aspect_ratio|
+        unless NAMED_ASPECT_RATIOS.include?(aspect_ratio) || aspect_ratio =~ ASPECT_RATIO_REGEX
+          raise ArgumentError, invalid_aspect_ratio_message
+        end
+      end
+    end
+
+    def invalid_aspect_ratio_message
+      <<~ERROR_MESSAGE
+        You must pass a valid aspect ratio to the validator
+        It should either be a named aspect ratio (#{NAMED_ASPECT_RATIOS.join(', ')})
+        Or an aspect ratio like 'is_16_9' (matching /#{ASPECT_RATIO_REGEX.source}/)
+      ERROR_MESSAGE
+    end
+
+    def authorized_aspect_ratios_from_options(flat_options)
+      (Array.wrap(flat_options[:with]) + Array.wrap(flat_options[:in]))
+    end
+
+    def string_aspect_ratios
+      @authorized_aspect_ratios.map do |aspect_ratio|
+        if NAMED_ASPECT_RATIOS.include?(aspect_ratio)
+          aspect_ratio
+        else
+          aspect_ratio =~ ASPECT_RATIO_REGEX
+          x = ::Regexp.last_match(1).to_i
+          y = ::Regexp.last_match(2).to_i
+
+          "#{x}:#{y}"
+        end
+      end.join(', ')
+    end
+  end
+end

data/lib/active_storage_validations/content_type_spoof_detector.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_loggable'
 require 'open3'
@@ -8,6 +9,7 @@ module ActiveStorageValidations
   class ContentTypeSpoofDetector
     class FileCommandLineToolNotInstalledError < StandardError; end
 
+    include ASVAnalyzable
     include ASVAttachable
     include ASVLoggable
 
@@ -49,7 +51,7 @@ module ActiveStorageValidations
     end
 
     def open3_mime_type_for_io
-      return nil if io.blank?
+      return nil if io.bytesize == 0
 
       Tempfile.create do |tempfile|
         tempfile.binmode

data/lib/active_storage_validations/content_type_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_optionable'
@@ -10,6 +11,7 @@ require_relative 'content_type_spoof_detector'
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
     include ASVActiveStorageable
+    include ASVAnalyzable
     include ASVAttachable
     include ASVErrorable
     include ASVOptionable
@@ -32,9 +34,11 @@ module ActiveStorageValidations
       @authorized_content_types = authorized_content_types_from_options(record)
       return if @authorized_content_types.empty?
 
-      attachables_from_changes(record, attribute).each do |attachable|
-        set_attachable_cached_values(attachable)
-        is_valid?(record, attribute, attachable)
+      checked_files = disable_spoofing_protection? ? attached_files(record, attribute) : attachables_from_changes(record, attribute)
+
+      checked_files.each do |file|
+        set_attachable_cached_values(file)
+        is_valid?(record, attribute, file)
       end
     end
 
@@ -52,8 +56,8 @@ module ActiveStorageValidations
     end
 
     def set_attachable_cached_values(attachable)
-      @attachable_content_type = attachable_content_type(attachable)
-      @attachable_filename = attachable_filename(attachable).to_s
+      @attachable_content_type = disable_spoofing_protection? ? attachable.blob.content_type : attachable_content_type_rails_like(attachable)
+      @attachable_filename = disable_spoofing_protection? ? attachable.blob.filename.to_s : attachable_filename(attachable).to_s
     end
 
     # Check if the provided content_type is authorized and not spoofed against
@@ -114,6 +118,10 @@ module ActiveStorageValidations
       Marcel::MimeType.for(declared_type: @attachable_content_type, name: @attachable_filename)
     end
 
+    def disable_spoofing_protection?
+      !enable_spoofing_protection?
+    end
+
     def enable_spoofing_protection?
       options[:spoofing_protection] == true
     end

data/lib/active_storage_validations/dimension_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_optionable'
@@ -9,6 +10,7 @@ require_relative 'shared/asv_symbolizable'
 module ActiveStorageValidations
   class DimensionValidator < ActiveModel::EachValidator # :nodoc
     include ASVActiveStorageable
+    include ASVAnalyzable
     include ASVAttachable
     include ASVErrorable
     include ASVOptionable

data/lib/active_storage_validations/marcel_extensor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "marcel"
+
 Marcel::MimeType.extend "application/x-rar-compressed", parents: %(application/x-rar)
 Marcel::MimeType.extend "audio/x-hx-aac-adts", parents: %(audio/x-aac)
 Marcel::MimeType.extend "audio/x-m4a", parents: %(audio/mp4)

data/lib/active_storage_validations/matchers/processable_image_validator_matcher.rb

@@ -43,10 +43,10 @@ module ActiveStorageValidations
         @subject = subject.is_a?(Class) ? subject.new : subject
 
         is_a_valid_active_storage_attribute? &&
-        is_context_valid? &&
-        is_custom_message_valid? &&
-        is_valid_when_image_processable? &&
-        is_invalid_when_image_not_processable?
+          is_context_valid? &&
+          is_custom_message_valid? &&
+          is_valid_when_image_processable? &&
+          is_invalid_when_image_not_processable?
       end
 
       private

data/lib/active_storage_validations/matchers.rb

@@ -27,7 +27,8 @@ module ActiveStorageValidations
 
     def self.mock_metadata(attachment, width, height)
       mock = Struct.new(:metadata).new({ width: width, height: height })
-      stub_method(ActiveStorageValidations::Metadata, :new, mock) do
+
+      stub_method(ActiveStorageValidations::Analyzer, :new, mock) do
         yield
       end
     end

data/lib/active_storage_validations/processable_image_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_symbolizable'
@@ -8,6 +9,7 @@ require_relative 'shared/asv_symbolizable'
 module ActiveStorageValidations
   class ProcessableImageValidator < ActiveModel::EachValidator # :nodoc
     include ASVActiveStorageable
+    include ASVAnalyzable
     include ASVAttachable
     include ASVErrorable
     include ASVSymbolizable

data/lib/active_storage_validations/shared/asv_active_storageable.rb

@@ -9,8 +9,8 @@ module ActiveStorageValidations
 
     private
 
-    # Retrieve either an ActiveStorage::Attached::One or an
-    # ActiveStorage::Attached::Many instance depending on attribute definition
+    # Retrieve either an `ActiveStorage::Attached::One` or an
+    # `ActiveStorage::Attached::Many` instance depending on attribute definition
     def attached_files(record, attribute)
       Array.wrap(record.send(attribute))
     end

data/lib/active_storage_validations/shared/asv_analyzable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # ActiveStorageValidations::ASVAnalyzable
+  #
+  # Validator methods for choosing the right analyzer depending on the file
+  # media type and available third-party analyzers.
+  module ASVAnalyzable
+    extend ActiveSupport::Concern
+
+    DEFAULT_IMAGE_PROCESSOR = :mini_magick.freeze
+
+    private
+
+    def metadata_for(attachable)
+      analyzer_for(attachable).metadata
+    end
+
+    def analyzer_for(attachable)
+      case attachable_media_type(attachable)
+      when "image" then image_analyzer_for(attachable)
+      else fallback_analyzer_for(attachable)
+      end
+    end
+
+    def image_analyzer_for(attachable)
+      case image_processor
+      when :mini_magick
+        ActiveStorageValidations::Analyzer::ImageAnalyzer::ImageMagick.new(attachable)
+      when :vips
+        ActiveStorageValidations::Analyzer::ImageAnalyzer::Vips.new(attachable)
+      end
+    end
+
+    def image_processor
+      # Rails returns nil for default image processor, because it is set in an after initialize callback
+      # https://github.com/rails/rails/blob/main/activestorage/lib/active_storage/engine.rb
+      ActiveStorage.variant_processor || DEFAULT_IMAGE_PROCESSOR
+    end
+
+    def fallback_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::NullAnalyzer.new(attachable)
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_attachable.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../metadata"
-
 module ActiveStorageValidations
   # ActiveStorageValidations::ASVAttachable
   #
@@ -20,7 +18,7 @@ module ActiveStorageValidations
     # to perform file analyses.
     def validate_changed_files_from_metadata(record, attribute)
       attachables_from_changes(record, attribute).each do |attachable|
-        is_valid?(record, attribute, attachable, Metadata.new(attachable).metadata)
+        is_valid?(record, attribute, attachable, metadata_for(attachable))
       end
     end
 
@@ -64,25 +62,67 @@ module ActiveStorageValidations
     def attachable_content_type(attachable)
       full_attachable_content_type(attachable) && full_attachable_content_type(attachable).downcase.split(/[;,\s]/, 2).first
     end
+      
+    # Retrieve the content_type from attachable using the same logic as Rails
+    # ActiveStorage::Blob::Identifiable#identify_content_type
+    def attachable_content_type_rails_like(attachable)
+      Marcel::MimeType.for(
+        attachable_io(attachable, max_byte_size: 4.kilobytes),
+        name: attachable_filename(attachable).to_s,
+        declared_type: full_attachable_content_type(attachable)
+      )
+    end
 
+    # Retrieve the media type of the attachable, which is the first part of the
+    # content type (or mime type).
+    # Possible values are: application/audio/example/font/image/model/text/video
+    def attachable_media_type(attachable)
+      (full_attachable_content_type(attachable) || marcel_content_type_from_filename(attachable)).split("/").first
+    end
+    
     # Retrieve the io from attachable.
-    def attachable_io(attachable)
+    def attachable_io(attachable, max_byte_size: nil)
+      io = case attachable
+           when ActiveStorage::Blob
+             (max_byte_size && supports_blob_download_chunk?) ? attachable.download_chunk(0...max_byte_size) : attachable.download
+           when ActionDispatch::Http::UploadedFile
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           when Rack::Test::UploadedFile
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           when String
+             blob = ActiveStorage::Blob.find_signed!(attachable)
+             (max_byte_size && supports_blob_download_chunk?) ? blob.download_chunk(0...max_byte_size) : blob.download
+           when Hash
+             max_byte_size ? attachable[:io].read(max_byte_size) : attachable[:io].read
+           when File
+             raise_rails_like_error(attachable) unless supports_file_attachment?
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           when Pathname
+             raise_rails_like_error(attachable) unless supports_pathname_attachment?
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           else
+             raise_rails_like_error(attachable)
+           end
+
+      rewind_attachable_io(attachable)
+      io
+    end
+
+    # Rewind the io attachable.
+    def rewind_attachable_io(attachable)
       case attachable
-      when ActiveStorage::Blob
-        attachable.download
-      when ActionDispatch::Http::UploadedFile
-        attachable.read
-      when Rack::Test::UploadedFile
-        attachable.read
-      when String
-        blob = ActiveStorage::Blob.find_signed!(attachable)
-        blob.download
+      when ActiveStorage::Blob, String
+        # nothing to do
+      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+        attachable.rewind
       when Hash
-        attachable[:io].read
+        attachable[:io].rewind
       when File
-        supports_file_attachment? ? attachable : raise_rails_like_error(attachable)
+        raise_rails_like_error(attachable) unless supports_file_attachment?
+        attachable.rewind
       when Pathname
-        supports_pathname_attachment? ? attachable.read : raise_rails_like_error(attachable)
+        raise_rails_like_error(attachable) unless supports_pathname_attachment?
+        File.open(attachable) { |f| f.rewind }
       else
         raise_rails_like_error(attachable)
       end
@@ -128,6 +168,13 @@ module ActiveStorageValidations
     end
     alias :supports_pathname_attachment? :supports_file_attachment?
 
+    # Check if the current Rails version supports ActiveStorage::Blob#download_chunk
+    #
+    # https://github.com/rails/rails/blob/7-0-stable/activestorage/CHANGELOG.md#rails-700alpha1-september-15-2021
+    def supports_blob_download_chunk?
+      Rails.gem_version >= Gem::Version.new('7.0.0.alpha1')
+    end
+
     # Retrieve the content_type from the file name only
     def marcel_content_type_from_filename(attachable)
       Marcel::MimeType.for(name: attachable_filename(attachable).to_s)

data/lib/active_storage_validations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  VERSION = '1.3.4'
+  VERSION = '1.4.0'
 end

data/lib/active_storage_validations.rb

@@ -3,6 +3,12 @@
 require 'active_model'
 require 'active_support/concern'
 
+require 'active_storage_validations/analyzer'
+require 'active_storage_validations/analyzer/image_analyzer'
+require 'active_storage_validations/analyzer/image_analyzer/image_magick'
+require 'active_storage_validations/analyzer/image_analyzer/vips'
+require 'active_storage_validations/analyzer/null_analyzer'
+
 require 'active_storage_validations/railtie'
 require 'active_storage_validations/engine'
 require 'active_storage_validations/attached_validator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_storage_validations
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.4.0
 platform: ruby
 authors:
 - Igor Kasyanchuk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-14 00:00:00.000000000 Z
+date: 2024-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -259,6 +259,11 @@ files:
 - config/locales/vi.yml
 - config/locales/zh-CN.yml
 - lib/active_storage_validations.rb
+- lib/active_storage_validations/analyzer.rb
+- lib/active_storage_validations/analyzer/image_analyzer.rb
+- lib/active_storage_validations/analyzer/image_analyzer/image_magick.rb
+- lib/active_storage_validations/analyzer/image_analyzer/vips.rb
+- lib/active_storage_validations/analyzer/null_analyzer.rb
 - lib/active_storage_validations/aspect_ratio_validator.rb
 - lib/active_storage_validations/attached_validator.rb
 - lib/active_storage_validations/base_size_validator.rb
@@ -285,10 +290,10 @@ files:
 - lib/active_storage_validations/matchers/shared/asv_validatable.rb
 - lib/active_storage_validations/matchers/size_validator_matcher.rb
 - lib/active_storage_validations/matchers/total_size_validator_matcher.rb
-- lib/active_storage_validations/metadata.rb
 - lib/active_storage_validations/processable_image_validator.rb
 - lib/active_storage_validations/railtie.rb
 - lib/active_storage_validations/shared/asv_active_storageable.rb
+- lib/active_storage_validations/shared/asv_analyzable.rb
 - lib/active_storage_validations/shared/asv_attachable.rb
 - lib/active_storage_validations/shared/asv_errorable.rb
 - lib/active_storage_validations/shared/asv_loggable.rb