file_validators 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9d77f05c14b168f172952bf2e4418b22e7d716c
+  data.tar.gz: 6686bd542bacb69ff3a0db1e7304b8b2ab4d55a4
+SHA512:
+  metadata.gz: d5f7393b1bc42819e548ed6f0cbc0633ab66ea5a87451c0ab60c8d50dc2b2036615a88f3548653603010d6661318017869c03d6b472a6338fc470e2e81acc5fc
+  data.tar.gz: d602cf19ecae5107bb10148bc7d105118e7c5610f5a099658870c63cb6ecbab4c115e26bc552400499284cecc393ce320fe62c49d1e9b7b723c260594bfbe5dc

data/.gitignore

@@ -0,0 +1,12 @@
+.bundle/
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache
+Gemfile.lock
+gemfiles/*.lock
+coverage/
+/.idea

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3
+gemfile:
+  - gemfiles/activemodel_4.1.gemfile
+  - gemfiles/activemodel_4.0.gemfile
+  - gemfiles/activemodel_3.2.gemfile
+  - gemfiles/activemodel_3.1.gemfile
+  - gemfiles/activemodel_3.0.gemfile

data/Appraisals

@@ -0,0 +1,19 @@
+appraise 'activemodel-3.0' do
+  gem 'activemodel', '3.0.20'
+end
+
+appraise 'activemodel-3.1' do
+  gem 'activemodel', '3.1.12'
+end
+
+appraise 'activemodel-3.2' do
+  gem 'activemodel', '3.2.18'
+end
+
+appraise 'activemodel-4.0' do
+  gem 'activemodel', '4.0.10'
+end
+
+appraise 'activemodel-4.1' do
+  gem 'activemodel', '4.1.6'
+end

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Declare your gem's dependencies in file_validators.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'
+gem 'appraisal'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,216 @@
+# File Validators
+
+[![Gem Version](http://img.shields.io/gem/v/file_validators.svg)](https://rubygems.org/gems/file_validators)
+[![Build Status](https://travis-ci.org/musaffa/file_validators.svg)](https://travis-ci.org/musaffa/file_validators)
+[![Dependency Status](http://img.shields.io/gemnasium/musaffa/file_validators.svg)](https://gemnasium.com/musaffa/file_validators)
+[![Coverage Status](http://img.shields.io/coveralls/musaffa/file_validators.svg)](https://coveralls.io/r/musaffa/file_validators)
+[![Code Climate](http://img.shields.io/codeclimate/github/musaffa/file_validators.svg)](https://codeclimate.com/github/musaffa/file_validators)
+
+File Validators gem adds file size and content type validations to ActiveModel. Any module that uses ActiveModel, for example ActiveRecord, can use these file validators.
+
+## Support
+
+* ActiveModel versions: 3 and 4.
+* Rails versions: 3 and 4.
+
+## Installation
+
+Add the following to your Gemfile:
+
+```ruby
+gem 'file_validators'
+```
+
+## Examples
+
+ActiveModel example:
+
+```ruby
+class Profile
+  include ActiveModel::Validations
+
+  attr_accessor :avatar
+  validates :avatar, file_size: { less_than_or_equal_to: 100.kilobytes },
+                     file_content_type: { allow: ['image/jpeg', 'image/png', 'image/gif'] } 
+end
+```
+ActiveRecord example:
+
+```ruby
+class Profile < ActiveRecord::Base
+  validates :avatar, file_size: { less_than_or_equal_to: 100.kilobytes },
+                     file_content_type: { allow: ['image/jpeg', 'image/png', 'image/gif'] }
+end
+```
+
+## API
+
+### File Size Validator:
+
+* `in`: A range of bytes
+```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
+```ruby
+validates :avatar, file_size: { less_than: 2.gigabytes }
+```
+* `greater_than`: greater than a number in bytes
+```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 }
+```
+The following two examples are equivalent:
+```ruby
+validates :avatar, file_size: { greater_than_or_equal_to: 500.kilobytes,
+                                less_than_or_equal_to: 3.megabytes }
+```
+```ruby
+validates :avatar, file_size: { in: 500.kilobytes..3.megabytes }
+```
+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.
+You can write error messages without using any replacement.
+```ruby
+validates :avatar, file_size: { less_than: 100.kilobytes,
+                                message: 'avatar file size should be less than %{count}' } 
+```
+```ruby
+validates :document, file_size: { in: 1.kilobyte..1.megabyte,
+                                  message: 'document should be within %{min} and %{max}' }
+```
+* `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.
+```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'] }
+```
+```ruby
+# regexp
+validates :avatar, file_content_type: { allow: /^image\/.*/ }
+```
+```ruby
+# array of regexps
+validates :attachment, file_content_type: { allow: [/^image\/.*/, /^text\/.*/] }
+```
+```ruby
+# array of regexps and strings
+validates :attachment, file_content_type: { allow: [/^image\/.*/, 'video/mp4'] }
+```
+* `exclude`: Forbidden content types. Can be a single content type or an array.  Each type can be a String or a Regexp.
+```ruby
+# string
+validates :avatar, file_content_type: { exclude: 'image/jpeg' }
+```
+```ruby
+# array of strings
+validates :attachment, file_content_type: { exclude: ['image/jpeg', 'text/plain'] }
+```
+```ruby
+# regexp
+validates :avatar, file_content_type: { exclude: /^image\/.*/ }
+```
+```ruby
+# array of regexps
+validates :attachment, file_content_type: { exclude: [/^image\/.*/, /^text\/.*/] }
+```
+```ruby
+# array of regexps and strings
+validates :attachment, file_content_type: { exclude: [/^text\/.*/, 'image/gif'] }
+```
+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' }
+```
+* `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
+validates :avatar, file_content_type: { allow: ['image/jpeg', 'image/gif'],
+                                        message: 'should have content type %{types}' }
+```
+```ruby
+validates :avatar, file_content_type: { allow: ['image/jpeg', 'image/gif'],
+                                        message: 'Avatar only allows jpeg and gif image files' }
+```
+* `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.
+
+## 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.
+
+For `:in`, `:allow` and `:exclude` you will have to write your own error messages under `errors.messages`.  
+
+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`.
+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`:
+
+```yml
+en:
+  number:
+    human:
+      storage_units:
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"
+```
+
+## Tests
+
+```ruby
+rake
+rake test:unit
+rake test:integration
+```
+
+## Problems
+
+Please use GitHub's [issue tracker](http://github.com/musaffa/file_validations/issues).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Inspirations
+
+* [PaperClip](https://github.com/thoughtbot/paperclip)
+
+## License
+
+This project rocks and uses MIT-LICENSE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= FileValidators
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,31 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rspec/core/rake_task'
+
+namespace :test do
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = ['spec/lib/**/*_spec.rb']
+  end
+
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.pattern = ['spec/integration/**/*_spec.rb']
+  end
+end
+
+task :default => ['test:unit', 'test:integration']
+
+# require 'rdoc/task'
+
+# RDoc::Task.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'FileValidators'
+#   rdoc.options << '--line-numbers'
+#   rdoc.rdoc_files.include('README.rdoc')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+
+Bundler::GemHelper.install_tasks

data/file_validators.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path('../lib', __FILE__)
+
+require 'file_validators/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'file_validators'
+  s.version     = FileValidators::VERSION
+  s.authors     = ['Ahmad Musaffa']
+  s.email       = ['musaffa_csemm@yahoo.com']
+  s.summary     = 'ActiveModel file validators'
+  s.description = 'Adds file validators to ActiveModel'
+  s.homepage    = 'https://github.com/musaffa/file_validators'
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^spec/})
+  s.require_paths  = ['lib']
+
+  s.add_dependency 'activemodel', '>= 3.0'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 3.1.0'
+  s.add_development_dependency 'coveralls'
+  s.add_development_dependency 'rack-test'
+end

data/gemfiles/activemodel_3.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "activemodel", "3.0.20"
+
+gemspec :path => "../"

data/gemfiles/activemodel_3.1.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "activemodel", "3.1.12"
+
+gemspec :path => "../"

data/gemfiles/activemodel_3.2.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "activemodel", "3.2.18"
+
+gemspec :path => "../"

data/gemfiles/activemodel_4.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "activemodel", "4.0.10"
+
+gemspec :path => "../"

data/gemfiles/activemodel_4.1.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "activemodel", "4.1.6"
+
+gemspec :path => "../"

data/lib/file_validators/validators/file_content_type_validator.rb

@@ -0,0 +1,73 @@
+module ActiveModel
+  module Validations
+
+    class FileContentTypeValidator < ActiveModel::EachValidator
+      def initialize(options)
+        super
+      end
+
+      def self.helper_method_name
+        :validates_file_content_type
+      end
+
+      def validate_each(record, attribute, value)
+        unless value.blank?
+          content_type = value.content_type
+          validate_whitelist(record, attribute, content_type)
+          validate_blacklist(record, attribute, content_type)
+        end
+      end
+
+      def validate_whitelist(record, attribute, value)
+        if allowed_types.present? && allowed_types.none? { |type| type === value }
+          mark_invalid record, attribute, allowed_types
+        end
+      end
+
+      def validate_blacklist(record, attribute, value)
+        if forbidden_types.present? && forbidden_types.any? { |type| type === value }
+          mark_invalid record, attribute, forbidden_types
+        end
+      end
+
+      def mark_invalid(record, attribute, types)
+        record.errors.add attribute, :invalid, options.merge(:types => types.join(', '))
+      end
+
+      def allowed_types
+        [options[:allow]].flatten.compact
+      end
+
+      def forbidden_types
+        [options[:exclude]].flatten.compact
+      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
+      end
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the content type of the file
+      # assigned. The possible options are:
+      # * +allow+: Allowed content types.  Can be a single content type
+      #   or an array.  Each type can be a String or a Regexp. It should be
+      #   noted that Internet Explorer uploads files with content_types that you
+      #   may not expect. For example, JPEG images are given image/pjpeg and
+      #   PNGs are image/x-png, so keep that in mind when determining how you
+      #   match.  Allows all by default.
+      # * +exclude+: Forbidden content types.
+      # * +message+: The message to display when the uploaded file has an invalid
+      #   content type.
+      # * +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.
+      def validates_file_content_type(*attr_names)
+        validates_with FileContentTypeValidator, _merge_attributes(attr_names)
+      end
+    end
+
+  end
+end

data/lib/file_validators/validators/file_size_validator.rb

@@ -0,0 +1,89 @@
+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
+
+      def self.helper_method_name
+        :validates_file_size
+      end
+
+      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)))
+            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]'
+        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
+        end
+      end
+
+      def clear_options(options)
+        AVAILABLE_CHECKS.each do |option|
+          options.delete(option)
+        end
+      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)  }
+        else
+          error_options = { count: human_size(option_value) }
+        end
+      end
+
+      def human_size(size)
+        if defined?(ActiveSupport::NumberHelper) # Rails 4.0+
+          ActiveSupport::NumberHelper.number_to_human_size(size)
+        else
+          storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+          unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => size.to_i, :raise => true)
+          storage_units_format.gsub(/%n/, size.to_i.to_s).gsub(/%u/, unit).html_safe
+        end
+      end
+
+    end
+
+    module HelperMethods
+      # Places ActiveModel validations on the size of the file assigned. The
+      # possible options are:
+      # * +in+: a Range of bytes (i.e. +1..1.megabyte+),
+      # * +less_than_or_equal_to+: equivalent to :in => 0..options[:less_than_or_equal_to]
+      # * +greater_than_or_equal_to+: equivalent to :in => options[:greater_than_or_equal_to]..Infinity
+      # * +less_than+: less than a number in bytes
+      # * +greater_than+: greater than a number in bytes
+      # * +message+: error message to display, use :min and :max as replacements
+      # * +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.
+      def validates_file_size(*attr_names)
+        validates_with FileSizeValidator, _merge_attributes(attr_names)
+      end
+    end
+
+  end
+end

data/lib/file_validators/version.rb

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

data/lib/file_validators.rb

@@ -0,0 +1,3 @@
+require 'active_model'
+require 'file_validators/validators/file_size_validator'
+require 'file_validators/validators/file_content_type_validator'

data/spec/fixtures/sample.txt

@@ -0,0 +1 @@
+a sample text