active_storage_validations 1.1.1 → 1.2.0

data/config/locales/tr.yml

@@ -7,6 +7,11 @@ tr:
       file_size_not_greater_than: "dosya boyutu %{min_size} boyutundan büyük olmalıdır (geçerli boyut %{file_size}'dir)"
       file_size_not_greater_than_or_equal_to: "dosya boyutu %{min_size} değerinden büyük veya eşit olmalıdır (geçerli boyut %{file_size}'dir)"
       file_size_not_between: "dosya boyutu %{min_size} ile %{max_size} arasında olmalıdır (geçerli boyut %{file_size}'dir)"
+      total_file_size_not_less_than: "toplam dosya boyutu %{max_size} boyutundan küçük olmalıdır (geçerli boyut %{total_file_size}'dir)"
+      total_file_size_not_less_than_or_equal_to: "toplam dosya boyutu %{max_size} değerinden küçük veya ona eşit olmalıdır (geçerli boyut %{total_file_size}'dir)"
+      total_file_size_not_greater_than: "toplam dosya boyutu %{min_size} boyutundan büyük olmalıdır (geçerli boyut %{total_file_size}'dir)"
+      total_file_size_not_greater_than_or_equal_to: "toplam dosya boyutu %{min_size} değerinden büyük veya eşit olmalıdır (geçerli boyut %{total_file_size}'dir)"
+      total_file_size_not_between: "toplam dosya boyutu %{min_size} ile %{max_size} arasında olmalıdır (geçerli boyut %{total_file_size}'dir)"
       limit_out_of_range: "toplam miktar aralık dışında"
       image_metadata_missing: "geçerli bir imaj değil"
       dimension_min_inclusion: "%{width} x %{height} piksele eşit ya da büyük olmalı"
@@ -24,3 +29,4 @@ tr:
       aspect_ratio_not_landscape: "yatay bir imaj olmalı"
       aspect_ratio_is_not: "%{aspect_ratio} en boy oranına sahip olmalı"
       aspect_ratio_unknown: "bilinmeyen en boy oranı"
+      image_not_processable: "geçerli bir imaj değil"

data/config/locales/uk.yml

@@ -7,6 +7,11 @@ uk:
       file_size_not_greater_than: "розмір файлу має бути більшим ніж %{min_size} (поточний розмір %{file_size})"
       file_size_not_greater_than_or_equal_to: "розмір файлу має бути більшим або дорівнювати %{min_size} (поточний розмір %{file_size})"
       file_size_not_between: "розмір файлу має бути від %{min_size} до %{max_size} (поточний розмір %{file_size})"
+      total_file_size_not_less_than: "загальний розмір файлу має бути менше %{max_size} (поточний розмір %{total_file_size})"
+      total_file_size_not_less_than_or_equal_to: "загальний розмір файлу має бути меншим або дорівнювати %{max_size} (поточний розмір %{total_file_size})"
+      total_file_size_not_greater_than: "загальний розмір файлу має бути більшим ніж %{min_size} (поточний розмір %{total_file_size})"
+      total_file_size_not_greater_than_or_equal_to: "загальний розмір файлу має бути більшим або дорівнювати %{min_size} (поточний розмір %{total_file_size})"
+      total_file_size_not_between: "загальний розмір файлу має бути від %{min_size} до %{max_size} (поточний розмір %{total_file_size})"
       limit_out_of_range: "кількість файлів більше необхідного"
       image_metadata_missing: "не є допустимим зображенням"
       dimension_min_inclusion: "мусить бути більше або дорівнювати %{width} x %{height} пікселям"
@@ -24,3 +29,4 @@ uk:
       aspect_ratio_not_landscape: "мусить бути пейзажне зображення"
       aspect_ratio_is_not: "мусить мати співвідношення сторін %{aspect_ratio}"
       aspect_ratio_unknown: "має невідоме співвідношення сторін"
+      image_not_processable: "не є допустимим зображенням"

data/config/locales/vi.yml

@@ -7,6 +7,11 @@ vi:
       file_size_not_greater_than: "kích thước tệp phải lớn hơn %{min_size} (kích thước hiện tại là %{file_size})"
       file_size_not_greater_than_or_equal_to: "kích thước tệp phải lớn hơn hoặc bằng %{min_size} (kích thước hiện tại là %{file_size})"
       file_size_not_between: "kích thước tệp phải nằm trong khoảng từ %{min_size} đến %{max_size} (kích thước hiện tại là %{file_size})"
