card 1.19.0 → 1.19.1

data/vendor/carrierwave/lib/carrierwave/utilities.rb

@@ -0,0 +1,6 @@
+require 'carrierwave/utilities/uri'
+
+module CarrierWave
+  module Utilities
+  end
+end

data/vendor/carrierwave/lib/carrierwave/utilities/uri.rb

@@ -0,0 +1,21 @@
+module CarrierWave
+  module Utilities
+    module Uri
+    # based on Ruby < 2.0's URI.encode
+    SAFE_STRING = URI::REGEXP::PATTERN::UNRESERVED + '\/'
+    UNSAFE = Regexp.new("[^#{SAFE_STRING}]", false)
+
+    private
+      def encode_path(path)
+        path.to_s.gsub(UNSAFE) do
+          us = $&
+          tmp = ''
+          us.each_byte do |uc|
+            tmp << sprintf('%%%02X', uc)
+          end
+          tmp
+        end
+      end
+    end # Uri
+  end # Utilities
+end # CarrierWave

data/vendor/carrierwave/lib/carrierwave/validations/active_model.rb

@@ -0,0 +1,78 @@
+require 'active_model/validator'
+require 'active_support/concern'
+
+module CarrierWave
+
+  # == Active Model Presence Validator
+  module Validations
+    module ActiveModel
+      extend ActiveSupport::Concern
+
+      class ProcessingValidator < ::ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          if e = record.send("#{attribute}_processing_error")
+            message = (e.message == e.class.to_s) ? :carrierwave_processing_error : e.message
+            record.errors.add(attribute, message)
+          end
+        end
+      end
+
+      class IntegrityValidator < ::ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          if e = record.send("#{attribute}_integrity_error")
+            message = (e.message == e.class.to_s) ? :carrierwave_integrity_error : e.message
+            record.errors.add(attribute, message)
+          end
+        end
+      end
+
+      class DownloadValidator < ::ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          if e = record.send("#{attribute}_download_error")
+            message = (e.message == e.class.to_s) ? :carrierwave_download_error : e.message
+            record.errors.add(attribute, message)
+          end
+        end
+      end
+
+      module HelperMethods
+
+        ##
+        # Makes the record invalid if the file couldn't be uploaded due to an integrity error
+        #
+        # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+        #
+        def validates_integrity_of(*attr_names)
+          validates_with IntegrityValidator, _merge_attributes(attr_names)
+        end
+
+        ##
+        # Makes the record invalid if the file couldn't be processed (assuming the process failed
+        # with a CarrierWave::ProcessingError)
+        #
+        # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+        #
+        def validates_processing_of(*attr_names)
+          validates_with ProcessingValidator, _merge_attributes(attr_names)
+        end
+        #
+        ##
+        # Makes the record invalid if the remote file couldn't be downloaded
+        #
+        # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+        #
+        def validates_download_of(*attr_names)
+          validates_with DownloadValidator, _merge_attributes(attr_names)
+        end
+      end
+
+      included do
+        extend HelperMethods
+        include HelperMethods
+      end
+    end
+  end
+end

data/vendor/carrierwave/lib/carrierwave/version.rb

@@ -0,0 +1,3 @@
+module CarrierWave
+  VERSION = "0.11.0"
+end

data/vendor/carrierwave/lib/generators/templates/uploader.rb

@@ -0,0 +1,49 @@
+class <%= class_name %>Uploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or MiniMagick support:
+  # include CarrierWave::RMagick
+  # include CarrierWave::MiniMagick
+
+  # Choose what kind of storage to use for this uploader:
+  storage :file
+  # storage :fog
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url
+  #   # For Rails 3.1+ asset pipeline compatibility:
+  #   # ActionController::Base.helpers.asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+  #
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  # process scale: [200, 300]
+  #
+  # def scale(width, height)
+  #   # do something
+  # end
+
+  # Create different versions of your uploaded files:
+  # version :thumb do
+  #   process resize_to_fit: [50, 50]
+  # end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_whitelist
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+
+end

data/vendor/carrierwave/lib/generators/uploader_generator.rb

@@ -0,0 +1,7 @@
+class UploaderGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path("../templates", __FILE__)
+
+  def create_uploader_file
+    template "uploader.rb", File.join('app/uploaders', class_path, "#{file_name}_uploader.rb")
+  end
+end

data/vendor/carrierwave/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/carrierwave.rb'}"
+puts "Loading carrierwave gem"
+exec "#{irb} #{libs} --simple-prompt"

data/vendor/carrierwave/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/vendor/carrierwave/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/vendor/carrierwave/spec/compatibility/paperclip_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'carrierwave/orm/activerecord'
+
+module Rails; end unless defined?(Rails)
+
+describe CarrierWave::Compatibility::Paperclip do
+  let(:uploader_class) do
+    Class.new(CarrierWave::Uploader::Base) do
+      include CarrierWave::Compatibility::Paperclip
+
+      version :thumb
+      version :list
+    end
+  end
+
+  let(:model) { double('model') }
+
+  let(:uploader) { uploader_class.new(model, :monkey) }
+
+  before do
+    allow(Rails).to receive(:root).and_return('/rails/root')
+    allow(Rails).to receive(:env).and_return('test')
+    allow(model).to receive(:id).and_return(23)
+    allow(model).to receive(:ook).and_return('eek')
+    allow(model).to receive(:money).and_return('monkey.png')
+  end
+
+  after { FileUtils.rm_rf(public_path) }
+
+  describe '#store_path' do
+    subject { uploader.store_path("monkey.png") }
+
+    it "mimics paperclip default" do
+      is_expected.to eq("/rails/root/public/system/monkeys/23/original/monkey.png")
+    end
+
+    it "interpolates the root path" do
+      allow(uploader).to receive(:paperclip_path).and_return(":rails_root/foo/bar")
+      is_expected.to eq(Rails.root + "/foo/bar")
+    end
+
+    it "interpolates the attachment" do
+      allow(uploader).to receive(:paperclip_path).and_return("/foo/:attachment/bar")
+      is_expected.to eq("/foo/monkeys/bar")
+    end
+
+    it "interpolates the id" do
+      allow(uploader).to receive(:paperclip_path).and_return("/foo/:id/bar")
+      is_expected.to eq("/foo/23/bar")
+    end
+
+    it "interpolates the id partition" do
+      allow(uploader).to receive(:paperclip_path).and_return("/foo/:id_partition/bar")
+      is_expected.to eq("/foo/000/000/023/bar")
+    end
+
+    it "interpolates the basename" do
+      allow(uploader).to receive(:paperclip_path).and_return("/foo/:basename/bar")
+      is_expected.to eq("/foo/monkey/bar")
+    end
+
+    it "interpolates the extension" do
+      allow(uploader).to receive(:paperclip_path).and_return("/foo/:extension/bar")
+      is_expected.to eq("/foo/png/bar")
+    end
+  end
+
+  describe '.interpolate' do
+    subject { uploader.store_path("monkey.png") }
+
+    before do
+      uploader_class.interpolate :ook do |custom, style|
+        custom.model.ook
+      end
+
+      uploader_class.interpolate :aak do |model, style|
+        style
+      end
+    end
+
+    it 'allows you to add custom interpolations' do
+      allow(uploader).to receive(:paperclip_path).and_return("/foo/:id/:ook")
+      is_expected.to eq('/foo/23/eek')
+    end
+
+    it 'mimics paperclips arguments' do
+      allow(uploader).to receive(:paperclip_path).and_return("/foo/:aak")
+      is_expected.to eq('/foo/original')
+    end
+
+    context 'when multiple uploaders include the compatibility module' do
+      let(:uploader) { uploader_class_other.new(model, :monkey) }
+      let(:uploader_class_other) do
+        Class.new(CarrierWave::Uploader::Base) do
+          include CarrierWave::Compatibility::Paperclip
+
+          version :thumb
+          version :list
+        end
+      end
+
+      before { allow(uploader).to receive(:paperclip_path).and_return("/foo/:id/:ook") }
+
+      it "doesn't share custom interpolations" do
+        is_expected.to eq('/foo/23/:ook')
+      end
+    end
+
+    context 'when there are multiple versions' do
+      let(:complex_uploader_class) do
+        Class.new(CarrierWave::Uploader::Base) do
+          include CarrierWave::Compatibility::Paperclip
+
+          interpolate :ook do |model, style|
+            'eek'
+          end
+
+          version :thumb
+          version :list
+
+          def paperclip_path
+            "#{public_path}/foo/:ook/:id/:style"
+          end
+        end
+      end
+
+      let(:uploader) { complex_uploader_class.new(model, :monkey) }
+      let!(:file) { File.open(file_path('test.jpg')) }
+
+      before { uploader.store!(file) }
+
+      it 'interpolates for all versions correctly' do
+        expect(uploader.thumb.path).to eq("#{public_path}/foo/eek/23/thumb")
+        expect(uploader.list.path).to eq("#{public_path}/foo/eek/23/list")
+      end
+    end
+  end
+end

data/vendor/carrierwave/spec/fixtures/Uppercase.jpg

@@ -0,0 +1 @@
+this is stuff

data/vendor/carrierwave/spec/fixtures/bork.ttxt

@@ -0,0 +1 @@
+bork bork bork Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/vendor/carrierwave/spec/fixtures/bork.txt

