dm-paperclip 2.4.1 → 2.5.0

data/lib/dm-paperclip.rb

@@ -26,26 +26,33 @@
 # See the +has_attached_file+ documentation for more details.
 
 require 'erb'
+require 'digest'
 require 'tempfile'
 
-require 'extlib'
 require 'dm-core'
+require 'extlib'
 
+require 'dm-paperclip/ext/compatibility'
+require 'dm-paperclip/ext/class'
+require 'dm-paperclip/ext/blank'
+require 'dm-paperclip/ext/try_dup'
+require 'dm-paperclip/version'
 require 'dm-paperclip/upfile'
 require 'dm-paperclip/iostream'
 require 'dm-paperclip/geometry'
 require 'dm-paperclip/processor'
 require 'dm-paperclip/thumbnail'
-require 'dm-paperclip/storage'
 require 'dm-paperclip/interpolations'
+require 'dm-paperclip/style'
 require 'dm-paperclip/attachment'
+require 'dm-paperclip/storage'
+require 'dm-paperclip/command_line'
+require 'dm-paperclip/callbacks'
 
 # The base module that gets included in ActiveRecord::Base. See the
 # documentation for Paperclip::ClassMethods for more useful information.
 module Paperclip
 
-  VERSION = "2.4.1"
-
   # To configure Paperclip, put this code in an initializer, Rake task, or wherever:
   #
   #   Paperclip.configure do |config|
@@ -104,12 +111,12 @@ module Paperclip
   class << self
 
     # Provides configurability to Paperclip. There are a number of options available, such as:
-    # * whiny: Will raise an error if Paperclip cannot process thumbnails of 
+    # * whiny: Will raise an error if Paperclip cannot process thumbnails of
     #   an uploaded image. Defaults to true.
     # * log: Logs progress to the Rails log. Uses ActiveRecord's logger, so honors
     #   log levels, etc. Defaults to true.
     # * command_path: Defines the path at which to find the command line
-    #   programs if they are not visible to Rails the system's search path. Defaults to 
+    #   programs if they are not visible to Rails the system's search path. Defaults to
     #   nil, which uses the first executable found in the user's search path.
     # * image_magick_path: Deprecated alias of command_path.
     def options
@@ -118,7 +125,7 @@ module Paperclip
         :image_magick_path => nil,
         :command_path      => nil,
         :log               => true,
-        :log_command       => false,
+        :log_command       => true,
         :swallow_stderr    => true
       }
     end
@@ -135,7 +142,7 @@ module Paperclip
       Paperclip::Interpolations[key] = block
     end
 
-    # The run method takes a command to execute and a string of parameters
+    # The run method takes a command to execute and an array of parameters
     # that get passed to it. The command is prefixed with the :command_path
     # option from Paperclip.options. If you have many commands to run and
     # they are in different paths, the suggested course of action is to
@@ -144,23 +151,19 @@ module Paperclip
     # If the command returns with a result code that is not one of the
     # expected_outcodes, a PaperclipCommandLineError will be raised. Generally
     # a code of 0 is expected, but a list of codes may be passed if necessary.
+    # These codes should be passed as a hash as the last argument, like so:
+    #
+    #   Paperclip.run("echo", "something", :expected_outcodes => [0,1,2,3])
     #
-    # This method can log the command being run when 
+    # This method can log the command being run when
     # Paperclip.options[:log_command] is set to true (defaults to false). This
     # will only log if logging in general is set to true as well.
-    def run cmd, params = "", expected_outcodes = 0
-      command = %Q<#{%Q[#{path_for_command(cmd)} #{params}].gsub(/\s+/, " ")}>
-      command = "#{command} 2>#{bit_bucket}" if Paperclip.options[:swallow_stderr]
-      Paperclip.log(command) if Paperclip.options[:log_command]
-      output = `#{command}`
-      unless [expected_outcodes].flatten.include?($?.exitstatus)
-        raise PaperclipCommandLineError, "Error while running #{cmd}"
+    def run cmd, *params
+      if options[:image_magick_path]
+        Paperclip.log("[DEPRECATION] :image_magick_path is deprecated and will be removed. Use :command_path instead")
       end
-      output
-    end
-
-    def bit_bucket #:nodoc:
-      File.exists?("/dev/null") ? "/dev/null" : "NUL"
+      CommandLine.path = options[:command_path] || options[:image_magick_path]
+      CommandLine.new(cmd, *params).run
     end
 
     def included base #:nodoc:
@@ -171,7 +174,7 @@ module Paperclip
     end
 
     def processor name #:nodoc:
-      name = name.to_s.camel_case
+      name = DataMapper::Inflector.classify(name.to_s)
       processor = Paperclip.const_get(name)
       unless processor.ancestors.include?(Paperclip::Processor)
         raise PaperclipError.new("[paperclip] Processor #{name} was not found")
@@ -179,6 +182,12 @@ module Paperclip
       processor
     end
 
+    def each_instance_with_attachment(klass, name)
+      Object.const_get(klass).all.each do |instance|
+        yield(instance) if instance.send(:"#{name}?")
+      end
+    end
+
     # Log a paperclip-specific line. Uses ActiveRecord::Base.logger
     # by default. Set Paperclip.options[:log] to false to turn off.
     def log message
@@ -197,31 +206,30 @@ module Paperclip
   class PaperclipError < StandardError #:nodoc:
   end
 
-  class PaperclipCommandLineError < StandardError #:nodoc:
+  class PaperclipCommandLineError < PaperclipError #:nodoc:
+    attr_accessor :output
+    def initialize(msg = nil, output = nil)
+      super(msg)
+      @output = output
+    end
+  end
+
+  class StorageMethodNotFound < PaperclipError
+  end
+
+  class CommandNotFoundError < PaperclipError
   end
 
   class NotIdentifiedByImageMagickError < PaperclipError #:nodoc:
   end
-  
+
   class InfiniteInterpolationError < PaperclipError #:nodoc:
   end
-  
-  module Resource
 
+  module Resource
     def self.included(base)
-
-      base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        class_variable_set(:@@attachment_definitions,nil) unless class_variable_defined?(:@@attachment_definitions)
-        def self.attachment_definitions
-          @@attachment_definitions
-        end
-
-        def self.attachment_definitions=(obj)
-          @@attachment_definitions = obj
-        end
-      RUBY
-
       base.extend Paperclip::ClassMethods
+      base.extend Paperclip::Ext::Class::Hook
 
       # Done at this time to ensure that the user
       # had a chance to configure the app in an initializer
@@ -232,50 +240,50 @@ module Paperclip
       end
 
       Paperclip.require_processors
-
     end
-
   end
 
   module ClassMethods
     # +has_attached_file+ gives the class it is called on an attribute that maps to a file. This
-    # is typically a file stored somewhere on the filesystem and has been uploaded by a user. 
+    # is typically a file stored somewhere on the filesystem and has been uploaded by a user.
     # The attribute returns a Paperclip::Attachment object which handles the management of
-    # that file. The intent is to make the attachment as much like a normal attribute. The 
-    # thumbnails will be created when the new file is assigned, but they will *not* be saved 
-    # until +save+ is called on the record. Likewise, if the attribute is set to +nil+ is 
-    # called on it, the attachment will *not* be deleted until +save+ is called. See the 
-    # Paperclip::Attachment documentation for more specifics. There are a number of options 
+    # that file. The intent is to make the attachment as much like a normal attribute. The
+    # thumbnails will be created when the new file is assigned, but they will *not* be saved
+    # until +save+ is called on the record. Likewise, if the attribute is set to +nil+ is
+    # called on it, the attachment will *not* be deleted until +save+ is called. See the
+    # Paperclip::Attachment documentation for more specifics. There are a number of options
     # you can set to change the behavior of a Paperclip attachment:
     # * +url+: The full URL of where the attachment is publically accessible. This can just
     #   as easily point to a directory served directly through Apache as it can to an action
     #   that can control permissions. You can specify the full domain and path, but usually
-    #   just an absolute path is sufficient. The leading slash must be included manually for 
-    #   absolute paths. The default value is "/:class/:attachment/:id/:style_:filename". See
+    #   just an absolute path is sufficient. The leading slash *must* be included manually for
+    #   absolute paths. The default value is
+    #   "/system/:attachment/:id/:style/:filename". See
     #   Paperclip::Attachment#interpolate for more information on variable interpolaton.
-    #     :url => "/:attachment/:id/:style_:basename:extension"
+    #     :url => "/:class/:attachment/:id/:style_:filename"
     #     :url => "http://some.other.host/stuff/:class/:id_:extension"
