jnicklas-carrierwave 0.2.2 → 0.2.3

data/README.rdoc

@@ -36,9 +36,7 @@ this should give you a file in:
 
 Check out this file for some hints on how you can customize your uploader. It should look something like this:
 
-    class AvatarUploader
-      include CarrierWave::Uploader
-
+    class AvatarUploader < CarrierWave::Uploader::Base
       storage :file
     end
 
@@ -97,9 +95,7 @@ Now you can cache files by assigning them to the attribute, they will automatica
 
 In order to change where uploaded files are put, just override the +store_dir+ method:
 
-    class MyUploader
-      include CarrierWave::Uploader
-
+    class MyUploader < CarrierWave::Uploader::Base
       def store_dir
         'public/my/upload/directory'
       end
@@ -111,10 +107,9 @@ This works for the file storage as well as Amazon S3.
 
 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:
 
-    class MyUploader
-      include CarrierWave::Uploader
+    class MyUploader < CarrierWave::Uploader::Base
       include CarrierWave::RMagick
-      
+
       process :resize => [800, 800]
 
       version :thumb do
@@ -135,8 +130,7 @@ One important thing to remember is that process is called *before* versions are
 
 It is possible to nest versions within versions:
 
-    class MyUploader
-      include CarrierWave::Uploader
+    class MyUploader < CarrierWave::Uploader::Base
 
       version :animal do
         version :human
@@ -174,6 +168,16 @@ in the case of images, a small thumbnail would be a good indicator:
 
 NOTE: this feature currently requires write access to your filesystem. If write access is unavailable (e.g. Heroku) you will not be able to upload files. You can prevent CarrierWave from writing to the file system by setting `CarrierWave.config[:cache_to_cache_dir] = false`. This will however break redisplays of forms.
 
+== Providing a default path
+
+In many cases, especially when working with images, it might be a good idea to provide a default path, a fallback in case no file has been uploaded. You can do this easily by overriding the +default_path+ method in your uploader:
+
+    class MyUploader < CarrierWave::Uploader::Base
+      def default_path
+        "images/fallback/" + [version_name, "default.png"].compact.join('_')
+      end
+    end
+
 == Using Amazon S3
 
 You'll need to configure a bucket, access id and secret key like this:
@@ -186,9 +190,7 @@ Do this in an initializer in Rails, and in a +before_app_loads+ block in Merb.
 
 And then in your uploader, set the storage to :s3
 
-    class AvatarUploader
-      include CarrierWave::Uploader
-
+    class AvatarUploader < 
       storage :s3
     end
 
@@ -198,15 +200,13 @@ That's it! You can still use the +CarrierWave::Uploader#url+ method to return th
 
 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:
 
-    class AvatarUploader
-      include CarrierWave::Uploader
+    class AvatarUploader < CarrierWave::Uploader::Base
       include CarrierWave::RMagick
     end
 
 The RMagick module gives you a few methods, like +CarrierWave::RMagick#crop_resized+ 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.
 
-    class AvatarUploader
-      include CarrierWave::Uploader
+    class AvatarUploader < CarrierWave::Uploader::Base
       include CarrierWave::RMagick
       
       process :crop_resized => [200, 200]
@@ -223,13 +223,28 @@ Check out the manipulate! method, which makes it easy for you to write your own
 
 ImageScience works the same way as RMagick.
 
-    class AvatarUploader
-      include CarrierWave::Uploader
+    class AvatarUploader < CarrierWave::Uploader::Base
       include CarrierWave::ImageScience
       
       process :crop_resized => [200, 200]
     end
 
