file_validators 2.3.0 → 3.0.0

data/lib/file_validators/validators/file_size_validator.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
-
     class FileSizeValidator < ActiveModel::EachValidator
       CHECKS = { in: :===,
                  less_than: :<,
@@ -13,23 +14,25 @@ module ActiveModel
       end
 
       def validate_each(record, attribute, value)
-        values = parse_values(value)
-        unless values.empty?
-          options.slice(*CHECKS.keys).each do |option, option_value|
-            option_value = option_value.call(record) if option_value.is_a?(Proc)
-            if values.any? { |v| not valid_size?(value_byte_size(v), option, option_value) }
-              record.errors.add(attribute,
-                                "file_size_is_#{option}".to_sym,
-                                filtered_options(values).merge!(detect_error_options(option_value)))
-            end
-          end
+        begin
+          values = parse_values(value)
+        rescue JSON::ParserError
+          record.errors.add attribute, :invalid
+          return
+        end
+
+        return if values.empty?
+
+        options.slice(*CHECKS.keys).each do |option, option_value|
+          check_errors(record, attribute, values, option, option_value)
         end
       end
 
       def check_validity!
         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'
+          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
 
         check_options(Numeric, options.slice(*(CHECKS.keys - [:in])))
@@ -46,7 +49,7 @@ module ActiveModel
 
         value = OpenStruct.new(value) if value.is_a?(Hash)
 
-        Array.wrap(value).reject { |value| value.blank? }
+        Array.wrap(value).reject(&:blank?)
       end
 
       def check_options(klass, options)
@@ -57,6 +60,18 @@ module ActiveModel
         end
       end
 
+      def check_errors(record, attribute, values, option, option_value)
+        option_value = option_value.call(record) if option_value.is_a?(Proc)
+        has_invalid_size = values.any? { |v| !valid_size?(value_byte_size(v), option, option_value) }
+        if has_invalid_size
+          record.errors.add(
+            attribute,
+            "file_size_is_#{option}".to_sym,
+            **filtered_options(values).merge!(detect_error_options(option_value))
+          )
+        end
+      end
+
       def value_byte_size(value)
         if value.respond_to?(:byte_size)
           value.byte_size
@@ -82,7 +97,7 @@ module ActiveModel
 
       def detect_error_options(option_value)
         if option_value.is_a?(Range)
-          { min: human_size(option_value.min), max: human_size(option_value.max)  }
+          { min: human_size(option_value.min), max: human_size(option_value.max) }
         else
           { count: human_size(option_value) }
         end
@@ -92,12 +107,22 @@ module ActiveModel
         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 = 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
@@ -116,6 +141,5 @@ module ActiveModel
         validates_with FileSizeValidator, _merge_attributes(attr_names)
       end
     end
-
   end
 end

data/lib/file_validators/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FileValidators
-  VERSION = '2.3.0'
+  VERSION = '3.0.0'
 end

data/lib/file_validators.rb

@@ -1,16 +1,15 @@
+# frozen_string_literal: true
+
 require 'active_model'
 require 'ostruct'
 
 module FileValidators
-  module Utils
-    extend ActiveSupport::Autoload
-
-    autoload :ContentTypeDetector
-    autoload :MediaTypeSpoofDetector
-  end
+  extend ActiveSupport::Autoload
+  autoload :Error
+  autoload :MimeTypeAnalyzer
 end
 
-Dir[File.dirname(__FILE__) + "/file_validators/validators/*.rb"].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/file_validators/validators/*.rb'].each { |file| require file }
 
 locale_path = Dir.glob(File.dirname(__FILE__) + '/file_validators/locale/*.yml')
 I18n.load_path += locale_path unless I18n.load_path.include?(locale_path)

data/spec/integration/combined_validators_integration_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'rack/test/uploaded_file'
 
@@ -52,7 +54,7 @@ describe 'Combined File Validators integration with ActiveModel' do
     before :all do
       Person.class_eval do
         Person.reset_callbacks(:validate)
-        validates_file_size :avatar, { less_than: 20.kilobytes }
+        validates_file_size :avatar, less_than: 20.kilobytes
         validates_file_content_type :avatar, allow: 'image/jpeg'
       end
     end

data/spec/integration/file_content_type_validation_integration_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'rack/test/uploaded_file'
 
@@ -69,7 +71,8 @@ describe 'File Content Type integration with ActiveModel' do
       before :all do
         Person.class_eval do
           Person.reset_callbacks(:validate)
-          validates :avatar, file_content_type: { allow: ['image/jpeg', 'text/plain'], mode: :strict }
+          validates :avatar, file_content_type: { allow: ['image/jpeg', 'text/plain'],
+                                                  mode: :strict }
         end
       end
 
@@ -97,7 +100,7 @@ describe 'File Content Type integration with ActiveModel' do
       before :all do
         Person.class_eval do
           Person.reset_callbacks(:validate)
-          validates :avatar, file_content_type: { allow: lambda { |record| ['image/jpeg', 'text/plain'] },
+          validates :avatar, file_content_type: { allow: ->(_record) { ['image/jpeg', 'text/plain'] },
                                                   mode: :strict }
         end
       end
@@ -177,7 +180,8 @@ describe 'File Content Type integration with ActiveModel' do
       before :all do
         Person.class_eval do
           Person.reset_callbacks(:validate)
-          validates :avatar, file_content_type: { exclude: ['image/jpeg', 'text/plain'], mode: :strict }
+          validates :avatar, file_content_type: { exclude: ['image/jpeg', 'text/plain'],
+                                                  mode: :strict }
         end
       end
 
@@ -205,7 +209,8 @@ describe 'File Content Type integration with ActiveModel' do
       before :all do
         Person.class_eval do
           Person.reset_callbacks(:validate)
-          validates :avatar, file_content_type: { exclude: lambda { |record| /^image\/.*/ }, mode: :strict }
+          validates :avatar, file_content_type: { exclude: ->(_record) { /^image\/.*/ },
+                                                  mode: :strict }
         end
       end
 
