active_storage_validations 1.0.4 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe9e0494c1bf81d0f0a00c649abce9de1ff9c0dc8782a6a39253bdf1a890361d
-  data.tar.gz: '0690ff0b6a259b35d074b8c81bad13ac4c699dbb1a3caca2b5b0b2b3d8b143ce'
+  metadata.gz: 3b512ecda0ff1fa0f06649f78b7b4f58433ca7f108abd729ce08cd0eea2b1baf
+  data.tar.gz: 1ef72d050d31ed0d4052672370849c5d66538df5b06e5a477ebc3575fc110e40
 SHA512:
-  metadata.gz: 040ea6fc5660f163ba936b0b384eb515bad557f8d489bc75560e745b03011e97bc699c13e220f48f2e617b72abb70163f86cb7bdeb68522da48acb3508642679
-  data.tar.gz: e014d61d14631626179784ce0f7e31a65264103264d0b39666c720e135e6b34b68a64f374157174a0f974644cfdb8b22deeeee365c2d29d6ccb7394e290edab0
+  metadata.gz: dc0392b8725f2a567df3f99b61c5053ab0870e877ba16f3085871842a70ca7f5db328b63b3275912017831d4ed29697a66106cdad4e7cfbb779a1985b7d20488
+  data.tar.gz: 8a6883ac4f1cbf0e703c41d1e8ddf6136397fb3973997cc37c83aef3f0456ab5278b5475518ce3ddb8a776a41c8e8f7774160850ddcb49b5ece6e9c846cab8db

data/README.md

@@ -149,7 +149,11 @@ en:
   errors:
     messages:
       content_type_invalid: "has an invalid content type"
-      file_size_out_of_range: "size %{file_size} is not between required range"
+      file_size_not_less_than: "file size must be less than %{max_size} (current size is %{file_size})"
+      file_size_not_less_than_or_equal_to: "file size must be less than or equal to %{max_size} (current size is %{file_size})"
+      file_size_not_greater_than: "file size must be greater than %{min_size} (current size is %{file_size})"
+      file_size_not_greater_than_or_equal_to: "file size must be greater than or equal to %{min_size} (current size is %{file_size})"
+      file_size_not_between: "file size must be between %{min_size} and %{max_size} (current size is %{file_size})"
       limit_out_of_range: "total number is out of range"
       image_metadata_missing: "is not a valid image"
       dimension_min_inclusion: "must be greater than or equal to %{width} x %{height} pixel."
@@ -172,17 +176,21 @@ en:
 
 In some cases, Active Storage Validations provides variables to help you customize messages:
 
-The "content_type_invalid" key has two variables that you can use, a variable named "content_type" containing the content type of the send file and a variable named "authorized_types" containing the list of authorized content types.
-
-The variables are not used by default to leave the choice to the user.
+### Content type
+The `content_type_invalid` key has two variables that you can use:
+- `content_type` containing the content type of the sent file
+- `authorized_types` containing the list of authorized content types
 
 For example :
 
 ```yml
-content_type_invalid: "has an invalid content type : %{content_type}"
+content_type_invalid: "has an invalid content type : %{content_type}, authorized types are %{authorized_types}"
 ```
 
-Also the "limit_out_of_range" key supports two variables the "min" and "max".
+### 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 :
 
@@ -190,6 +198,28 @@ For example :
 limit_out_of_range: "total number is out of range. range: [%{min}, %{max}]"
 ```
 
+### File size
+The keys starting with `file_size_not_` support three variables that you can use:
+- `file_size` containing the current file size
+- `min` containing the minimum file size
+- `max` containing the maxmimum file size
+
+For example :
+
+```yml
+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
+
+For example :
+
+```yml
+aspect_ratio_is_not: "must be a %{aspect_ratio} image"
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -240,9 +270,11 @@ Example (Note that the options are chainable):
 ```ruby
 describe User do
   it { is_expected.to validate_attached_of(:avatar) }
+  it { is_expected.to validate_attached_of(:avatar).with_message('must not be blank') }
 
   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") }
 
   it { is_expected.to validate_dimensions_of(:avatar).width(250) }
   it { is_expected.to validate_dimensions_of(:avatar).height(200) }
@@ -257,6 +289,7 @@ describe User do
   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
@@ -282,9 +315,11 @@ 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)
@@ -299,6 +334,7 @@ class UserTest < ActiveSupport::TestCase
   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
@@ -308,7 +344,6 @@ end
 
 * verify with remote storages (s3, etc)
 * verify how it works with direct upload
-* better error message when content_size is invalid
 * add more translations
 
 ## Tests & Contributing
@@ -346,8 +381,12 @@ BUNDLE_GEMFILE=gemfiles/rails_next.gemfile bundle exec rake test
 This is a Rails issue, and is fixed in Rails 6.
 
 ## Contributing
+
 You are welcome to contribute.
 
