paperclip 2.4.2 → 2.4.3

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rubygems'
-require 'appraisal'
 require 'bundler/setup'
+require 'appraisal'
 
 require 'rake'
 require 'rake/testtask'

data/lib/paperclip.rb

@@ -28,6 +28,7 @@
 require 'erb'
 require 'digest'
 require 'tempfile'
+require 'paperclip/options'
 require 'paperclip/version'
 require 'paperclip/upfile'
 require 'paperclip/iostream'
@@ -137,8 +138,10 @@ module Paperclip
       @known_processors[name.to_s] = processor
     end
 
+    # Find all instances of the given Active Record model +klass+ with attachment +name+.
+    # This method is used by the refresh rake tasks.
     def each_instance_with_attachment(klass, name)
-      class_for(klass).all.each do |instance|
+      class_for(klass).find(:all, :order => 'id').each do |instance|
         yield(instance) if instance.send(:"#{name}?")
       end
     end
@@ -317,7 +320,7 @@ module Paperclip
       end
 
       attachment_definitions[name] = {:validations => []}.merge(options)
-      Paperclip.classes_with_attachments << self unless Paperclip.classes_with_attachments.include?(self)
+      Paperclip.classes_with_attachments << self.name
       Paperclip.check_for_url_clash(name,attachment_definitions[name][:url],self.name)
 
       after_save :save_attached_files

data/lib/paperclip/attachment.rb

@@ -29,7 +29,7 @@ module Paperclip
       }
     end
 
-    attr_reader :name, :instance, :default_style, :convert_options, :queued_for_write, :whiny, :options, :source_file_options, :interpolator
+    attr_reader :name, :instance, :default_style, :convert_options, :queued_for_write, :whiny, :options, :interpolator
     attr_accessor :post_processing
 
     # Creates an Attachment object. +name+ is the name of the attachment,
@@ -62,27 +62,7 @@ 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]
-      @only_process          = options[:only_process]
-      @normalized_styles     = nil
-      @default_url           = options[:default_url]
-      @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]
-      @source_file_options   = options[:source_file_options]
-      @processors            = options[:processors]
-      @preserve_files        = options[:preserve_files]
-      @options               = options
+      @options               = Paperclip::Options.new(self, options)
       @post_processing       = true
       @queued_for_delete     = []
       @queued_for_write      = {}
@@ -93,19 +73,13 @@ module Paperclip
       initialize_storage
     end
 
-    def styles
-      if @styles.respond_to?(:call) || !@normalized_styles
-        @normalized_styles = ActiveSupport::OrderedHash.new
-        (@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
+    # [:url, :path, :only_process, :normalized_styles, :default_url, :default_style,
+    #  :storage, :use_timestamp, :whiny, :use_default_time_zone, :hash_digest, :hash_secret,
+    #  :convert_options, :preserve_files].each do |field|
+    #   define_method field do
+    #     @options.send(field)
+    #   end
+    # end
 
     # What gets called when you call instance.attachment = File. It clears
     # errors, assigns attributes, and processes the file. It
@@ -139,7 +113,7 @@ module Paperclip
 
       @dirty = true
 
-      post_process(*@only_process) if post_processing
+      post_process(*@options.only_process) if post_processing
 
       # Reset the file size if the original file was reprocessed.
       instance_write(:file_size,   @queued_for_write[:original].size.to_i)
@@ -154,9 +128,9 @@ module Paperclip
     # grained security.  This is not recommended if you don't need the
     # 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)
-      default_url = @default_url.is_a?(Proc) ? @default_url.call(self) : @default_url
-      url = original_filename.nil? ? interpolate(default_url, style_name) : interpolate(@url, style_name)
+    def url(style_name = default_style, use_timestamp = @options.use_timestamp)
+      default_url = @options.default_url.is_a?(Proc) ? @options.default_url.call(self) : @options.default_url
+      url = original_filename.nil? ? interpolate(default_url, style_name) : interpolate(@options.url, style_name)
       URI.escape(use_timestamp && updated_at ? [url, updated_at].compact.join(url.include?("?") ? "&" : "?") : url)
     end
 
@@ -165,7 +139,7 @@ module Paperclip
     # 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_name = default_style)
-      original_filename.nil? ? nil : interpolate(@path, style_name)
+      original_filename.nil? ? nil : interpolate(@options.path, style_name)
     end
 
     # Alias to +url+
@@ -173,6 +147,14 @@ module Paperclip
       url(style_name)
     end
 
+    def default_style
+      @options.default_style
+    end
+
+    def styles
+      @options.styles
+    end
+
     # Returns an array containing the errors on this attachment.
     def errors
       @errors
@@ -205,7 +187,7 @@ module Paperclip
     # nil to the attachment *and saving*. This is permanent. If you wish to
     # wipe out the existing attachment but not save, use #clear.
     def destroy
-      unless @preserve_files
+      unless @options.preserve_files
         clear
         save
       end
@@ -245,16 +227,16 @@ module Paperclip
     # The time zone to use for timestamp interpolation.  Using the default
     # time zone ensures that results are consistent across all threads.
     def time_zone
-      @use_default_time_zone ? Time.zone_default : Time.zone
+      @options.use_default_time_zone ? Time.zone_default : Time.zone
     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
+      raise ArgumentError, "Unable to generate hash without :hash_secret" unless @options.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)
+      data = interpolate(@options.hash_data, style_name)
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@options.hash_digest).new, @options.hash_secret, data)
     end
 
     def generate_fingerprint(source)