@@ -229,7 +234,8 @@ describe 'File Content Type integration with ActiveModel' do
     before :all do
       Person.class_eval do
         Person.reset_callbacks(:validate)
-        validates :avatar, file_content_type: { allow: /^image\/.*/, exclude: 'image/png', mode: :strict }
+        validates :avatar, file_content_type: { allow: /^image\/.*/, exclude: 'image/png',
+                                                mode: :strict }
       end
     end
 
@@ -246,6 +252,31 @@ describe 'File Content Type integration with ActiveModel' do
     end
   end
 
+  context ':tool option' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_content_type: { allow: 'image/jpeg', tool: :marcel }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'with valid file' do
+      it 'validates the file' do
+        subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'with spoofed file' do
+      it 'invalidates the file' do
+        subject.avatar = Rack::Test::UploadedFile.new(@spoofed_file_path, 'image/jpeg')
+        expect(subject).not_to be_valid
+      end
+    end
+  end
+
   context ':mode option' do
     context 'strict mode' do
       before :all do
@@ -334,24 +365,35 @@ describe 'File Content Type integration with ActiveModel' do
     subject { Person.new }
 
     context 'for invalid content type' do
-      before { subject.avatar = "{\"filename\":\"img140910_88338.GIF\",\"content_type\":\"image/gif\",\"size\":13150}" }
+      before do
+        subject.avatar = '{"filename":"img140910_88338.GIF","content_type":"image/gif","size":13150}'
+      end
+
       it { is_expected.not_to be_valid }
     end
 
     context 'for valid content type' do