+[<img src="https://opensource-heroes.com/svg/embed/igorkasyanchuk/active_storage_validations"
+/>](https://opensource-heroes.com/r/igorkasyanchuk/active_storage_validations)
+
 ## Contributors (BIG THANK YOU)
 - https://github.com/schweigert
 - https://github.com/tleneveu
@@ -403,6 +442,11 @@ You are welcome to contribute.
 - https://github.com/sobrinho
 - https://github.com/iainbeeston
 - https://github.com/marckohlbrugge
+- https://github.com/Mth0158
+- https://github.com/technicalpickles
+- https://github.com/ricsdeol
+- https://github.com/Fonsan
+
 
 ## License
 

data/config/locales/de.yml

@@ -2,7 +2,11 @@ de:
   errors:
     messages:
       content_type_invalid: "hat einen ungültigen Dateityp"
-      file_size_out_of_range: "Dateigröße %{file_size} liegt nicht im erlaubten Bereich"
+      file_size_not_less_than: "Dateigröße muss kleiner als %{max_size} sein (aktuelle Dateigröße ist %{file_size})"
+      file_size_not_less_than_or_equal_to: "Dateigröße muss kleiner oder gleich %{max_size} sein (aktuelle Dateigröße ist %{file_size})"
+      file_size_not_greater_than: "Dateigröße muss größer als %{min_size} sein (aktuelle Dateigröße ist %{file_size})"
+      file_size_not_greater_than_or_equal_to: "Dateigröße muss größer oder gleich %{min_size} sein (aktuelle Dateigröße ist %{file_size})"
+      file_size_not_between: "Dateigröße muss zwischen %{min_size} und %{max_size} liegen (aktuelle Dateigröße ist %{file_size})"
       limit_out_of_range: "Anzahl ist außerhalb des gültigen Bereichs"
       image_metadata_missing: "ist kein gültiges Bild"
       dimension_min_inclusion: "muss größer oder gleich %{width} x %{height} Pixel sein"

data/config/locales/en.yml

@@ -2,7 +2,11 @@ en:
   errors:
     messages:
       content_type_invalid: "has an invalid content type"
-      file_size_out_of_range: "size %{file_size} is not between required range"
+      file_size_not_less_than: "file size must be less than %{max_size} (current size is %{file_size})"
+      file_size_not_less_than_or_equal_to: "file size must be less than or equal to %{max_size} (current size is %{file_size})"
+      file_size_not_greater_than: "file size must be greater than %{min_size} (current size is %{file_size})"
+      file_size_not_greater_than_or_equal_to: "file size must be greater than or equal to %{min_size} (current size is %{file_size})"
+      file_size_not_between: "file size must be between %{min_size} and %{max_size} (current size is %{file_size})"
       limit_out_of_range: "total number is out of range"
       image_metadata_missing: "is not a valid image"
       dimension_min_inclusion: "must be greater than or equal to %{width} x %{height} pixel"

data/config/locales/es.yml

@@ -2,7 +2,11 @@ es:
   errors:
     messages:
       content_type_invalid: "tiene un tipo de contenido inválido"
-      file_size_out_of_range: "tamaño %{file_size} no está entre el rango requerido"
+      file_size_not_less_than: "el tamaño del archivo debe ser inferior a %{max_size} (el tamaño actual es %{file_size})"
+      file_size_not_less_than_or_equal_to: "el tamaño del archivo debe ser menor o igual a %{max_size} (el tamaño actual es %{file_size})"
+      file_size_not_greater_than: "el tamaño del archivo debe ser mayor que %{min_size} (el tamaño actual es %{file_size})"
+      file_size_not_greater_than_or_equal_to: "el tamaño del archivo debe ser mayor o igual a %{min_size} (el tamaño actual es %{file_size})"
+      file_size_not_between: "el tamaño del archivo debe estar entre %{min_size} y %{max_size} (el tamaño actual es %{file_size})"
       limit_out_of_range: "el número total está fuera de rango"
       image_metadata_missing: "no es una imagen válida"
       dimension_min_inclusion: "debe ser mayor o igual a %{width} x %{height} pixel"

data/config/locales/fr.yml

@@ -2,7 +2,11 @@ fr:
   errors:
     messages:
       content_type_invalid: "a un type de contenu non valide"
-      file_size_out_of_range: "la taille %{file_size} n'est pas comprise dans la plage permise"
+      file_size_not_less_than: "la taille du fichier doit être inférieure à %{max_size} (la taille actuelle est %{file_size})"
+      file_size_not_less_than_or_equal_to: "la taille du fichier doit être inférieure ou égale à %{max_size} (la taille actuelle est %{file_size})"
+      file_size_not_greater_than: "la taille du fichier doit être supérieure à %{min_size} (la taille actuelle est %{file_size})"
+      file_size_not_greater_than_or_equal_to: "la taille du fichier doit être supérieure ou égale à %{min_size} (la taille actuelle est %{file_size})"
+      file_size_not_between: "la taille du fichier doit être comprise entre %{min_size} et %{max_size} (la taille actuelle est %{file_size})"
       limit_out_of_range: "le nombre total est hors limites"
       image_metadata_missing: "n'est pas une image valide"
       dimension_min_inclusion: "doit être supérieur ou égal à %{width} x %{height} pixels"

data/config/locales/it.yml

@@ -2,7 +2,11 @@ it:
   errors:
     messages:
       content_type_invalid: "ha un tipo di contenuto non valido"
-      file_size_out_of_range: "la dimensione del file %{file_size} non è compresa nell’intervallo consentito"
+      file_size_not_less_than: "la dimensione del file deve essere inferiore a %{max_size} (la dimensione attuale è %{file_size})"
+      file_size_not_less_than_or_equal_to: "la dimensione del file deve essere minore o uguale a %{max_size} (la dimensione attuale è %{file_size})"
+      file_size_not_greater_than: "la dimensione del file deve essere maggiore di %{min_size} (la dimensione attuale è %{file_size})"
+      file_size_not_greater_than_or_equal_to: "la dimensione del file deve essere maggiore o uguale a %{min_size} (la dimensione attuale è %{file_size})"
+      file_size_not_between: "la dimensione del file deve essere compresa tra %{min_size} e %{max_size} (la dimensione attuale è %{file_size})"
       limit_out_of_range: "il valore è al di fuori dell’intervallo consentito"
       image_metadata_missing: "non è un'immagine valida"
       dimension_min_inclusion: "deve essere maggiore o uguale a %{width} x %{height} pixel"

data/config/locales/ja.yml

@@ -2,7 +2,11 @@ ja:
   errors:
     messages:
       content_type_invalid: "のContent Typeが不正です"
-      file_size_out_of_range: "の容量 %{file_size} が許容範囲外です"
+      file_size_not_less_than: "ファイル サイズは %{max_size} 未満にする必要があります (現在のサイズは %{file_size})"
+      file_size_not_less_than_or_equal_to: "ファイル サイズは %{max_size} 以下である必要があります (現在のサイズは %{file_size})"
+      file_size_not_greater_than: "ファイル サイズは %{min_size} より大きい必要があります (現在のサイズは %{file_size} です)"
+      file_size_not_greater_than_or_equal_to: "ファイル サイズは %{min_size} 以上である必要があります (現在のサイズは %{file_size})"
+      file_size_not_between: "ファイル サイズは %{min_size} から %{max_size} の間でなければなりません (現在のサイズは %{file_size} です)"
       limit_out_of_range: "の数が許容範囲外です"
       image_metadata_missing: "は不正な画像です"
       dimension_min_inclusion: "は %{width} x %{height} ピクセル以上の大きさにしてください"

data/config/locales/nl.yml

@@ -2,7 +2,11 @@ nl:
   errors:
     messages:
       content_type_invalid: "heeft een ongeldig inhoudstype"
-      file_size_out_of_range: "bestandsgrootte %{file_size} valt niet tussen het vereiste bereik"
+      file_size_not_less_than: "bestandsgrootte moet kleiner zijn dan %{max_size} (huidige grootte is %{file_size})"
+      file_size_not_less_than_or_equal_to: "bestandsgrootte moet kleiner zijn dan of gelijk zijn aan %{max_size} (huidige grootte is %{file_size})"
+      file_size_not_greater_than: "bestandsgrootte moet groter zijn dan %{min_size} (huidige grootte is %{file_size})"
+      file_size_not_greater_than_or_equal_to: "bestandsgrootte moet groter zijn dan of gelijk zijn aan %{min_size} (huidige grootte is %{file_size})"
+      file_size_not_between: "bestandsgrootte moet tussen %{min_size} en %{max_size} liggen (huidige grootte is %{file_size})"
       limit_out_of_range: "totaal aantal valt buiten het vereiste bereik"
       image_metadata_missing: "is geen geldige afbeelding"
       dimension_min_inclusion: "moet groter of gelijk zijn aan %{width} x %{height} pixels"

data/config/locales/pl.yml

@@ -2,7 +2,11 @@ pl:
   errors:
     messages:
       content_type_invalid: "jest nieprawidłowego typu"
-      file_size_out_of_range: "rozmiar %{file_size} nie zawiera się w dopuszczalnym zakresie"
+      file_size_not_less_than: "rozmiar pliku musi być mniejszy niż %{max_size} (obecny rozmiar to %{file_size})"
+      file_size_not_less_than_or_equal_to: "rozmiar pliku musi być mniejszy lub równy %{max_size} (obecny rozmiar to %{file_size})"
+      file_size_not_greater_than: "rozmiar pliku musi być większy niż %{min_size} (obecny rozmiar to %{file_size})"
+      file_size_not_greater_than_or_equal_to: "rozmiar pliku musi być większy lub równy %{min_size} (obecny rozmiar to %{file_size})"
+      file_size_not_between: "rozmiar pliku musi mieścić się w przedziale od %{min_size} do %{max_size} (obecny rozmiar to %{file_size})"
       limit_out_of_range: "ilość przekracza dopuszczalny zakres"
       image_metadata_missing: "nie jest prawidłowym obrazem"
       dimension_min_inclusion: "musi być równe lub większe od %{width} x %{height} pixeli"

data/config/locales/pt-BR.yml

@@ -2,7 +2,11 @@ pt-BR:
   errors:
     messages:
       content_type_invalid: "tem um tipo de arquivo inválido"
-      file_size_out_of_range: "tem tamanho %{file_size} e está fora da faixa de tamanho válida"
+      file_size_not_less_than: "o tamanho do arquivo deve ser menor que %{max_size} (o tamanho atual é %{file_size})"
+      file_size_not_less_than_or_equal_to: "o tamanho do arquivo deve ser menor ou igual a %{max_size} (o tamanho atual é %{file_size})"
+      file_size_not_greater_than: "o tamanho do arquivo deve ser maior que %{min_size} (o tamanho atual é %{file_size})"
+      file_size_not_greater_than_or_equal_to: "o tamanho do arquivo deve ser maior ou igual a %{min_size} (o tamanho atual é %{file_size})"
+      file_size_not_between: "o tamanho do arquivo deve estar entre %{min_size} e %{max_size} (o tamanho atual é %{file_size})"
       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} pixels"
