active_storage_validations 1.1.2 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 288f21f798861bd7e44ad225052620bfcfd2d58efe73f0aeda8f4964ace98f56
-  data.tar.gz: b19cce430aae6c1eed3c2d29cbafa6d07b36423f122157603d4391a892267d64
+  metadata.gz: 305a698168303d4889b8ba6b3972201842af8679758f6f9c81140658a0abdc8a
+  data.tar.gz: 414b60017f2da20463daa783e56028c927c2090a80e7728877f569323ec0b60a
 SHA512:
-  metadata.gz: e7d6e8ac601a1bd25c2c4f4a199782e7b8dd5821ce99a2bcf14a60c0d8dd2f5e55c46d1eeae758438f8e9da34ae2f9366bf4690345dde242af897cf405dc1624
-  data.tar.gz: a4335b501b1298517053f45ec6f1192d053cd73fd682bc19127f5891aa7704e2116659991e29c3d2c4bd6ff9acf0847b91389b6bbfafb52d2c45a941dbb9dd35
+  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,21 +376,21 @@ end
 
 To run tests in root folder of gem:
 
-* `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_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
 
 Snippet to run in console:
 
-```
-BUNDLE_GEMFILE=gemfiles/rails_6_0.gemfile bundle
-BUNDLE_GEMFILE=gemfiles/rails_6_1.gemfile bundle
+```bash
+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_0.gemfile bundle exec rake test
-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
 ```
 
@@ -453,6 +479,7 @@ You are welcome to contribute.
 - https://github.com/Fonsan
 - https://github.com/tagliala
 - https://github.com/ocarreterom
+- https://github.com/aditya-cherukuri
 
 
 ## License

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