+      total_file_size_not_less_than: "tổng kích thước tệp phải nhỏ hơn %{max_size} (kích thước hiện tại là %{total_file_size})"
+      total_file_size_not_less_than_or_equal_to: "tổng kích thước tệp phải nhỏ hơn hoặc bằng %{max_size} (kích thước hiện tại là %{total_file_size})"
+      total_file_size_not_greater_than: "tổng kích thước tệp phải lớn hơn %{min_size} (kích thước hiện tại là %{total_file_size})"
+      total_file_size_not_greater_than_or_equal_to: "tổng kích thước tệp phải lớn hơn hoặc bằng %{min_size} (kích thước hiện tại là %{total_file_size})"
+      total_file_size_not_between: "tổng kích thước tệp phải nằm trong khoảng từ %{min_size} đến %{max_size} (kích thước hiện tại là %{total_file_size})"
       limit_out_of_range: "tổng số tệp vượt giới hạn"
       image_metadata_missing: "không phải là ảnh"
       dimension_min_inclusion: "phải lớn hơn hoặc bằng %{width} x %{height} pixel"
@@ -24,3 +29,4 @@ vi:
       aspect_ratio_not_landscape: "phải là ảnh ngang"
       aspect_ratio_is_not: "phải có tỉ lệ ảnh %{aspect_ratio}"
       aspect_ratio_unknown: "tỉ lệ ảnh không xác định"
+      image_not_processable: "không phải là ảnh"

data/config/locales/zh-CN.yml

@@ -7,6 +7,11 @@ zh-CN:
       file_size_not_greater_than: "文件大小必须大于 %{min_size}（当前大小为 %{file_size})"
       file_size_not_greater_than_or_equal_to: "文件大小必须大于或等于 %{min_size}（当前大小为 %{file_size})"
       file_size_not_between: "文件大小必须介于 %{min_size} 和 %{max_size} 之间（当前大小为 %{file_size})"
+      total_file_size_not_less_than: "总文件大小必须小于 %{max_size}（当前大小为 %{total_file_size})"
+      total_file_size_not_less_than_or_equal_to: "文件总大小必须小于或等于 %{max_size}（当前大小为 %{total_file_size})"
+      total_file_size_not_greater_than: "总文件大小必须大于 %{min_size}（当前大小为 %{total_file_size})"
+      total_file_size_not_greater_than_or_equal_to: "文件总大小必须大于或等于 %{min_size}（当前大小为 %{total_file_size})"
+      total_file_size_not_between: "总文件大小必须介于 %{min_size} 和 %{max_size} 之间（当前大小为 %{total_file_size})"
       limit_out_of_range: "文件数超出限定范围"
       image_metadata_missing: "不是有效的图像"
       dimension_min_inclusion: "必须大于或等于 %{width} x %{height} 像素"
@@ -24,3 +29,4 @@ zh-CN:
       aspect_ratio_not_landscape: "必须是横屏图片"
       aspect_ratio_is_not: "纵横比必须是 %{aspect_ratio}"
       aspect_ratio_unknown: "未知的纵横比"
+      image_not_processable: "不是有效的图像"

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -1,19 +1,31 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/errorable.rb'
+require_relative 'concerns/symbolizable.rb'
 require_relative 'metadata.rb'
 
 module ActiveStorageValidations
   class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
     include OptionProcUnfolding
-    include ErrorHandler
+    include Errorable
+    include Symbolizable
 
     AVAILABLE_CHECKS = %i[with].freeze
-    PRECISION = 3
+    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
+      aspect_ratio_unknown
+    ].freeze
+    PRECISION = 3.freeze
 
     def check_validity!
-      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass :with to the validator'
-      end
+      ensure_at_least_one_validator_option
+      ensure_aspect_ratio_validity
     end
 
     if Rails.gem_version >= Gem::Version.new('6.0.0')
@@ -27,7 +39,7 @@ module ActiveStorageValidations
 
         files.each do |file|
           metadata = Metadata.new(file).metadata
-          next if is_valid?(record, attribute, metadata)
+          next if is_valid?(record, attribute, file, metadata)
           break
         end
       end
@@ -43,19 +55,17 @@ module ActiveStorageValidations
           file.analyze; file.reload unless file.analyzed?
           metadata = file.metadata
 
-          next if is_valid?(record, attribute, metadata)
+          next if is_valid?(record, attribute, file, metadata)
           break
         end
       end
     end
 
-
     private
 
