active_storage_validations 0.9.5 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efa69aeeea1b171286c6ca464e38146dedef79d22853c35ec6ea0ce0ca089812
-  data.tar.gz: e186561942afb6b295839565323d0bbed704de9e413b79ecc1fb194ada643ca5
+  metadata.gz: 267c083e1e37ff53853d928bf3df0a69b8c9cf0662c3cf744f99cde3d5809125
+  data.tar.gz: 36554892e5c2df7ad812119b6acfae985e4adbe1dd8f7c29699f8f9ba69f0506
 SHA512:
-  metadata.gz: c31ec657e1121427f19d7617d5efbeab639c6ebd87c0333c36510064e7b4d8125ffd8e4f5afa86121e626dd608d2ad1b859a3515c8bc7683e0793291a30c7fd2
-  data.tar.gz: 3141abc08b6b33d90f9874a74e93f6aaddb0ebbd52bdd36ee292a1e0ff7d37cf65a8ced082d316f48cc8e0132320c4f83304d9823971906526096264129c0145
+  metadata.gz: 6cbe5d7521afc8680a9df584968c4e3da7c5e1602efc30f60dc6890a54bb9d609daf7e7eaa0924d6d7971f13e9c763e4063c228d14645b8c5261f1702c4a21c9
+  data.tar.gz: 989e058c095e07790f647af2582355dddd715101b6dce10d4b521865362c5857f8df869270ae88e5eb58d20fa698ed470f4b181517ac016439d45f0e30049e21

data/README.md

@@ -1,3 +1,6 @@
+[<img src="https://github.com/igorkasyanchuk/rails_time_travel/blob/main/docs/more_gems.png?raw=true"
+/>](https://www.railsjazz.com/?utm_source=github&utm_medium=top&utm_campaign=active_storage_validations)
+
 # Active Storage Validations
 
 [![MiniTest](https://github.com/igorkasyanchuk/active_storage_validations/workflows/MiniTest/badge.svg)](https://github.com/igorkasyanchuk/active_storage_validations/actions)
@@ -16,7 +19,9 @@ This gems doing it for you. Just use `attached: true` or `content_type: 'image/p
 * validates dimension of images/videos
 * validates number of uploaded files (min/max required)
 * validates aspect ratio (if square, portrait, landscape, is_16_9, ...)
+* validates if file can be processed by MiniMagick or Vips
 * custom error messages
+* allow procs for dynamic determination of values
 
 ## Usage
 
@@ -26,16 +31,18 @@ For example you have a model like this and you want to add validation.
 class User < ApplicationRecord
   has_one_attached :avatar
   has_many_attached :photos
+  has_one_attached :image
 
   validates :name, presence: true
 
   validates :avatar, attached: true, content_type: 'image/png',
                                      dimension: { width: 200, height: 200 }
-  validates :photos, attached: true, content_type: ['image/png', 'image/jpg', 'image/jpeg'],
+  validates :photos, attached: true, content_type: ['image/png', 'image/jpeg'],
                                      dimension: { width: { min: 800, max: 2400 },
                                                   height: { min: 600, max: 1800 }, message: 'is not given between dimension' }
   validates :image, attached: true,
-                    content_type: ['image/png', 'image/jpg'],
+                    processable_image: true,
+                    content_type: ['image/png', 'image/jpeg'],
                     aspect_ratio: :landscape
 end
 ```
@@ -44,13 +51,15 @@ or
 
 ```ruby
 class Project < ApplicationRecord
+  has_one_attached :logo
   has_one_attached :preview
   has_one_attached :attachment
   has_many_attached :documents
 
   validates :title, presence: true
 
-  validates :preview, attached: true, size: { less_than: 100.megabytes , message: 'is not given between size' }
+  validates :logo, attached: true, size: { less_than: 100.megabytes , message: 'is too large' }
+  validates :preview, attached: true, size: { between: 1.kilobyte..100.megabytes , message: 'is not given between size' }
   validates :attachment, attached: true, content_type: { in: 'application/pdf', message: 'is not a PDF' }
   validates :documents, limit: { min: 1, max: 3 }
 end
@@ -58,14 +67,15 @@ 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 `MimeMagic::EXTENSIONS`.
+- 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).
 
 ```ruby
 class User < ApplicationRecord
   has_one_attached :avatar
   has_many_attached :photos
 
-  validates :avatar, attached: true, content_type: :png # MimeMagic.by_extension(:png).to_s => 'image/png'
+  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'
   # or
   validates :photos, attached: true, content_type: [:png, :jpg, :jpeg]
   # or
@@ -117,6 +127,18 @@ class User < ApplicationRecord
 end
 ```
 
+- Proc Usage:
+
+Procs can be used instead of values in all the above examples. They will be called on every validation.
+```ruby
+class User < ApplicationRecord
+  has_many_attached :proc_files
+
+  validates :proc_files, limit: { max: -> (record) { record.admin? ? 100 : 10 } }
+end
+
+```
+
 ## Internationalization (I18n)
 
 Active Storage Validations uses I18n for error messages. For this, add these keys in your translation file:
@@ -144,6 +166,7 @@ en:
       aspect_ratio_not_landscape: "must be a landscape image"
       aspect_ratio_is_not: "must have an aspect ratio of %{aspect_ratio}"
       aspect_ratio_unknown: "has an unknown aspect ratio"
+      image_not_processable: "is not a valid image"
 ```
 
 In some cases, Active Storage Validations provides variables to help you customize messages:
@@ -176,6 +199,8 @@ gem 'active_storage_validations'
 
 # Optional, to use :dimension validator or :aspect_ratio validator
 gem 'mini_magick', '>= 4.9.5'
+# Or
+gem 'ruby-vips', '>= 2.1.0'
 ```
 
 And then execute:
@@ -289,9 +314,23 @@ end
 
 To run tests in root folder of gem:
 
-* `BUNDLE_GEMFILE=gemfiles/rails_5_2.gemfile bundle exec rake test` to run for Rails 5.2
 * `BUNDLE_GEMFILE=gemfiles/rails_6_0.gemfile bundle exec rake test` to run for Rails 6.0
 * `BUNDLE_GEMFILE=gemfiles/rails_6_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_next.gemfile bundle exec rake test` to run for Rails main branch
+
+Snippet to run in console:
+
+```
+BUNDLE_GEMFILE=gemfiles/rails_6_0.gemfile bundle
+BUNDLE_GEMFILE=gemfiles/rails_6_1.gemfile bundle
+BUNDLE_GEMFILE=gemfiles/rails_7_0.gemfile bundle
+BUNDLE_GEMFILE=gemfiles/rails_next.gemfile bundle
+BUNDLE_GEMFILE=gemfiles/rails_6_0.gemfile bundle exec rake test
+BUNDLE_GEMFILE=gemfiles/rails_6_1.gemfile bundle exec rake test
+BUNDLE_GEMFILE=gemfiles/rails_7_0.gemfile bundle exec rake test
+BUNDLE_GEMFILE=gemfiles/rails_next.gemfile bundle exec rake test
+```
 
 ## Known issues
 
@@ -344,11 +383,27 @@ You are welcome to contribute.
 - https://github.com/jayshepherd
 - https://github.com/ohbarye
 - https://github.com/randsina
-- https://github.com/...
+- https://github.com/vietqhoang
+- https://github.com/kemenaran
+- https://github.com/jrmhaig
+- https://github.com/tagliala
+- https://github.com/evedovelli
+- https://github.com/JuanVqz
+- https://github.com/luiseugenio
+- https://github.com/equivalent
+- https://github.com/NARKOZ
+- https://github.com/stephensolis
+- https://github.com/kwent
+= https://github.com/Animesh-Ghosh
+= https://github.com/gr8bit
+= https://github.com/codegeek319
+= https://github.com/clwy-cn
+= https://github.com/kukicola
+= https://github.com/sobrinho
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 [<img src="https://github.com/igorkasyanchuk/rails_time_travel/blob/main/docs/more_gems.png?raw=true"
-/>](https://www.railsjazz.com/)
+/>](https://www.railsjazz.com/?utm_source=github&utm_medium=bottom&utm_campaign=active_storage_validations)

data/config/locales/en.yml

@@ -20,3 +20,4 @@ en:
       aspect_ratio_not_landscape: "must be a landscape image"
       aspect_ratio_is_not: "must have an aspect ratio of %{aspect_ratio}"
       aspect_ratio_unknown: "has an unknown aspect ratio"
+      image_not_processable: "is not a valid image"

data/config/locales/pt-BR.yml

@@ -2,21 +2,21 @@ pt-BR:
   errors:
     messages:
       content_type_invalid: "tem um tipo de arquivo inválido"
-      file_size_out_of_range: "tamanho %{file_size} está fora da faixa de tamanho válida"
-      limit_out_of_range: "número total está fora do limite"
+      file_size_out_of_range: "tem tamanho %{file_size} e está fora da faixa de tamanho válida"
+      limit_out_of_range: "o número total está fora do limite"
       image_metadata_missing: "não é uma imagem válida"
-      dimension_min_inclusion: "deve ser maior ou igual a %{width} x %{height} pixel"
-      dimension_max_inclusion: "deve ser menor ou igual a %{width} x %{height} pixel"
-      dimension_width_inclusion: "largura não está entre %{min} e %{max} pixel"
-      dimension_height_inclusion: "altura não está entre %{min} e %{max} pixel"
-      dimension_width_greater_than_or_equal_to: "largura deve ser maior ou igual a %{length} pixel"
-      dimension_height_greater_than_or_equal_to: "altura deve ser maior ou igual a %{length} pixel"
-      dimension_width_less_than_or_equal_to: "largura deve ser menor ou igual a %{length} pixel"
-      dimension_height_less_than_or_equal_to: "altura deve ser menor ou igual a %{length} pixel"
-      dimension_width_equal_to: "largura deve ser igual a %{length} pixel"
-      dimension_height_equal_to: "altura deve ser igual a %{length} pixel"
+      dimension_min_inclusion: "deve ser maior ou igual a %{width} x %{height} pixels"
+      dimension_max_inclusion: "deve ser menor ou igual a %{width} x %{height} pixels"
+      dimension_width_inclusion: "deve ter largura entre %{min} e %{max} pixels"
+      dimension_height_inclusion: "deve ter altura entre %{min} e %{max} pixels"
+      dimension_width_greater_than_or_equal_to: "deve ter largura maior ou igual a %{length} pixels"
+      dimension_height_greater_than_or_equal_to: "deve ter altura maior ou igual a %{length} pixels"
+      dimension_width_less_than_or_equal_to: "deve ter largura menor ou igual a %{length} pixels"
+      dimension_height_less_than_or_equal_to: "deve ter altura menor ou igual a %{length} pixels"
+      dimension_width_equal_to: "deve ter largura igual a %{length} pixels"
+      dimension_height_equal_to: "deve ter altura igual a %{length} pixels"
       aspect_ratio_not_square: "não é uma imagem quadrada"
-      aspect_ratio_not_portrait: "não contém uma imagem no formato retrato"
-      aspect_ratio_not_landscape: "não contém uma imagem no formato paisagem"
+      aspect_ratio_not_portrait: "não está no formato retrato"
+      aspect_ratio_not_landscape: "não está no formato paisagem"
       aspect_ratio_is_not: "não contém uma proporção de %{aspect_ratio}"
       aspect_ratio_unknown: "não tem uma proporção definida"

data/config/locales/zh-CN.yml

@@ -0,0 +1,22 @@
+zh-CN:
+  errors:
+    messages:
+      content_type_invalid: "文件类型错误"
+      file_size_out_of_range: "文件大小 %{file_size} 超出限定范围"
+      limit_out_of_range: "文件数超出限定范围"
+      image_metadata_missing: "不是有效的图像"
+      dimension_min_inclusion: "必须大于或等于 %{width} x %{height} 像素"
+      dimension_max_inclusion: "必须小于或等于 %{width} x %{height} 像素"
+      dimension_width_inclusion: "宽度不在 %{min} 和 %{max} 像素之间"
+      dimension_height_inclusion: "高度不在 %{min} 和 %{max} 像素之间"
+      dimension_width_greater_than_or_equal_to: "宽度必须大于或等于 %{length} 像素"
+      dimension_height_greater_than_or_equal_to: "高度必须大于或等于 %{length} 像素"
+      dimension_width_less_than_or_equal_to: "宽度必须小于或等于 %{length} 像素"
+      dimension_height_less_than_or_equal_to: "高度必须小于或等于 %{length} 像素"
+      dimension_width_equal_to: "宽度必须等于 %{length} 像素"
+      dimension_height_equal_to: "高度必须等于 %{length} 像素"
+      aspect_ratio_not_square: "必须是方形图片"
+      aspect_ratio_not_portrait: "必须是竖屏图片"
+      aspect_ratio_not_landscape: "必须是横屏图片"
+      aspect_ratio_is_not: "纵横比必须是 %{aspect_ratio}"
+      aspect_ratio_unknown: "未知的纵横比"

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -4,21 +4,17 @@ require_relative 'metadata.rb'
 
 module ActiveStorageValidations
   class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
+    include OptionProcUnfolding
+
     AVAILABLE_CHECKS = %i[with].freeze
     PRECISION = 3
 
-    def initialize(options)
-      require 'mini_magick' unless defined?(MiniMagick)
-      super(options)
-    end
-
-
     def check_validity!
       return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass "aspect_ratio: :OPTION" option to the validator'
+      raise ArgumentError, 'You must pass :with to the validator'
     end
 
-    if Rails::VERSION::MAJOR >= 6
+    if Rails.gem_version >= Gem::Version.new('6.0.0')
       def validate_each(record, attribute, _value)
         return true unless record.send(attribute).attached?
 
@@ -37,14 +33,14 @@ module ActiveStorageValidations
       # Rails 5
       def validate_each(record, attribute, _value)
         return true unless record.send(attribute).attached?
-  
+
         files = Array.wrap(record.send(attribute))
-  
+
         files.each do |file|
           # Analyze file first if not analyzed to get all required metadata.
           file.analyze; file.reload unless file.analyzed?
           metadata = file.metadata
-  
+
           next if is_valid?(record, attribute, metadata)
           break
         end
@@ -56,26 +52,27 @@ module ActiveStorageValidations
 
 
     def is_valid?(record, attribute, metadata)
+      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
       if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
-        add_error(record, attribute, options[:message].presence || :image_metadata_missing)
+        add_error(record, attribute, :image_metadata_missing, flat_options[:with])
         return false
       end
 
-      case options[:with]
+      case flat_options[:with]
       when :square
         return true if metadata[:width] == metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_square)
+        add_error(record, attribute, :aspect_ratio_not_square, flat_options[:with])
 
       when :portrait
         return true if metadata[:height] > metadata[:width]
-        add_error(record, attribute, :aspect_ratio_not_portrait)
+        add_error(record, attribute, :aspect_ratio_not_portrait, flat_options[:with])
 
       when :landscape
         return true if metadata[:width] > metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_landscape)
+        add_error(record, attribute, :aspect_ratio_not_landscape, flat_options[:with])
 
       else
-        if options[:with] =~ /is\_(\d*)\_(\d*)/
+        if flat_options[:with] =~ /is_(\d*)_(\d*)/
           x = $1.to_i
           y = $2.to_i
 
@@ -83,17 +80,17 @@ module ActiveStorageValidations
 
           add_error(record, attribute, :aspect_ratio_is_not, "#{x}x#{y}")
         else
-          add_error(record, attribute, :aspect_ratio_unknown)
+          add_error(record, attribute, :aspect_ratio_unknown, flat_options[:with])
         end
       end
       false
     end
 
 
-    def add_error(record, attribute, type, interpolate = options[:with])
-      key = options[:message].presence || type
-      return if record.errors.added?(attribute, key)
-      record.errors.add(attribute, key, aspect_ratio: interpolate)
+    def add_error(record, attribute, default_message, interpolate)
+      message = options[:message].presence || default_message
+      return if record.errors.added?(attribute, message)
+      record.errors.add(attribute, message, aspect_ratio: interpolate)
     end
 
   end

data/lib/active_storage_validations/content_type_validator.rb

@@ -2,16 +2,23 @@
 
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
+    include OptionProcUnfolding
+
+    AVAILABLE_CHECKS = %i[with in].freeze
+    
     def validate_each(record, attribute, _value)
-      return true if !record.send(attribute).attached? || types.empty?
+      return true unless record.send(attribute).attached?
 
+      types = authorized_types(record)
+      return true if types.empty?
+      
       files = Array.wrap(record.send(attribute))
 
-      errors_options = { authorized_types: types_to_human_format }
+      errors_options = { authorized_types: types_to_human_format(types) }
       errors_options[:message] = options[:message] if options[:message].present?
 
       files.each do |file|
-        next if is_valid?(file)
+        next if is_valid?(file, types)
 
         errors_options[:content_type] = content_type(file)
         record.errors.add(attribute, :content_type_invalid, **errors_options)
@@ -19,10 +26,9 @@ module ActiveStorageValidations
       end
     end
 
-    def types
-      return @types if defined? @types
-
-      @types = (Array.wrap(options[:with]) + Array.wrap(options[:in])).compact.map do |type|
+    def authorized_types(record)
+      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+      (Array.wrap(flat_options[:with]) + Array.wrap(flat_options[:in])).compact.map do |type|
         if type.is_a?(Regexp)
           type
         else
@@ -31,7 +37,7 @@ module ActiveStorageValidations
       end
     end
 
-    def types_to_human_format
+    def types_to_human_format(types)
       types
         .map { |type| type.to_s.split('/').last.upcase }
         .join(', ')
@@ -41,7 +47,7 @@ module ActiveStorageValidations
       file.blob.present? && file.blob.content_type
     end
 
-    def is_valid?(file)
+    def is_valid?(file, types)
       file_type = content_type(file)
       types.any? do |type|
         type == file_type || (type.is_a?(Regexp) && type.match?(file_type.to_s))

data/lib/active_storage_validations/dimension_validator.rb

@@ -4,27 +4,30 @@ require_relative 'metadata.rb'
 
 module ActiveStorageValidations
   class DimensionValidator < ActiveModel::EachValidator # :nodoc
+    include OptionProcUnfolding
+
     AVAILABLE_CHECKS = %i[width height min max].freeze
 
-    def initialize(options)
-      require 'mini_magick' unless defined?(MiniMagick)
+    def process_options(record)
+      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
 
       [:width, :height].each do |length|
-        if options[length] and options[length].is_a?(Hash)
-          if range = options[length][:in]
+        if flat_options[length] and flat_options[length].is_a?(Hash)
+          if (range = flat_options[length][:in])
             raise ArgumentError, ":in must be a Range" unless range.is_a?(Range)
-            options[length][:min], options[length][:max] = range.min, range.max
+            flat_options[length][:min], flat_options[length][:max] = range.min, range.max
           end
         end
       end
       [:min, :max].each do |dim|
-        if range = options[dim]
+        if (range = flat_options[dim])
           raise ArgumentError, ":#{dim} must be a Range (width..height)" unless range.is_a?(Range)
-          options[:width] = { dim => range.first }
-          options[:height] = { dim => range.last }
+          flat_options[:width] = { dim => range.first }
+          flat_options[:height] = { dim => range.last }
         end
       end
-      super
+
+      flat_options
     end
 
 
@@ -34,7 +37,7 @@ module ActiveStorageValidations
     end
 
 
-    if Rails::VERSION::MAJOR >= 6
+    if Rails.gem_version >= Gem::Version.new('6.0.0')
       def validate_each(record, attribute, _value)
         return true unless record.send(attribute).attached?
 
@@ -66,63 +69,67 @@ module ActiveStorageValidations
 
 
     def is_valid?(record, attribute, file_metadata)
+      flat_options = process_options(record)
       # Validation fails unless file metadata contains valid width and height.
       if file_metadata[:width].to_i <= 0 || file_metadata[:height].to_i <= 0
-        add_error(record, attribute, options[:message].presence || :image_metadata_missing)
+        add_error(record, attribute, :image_metadata_missing)
         return false
       end
 
       # Validation based on checks :min and :max (:min, :max has higher priority to :width, :height).
-      if options[:min] || options[:max]
-        if options[:min] && (
-          (options[:width][:min] && file_metadata[:width] < options[:width][:min]) ||
-          (options[:height][:min] && file_metadata[:height] < options[:height][:min])
+      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])
           )
-          add_error(record, attribute, options[:message].presence || :"dimension_min_inclusion", width: options[:width][:min], height: options[:height][:min])
+          add_error(record, attribute, :dimension_min_inclusion, width: flat_options[:width][:min], height: flat_options[:height][:min])
           return false
         end
-        if options[:max] && (
-          (options[:width][:max] && file_metadata[:width] > options[:width][:max]) ||
-          (options[:height][:max] && file_metadata[:height] > options[:height][:max])
+        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])
           )
-          add_error(record, attribute, options[:message].presence || :"dimension_max_inclusion", width: options[:width][:max], height: options[:height][:max])
+          add_error(record, attribute, :dimension_max_inclusion, width: flat_options[:width][:max], height: flat_options[:height][:max])
           return false
         end
 
       # Validation based on checks :width and :height.
       else
+        width_or_height_invalid = false
         [:width, :height].each do |length|
-          next unless options[length]
-          if options[length].is_a?(Hash)
-            if options[length][:in] && (file_metadata[length] < options[length][:min] || file_metadata[length] > options[length][:max])
-              add_error(record, attribute, options[:message].presence || :"dimension_#{length}_inclusion", min: options[length][:min], max: options[length][:max])
-              return false
+          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])
+              add_error(record, attribute, :"dimension_#{length}_inclusion", min: flat_options[length][:min], max: flat_options[length][:max])
+              width_or_height_invalid = true
             else
-              if options[length][:min] && file_metadata[length] < options[length][:min]
-                add_error(record, attribute, options[:message].presence || :"dimension_#{length}_greater_than_or_equal_to", length: options[length][:min])
-                return false
+              if flat_options[length][:min] && file_metadata[length] < flat_options[length][:min]
+                add_error(record, attribute, :"dimension_#{length}_greater_than_or_equal_to", length: flat_options[length][:min])
+                width_or_height_invalid = true
               end
-              if options[length][:max] && file_metadata[length] > options[length][:max]
-                add_error(record, attribute, options[:message].presence || :"dimension_#{length}_less_than_or_equal_to", length: options[length][:max])
-                return false
+              if flat_options[length][:max] && file_metadata[length] > flat_options[length][:max]
+                add_error(record, attribute, :"dimension_#{length}_less_than_or_equal_to", length: flat_options[length][:max])
+                width_or_height_invalid = true
               end
             end
           else
-            if file_metadata[length] != options[length]
-              add_error(record, attribute, options[:message].presence || :"dimension_#{length}_equal_to", length: options[length])
-              return false
+            if file_metadata[length] != flat_options[length]
+              add_error(record, attribute, :"dimension_#{length}_equal_to", length: flat_options[length])
+              width_or_height_invalid = true
             end
           end
         end
+
+        return false if width_or_height_invalid
       end
 
       true # valid file
     end
 
-    def add_error(record, attribute, type, **attrs)
-      key = options[:message].presence || type
-      return if record.errors.added?(attribute, key)
-      record.errors.add(attribute, key, **attrs)
+    def add_error(record, attribute, default_message, **attrs)
+      message = options[:message].presence || default_message
+      return if record.errors.added?(attribute, message)
+      record.errors.add(attribute, message, **attrs)
     end
 
   end

data/lib/active_storage_validations/limit_validator.rb

@@ -2,11 +2,12 @@
 
 module ActiveStorageValidations
   class LimitValidator < ActiveModel::EachValidator # :nodoc:
+    include OptionProcUnfolding
+
     AVAILABLE_CHECKS = %i[max min].freeze
 
     def check_validity!
       return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-
       raise ArgumentError, 'You must pass either :max or :min to the validator'
     end
 
@@ -14,19 +15,20 @@ module ActiveStorageValidations
       return true unless record.send(attribute).attached?
 
       files = Array.wrap(record.send(attribute)).compact.uniq
-      errors_options = { min: options[:min], max: options[:max] }
+      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+      errors_options = { min: flat_options[:min], max: flat_options[:max] }
 
-      return true if files_count_valid?(files.count)
+      return true if files_count_valid?(files.count, flat_options)
       record.errors.add(attribute, options[:message].presence || :limit_out_of_range, **errors_options)
     end
 
-    def files_count_valid?(count)
-      if options[:max].present? && options[:min].present?
-        count >= options[:min] && count <= options[:max]
-      elsif options[:max].present?
-        count <= options[:max]
-      elsif options[:min].present?
-        count >= options[:min]
+    def files_count_valid?(count, flat_options)
+      if flat_options[:max].present? && flat_options[:min].present?
+        count >= flat_options[:min] && count <= flat_options[:max]
+      elsif flat_options[:max].present?
+        count <= flat_options[:max]
+      elsif flat_options[:min].present?
+        count >= flat_options[:min]
       end
     end
   end

data/lib/active_storage_validations/matchers/content_type_validator_matcher.rb

@@ -33,15 +33,19 @@ module ActiveStorageValidations
       end
 
       def failure_message
-        <<~MESSAGE
-          Expected #{@attribute_name}
-            
-            Accept content types: #{allowed_types.join(", ")}
-              #{accepted_types_and_failures}
-
-            Reject content types: #{rejected_types.join(", ")}
-              #{rejected_types_and_failures}
-        MESSAGE
+        message = ["Expected #{@attribute_name}"]
+
+        if @allowed_types
+          message << "Accept content types: #{allowed_types.join(", ")}"
+          message << "#{@missing_allowed_types.join(", ")} were rejected"
+        end
+
+        if @rejected_types
+          message << "Reject content types: #{rejected_types.join(", ")}"
+          message << "#{@missing_rejected_types.join(", ")} were accepted"
+        end
+
+        message.join("\n")
       end
 
       protected
@@ -57,7 +61,7 @@ module ActiveStorageValidations
       end
 
       def rejected_types
-        @rejected_types || (Marcel::TYPES.keys - allowed_types)
+        @rejected_types || []
       end
 
       def allowed_types_allowed?
@@ -70,22 +74,6 @@ module ActiveStorageValidations
         @missing_rejected_types.none?
       end
 
-      def accepted_types_and_failures
-        if @missing_allowed_types.present?
-          "#{@missing_allowed_types.join(", ")} were rejected."
-        else
-          "All were accepted successfully."
-        end
-      end
-
-      def rejected_types_and_failures
-        if @missing_rejected_types.present?
-          "#{@missing_rejected_types.join(", ")} were accepted."
-        else
-          "All were rejected successfully."
-        end
-      end
-
       def type_allowed?(type)
         @subject.public_send(@attribute_name).attach(attachment_for(type))
         @subject.validate

data/lib/active_storage_validations/matchers.rb

@@ -22,7 +22,7 @@ module ActiveStorageValidations
     end
 
     def self.mock_metadata(attachment, width, height)
-      if Rails::VERSION::MAJOR >= 6
+      if Rails.gem_version >= Gem::Version.new('6.0.0')
         # Mock the Metadata class for rails 6
         mock = OpenStruct.new(metadata: { width: width, height: height })
         stub_method(ActiveStorageValidations::Metadata, :new, mock) do

data/lib/active_storage_validations/metadata.rb

@@ -1,11 +1,34 @@
 module ActiveStorageValidations
   class Metadata
+    class InvalidImageError < StandardError; end
+
     attr_reader :file
 
     def initialize(file)
+      require_image_processor
       @file = file
     end
 
+    def image_processor
+      Rails.application.config.active_storage.variant_processor
+    end
+
+    def exception_class
+      if image_processor == :vips && defined?(Vips)
+        Vips::Error
+      elsif defined?(MiniMagick)
+        MiniMagick::Error
+      end
+    end
+
+    def require_image_processor
+      if image_processor == :vips
+        require 'vips' unless defined?(Vips)
+      else
+        require 'mini_magick' unless defined?(MiniMagick)
+      end
+    end
+
     def metadata
       read_image do |image|
         if rotated_image?(image)
@@ -14,6 +37,16 @@ module ActiveStorageValidations
           { width: image.width, height: image.height }
         end
       end
+    rescue InvalidImageError
+      logger.info "Skipping image analysis because ImageMagick or Vips doesn't support the file"
+      {}
+    end
+
+    def valid?
+      read_image
+      true
+    rescue InvalidImageError
+      false
     end
 
     private
@@ -21,17 +54,16 @@ module ActiveStorageValidations
     def read_image
       is_string = file.is_a?(String)
       if is_string || file.is_a?(ActiveStorage::Blob)
-        if is_string
-          # If Rails 5.2 or 6.0, use `find_signed`
-          if Rails::VERSION::MAJOR < 6 || (Rails::VERSION::MAJOR == 6 && Rails::VERSION::MINOR == 0)
-            blob = ActiveStorage::Blob.find_signed(file)
-          # If Rails 6.1 or higher, use `find_signed!`
-          elsif Rails::VERSION::MAJOR > 6 || (Rails::VERSION::MAJOR == 6 && Rails::VERSION::MINOR >= 1)
-            blob = ActiveStorage::Blob.find_signed!(file)
+        blob =
+          if is_string
+            if Rails.gem_version < Gem::Version.new('6.1.0')
+              ActiveStorage::Blob.find_signed(file)
+            else
+              ActiveStorage::Blob.find_signed!(file)
+            end
+          else
+            file
           end
-        else
-          blob = file
-        end
 
         tempfile = Tempfile.new(["ActiveStorage-#{blob.id}-", blob.filename.extension_with_delimiter])
         tempfile.binmode
@@ -43,29 +75,49 @@ module ActiveStorageValidations
         tempfile.flush
         tempfile.rewind
 
-        image = MiniMagick::Image.new(tempfile.path)
+        image = if image_processor == :vips && defined?(Vips) && Vips::get_suffixes.include?(File.extname(tempfile.path).downcase)
+                  Vips::Image.new_from_file(tempfile.path)
+                elsif defined?(MiniMagick)
+                  MiniMagick::Image.new(tempfile.path)
+                end
       else
-        image = MiniMagick::Image.new(read_file_path)
+        image = if image_processor == :vips && defined?(Vips) && Vips::get_suffixes.include?(File.extname(read_file_path).downcase)
+                  Vips::Image.new_from_file(read_file_path)
+                elsif defined?(MiniMagick)
+                  MiniMagick::Image.new(read_file_path)
+                end
       end
 
-      if image.valid?
-        yield image
-      else
-        logger.info "Skipping image analysis because ImageMagick doesn't support the file"
-        {}
-      end
-    rescue LoadError
-      logger.info "Skipping image analysis because the mini_magick gem isn't installed"
+
+      raise InvalidImageError unless valid_image?(image)
+      yield image if block_given?
+    rescue LoadError, NameError
+      logger.info "Skipping image analysis because the mini_magick or ruby-vips gem isn't installed"
       {}
-    rescue MiniMagick::Error => error
-      logger.error "Skipping image analysis due to an ImageMagick error: #{error.message}"
+    rescue exception_class => error
+      logger.error "Skipping image analysis due to an #{exception_class.name.split('::').map(&:downcase).join(' ').capitalize} error: #{error.message}"
       {}
     ensure
       image = nil
     end
 
+    def valid_image?(image)
+      return false unless image
+
+      image_processor == :vips && image.is_a?(Vips::Image) ? image.avg : image.valid?
+    rescue exception_class
+      false
+    end
+
     def rotated_image?(image)
-      %w[ RightTop LeftBottom ].include?(image["%[orientation]"])
+      if image_processor == :vips && image.is_a?(Vips::Image)
+        image.get('exif-ifd0-Orientation').include?('Right-top') ||
+          image.get('exif-ifd0-Orientation').include?('Left-bottom')
+      else
+        %w[ RightTop LeftBottom ].include?(image["%[orientation]"])
+      end
+    rescue exception_class # field "exif-ifd0-Orientation" not found
+      false
     end
 
     def read_file_path

data/lib/active_storage_validations/option_proc_unfolding.rb

@@ -0,0 +1,16 @@
+module ActiveStorageValidations
+  module OptionProcUnfolding
+
+    def unfold_procs(record, object, only_keys)
+      case object
+      when Hash
+        object.merge(object) { |key, value| only_keys&.exclude?(key) ? {} : unfold_procs(record, value, nil) }
+      when Array
+        object.map { |o| unfold_procs(record, o, only_keys) }
+      else
+        object.is_a?(Proc) ? object.call(record) : object
+      end
+    end
+
+  end
+end

data/lib/active_storage_validations/processable_image_validator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'metadata.rb'
+
+module ActiveStorageValidations
+  class ProcessableImageValidator < ActiveModel::EachValidator # :nodoc
+    include OptionProcUnfolding
+
+    if Rails.gem_version >= Gem::Version.new('6.0.0')
+      def validate_each(record, attribute, _value)
+        return true unless record.send(attribute).attached?
+
+        changes = record.attachment_changes[attribute.to_s]
+        return true if changes.blank?
+
+        files = Array.wrap(changes.is_a?(ActiveStorage::Attached::Changes::CreateMany) ? changes.attachables : changes.attachable)
+
+        files.each do |file|
+          add_error(record, attribute, :image_not_processable) unless Metadata.new(file).valid?
+        end
+      end
+    else
+      # Rails 5
+      def validate_each(record, attribute, _value)
+        return true unless record.send(attribute).attached?
+
+        files = Array.wrap(record.send(attribute))
+
+        files.each do |file|
+          add_error(record, attribute, :image_not_processable) unless Metadata.new(file).valid?
+        end
+      end
+    end
+
+    private
+
+    def add_error(record, attribute, default_message)
+      message = options[:message].presence || default_message
+      return if record.errors.added?(attribute, message)
+      record.errors.add(attribute, message)
+    end
+  end
+end

data/lib/active_storage_validations/size_validator.rb

@@ -2,14 +2,15 @@
 
 module ActiveStorageValidations
   class SizeValidator < ActiveModel::EachValidator # :nodoc:
+    include OptionProcUnfolding
+
     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 check_validity!
       return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-
-      raise ArgumentError, 'You must pass either :less_than, :greater_than, or :between to the validator'
+      raise ArgumentError, 'You must pass either :less_than(_or_equal_to), :greater_than(_or_equal_to), or :between to the validator'
     end
 
     def validate_each(record, attribute, _value)
@@ -20,28 +21,40 @@ module ActiveStorageValidations
 
       errors_options = {}
       errors_options[:message] = options[:message] if options[:message].present?
+      flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
 
       files.each do |file|
-        next if content_size_valid?(file.blob.byte_size)
+        next if content_size_valid?(file.blob.byte_size, flat_options)
 
         errors_options[:file_size] = number_to_human_size(file.blob.byte_size)
+        errors_options[:min_size] = number_to_human_size(min_size(flat_options))
+        errors_options[:max_size] = number_to_human_size(max_size(flat_options))
+
         record.errors.add(attribute, :file_size_out_of_range, **errors_options)
         break
       end
     end
 
-    def content_size_valid?(file_size)
-      if options[:between].present?
-        options[:between].include?(file_size)
-      elsif options[:less_than].present?
-        file_size < options[:less_than]
-      elsif options[:less_than_or_equal_to].present?
-        file_size <= options[:less_than_or_equal_to]
-      elsif options[:greater_than].present?
-        file_size > options[:greater_than]
-      elsif options[:greater_than_or_equal_to].present?
-        file_size >= options[:greater_than_or_equal_to]
+    def content_size_valid?(file_size, flat_options)
+      if flat_options[:between].present?
+        flat_options[:between].include?(file_size)
+      elsif flat_options[:less_than].present?
+        file_size < flat_options[:less_than]
+      elsif flat_options[:less_than_or_equal_to].present?
+        file_size <= flat_options[:less_than_or_equal_to]
+      elsif flat_options[:greater_than].present?
+        file_size > flat_options[:greater_than]
+      elsif flat_options[:greater_than_or_equal_to].present?
+        file_size >= flat_options[:greater_than_or_equal_to]
       end
     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/version.rb

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

data/lib/active_storage_validations.rb

@@ -2,12 +2,14 @@
 
 require 'active_storage_validations/railtie'
 require 'active_storage_validations/engine'
+require 'active_storage_validations/option_proc_unfolding'
 require 'active_storage_validations/attached_validator'
 require 'active_storage_validations/content_type_validator'
 require 'active_storage_validations/size_validator'
 require 'active_storage_validations/limit_validator'
 require 'active_storage_validations/dimension_validator'
 require 'active_storage_validations/aspect_ratio_validator'
+require 'active_storage_validations/processable_image_validator'
 
 ActiveSupport.on_load(:active_record) do
   send :include, ActiveStorageValidations

metadata

@@ -1,17 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: active_storage_validations
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 1.0.3
 platform: ruby
 authors:
 - Igor Kasyanchuk
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-26 00:00:00.000000000 Z
+date: 2022-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: activestorage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.9.5
+- !ruby/object:Gem::Dependency
+  name: ruby-vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +150,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: marcel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: globalid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Validations for Active Storage (presence)
 email:
 - igorkasyanchuk@gmail.com
@@ -117,6 +201,7 @@ files:
 - config/locales/tr.yml
 - config/locales/uk.yml
 - config/locales/vi.yml
+- config/locales/zh-CN.yml
 - lib/active_storage_validations.rb
 - lib/active_storage_validations/aspect_ratio_validator.rb
 - lib/active_storage_validations/attached_validator.rb
@@ -130,6 +215,8 @@ files:
 - lib/active_storage_validations/matchers/dimension_validator_matcher.rb
 - lib/active_storage_validations/matchers/size_validator_matcher.rb
 - lib/active_storage_validations/metadata.rb
+- lib/active_storage_validations/option_proc_unfolding.rb
+- lib/active_storage_validations/processable_image_validator.rb
 - lib/active_storage_validations/railtie.rb
 - lib/active_storage_validations/size_validator.rb
 - lib/active_storage_validations/version.rb
@@ -138,7 +225,7 @@ homepage: https://github.com/igorkasyanchuk/active_storage_validations
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -153,8 +240,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Validations for Active Storage
 test_files: []