active_storage_validations 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ee85f42558858c115d91d107a0b67f6088d65b4cbc1ec8461f4f5baf230a025
-  data.tar.gz: 4cf3fdb1bde0e805d22ad7d7d81d43cf5b378e06bde5443d938d1e390deee816
+  metadata.gz: 305a698168303d4889b8ba6b3972201842af8679758f6f9c81140658a0abdc8a
+  data.tar.gz: 414b60017f2da20463daa783e56028c927c2090a80e7728877f569323ec0b60a
 SHA512:
-  metadata.gz: 9c3a532221860176a87f042126b7a068425d2efca7ec908393691ae807af36e55b10d38180f8226dd73c1da0cff9f7dc5d1408ac1049ccbef58033ce9fdca48c
-  data.tar.gz: 469f3406a95dc8d0466d475d1cabc5b5658e813430728593140ce78b96892d0837da075f83d2901967b258f7ff57cf830390401737cb2f739b0bcd6c13d16aa3
+  metadata.gz: 48123a7a880a4f8e1b7680d3ea21b2e54c6f13b884b351e11c3f912fcdeec01efe24a0d6fc26b1021ec9b92460f6c6df321c869d9a8ce4e1848d339b1e35b0ca
+  data.tar.gz: faee600c94d2534a943feb4eebe14574341e3920e9bfd03fe663afad85c80e01c8cb7f95ced957ce333a323553798c6d73c0f8bffb33bdc185b922047f176b20

data/README.md

@@ -68,15 +68,14 @@ end
 
 ### More examples
 