-
-    def is_valid?(record, attribute, metadata)
+    def is_valid?(record, attribute, file, metadata)
       flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
-      errors_options = initialize_error_options(options)
+      errors_options = initialize_error_options(options, file)
 
       if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
         errors_options[:aspect_ratio] = flat_options[:with]
@@ -80,21 +90,38 @@ module ActiveStorageValidations
         errors_options[:aspect_ratio] = flat_options[:with]
         add_error(record, attribute, :aspect_ratio_not_landscape, **errors_options)
 
+      when ASPECT_RATIO_REGEX
+        flat_options[:with] =~ ASPECT_RATIO_REGEX
+        x = $1.to_i
+        y = $2.to_i
+
+        return true if x > 0 && y > 0 && (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
+
+        errors_options[:aspect_ratio] = "#{x}:#{y}"
+        add_error(record, attribute, :aspect_ratio_is_not, **errors_options)
       else
-        if flat_options[:with] =~ /is_(\d*)_(\d*)/
-          x = $1.to_i
-          y = $2.to_i
+        errors_options[:aspect_ratio] = flat_options[:with]
+        add_error(record, attribute, :aspect_ratio_unknown, **errors_options)
+        return false
+      end
+    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
 
-          return true if (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
+    def ensure_aspect_ratio_validity
+      return true if options[:with]&.is_a?(Proc)
 
-          errors_options[:aspect_ratio] = "#{x}x#{y}"
-          add_error(record, attribute, :aspect_ratio_is_not, **errors_options)
-        else
-          errors_options[:aspect_ratio] = flat_options[:with]
-          add_error(record, attribute, :aspect_ratio_unknown, **errors_options)
-        end
+      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
-      false
     end
   end
 end

data/lib/active_storage_validations/attached_validator.rb

@@ -1,15 +1,29 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/errorable.rb'
+require_relative 'concerns/symbolizable.rb'
+
 module ActiveStorageValidations
   class AttachedValidator < ActiveModel::EachValidator # :nodoc:
-    include ErrorHandler
+    include Errorable
+    include Symbolizable
+
+    ERROR_TYPES = %i[blank].freeze
+
+    def check_validity!
+      %i[allow_nil allow_blank].each do |not_authorized_option|
+        if options.include?(not_authorized_option)
+          raise ArgumentError, "You cannot pass the :#{not_authorized_option} option to the #{self.class.name.split('::').last.underscore}"
+        end
+      end
+    end
 
     def validate_each(record, attribute, _value)
-      return if record.send(attribute).attached?
+      return if record.send(attribute).attached? &&
+                !Array.wrap(record.send(attribute)).all?(&:marked_for_destruction?)
 
       errors_options = initialize_error_options(options)
-
-      add_error(record, attribute, :blank, **errors_options)
+      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
     end
   end
 end

data/lib/active_storage_validations/base_size_validator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/errorable.rb'
+require_relative 'concerns/symbolizable.rb'
+
+module ActiveStorageValidations
+  class BaseSizeValidator < ActiveModel::EachValidator # :nodoc:
+    include OptionProcUnfolding
+    include Errorable
+    include Symbolizable
+
+    delegate :number_to_human_size, to: ActiveSupport::NumberHelper
+
+    AVAILABLE_CHECKS = %i[
+      less_than
+      less_than_or_equal_to
+      greater_than
+      greater_than_or_equal_to
+      between
+    ].freeze
+
+    def initialize(*args)
+      if self.class == BaseSizeValidator
+        raise NotImplementedError, 'BaseSizeValidator is an abstract class and cannot be instantiated directly.'
+      end
+      super
+    end
+
+    def check_validity!
+      unless AVAILABLE_CHECKS.one? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :less_than(_or_equal_to), :greater_than(_or_equal_to), or :between to the validator'
+      end
+    end
+
+    private
+
+    def is_valid?(size, flat_options)
+      return false if size < 0
+
+      if flat_options[:between].present?
+        flat_options[:between].include?(size)
+      elsif flat_options[:less_than].present?
+        size < flat_options[:less_than]
+      elsif flat_options[:less_than_or_equal_to].present?
+        size <= flat_options[:less_than_or_equal_to]
+      elsif flat_options[:greater_than].present?
+        size > flat_options[:greater_than]
+      elsif flat_options[:greater_than_or_equal_to].present?
+        size >= flat_options[:greater_than_or_equal_to]
+      end
+    end
+
+    def populate_error_options(errors_options, flat_options)
+      errors_options[:min_size] = number_to_human_size(min_size(flat_options))
+      errors_options[:max_size] = number_to_human_size(max_size(flat_options))
+    end
+
+    def min_size(flat_options)
+      flat_options[:between]&.min || flat_options[:greater_than] || flat_options[:greater_than_or_equal_to]
+    end
+
+    def max_size(flat_options)
+      flat_options[:between]&.max || flat_options[:less_than] || flat_options[:less_than_or_equal_to]
+    end
+  end
+end

data/lib/active_storage_validations/concerns/errorable.rb

@@ -0,0 +1,38 @@
+module ActiveStorageValidations
+  module Errorable
+    extend ActiveSupport::Concern
+
+    def initialize_error_options(options, file = nil)
+      not_explicitly_written_options = %i(with in)
+      curated_options = options.except(*not_explicitly_written_options)
+
+      active_storage_validations_options = {
+        validator_type: self.class.to_sym,
+        custom_message: (options[:message] if options[:message].present?),
+        filename: (get_filename(file) unless self.class.to_sym == :total_size)
+      }.compact
+
+      curated_options.merge(active_storage_validations_options)
+    end
+
+    def add_error(record, attribute, error_type, **errors_options)
+      type = errors_options[:custom_message].presence || error_type
+      return if record.errors.added?(attribute, type)
+
+      # You can read https://api.rubyonrails.org/classes/ActiveModel/Errors.html#method-i-add
+      # to better understand how Rails model errors work
+      record.errors.add(attribute, type, **errors_options)
+    end
+
+    private
+
+    def get_filename(file)
+      return nil unless file
+
+      case file
+      when ActiveStorage::Attached, ActiveStorage::Attachment then file.blob&.filename&.to_s
+      when Hash then file[:filename]
+      end
+    end
+  end
+end

data/lib/active_storage_validations/concerns/symbolizable.rb

@@ -0,0 +1,12 @@
+module ActiveStorageValidations
+  module Symbolizable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def to_sym
+        validator_class = self.name.split("::").last
+        validator_class.sub(/Validator/, '').underscore.to_sym
+      end
+    end
+  end
+end

data/lib/active_storage_validations/content_type_validator.rb

@@ -1,28 +1,37 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/errorable.rb'
+require_relative 'concerns/symbolizable.rb'
+
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
     include OptionProcUnfolding
-    include ErrorHandler
+    include Errorable
+    include Symbolizable
 
     AVAILABLE_CHECKS = %i[with in].freeze
-    
+    ERROR_TYPES = %i[content_type_invalid].freeze
+
+    def check_validity!
+      ensure_exactly_one_validator_option
+      ensure_content_types_validity
+    end
+
     def validate_each(record, attribute, _value)
       return true unless record.send(attribute).attached?
 
       types = authorized_types(record)
       return true if types.empty?
-      
-      files = Array.wrap(record.send(attribute))
 
-      errors_options = initialize_error_options(options)
-      errors_options[:authorized_types] = types_to_human_format(types)
+      files = Array.wrap(record.send(attribute))
 
       files.each do |file|
         next if is_valid?(file, types)
 
+        errors_options = initialize_error_options(options, file)
+        errors_options[:authorized_types] = types_to_human_format(types)
         errors_options[:content_type] = content_type(file)
-        add_error(record, attribute, :content_type_invalid, **errors_options)
+        add_error(record, attribute, ERROR_TYPES.first, **errors_options)
         break
       end
     end
@@ -40,7 +49,7 @@ module ActiveStorageValidations
 
     def types_to_human_format(types)
       types
-        .map { |type| type.to_s.split('/').last.upcase }
+        .map { |type| type.is_a?(Regexp) ? type.source : type.to_s.split('/').last.upcase }
         .join(', ')
     end
 
@@ -54,5 +63,35 @@ module ActiveStorageValidations
         type == file_type || (type.is_a?(Regexp) && type.match?(file_type.to_s))
       end
     end
+
+    def ensure_exactly_one_validator_option
+      unless AVAILABLE_CHECKS.one? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :with or :in to the validator'
+      end
+    end
+
+    def ensure_content_types_validity
+      return true if options[:with]&.is_a?(Proc) || options[:in]&.is_a?(Proc)
+
+      ([options[:with]] || options[:in]).each do |content_type|
+        raise ArgumentError, invalid_content_type_message(content_type) if invalid_content_type?(content_type)
+      end
+    end
+
+    def invalid_content_type_message(content_type)
+      <<~ERROR_MESSAGE
+        You must pass valid content types to the validator
+        '#{content_type}' is not find in Marcel::EXTENSIONS mimes
+      ERROR_MESSAGE
+    end
+
+    def invalid_content_type?(content_type)
+      case content_type
+      when String, Symbol
+        Marcel::MimeType.for(declared_type: content_type.to_s, extension: content_type.to_s) == 'application/octet-stream'
+      when Regexp
+        false # We always validate regexes
+      end
+    end
   end
 end

data/lib/active_storage_validations/dimension_validator.rb

@@ -1,13 +1,29 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/errorable.rb'
+require_relative 'concerns/symbolizable.rb'
 require_relative 'metadata.rb'
 
 module ActiveStorageValidations
   class DimensionValidator < ActiveModel::EachValidator # :nodoc
     include OptionProcUnfolding
-    include ErrorHandler
+    include Errorable
+    include Symbolizable
 
     AVAILABLE_CHECKS = %i[width height min max].freeze
+    ERROR_TYPES = %i[
+      image_metadata_missing
+      dimension_min_inclusion
+      dimension_max_inclusion
+      dimension_width_inclusion
+      dimension_height_inclusion
+      dimension_width_greater_than_or_equal_to
+      dimension_height_greater_than_or_equal_to
+      dimension_width_less_than_or_equal_to
+      dimension_height_less_than_or_equal_to
+      dimension_width_equal_to
+      dimension_height_equal_to
+    ].freeze
 
     def process_options(record)
       flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
@@ -31,7 +47,6 @@ module ActiveStorageValidations
       flat_options
     end
 
-
     def check_validity!
       unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
         raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
@@ -49,7 +64,7 @@ module ActiveStorageValidations
         files = Array.wrap(changes.is_a?(ActiveStorage::Attached::Changes::CreateMany) ? changes.attachables : changes.attachable)
         files.each do |file|
           metadata = Metadata.new(file).metadata
-          next if is_valid?(record, attribute, metadata)
+          next if is_valid?(record, attribute, file, metadata)
           break
         end
       end
@@ -63,19 +78,19 @@ module ActiveStorageValidations
           # Analyze file first if not analyzed to get all required metadata.
           file.analyze; file.reload unless file.analyzed?
           metadata = file.metadata rescue {}
-          next if is_valid?(record, attribute, metadata)
+          next if is_valid?(record, attribute, file, metadata)
           break
         end
       end
     end
 
 
-    def is_valid?(record, attribute, file_metadata)
+    def is_valid?(record, attribute, file, metadata)
       flat_options = process_options(record)
-      errors_options = initialize_error_options(options)
+      errors_options = initialize_error_options(options, file)
 
       # Validation fails unless file metadata contains valid width and height.
-      if file_metadata[:width].to_i <= 0 || file_metadata[:height].to_i <= 0
+      if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
         add_error(record, attribute, :image_metadata_missing, **errors_options)
         return false
       end
@@ -83,8 +98,8 @@ module ActiveStorageValidations
       # Validation based on checks :min and :max (:min, :max has higher priority to :width, :height).
       if flat_options[:min] || flat_options[:max]
         if flat_options[:min] && (
-          (flat_options[:width][:min] && file_metadata[:width] < flat_options[:width][:min]) ||
-          (flat_options[:height][:min] && file_metadata[:height] < flat_options[:height][:min])
+          (flat_options[:width][:min] && metadata[:width] < flat_options[:width][:min]) ||
+          (flat_options[:height][:min] && metadata[:height] < flat_options[:height][:min])
           )
           errors_options[:width] = flat_options[:width][:min]
           errors_options[:height] = flat_options[:height][:min]
@@ -93,8 +108,8 @@ module ActiveStorageValidations
           return false
         end
         if flat_options[:max] && (
-          (flat_options[:width][:max] && file_metadata[:width] > flat_options[:width][:max]) ||
-          (flat_options[:height][:max] && file_metadata[:height] > flat_options[:height][:max])
+          (flat_options[:width][:max] && metadata[:width] > flat_options[:width][:max]) ||
+          (flat_options[:height][:max] && metadata[:height] > flat_options[:height][:max])
           )
           errors_options[:width] = flat_options[:width][:max]
           errors_options[:height] = flat_options[:height][:max]
@@ -110,7 +125,7 @@ module ActiveStorageValidations
         [:width, :height].each do |length|
           next unless flat_options[length]
           if flat_options[length].is_a?(Hash)
-            if flat_options[length][:in] && (file_metadata[length] < flat_options[length][:min] || file_metadata[length] > flat_options[length][:max])
+            if flat_options[length][:in] && (metadata[length] < flat_options[length][:min] || metadata[length] > flat_options[length][:max])
               error_type = :"dimension_#{length}_inclusion"
               errors_options[:min] = flat_options[length][:min]
               errors_options[:max] = flat_options[length][:max]
@@ -118,13 +133,13 @@ module ActiveStorageValidations
               add_error(record, attribute, error_type, **errors_options)
               width_or_height_invalid = true
             else
-              if flat_options[length][:min] && file_metadata[length] < flat_options[length][:min]
+              if flat_options[length][:min] && metadata[length] < flat_options[length][:min]
                 error_type = :"dimension_#{length}_greater_than_or_equal_to"
                 errors_options[:length] = flat_options[length][:min]
 
                 add_error(record, attribute, error_type, **errors_options)
                 width_or_height_invalid = true
-              elsif flat_options[length][:max] && file_metadata[length] > flat_options[length][:max]
+              elsif flat_options[length][:max] && metadata[length] > flat_options[length][:max]
                 error_type = :"dimension_#{length}_less_than_or_equal_to"
                 errors_options[:length] = flat_options[length][:max]
 
@@ -133,7 +148,7 @@ module ActiveStorageValidations
               end
             end
           else
-            if file_metadata[length] != flat_options[length]
+            if metadata[length] != flat_options[length]
               error_type = :"dimension_#{length}_equal_to"
               errors_options[:length] = flat_options[length]
 

data/lib/active_storage_validations/limit_validator.rb

@@ -1,29 +1,38 @@
 # frozen_string_literal: true
 
+require_relative 'concerns/errorable.rb'
+require_relative 'concerns/symbolizable.rb'
+
 module ActiveStorageValidations
   class LimitValidator < ActiveModel::EachValidator # :nodoc:
     include OptionProcUnfolding
-    include ErrorHandler
+    include Errorable
+    include Symbolizable
 
     AVAILABLE_CHECKS = %i[max min].freeze
+    ERROR_TYPES = %i[
+      limit_out_of_range
+    ].freeze
 
     def check_validity!
-      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-        raise ArgumentError, 'You must pass either :max or :min to the validator'
-      end
+      ensure_at_least_one_validator_option
+      ensure_arguments_validity
     end
 
     def validate_each(record, attribute, _)
-      files = Array.wrap(record.send(attribute)).compact.uniq
+      files = Array.wrap(record.send(attribute)).reject { |file| file.blank? }.compact.uniq
       flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+
+      return true if files_count_valid?(files.count, flat_options)
+
       errors_options = initialize_error_options(options)
       errors_options[:min] = flat_options[:min]
       errors_options[:max] = flat_options[:max]
-
-      return true if files_count_valid?(files.count, flat_options)
-      add_error(record, attribute, :limit_out_of_range, **errors_options)
+      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
     end
 
+    private
+
     def files_count_valid?(count, flat_options)
       if flat_options[:max].present? && flat_options[:min].present?
         count >= flat_options[:min] && count <= flat_options[:max]
@@ -33,5 +42,36 @@ module ActiveStorageValidations
         count >= flat_options[:min]
       end
     end
+
+    def ensure_at_least_one_validator_option
+      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :max or :min to the validator'
+      end
+    end
+
+    def ensure_arguments_validity
+      return true if min_max_are_proc? || min_or_max_is_proc_and_other_not_present?
+
+      raise ArgumentError, 'You must pass integers to :min and :max' if min_or_max_defined_and_not_integer?
+      raise ArgumentError, 'You must pass a higher value to :max than to :min' if min_higher_than_max?
+    end
+
+    def min_max_are_proc?
+      options[:min]&.is_a?(Proc) && options[:max]&.is_a?(Proc)
+    end
+
+    def min_or_max_is_proc_and_other_not_present?
+      (options[:min]&.is_a?(Proc) && options[:max].nil?) ||
+        (options[:min].nil? && options[:max]&.is_a?(Proc))
+    end
+
+    def min_or_max_defined_and_not_integer?
+      (options.key?(:min) && !options[:min].is_a?(Integer)) ||
+        (options.key?(:max) && !options[:max].is_a?(Integer))
+    end
+
+    def min_higher_than_max?
+      options[:min] > options[:max] if options[:min].is_a?(Integer) && options[:max].is_a?(Integer)
+    end
   end
 end