+== Migrating
+
+If you are using Paperclip, you can use the provided compatibility module:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include CarrierWave::Compatibility::Paperclip
+    end
+
+See the documentation for +Paperclip::Compatibility::Paperclip+ for more detaills.
+
+Be sure to use mount_on to specify the correct column:
+
+    mount_uploader :avatar, AvatarUploader, :mount_on => :avatar_file_name
+
+Unfortunately AttachmentFoo differs too much in philosophy for there to be a sensible compatibility mode. Patches for migrating from other solutions will be happily accepted.
+
 == Documentation
 
 Full rdoc documentation is {available at Rubyforge}[http://carrierwave.rubyforge.org/].

data/Rakefile

@@ -9,7 +9,7 @@ require 'spec/rake/spectask'
 require 'cucumber/rake/task'
 
 NAME = "carrierwave"
-GEM_VERSION = "0.2.2"
+GEM_VERSION = "0.2.3"
 AUTHOR = "Jonas Nicklas"
 EMAIL = "jonas.nicklas@gmail.com"
 HOMEPAGE = "http://www.example.com"

data/lib/carrierwave/compatibility/paperclip.rb

@@ -0,0 +1,91 @@
+# This file contains code taken from Paperclip
+# 
+# LICENSE
+# 
+# The MIT License
+# 
+# Copyright (c) 2008 Jon Yurek and thoughtbot, inc.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module CarrierWave
+  module Compatibility
+
+    ##
+    # Mix this module into an Uploader to make it mimic Paperclip's storage paths
+    # This will make your Uploader use the same default storage path as paperclip
+    # does. If you need to override it, you can override the +paperclip_path+ method
+    # and provide a Paperclip style path:
+    #
+    #     class MyUploader < CarrierWave::Uploader::Base
+    #       include CarrierWave::Compatibility::Paperclip
+    #       
+    #       def paperclip_path
+    #         ":rails_root/public/uploads/:id/:attachment/:style_:basename.:extension"
+    #       end
+    #     end
+    #
+    module Paperclip
+
+      def store_path(for_file=filename)
+        path = paperclip_path
+        path ||= File.join(*[store_dir, paperclip_style.to_s, for_file].compact)
+        interpolate_paperclip_path(path, for_file)
+      end
+
+      def store_dir
+        ":rails_root/public/system/:attachment/:id"
+      end
+
+      def paperclip_default_style
+        :original
+      end
+
+      def paperclip_path
+      end
+
+      def paperclip_style
+        version_name || paperclip_default_style
+      end
+
+    private
+
+      def interpolate_paperclip_path(path, filename)
+        mappings.inject(path) do |agg, pair|
+          agg.gsub(":#{pair[0]}", pair[1].call(self, filename).to_s)
+        end
+      end
+
+      def mappings
+        {
+          :rails_root   => lambda{|u, f| CarrierWave.config[:root] },
+          :rails_env    => lambda{|u, f| CarrierWave.config[:env] },
+          :class        => lambda{|u, f| u.model.class.name.underscore.pluralize},
+          :id           => lambda{|u, f| u.model.id },
+          :id_partition => lambda{|u, f| ("%09d" % u.model.id).scan(/\d{3}/).join("/")},
+          :attachment   => lambda{|u, f| u.mounted_as.to_s.downcase.pluralize },
+          :style        => lambda{|u, f| u.paperclip_style },
+          :basename     => lambda{|u, f| f.gsub(/#{File.extname(f)}$/, "") },
+          :extension    => lambda{|u, f| File.extname(f).gsub(/^\.+/, "")}
+        }
+      end
+
+    end # Paperclip
+  end # Compatibility
+end # CarrierWave

data/lib/carrierwave/core_ext/inheritable_attributes.rb

@@ -0,0 +1,102 @@
+# Stolen from Rails 3
+
+# Copyright (c) 2005-2009 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Retain for backward compatibility.  Methods are now included in Class.
+class Class
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def extlib_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def extlib_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def extlib_inheritable_accessor(*syms)
+    extlib_inheritable_reader(*syms)
+    extlib_inheritable_writer(*syms)
+  end
+end

data/lib/carrierwave/core_ext/module_setup.rb

@@ -0,0 +1,49 @@
+# Stolen from Rails 3
+
+# Copyright (c) 2005-2009 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class Module
+  attr_accessor :_setup_block
+  attr_accessor :_dependencies
+  
+  def setup(&blk)
+    @_setup_block = blk
+  end
+  
+  def use(mod)
+    return if self < mod
+    
+    (mod._dependencies || []).each do |dep|
+      use dep
+    end
+    # raise "Circular dependencies" if self < mod
+    include mod
+    extend mod.const_get("ClassMethods") if mod.const_defined?("ClassMethods")
+    class_eval(&mod._setup_block) if mod._setup_block
+  end
+  
+  def depends_on(mod)
+    return if self < mod
+    @_dependencies ||= []
+    @_dependencies << mod
+  end
+end

data/lib/carrierwave/mount.rb

@@ -70,6 +70,7 @@ module CarrierWave
     # [remove_image?]           Whether the file should be removed when store_image! is called.
     #
     # [store_image!]            Stores a file that has been assigned with +image=+
+    # [remove_image!]           Removes the uploaded file from the filesystem.
     #
     # [image_integrity_error]   Returns an error object if the last file to be assigned caused an integrty error
     # [image_processing_error]  Returns an error object if the last file to be assigned caused a processing error
@@ -115,9 +116,7 @@ module CarrierWave
     #
     def mount_uploader(column, uploader=nil, options={}, &block)
       unless uploader
-        uploader = Class.new do
-          include CarrierWave::Uploader
-        end
+        uploader = Class.new(CarrierWave::Uploader::Base)
         uploader.class_eval(&block)
       end
 
@@ -127,58 +126,68 @@ module CarrierWave
       include CarrierWave::Mount::Extension
 
       class_eval <<-RUBY, __FILE__, __LINE__+1
-        def #{column}_uploader                            # def image_uploader
-          _uploader_get(:#{column})                       #   _uploader_get(:image)
-        end                                               # end
-                                                          #
-        def #{column}_uploader=(uploader)                 # def image_uploader=(uploader)
-          _uploader_set(:#{column}, uploader)             #   _uploader_set(:image, uploader)
-        end                                               # end
-                                                          #
-        def #{column}_url(*args)                          # def image_url(*args)
-          _uploader_get_url(:#{column}, *args)            #   _uploader_get_url(:image, *args)
-        end                                               # end
-                                                          #
-        def #{column}                                     # def image
-          _uploader_get_column(:#{column})                #   _uploader_get_column(:image)
-        end                                               # end
-                                                          #
-        def #{column}=(new_file)                          # def image=(new_file)
-          _uploader_set_column(:#{column}, new_file)      #   _uploader_set_column(:image, new_file)
-        end                                               # end
-                                                          #
-        def #{column}_cache                               # def image_cache
-          _uploader_get_cache(:#{column})                 #   _uploader_get_cache(:image)
-        end                                               # end
-                                                          #
-        def #{column}_cache=(cache_name)                  # def image_cache=(cache_name)
-          _uploader_set_cache(:#{column}, cache_name)     #   _uploader_set_cache(:image, cache_name)
-        end                                               # end
-                                                          #
-        def remove_#{column}                              # def remove_image
-          _uploader_remove[:#{column}]                    #   _uploader_remove[:image]
-        end                                               # end
-                                                          #
-        def remove_#{column}=(value)                      # def remove_image=(value)
-          _uploader_remove[:#{column}] = value            #   _uploader_remove[:image] = value
-        end                                               # end
-                                                          #
-        def remove_#{column}?                             # def remove_image?
-          _uploader_remove?(:#{column})                   #   _uploader_remove?(:image)
-        end                                               # end
-                                                          #
-        def store_#{column}!                              # def store_image!
-          _uploader_store!(:#{column})                    #   _uploader_store!(:image)
-        end                                               # end
-                                                          #
-        def #{column}_integrity_error                     # def image_integrity_error
-          _uploader_integrity_errors[:#{column}]          #   _uploader_integrity_errors[:image]
-        end                                               # end
-                                                          #
-        def #{column}_processing_error                    # def image_processing_error
-          _uploader_processing_errors[:#{column}]         #   _uploader_processing_errors[:image]
-        end                                               # end
+
+        def #{column}
+          _mounter(:#{column}).uploader
+        end
+
+        def #{column}=(new_file)
+          _mounter(:#{column}).cache(new_file)
+        end
+
+        def #{column}?
+          !_mounter(:#{column}).blank?
+        end
+
+        def #{column}_url(*args)
+          _mounter(:#{column}).url(*args)
+        end
+
+        def #{column}_uploader
+          _mounter(:#{column}).uploader
+        end
+
+        def #{column}_uploader=(uploader)
+          _mounter(:#{column}).uploader = uploader
+        end
+
+        def #{column}_cache
+          _mounter(:#{column}).cache_name
+        end
+
+        def #{column}_cache=(cache_name)
+          _mounter(:#{column}).cache_name = cache_name
+        end
+
+        def remove_#{column}
+          _mounter(:#{column}).remove
+        end
+
+        def remove_#{column}!
+          _mounter(:#{column}).remove!
+        end
+
+        def remove_#{column}=(value)
+          _mounter(:#{column}).remove = value
+        end
+
+        def remove_#{column}?
+          _mounter(:#{column}).remove?
+        end
+
+        def store_#{column}!
+          _mounter(:#{column}).store!
+        end
+
+        def #{column}_integrity_error
+          _mounter(:#{column}).integrity_error
+        end
+
+        def #{column}_processing_error
+          _mounter(:#{column}).processing_error
+        end
       RUBY
+
     end
 
     module Extension
@@ -195,85 +204,92 @@ module CarrierWave
 
     private
 
-      def _uploader_get(column)
-        @_uploaders ||= {}
-        @_uploaders[column] ||= self.class.uploaders[column].new(self, column)
+      def _mounter(column)
+        @_mounters ||= {}
+        @_mounters[column] ||= Mounter.new(self, column)
       end
 
-      def _uploader_set(column, uploader)
-        @_uploaders ||= {}
-        @_uploaders[column] = uploader
-      end
+    end # Extension
 
-      def _uploader_options(column)
-        self.class.uploader_options[column]
-      end
+    # this is an internal class, used by CarrierWave::Mount so that
+    # we don't pollute the model with a lot of methods.
+    class Mounter #:nodoc:
+
+      attr_reader :column, :record, :options
 
-      def _uploader_get_column(column)
-        return _uploader_get(column) unless _uploader_get(column).blank?
+      attr_accessor :uploader, :integrity_error, :processing_error, :remove
 
-        identifier = read_uploader(_uploader_options(column)[:mount_on] || column)
+      def initialize(record, column, options={})
+        @record = record
+        @column = column
+        @options = record.class.uploader_options[column]
+      end
 
-        unless identifier.blank?
-          _uploader_get(column).retrieve_from_store!(identifier)
-          _uploader_get(column)
+      def uploader
+        @uploader ||= record.class.uploaders[column].new(record, column)
+        if @uploader.blank?
+          identifier = record.read_uploader(serialization_column)
+          @uploader.retrieve_from_store!(identifier) unless identifier.blank?
         end
+        return @uploader
       end
 
-      def _uploader_set_column(column, new_file)
-        _uploader_get(column).cache!(new_file)
-        _uploader_integrity_errors[column] = nil
-        _uploader_processing_errors[column] = nil
+      def cache(new_file)
+        uploader.cache!(new_file)
+        self.integrity_error = nil
+        self.processing_error = nil
       rescue CarrierWave::IntegrityError => e
-        _uploader_integrity_errors[column] = e
-        raise e unless _uploader_options(column)[:ignore_integrity_errors]
+        self.integrity_error = e
+        raise e unless options[:ignore_integrity_errors]
       rescue CarrierWave::ProcessingError => e
-        _uploader_processing_errors[column] = e
-        raise e unless _uploader_options(column)[:ignore_processing_errors]
-      end
-
-      def _uploader_get_url(column, *args)
-        _uploader_get_column(column)
-        _uploader_get(column).url(*args)
+        self.processing_error = e
+        raise e unless options[:ignore_processing_errors]
       end
 
-      def _uploader_get_cache(column)
-        _uploader_get(column).cache_name
+      def cache_name
+        uploader.cache_name
       end
 
-      def _uploader_set_cache(column, cache_name)
-        _uploader_get(column).retrieve_from_cache(cache_name) unless cache_name.blank?
+      def cache_name=(cache_name)
+        uploader.retrieve_from_cache!(cache_name) unless uploader.cached?
+      rescue CarrierWave::InvalidParameter
       end
 
-      def _uploader_store!(column)
-        unless _uploader_get(column).blank?
-          if _uploader_remove?(column)
-            _uploader_set(column, nil)
-            write_uploader(column, '')
+      def store!
+        unless uploader.blank?
+          if remove?
+            uploader.remove!
+            record.write_uploader(serialization_column, '')
           else
-            _uploader_get(column).store!
-            write_uploader(_uploader_options(column)[:mount_on] || column, _uploader_get(column).identifier)
+            uploader.store!
+            record.write_uploader(serialization_column, uploader.identifier)
           end
         end
       end
 
-      def _uploader_remove
-        @_uploader_remove ||= {}
+      def url(*args)
+        uploader.url(*args)
       end
 
-      def _uploader_remove?(column)
-        !_uploader_remove[column].blank? and _uploader_remove[column] !~ /\A0|false$\z/
+      def blank?
+        uploader.blank?
       end
 
-      def _uploader_integrity_errors
-        @_uploader_integrity_errors ||= {}
+      def remove?
+        !remove.blank? and remove !~ /\A0|false$\z/
       end
 
-      def _uploader_processing_errors
-        @_uploader_processing_errors ||= {}
+      def remove!
+        uploader.remove!
       end
 
-    end # Extension
+    private
+
+      def serialization_column
+        options[:mount_on] || column
+      end
+
+    end # Mounter
 
   end # Mount
 end # CarrierWave

data/lib/carrierwave/orm/activerecord.rb

@@ -17,7 +17,12 @@ module CarrierWave
       validates_integrity_of column if uploader_options[column.to_sym][:validate_integrity]
       validates_processing_of column if uploader_options[column.to_sym][:validate_processing]
 
-      before_save do |record|
+      after_create do |record|
+        record.send("store_#{column}!")
+        record.save
+      end
+
+      before_update do |record|
         record.send("store_#{column}!")
       end
     end