file_validators 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9d77f05c14b168f172952bf2e4418b22e7d716c
-  data.tar.gz: 6686bd542bacb69ff3a0db1e7304b8b2ab4d55a4
+  metadata.gz: e8e04639d14acd35e4d98938b786d372f5218bdd
+  data.tar.gz: b045b75d86de521365bece751da3b3c24ea890c8
 SHA512:
-  metadata.gz: d5f7393b1bc42819e548ed6f0cbc0633ab66ea5a87451c0ab60c8d50dc2b2036615a88f3548653603010d6661318017869c03d6b472a6338fc470e2e81acc5fc
-  data.tar.gz: d602cf19ecae5107bb10148bc7d105118e7c5610f5a099658870c63cb6ecbab4c115e26bc552400499284cecc393ce320fe62c49d1e9b7b723c260594bfbe5dc
+  metadata.gz: a57497456ee76a9f96f1d74e3e5599e43d8d9e68ab120c0bd6b8fe6945a643cc04acb7b97c50ec65f33b34c1352a346bf6564f0c695b67940e10a459b2f5be19
+  data.tar.gz: 4fd2174b5f6a7dae46f0f6ada517f4cb918279286918425948c845dd67d0a744f4e6086eb68ee4b2add6da9849c3a0d2033efa8559e664cdc11c828161dbe9c4

data/README.md

@@ -47,40 +47,26 @@ end
 
 ### File Size Validator:
 
-* `in`: A range of bytes
+* `in`: A range of bytes or a proc that returns a range
 ```ruby
 validates :avatar, file_size: { in: 100.kilobytes..1.megabyte }
 ```
-* `less_than_or_equal_to`: Less than or equal to a number in bytes
-```ruby
-validates :avatar, file_size: { less_than_or_equal_to: 50.bytes } 
-```
-* `greater_than_or_equal_to`: Greater than or equal to a number in bytes
-```ruby
-validates :avatar, file_size: { greater_than_or_equal_to: 50.bytes } 
-```
-* `less_than`: Less than a number in bytes
+* `less_than`: Less than a number in bytes or a proc that returns a number
 ```ruby
 validates :avatar, file_size: { less_than: 2.gigabytes }
 ```
-* `greater_than`: greater than a number in bytes
+* `less_than_or_equal_to`: Less than or equal to a number in bytes or a proc that returns a number
 ```ruby
-validates :avatar, file_size: { greater_than: 1.byte } 
-```
-You can also combine these options.
-```ruby
-validates :avatar, file_size: { less_than: 1.megabyte,
-                                greater_than_or_equal_to: 20.kilobytes }
+validates :avatar, file_size: { less_than_or_equal_to: 50.bytes } 
 ```
-The following two examples are equivalent:
+* `greater_than`: greater than a number in bytes or a proc that returns a number
 ```ruby
-validates :avatar, file_size: { greater_than_or_equal_to: 500.kilobytes,
-                                less_than_or_equal_to: 3.megabytes }
+validates :avatar, file_size: { greater_than: 1.byte } 
 ```
+* `greater_than_or_equal_to`: Greater than or equal to a number in bytes or a proc that returns a number
 ```ruby
-validates :avatar, file_size: { in: 500.kilobytes..3.megabytes }
+validates :avatar, file_size: { greater_than_or_equal_to: 50.bytes } 
 ```
-If you use `:in`, then the other options will be neglected.
 * `message`: Error message to display. With all the options above except `:in`, you will get `count` as a replacement. 
 With `:in` you will get `min` and `max` as replacements. 
 `count`, `min` and `max` each will have its value and unit together.