@@ -352,28 +334,28 @@ module Paperclip
     end
 
     def initialize_storage #:nodoc:
-      storage_class_name = @storage.to_s.downcase.camelize
+      storage_class_name = @options.storage.to_s.downcase.camelize
       begin
-        @storage_module = Paperclip::Storage.const_get(storage_class_name)
+        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)
+      self.extend(storage_module)
     end
 
     def extra_options_for(style) #:nodoc:
-      all_options   = convert_options[:all]
+      all_options   = @options.convert_options[:all]
       all_options   = all_options.call(instance)   if all_options.respond_to?(:call)
-      style_options = convert_options[style]
+      style_options = @options.convert_options[style]
       style_options = style_options.call(instance) if style_options.respond_to?(:call)
 
       [ style_options, all_options ].compact.join(" ")
     end
 
     def extra_source_file_options_for(style) #:nodoc:
-      all_options   = source_file_options[:all]
+      all_options   = @options.source_file_options[:all]
       all_options   = all_options.call(instance)   if all_options.respond_to?(:call)
-      style_options = source_file_options[style]
+      style_options = @options.source_file_options[style]
       style_options = style_options.call(instance) if style_options.respond_to?(:call)
 
       [ style_options, all_options ].compact.join(" ")
@@ -389,7 +371,7 @@ module Paperclip
     end
 
     def post_process_styles(*style_args) #:nodoc:
-      styles.each do |name, style|
+      @options.styles.each do |name, style|
         begin
           if style_args.empty? || style_args.include?(name)
             raise RuntimeError.new("Style #{name} has no processors defined.") if style.processors.blank?
@@ -399,7 +381,7 @@ module Paperclip
           end
         rescue PaperclipError => e
           log("An error was received while processing: #{e.inspect}")
-          (@errors[:processing] ||= []) << e.message if @whiny
+          (@errors[:processing] ||= []) << e.message if @options.whiny
         end
       end
     end
@@ -409,8 +391,8 @@ module Paperclip
     end
 
     def queue_existing_for_delete #:nodoc:
-      return unless (file? && @preserve_files==false)
-      @queued_for_delete += [:original, *styles.keys].uniq.map do |style|
+      return if @options.preserve_files || !file?
+      @queued_for_delete += [:original, *@options.styles.keys].uniq.map do |style|
         path(style) if exists?(style)
       end.compact
       instance_write(:file_name, nil)

data/lib/paperclip/geometry.rb