@@ -0,0 +1 @@
+bork bork bork Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/vendor/carrierwave/spec/fixtures/bork.txtt

@@ -0,0 +1 @@
+bork bork bork Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/vendor/carrierwave/spec/fixtures/case.JPG

@@ -0,0 +1 @@
+this is stuff

data/vendor/carrierwave/spec/fixtures/new.jpeg

@@ -0,0 +1 @@
+this is stuff

data/vendor/carrierwave/spec/fixtures/new.txt

@@ -0,0 +1 @@
+bork bork bork Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/vendor/carrierwave/spec/fixtures/old.jpeg

@@ -0,0 +1 @@
+this is stuff

data/vendor/carrierwave/spec/fixtures/old.txt

@@ -0,0 +1 @@
+bork bork bork Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/vendor/carrierwave/spec/fixtures/sponsored.doc

@@ -0,0 +1 @@
+Hi there

data/vendor/carrierwave/spec/fixtures/test+.jpg

@@ -0,0 +1 @@
+this is stuff

data/vendor/carrierwave/spec/fixtures/test.jpeg

@@ -0,0 +1 @@
+this is stuff

data/vendor/carrierwave/spec/fixtures/test.jpg

@@ -0,0 +1 @@
+this is stuff

data/vendor/carrierwave/spec/generators/uploader_generator_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'generator_spec'
+require 'generators/uploader_generator'
+
+describe UploaderGenerator, :type => :generator do
+  destination(File.expand_path("../../tmp", __FILE__))
+
+  before { prepare_destination }
+
+  it "creates uploader file" do
+    run_generator %w(Avatar)
+    assert_file 'app/uploaders/avatar_uploader.rb', /class AvatarUploader < CarrierWave::Uploader::Base/
+  end
+
+  it "creates namespaced uploader file" do
+    run_generator %w(MyModule::Avatar)
+    assert_file 'app/uploaders/my_module/avatar_uploader.rb', /class MyModule::AvatarUploader < CarrierWave::Uploader::Base/
+  end
+end

data/vendor/carrierwave/spec/mount_multiple_spec.rb