-    # * +default_url+: The URL that will be returned if there is no attachment assigned. 
-    #   This field is interpolated just as the url is. The default value is 
-    #   "/:class/:attachment/missing_:style.png"
+    # * +default_url+: The URL that will be returned if there is no attachment assigned.
+    #   This field is interpolated just as the url is. The default value is
+    #   "/:attachment/:style/missing.png"
     #     has_attached_file :avatar, :default_url => "/images/default_:style_avatar.png"
     #     User.new.avatar_url(:small) # => "/images/default_small_avatar.png"
-    # * +styles+: A hash of thumbnail styles and their geometries. You can find more about 
-    #   geometry strings at the ImageMagick website 
+    # * +styles+: A hash of thumbnail styles and their geometries. You can find more about
+    #   geometry strings at the ImageMagick website
     #   (http://www.imagemagick.org/script/command-line-options.php#resize). Paperclip
-    #   also adds the "#" option (e.g. "50x50#"), which will resize the image to fit maximally 
-    #   inside the dimensions and then crop the rest off (weighted at the center). The 
+    #   also adds the "#" option (e.g. "50x50#"), which will resize the image to fit maximally
+    #   inside the dimensions and then crop the rest off (weighted at the center). The
     #   default value is to generate no thumbnails.
-    # * +default_style+: The thumbnail style that will be used by default URLs. 
+    # * +default_style+: The thumbnail style that will be used by default URLs.
     #   Defaults to +original+.
     #     has_attached_file :avatar, :styles => { :normal => "100x100#" },
     #                       :default_style => :normal
     #     user.avatar.url # => "/avatars/23/normal_me.png"
-    # * +whiny_thumbnails+: Will raise an error if Paperclip cannot process thumbnails of an
-    #   uploaded image. This will ovrride the global setting for this attachment. 
-    #   Defaults to true. 
+    # * +whiny+: Will raise an error if Paperclip cannot post_process an uploaded file due
+    #   to a command line error. This will override the global setting for this attachment.
+    #   Defaults to true. This option used to be called :whiny_thumbanils, but this is
+    #   deprecated.
     # * +convert_options+: When creating thumbnails, use this free-form options
-    #   field to pass in various convert command options.  Typical options are "-strip" to
+    #   array to pass in various convert command options.  Typical options are "-strip" to
     #   remove all Exif data from the image (save space for thumbnails and avatars) or
     #   "-depth 8" to specify the bit depth of the resulting conversion.  See ImageMagick
     #   convert documentation for more options: (http://www.imagemagick.org/script/convert.php)
@@ -283,12 +291,18 @@ module Paperclip
     #   of thumbnail being generated. You can also specify :all as a key, which will apply
     #   to all of the thumbnails being generated. If you specify options for the :original,
     #   it would be best if you did not specify destructive options, as the intent of keeping
-    #   the original around is to regenerate all the thumbnails then requirements change.
+    #   the original around is to regenerate all the thumbnails when requirements change.
     #     has_attached_file :avatar, :styles => { :large => "300x300", :negative => "100x100" }
     #                                :convert_options => {
     #                                  :all => "-strip",
     #                                  :negative => "-negate"
     #                                }
+    #   NOTE: While not deprecated yet, it is not recommended to specify options this way.
+    #   It is recommended that :convert_options option be included in the hash passed to each
+    #   :styles for compatability with future versions.
+    #   NOTE: Strings supplied to :convert_options are split on space in order to undergo
+    #   shell quoting for safety. If your options require a space, please pre-split them
+    #   and pass an array to :convert_options instead.
     # * +storage+: Chooses the storage backend where the files will be stored. The current
     #   choices are :filesystem and :s3. The default is :filesystem. Make sure you read the
     #   documentation for Paperclip::Storage::Filesystem and Paperclip::Storage::S3
@@ -296,10 +310,11 @@ module Paperclip
     def has_attached_file name, options = {}
       include InstanceMethods
 
-      self.attachment_definitions = {} if self.attachment_definitions.nil?
-      self.attachment_definitions[name] = {:validations => []}.merge(options)
-      
+      Paperclip::Ext::Class.write_inheritable_attribute(self, :attachment_definitions, {}) if attachment_definitions.nil?
+      attachment_definitions[name] = {:validations => []}.merge(options)
+
       property_options = options.delete_if { |k,v| ![ :public, :protected, :private, :accessor, :reader, :writer ].include?(key) }
+      property_options[:required] = false
 
       property :"#{name}_file_name",    String,   property_options.merge(:length => 255)
       property :"#{name}_content_type", String,   property_options.merge(:length => 255)
