card 1.19.3 → 1.19.4

data/vendor/carrierwave/spec/storage/fog_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'fog'
-require 'carrierwave/storage/fog'
-
-unless ENV['REMOTE'] == 'true'
-  Fog.mock!
-end
-
-require_relative './fog_credentials' # after Fog.mock!
-require_relative './fog_helper'
-
-FOG_CREDENTIALS.each do |credential|
-  fog_tests(credential)
-end
-
-describe CarrierWave::Storage::Fog::File do
-  subject(:file) { CarrierWave::Storage::Fog::File.new(nil, nil, nil) }
-
-  describe "#filename" do
-    subject(:filename) { file.filename }
-
-    before { allow(file).to receive(:url).and_return(url) }
-
-    context "with normal url" do
-      let(:url) { 'http://example.com/path/to/foo.txt' }
-
-      it "extracts filename from url" do
-        is_expected.to eq('foo.txt')
-      end
-    end
-
-    context "when url contains '/' in query string" do
-      let(:url){ 'http://example.com/path/to/foo.txt?bar=baz/fubar' }
-
-      it "extracts correct part" do
-        is_expected.to eq('foo.txt')
-      end
-    end
-
-    context "when url contains multi-byte characters" do
-      let(:url) { 'http://example.com/path/to/%E6%97%A5%E6%9C%AC%E8%AA%9E.txt' }
-
-      it "decodes multi-byte characters" do
-        is_expected.to eq('日本語.txt')
-      end
-    end
-  end
-end

data/vendor/carrierwave/spec/support/activerecord.rb

@@ -1,31 +0,0 @@
-if RUBY_ENGINE == 'jruby'
-  require 'activerecord-jdbcpostgresql-adapter'
-else
-  require 'pg'
-end
-require 'active_record'
-require 'carrierwave/orm/activerecord'
-Bundler.require
-
-# Change this if PG is unavailable
-dbconfig = {
-  :adapter  => 'postgresql',
-  :database => 'carrierwave_test',
-  :encoding => 'utf8',
-  :username => 'postgres'
-}
-
-database = dbconfig.delete(:database)
-
-ActiveRecord::Base.establish_connection(dbconfig.merge(database: "template1"))
-begin
-  ActiveRecord::Base.connection.create_database database
-rescue ActiveRecord::StatementInvalid => e # database already exists
-end
-ActiveRecord::Base.establish_connection(dbconfig.merge(:database => database))
-
-ActiveRecord::Migration.verbose = false
-
-if ActiveRecord::VERSION::STRING >= '4.2'
-  ActiveRecord::Base.raise_in_transactional_callbacks = true
-end

data/vendor/carrierwave/spec/support/file_utils_helper.rb

@@ -1,15 +0,0 @@
-module FileUtilsHelper
-  # NOTE: Make FileUtils.mkdir_p to raise `Errno::EMLINK` only once
-  def fake_failed_mkdir_p
-    original_mkdir_p = FileUtils.method(:mkdir_p)
-    mkdir_p_called = false
-    allow(FileUtils).to receive(:mkdir_p) do |args|
-      if mkdir_p_called
-        original_mkdir_p.call(*args)
-      else
-        mkdir_p_called = true
-        raise Errno::EMLINK
-      end
-    end
-  end
-end

data/vendor/carrierwave/spec/uploader/cache_spec.rb