@@ -20,3 +24,4 @@ pt-BR:
       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"
+      image_not_processable: "não é uma imagem válida"

data/config/locales/ru.yml

@@ -2,7 +2,11 @@ ru:
   errors:
     messages:
       content_type_invalid: "имеет недопустимый тип содержимого"
-      file_size_out_of_range: "размер %{file_size} больше требуемого"
+      file_size_not_less_than: "размер файла должен быть меньше %{max_size} (текущий размер %{file_size})"
+      file_size_not_less_than_or_equal_to: "размер файла должен быть меньше или равен %{max_size} (текущий размер %{file_size})"
+      file_size_not_greater_than: "размер файла должен быть больше %{min_size} (текущий размер %{file_size})"
+      file_size_not_greater_than_or_equal_to: "размер файла должен быть больше или равен %{min_size} (текущий размер %{file_size})"
+      file_size_not_between: "размер файла должен быть между %{min_size} и %{max_size} (текущий размер %{file_size})"
       limit_out_of_range: "количество файлов больше требуемого"
       image_metadata_missing: "не является допустимым изображением"
       dimension_min_inclusion: "должен быть больше или равно %{width} x %{height} пикселям"

data/config/locales/sv.yml

@@ -0,0 +1,23 @@
+sv:
+  errors:
+    messages:
+      content_type_invalid: "Har en ogiltig filtyp"
+      file_size_out_of_range: "storleken %{file_size} är utanför det krävda intervallet"
+      limit_out_of_range: "antalet filer är utanför det godkända intervallet"
+      image_metadata_missing: "bilden sankar metadata"
+      dimension_min_inclusion: "måste minst vara %{width} x %{height} pixlar"
+      dimension_max_inclusion: "måste vara mindre eller lika med %{width} x %{height} pixlar"
+      dimension_width_inclusion: "bredden är utanför %{min} till %{max} pixlar"
+      dimension_height_inclusion: "höjden är utanför %{min} till %{max} pixlar"
+      dimension_width_greater_than_or_equal_to: "bredden måste minst vara %{length} pixlar"
+      dimension_height_greater_than_or_equal_to: "höjden måste minst vara %{length} pixlar"
+      dimension_width_less_than_or_equal_to: "bredden får max vara %{length} pixlar"
+      dimension_height_less_than_or_equal_to: "höjden får max vara %{length} pixlar"
+      dimension_width_equal_to: "bredden måste vara %{length} pixlar"
+      dimension_height_equal_to: "höjden måste vara %{length} pixlar"
+      aspect_ratio_not_square: "måste vara en kvadratisk bild"
+      aspect_ratio_not_portrait: "måste vara en porträttorienterad bild"
+      aspect_ratio_not_landscape: "måste vara en landskapsorienterad bild"
+      aspect_ratio_is_not: "måste ha en följande aspect ratio  %{aspect_ratio}"
+      aspect_ratio_unknown: "har en okänd aspect ratio"
+      image_not_processable: "är inte en giltig bild"

data/config/locales/tr.yml

@@ -2,7 +2,11 @@ tr:
   errors:
     messages:
       content_type_invalid: "geçersiz dosya tipine sahip"
-      file_size_out_of_range: "dosya boyutu %{file_size} gerekli aralık dışında"
+      file_size_not_less_than: "dosya boyutu %{max_size} boyutundan küçük olmalıdır (geçerli boyut %{file_size}'dir)"
+      file_size_not_less_than_or_equal_to: "dosya boyutu %{max_size} değerinden küçük veya ona eşit olmalıdır (geçerli boyut %{file_size}'dir)"
+      file_size_not_greater_than: "dosya boyutu %{min_size} boyutundan büyük olmalıdır (geçerli boyut %{file_size}'dir)"
+      file_size_not_greater_than_or_equal_to: "dosya boyutu %{min_size} değerinden büyük veya eşit olmalıdır (geçerli boyut %{file_size}'dir)"
+      file_size_not_between: "dosya boyutu %{min_size} ile %{max_size} arasında olmalıdır (geçerli boyut %{file_size}'dir)"
       limit_out_of_range: "toplam miktar aralık dışında"
       image_metadata_missing: "geçerli bir imaj değil"
       dimension_min_inclusion: "%{width} x %{height} piksele eşit ya da büyük olmalı"

data/config/locales/uk.yml

@@ -2,7 +2,11 @@ uk:
   errors:
     messages:
       content_type_invalid: "має неприпустимий тип вмісту"
-      file_size_out_of_range: "розмір %{file_size} більше необхідного"
+      file_size_not_less_than: "розмір файлу має бути менше %{max_size} (поточний розмір %{file_size})"
+      file_size_not_less_than_or_equal_to: "розмір файлу має бути меншим або дорівнювати %{max_size} (поточний розмір %{file_size})"
+      file_size_not_greater_than: "розмір файлу має бути більшим ніж %{min_size} (поточний розмір %{file_size})"
+      file_size_not_greater_than_or_equal_to: "розмір файлу має бути більшим або дорівнювати %{min_size} (поточний розмір %{file_size})"
+      file_size_not_between: "розмір файлу має бути від %{min_size} до %{max_size} (поточний розмір %{file_size})"
       limit_out_of_range: "кількість файлів більше необхідного"
       image_metadata_missing: "не є допустимим зображенням"
       dimension_min_inclusion: "мусить бути більше або дорівнювати %{width} x %{height} пікселям"