@@ -308,10 +323,9 @@ module Paperclip
 
       after :save, :save_attached_files
       before :destroy, :destroy_attached_files
-      
-      # not needed with extlib just do before :post_process, or after :post_process
-      # define_callbacks :before_post_process, :after_post_process
-      # define_callbacks :"before_#{name}_post_process", :"after_#{name}_post_process"
+
+      Paperclip::Callbacks.define(self, "post_process")
+      Paperclip::Callbacks.define(self, "#{name}_post_process")
 
       define_method name do |*args|
         a = attachment_for(name)
@@ -323,11 +337,11 @@ module Paperclip
       end
 
       define_method "#{name}?" do
-        ! attachment_for(name).original_filename.blank?
+        attachment_for(name).file?
       end
 
       if Paperclip.config.use_dm_validations
-        add_validator_to_context(opts_from_validator_args([name]), [name], Paperclip::Validate::CopyAttachmentErrors)
+        validators.add(Paperclip::Validate::CopyAttachmentErrors, name)
       end
 
     end
@@ -335,14 +349,14 @@ module Paperclip
     # Returns the attachment definitions defined by each call to
     # has_attached_file.
     def attachment_definitions
-      read_inheritable_attribute(:attachment_definitions)
+      Paperclip::Ext::Class.read_inheritable_attribute(self, :attachment_definitions)
     end
   end
 
   module InstanceMethods #:nodoc:
     def attachment_for name
-      @attachments ||= {}
-      @attachments[name] ||= Attachment.new(name, self, self.class.attachment_definitions[name])
+      @_paperclip_attachments ||= {}
+      @_paperclip_attachments[name] ||= Attachment.new(name, self, self.class.attachment_definitions[name])
     end
 
     def each_attachment

data/lib/dm-paperclip/attachment.rb

@@ -1,23 +1,31 @@
+# encoding: utf-8
 module Paperclip
   # The Attachment class manages the files for a given attachment. It saves
   # when the model saves, deletes when the model is destroyed, and processes
   # the file upon assignment.
   class Attachment
-
+    include IOStream
     def self.default_options
       @default_options ||= {
-        :url           => "/system/:attachment/:id/:style/:filename",
-        :path          => ":rails_root/public:url",
-        :styles        => {},
-        :default_url   => "/:attachment/:style/missing.png",
-        :default_style => :original,
-        :validations   => [],
-        :storage       => :filesystem,
-        :whiny         => Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails]
+        :url                   => "/system/:attachment/:id/:style/:filename",
+        :path                  => ":web_root/public:url",
+        :styles                => {},
+        :processors            => [:thumbnail],
+        :convert_options       => {},
+        :default_url           => "/:attachment/:style/missing.png",
+        :default_style         => :original,
+        :validations           => [],
+        :storage               => :filesystem,
+        :use_timestamp         => true,
+        :whiny                 => Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails],
+        :use_default_time_zone => true,
+        :hash_digest           => "SHA1",
+        :hash_data             => ":class/:attachment/:id/:style/:updated_at"
       }
     end
 
-    attr_reader :name, :instance, :styles, :default_style, :convert_options, :queued_for_write, :options
+    attr_reader :name, :instance, :default_style, :convert_options, :queued_for_write, :whiny, :options
+    attr_accessor :post_processing
 
     # Creates an Attachment object. +name+ is the name of the attachment,
     # +instance+ is the ActiveRecord object instance it's attached to, and
@@ -28,38 +36,55 @@ module Paperclip
 
       options = self.class.default_options.merge(options)
 