-      before { subject.avatar = "{\"filename\":\"img140910_88338.jpg\",\"content_type\":\"image/jpeg\",\"size\":13150}" }
+      before do
+        subject.avatar = '{"filename":"img140910_88338.jpg","content_type":"image/jpeg","size":13150}'
+      end
+
       it { is_expected.to be_valid }
     end
 
     context 'empty json string' do
-      before { subject.avatar = "{}" }
+      before { subject.avatar = '{}' }
       it { is_expected.to be_valid }
     end
 
     context 'empty string' do
-      before { subject.avatar = "" }
+      before { subject.avatar = '' }
       it { is_expected.to be_valid }
     end
+
+    context 'invalid json string' do
+      before { subject.avatar = '{filename":"img140910_88338.jpg","content_type":"image/jpeg","size":13150}' }
+      it { is_expected.not_to be_valid }
+    end
   end
 
   context 'image data as hash' do
@@ -365,12 +407,26 @@ describe 'File Content Type integration with ActiveModel' do
     subject { Person.new }
 
     context 'for invalid content type' do
-      before { subject.avatar = { "filename" => "img140910_88338.GIF", "content_type" => "image/gif", "size" => 13150 } }
+      before do
+        subject.avatar = {
+          'filename' => 'img140910_88338.GIF',
+          'content_type' => 'image/gif',
+          'size' => 13_150
+        }
+      end
+
       it { is_expected.not_to be_valid }
     end
 
     context 'for valid content type' do
-      before { subject.avatar = { "filename" => "img140910_88338.jpg", "content_type" => "image/jpeg", "size" => 13150 } }
+      before do
+        subject.avatar = {
+          'filename' => 'img140910_88338.jpg',
+          'content_type' => 'image/jpeg',
+          'size' => 13_150
+        }
+      end
+
       it { is_expected.to be_valid }
     end
 
@@ -391,22 +447,22 @@ describe 'File Content Type integration with ActiveModel' do
     subject { Person.new }
 
     context 'for one invalid content type' do
-      before {
+      before do
         subject.avatar = [
           Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain'),
           Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
         ]
-      }
+      end
       it { is_expected.not_to be_valid }
     end
 
     context 'for two invalid content types' do
-      before {
+      before do
         subject.avatar = [
           Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain'),
           Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain')
         ]
-      }
+      end
 
       it 'is invalid and adds just one error' do
         expect(subject).not_to be_valid
@@ -415,12 +471,12 @@ describe 'File Content Type integration with ActiveModel' do
     end
 
     context 'for valid content type' do
-      before {
+      before do
         subject.avatar = [
           Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg'),
           Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
         ]
-      }
+      end
       it { is_expected.to be_valid }
     end
 

data/spec/integration/file_size_validator_integration_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'rack/test/uploaded_file'
 
@@ -44,7 +46,7 @@ describe 'File Size Validator integration with ActiveModel' do
       before :all do
         Person.class_eval do
           Person.reset_callbacks(:validate)
-          validates :avatar, file_size: { in: lambda { |record| 20.kilobytes..40.kilobytes } }
+          validates :avatar, file_size: { in: ->(_record) { 20.kilobytes..40.kilobytes } }
         end
       end
 
@@ -99,8 +101,8 @@ describe 'File Size Validator integration with ActiveModel' 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 } }
+          validates :avatar, file_size: { greater_than: ->(_record) { 20.kilobytes },
+                                          less_than:    ->(_record) { 40.kilobytes } }
         end
       end
 
@@ -218,24 +220,35 @@ describe 'File Size Validator integration with ActiveModel' do
     subject { Person.new }
 
     context 'when file size is less than the specified size' do
-      before { subject.avatar = "{\"filename\":\"img140910_88338.GIF\",\"content_type\":\"image/gif\",\"size\":13150}" }
+      before do
+        subject.avatar = '{"filename":"img140910_88338.GIF","content_type":"image/gif","size":13150}'
+      end
+
       it { is_expected.not_to be_valid }
     end
 
     context 'when file size within the specified size' do