data/config/locales/vi.yml

@@ -2,7 +2,11 @@ vi:
   errors:
     messages:
       content_type_invalid: "tệp không hợp lệ"
-      file_size_out_of_range: "kích thước %{file_size} vượt giới hạn"
+      file_size_not_less_than: "kích thước tệp phải nhỏ hơn %{max_size} (kích thước hiện tại là %{file_size})"
+      file_size_not_less_than_or_equal_to: "kích thước tệp phải nhỏ hơn hoặc bằng %{max_size} (kích thước hiện tại là %{file_size})"
+      file_size_not_greater_than: "kích thước tệp phải lớn hơn %{min_size} (kích thước hiện tại là %{file_size})"
+      file_size_not_greater_than_or_equal_to: "kích thước tệp phải lớn hơn hoặc bằng %{min_size} (kích thước hiện tại là %{file_size})"
+      file_size_not_between: "kích thước tệp phải nằm trong khoảng từ %{min_size} đến %{max_size} (kích thước hiện tại là %{file_size})"
       limit_out_of_range: "tổng số tệp vượt giới hạn"
       image_metadata_missing: "không phải là ảnh"
       dimension_min_inclusion: "phải lớn hơn hoặc bằng %{width} x %{height} pixel"

data/config/locales/zh-CN.yml

@@ -2,7 +2,11 @@ zh-CN:
   errors:
     messages:
       content_type_invalid: "文件类型错误"
-      file_size_out_of_range: "文件大小 %{file_size} 超出限定范围"
+      file_size_not_less_than: "文件大小必须小于 %{max_size}（当前大小为 %{file_size})"
+      file_size_not_less_than_or_equal_to: "文件大小必须小于或等于 %{max_size}（当前大小为 %{file_size})"
+      file_size_not_greater_than: "文件大小必须大于 %{min_size}（当前大小为 %{file_size})"
+      file_size_not_greater_than_or_equal_to: "文件大小必须大于或等于 %{min_size}（当前大小为 %{file_size})"
+      file_size_not_between: "文件大小必须介于 %{min_size} 和 %{max_size} 之间（当前大小为 %{file_size})"
       limit_out_of_range: "文件数超出限定范围"
       image_metadata_missing: "不是有效的图像"
       dimension_min_inclusion: "必须大于或等于 %{width} x %{height} 像素"

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -5,13 +5,15 @@ require_relative 'metadata.rb'
 module ActiveStorageValidations
   class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
     include OptionProcUnfolding
+    include ErrorHandler
 
     AVAILABLE_CHECKS = %i[with].freeze
     PRECISION = 3
 
     def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass :with to the validator'
+      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass :with to the validator'
+      end
     end
 
     if Rails.gem_version >= Gem::Version.new('6.0.0')
@@ -53,23 +55,30 @@ module ActiveStorageValidations
 
     def is_valid?(record, attribute, metadata)
       flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
+      errors_options = initialize_error_options(options)
+
       if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
-        add_error(record, attribute, :image_metadata_missing, flat_options[:with])
+        errors_options[:aspect_ratio] = flat_options[:with]
+
+        add_error(record, attribute, :image_metadata_missing, **errors_options)
         return false
       end
 
       case flat_options[:with]
       when :square
         return true if metadata[:width] == metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_square, flat_options[:with])
+        errors_options[:aspect_ratio] = flat_options[:with]
+        add_error(record, attribute, :aspect_ratio_not_square, **errors_options)
 
       when :portrait
         return true if metadata[:height] > metadata[:width]
-        add_error(record, attribute, :aspect_ratio_not_portrait, flat_options[:with])
+        errors_options[:aspect_ratio] = flat_options[:with]
+        add_error(record, attribute, :aspect_ratio_not_portrait, **errors_options)
 
       when :landscape
         return true if metadata[:width] > metadata[:height]
-        add_error(record, attribute, :aspect_ratio_not_landscape, flat_options[:with])
+        errors_options[:aspect_ratio] = flat_options[:with]
+        add_error(record, attribute, :aspect_ratio_not_landscape, **errors_options)
 
       else
         if flat_options[:with] =~ /is_(\d*)_(\d*)/