-      @url               = options[:url]
-      @url               = @url.call(self) if @url.is_a?(Proc)
-      @path              = options[:path]
-      @path              = @path.call(self) if @path.is_a?(Proc)
-      @styles            = options[:styles]
-      @styles            = @styles.call(self) if @styles.is_a?(Proc)
-      @default_url       = options[:default_url]
-      @validations       = options[:validations]
-      @default_style     = options[:default_style]
-      @storage           = options[:storage]
-      @whiny             = options[:whiny_thumbnails] || options[:whiny]
-      @convert_options   = options[:convert_options] || {}
-      @processors        = options[:processors] || [:thumbnail]
-      @options           = options
-      @queued_for_delete = []
-      @queued_for_write  = {}
-      @errors            = {}
-      @validation_errors = nil
-      @dirty             = false
+      @url                   = options[:url]
+      @url                   = @url.call(self) if @url.is_a?(Proc)
+      @path                  = options[:path]
+      @path                  = @path.call(self) if @path.is_a?(Proc)
+      @styles                = options[:styles]
+      @normalized_styles     = nil
+      @default_url           = options[:default_url]
+      @validations           = options[:validations]
+      @default_style         = options[:default_style]
+      @storage               = options[:storage]
+      @use_timestamp         = options[:use_timestamp]
+      @whiny                 = options[:whiny_thumbnails] || options[:whiny]
+      @use_default_time_zone = options[:use_default_time_zone]
+      @hash_digest           = options[:hash_digest]
+      @hash_data             = options[:hash_data]
+      @hash_secret           = options[:hash_secret]
+      @convert_options       = options[:convert_options]
+      @processors            = options[:processors]
+      @options               = options
+      @post_processing       = true
+      @queued_for_delete     = []
+      @queued_for_write      = {}
+      @errors                = {}
+      @validation_errors     = nil
+      @dirty                 = false
 
-      normalize_style_definition
       initialize_storage
     end
 
+    def styles
+      unless @normalized_styles
+        @normalized_styles = {}
+        (@styles.respond_to?(:call) ? @styles.call(self) : @styles).each do |name, args|
+          @normalized_styles[name] = Paperclip::Style.new(name, args.dup, self)
+        end
+      end
+      @normalized_styles
+    end
+
+    def processors
+      @processors.respond_to?(:call) ? @processors.call(instance) : @processors
+    end
+
     # What gets called when you call instance.attachment = File. It clears
-    # errors, assigns attributes, processes the file, and runs validations. It
+    # errors, assigns attributes, and processes the file. It
     # also queues up the previous file for deletion, to be flushed away on
     # #save of its host.  In addition to form uploads, you can also assign
     # another Paperclip attachment:
     #   new_user.avatar = old_user.avatar
-    # If the file that is assigned is not valid, the processing (i.e.
-    # thumbnailing, etc) will NOT be run.
     def assign uploaded_file
 
       ensure_required_accessors!
@@ -77,28 +102,29 @@ module Paperclip
       return nil if uploaded_file.nil?
 
       if uploaded_file.respond_to?(:[])
-        uploaded_file = uploaded_file.to_mash
-        
+        uploaded_file = DataMapper::Mash.new(uploaded_file)
+
         @queued_for_write[:original]   = uploaded_file['tempfile']
         instance_write(:file_name,       uploaded_file['filename'].strip.gsub(/[^\w\d\.\-]+/, '_'))
-        instance_write(:content_type,    uploaded_file['content_type'] ? uploaded_file['content_type'].strip : uploaded_file['tempfile'].content_type.to_s.strip)
+        instance_write(:content_type,    (  uploaded_file['content_type'] && uploaded_file['content_type'].strip || # sometimes it is 'type' instead of 'content_type'
+                                            uploaded_file['type'] && uploaded_file['type'].strip ||
+                                            uploaded_file['tempfile'].content_type.to_s.strip))
         instance_write(:file_size,       uploaded_file['size'] ? uploaded_file['size'].to_i : uploaded_file['tempfile'].size.to_i)
-        instance_write(:updated_at,      Time.now)
       else
-        @queued_for_write[:original]   = uploaded_file.to_tempfile
-        instance_write(:file_name,       uploaded_file.original_filename.strip.gsub(/[^\w\d\.\-]+/, '_'))
+        @queued_for_write[:original]   = to_tempfile(uploaded_file)
+        instance_write(:file_name,       uploaded_file.original_filename.strip)
         instance_write(:content_type,    uploaded_file.content_type.to_s.strip)
         instance_write(:file_size,       uploaded_file.size.to_i)
-        instance_write(:updated_at,      Time.now)
       end
 
       @dirty = true
 
-      post_process if valid?
+      post_process if @post_processing && valid?
 
       # Reset the file size if the original file was reprocessed.
-      instance_write(:file_size, @queued_for_write[:original].size.to_i)
-
+      instance_write(:file_size,   @queued_for_write[:original].size.to_i)
+      instance_write(:fingerprint, generate_fingerprint(@queued_for_write[:original]))
+      instance_write(:updated_at,      DateTime.now)
     ensure
       uploaded_file.close if close_uploaded_file
       validate