@@ -13,18 +13,20 @@ module Paperclip
 
     # Uses ImageMagick to determing the dimensions of a file, passed in as either a
     # File or path.
+    # NOTE: (race cond) Do not reassign the 'file' variable inside this method as it is likely to be
+    # a Tempfile object, which would be eligible for file deletion when no longer referenced.
     def self.from_file file
-      file = file.path if file.respond_to? "path"
-      raise(Paperclip::NotIdentifiedByImageMagickError.new("Cannot find the geometry of a file with a blank name")) if file.blank?
+      file_path = file.respond_to?(:path) ? file.path : file
+      raise(Paperclip::NotIdentifiedByImageMagickError.new("Cannot find the geometry of a file with a blank name")) if file_path.blank?
       geometry = begin
-                   Paperclip.run("identify", "-format %wx%h :file", :file => "#{file}[0]")
+                   Paperclip.run("identify", "-format %wx%h :file", :file => "#{file_path}[0]")
                  rescue Cocaine::ExitStatusError
                    ""
                  rescue Cocaine::CommandNotFoundError => e
                    raise Paperclip::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
                  end
       parse(geometry) ||
-        raise(NotIdentifiedByImageMagickError.new("#{file} is not recognized by the 'identify' command."))
+        raise(NotIdentifiedByImageMagickError.new("#{file_path} is not recognized by the 'identify' command."))
     end
 
     # Parses a "WxH" formatted string, where W is the width and H is the height.

data/lib/paperclip/missing_attachment_styles.rb

@@ -38,7 +38,8 @@ module Paperclip
   #   }
   def self.current_attachments_styles
     Hash.new.tap do |current_styles|
-      Paperclip.classes_with_attachments.each do |klass|
+      Paperclip.classes_with_attachments.each do |klass_name|
+        klass = Paperclip.class_for(klass_name)
         klass.attachment_definitions.each do |attachment_name, attachment_attributes|
           # TODO: is it even possible to take into account Procs?
           next if attachment_attributes[:styles].kind_of?(Proc)

data/lib/paperclip/options.rb

@@ -0,0 +1,78 @@
+module Paperclip
+  class Options
+
+    attr_accessor :url, :path, :only_process, :normalized_styles, :default_url, :default_style,
+     :storage, :use_timestamp, :whiny, :use_default_time_zone, :hash_digest, :hash_secret,
+     :convert_options, :source_file_options, :preserve_files, :http_proxy
+
+    attr_accessor :s3_credentials, :s3_host_name, :s3_options, :s3_permissions, :s3_protocol,
+      :s3_headers, :s3_host_alias, :bucket
+
+    attr_accessor :fog_directory, :fog_credentials, :fog_host, :fog_public, :fog_file
+
+    def initialize(attachment, hash)
+      @attachment            = attachment
+
+      @url                   = hash[:url]
+      @url                   = @url.call(@attachment) if @url.is_a?(Proc)
+      @path                  = hash[:path]
+      @path                  = @path.call(@attachment) if @path.is_a?(Proc)
+      @styles                = hash[:styles]
+      @only_process          = hash[:only_process]
+      @normalized_styles     = nil
+      @default_url           = hash[:default_url]
+      @default_style         = hash[:default_style]
+      @storage               = hash[:storage]
+      @use_timestamp         = hash[:use_timestamp]
+      @whiny                 = hash[:whiny_thumbnails] || hash[:whiny]
+      @use_default_time_zone = hash[:use_default_time_zone]
+      @hash_digest           = hash[:hash_digest]
+      @hash_data             = hash[:hash_data]
+      @hash_secret           = hash[:hash_secret]
+      @convert_options       = hash[:convert_options]
+      @source_file_options   = hash[:source_file_options]
+      @processors            = hash[:processors]
+      @preserve_files        = hash[:preserve_files]
+      @http_proxy            = hash[:http_proxy]
+
+      #s3 options
+      @s3_credentials        = hash[:s3_credentials]
+      @s3_host_name          = hash[:s3_host_name]
+      @bucket                = hash[:bucket]
+      @s3_options            = hash[:s3_options]
+      @s3_permissions        = hash[:s3_permissions]
+      @s3_protocol           = hash[:s3_protocol]
+      @s3_headers            = hash[:s3_headers]
+      @s3_host_alias         = hash[:s3_host_alias]
+
+      #fog options
+      @fog_directory         = hash[:fog_directory]
+      @fog_credentials       = hash[:fog_credentials]
+      @fog_host              = hash[:fog_host]
+      @fog_public            = hash[:fog_public]
+      @fog_file              = hash[:fog_file]
+    end
+
+    def method_missing(method, *args, &blk)
+      if method.to_s[-1] == "="
+        instance_variable_set("@#{method[0..-2]}", args[0])
+      else
+        instance_variable_get("@#{method}")
+      end
+    end
+
+    def processors
+      @processors.respond_to?(:call) ? @processors.call(@attachment.instance) : @processors
+    end
+
+    def styles
+      if @styles.respond_to?(:call) || !@normalized_styles
+        @normalized_styles = ActiveSupport::OrderedHash.new
+        (@styles.respond_to?(:call) ? @styles.call(@attachment) : @styles).each do |name, args|
+          normalized_styles[name] = Paperclip::Style.new(name, args.dup, @attachment)
+        end
+      end
+      @normalized_styles
+    end
+  end
+end