-      before { subject.avatar = "{\"filename\":\"img140910_88338.GIF\",\"content_type\":\"image/gif\",\"size\":33150}" }
+      before do
+        subject.avatar = '{"filename":"img140910_88338.GIF","content_type":"image/gif","size":33150}'
+      end
+
       it { is_expected.to be_valid }
     end
 
     context 'empty json string' do
-      before { subject.avatar = "{}" }
+      before { subject.avatar = '{}' }
       it { is_expected.to be_valid }
     end
 
-    context 'empty json string' do
-      before { subject.avatar = "" }
+    context 'empty string' do
+      before { subject.avatar = '' }
       it { is_expected.to be_valid }
     end
+
+    context 'invalid json string' do
+      before { subject.avatar = '{filename":"img140910_88338.GIF","content_type":"image/gif","size":33150}' }
+      it { is_expected.not_to be_valid }
+    end
   end
 
   context 'image data as hash' do
@@ -249,12 +262,26 @@ describe 'File Size Validator integration with ActiveModel' do
     subject { Person.new }
 
     context 'when file size is less than the specified size' do
-      before { subject.avatar = { "filename" => "img140910_88338.GIF", "content_type" => "image/gif", "size" => 13150 } }
+      before do
+        subject.avatar = {
+          'filename' => 'img140910_88338.GIF',
+          'content_type' => 'image/gif',
+          'size' => 13_150
+        }
+      end
+
       it { is_expected.not_to be_valid }
     end
 
     context 'when file size within the specified size' do
-      before { subject.avatar = { "filename" => "img140910_88338.GIF", "content_type" => "image/gif", "size" => 33150 } }
+      before do
+        subject.avatar = {
+          'filename' => 'img140910_88338.GIF',
+          'content_type' => 'image/gif',
+          'size' => 33_150
+        }
+      end
+
       it { is_expected.to be_valid }
     end
 
@@ -275,22 +302,22 @@ describe 'File Size Validator integration with ActiveModel' do
     subject { Person.new }
 
     context 'when size of one file is less than the specified size' do
-      before {
+      before do
         subject.avatar = [
           Rack::Test::UploadedFile.new(@cute_path),
           Rack::Test::UploadedFile.new(@chubby_bubble_path)
         ]
-      }
+      end
       it { is_expected.not_to be_valid }
     end
 
     context 'when size of all files is within the specified size' do
-      before {
+      before do
         subject.avatar = [
           Rack::Test::UploadedFile.new(@cute_path),
           Rack::Test::UploadedFile.new(@cute_path)
         ]
-      }
+      end
 
       it 'is invalid and adds just one error' do
         expect(subject).not_to be_valid
@@ -299,12 +326,12 @@ describe 'File Size Validator integration with ActiveModel' do
     end
 
     context 'when size of all files is less than the specified size' do
-      before {
+      before do
         subject.avatar = [
           Rack::Test::UploadedFile.new(@chubby_bubble_path),
           Rack::Test::UploadedFile.new(@chubby_bubble_path)
         ]
-      }
+      end
 
       it { is_expected.to be_valid }
     end