@@ -96,55 +82,53 @@ validates :document, file_size: { in: 1.kilobyte..1.megabyte,
 * `if`: A lambda or name of an instance method. Validation will only be run if this lambda or method returns true.
 * `unless`: Same as `if` but validates if lambda or method returns false.
 
-### File Content Type Validator
-
-* `allow`: Allowed content types.  Can be a single content type or an array.  Each type can be a String or a Regexp. Allows all by default.
+You can combine different options.
 ```ruby
-# string
-validates :avatar, file_content_type: { allow: 'image/jpeg' }
-```
-```ruby
-# array of strings
-validates :attachment, file_content_type: { allow: ['image/jpeg', 'image/png', 'text/plain'] }
+validates :avatar, file_size: { less_than: 1.megabyte,
+                                greater_than_or_equal_to: 20.kilobytes }
 ```
+The following two examples are equivalent:
 ```ruby
-# regexp
-validates :avatar, file_content_type: { allow: /^image\/.*/ }
+validates :avatar, file_size: { greater_than_or_equal_to: 500.kilobytes,
+                                less_than_or_equal_to: 3.megabytes }
 ```
 ```ruby
-# array of regexps
-validates :attachment, file_content_type: { allow: [/^image\/.*/, /^text\/.*/] }
+validates :avatar, file_size: { in: 500.kilobytes..3.megabytes }
 ```
+Options can also take `Proc`/`lambda`:
+
 ```ruby
-# array of regexps and strings
-validates :attachment, file_content_type: { allow: [/^image\/.*/, 'video/mp4'] }
+validates :avatar, file_size: { less_than: lambda { |record| record.size_in_bytes } }
 ```
-* `exclude`: Forbidden content types. Can be a single content type or an array.  Each type can be a String or a Regexp.
+
+### File Content Type Validator
+
+* `allow`: Allowed content types.  Can be a single content type or an array.  Each type can be a String or a Regexp. It also accepts proc. Allows all by default.
 ```ruby
 # string
-validates :avatar, file_content_type: { exclude: 'image/jpeg' }
+validates :avatar, file_content_type: { allow: 'image/jpeg' }
 ```
 ```ruby
 # array of strings
-validates :attachment, file_content_type: { exclude: ['image/jpeg', 'text/plain'] }
+validates :attachment, file_content_type: { allow: ['image/jpeg', 'image/png', 'text/plain'] }
 ```
 ```ruby
 # regexp
-validates :avatar, file_content_type: { exclude: /^image\/.*/ }
+validates :avatar, file_content_type: { allow: /^image\/.*/ }
 ```
 ```ruby
 # array of regexps
-validates :attachment, file_content_type: { exclude: [/^image\/.*/, /^text\/.*/] }
+validates :attachment, file_content_type: { allow: [/^image\/.*/, /^text\/.*/] }
 ```
 ```ruby
 # array of regexps and strings
-validates :attachment, file_content_type: { exclude: [/^text\/.*/, 'image/gif'] }
+validates :attachment, file_content_type: { allow: [/^image\/.*/, 'video/mp4'] }
 ```
-You can also combine `:allow` and `:exclude`:
 ```ruby
-# this will allow all the image types except gif
-validates :avatar, file_content_type: { allow: /^image\/.*/, exclude: 'image/gif' }
+# proc/lambda example
+validates :video, file_content_type: { allow: lambda { |record| record.content_types } }
 ```
+* `exclude`: Forbidden content types. Can be a single content type or an array.  Each type can be a String or a Regexp. It also accepts `proc`. See `:allow` options examples.
 * `message`: The message to display when the uploaded file has an invalid content type.
 You will get `types` as a replacement. You can write error messages without using any replacement.
 ```ruby
@@ -158,16 +142,35 @@ validates :avatar, file_content_type: { allow: ['image/jpeg', 'image/gif'],
 * `if`: A lambda or name of an instance method. Validation will only be run is this lambda or method returns true.
 * `unless`: Same as `if` but validates if lambda or method returns false.
 
+You can combine `:allow` and `:exclude`:
+```ruby
+# this will allow all the image types except png and gif
+validates :avatar, file_content_type: { allow: /^image\/.*/, exclude: ['image/png', 'image/gif'] }
+```
+
 ## i18n Translations
 
-By default, `FileSizeValidator` will use the error messages of `:less_than`, `:greater_than_or_equal_to` etc from `errors.messages` of your locale. `errors.messages` translation is available under ActiveModel's locale.
+File Size Errors
+* `file_size_is_in`: takes `min` and `max` as replacements
+* `file_size_is_less_than`: takes `count` as replacement
+* `file_size_is_less_than_or_equal_to`: takes `count` as replacement
+* `file_size_is_greater_than`: takes `count` as replacement
+* `file_size_is_greater_than_or_equal_to`: takes `count` as replacement
+
+Content Type Errors
+* `allowed_file_content_types`: generated when you have specified allowed types but the content type
+of the file doesn't match. takes `types` as replacement.
+* `excluded_file_content_types`: generated when you have specified excluded types and the content type
+of the file matches anyone of them. takes `types` as replacement.
 
-For `:in`, `:allow` and `:exclude` you will have to write your own error messages under `errors.messages`.  
+This gem provides `en` translations for this errors under `errors.messages` namespace.
+If you want to override and/or create other locales, you can
+check [this](https://github.com/musaffa/file_validators/blob/master/lib/file_validators/locale/en.yml) out to see how translations are done.  
 
 You can override all of them with the `:message` option.
 
 For unit format, it will use `number.human.storage_units.format` from your locale.
-For unit translation, it will use `number.human.storage_units`.
+For unit translation, `number.human.storage_units` is used.
 Rails applications already have these translations either in ActiveSupport's locale (Rails 4) or in ActionView's locale (Rails 3).
 In case your setup doesn't have the translations, here's an example for `en`:
 

data/lib/file_validators.rb

@@ -1,3 +1,6 @@
 require 'active_model'
 require 'file_validators/validators/file_size_validator'
 require 'file_validators/validators/file_content_type_validator'
+
+locale_path = Dir.glob(File.dirname(__FILE__) + '/file_validators/locale/*.yml')
+I18n.load_path += locale_path unless I18n.load_path.include?(locale_path)

data/lib/file_validators/locale/en.yml

@@ -0,0 +1,12 @@
+en:
+  errors:
+    messages:
+      file_size_is_in: ! 'file size must be between %{min} and %{max}'
+      file_size_is_less_than: ! 'file size must be less than %{count}'
+      file_size_is_less_than_or_equal_to: ! 'file size must be less than or equal to %{count}'
+      file_size_is_greater_than: ! 'file size must be greater than %{count}'
+      file_size_is_greater_than_or_equal_to: ! 'file size must be greater than or equal to %{count}'
+
+      allowed_file_content_types: ! 'file should be one of %{types}'
+      excluded_file_content_types: ! 'file cannot be %{types}'
+

data/lib/file_validators/validators/file_content_type_validator.rb

@@ -1,10 +1,8 @@
 module ActiveModel
   module Validations
 
-    class FileContentTypeValidator < ActiveModel::EachValidator
-      def initialize(options)
-        super
-      end
+    class FileContentTypeValidator < EachValidator
+      CHECKS = [:allow, :exclude].freeze
 
       def self.helper_method_name
         :validates_file_content_type
@@ -18,34 +16,36 @@ module ActiveModel
         end
       end
 
-      def validate_whitelist(record, attribute, value)
-        if allowed_types.present? && allowed_types.none? { |type| type === value }
-          mark_invalid record, attribute, allowed_types
+      def check_validity!
+        unless (CHECKS & options.keys).present?
+          raise ArgumentError, 'You must at least pass in :allow or :exclude option'
         end
-      end
 
-      def validate_blacklist(record, attribute, value)
-        if forbidden_types.present? && forbidden_types.any? { |type| type === value }
-          mark_invalid record, attribute, forbidden_types
+        options.slice(*CHECKS).each do |option, value|
+          unless value.is_a?(String) || value.is_a?(Array) || value.is_a?(Regexp) || value.is_a?(Proc)
+            raise ArgumentError, ":#{option} must be a string, an array, a regex or a proc"
+          end
         end
       end
 
-      def mark_invalid(record, attribute, types)
-        record.errors.add attribute, :invalid, options.merge(:types => types.join(', '))
-      end
+      private
 
-      def allowed_types
-        [options[:allow]].flatten.compact
+      def validate_whitelist(record, attribute, value)
+        allowed_types = [options_call(record, :allow)].flatten.compact
+        if allowed_types.present? && allowed_types.none? { |type| type === value }
+          record.errors.add attribute, :allowed_file_content_types, options.merge(:types => allowed_types.join(', '))
+        end
       end
 
-      def forbidden_types
-        [options[:exclude]].flatten.compact
+      def validate_blacklist(record, attribute, value)
+        forbidden_types = [options_call(record, :exclude)].flatten.compact
+        if forbidden_types.present? && forbidden_types.any? { |type| type === value }
+          record.errors.add attribute, :excluded_file_content_types, options.merge(:types => forbidden_types.join(', '))
+        end
       end
 
-      def check_validity!
-        unless options.has_key?(:allow) || options.has_key?(:exclude)
-          raise ArgumentError, 'You must pass in either :allow or :exclude to the validator'
-        end
+      def options_call(record, key)
+        options[key].is_a?(Proc) ? options[key].call(record) : options[key]
       end
     end
 

data/lib/file_validators/validators/file_size_validator.rb

@@ -1,13 +1,12 @@
 module ActiveModel
   module Validations
 
-    class FileSizeValidator < ActiveModel::Validations::NumericalityValidator
-      AVAILABLE_CHECKS = [:less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to].freeze
-
-      def initialize(options)
-        extract_options(options)
-        super
-      end
+    class FileSizeValidator < EachValidator
+      CHECKS = { in: :===,
+                 less_than: :<,
+                 less_than_or_equal_to: :<=,
+                 greater_than: :>,
+                 greater_than_or_equal_to: :>= }.freeze
 
       def self.helper_method_name
         :validates_file_size
@@ -15,44 +14,51 @@ module ActiveModel
 
       def validate_each(record, attribute, value)
         unless value.blank?
-          options.slice(*AVAILABLE_CHECKS).each do |option, option_value|
-            unless value.size.send(CHECKS[option], option_value)
-              error_message_key = options[:in] ? :in : option
-              record.errors.add(attribute, error_message_key, filtered_options(value).merge!(detect_error_options(option, option_value)))
+          options.slice(*CHECKS.keys).each do |option, option_value|
+            option_value = option_value.call(record) if option_value.is_a?(Proc)
+            unless valid_size?(value.size, option, option_value)
+              record.errors.add(attribute,
+                                "file_size_is_#{option}".to_sym,
+                                filtered_options(value).merge!(detect_error_options(option_value)))
             end
           end
         end
       end
 
       def check_validity!
-        unless (AVAILABLE_CHECKS + [:in]).any? { |argument| options.has_key?(argument) }
-          raise ArgumentError, 'List of allowed options - [:in, :less_than, :greater_than, :less_than_or_equal_to, :greater_than_or_equal_to]'
+        unless (CHECKS.keys & options.keys).present?
+          raise ArgumentError, 'You must at least pass in one of these options - :in, :less_than,
+                                :less_than_or_equal_to, :greater_than and :greater_than_or_equal_to'
+        end
+
+        options.slice(*CHECKS.keys).each do |option, value|
+          unless value.is_a?(Numeric) || value.is_a?(Range) || value.is_a?(Proc)
+            raise ArgumentError, ":#{option} must be a number, a range or a proc"
+          end
         end
       end
 
       private
 
-      def extract_options(options)
-        if range = options[:in]
-          raise ArgumentError, ':in must be a Range' unless range.is_a?(Range)
-          clear_options(options)
-          options[:less_than_or_equal_to], options[:greater_than_or_equal_to] = range.max, range.min
+      def valid_size?(size, option, option_value)
+        if option_value.is_a?(Range)
+          option_value.send(CHECKS[option], size)
+        else
+          size.send(CHECKS[option], option_value)
         end
       end
 
-      def clear_options(options)
-        AVAILABLE_CHECKS.each do |option|
-          options.delete(option)
-        end
+      def filtered_options(value)
+        filtered = options.except(*CHECKS.keys)
+        filtered[:value] = value
+        filtered
       end
 
-      def detect_error_options(option, option_value)
-        if options[:in]
-          max = options[:less_than_or_equal_to]
-          min =  options[:greater_than_or_equal_to]
-          error_options = { min: human_size(min), max: human_size(max)  }
+      def detect_error_options(option_value)
+        if option_value.is_a?(Range)
+          { min: human_size(option_value.min), max: human_size(option_value.max)  }
         else
-          error_options = { count: human_size(option_value) }
+          { count: human_size(option_value) }
         end
       end
 

data/lib/file_validators/version.rb

@@ -1,3 +1,3 @@
 module FileValidators
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/spec/integration/file_content_type_validation_integration_spec.rb

@@ -91,6 +91,34 @@ describe 'File Content Type integration with ActiveModel' do
         it { is_expected.not_to be_valid }
       end
     end
+
+    context 'as a proc' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { allow: lambda { |record| ['image/jpeg', 'text/plain'] } }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with allowed types' do
+        it 'validates jpeg' do
+          subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
+          expect(subject).to be_valid
+        end
+
+        it 'validates text file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain')
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'with a disallowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png') }
+        it { is_expected.not_to be_valid }
+      end
+    end
   end
 
   context ':exclude option' do
@@ -170,6 +198,29 @@ describe 'File Content Type integration with ActiveModel' do
         end
       end
     end
+
+    context 'as a proc' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { exclude: lambda { |record| /^image\/.*/ } }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with an allowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain') }
+        it { is_expected.to be_valid }
+      end
+
+      context 'with a disallowed types' do
+        it 'invalidates jpeg image file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
+          expect(subject).not_to be_valid
+        end
+      end
+    end
   end
 
   context ':allow and :exclude combined' do

data/spec/integration/file_size_validator_integration_spec.rb

@@ -14,55 +14,112 @@ describe 'File Size Validator integration with ActiveModel' do
   end
 
   context ':in option' do
-    before :all do
-      Person.class_eval do
-        Person.reset_callbacks(:validate)
-        validates :avatar, file_size: { in: 20.kilobytes..40.kilobytes }
+    context 'as a range' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_size: { in: 20.kilobytes..40.kilobytes }
+        end
       end
-    end
 
-    subject { Person.new }
+      subject { Person.new }
 
-    context 'when file size is out of range' do
-      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
-      it { is_expected.not_to be_valid }
-    end
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+        it { is_expected.not_to be_valid }
+      end
 
-    context 'when file size is out of range' do
-      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
-      it { is_expected.not_to be_valid }
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
+        it { is_expected.not_to be_valid }
+      end
+
+      context 'when file size within range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+        it { is_expected.to be_valid }
+      end
     end
 
-    context 'when file size within range' do
-      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
-      it { is_expected.to be_valid }
+    context 'as a proc' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_size: { in: lambda { |record| 20.kilobytes..40.kilobytes } }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+        it { is_expected.not_to be_valid }
+      end
+
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
+        it { is_expected.not_to be_valid }
+      end
+
+      context 'when file size within range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+        it { is_expected.to be_valid }
+      end
     end
   end
 
   context ':greater_than and :less_than option' do
-    before :all do
-      Person.class_eval do
-        Person.reset_callbacks(:validate)
-        validates :avatar, file_size: { greater_than: 20.kilobytes,
-                                        less_than:    40.kilobytes }
+    context 'as numbers' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_size: { greater_than: 20.kilobytes,
+                                          less_than:    40.kilobytes }
+        end
       end
-    end
 
-    subject { Person.new }
+      subject { Person.new }
 
-    context 'when file size is out of range' do
-      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
-      it { is_expected.not_to be_valid }
-    end
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+        it { is_expected.not_to be_valid }
+      end
 
-    context 'when file size is out of range' do
-      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
-      it { is_expected.not_to be_valid }
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
+        it { is_expected.not_to be_valid }
+      end
+
+      context 'when file size within range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+        it { is_expected.to be_valid }
+      end
     end
 
-    context 'when file size within range' do
-      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
-      it { is_expected.to be_valid }
+    context 'as procs' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_size: { greater_than: lambda { |record| 20.kilobytes },
+                                          less_than:    lambda { |record| 40.kilobytes } }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+        it { is_expected.not_to be_valid }
+      end
+
+      context 'when file size is out of range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
+        it { is_expected.not_to be_valid }
+      end
+
+      context 'when file size within range' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+        it { is_expected.to be_valid }
+      end
     end
   end
 

data/spec/lib/file_validators/validators/file_content_type_validator_spec.rb

@@ -28,6 +28,11 @@ describe ActiveModel::Validations::FileContentTypeValidator do
         before { build_validator allow: ['image/png', 'image/jpg', 'image/jpeg'] }
         it { is_expected.to allow_file_content_type('image/png', @validator) }
       end
+
+      context 'as a proc' do
+        before { build_validator allow: lambda { |record| ['image/png', 'image/jpg', 'image/jpeg'] } }
+        it { is_expected.to allow_file_content_type('image/png', @validator) }
+      end
     end
   
     context 'with a disallowed type' do
@@ -40,6 +45,11 @@ describe ActiveModel::Validations::FileContentTypeValidator do
         before { build_validator allow: /^text\/.*/ }
         it { is_expected.not_to allow_file_content_type('image/png', @validator) }
       end
+
+      context 'as a proc' do
+        before { build_validator allow: lambda { |record| /^text\/.*/ } }
+        it { is_expected.not_to allow_file_content_type('image/png', @validator) }
+      end
   
       context 'with :message option' do
         context 'without interpolation' do
@@ -55,6 +65,11 @@ describe ActiveModel::Validations::FileContentTypeValidator do
                                                           message: 'Avatar should have content type image/png') }
         end
       end
+
+      context 'default message' do
+        before { build_validator allow: 'image/png' }
+        it { is_expected.not_to allow_file_content_type('image/jpeg', @validator, message: 'Avatar file should be one of image/png') }
+      end
     end
   end
 
@@ -74,6 +89,11 @@ describe ActiveModel::Validations::FileContentTypeValidator do
         before { build_validator exclude: ['image/png', 'image/jpg', 'image/jpeg'] }
         it { is_expected.to allow_file_content_type('image/gif', @validator) }
       end
+
+      context 'as a proc' do
+        before { build_validator exclude: lambda { |record| ['image/png', 'image/jpg', 'image/jpeg'] } }
+        it { is_expected.to allow_file_content_type('image/gif', @validator) }
+      end
     end
   
     context 'with a disallowed type' do
@@ -86,6 +106,11 @@ describe ActiveModel::Validations::FileContentTypeValidator do
         before { build_validator exclude: /^text\/.*/ }
         it { is_expected.not_to allow_file_content_type('text/plain', @validator) }
       end
+
+      context 'as an proc' do
+        before { build_validator exclude: lambda { |record| /^text\/.*/ } }
+        it { is_expected.not_to allow_file_content_type('text/plain', @validator) }
+      end
   
       context 'with :message option' do
         context 'without interpolation' do
@@ -101,6 +126,11 @@ describe ActiveModel::Validations::FileContentTypeValidator do
                                                       message: 'Avatar should not have content type image/jpeg') }
         end
       end
+
+      context 'default message' do
+        before { build_validator exclude: 'image/png' }
+        it { is_expected.not_to allow_file_content_type('image/png', @validator, message: 'Avatar file cannot be image/png') }
+      end
     end
   end
 

data/spec/lib/file_validators/validators/file_size_validator_spec.rb

@@ -25,49 +25,108 @@ describe ActiveModel::Validations::FileSizeValidator do
   end
 
   context 'with :in option' do
-    before { build_validator in: (5.kilobytes..10.kilobytes) }
+    context 'as a range' do
+      before { build_validator in: (5.kilobytes..10.kilobytes) }
 
-    it { is_expected.to allow_file_size(7.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(4.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(7.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(4.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+    end
+
+    context 'as a proc' do
+      before { build_validator in: lambda { |record| (5.kilobytes..10.kilobytes) } }
+
+      it { is_expected.to allow_file_size(7.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(4.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+    end
   end
 
   context 'with :greater_than_or_equal_to option' do
-    before { build_validator greater_than_or_equal_to: 10.kilobytes }
+    context 'as a number' do
+      before { build_validator greater_than_or_equal_to: 10.kilobytes }
 
-    it { is_expected.to allow_file_size(11.kilobytes, @validator) }
-    it { is_expected.to allow_file_size(10.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(9.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(11.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(10.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(9.kilobytes, @validator) }
+    end
+
+    context 'as a proc' do
+      before { build_validator greater_than_or_equal_to: lambda { |record| 10.kilobytes } }
+
+      it { is_expected.to allow_file_size(11.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(10.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(9.kilobytes, @validator) }
+    end
   end
 
   context 'with :less_than_or_equal_to option' do
-    before { build_validator less_than_or_equal_to: 10.kilobytes }
+    context 'as a number' do
+      before { build_validator less_than_or_equal_to: 10.kilobytes }
 
-    it { is_expected.to allow_file_size(9.kilobytes, @validator) }
-    it { is_expected.to allow_file_size(10.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(9.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(10.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+    end
+
+    context 'as a proc' do
+      before { build_validator less_than_or_equal_to: lambda { |record| 10.kilobytes } }
+
+      it { is_expected.to allow_file_size(9.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(10.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+    end
   end
 
   context 'with :greater_than option' do
-    before { build_validator greater_than: 10.kilobytes }
+    context 'as a number' do
+      before { build_validator greater_than: 10.kilobytes }
+
+      it { is_expected.to allow_file_size(11.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+    end
+
+    context 'as a proc' do
+      before { build_validator greater_than: lambda { |record| 10.kilobytes } }
 
-    it { is_expected.to allow_file_size(11.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(11.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+    end
   end
 
   context 'with :less_than option' do
-    before { build_validator less_than: 10.kilobytes }
+    context 'as a number' do
+      before { build_validator less_than: 10.kilobytes }
+
+      it { is_expected.to allow_file_size(9.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+    end
+
+    context 'as a proc' do
+      before { build_validator less_than: lambda { |record| 10.kilobytes } }
 
-    it { is_expected.to allow_file_size(9.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+      it { is_expected.to allow_file_size(9.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+    end
   end
 
   context 'with :greater_than and :less_than option' do
-    before { build_validator greater_than: 5.kilobytes, less_than: 10.kilobytes }
+    context 'as a number' do
+      before { build_validator greater_than: 5.kilobytes, less_than: 10.kilobytes }
+
+      it { is_expected.to allow_file_size(7.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(5.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+    end
 
-    it { is_expected.to allow_file_size(7.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(5.kilobytes, @validator) }
-    it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+    context 'as a proc' do
+      before { build_validator greater_than: lambda { |record| 5.kilobytes },
+                                  less_than: lambda { |record| 10.kilobytes } }
+
+      it { is_expected.to allow_file_size(7.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(5.kilobytes, @validator) }
+      it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+    end
   end
 
   context 'with :message option' do
@@ -81,6 +140,35 @@ describe ActiveModel::Validations::FileSizeValidator do
                                         message: "Avatar is invalid. (Between #{@storage_units[5120]} and #{@storage_units[10240]} please.)") }
   end
 
+  context 'default error message' do
+    context 'given :in options' do
+      before { build_validator in: 5.kilobytes..10.kilobytes }
+
+      it { is_expected.not_to allow_file_size(11.kilobytes, @validator,
+                                              message: "Avatar file size must be between #{@storage_units[5120]} and #{@storage_units[10240]}") }
+      it { is_expected.not_to allow_file_size(4.kilobytes, @validator,
+                                              message: "Avatar file size must be between #{@storage_units[5120]} and #{@storage_units[10240]}") }
+    end
+
+    context 'given :greater_than and :less_than options' do
+      before { build_validator greater_than: 5.kilobytes, less_than: 10.kilobytes }
+
+      it { is_expected.not_to allow_file_size(11.kilobytes, @validator,
+                                              message: "Avatar file size must be less than #{@storage_units[10240]}") }
+      it { is_expected.not_to allow_file_size(4.kilobytes, @validator,
+                                              message: "Avatar file size must be greater than #{@storage_units[5120]}") }
+    end
+
+    context 'given :greater_than_or_equal_to and :less_than_or_equal_to options' do
+      before { build_validator greater_than_or_equal_to: 5.kilobytes, less_than_or_equal_to: 10.kilobytes }
+
+      it { is_expected.not_to allow_file_size(11.kilobytes, @validator,
+                                              message: "Avatar file size must be less than or equal to #{@storage_units[10240]}") }
+      it { is_expected.not_to allow_file_size(4.kilobytes, @validator,
+                                              message: "Avatar file size must be greater than or equal to #{@storage_units[5120]}") }
+    end
+  end
+
 
   context 'using the helper' do
     before { Dummy.validates_file_size :avatar, in: (5.kilobytes..10.kilobytes) }
@@ -95,7 +183,7 @@ describe ActiveModel::Validations::FileSizeValidator do
       expect { build_validator message: 'Some message' }.to raise_error(ArgumentError)
     end
 
-    (ActiveModel::Validations::FileSizeValidator::AVAILABLE_CHECKS).each do |argument|
+    (ActiveModel::Validations::FileSizeValidator::CHECKS.keys).each do |argument|
       it "does not raise argument error if #{argument} was given" do
         expect { build_validator argument => 5.kilobytes }.not_to raise_error
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: file_validators
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Ahmad Musaffa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-10 00:00:00.000000000 Z
+date: 2014-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -102,6 +102,7 @@ files:
 - gemfiles/activemodel_4.0.gemfile
 - gemfiles/activemodel_4.1.gemfile
 - lib/file_validators.rb
+- lib/file_validators/locale/en.yml
 - lib/file_validators/validators/file_content_type_validator.rb
 - lib/file_validators/validators/file_size_validator.rb
 - lib/file_validators/version.rb
@@ -156,4 +157,3 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/matchers/allow_content_type.rb
 - spec/support/matchers/allow_file_size.rb
-has_rdoc: