carrierwave 2.2.5 → 3.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04ecbb3b2d0424203756bda1f73e89bdf32d52f3fbcda13b979e9904d1d4f2c9
-  data.tar.gz: e7474ccefff230df0f9d6564825c63acd3176c2a37e2a4b66a797a864d610f74
+  metadata.gz: cc579131ed1965aefce70fdce2c9342f576b2d8ef07afbfdeafac862f0b18bfa
+  data.tar.gz: 596d03d52c549e3e2a76f3857c1994d7e8eac60ac3262951232d0ee85137a553
 SHA512:
-  metadata.gz: 9a2cff0c002d2d31c1a61bf4d7158a4d648a88bb69843092130bfc48cf2026386becdc707e00f6eff379929ff88f7c20929fa67310e874fe3b4ad3197793b269
-  data.tar.gz: fe8c49e5858818fd2e8f3e271ba884a839d627aefe420f1c4e5d63c00601b4c2e71cb07cdb77ccf0758121173b932c4a12b95762b2b60ee6d0930c9a290f375a
+  metadata.gz: a2bfddc631da38614bd60be423afc39ee59a904898ad998c11f6934b8c4adc5de4c51ccdc284b70ada8403f5285e6650df936c1dfd4963067ff60fd985736c06
+  data.tar.gz: 997f8bf0b24e0327ec699246fe281f74d2d4dfc5c0e9086223da61a438d05cee0d436f23b24405d3e2866bc015e473302eab2bf5177a9f2891dbd188d95e1d9e

data/README.md

@@ -10,7 +10,7 @@ It works well with Rack based web applications, such as Ruby on Rails.
 
 ## Information
 
-* RDoc documentation [available on RubyDoc.info](http://rubydoc.info/gems/carrierwave/frames)
+* RDoc documentation [available on RubyDoc.info](https://rubydoc.info/gems/carrierwave)
 * Source code [available on GitHub](http://github.com/carrierwaveuploader/carrierwave)
 * More information, known limitations, and how-tos [available on the wiki](https://github.com/carrierwaveuploader/carrierwave/wiki)
 
@@ -30,13 +30,19 @@ $ gem install carrierwave
 In Rails, add it to your Gemfile:
 
 ```ruby
-gem 'carrierwave', '~> 2.0'
+gem 'carrierwave', '~> 3.0'
 ```
 
 Finally, restart the server to apply the changes.
 
-As of version 2.0, CarrierWave requires Rails 5.0 or higher and Ruby 2.2
-or higher. If you're on Rails 4, you should use 1.x.
+## Upgrading from 2.x or earlier
+
+CarrierWave 3.0 comes with a change in the way of handling the file extension on conversion. This results in following issues if you use `process convert: :format` to change the file format:
+
+- If you have it on the uploader itself (not within a version), the file extension of the cached file will change. That means if you serve both CarrierWave 2.x and 3.x simultaneously on the same workload (e.g. using blue-green deployment), a cache file stored by 2.x can't be retrieved by 3.x and vice versa.
+- If you have it within a version, the file extension of the stored file will change. You need to perform `#recreate_versions!` to make it usable again.
+
+To preserve the 2.x behavior, you can set `force_extension false` right after calling `process convert: :format`. See [#2659](https://github.com/carrierwaveuploader/carrierwave/pull/2659) for the detail.
 
 ## Getting Started
 
@@ -227,6 +233,20 @@ class MyUploader < CarrierWave::Uploader::Base
 end
 ```
 
+## Changing the filename
+
+To change the filename of uploaded files, you can override `#filename` method in the uploader.
+
+```ruby
+class MyUploader < CarrierWave::Uploader::Base
+  def filename
+    "image.#{file.extension}" # If you upload 'file.jpg', you'll get 'image.jpg'
+  end
+end
+```
+
+Some old documentations (like [this](https://stackoverflow.com/a/5865117)) may instruct you to safeguard the filename value with `if original_filename`, but it's no longer necessary with CarrierWave 3.0 or later.
+
 ## Securing uploads
 
 Certain files might be dangerous if uploaded to the wrong location, such as PHP
@@ -305,17 +325,8 @@ You no longer need to do this manually.
 
 ## Adding versions
 
-Often you'll want to add different versions of the same file. The classic example is image thumbnails. There is built in support for this*:
-
-*Note:* You must have Imagemagick installed to do image resizing.
-
-Some documentation refers to RMagick instead of MiniMagick but MiniMagick is recommended.
-
-To install Imagemagick on OSX with homebrew type the following:
-
-```
-$ brew install imagemagick
-```
+Often you'll want to add different versions of the same file. The classic example is generating image thumbnails while preserving the original file to be used for high-quality representation.
+In this section we'll explore how CarrierWave supports working with multiple versions. The image manipulation itself is covered in [another section](#manipulating-images).
 
 ```ruby
 class MyUploader < CarrierWave::Uploader::Base
@@ -351,17 +362,7 @@ uploader.thumb.url # => '/url/to/thumb_my_file.png'   # size: 200x200
 One important thing to remember is that process is called *before* versions are
 created. This can cut down on processing cost.
 
-### Processing Methods: mini_magick
-
-- `convert` - Changes the image encoding format to the given format, eg. jpg
-- `resize_to_limit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. Will only resize the image if it is larger than the specified dimensions. The resulting image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
-- `resize_to_fit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. The image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
-- `resize_to_fill` - Resize the image to fit within the specified dimensions while retaining the aspect ratio of the original image. If necessary, crop the image in the larger dimension. Optionally, a "gravity" may be specified, for example "Center", or "NorthEast".
-- `resize_and_pad` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. If necessary, will pad the remaining area with the given color, which defaults to transparent (for gif and png, white for jpeg). Optionally, a "gravity" may be specified, as above.
-
-See `carrierwave/processing/mini_magick.rb` for details.
-
-### conditional process
+### Conditional processing
 
 If you want to use conditional process, you can only use `if` statement.
 
@@ -445,8 +446,27 @@ class MyUploader < CarrierWave::Uploader::Base
 end
 ```
 
-The option `:from_version` uses the file cached in the `:thumb` version instead
-of the original version, potentially resulting in faster processing.
+### Customizing version filenames
+
+CarrierWave supports [customization of filename](#changing-the-filename) by overriding an uploader's
+#filename method, but this doesn't work for versions because of the limitation on how CarrierWave
+re-constructs the filename on retrieval of the stored file.
+Instead, you can override `#full_filename` with providing a version-aware name.
+
+```ruby
+class MyUploader < CarrierWave::Uploader::Base
+  version :thumb do
+    def full_filename(for_file)
+      'thumb.png'
+    end
+    process convert: 'png'
+  end
+end
+```
+
+Please note that `#full_filename` mustn't be constructed based on a dynamic value
+that can change from the time of store and time of retrieval, since it will result in
+being unable to retrieve a file previously stored.
 
 ## Making uploads work across form redisplays
 
@@ -531,6 +551,17 @@ failures automatically with attribute validation errors. If you aren't, or you
 disable CarrierWave's `validate_download` option, you'll need to handle those
 errors yourself.
 
+### Retry option for download from remote location
+If you want to retry the download from the Remote URL, enable the download_retry_count option, an error occurs during download, it will try to execute the specified number of times.
+This option is effective when the remote destination is unstable.
+
+```rb
+CarrierWave.configure do |config|
+  config.download_retry_count = 3 # Default 0
+  config.download_retry_wait_time = 3 # Default 5
+end
+```
+
 ## Providing a default URL
 
 In many cases, especially when working with images, it might be a good idea to
@@ -832,7 +863,6 @@ Please read the [fog-google README](https://github.com/fog/fog-google/blob/maste
 For Google Storage JSON API (recommended):
 ```ruby
 CarrierWave.configure do |config|
-    config.fog_provider = 'fog/google'
     config.fog_credentials = {
         provider:               'Google',
         google_project:         'my-project',
@@ -846,7 +876,6 @@ end
 For Google Storage XML API:
 ```ruby
 CarrierWave.configure do |config|
-    config.fog_provider = 'fog/google'
     config.fog_credentials = {
         provider:                         'Google',
         google_storage_access_key_id:     'xxxxxx',
@@ -905,67 +934,81 @@ CarrierWave.configure do |config|
 end
 ```
 
-## Using RMagick
+## Manipulating images
 
 If you're uploading images, you'll probably want to manipulate them in some way,
-you might want to create thumbnail images for example. CarrierWave comes with a
-small library to make manipulating images with RMagick easier, you'll need to
-include it in your Uploader:
+you might want to create thumbnail images for example.
 
-```ruby
-class AvatarUploader < CarrierWave::Uploader::Base
-  include CarrierWave::RMagick
-end
+### Using MiniMagick
+
+MiniMagick performs all the operations using the 'convert' CLI which is part of the standard ImageMagick kit.
+This allows you to have the power of ImageMagick without having to worry about installing
+all the RMagick libraries, it often results in higher memory footprint.
+
+See the MiniMagick site for more details:
+
+https://github.com/minimagick/minimagick
+
+To install Imagemagick on OSX with homebrew type the following:
+
+```
+$ brew install imagemagick
 ```
 
-The RMagick module gives you a few methods, like
-`CarrierWave::RMagick#resize_to_fill` which manipulate the image file in some
-way. You can set a `process` callback, which will call that method any time a
-file is uploaded.
-There is a demonstration of convert here.
-Convert will only work if the file has the same file extension, thus the use of the filename method.
+And the ImageMagick command line options for more for what's on offer:
+
+http://www.imagemagick.org/script/command-line-options.php
+
+Currently, the MiniMagick carrierwave processor provides exactly the same methods as
+for the RMagick processor.
 
 ```ruby
 class AvatarUploader < CarrierWave::Uploader::Base
-  include CarrierWave::RMagick
+  include CarrierWave::MiniMagick
 
   process resize_to_fill: [200, 200]
-  process convert: 'png'
-
-  def filename
-    super.chomp(File.extname(super)) + '.png' if original_filename.present?
-  end
 end
 ```
 
-Check out the manipulate! method, which makes it easy for you to write your own
-manipulation methods.
+#### List of available processing methods:
 
-## Using MiniMagick
-
-MiniMagick is similar to RMagick but performs all the operations using the 'convert'
-CLI which is part of the standard ImageMagick kit. This allows you to have the power
-of ImageMagick without having to worry about installing all the RMagick libraries.
+- `convert` - Changes the image encoding format to the given format(eg. jpg). This operation is treated specially to trigger the change of the file extension, so it matches with the format of the resulting file.
+- `resize_to_limit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. Will only resize the image if it is larger than the specified dimensions. The resulting image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
+- `resize_to_fit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. The image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
+- `resize_to_fill` - Resize the image to fit within the specified dimensions while retaining the aspect ratio of the original image. If necessary, crop the image in the larger dimension. Optionally, a "gravity" may be specified, for example "Center", or "NorthEast".
+- `resize_and_pad` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. If necessary, will pad the remaining area with the given color, which defaults to transparent (for gif and png, white for jpeg). Optionally, a "gravity" may be specified, as above.
 
-See the MiniMagick site for more details:
+See `carrierwave/processing/mini_magick.rb` for details.
 
-https://github.com/minimagick/minimagick
+### Using RMagick
 
-And the ImageMagick command line options for more for whats on offer:
+CarrierWave also comes with support for RMagick, a well-known image processing library.
+To use it, you'll need to include this in your Uploader:
 
-http://www.imagemagick.org/script/command-line-options.php
+```ruby
+class AvatarUploader < CarrierWave::Uploader::Base
+  include CarrierWave::RMagick
+end
+```
 
-Currently, the MiniMagick carrierwave processor provides exactly the same methods as
-for the RMagick processor.
+The RMagick module gives you a few methods, like
+`CarrierWave::RMagick#resize_to_fill` which manipulate the image file in some
+way. You can set a `process` callback, which will call that method any time a
+file is uploaded.
+There is a demonstration of convert here.
 
 ```ruby
 class AvatarUploader < CarrierWave::Uploader::Base
-  include CarrierWave::MiniMagick
+  include CarrierWave::RMagick
 
   process resize_to_fill: [200, 200]
+  process convert: 'png'
 end
 ```
 
+Check out the manipulate! method, which makes it easy for you to write your own
+manipulation methods.
+
 ## Migrating from Paperclip
 
 If you are using Paperclip, you can use the provided compatibility module:
@@ -1000,10 +1043,13 @@ errors:
     extension_denylist_error: "You are not allowed to upload %{extension} files, prohibited types: %{prohibited_types}"
     content_type_allowlist_error: "You are not allowed to upload %{content_type} files, allowed types: %{allowed_types}"
     content_type_denylist_error: "You are not allowed to upload %{content_type} files"
-    rmagick_processing_error: "Failed to manipulate with rmagick, maybe it is not an image?"
-    mini_magick_processing_error: "Failed to manipulate with MiniMagick, maybe it is not an image? Original Error: %{e}"
+    processing_error: "Failed to manipulate, maybe it is not an image?"
     min_size_error: "File size should be greater than %{min_size}"
     max_size_error: "File size should be less than %{max_size}"
+    min_width_error: "Image width should be greater than %{min_width}px"
+    max_width_error: "Image width should be less than %{max_width}px"
+    min_height_error: "Image height should be greater than %{min_height}px"
+    max_height_error: "Image height should be less than %{max_height}px"
 ```
 
 The [`carrierwave-i18n`](https://github.com/carrierwaveuploader/carrierwave-i18n)
@@ -1066,6 +1112,30 @@ class User
 end
 ```
 
+## Uploader Callbacks
+
+In addition to the ActiveRecord callbacks described above, uploaders also have callbacks.
+
+```ruby
+class MyUploader < ::CarrierWave::Uploader::Base
+  before :remove, :log_removal
+  private
+  def log_removal
+    ::Rails.logger.info(format('Deleting file on S3: %s', @file))
+  end
+end
+```
+
+Uploader callbacks can be `before` or `after` the following events:
+
+```
+cache
+process
+remove
+retrieve_from_cache
+store
+```
+
 ## Contributing to CarrierWave
 
 See [CONTRIBUTING.md](https://github.com/carrierwaveuploader/carrierwave/blob/master/CONTRIBUTING.md)
@@ -1074,7 +1144,7 @@ See [CONTRIBUTING.md](https://github.com/carrierwaveuploader/carrierwave/blob/ma
 
 The MIT License (MIT)
 
-Copyright (c) 2008-2015 Jonas Nicklas
+Copyright (c) 2008 Jonas Nicklas
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/carrierwave/compatibility/paperclip.rb

@@ -56,10 +56,11 @@ module CarrierWave
         :basename     => lambda{|u, f| u.filename.gsub(/#{File.extname(u.filename)}$/, "") },
         :extension    => lambda{|u, d| File.extname(u.filename).gsub(/^\.+/, "")},
         :class        => lambda{|u, f| u.model.class.name.underscore.pluralize}
-      }
+      }.freeze
 
       included do
         attr_accessor :filename
+
         class_attribute :mappings
         self.mappings ||= DEFAULT_MAPPINGS.dup
       end
@@ -92,7 +93,8 @@ module CarrierWave
         end
       end
 
-      private
+    private
+
       def interpolate_paperclip_path(path)
         mappings.each_pair.inject(path) do |agg, pair|
           agg.gsub(":#{pair[0]}") { pair[1].call(self, self.paperclip_style).to_s }

data/lib/carrierwave/downloader/base.rb

@@ -6,6 +6,8 @@ require 'carrierwave/downloader/remote_file'
 module CarrierWave
   module Downloader
     class Base
+      include CarrierWave::Utilities::Uri
+
       attr_reader :uploader
 
       def initialize(uploader)
@@ -21,6 +23,7 @@ module CarrierWave
       # [remote_headers (Hash)] Request headers
       #
       def download(url, remote_headers = {})
+        @current_download_retry_count = 0
         headers = remote_headers.
           reverse_merge('User-Agent' => "CarrierWave/#{CarrierWave::VERSION}")
         uri = process_uri(url.to_s)
@@ -42,7 +45,13 @@ module CarrierWave
             response.value
           end
         rescue StandardError => e
-          raise CarrierWave::DownloadError, "could not download file: #{e.message}"
+          if @current_download_retry_count < @uploader.download_retry_count
+            @current_download_retry_count += 1
+            sleep @uploader.download_retry_wait_time
+            retry
+          else
+            raise CarrierWave::DownloadError, "could not download file: #{e.message}"
+          end
         end
         CarrierWave::Downloader::RemoteFile.new(response)
       end
@@ -54,17 +63,16 @@ module CarrierWave
       #
       # [url (String)] The URL where the remote file is stored
       #
-      def process_uri(uri)
-        uri_parts = uri.split('?')
-        encoded_uri = Addressable::URI.parse(uri_parts.shift).normalize.to_s
-        query = uri_parts.any? ? "?#{uri_parts.join('?')}" : ''
-        begin
-          URI.parse("#{encoded_uri}#{query}")
-        rescue URI::InvalidURIError
-          URI.parse("#{encoded_uri}#{URI::DEFAULT_PARSER.escape(query)}")
-        end
+      def process_uri(source)
+        uri = Addressable::URI.parse(source)
+        uri.host = uri.normalized_host
+        # Perform decode first, as the path is likely to be already encoded
+        uri.path = encode_path(decode_uri(uri.path)) if uri.path =~ CarrierWave::Utilities::Uri::PATH_UNSAFE
+        uri.query = encode_non_ascii(uri.query) if uri.query
+        uri.fragment = encode_non_ascii(uri.fragment) if uri.fragment
+        URI.parse(uri.to_s)
       rescue URI::InvalidURIError, Addressable::URI::InvalidURIError
-        raise CarrierWave::DownloadError, "couldn't parse URL: #{uri}"
+        raise CarrierWave::DownloadError, "couldn't parse URL: #{source}"
       end
 
       ##

data/lib/carrierwave/downloader/remote_file.rb

@@ -8,7 +8,10 @@ module CarrierWave
         when String
           @file = StringIO.new(file)
         when Net::HTTPResponse
-          @file = StringIO.new(file.body)
+          body = file.body
+          raise CarrierWave::DownloadError, 'could not download file: No Content' if body.nil?
+
+          @file = StringIO.new(body)
           @content_type = file.content_type
           @headers = file
           @uri = file.uri
@@ -30,18 +33,15 @@ module CarrierWave
 
       def original_filename
         filename = filename_from_header || filename_from_uri
-        mime_type = MiniMime.lookup_by_content_type(content_type)
+        mime_type = Marcel::TYPES[content_type]
         unless File.extname(filename).present? || mime_type.blank?
-          filename = "#{filename}.#{mime_type.extension}"
+          extension = mime_type[0].first
+          filename = "#{filename}.#{extension}"
         end
         filename
       end
 
-      def respond_to?(*args)
-        super || file.respond_to?(*args)
-      end
-
-      private
+    private
 
       def filename_from_header
         return nil unless headers['content-disposition']
@@ -59,7 +59,10 @@ module CarrierWave
       def method_missing(*args, &block)
         file.send(*args, &block)
       end
+
+      def respond_to_missing?(*args)
+        super || file.respond_to?(*args)
+      end
     end
   end
 end
-

data/lib/carrierwave/locale/en.yml

@@ -8,8 +8,10 @@ en:
       extension_denylist_error: "You are not allowed to upload %{extension} files, prohibited types: %{prohibited_types}"
       content_type_allowlist_error: "You are not allowed to upload %{content_type} files, allowed types: %{allowed_types}"
       content_type_denylist_error: "You are not allowed to upload %{content_type} files"
-      rmagick_processing_error: "Failed to manipulate with rmagick, maybe it is not an image?"
-      mini_magick_processing_error: "Failed to manipulate with MiniMagick, maybe it is not an image? Original Error: %{e}"
-      vips_processing_error: "Failed to manipulate with vips, maybe it is not an image? Original Error: %{e}"
+      processing_error: "Failed to manipulate, maybe it is not an image?"
       min_size_error: "File size should be greater than %{min_size}"
       max_size_error: "File size should be less than %{max_size}"
+      min_width_error: "Image width should be greater than %{min_width}px"
+      max_width_error: "Image width should be less than %{max_width}px"
+      min_height_error: "Image height should be greater than %{min_height}px"
+      max_height_error: "Image height should be less than %{max_height}px"

data/lib/carrierwave/mount.rb

@@ -132,7 +132,7 @@ module CarrierWave
     #     end
     #
     def mount_uploader(column, uploader=nil, options={}, &block)
-      mount_base(column, uploader, options, &block)
+      mount_base(column, uploader, options.merge(multiple: false), &block)
 
       mod = Module.new
       include mod
@@ -163,21 +163,13 @@ module CarrierWave
         end
 
         def remote_#{column}_url=(url)
-          _mounter(:#{column}).remote_urls = [url]
+          _mounter(:#{column}).remote_urls = url
         end
 
         def remote_#{column}_request_header=(header)
           _mounter(:#{column}).remote_request_headers = [header]
         end
 
-        def write_#{column}_identifier
-          return if frozen?
-          mounter = _mounter(:#{column})
-
-          mounter.clear! if mounter.remove?
-          write_uploader(mounter.serialization_column, mounter.identifiers.first)
-        end
-
         def #{column}_identifier
           _mounter(:#{column}).read_identifiers[0]
         end
@@ -193,16 +185,6 @@ module CarrierWave
         def #{column}_download_error
           #{column}_download_errors.last
         end
-
-        def store_previous_changes_for_#{column}
-          attribute_changes = ::ActiveRecord.version.to_s.to_f >= 5.1 ? saved_changes : changes
-          @_previous_changes_for_#{column} = attribute_changes[_mounter(:#{column}).serialization_column]
-        end
-
-        def remove_previously_stored_#{column}
-          before, after = @_previous_changes_for_#{column}
-          _mounter(:#{column}).remove_previous([before], [after])
-        end
       RUBY
     end
 
@@ -295,7 +277,7 @@ module CarrierWave
     #     end
     #
     def mount_uploaders(column, uploader=nil, options={}, &block)
-      mount_base(column, uploader, options, &block)
+      mount_base(column, uploader, options.merge(multiple: true), &block)
 
       mod = Module.new
       include mod
@@ -334,35 +316,18 @@ module CarrierWave
           _mounter(:#{column}).remote_request_headers = headers
         end
 
-        def write_#{column}_identifier
-          return if frozen?
-          mounter = _mounter(:#{column})
-
-          mounter.clear! if mounter.remove?
-          write_uploader(mounter.serialization_column, mounter.identifiers.presence)
-        end
-
         def #{column}_identifiers
           _mounter(:#{column}).read_identifiers
         end
-
-        def store_previous_changes_for_#{column}
-          attribute_changes = ::ActiveRecord.version.to_s.to_f >= 5.1 ? saved_changes : changes
-          @_previous_changes_for_#{column} = attribute_changes[_mounter(:#{column}).serialization_column]
-        end
-
-        def remove_previously_stored_#{column}
-          _mounter(:#{column}).remove_previous(*@_previous_changes_for_#{column})
-        end
       RUBY
     end
 
-    private
+  private
 
     def mount_base(column, uploader=nil, options={}, &block)
       include CarrierWave::Mount::Extension
 
-      uploader = build_uploader(uploader, &block)
+      uploader = build_uploader(uploader, column, &block)
       uploaders[column.to_sym] = uploader
       uploader_options[column.to_sym] = options
 
@@ -387,6 +352,8 @@ module CarrierWave
 
         def remove_#{column}!
           _mounter(:#{column}).remove!
+          self.remove_#{column} = true
+          write_#{column}_identifier
         end
 
         def remove_#{column}=(value)
@@ -413,22 +380,36 @@ module CarrierWave
           _mounter(:#{column}).download_errors
         end
 
+        def write_#{column}_identifier
+          _mounter(:#{column}).write_identifier
+        end
+
         def mark_remove_#{column}_false
           _mounter(:#{column}).remove = false
         end
+
+        def reset_previous_changes_for_#{column}
+          _mounter(:#{column}).reset_changes!
+        end
+
+        def remove_previously_stored_#{column}
+          _mounter(:#{column}).remove_previous
+        end
+
+        def remove_rolled_back_#{column}
+          _mounter(:#{column}).remove_added
+        end
       RUBY
     end
 
-    def build_uploader(uploader, &block)
-      return uploader if uploader && !block_given?
+    def build_uploader(uploader, column, &block)
+      uploader ||= CarrierWave::Uploader::Base
+      return uploader unless block_given?
 
-      uploader = Class.new(uploader || CarrierWave::Uploader::Base)
-      const_set("Uploader#{uploader.object_id}".tr('-', '_'), uploader)
+      uploader = Class.new(uploader)
+      const_set("CarrierWave#{column.to_s.camelize}Uploader", uploader)
 
-      if block_given?
-        uploader.class_eval(&block)
-        uploader.recursively_apply_block_to_versions(&block)
-      end
+      uploader.class_eval(&block)
 
       uploader
     end
@@ -447,11 +428,16 @@ module CarrierWave
 
     private
 
+      def initialize_dup(other)
+        @_mounters = @_mounters.dup
+        super
+      end
+
       def _mounter(column)
         # We cannot memoize in frozen objects :(
-        return Mounter.new(self, column) if frozen?
+        return Mounter.build(self, column) if frozen?
         @_mounters ||= {}
-        @_mounters[column] ||= Mounter.new(self, column)
+        @_mounters[column] ||= Mounter.build(self, column)
       end
 
     end # Extension