-- Content type validation using symbols. In order to infer the correct mime type from the symbol, the types must be registered with `Marcel::EXTENSIONS` (`MimeMagic::EXTENSIONS` for Rails <= 6.1.3).
+- Content type validation using symbols or regex. The symbol types must be registered by [`Marcel::EXTENSIONS`](https://github.com/rails/marcel/blob/main/lib/marcel/tables.rb) that's used by this gem to infer the full content type.
 
 ```ruby
 class User < ApplicationRecord
   has_one_attached :avatar
   has_many_attached :photos
 
-  validates :avatar, attached: true, content_type: :png # Marcel::Magic.by_extension(:png).to_s => 'image/png'
-                                                        # Rails <= 6.1.3; MimeMagic.by_extension(:png).to_s => 'image/png'
+  validates :avatar, attached: true, content_type: :png
   # or
   validates :photos, attached: true, content_type: [:png, :jpg, :jpeg]
   # or
@@ -174,12 +173,24 @@ en:
       image_not_processable: "is not a valid image"
 ```
 
-In some cases, Active Storage Validations provides variables to help you customize messages:
+In several cases, Active Storage Validations provides variables to help you customize messages:
+
+### Aspect ratio
+The keys starting with `aspect_ratio_` support two variables that you can use:
+- `aspect_ratio` containing the expected aspect ratio, especially usefull for custom aspect ratio
+- `filename` containing the current file name
+
+For example :
+
+```yml
+aspect_ratio_is_not: "must be a %{aspect_ratio} image"
+```
 
 ### Content type
-The `content_type_invalid` key has two variables that you can use:
+The `content_type_invalid` key has three variables that you can use:
 - `content_type` containing the content type of the sent file
 - `authorized_types` containing the list of authorized content types
+- `filename` containing the current file name
 
 For example :
 
@@ -187,22 +198,27 @@ For example :
 content_type_invalid: "has an invalid content type : %{content_type}, authorized types are %{authorized_types}"
 ```
 
-### Number of files
-The `limit_out_of_range` key supports two variables that you can use:
-- `min` containing the minimum number of files
-- `max` containing the maximum number of files
+### Dimension
+The keys starting with `dimension_` support six variables that you can use:
+- `min` containing the minimum width or height allowed
+- `max` containing the maximum width or height allowed
+- `width` containing the minimum or maximum width allowed
+- `height` containing the minimum or maximum width allowed
+- `lenght` containing the exact width or height allowed
+- `filename` containing the current file name
 
 For example :
 
 ```yml
-limit_out_of_range: "total number is out of range. range: [%{min}, %{max}]"
+dimension_min_inclusion: "must be greater than or equal to %{width} x %{height} pixel."
 ```
 
 ### File size
-The keys starting with `file_size_not_` support three variables that you can use:
+The keys starting with `file_size_not_` support four variables that you can use:
 - `file_size` containing the current file size
 - `min` containing the minimum file size
 - `max` containing the maxmimum file size
+- `filename` containing the current file name
 
 For example :
 
@@ -210,14 +226,25 @@ For example :
 file_size_not_between: "file size must be between %{min_size} and %{max_size} (current size is %{file_size})"
 ```
 
-### Aspect ratio
-The keys starting with `aspect_ratio_` support one variable that you can use:
-- `aspect_ratio` containing the expected aspect ratio, especially usefull for custom aspect ratio
+### Number of files
+The `limit_out_of_range` key supports two variables that you can use:
+- `min` containing the minimum number of files
+- `max` containing the maximum number of files
 
 For example :
 
 ```yml
-aspect_ratio_is_not: "must be a %{aspect_ratio} image"
+limit_out_of_range: "total number is out of range. range: [%{min}, %{max}]"
+```
+
+### Processable image
+The `image_not_processable` key supports one variable that you can use:
+- `filename` containing the current file name
+
+For example :
+
+```yml
+image_not_processable: "is not a valid image (file: %{filename})"
 ```
 
 ## Installation
@@ -247,7 +274,7 @@ Very simple example of validation with file attached, content type check and cus
 [![Sample](https://raw.githubusercontent.com/igorkasyanchuk/active_storage_validations/master/docs/preview.png)](https://raw.githubusercontent.com/igorkasyanchuk/active_storage_validations/master/docs/preview.png)
 
 ## Test matchers
-Provides RSpec-compatible and Minitest-compatible matchers for testing the validators.
+Provides RSpec-compatible and Minitest-compatible matchers for testing the validators. Only `aspect_ratio`, `attached`, `content_type`, `dimension` and `size` validators currently have their matcher developped.
 
 ### RSpec
 
@@ -265,38 +292,65 @@ RSpec.configure do |config|
 end
 ```
 
-Example (Note that the options are chainable):
+Matcher methods available:
 
 ```ruby
 describe User do
+  # aspect_ratio:
+  # #allowing, #rejecting
+  it { is_expected.to validate_aspect_ratio_of(:avatar).allowing(:square) }
+  it { is_expected.to validate_aspect_ratio_of(:avatar).rejecting(:portrait) }
+
+  # attached
   it { is_expected.to validate_attached_of(:avatar) }
-  it { is_expected.to validate_attached_of(:avatar).with_message('must not be blank') }
 
+  # content_type:
+  # #allowing, #rejecting
   it { is_expected.to validate_content_type_of(:avatar).allowing('image/png', 'image/gif') }
   it { is_expected.to validate_content_type_of(:avatar).rejecting('text/plain', 'text/xml') }
-  it { is_expected.to validate_content_type_of(:avatar).rejecting('text/plain', 'text/xml').with_message("must be an authorized type") }
 
+  # dimension:
+  # #width, #height, #width_min, #height_min, #width_max, #height_max, #width_between, #height_between
   it { is_expected.to validate_dimensions_of(:avatar).width(250) }
   it { is_expected.to validate_dimensions_of(:avatar).height(200) }
-  it { is_expected.to validate_dimensions_of(:avatar).width(250).height(200).with_message('Invalid dimensions.') }
   it { is_expected.to validate_dimensions_of(:avatar).width_min(200) }
-  it { is_expected.to validate_dimensions_of(:avatar).width_max(500) }
   it { is_expected.to validate_dimensions_of(:avatar).height_min(100) }
+  it { is_expected.to validate_dimensions_of(:avatar).width_max(500) }
   it { is_expected.to validate_dimensions_of(:avatar).height_max(300) }
   it { is_expected.to validate_dimensions_of(:avatar).width_between(200..500) }
   it { is_expected.to validate_dimensions_of(:avatar).height_between(100..300) }
 
+  # size:
+  # #less_than, #less_than_or_equal_to, #greater_than, #greater_than_or_equal_to, #between
   it { is_expected.to validate_size_of(:avatar).less_than(50.kilobytes) }
   it { is_expected.to validate_size_of(:avatar).less_than_or_equal_to(50.kilobytes) }
   it { is_expected.to validate_size_of(:avatar).greater_than(1.kilobyte) }
-  it { is_expected.to validate_size_of(:avatar).greater_than(1.kilobyte).with_message('is not in required file size range') }
   it { is_expected.to validate_size_of(:avatar).greater_than_or_equal_to(1.kilobyte) }
   it { is_expected.to validate_size_of(:avatar).between(100..500.kilobytes) }
 end
 ```
+(Note that matcher methods are chainable)
+
+All matchers can currently be customized with Rails validation options:
+
+```ruby
+describe User do
+  # :allow_blank
+  it { is_expected.to validate_attached_of(:avatar).allow_blank }
+
+  # :on
+  it { is_expected.to validate_attached_of(:avatar).on(:update) }
+  it { is_expected.to validate_attached_of(:avatar).on(%i[update custom]) }
+
+  # :message
+  it { is_expected.to validate_dimensions_of(:avatar).width(250).with_message('Invalid dimensions.') }
+end
+```
 
 ### Minitest
-To use the following syntax, make sure you have the [shoulda-context](https://github.com/thoughtbot/shoulda-context) gem up and running. To make use of the matchers you need to require the matchers:
+To use the matchers, make sure you have the [shoulda-context](https://github.com/thoughtbot/shoulda-context) gem up and running.
+
+You need to require the matchers:
 
 ```ruby
 require 'active_storage_validations/matchers'
@@ -310,35 +364,7 @@ class ActiveSupport::TestCase
 end
 ```
 
-Example (Note that the options are chainable):
-
-```ruby
-class UserTest < ActiveSupport::TestCase
-  should validate_attached_of(:avatar)
-  should validate_attached_of(:avatar).with_message('must not be blank')
-
-  should validate_content_type_of(:avatar).allowing('image/png', 'image/gif')
-  should validate_content_type_of(:avatar).rejecting('text/plain', 'text/xml')
-  should validate_content_type_of(:avatar).rejecting('text/plain', 'text/xml').with_message("must be an authorized type")
-
-  should validate_dimensions_of(:avatar).width(250)
-  should validate_dimensions_of(:avatar).height(200)
-  should validate_dimensions_of(:avatar).width(250).height(200).with_message('Invalid dimensions.')
-  should validate_dimensions_of(:avatar).width_min(200)
-  should validate_dimensions_of(:avatar).width_max(500)
-  should validate_dimensions_of(:avatar).height_min(100)
-  should validate_dimensions_of(:avatar).height_max(300)
-  should validate_dimensions_of(:avatar).width_between(200..500)
-  should validate_dimensions_of(:avatar).height_between(100..300)
-
-  should validate_size_of(:avatar).less_than(50.kilobytes)
-  should validate_size_of(:avatar).less_than_or_equal_to(50.kilobytes)
-  should validate_size_of(:avatar).greater_than(1.kilobyte)
-  should validate_size_of(:avatar).greater_than(1.kilobyte).with_message('is not in required file size range')
-  should validate_size_of(:avatar).greater_than_or_equal_to(1.kilobyte)
-  should validate_size_of(:avatar).between(100..500.kilobytes)
-end
-```
+Then you can use the matchers with the syntax specified in the RSpec section, just use `should validate_method` instead of `it { is_expected_to validate_method }` as specified in the [shoulda-context](https://github.com/thoughtbot/shoulda-context) gem.
 
 ## Todo
 
@@ -350,7 +376,7 @@ end
 
 To run tests in root folder of gem:
 
-* `BUNDLE_GEMFILE=gemfiles/rails_6_1.gemfile bundle exec rake test` to run for Rails 6.1
+* `BUNDLE_GEMFILE=gemfiles/rails_6_1_3_1.gemfile bundle exec rake test` to run for Rails 6.1
 * `BUNDLE_GEMFILE=gemfiles/rails_7_0.gemfile bundle exec rake test` to run for Rails 7.0
 * `BUNDLE_GEMFILE=gemfiles/rails_7_1.gemfile bundle exec rake test` to run for Rails 7.0
 * `BUNDLE_GEMFILE=gemfiles/rails_next.gemfile bundle exec rake test` to run for Rails main branch
@@ -358,11 +384,11 @@ To run tests in root folder of gem:
 Snippet to run in console:
 
 ```bash
-BUNDLE_GEMFILE=gemfiles/rails_6_1.gemfile bundle
+BUNDLE_GEMFILE=gemfiles/rails_6_1_3_1.gemfile bundle
 BUNDLE_GEMFILE=gemfiles/rails_7_0.gemfile bundle
 BUNDLE_GEMFILE=gemfiles/rails_7_1.gemfile bundle
 BUNDLE_GEMFILE=gemfiles/rails_next.gemfile bundle
-BUNDLE_GEMFILE=gemfiles/rails_6_1.gemfile bundle exec rake test
+BUNDLE_GEMFILE=gemfiles/rails_6_1_3_1.gemfile bundle exec rake test
 BUNDLE_GEMFILE=gemfiles/rails_7_0.gemfile bundle exec rake test
 BUNDLE_GEMFILE=gemfiles/rails_7_1.gemfile bundle exec rake test
 BUNDLE_GEMFILE=gemfiles/rails_next.gemfile bundle exec rake test

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -1,21 +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')
@@ -29,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
@@ -45,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]
@@ -82,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,19 +1,28 @@
 # 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 this validator"
+        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? { |file| file.marked_for_destruction? }
 
       errors_options = initialize_error_options(options)
-
       add_error(record, attribute, ERROR_TYPES.first, **errors_options)
     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)
+      }.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 then file.blob.filename.to_s
+      when Hash then file[:filename]
+      end
+    end
+  end
+end

data/lib/active_storage_validations/concerns/symbolizable.rb

@@ -1,10 +1,12 @@
-module Symbolizable
-  extend ActiveSupport::Concern
+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
+    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,30 +1,35 @@
 # 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, ERROR_TYPES.first, **errors_options)
         break
@@ -44,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
 
@@ -58,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,12 +1,13 @@
 # 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
@@ -46,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'
@@ -64,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
@@ -78,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
@@ -98,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]
@@ -108,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]
@@ -125,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]
@@ -133,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]
 
@@ -148,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]