@@ -108,25 +134,24 @@ module Paperclip
     # this does not necessarily need to point to a file that your web server
     # can access and can point to an action in your app, if you need fine
     # grained security.  This is not recommended if you don't need the
-    # security, however, for performance reasons.  set
-    # include_updated_timestamp to false if you want to stop the attachment
-    # update time appended to the url
-    def url style = default_style, include_updated_timestamp = true
-      the_url = original_filename.nil? ? interpolate(@default_url, style) : interpolate(@url, style)
-      include_updated_timestamp && updated_at ? [the_url, updated_at.to_time.to_i].compact.join(the_url.include?("?") ? "&" : "?") : the_url
+    # security, however, for performance reasons. Set use_timestamp to false
+    # if you want to stop the attachment update time appended to the url
+    def url(style_name = default_style, use_timestamp = @use_timestamp)
+      url = original_filename.nil? ? interpolate(@default_url, style_name) : interpolate(@url, style_name)
+      use_timestamp && updated_at ? [url, updated_at].compact.join(url.include?("?") ? "&" : "?") : url
     end
 
     # Returns the path of the attachment as defined by the :path option. If the
     # file is stored in the filesystem the path refers to the path of the file
     # on disk. If the file is stored in S3, the path is the "key" part of the
     # URL, and the :bucket option refers to the S3 bucket.
-    def path style = default_style
-      original_filename.nil? ? nil : interpolate(@path, style)
+    def path style_name = default_style
+      original_filename.nil? ? nil : interpolate(@path, style_name)
     end
 
     # Alias to +url+
-    def to_s style = nil
-      url(style)
+    def to_s style_name = default_style
+      url(style_name)
     end
 
     # Returns true if there are no errors on this attachment.
@@ -188,6 +213,12 @@ module Paperclip
       instance_read(:file_size) || (@queued_for_write[:original] && @queued_for_write[:original].size)
     end
 
+    # Returns the hash of the file as originally assigned, and lives in the
+    # <attachment>_fingerprint attribute of the model.
+    def fingerprint
+      instance_read(:fingerprint) || (@queued_for_write[:original] && generate_fingerprint(@queued_for_write[:original]))
+    end
+
     # Returns the content_type of the file as originally assigned, and lives
     # in the <attachment>_content_type attribute of the model.
     def content_type
@@ -197,7 +228,29 @@ module Paperclip
     # Returns the last modified time of the file as originally assigned, and
     # lives in the <attachment>_updated_at attribute of the model.
     def updated_at
-      instance_read(:updated_at)
+      time = instance_read(:updated_at)
+      return nil unless time
+
+      if time.is_a?(DateTime)
+        time && ((time - ::DateTime.civil(1970)) * 86_400).to_i
+      else
+        time.to_i
+      end
+    end
+
+    # Returns a unique hash suitable for obfuscating the URL of an otherwise
+    # publicly viewable attachment.
+    def hash(style_name = default_style)
+      raise ArgumentError, "Unable to generate hash without :hash_secret" unless @hash_secret
+      require 'openssl' unless defined?(OpenSSL)
+      data = interpolate(@hash_data, style_name)
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@hash_digest).new, @hash_secret, data)
+    end
+
+    def generate_fingerprint(source)
+      data = source.read
+      source.rewind if source.respond_to?(:rewind)
+      Digest::MD5.hexdigest(data)
     end
 
     # Paths and URLs can have a number of variables interpolated into them
@@ -216,15 +269,15 @@ module Paperclip
     # in the paperclip:refresh rake task and that's it. It will regenerate all
     # thumbnails forcefully, by reobtaining the original file and going through
     # the post-process again.
-    def reprocess!
+    def reprocess!(*style_args)
       new_original = Tempfile.new("paperclip-reprocess")
       new_original.binmode
       if old_original = to_file(:original)
-        new_original.write( old_original.read )
+        new_original.write( old_original.respond_to?(:get) ? old_original.get : old_original.read )
         new_original.rewind
 
         @queued_for_write = { :original => new_original }
-        post_process
+        post_process(*style_args)
 
         old_original.close if old_original.respond_to?(:close)
 
@@ -232,11 +285,14 @@ module Paperclip
       else
         true
       end
+    rescue Errno::EACCES => e
+      log "Skipping file: #{e.message}"
+      false
     end
 
     # Returns true if a file has been assigned.
     def file?
-      !original_filename.blank?
+      !Paperclip::Ext.blank?(original_filename)
     end
 
     # Writes the attachment-specific attribute on the instance. For example,