@@ -0,0 +1,913 @@
+require 'spec_helper'
+
+describe CarrierWave::Mount do
+  let(:klass) { Class.new.send(:extend, CarrierWave::Mount) }
+  let(:uploader) { Class.new(CarrierWave::Uploader::Base) }
+  let(:instance) { klass.new }
+  let(:test_file_name) { 'test.jpg' }
+  let(:new_file_name) { 'new.jpeg' }
+  let(:test_file_stub) { stub_file(test_file_name) }
+  let(:new_file_stub) { stub_file(new_file_name) }
+
+  after { FileUtils.rm_rf(public_path) }
+
+  describe '.mount_uploaders' do
+    before { klass.mount_uploaders(:images, uploader) }
+
+    describe "super behavior" do
+      before do
+        klass.class_eval do
+          def images_uploader
+            super
+          end
+
+          def images=(val)
+            super
+          end
+        end
+
+        instance.images = [stub_file(test_file_name)]
+      end
+
+      it "maintains the ability to super" do
+        expect(instance.images[0]).to be_an_instance_of(uploader)
+      end
+    end
+
+    describe "upload inheritance" do
+      let(:subclass) { Class.new(klass) }
+      let(:subclass_instance) { subclass.new }
+
+      before { subclass_instance.images = [test_file_stub, new_file_stub] }
+
+      it "inherits uploaders to subclasses" do
+        expect(subclass_instance.images[0]).to be_an_instance_of(uploader)
+        expect(subclass_instance.images[1]).to be_an_instance_of(uploader)
+      end
+    end
+
+    describe "upload marshalling" do
+      before do
+        Object.const_set("MyClass#{klass.object_id}".gsub('-', '_'), klass)
+        Object.const_set("Uploader#{uploader.object_id}".gsub('-', '_'), uploader)
+
+        uploader.class_eval do
+          def rotate
+          end
+        end
+
+        uploader.version :thumb do
+          process :rotate
+        end
+
+        instance.images = [test_file_stub]
+      end
+
+      it "allows marshalling uploaders and versions" do
+        expect { Marshal.dump(instance.images) }.not_to raise_error
+      end
+    end
+
+    describe "behavior of subclassed uploaders" do
+      let(:uploader_1) do
+        Class.new(CarrierWave::Uploader::Base) do
+          [:rotate, :compress, :encrypt, :shrink].each { |m| define_method(m) {} }
+        end.tap do |uploader|
+          uploader.process :rotate
+          uploader.version :thumb do
+            process :compress
+          end
+        end
+      end
+
+      let(:uploader_2) do
+        Class.new(uploader_1).tap do |uploader|
+          uploader.process :shrink
+          uploader.version :secret do
+            process :encrypt
+          end
+        end
+      end
+
+      let(:instance) do
+        klass.new.tap do |instance|
+          instance.images1 = [test_file_stub]
+          instance.images2 = [test_file_stub]
+        end
+      end
+
+      before do
+        klass.mount_uploaders(:images1, uploader_1)
+        klass.mount_uploaders(:images2, uploader_2)
+      end
+
+      context "defined version inheritance works" do
+        it { expect(instance.images1[0]).to respond_to(:thumb) }
+
+        it { expect(instance.images2[0]).to respond_to(:thumb) }
+      end
+
+      context "version inheritance defined in subclasses works" do
+        it { expect(instance.images1[0]).not_to respond_to(:secret) }
+
+        it { expect(instance.images2[0]).to respond_to(:secret) }
+      end
+
+      context "defined processors inheritance works" do
+        it { expect(uploader_1.processors).to eq([[:rotate, [], nil]]) }
+
+        it { expect(uploader_2.processors).to eq([[:rotate, [], nil], [:shrink, [], nil]]) }
+
+        it { expect(uploader_1.versions[:thumb].processors).to eq([[:compress, [], nil]]) }
+
+        it { expect(uploader_2.versions[:thumb].processors).to eq([[:compress, [], nil]]) }
+
+        it { expect(uploader_2.versions[:secret].processors).to eq([[:encrypt, [], nil]]) }
+      end
+    end
+
+    describe '#images' do
+      context "return an empty array when nothing has been assigned" do
+        before do
+          allow(instance).to receive(:read_uploader).with(:images).and_return(nil)
+        end
+
+        it { expect(instance.images).to eq [] }
+      end
+
+      context "returns an empty array when an empty string has been assigned" do
+        before do
+          allow(instance).to receive(:read_uploader).with(:images).and_return('')
+        end
+
+        it { expect(instance.images).to eq [] }
+      end
+
+      context "retrieves a file from the storage if a value is stored in the database" do
+        subject(:images) { instance.images }
+
+        before do
+          allow(instance).to receive(:read_uploader).with(:images).at_least(:once).and_return([test_file_name, new_file_name])
+        end
+
+        it { expect(images[0]).to be_an_instance_of(uploader) }
+        it { expect(images[1]).to be_an_instance_of(uploader) }
+      end
+
+      context "sets the path to the store dir" do
+        subject(:image) { instance.images.first }
+
+        before do
+          allow(instance).to receive(:read_uploader).with(:images).at_least(:once).and_return(test_file_name)
+        end
+
+        it { expect(image.current_path).to eq(public_path("uploads/#{test_file_name}")) }
+      end
+    end
+
+    describe '#images=' do
+      let(:old_image_stub) { stub_file('old.jpeg') }
+      let(:text_file_stub) { stub_file('bork.txt') }
+
+      context "caching images" do
+        before do
+          instance.images = [test_file_stub, old_image_stub]
+        end
+
+        it { expect(instance.images[0]).to be_an_instance_of(uploader) }
+
+        it { expect(instance.images[1]).to be_an_instance_of(uploader) }
+
+        it "copies files into the cache directory" do
+          expect(instance.images[0].current_path).to match(/^#{public_path('uploads/tmp')}/)
+        end
+      end
+
+      it "does nothing when nil is assigned" do
+        expect(instance).not_to receive(:write_uploader)
+        instance.images = nil
+      end
+
+      it "does nothing when an empty string is assigned" do
+        expect(instance).not_to receive(:write_uploader)
+
+        instance.images = [test_file_stub]
+      end
+
+      context "fails silently if the images fails a white list integrity check" do
+        before do
+          uploader.class_eval do
+            def extension_whitelist
+              %w(txt)
+            end
+          end
+
+          instance.images = [text_file_stub, test_file_stub]
+        end
+
+        it { expect(instance.images).to be_empty }
+      end
+
+      describe "fails silently if the images fails a black list integrity check" do
+        before do
+          uploader.class_eval do
+            def extension_blacklist
+              %w(jpg)
+            end
+          end
+
+          instance.images = [text_file_stub, test_file_stub]
+        end
+
+        it { expect(instance.images).to be_empty }
+      end
+
+      describe "fails silently if the images fails to be processed" do
+        before do
+          uploader.class_eval do
+            process :monkey
+            def monkey
+              raise CarrierWave::ProcessingError, "Ohh noez!"
+            end
+          end
+
+          instance.images = [test_file_stub]
+        end
+
+        it { expect(instance.images).to be_empty }
+      end
+    end
+
+    describe '#images?' do
+      subject { instance.images? }
+
+      context "false when nothing has been assigned" do
+        before { instance.images = nil }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context "false when an empty string has been assigned" do
+        before { instance.images = '' }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context "true when a file has been cached" do
+        before { instance.images = [test_file_stub] }
+
+        it { is_expected.to be_truthy }
+      end
+    end
+
+    describe '#images_urls' do
+      subject(:images_urls) { instance.images_urls }
+
+      describe "returns nil when nothing has been assigned" do
+        before do
+          allow(instance).to receive(:read_uploader).with(:images).and_return(nil)
+        end
+
+        it { is_expected.to be_empty }
+      end
+
+      describe "should return nil when an empty string has been assigned" do
+        before do
+          allow(instance).to receive(:read_uploader).with(:images).and_return('')
+        end
+
+        it { is_expected.to be_empty }
+      end
+
+      describe "gets the url from a retrieved file" do
+        before do
+          allow(instance).to receive(:read_uploader).at_least(:once).with(:images).and_return(test_file_name)
+        end
+
+        it { expect(images_urls.first).to eq("/uploads/#{test_file_name}") }
+      end
+
+      describe "gets the url from a cached file" do
+        before { instance.images = [test_file_stub] }
+
+        it { expect(images_urls[0]).to match(%r{uploads/tmp/[\d\-]+/test.jpg}) }
+      end
+
+      describe "gets the url from a cached file's version" do
+        before do
+          uploader.version(:thumb)
+          instance.images = [test_file_stub]
+        end
+
+        it { expect(instance.images_urls(:thumb)[0]).to match(%r{uploads/tmp/[\d\-]+/thumb_test.jpg}) }
+      end
+    end
+
+    describe '#images_cache' do
+      before do
+        allow(instance).to receive(:write_uploader)
+        allow(instance).to receive(:read_uploader).and_return(nil)
+      end
+
+      context "when nothing has been assigned" do
+        it { expect(instance.images_cache).to be_nil }
+      end
+
+      context "when a file has been stored" do
+        before do
+          instance.images = [test_file_stub]
+          instance.store_images!
+        end
+
+        it { expect(instance.images_cache).to be_nil }
+      end
+
+      context "when a file has been cached" do
+        let(:json_response) { JSON.parse(instance.images_cache) }
+
+        before do
+          instance.images = [test_file_stub, stub_file('old.jpeg')]
+        end
+
+        it { expect(json_response[0]).to match(%r(^[\d]+\-[\d]+\-[\d]{4}\-[\d]{4}/test\.jpg$)) }
+
+        it { expect(json_response[1]).to match(%r(^[\d]+\-[\d]+\-[\d]{4}\-[\d]{4}/old\.jpeg$)) }
+      end
+    end
+
+    describe '#images_cache=' do
+      before do
+        allow(instance).to receive(:write_uploader)
+        allow(instance).to receive(:read_uploader).and_return(nil)
+        CarrierWave::SanitizedFile.new(test_file_stub).copy_to(public_path('uploads/tmp/1369894322-123-0123-1234/test.jpg'))
+      end
+
+      before { instance.images_cache = images_cache }
+
+      context "does nothing when nil is assigned" do
+        let(:images_cache) { nil }
+
+        it { expect(instance.images).to be_empty }
+      end
+
+      context "does nothing when an empty string is assigned" do
+        let(:images_cache) { '' }
+
+        it { expect(instance.images).to be_empty }
+      end
+
+      context "retrieve from cache when a cache name is assigned" do
+        let(:images_cache) { ['1369894322-123-0123-1234/test.jpg'].to_json }
+
+        it { expect(instance.images[0].current_path).to eq(public_path('uploads/tmp/1369894322-123-0123-1234/test.jpg')) }
+      end
+
+      context "doesn't write over a previously assigned file" do
+        let(:images_cache) { ['1369894322-123-0123-1234/monkey.jpg'].to_json }
+
+        before { instance.images = [test_file_stub] }
+
+        it { expect(instance.images[0].current_path).to match(/test.jpg$/) }
+      end
+    end
+
+    describe "#remote_images_urls" do
+      subject { instance.remote_images_urls }
+
+      before { stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub)) }
+
+      context "returns nil" do
+        it { is_expected.to be_nil }
+      end
+
+      context "returns previously cached URL" do
+        before { instance.remote_images_urls = ["http://www.example.com/test.jpg"] }
+
+        it { is_expected.to eq(["http://www.example.com/test.jpg"]) }
+      end
+    end
+
+    describe "#remote_images_urls=" do
+      subject(:images) { instance.images }
+
+      before do
+        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+        instance.remote_images_urls = remote_images_url
+      end
+
+      context "does nothing when nil is assigned" do
+        let(:remote_images_url) { nil }
+
+        it { is_expected.to be_empty }
+      end
+
+      context "does nothing when an empty string is assigned" do
+        let(:remote_images_url) { '' }
+
+        it { is_expected.to be_empty }
+      end
+
+      context "retrieves from cache when a cache name is assigned" do
+        subject { images[0].current_path }
+
+        let(:remote_images_url) { ["http://www.example.com/test.jpg"] }
+
+        it { is_expected.to match(/test.jpg$/) }
+      end
+
+      context "writes over a previously assigned file" do
+        subject { images[0].current_path }
+
+        let(:remote_images_url) { ["http://www.example.com/test.jpg"] }
+
+        before do
+          instance.images = [stub_file("portrait.jpg")]
+          instance.remote_images_urls = remote_images_url
+        end
+
+        it { is_expected.to match(/test.jpg$/) }
+      end
+    end
+
+    describe '#store_images!' do
+      before do
+        allow(instance).to receive(:write_uploader)
+        allow(instance).to receive(:read_uploader).and_return(nil)
+      end
+
+      context "does nothing when no file has been uploaded" do
+        before { instance.store_images! }
+
+        it { expect(instance.images).to be_empty }
+      end
+
+      context "stores an assigned file" do
+        let(:images) { [test_file_stub] }
+
+        before do
+          instance.images = images
+          instance.store_images!
+        end
+
+        it { expect(instance.images[0].current_path).to eq(public_path("uploads/#{test_file_name}")) }
+      end
+
+      context "removes an uploaded file when remove_images is true" do
+        let(:images) { [test_file_stub] }
+
+        before do
+          instance.images = images
+          @image_path = instance.images[0].current_path.dup
+          instance.remove_images = true
+          instance.store_images!
+        end
+
+        it { expect(instance.images).to be_empty }
+
+        it { expect(File.exist?(@image_path)).to be_falsey }
+      end
+    end
+
+    describe '#remove_images!' do
+      before do
+        allow(instance).to receive(:write_uploader)
+        allow(instance).to receive(:read_uploader).and_return(nil)
+      end
+
+      context "does nothing when no file has been uploaded" do
+        before { instance.remove_images! }
+
+        it { expect(instance.images).to be_empty }
+      end
+
+      context "removes an uploaded file" do
+        before do
+          instance.images = [test_file_stub]
+          @image_path = instance.images[0].current_path
+          instance.remove_images!
+        end
+
+        it { expect(instance.images).to be_empty }
+
+        it { expect(File.exist?(@image_path)).to be_falsey }
+      end
+    end
+
+    describe '#remove_images' do
+      before { instance.remove_images = true }
+
+      it "stores a value" do
+        expect(instance.remove_images).to be_truthy
+      end
+    end
+
+    describe '#remove_images?' do
+      subject { instance.remove_images? }
+
+      let(:remove_images) { true }
+
+      before { instance.remove_images = remove_images }
+
+      it "when value is true" do
+        is_expected.to be_truthy
+      end
+
+      context "when value is false" do
+        let(:remove_images) { false }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context "when value is ''" do
+        let(:remove_images) { '' }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context "when value is 0" do
+        let(:remove_images) { "0" }
+
+        it { is_expected.to be_falsey }
+      end
+
+      context "when value is false" do
+        let(:remove_images) { 'false' }
+
+        it { is_expected.to be_falsey }
+      end
+    end
+
+    describe '#images_integrity_error' do
+      subject(:images_integrity_error) { instance.images_integrity_error }
+
+      describe "default behaviour" do
+        it { is_expected.to be_nil }
+      end
+
+      context "when a file is cached" do
+        before { instance.images = test_file_stub }
+
+        it { is_expected.to be_nil }
+      end
+
+      describe "when an integrity check fails" do
+        before do
+          uploader.class_eval do
+            def extension_whitelist
+              %w(txt)
+            end
+          end
+        end
+
+        context "when file is cached" do
+          before { instance.images = [test_file_stub] }
+
+          it { is_expected.to be_an_instance_of(CarrierWave::IntegrityError) }
+
+          it "has an error message" do
+            expect(images_integrity_error.message.lines.grep(/^You are not allowed to upload/)).to be_truthy
+          end
+        end
+
+        context "when file was downloaded" do
+          before do
+            stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+            instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]
+          end
+
+          it { is_expected.to be_an_instance_of(CarrierWave::IntegrityError) }
+
+          it "has an error message" do
+            expect(images_integrity_error.message.lines.grep(/^You are not allowed to upload/)).to be_truthy
+          end
+        end
+
+        context "when file is assigned and remote_iamges_url is blank" do
+          before do
+            instance.images = [test_file_stub]
+            instance.remote_images_urls = ""
+          end
+
+          it { is_expected.to be_an_instance_of(CarrierWave::IntegrityError) }
+
+          it "has an error message" do
+            expect(images_integrity_error.message.lines.grep(/^You are not allowed to upload/)).to be_truthy
+          end
+        end
+      end
+    end
+
+    describe '#images_processing_error' do
+      subject(:images_processing_error) { instance.images_processing_error }
+
+      describe "default behavior" do
+        it { is_expected.to be_nil }
+      end
+
+      context "when file is cached" do
+        before { instance.images = [test_file_stub] }
+
+        it { is_expected.to be_nil }
+      end
+
+      describe "when an processing error occurs" do
+        before do
+          uploader.class_eval do
+            process :monkey
+            def monkey
+              raise CarrierWave::ProcessingError, "Ohh noez!"
+            end
+          end
+        end
+
+        context "when file is cached" do
+          before { instance.images = [test_file_stub] }
+
+          it { is_expected.to be_an_instance_of(CarrierWave::ProcessingError) }
+        end
+
+        context "when file was downloaded" do
+          before do
+            stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+            instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]
+          end
+
+          it { is_expected.to be_an_instance_of(CarrierWave::ProcessingError) }
+        end
+      end
+    end
+
+    describe '#images_download_error' do
+      subject(:images_download_error) { instance.images_download_error }
+
+      before do
+        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+        stub_request(:get, "www.example.com/missing.jpg").to_return(status: 404)
+      end
+
+      describe "default behaviour" do
+        it { expect(instance.images_download_error).to be_nil }
+      end
+
+      context "when file download was successful" do
+        before { instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"] }
+
+        it { is_expected.to be_nil }
+      end
+
+      context "when file couldn't be found" do
+        before { instance.remote_images_urls = ["http://www.example.com/missing.jpg"] }
+
+        it { is_expected.to be_an_instance_of(CarrierWave::DownloadError) }
+      end
+    end
+
+    describe '#write_images_identifier' do
+      after { instance.write_images_identifier }
+
+      it "writes to the column" do
+        expect(instance).to receive(:write_uploader).with(:images, [test_file_name]).at_least(:once)
+        instance.images = [test_file_stub]
+        instance.write_images_identifier
+      end
+
+      context "when remove_images is true" do
+        before do
+          instance.images = [test_file_name]
+          instance.store_images!
+          instance.remove_images = true
+        end
+
+        it "removes from the column when remove_images is true" do
+          expect(instance).to receive(:write_uploader).with(:images, nil)
+        end
+      end
+    end
+
+    describe '#images_identifiers' do
+      it "returns the identifier from the mounted column" do
+        expect(instance).to receive(:read_uploader).with(:images).and_return(test_file_name)
+        expect(instance.images_identifiers).to eq([test_file_name])
+      end
+    end
+  end
+
+  describe '#mount_uploaders without an uploader' do
+    let(:klass) do
+      Class.new.tap do |k|
+        k.send(:extend, CarrierWave::Mount)
+        k.mount_uploaders(:images)
+      end
+    end
+
+    let(:instance) { klass.new }
+
+    describe '#images' do
+      before do
+        allow(instance).to receive(:read_uploader).and_return(test_file_name)
+      end
+
+      it "returns an instance of a subclass of CarrierWave::Uploader::Base" do
+        expect(instance.images[0]).to be_a(CarrierWave::Uploader::Base)
+      end
+
+      it "sets the path to the store dir" do
+        expect(instance.images[0].current_path).to eq(public_path("uploads/#{test_file_name}"))
+      end
+    end
+  end
+
+  describe '#mount_uploaders with a block' do
+    describe 'and no uploader given' do
+      subject(:last_image) { instance.images[0] }
+
+      let(:klass) do
+        Class.new do |k|
+          k.send(:extend, CarrierWave::Mount)
+          k.mount_uploaders(:images) do
+            def monkey
+              'blah'
+            end
+          end
+        end
+      end
+
+      before { instance.images = [test_file_stub] }
+
+      it "returns an instance of a subclass of CarrierWave::Uploader::Base" do
+        is_expected.to be_a(CarrierWave::Uploader::Base)
+      end
+
+      it "applies any custom modifications" do
+        expect(last_image.monkey).to eq("blah")
+      end
+    end
+
+    describe 'and an uploader given' do
+      let!(:uploader) do
+        Class.new(CarrierWave::Uploader::Base).tap do |u|
+          u.version :thumb do
+            version :mini
+            version :maxi
+          end
+        end
+      end
+
+      let(:klass) do
+        Class.new.tap do |k|
+          k.send(:extend, CarrierWave::Mount)
+          k.mount_uploaders(:images, uploader) do
+            def fish
+              'blub'
+            end
+          end
+        end
+      end
+
+      let(:first_image) { instance.images[0] }
+
+      before { instance.images = [test_file_stub] }
+
+      it "returns an instance of the uploader specified" do
+        expect(first_image).to be_a_kind_of(uploader)
+      end
+
+      it "applies any custom modifications to the instance" do
+        expect(first_image.fish).to eq("blub")
+      end
+
+      it "applies any custom modifications to all defined versions" do
+        expect(first_image.thumb.fish).to eq("blub")
+        expect(first_image.thumb.mini.fish).to eq("blub")
+        expect(first_image.thumb.maxi.fish).to eq("blub")
+      end
+
+      it "applies any custom modifications to the uploader class" do
+        expect(uploader.new).not_to respond_to(:fish)
+      end
+    end
+  end
+
+  describe '#mount_uploaders with :ignore_integrity_errors => false' do
+    let(:klass) do
+      Class.new.tap do |k|
+        k.send(:extend, CarrierWave::Mount)
+        k.mount_uploaders(:images, uploader, :ignore_integrity_errors => false)
+      end
+    end
+
+    let(:uploader) do
+      Class.new(CarrierWave::Uploader::Base).tap do |u|
+        u.class_eval do
+          def extension_whitelist
+            %w(txt)
+          end
+        end
+      end
+    end
+
+    context "when a cached image fails an integrity check" do
+      it { expect(running { instance.images = [test_file_stub] }).to raise_error(CarrierWave::IntegrityError) }
+    end
+
+    context "when a downloaded image fails an integity check" do
+      before do
+        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: test_file_stub)
+      end
+
+      it { expect(running {instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]}).to raise_error(CarrierWave::IntegrityError) }
+    end
+  end
+
+  describe '#mount_uploaders with :ignore_processing_errors => false' do
+    let(:klass) do
+      Class.new.tap do |k|
+        k.send(:extend, CarrierWave::Mount)
+        k.mount_uploaders(:images, uploader, :ignore_processing_errors => false)
+      end
+    end
+
+    let(:uploader) do
+      Class.new(CarrierWave::Uploader::Base).tap do |u|
+        u.class_eval do
+          process :monkey
+          def monkey
+            raise CarrierWave::ProcessingError, "Ohh noez!"
+          end
+        end
+      end
+    end
+
+    context "when a cached image fails an integrity check" do
+      it { expect(running { instance.images = [test_file_stub] }).to raise_error(CarrierWave::ProcessingError) }
+    end
+
+    context "when a downloaded image fails an integity check" do
+      before do
+        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: test_file_stub)
+      end
+
+      it { expect(running {instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]}).to raise_error(CarrierWave::ProcessingError) }
+    end
+  end
+
+  describe '#mount_uploaders with :ignore_download_errors => false' do
+    let(:klass) do
+      Class.new.tap do |k|
+        k.send(:extend, CarrierWave::Mount)
+        k.mount_uploaders(:images, uploader, ignore_download_errors: false)
+      end
+    end
+
+    let(:uploader) { Class.new(CarrierWave::Uploader::Base) }
+
+    before do
+      uploader.class_eval do
+        def download! uri
+          raise CarrierWave::DownloadError
+        end
+      end
+    end
+
+    context "when the image fail to be processed" do
+      it { expect(running {instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]}).to raise_error(CarrierWave::DownloadError) }
+    end
+  end
+
+  describe '#mount_uploaders with :mount_on => :monkey' do
+    let(:klass) do
+      Class.new.tap do |k|
+        k.send(:extend, CarrierWave::Mount)
+        k.mount_uploaders(:images, uploader, mount_on: :monkey)
+      end
+    end
+
+    let(:uploader) { Class.new(CarrierWave::Uploader::Base) }
+
+    describe '#images' do
+      context "when a value is store in the database" do
+        it "retrieves a file from the storage" do
+          expect(instance).to receive(:read_uploader).at_least(:once).with(:monkey).and_return([test_file_name])
+          expect(instance.images[0]).to be_an_instance_of(uploader)
+          expect(instance.images[0].current_path).to eq(public_path("uploads/#{test_file_name}"))
+        end
+      end
+    end
+
+    describe '#write_images_identifier' do
+      it "writes to the given column" do
+        expect(instance).to receive(:write_uploader).with(:monkey, [test_file_name])
+        instance.images = [test_file_stub]
+        instance.write_images_identifier
+      end
+
+      it "removes from the given column when remove_images is true" do
+        instance.images = [test_file_stub]
+        instance.store_images!
+        instance.remove_images = true
+        expect(instance).to receive(:write_uploader).with(:monkey, nil)
+        instance.write_images_identifier
+      end
+    end
+  end
+end