data/spec/lib/file_validators/mime_type_analyzer_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rack/test/uploaded_file'
+
+describe FileValidators::MimeTypeAnalyzer do
+  it 'rises error when tool is invalid' do
+    expect { described_class.new(:invalid) }.to raise_error(FileValidators::Error)
+  end
+
+  before :all do
+    @cute_path = File.join(File.dirname(__FILE__), '../../fixtures/cute.jpg')
+    @spoofed_file_path = File.join(File.dirname(__FILE__), '../../fixtures/spoofed.jpg')
+  end
+
+  let(:cute_image) { Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg') }
+  let(:spoofed_file) { Rack::Test::UploadedFile.new(@spoofed_file_path, 'image/jpeg') }
+
+  describe ':file analyzer' do
+    let(:analyzer) { described_class.new(:file) }
+
+    it 'determines MIME type from file contents' do
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'returns text/plain for unidentified MIME types' do
+      expect(analyzer.call(fakeio('a' * 5 * 1024 * 1024))).to eq('text/plain')
+    end
+
+    it 'is able to determine MIME type for spoofed files' do
+      expect(analyzer.call(spoofed_file)).to eq('text/plain')
+    end
+
+    it 'is able to determine MIME type for non-files' do
+      expect(analyzer.call(fakeio(cute_image.read))).to eq('image/jpeg')
+    end
+
+    it 'returns nil for empty IOs' do
+      expect(analyzer.call(fakeio(''))).to eq(nil)
+    end
+
+    it 'raises error if file command is not found' do
+      allow(Open3).to receive(:popen3).and_raise(Errno::ENOENT)
+      expect { analyzer.call(fakeio) }.to raise_error(FileValidators::Error, 'file command-line tool is not installed')
+    end
+  end
+
+  describe ':fastimage analyzer' do
+    let(:analyzer) { described_class.new(:fastimage) }
+
+    it 'extracts MIME type of any IO' do
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'returns nil for unidentified MIME types' do
+      expect(analyzer.call(fakeio('😃'))).to eq nil
+    end
+
+    it 'returns nil for empty IOs' do
+      expect(analyzer.call(fakeio(''))).to eq nil
+    end
+  end
+
+  describe ':mimemagic analyzer' do
+    let(:analyzer) { described_class.new(:mimemagic) }
+
+    it 'extracts MIME type of any IO' do
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'returns nil for unidentified MIME types' do
+      expect(analyzer.call(fakeio('😃'))).to eq nil
+    end
+
+    it 'returns nil for empty IOs' do
+      expect(analyzer.call(fakeio(''))).to eq nil
+    end
+  end
+
+  if RUBY_VERSION >= '2.2.0'
+    describe ':marcel analyzer' do
+      let(:analyzer) { described_class.new(:marcel) }
+
+      it 'extracts MIME type of any IO' do
+        expect(analyzer.call(cute_image)).to eq('image/jpeg')
+      end
+
+      it 'returns application/octet-stream for unidentified MIME types' do
+        expect(analyzer.call(fakeio('😃'))).to eq 'application/octet-stream'
+      end
+
+      it 'returns nil for empty IOs' do
+        expect(analyzer.call(fakeio(''))).to eq nil
+      end
+    end
+  end
+
+  describe ':mime_types analyzer' do
+    let(:analyzer) { described_class.new(:mime_types) }
+
+    it 'extract MIME type from the file extension' do
+      expect(analyzer.call(fakeio(filename: 'image.png'))).to eq('image/png')
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'extracts MIME type from file extension when IO is empty' do
+      expect(analyzer.call(fakeio('', filename: 'image.png'))).to eq('image/png')
+    end
+
+    it 'returns nil on unknown extension' do
+      expect(analyzer.call(fakeio(filename: 'file.foo'))).to eq(nil)
+    end
+
+    it 'returns nil when input is not a file' do
+      expect(analyzer.call(fakeio)).to eq(nil)
+    end
+  end
+
+  describe ':mini_mime analyzer' do
+    let(:analyzer) { described_class.new(:mini_mime) }
+
+    it 'extract MIME type from the file extension' do
+      expect(analyzer.call(fakeio(filename: 'image.png'))).to eq('image/png')
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'extracts MIME type from file extension when IO is empty' do
+      expect(analyzer.call(fakeio('', filename: 'image.png'))).to eq('image/png')
+    end
+
+    it 'returns nil on unkown extension' do
+      expect(analyzer.call(fakeio(filename: 'file.foo'))).to eq(nil)
+    end
+
+    it 'returns nil when input is not a file' do
+      expect(analyzer.call(fakeio)).to eq(nil)
+    end
+  end
+end