@@ -301,7 +357,7 @@ module Paperclip
     def check_guard guard #:nodoc:
       if guard.respond_to? :call
         guard.call(instance)
-      elsif ! guard.blank?
+      elsif ! Paperclip::Ext.blank?(guard)
         instance.send(guard.to_s)
       end
     end
@@ -318,8 +374,8 @@ module Paperclip
 
     def validate_content_type options #:nodoc:
       valid_types = [options[:content_type]].flatten
-      unless original_filename.blank?
-        unless valid_types.blank?
+      unless Paperclip::Ext.blank?(original_filename)
+        unless Paperclip::Ext.blank?(valid_types)
           content_type = instance_read(:content_type)
           unless valid_types.any?{|t| content_type.nil? || t === content_type }
             options[:message] || "is not one of the allowed file types."
@@ -328,37 +384,13 @@ module Paperclip
       end
     end
 
-    def normalize_style_definition #:nodoc:
-      @styles.each do |name, args|
-        unless args.is_a? Hash
-          dimensions, format = [args, nil].flatten[0..1]
-          format             = nil if format.blank?
-          @styles[name]      = {
-            :processors      => @processors,
-            :geometry        => dimensions,
-            :format          => format,
-            :whiny           => @whiny,
-            :convert_options => extra_options_for(name)
-          }
-        else
-          @styles[name] = {
-            :processors => @processors,
-            :whiny => @whiny,
-            :convert_options => extra_options_for(name)
-          }.merge(@styles[name])
-        end
-      end
-    end
-
-    def solidify_style_definitions #:nodoc:
-      @styles.each do |name, args|
-        @styles[name][:geometry] = @styles[name][:geometry].call(instance) if @styles[name][:geometry].respond_to?(:call)
-        @styles[name][:processors] = @styles[name][:processors].call(instance) if @styles[name][:processors].respond_to?(:call)
-      end
-    end
-
     def initialize_storage #:nodoc:
-      @storage_module = Paperclip::Storage.const_get(@storage.to_s.capitalize)
+      storage_class_name = @storage.to_s.capitalize
+      begin
+        @storage_module = Paperclip::Storage.const_get(storage_class_name)
+      rescue NameError
+        raise StorageMethodNotFound, "Cannot load storage module '#{storage_class_name}'"
+      end
       self.extend(@storage_module)
     end
 
@@ -371,18 +403,23 @@ module Paperclip
       [ style_options, all_options ].compact.join(" ")
     end
 
-    def post_process #:nodoc:
+    def post_process(*style_args) #:nodoc:
       return if @queued_for_write[:original].nil?
-      solidify_style_definitions
-      post_process_styles
+      Paperclip::Callbacks.run(instance, 'post_process') do
+        Paperclip::Callbacks.run(instance, "#{name}_post_process") do
+          post_process_styles(*style_args)
+        end
+      end
     end
 
-    def post_process_styles #:nodoc:
-      @styles.each do |name, args|
+    def post_process_styles(*style_args) #:nodoc:
+      styles.each do |name, style|
         begin
-          raise RuntimeError.new("Style #{name} has no processors defined.") if args[:processors].blank?
-          @queued_for_write[name] = args[:processors].inject(@queued_for_write[:original]) do |file, processor|
-            Paperclip.processor(processor).make(file, args, self)
+          if style_args.empty? || style_args.include?(name)
+            raise RuntimeError.new("Style #{name} has no processors defined.") if style.processors.empty?
+            @queued_for_write[name] = style.processors.inject(@queued_for_write[:original]) do |file, processor|
+              Paperclip.processor(processor).make(file, style.processor_options, self)
+            end
           end
         rescue PaperclipError => e
           log("An error was received while processing: #{e.inspect}")
@@ -391,13 +428,13 @@ module Paperclip
       end
     end
 
-    def interpolate pattern, style = default_style #:nodoc:
-      Paperclip::Interpolations.interpolate(pattern, self, style)
+    def interpolate pattern, style_name = default_style #:nodoc:
+      Paperclip::Interpolations.interpolate(pattern, self, style_name)
     end
 
     def queue_existing_for_delete #:nodoc:
       return unless file?
-      @queued_for_delete += [:original, *@styles.keys].uniq.map do |style|
+      @queued_for_delete += [:original, *styles.keys].uniq.map do |style|
         path(style) if exists?(style)
       end.compact
       instance_write(:file_name, nil)