@@ -78,20 +87,14 @@ module ActiveStorageValidations
 
           return true if (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
 
-          add_error(record, attribute, :aspect_ratio_is_not, "#{x}x#{y}")
+          errors_options[:aspect_ratio] = "#{x}x#{y}"
+          add_error(record, attribute, :aspect_ratio_is_not, **errors_options)
         else
-          add_error(record, attribute, :aspect_ratio_unknown, flat_options[:with])
+          errors_options[:aspect_ratio] = flat_options[:with]
+          add_error(record, attribute, :aspect_ratio_unknown, **errors_options)
         end
       end
       false
     end
-
-
-    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
 end

data/lib/active_storage_validations/attached_validator.rb

@@ -2,13 +2,14 @@
 
 module ActiveStorageValidations
   class AttachedValidator < ActiveModel::EachValidator # :nodoc:
+    include ErrorHandler
+
     def validate_each(record, attribute, _value)
       return if record.send(attribute).attached?
 
-      errors_options = {}
-      errors_options[:message] = options[:message] if options[:message].present?
+      errors_options = initialize_error_options(options)
 
-      record.errors.add(attribute, :blank, **errors_options)
+      add_error(record, attribute, :blank, **errors_options)
     end
   end
 end

data/lib/active_storage_validations/content_type_validator.rb

@@ -3,6 +3,7 @@
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
     include OptionProcUnfolding
+    include ErrorHandler
 
     AVAILABLE_CHECKS = %i[with in].freeze
     
@@ -14,14 +15,14 @@ module ActiveStorageValidations
       
       files = Array.wrap(record.send(attribute))
 
-      errors_options = { authorized_types: types_to_human_format(types) }
-      errors_options[:message] = options[:message] if options[:message].present?
+      errors_options = initialize_error_options(options)
+      errors_options[:authorized_types] = types_to_human_format(types)
 
       files.each do |file|
         next if is_valid?(file, types)
 
         errors_options[:content_type] = content_type(file)
-        record.errors.add(attribute, :content_type_invalid, **errors_options)
+        add_error(record, attribute, :content_type_invalid, **errors_options)
         break
       end
     end

data/lib/active_storage_validations/dimension_validator.rb

@@ -5,6 +5,7 @@ require_relative 'metadata.rb'
 module ActiveStorageValidations
   class DimensionValidator < ActiveModel::EachValidator # :nodoc
     include OptionProcUnfolding
+    include ErrorHandler
 
     AVAILABLE_CHECKS = %i[width height min max].freeze
 
@@ -32,8 +33,9 @@ module ActiveStorageValidations
 
 
     def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
+      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
+      end
     end
 
 
@@ -70,9 +72,11 @@ module ActiveStorageValidations
 
     def is_valid?(record, attribute, file_metadata)
       flat_options = process_options(record)
+      errors_options = initialize_error_options(options)
+
       # 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, :image_metadata_missing)
+        add_error(record, attribute, :image_metadata_missing, **errors_options)
         return false
       end
 
@@ -82,39 +86,58 @@ module ActiveStorageValidations
           (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, :dimension_min_inclusion, width: flat_options[:width][:min], height: flat_options[:height][:min])
+          errors_options[:width] = flat_options[:width][:min]
+          errors_options[:height] = flat_options[:height][:min]
+
+          add_error(record, attribute, :dimension_min_inclusion, **errors_options)
           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])
           )
-          add_error(record, attribute, :dimension_max_inclusion, width: flat_options[:width][:max], height: flat_options[:height][:max])
+          errors_options[:width] = flat_options[:width][:max]
+          errors_options[:height] = flat_options[:height][:max]
+
+          add_error(record, attribute, :dimension_max_inclusion, **errors_options)
           return false
         end
 
       # Validation based on checks :width and :height.
       else
         width_or_height_invalid = false
+
         [: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])
-              add_error(record, attribute, :"dimension_#{length}_inclusion", min: flat_options[length][:min], max: flat_options[length][:max])
+              error_type = :"dimension_#{length}_inclusion"
+              errors_options[:min] = flat_options[length][:min]
+              errors_options[:max] = flat_options[length][:max]
+
+              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]
-                add_error(record, attribute, :"dimension_#{length}_greater_than_or_equal_to", 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
-              end
-              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])
+              elsif flat_options[length][:max] && file_metadata[length] > flat_options[length][:max]
+                error_type = :"dimension_#{length}_less_than_or_equal_to"
+                errors_options[:length] = flat_options[length][:max]
+
+                add_error(record, attribute, error_type, **errors_options)
                 width_or_height_invalid = true
               end
             end
           else
             if file_metadata[length] != flat_options[length]
-              add_error(record, attribute, :"dimension_#{length}_equal_to", length: flat_options[length])
+              error_type = :"dimension_#{length}_equal_to"
+              errors_options[:length] = flat_options[length]
+
+              add_error(record, attribute, error_type, **errors_options)
               width_or_height_invalid = true
             end
           end
@@ -125,12 +148,5 @@ module ActiveStorageValidations
 
       true # valid file
     end
-
-    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
 end

data/lib/active_storage_validations/error_handler.rb

@@ -0,0 +1,18 @@
+module ActiveStorageValidations
+  module ErrorHandler
+
+    def initialize_error_options(options)
+      {
+        message: (options[:message] if options[:message].present?)
+      }
+    end
+
+    def add_error(record, attribute, default_message, **errors_options)
+      message = errors_options[:message].presence || default_message
+      return if record.errors.added?(attribute, message)
+
+      record.errors.add(attribute, message, **errors_options)
+    end
+
+  end
+end

data/lib/active_storage_validations/limit_validator.rb

@@ -3,21 +3,25 @@
 module ActiveStorageValidations
   class LimitValidator < ActiveModel::EachValidator # :nodoc:
     include OptionProcUnfolding
+    include ErrorHandler
 
     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'
+      unless AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :max or :min to the validator'
+      end
     end
 
     def validate_each(record, attribute, _)
       files = Array.wrap(record.send(attribute)).compact.uniq
       flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