data/lib/paperclip/storage/fog.rb

@@ -41,15 +41,9 @@ module Paperclip
         end unless defined?(Fog)
 
         base.instance_eval do
-          @fog_directory    = @options[:fog_directory]
-          @fog_credentials  = parse_credentials(@options[:fog_credentials])
-          @fog_host         = @options[:fog_host]
-          @fog_public       = @options.key?(:fog_public) ? @options[:fog_public] : true
-          @fog_file         = @options[:fog_file] || {}
-
-          unless @url.to_s.match(/^:fog.*url$/)
-            @path  = @path.gsub(/:url/, @url)
-            @url   = ':fog_public_url'
+          unless @options.url.to_s.match(/^:fog.*url$/)
+            @options.path  = @options.path.gsub(/:url/, @options.url)
+            @options.url   = ':fog_public_url'
           end
           Paperclip.interpolates(:fog_public_url) do |attachment, style|
             attachment.public_url(style)
@@ -65,15 +59,27 @@ module Paperclip
         end
       end
 
+      def fog_credentials
+        @fog_credentials ||= parse_credentials(@options.fog_credentials)
+      end
+
+      def fog_file
+        @fog_file ||= @options.fog_file || {}
+      end
+
+      def fog_public
+        @fog_public ||= @options.fog_public || true
+      end
+
       def flush_writes
         for style, file in @queued_for_write do
           log("saving #{path(style)}")
           retried = false
           begin
