samlown-carrierwave 0.4.5

data/lib/carrierwave/uploader/versions.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Versions
+
+      depends_on CarrierWave::Uploader::Callbacks
+
+      setup do
+        after :cache, :cache_versions!
+        after :store, :store_versions!
+        after :remove, :remove_versions!
+        after :retrieve_from_cache, :retrieve_versions_from_cache!
+        after :retrieve_from_store, :retrieve_versions_from_store!
+      end
+
+      module ClassMethods
+
+        def version_names
+          @version_names ||= []
+        end
+
+        ##
+        # Adds a new version to this uploader
+        #
+        # === Parameters
+        #
+        # [name (#to_sym)] name of the version
+        # [&block (Proc)] a block to eval on this version of the uploader
+        #
+        def version(name, &block)
+          name = name.to_sym
+          unless versions[name]
+            versions[name] = Class.new(self)
+            versions[name].version_names.push(*version_names)
+            versions[name].version_names.push(name)
+            class_eval <<-RUBY
+              def #{name}
+                versions[:#{name}]
+              end
+            RUBY
+          end
+          versions[name].class_eval(&block) if block
+          versions[name]
+        end
+
+        ##
+        # === Returns
+        #
+        # [Hash{Symbol => Class}] a list of versions available for this uploader
+        #
+        def versions
+          @versions ||= {}
+        end
+
+      end # ClassMethods
+
+      ##
+      # Returns a hash mapping the name of each version of the uploader to an instance of it
+      #
+      # === Returns
+      #
+      # [Hash{Symbol => CarrierWave::Uploader}] a list of uploader instances
+      #
+      def versions
+        return @versions if @versions
+        @versions = {}
+        self.class.versions.each do |name, klass|
+          @versions[name] = klass.new(model, mounted_as)
+        end
+        @versions
+      end
+
+      ##
+      # === Returns
+      #
+      # [String] the name of this version of the uploader
+      #
+      def version_name
+        self.class.version_names.join('_').to_sym unless self.class.version_names.blank?
+      end
+
+      ##
+      # When given a version name as a parameter, will return the url for that version
+      # This also works with nested versions.
+      #
+      # === Example
+      #
+      #     my_uploader.url                 # => /path/to/my/uploader.gif
+      #     my_uploader.url(:thumb)         # => /path/to/my/thumb_uploader.gif
+      #     my_uploader.url(:thumb, :small) # => /path/to/my/thumb_small_uploader.gif
+      #
+      # === Parameters
+      #
+      # [*args (Symbol)] any number of versions
+      #
+      # === Returns
+      #
+      # [String] the location where this file is accessible via a url
+      #
+      def url(*args)
+        if(args.first)
+          raise ArgumentError, "Version #{args.first} doesn't exist!" if versions[args.first.to_sym].nil?
+          # recursively proxy to version
+          versions[args.first.to_sym].url(*args[1..-1])
+        else
+          super()
+        end
+      end
+
+    private
+
+      def full_filename(for_file)
+        [version_name, super(for_file)].compact.join('_')
+      end
+
+      def full_original_filename
+        [version_name, super].compact.join('_')
+      end
+
+      def cache_versions!(new_file)
+        versions.each do |name, v|
+          v.send(:cache_id=, cache_id)
+          v.cache!(new_file)
+        end
+      end
+
+      def store_versions!(new_file)
+        versions.each { |name, v| v.store!(new_file) }
+      end
+
+      def remove_versions!
+        versions.each { |name, v| v.remove! }
+      end
+
+      def retrieve_versions_from_cache!(cache_name)
+        versions.each { |name, v| v.retrieve_from_cache!(cache_name) }
+      end
+
+      def retrieve_versions_from_store!(identifier)
+        versions.each { |name, v| v.retrieve_from_store!(identifier) }
+      end
+
+    end # Versions
+  end # Uploader
+end # CarrierWave

data/merb_generators/uploader_generator.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Merb
+  module Generators
+    class UploaderGenerator < NamedGenerator
+
+      def self.source_root
+        File.join(File.dirname(__FILE__), '..', '..', 'rails_generators', 'uploader', 'templates')
+      end
+
+      first_argument :name, :required => true, :desc => "The name of this uploader"
+
+      template :uploader do |t|
+        t.source = 'uploader.rb'
+        t.destination = "app/uploaders/#{file_name}_uploader.rb"
+      end
+    end
+
+    add :uploader, UploaderGenerator
+
+  end
+end

data/rails_generators/uploader/USAGE

@@ -0,0 +1,2 @@
+Description:
+    Generates a skeleton for a new uploader.

data/rails_generators/uploader/templates/uploader.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+class <%= class_name %>Uploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or ImageScience support
+  #     include CarrierWave::RMagick
+  #     include CarrierWave::ImageScience
+
+  # Choose what kind of storage to use for this uploader
+  storage :file
+  #     storage :s3
+
+  # 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
+  #       "/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 :scale => [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_white_list
+  #       %w(jpg jpeg gif png)
+  #     end
+
+  # Override the filename of the uploaded files
+  #     def filename
+  #       "something.jpg" if original_filename
+  #     end
+
+end

data/rails_generators/uploader/uploader_generator.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+class UploaderGenerator < Rails::Generator::NamedBase
+
+  def manifest
+    record do |m|
+      m.directory 'app/uploaders'
+      m.template  'uploader.rb', "app/uploaders/#{name.underscore}_uploader.rb"
+    end
+  end
+
+  def class_name
+    name.camelize
+  end
+
+  protected
+
+  def banner
+    "Usage: #{$0} uploader UploaderName"
+  end
+end

data/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/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/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/spec/compatibility/paperclip_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'carrierwave/orm/activerecord'
+
+module Rails
+  def self.root
+    File.expand_path(File.join('..'), File.dirname(__FILE__))
+  end
+  def self.env
+    "test"
+  end
+end unless defined?(Rails)
+
+describe CarrierWave::Compatibility::Paperclip do
+
+  before do
+    @uploader_class = Class.new(CarrierWave::Uploader::Base) do
+      include CarrierWave::Compatibility::Paperclip
+    end
+    @model = mock('a model')
+    @model.stub!(:id).and_return(23)
+    @uploader = @uploader_class.new(@model, :monkey)
+  end
+  
+  after do
+    FileUtils.rm_rf(public_path)
+  end
+
+  describe '#store_path' do
+    it "should mimics paperclip default" do
+      @uploader.store_path("monkey.png").should == CarrierWave::Uploader::Base.root + "/system/monkeys/23/original/monkey.png"
+    end
+
+    it "should interpolate the root path" do
+      @uploader.stub!(:paperclip_path).and_return(":rails_root/foo/bar")
+      @uploader.store_path("monkey.png").should == Rails.root + "/foo/bar"
+    end
+
+    it "should interpolate the attachment" do
+      @uploader.stub!(:paperclip_path).and_return("/foo/:attachment/bar")
+      @uploader.store_path("monkey.png").should == "/foo/monkeys/bar"
+    end
+
+    it "should interpolate the id" do
+      @uploader.stub!(:paperclip_path).and_return("/foo/:id/bar")
+      @uploader.store_path("monkey.png").should == "/foo/23/bar"
+    end
+  end
+
+end

data/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/spec/fixtures/test.jpeg

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

data/spec/fixtures/test.jpg

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

data/spec/mount_spec.rb

@@ -0,0 +1,538 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe CarrierWave::Mount do
+  
+  after do
+    FileUtils.rm_rf(public_path)
+  end
+
+  describe '.mount_uploader' do
+    
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader)
+      @instance = @class.new
+    end
+
+    it "should maintain the ability to super" do
+      @class.class_eval do
+        def image_uploader
+          super
+        end
+
+        def image=(val)
+          super
+        end
+      end
+
+      @instance.image = stub_file('test.jpg')
+      @instance.image.should be_an_instance_of(@uploader)
+    end
+    
+    it "should inherit uploaders to subclasses" do
+      @subclass = Class.new(@class)
+      @subclass_instance = @subclass.new
+      @subclass_instance.image = stub_file('test.jpg')
+      @subclass_instance.image.should be_an_instance_of(@uploader)
+    end
+    
+    describe '#image' do
+      
+      it "should return a blank uploader when nothing has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).twice.and_return(nil)
+        @instance.image.should be_an_instance_of(@uploader)
+        @instance.image.should be_blank
+      end
+      
+      it "should return a blank uploader when an empty string has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).twice.and_return('')
+        @instance.image.should be_an_instance_of(@uploader)
+        @instance.image.should be_blank
+      end
+      
+      it "should retrieve a file from the storage if a value is stored in the database" do
+        @instance.should_receive(:read_uploader).with(:image).at_least(:once).and_return('test.jpg')
+        @instance.image.should be_an_instance_of(@uploader)
+      end
+      
+      it "should set the path to the store dir" do
+        @instance.should_receive(:read_uploader).with(:image).at_least(:once).and_return('test.jpg')
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+    
+    end
+    
+    describe '#image=' do
+      
+      it "should cache a file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image.should be_an_instance_of(@uploader)
+      end
+      
+      it "should copy a file into into the cache directory" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image.current_path.should =~ /^#{public_path('uploads/tmp')}/
+      end
+      
+      it "should do nothing when nil is assigned" do
+        @instance.should_not_receive(:write_uploader)
+        @instance.image = nil
+      end
+      
+      it "should do nothing when an empty string is assigned" do
+        @instance.should_not_receive(:write_uploader)
+        @instance.image = stub_file('test.jpg')
+      end
+
+      it "should fail silently if the image fails an integrity check" do
+        @uploader.class_eval do
+          def extension_white_list
+            %(txt)
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+        @instance.image.should be_blank
+      end
+      
+      it "should fail silently if the image fails to be processed" do
+        @uploader.class_eval do
+          process :monkey
+          def monkey
+            raise CarrierWave::ProcessingError, "Ohh noez!"
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+      end
+      
+    end
+
+    describe '#image?' do
+      
+      it "should be false when nothing has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return(nil)
+        @instance.image?.should be_false
+      end
+      
+      it "should be false when an empty string has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return('')
+        @instance.image?.should be_false
+      end
+
+      it "should be true when a file has been cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image?.should be_true
+      end
+    
+    end
+
+    describe '#image_url' do
+      
+      it "should return nil when nothing has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return(nil)
+        @instance.image_url.should be_nil
+      end
+      
+      it "should return nil when an empty string has been assigned" do
+        @instance.should_receive(:read_uploader).with(:image).and_return('')
+        @instance.image_url.should be_nil
+      end
+      
+      it "should get the url from a retrieved file" do
+        @instance.should_receive(:read_uploader).at_least(:once).with(:image).and_return('test.jpg')
+        @instance.image_url.should == '/uploads/test.jpg'
+      end
+
+      it "should get the url from a cached file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_url.should =~ %r{uploads/tmp/[\d\-]+/test.jpg}
+      end
+
+      it "should get the url from a cached file's version" do
+        @uploader.version(:thumb)
+        @instance.image = stub_file('test.jpg')
+        @instance.image_url(:thumb).should =~ %r{uploads/tmp/[\d\-]+/thumb_test.jpg}
+      end
+
+    end
+
+    describe '#image_cache' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+      end
+
+      it "should return nil when nothing has been assigned" do
+        @instance.image_cache.should be_nil
+      end
+
+      it "should be nil when a file has been stored" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image.store!
+        @instance.image_cache.should be_nil
+      end
+
+      it "should be the cache name when a file has been cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_cache.should =~ %r(^[\d]{8}\-[\d]{4}\-[\d]+\-[\d]{4}/test\.jpg$)
+      end
+
+    end
+    
+    describe '#image_cache=' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+        CarrierWave::SanitizedFile.new(file_path('test.jpg')).copy_to(public_path('uploads/tmp/19990512-1202-123-1234/test.jpg'))
+      end
+
+      it "should do nothing when nil is assigned" do
+        @instance.image_cache = nil
+        @instance.image.should be_blank
+      end
+
+      it "should do nothing when an empty string is assigned" do
+        @instance.image_cache = ''
+        @instance.image.should be_blank
+      end
+
+      it "retrieve from cache when a cache name is assigned" do
+        @instance.image_cache = '19990512-1202-123-1234/test.jpg'
+        @instance.image.current_path.should == public_path('uploads/tmp/19990512-1202-123-1234/test.jpg')
+      end
+
+      it "should not write over a previously assigned file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_cache = '19990512-1202-123-1234/monkey.jpg'
+        @instance.image.current_path.should =~ /test.jpg$/
+      end
+    end
+
+    describe '#remote_image_url' do
+      before do
+        response = mock('HTTP Response')
+        response.stub!(:body).and_return('Response Body')
+        Net::HTTP.stub!(:get_response).and_return(response)
+      end
+
+      it "should return nil" do
+        @instance.remote_image_url.should be_nil
+      end
+
+      it "should return previously cached URL" do
+        @instance.remote_image_url = 'http://www.example.com/funky/monkey.png'
+        @instance.remote_image_url.should == 'http://www.example.com/funky/monkey.png'
+      end
+    end
+
+    describe '#remote_image_url=' do
+      before do
+        response = mock('HTTP Response')
+        response.stub!(:body).and_return('Response Body')
+        Net::HTTP.stub!(:get_response).and_return(response)
+      end
+
+      it "should do nothing when nil is assigned" do
+        @instance.remote_image_url = nil
+        @instance.image.should be_blank
+      end
+
+      it "should do nothing when an empty string is assigned" do
+        @instance.remote_image_url = ''
+        @instance.image.should be_blank
+      end
+
+      it "retrieve from cache when a cache name is assigned" do
+        @instance.remote_image_url = 'http://www.example.com/funky/monkey.png'
+        @instance.image.current_path.should =~ /monkey.png$/
+      end
+
+      it "should not write over a previously assigned file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.remote_image_url = '19990512-1202-123-1234/monkey.jpg'
+        @instance.image.current_path.should =~ /test.jpg$/
+      end
+    end
+
+    describe '#store_image!' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+      end
+
+      it "should do nothing when no file has been uploaded" do
+        @instance.store_image!
+        @instance.image.should be_blank
+      end
+
+      it "store an assigned file" do
+        @instance.image = stub_file('test.jpg')
+        @instance.store_image!
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+
+      it "should remove an uploaded file when remove_image? returns true" do
+        @instance.image = stub_file('test.jpg')
+        path = @instance.image.current_path
+        @instance.remove_image = true
+        @instance.store_image!
+        @instance.image.should be_blank
+        File.exist?(path).should be_false
+      end
+    end
+
+    describe '#remove_image!' do
+
+      before do
+        @instance.stub!(:write_uploader)
+        @instance.stub!(:read_uploader).and_return(nil)
+      end
+
+      it "should do nothing when no file has been uploaded" do
+        @instance.remove_image!
+        @instance.image.should be_blank
+      end
+
+      it "should remove an uploaded file" do
+        @instance.image = stub_file('test.jpg')
+        path = @instance.image.current_path
+        @instance.remove_image!
+        @instance.image.should be_blank
+        File.exist?(path).should be_false
+      end
+    end
+
+    describe '#remove_image' do
+      
+      it "should store a value" do
+        @instance.remove_image = true
+        @instance.remove_image.should be_true
+      end
+      
+    end
+
+    describe '#remove_image?' do
+      
+      it "should be true when the value is truthy" do
+        @instance.remove_image = true
+        @instance.remove_image?.should be_true
+      end
+      
+      it "should be false when the value is falsey" do
+        @instance.remove_image = false
+        @instance.remove_image?.should be_false
+      end
+      
+      it "should be false when the value is ''" do
+        @instance.remove_image = ''
+        @instance.remove_image?.should be_false
+      end
+      
+      it "should be false when the value is '0'" do
+        @instance.remove_image = '0'
+        @instance.remove_image?.should be_false
+      end
+
+      it "should be false when the value is 'false'" do
+        @instance.remove_image = 'false'
+        @instance.remove_image?.should be_false
+      end
+      
+    end
+
+    describe '#image_integrity_error' do
+
+      it "should be nil by default" do
+        @instance.image_integrity_error.should be_nil
+      end
+
+      it "should be nil after a file is cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_integrity_error.should be_nil
+      end
+
+      it "should be an error instance after an integrity check has failed" do
+        @uploader.class_eval do
+          def extension_white_list
+            %(txt)
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+        @instance.image_integrity_error.should be_an_instance_of(CarrierWave::IntegrityError)
+      end
+    end
+    
+    describe '#image_processing_error' do
+
+      it "should be nil by default" do
+        @instance.image_processing_error.should be_nil
+      end
+
+      it "should be nil after a file is cached" do
+        @instance.image = stub_file('test.jpg')
+        @instance.image_processing_error.should be_nil
+      end
+
+      it "should be an error instance after an integrity check has failed" do
+        @uploader.class_eval do
+          process :monkey
+          def monkey
+            raise CarrierWave::ProcessingError, "Ohh noez!"
+          end
+        end
+        @instance.image = stub_file('test.jpg')
+        @instance.image_processing_error.should be_an_instance_of(CarrierWave::ProcessingError)
+      end
+    end
+
+    describe '#write_image_identifier' do
+      it "should write to the column" do
+        @instance.should_receive(:write_uploader).with(:image, "test.jpg")
+        @instance.image = stub_file('test.jpg')
+        @instance.write_image_identifier
+      end
+
+      it "should remove from the column when remove_image is true" do
+        @instance.image = stub_file('test.jpg')
+        @instance.store_image!
+        @instance.remove_image = true
+        @instance.should_receive(:write_uploader).with(:image, "")
+        @instance.write_image_identifier
+      end
+    end
+
+  end
+  
+  describe '#mount_uploader with a block' do
+   
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      @class.mount_uploader(:image) do
+        def monkey
+          'blah'
+        end
+      end
+      @instance = @class.new
+    end
+    
+    describe '#image' do
+      
+      before do
+        @instance.stub!(:read_uploader).and_return('test.jpg')
+      end
+      
+      it "should return an instance of a subclass of CarrierWave::Uploader::Base" do
+        @instance.image.should be_a(CarrierWave::Uploader::Base)
+      end
+      
+      it "should set the path to the store dir" do
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+    
+      it "should apply any custom modifications" do
+        @instance.image.monkey.should == "blah"
+      end
+    
+    end
+    
+  end
+  
+  describe '#mount_uploader with :ignore_integrity_errors => false' do
+   
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader, :ignore_integrity_errors => false)
+      @instance = @class.new
+    end
+
+    it "should raise an error if the image fails an integrity check" do
+      @uploader.class_eval do
+        def extension_white_list
+          %(txt)
+        end
+      end
+      running {
+        @instance.image = stub_file('test.jpg')
+      }.should raise_error(CarrierWave::IntegrityError)
+    end
+
+  end
+
+  describe '#mount_uploader with :ignore_processing_errors => false' do
+   
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+      
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader, :ignore_processing_errors => false)
+      @instance = @class.new
+    end
+
+    it "should raise an error if the image fails to be processed" do
+      @uploader.class_eval do
+        process :monkey
+        def monkey
+          raise CarrierWave::ProcessingError, "Ohh noez!"
+        end
+      end
+      running {
+        @instance.image = stub_file('test.jpg')
+      }.should raise_error(CarrierWave::ProcessingError)
+    end
+
+  end
+
+  describe '#mount_uploader with :mount_on => :monkey' do
+
+  
+    before do
+      @class = Class.new
+      @class.send(:extend, CarrierWave::Mount)
+
+      @uploader = Class.new(CarrierWave::Uploader::Base)
+
+      @class.mount_uploader(:image, @uploader, :mount_on => :monkey)
+      @instance = @class.new
+    end
+
+    describe '#image' do
+      it "should retrieve a file from the storage if a value is stored in the database" do
+        @instance.should_receive(:read_uploader).at_least(:once).with(:monkey).twice.and_return('test.jpg')
+        @instance.image.should be_an_instance_of(@uploader)
+        @instance.image.current_path.should == public_path('uploads/test.jpg')
+      end
+    end
+
+    describe '#write_image_identifier' do
+      it "should write to the given column" do
+        @instance.should_receive(:write_uploader).with(:monkey, "test.jpg")
+        @instance.image = stub_file('test.jpg')
+        @instance.write_image_identifier
+      end
+
+      it "should remove from the given column when remove_image is true" do
+        @instance.image = stub_file('test.jpg')
+        @instance.store_image!
+        @instance.remove_image = true
+        @instance.should_receive(:write_uploader).with(:monkey, "")
+        @instance.write_image_identifier
+      end
+    end
+  end
+
+end