-      errors_options = { min: flat_options[:min], max: flat_options[:max] }
+      errors_options = initialize_error_options(options)
+      errors_options[:min] = flat_options[:min]
+      errors_options[:max] = flat_options[:max]
 
       return true if files_count_valid?(files.count, flat_options)
-      record.errors.add(attribute, options[:message].presence || :limit_out_of_range, **errors_options)
+      add_error(record, attribute, :limit_out_of_range, **errors_options)
     end
 
     def files_count_valid?(count, flat_options)

data/lib/active_storage_validations/matchers/attached_validator_matcher.rb

@@ -9,12 +9,18 @@ module ActiveStorageValidations
     class AttachedValidatorMatcher
       def initialize(attribute_name)
         @attribute_name = attribute_name
+        @custom_message = nil
       end
 
       def description
         "validate #{@attribute_name} must be attached"
       end
 
+      def with_message(message)
+        @custom_message = message
+        self
+      end
+
       def matches?(subject)
         @subject = subject.is_a?(Class) ? subject.new : subject
         responds_to_methods && valid_when_attached && invalid_when_not_attached
@@ -39,7 +45,7 @@ module ActiveStorageValidations
       def valid_when_attached
         @subject.public_send(@attribute_name).attach(attachable) unless @subject.public_send(@attribute_name).attached?
         @subject.validate
-        @subject.errors.details[@attribute_name].exclude?(error: :blank)
+        @subject.errors.details[@attribute_name].exclude?(error: error_message)
       end
 
       def invalid_when_not_attached
@@ -48,7 +54,11 @@ module ActiveStorageValidations
         @subject.public_send("#{@attribute_name}=", nil)
 
         @subject.validate
-        @subject.errors.details[@attribute_name].include?(error: :blank)
+        @subject.errors.details[@attribute_name].include?(error: error_message)
+      end
+
+      def error_message
+        @custom_message || :blank
       end
 
       def attachable

data/lib/active_storage_validations/matchers/content_type_validator_matcher.rb

@@ -11,6 +11,7 @@ module ActiveStorageValidations
     class ContentTypeValidatorMatcher
       def initialize(attribute_name)
         @attribute_name = attribute_name
+        @custom_message = nil
       end
 
       def description
@@ -27,9 +28,14 @@ module ActiveStorageValidations
         self
       end
 
+      def with_message(message)
+        @custom_message = message
+        self
+      end
+
       def matches?(subject)
         @subject = subject.is_a?(Class) ? subject.new : subject
-        responds_to_methods && allowed_types_allowed? && rejected_types_rejected?
+        responds_to_methods && allowed_types_allowed? && rejected_types_rejected? && validate_custom_message?
       end
 
       def failure_message
@@ -77,7 +83,23 @@ module ActiveStorageValidations
       def type_allowed?(type)
         @subject.public_send(@attribute_name).attach(attachment_for(type))
         @subject.validate
-        @subject.errors.details[@attribute_name].all? { |error| error[:error] != :content_type_invalid }
+        @subject.errors.details[@attribute_name].none? do |error|
+          error[:error].to_s.include?(error_message)
+        end
+      end
+
+      def validate_custom_message?
+        return true unless @custom_message
+
+        @subject.public_send(@attribute_name).attach(attachment_for('fake/fake'))
+        @subject.validate
+        @subject.errors.details[@attribute_name].select{|error| error[:content_type]}.all? do |error|
+          error[:error].to_s.include?(error_message)
+        end
+      end
+
+      def error_message
+        @custom_message || :content_type_invalid.to_s
       end
 
       def attachment_for(type)

data/lib/active_storage_validations/matchers/size_validator_matcher.rb

@@ -11,7 +11,8 @@ module ActiveStorageValidations
     class SizeValidatorMatcher
       def initialize(attribute_name)
         @attribute_name = attribute_name
-        @low = @high = nil
+        @min = @max = nil
+        @custom_message = nil
       end
 
       def description
@@ -19,41 +20,46 @@ module ActiveStorageValidations
       end
 
       def less_than(size)
-        @high = size - 1.byte
+        @max = size - 1.byte
         self
       end
 
       def less_than_or_equal_to(size)
-        @high = size
+        @max = size
         self
       end
 
       def greater_than(size)
-        @low = size + 1.byte
+        @min = size + 1.byte
         self
       end
 
       def greater_than_or_equal_to(size)
-        @low = size
+        @min = size
         self
       end
 
       def between(range)
-        @low, @high = range.first, range.last
+        @min, @max = range.first, range.last
+        self
+      end
+
+      def with_message(message)
+        @custom_message = message
         self
       end
 
       def matches?(subject)
         @subject = subject.is_a?(Class) ? subject.new : subject
-        responds_to_methods && lower_than_low? && higher_than_low? && lower_than_high? && higher_than_high?
+        responds_to_methods && not_lower_than_min? && higher_than_min? && lower_than_max? && not_higher_than_max?
       end
 
       def failure_message
-        "is expected to validate file size of #{@attribute_name} to be between #{@low} and #{@high} bytes"
+        "is expected to validate file size of #{@attribute_name} to be between #{@min} and #{@max} bytes"
       end
 
       def failure_message_when_negated
-        "is expected to not validate file size of #{@attribute_name} to be between #{@low} and #{@high} bytes"
+        "is expected to not validate file size of #{@attribute_name} to be between #{@min} and #{@max} bytes"
       end
 
       protected