-            directory.files.create(@fog_file.merge(
+            directory.files.create(fog_file.merge(
               :body   => file,
               :key    => path(style),
-              :public => @fog_public
+              :public => fog_public
             ))
           rescue Excon::Errors::NotFound
             raise if retried
@@ -115,8 +121,8 @@ module Paperclip
       end
 
       def public_url(style = default_style)
-        if @fog_host
-          host = (@fog_host =~ /%d/) ? @fog_host % (path(style).hash % 4) : @fog_host
+        if @options.fog_host
+          host = (@options.fog_host =~ /%d/) ? @options.fog_host % (path(style).hash % 4) : @options.fog_host
           "#{host}/#{path(style)}"
         else
           directory.files.new(:key => path(style)).public_url
@@ -145,11 +151,11 @@ module Paperclip
       end
 
       def connection
-        @connection ||= ::Fog::Storage.new(@fog_credentials)
+        @connection ||= ::Fog::Storage.new(fog_credentials)
       end
 
       def directory
-        @directory ||= connection.directories.new(:key => @fog_directory)
+        @directory ||= connection.directories.new(:key => @options.fog_directory)
       end
     end
   end

data/lib/paperclip/storage/s3.rb

@@ -77,33 +77,28 @@ module Paperclip
         end unless defined?(AWS::S3)
 
         base.instance_eval do
-          @s3_credentials = parse_credentials(@options[:s3_credentials])
-          @s3_host_name   = @options[:s3_host_name] || @s3_credentials[:s3_host_name]
-          @bucket         = @options[:bucket]         || @s3_credentials[:bucket]
-          @bucket         = @bucket.call(self) if @bucket.is_a?(Proc)
-          @s3_options     = @options[:s3_options]     || {}
-          @s3_permissions = set_permissions(@options[:s3_permissions])
-          @s3_protocol    = @options[:s3_protocol]    ||
+          @s3_options     = @options.s3_options     || {}
+          @s3_permissions = set_permissions(@options.s3_permissions)
+          @s3_protocol    = @options.s3_protocol    ||
             Proc.new do |style|
               (@s3_permissions[style.to_sym] || @s3_permissions[:default]) == :public_read ? 'http' : 'https'
             end
-          @s3_headers     = @options[:s3_headers]     || {}
-          @s3_host_alias  = @options[:s3_host_alias]
-          @s3_host_alias  = @s3_host_alias.call(self) if @s3_host_alias.is_a?(Proc)
-          unless @url.to_s.match(/^:s3.*url$/)
-            @path         = @path.gsub(/:url/, @url)
-            @url          = ":s3_path_url"
+          @s3_headers     = @options.s3_headers     || {}
+
+          unless @options.url.to_s.match(/^:s3.*url$/) || @options.url == ":asset_host"
+            @options.path         = @options.path.gsub(/:url/, @options.url)
+            @options.url          = ":s3_path_url"
           end
-          @url            = ":asset_host" if @options[:url].to_s == ":asset_host"
+          @options.url = @options.url.inspect if @options.url.is_a?(Symbol)
 
-          @http_proxy = @options[:http_proxy] || nil
+          @http_proxy = @options.http_proxy || nil
           if @http_proxy
             @s3_options.merge!({:proxy => @http_proxy})
           end
 
           AWS::S3::Base.establish_connection!( @s3_options.merge(
-            :access_key_id => @s3_credentials[:access_key_id],
-            :secret_access_key => @s3_credentials[:secret_access_key]
+            :access_key_id => s3_credentials[:access_key_id],
+            :secret_access_key => s3_credentials[:secret_access_key]
           ))
         end
         Paperclip.interpolates(:s3_alias_url) do |attachment, style|
@@ -124,7 +119,23 @@ module Paperclip
         AWS::S3::S3Object.url_for(path(style_name), bucket_name, :expires_in => time, :use_ssl => (s3_protocol(style_name) == 'https'))
       end
 
+      def s3_credentials
+        @s3_credentials ||= parse_credentials(@options.s3_credentials)
+      end
+
+      def s3_host_name
+        @options.s3_host_name || s3_credentials[:s3_host_name] || "s3.amazonaws.com"
+      end
+
+      def s3_host_alias
+        @s3_host_alias = @options.s3_host_alias
+        @s3_host_alias = @s3_host_alias.call(self) if @s3_host_alias.is_a?(Proc)
+        @s3_host_alias
+      end
+
       def bucket_name
+        @bucket = @options.bucket || s3_credentials[:bucket]
+        @bucket = @bucket.call(self) if @bucket.is_a?(Proc)
         @bucket
       end
 
@@ -148,10 +159,6 @@ module Paperclip
         using_http_proxy? ? @http_proxy[:password] : nil
       end
 
-      def s3_host_name
-        @s3_host_name || "s3.amazonaws.com"
-      end
-
       def set_permissions permissions
         if permissions.is_a?(Hash)
           permissions[:default] = permissions[:default] || :public_read
@@ -161,10 +168,6 @@ module Paperclip
         permissions
       end
 
-      def s3_host_alias
-        @s3_host_alias
-      end
-
       def parse_credentials creds
         creds = find_credentials(creds).stringify_keys
         env = Object.const_defined?(:Rails) ? Rails.env : nil