@@ -1,324 +0,0 @@
-require 'spec_helper'
-
-describe CarrierWave::Uploader do
-  let(:uploader_class) { Class.new(CarrierWave::Uploader::Base) }
-  let(:uploader) { uploader_class.new }
-  let(:test_file_name) { "test.jpg"}
-  let(:test_file_path) { file_path(test_file_name) }
-  let(:test_file) { File.open(test_file_path) }
-  let(:permission) { 0777 }
-  let(:cache_id) { '1369894322-345-1234-2255' }
-
-  before { FileUtils.rm_rf(public_path) }
-
-  after { FileUtils.rm_rf(public_path) }
-
-  describe '#cache_dir' do
-    it "defaults to the config option" do
-      expect(uploader.cache_dir).to eq('uploads/tmp')
-    end
-  end
-
-  describe '#sanitized_file' do
-    before { uploader.store! CarrierWave::SanitizedFile.new(test_file) }
-
-    it "returns a sanitized file" do
-      expect(uploader.sanitized_file).to be_an_instance_of(CarrierWave::SanitizedFile)
-    end
-
-    it "only read the file once" do
-      expect(uploader.file).to receive(:read).once.and_return('this is stuff')
-
-      uploader.sanitized_file
-    end
-  end
-
-  context "permissions" do
-    it "sets permissions if options are given" do
-      uploader_class.permissions = permission
-      uploader.cache!(test_file)
-
-      expect(uploader).to have_permissions(permission)
-    end
-
-    it "sets directory permissions if options are given" do
-      uploader_class.directory_permissions = permission
-      uploader.cache!(test_file)
-
-      expect(uploader).to have_directory_permissions(permission)
-    end
-
-    describe "with ensuring multipart form deactivated" do
-      before do
-        CarrierWave.configure { |config| config.ensure_multipart_form = false }
-      end
-
-      it "doesn't raise an error when trying to cache a string" do
-        expect(running {
-                 uploader.cache!(file_path(test_file_name))
-        }).not_to raise_error
-      end
-
-      it "doesn't raise an error when trying to cache a pathname and " do
-        expect(running {
-                 uploader.cache!(Pathname.new(file_path(test_file_name)))
-        }).not_to raise_error
-      end
-    end
-  end
-
-  describe '#cache!' do
-    before { allow(CarrierWave).to receive(:generate_cache_id).and_return(cache_id) }
-
-    context "when ensure_multipart_form is true" do
-      before { CarrierWave.configure { |config| config.ensure_multipart_form = true } }
-
-      it "raises an error when trying to cache a string" do
-        expect(running { uploader.cache!(test_file_path) }).to raise_error(CarrierWave::FormNotMultipart)
-      end
-
-      it "raises an error when trying to cache a pathname" do
-        expect { uploader.cache!(Pathname.new(test_file)) }.to raise_error(CarrierWave::FormNotMultipart)
-      end
-    end
-
-    context "when a file is cached" do
-      before { uploader.cache!(test_file) }
-
-      it "caches the file" do
-        expect(uploader.file).to be_an_instance_of(CarrierWave::SanitizedFile)
-      end
-
-      it { expect(uploader).to be_cached }
-
-      it "stores the cache name" do
-        expect(uploader.cache_name).to eq("#{cache_id}/#{test_file_name}")
-      end
-
-      it "sets the filename to the file's sanitized filename" do
-        expect(uploader.filename).to eq(test_file_name)
-      end
-
-      it "moves it to the tmp dir" do
-        expect(uploader.file.path).to eq(public_path("uploads/tmp/#{cache_id}/#{test_file_name}"))
-      end
-
-      it { expect(uploader.file.exists?).to be_truthy }
-
-      it "sets the url" do
-        expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/#{test_file_name}")
-      end
-
-      it "does nothing when trying to cache an empty file" do
-        uploader.cache!(nil)
-      end
-    end
-
-    describe "with the move_to_cache option" do
-      let(:tmp_file_name) { "test_move.jpeg" }
-      let(:tmp_file_path) { file_path(tmp_file_name) }
-      let(:tmp_file) { File.open(tmp_file_path) }
-      let(:cached_id) { '1369894322-345-1234-2255' }
-      let(:cached_path) { public_path("uploads/tmp/#{cached_id}/#{tmp_file_name}") }
-      let(:workfile_path) { tmp_path("#{cached_id}/#{tmp_file_name}") }
-
-      before do
-        FileUtils.cp(test_file, File.join(File.dirname(test_file), tmp_file_name))
-
-        allow(CarrierWave).to receive(:generate_cache_id).and_return(cached_id)
-
-        uploader_class.permissions = permission
-        uploader_class.directory_permissions = permission
-      end
-
-      after do
-        FileUtils.rm_f(tmp_file.path)
-      end
-
-      context "set to true" do
-        before { uploader_class.move_to_cache = true }
-
-        context "moving from the upload directory to the temporary directory" do
-          let(:original_path) { tmp_file.path }
-
-          before { uploader.cache!(tmp_file) }
-
-          it { expect(uploader.file.path).to eq(cached_path) }
-
-          it { expect(File.exist?(cached_path)).to be_truthy }
-
-          it { expect(File.exist?(original_path)).to be_falsey }
-
-        end
-
-        describe "method usage" do
-          after { uploader.cache!(tmp_file) }
-
-          it "uses #move_to during #cache!" do
-            moved_file = double('moved file').as_null_object
-
-            expect_any_instance_of(CarrierWave::SanitizedFile).to receive(:move_to).with(workfile_path, permission, permission).and_return(moved_file)
-            expect(moved_file).to receive(:move_to).with(cached_path, permission, permission, true)
-          end
-
-          it "doesn't use #copy_to during #cache!" do
-            expect_any_instance_of(CarrierWave::SanitizedFile).not_to receive(:copy_to)
-          end
-        end
-      end
-
-      context "set to false" do
-        before { uploader_class.move_to_cache = false }
-
-        context "copying from the upload directory to the temporary directory" do
-          let(:original_path) { tmp_file.path }
-
-          before { uploader.cache!(tmp_file) }
-
-          it { expect(uploader.file.path).to eq(cached_path) }
-          it { expect(File.exist?(cached_path)).to be_truthy }
-          it { expect(File.exist?(original_path)).to be_truthy }
-        end
-
-        describe "method usage" do
-          after { uploader.cache!(tmp_file) }
-
-          it "uses #move_to during cache!" do
-            moved_file = double('moved file').as_null_object
-
-            expect_any_instance_of(CarrierWave::SanitizedFile).to receive(:copy_to).with(workfile_path, permission, permission).and_return(moved_file)
-            expect(moved_file).to receive(:move_to).with(cached_path, permission, permission, true)
-          end
-
-          it "doesn't use #move_to during #cache!" do
-            expect_any_instance_of(CarrierWave::SanitizedFile).not_to receive(:move_to).with(workfile_path, permission, permission)
-          end
-        end
-      end
-    end
-
-    it "uses different workfiles for different versions" do
-      uploader_class.version(:small)
-      uploader_class.version(:large)
-
-      uploader.cache!(test_file)
-
-      expect(uploader.small.send(:workfile_path)).not_to eq uploader.large.send(:workfile_path)
-    end
-  end
-
-  describe '#retrieve_from_cache!' do
-    before { uploader.retrieve_from_cache!("#{cache_id}/#{test_file_name}") }
-
-    it "caches a file" do
-      expect(uploader.file).to be_an_instance_of(CarrierWave::SanitizedFile)
-    end
-
-    it { expect(uploader).to be_cached }
-
-    it "sets the path to the tmp dir" do
-      expect(uploader.current_path).to eq(public_path("uploads/tmp/#{cache_id}/#{test_file_name}"))
-    end
-
-    it "overwrites a file that has already been cached" do
-      uploader.retrieve_from_cache!("#{cache_id}/#{test_file_name}")
-      uploader.retrieve_from_cache!("#{cache_id}/bork.txt")
-
-      expect(uploader.current_path).to eq(public_path("uploads/tmp/#{cache_id}/bork.txt"))
-    end
-
-    it "stores the cache_name" do
-      expect(uploader.cache_name).to eq("#{cache_id}/#{test_file_name}")
-    end
-
-    it "stores the filename" do
-      expect(uploader.filename).to eq(test_file_name)
-    end
-
-    it "sets the url" do
-      expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/#{test_file_name}")
-    end
-
-
-    it "supports old format of cache_id (without counter) for backwards compartibility" do
-      expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/#{test_file_name}")
-    end
-
-    it "raises an error when the cache_id has an invalid format" do
-      expect(running {
-        uploader.retrieve_from_cache!("12345/#{test_file_name}")
-      }).to raise_error(CarrierWave::InvalidParameter)
-    end
-
-    context "when the original filename has invalid characters" do
-      it do
-        expect(running {
-          uploader.retrieve_from_cache!('1369894322-345-1234-2255/te/st.jpeg')
-        }).to raise_error(CarrierWave::InvalidParameter)
-      end
-
-      it do
-        expect(running {
-          uploader.retrieve_from_cache!('1369894322-345-1234-2255/te??%st.jpeg')
-        }).to raise_error(CarrierWave::InvalidParameter)
-      end
-    end
-  end
-
-  describe 'with an overridden, reversing, filename' do
-    before do
-      uploader_class.class_eval do
-        def filename
-          super.reverse unless super.blank?
-        end
-      end
-
-      allow(CarrierWave).to receive(:generate_cache_id).and_return(cache_id)
-      uploader.cache!(test_file)
-    end
-
-    let(:reversed_test_file_name) { test_file_name.reverse }
-
-    describe '#cache!' do
-      it "sets the filename to the file's reversed filename" do
-        expect(uploader.filename).to eq(reversed_test_file_name)
-      end
-
-      it "moves it to the tmp dir with the filename unreversed" do
-        expect(uploader.current_path).to eq(public_path("uploads/tmp/#{cache_id}/#{test_file_name}"))
-        expect(uploader.file.exists?).to be_truthy
-      end
-    end
-
-    describe '#retrieve_from_cache!' do
-      it "sets the path to the tmp dir" do
-        expect(uploader.current_path).to eq(public_path("uploads/tmp/#{cache_id}/#{test_file_name}"))
-      end
-
-      it "sets the filename to the reversed name of the file" do
-        expect(uploader.filename).to eq(reversed_test_file_name)
-      end
-    end
-  end
-
-  describe '.generate_cache_id' do
-    it 'generates dir name based on UTC time' do
-      Timecop.freeze(Time.at(1369896000)) do
-        expect(CarrierWave.generate_cache_id).to match(/\A1369896000-\d+-\d+-\d+\Z/)
-      end
-    end
-
-    it 'generates dir name with a counter substring' do
-      counter = CarrierWave.generate_cache_id.split('-')[2].to_i
-
-      expect(CarrierWave.generate_cache_id.split('-')[2].to_i).to eq(counter + 1)
-    end
-
-    it 'generates dir name with constant length even when counter has big value' do
-      length = CarrierWave.generate_cache_id.length
-      allow(CarrierWave::CacheCounter).to receive(:increment).and_return(1234567890)
-
-      expect(CarrierWave.generate_cache_id.length).to eq(length)
-    end
-  end
-end

data/vendor/carrierwave/spec/uploader/callback_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe CarrierWave::Uploader do
-  describe "callback isolation" do
-    let(:default_before_callbacks) do
-      [
-        :check_extension_whitelist!,
-        :check_extension_blacklist!,
-        :check_content_type_whitelist!,
-        :check_content_type_blacklist!,
-        :check_size!,
-        :process!
-      ]
-    end
-
-    let(:uploader_class_1) { Class.new(CarrierWave::Uploader::Base) }
-    let(:uploader_class_2) { Class.new(CarrierWave::Uploader::Base) }
-
-    before { uploader_class_2.before(:cache, :before_cache_callback) }
-
-    it { expect(uploader_class_1._before_callbacks[:cache]).to eq(default_before_callbacks) }
-
-
-    it { expect(uploader_class_2._before_callbacks[:cache]).to eq(default_before_callbacks + [:before_cache_callback]) }
-
-    it "doesn't inherit the uploader 2 callback" do
-      expect(uploader_class_1._before_callbacks[:cache]).to eq(default_before_callbacks)
-    end
-  end
-end