@@ -64,20 +70,20 @@ module ActiveStorageValidations
           @subject.public_send(@attribute_name).respond_to?(:detach)
       end
 
-      def lower_than_low?
-        @low.nil? || !passes_validation_with_size(@low - 1)
+      def not_lower_than_min?
+        @min.nil? || !passes_validation_with_size(@min - 1)
       end
 
-      def higher_than_low?
-        @low.nil? || passes_validation_with_size(@low + 1)
+      def higher_than_min?
+        @min.nil? || passes_validation_with_size(@min + 1)
       end
 
-      def lower_than_high?
-        @high.nil? || @high == Float::INFINITY || passes_validation_with_size(@high - 1)
+      def lower_than_max?
+        @max.nil? || @max == Float::INFINITY || passes_validation_with_size(@max - 1)
       end
 
-      def higher_than_high?
-        @high.nil? || @high == Float::INFINITY || !passes_validation_with_size(@high + 1)
+      def not_higher_than_max?
+        @max.nil? || @max == Float::INFINITY || !passes_validation_with_size(@max + 1)
       end
 
       def passes_validation_with_size(new_size)
@@ -85,7 +91,10 @@ module ActiveStorageValidations
         Matchers.stub_method(io, :size, new_size) do
           @subject.public_send(@attribute_name).attach(io: io, filename: 'test.png', content_type: 'image/pg')
           @subject.validate
-          @subject.errors.details[@attribute_name].all? { |error| error[:error] != :file_size_out_of_range }
+          exclude_error_message = @custom_message || "file_size_not_"
+          @subject.errors.details[@attribute_name].none? do |error|
+            error[:error].to_s.include?(exclude_error_message)
+          end
         end
       end
     end

data/lib/active_storage_validations/processable_image_validator.rb

@@ -5,18 +5,21 @@ require_relative 'metadata.rb'
 module ActiveStorageValidations
   class ProcessableImageValidator < ActiveModel::EachValidator # :nodoc
     include OptionProcUnfolding
+    include ErrorHandler
 
     if Rails.gem_version >= Gem::Version.new('6.0.0')
       def validate_each(record, attribute, _value)
         return true unless record.send(attribute).attached?
 
+        errors_options = initialize_error_options(options)
+
         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?
+          add_error(record, attribute, :image_not_processable, **errors_options) unless Metadata.new(file).valid?
         end
       end
     else
@@ -27,17 +30,9 @@ module ActiveStorageValidations
         files = Array.wrap(record.send(attribute))
 
         files.each do |file|
-          add_error(record, attribute, :image_not_processable) unless Metadata.new(file).valid?
+          add_error(record, attribute, :image_not_processable, **errors_options) 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

@@ -3,14 +3,16 @@
 module ActiveStorageValidations
   class SizeValidator < ActiveModel::EachValidator # :nodoc:
     include OptionProcUnfolding
+    include ErrorHandler
 
     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(_or_equal_to), :greater_than(_or_equal_to), or :between to the validator'
+      unless AVAILABLE_CHECKS.one? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :less_than(_or_equal_to), :greater_than(_or_equal_to), or :between to the validator'
+      end
     end
 
     def validate_each(record, attribute, _value)
@@ -19,8 +21,8 @@ module ActiveStorageValidations
 
       files = Array.wrap(record.send(attribute))
 
-      errors_options = {}
-      errors_options[:message] = options[:message] if options[:message].present?
+      errors_options = initialize_error_options(options)
+
       flat_options = unfold_procs(record, self.options, AVAILABLE_CHECKS)
 
       files.each do |file|
@@ -29,8 +31,9 @@ module ActiveStorageValidations
         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))
+        error_type = "file_size_not_#{flat_options.keys.first}".to_sym
 
-        record.errors.add(attribute, :file_size_out_of_range, **errors_options)
+        add_error(record, attribute, error_type, **errors_options)
         break
       end
     end

data/lib/active_storage_validations/version.rb

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

data/lib/active_storage_validations.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'active_model'
+
 require 'active_storage_validations/railtie'
 require 'active_storage_validations/engine'
 require 'active_storage_validations/option_proc_unfolding'
+require 'active_storage_validations/error_handler'
 require 'active_storage_validations/attached_validator'
 require 'active_storage_validations/content_type_validator'
 require 'active_storage_validations/size_validator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_storage_validations
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.1
 platform: ruby
 authors:
 - Igor Kasyanchuk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-10 00:00:00.000000000 Z
+date: 2023-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -212,6 +212,7 @@ files:
 - config/locales/pl.yml
 - config/locales/pt-BR.yml
 - config/locales/ru.yml
+- config/locales/sv.yml
 - config/locales/tr.yml
 - config/locales/uk.yml
 - config/locales/vi.yml
@@ -222,6 +223,7 @@ files:
 - lib/active_storage_validations/content_type_validator.rb
 - lib/active_storage_validations/dimension_validator.rb
 - lib/active_storage_validations/engine.rb
+- lib/active_storage_validations/error_handler.rb
 - lib/active_storage_validations/limit_validator.rb
 - lib/active_storage_validations/matchers.rb
 - lib/active_storage_validations/matchers/attached_validator_matcher.rb
@@ -254,7 +256,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Validations for Active Storage