paperclip 2.8.0 → 3.0.2

data/lib/paperclip/attachment.rb

@@ -7,8 +7,6 @@ module Paperclip
   # 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 ||= {
         :convert_options       => {},
@@ -25,7 +23,7 @@ module Paperclip
         :source_file_options   => {},
         :storage               => :filesystem,
         :styles                => {},
-        :url                   => "/system/:attachment/:id/:style/:filename",
+        :url                   => "/system/:class/:attachment/:id_partition/:style/:filename",
         :url_generator         => Paperclip::UrlGenerator,
         :use_default_time_zone => true,
         :use_timestamp         => true,
@@ -90,29 +88,16 @@ module Paperclip
     #   new_user.avatar = old_user.avatar
     def assign uploaded_file
       ensure_required_accessors!
+      file = Paperclip.io_adapters.for(uploaded_file)
 
-      if uploaded_file.is_a?(Paperclip::Attachment)
-        uploaded_filename = uploaded_file.original_filename
-        uploaded_file = uploaded_file.to_file(:original)
-        close_uploaded_file = uploaded_file.respond_to?(:close)
-      else
-        instance_write(:uploaded_file, uploaded_file) if uploaded_file
-      end
-
-      return nil unless valid_assignment?(uploaded_file)
-
-      uploaded_file.binmode if uploaded_file.respond_to? :binmode
       self.clear
+      return nil if file.nil?
 
-      return nil if uploaded_file.nil?
-
-      uploaded_filename ||= uploaded_file.original_filename
-      stores_fingerprint             = @instance.respond_to?("#{name}_fingerprint".to_sym)
-      @queued_for_write[:original]   = to_tempfile(uploaded_file)
-      instance_write(:file_name,       cleanup_filename(uploaded_filename.strip))
-      instance_write(:content_type,    uploaded_file.content_type.to_s.strip)
-      instance_write(:file_size,       uploaded_file.size.to_i)
-      instance_write(:fingerprint,     generate_fingerprint(uploaded_file)) if stores_fingerprint
+      @queued_for_write[:original]   = file
+      instance_write(:file_name,       cleanup_filename(file.original_filename))
+      instance_write(:content_type,    file.content_type)
+      instance_write(:file_size,       file.size)
+      instance_write(:fingerprint,     file.fingerprint) if instance_respond_to?(:fingerprint)
       instance_write(:updated_at,      Time.now)
 
       @dirty = true
@@ -120,10 +105,8 @@ module Paperclip
       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)
-      instance_write(:fingerprint, generate_fingerprint(@queued_for_write[:original])) if stores_fingerprint
-    ensure
-      uploaded_file.close if close_uploaded_file
+      instance_write(:file_size,   @queued_for_write[:original].size)
+      instance_write(:fingerprint, @queued_for_write[:original].fingerprint) if instance_respond_to?(:fingerprint)
     end
 
     # Returns the public URL of the attachment with a given style. This does
@@ -252,16 +235,10 @@ 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.
+    # Returns the fingerprint of the file, if one's defined. The fingerprint is
+    # stored in the <attachment>_fingerpring attribute of the model.
     def fingerprint
-      if instance_read(:fingerprint)
-        instance_read(:fingerprint)
-      elsif @instance.respond_to?("#{name}_fingerprint".to_sym)
-        @queued_for_write[:original] && generate_fingerprint(@queued_for_write[:original])
-      else
-        nil
-      end
+      instance_read(:fingerprint)
     end
 
     # Returns the content_type of the file as originally assigned, and lives
@@ -292,53 +269,21 @@ module Paperclip
       OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@options[:hash_digest]).new, @options[:hash_secret], data)
     end
 
-    def generate_fingerprint(source)
-      if source.respond_to?(:path) && source.path && !source.path.blank?
-        Digest::MD5.file(source.path).to_s
-      else
-        data = source.read
-        source.rewind if source.respond_to?(:rewind)
-        Digest::MD5.hexdigest(data)
-      end
-    end
-
-    # Paths and URLs can have a number of variables interpolated into them
-    # to vary the storage location based on name, id, style, class, etc.
-    # This method is a deprecated access into supplying and retrieving these
-    # interpolations. Future access should use either Paperclip.interpolates
-    # or extend the Paperclip::Interpolations module directly.
-    def self.interpolations
-      warn('[DEPRECATION] Paperclip::Attachment.interpolations is deprecated ' +
-           'and will be removed from future versions. ' +
-           'Use Paperclip.interpolates instead')
-      Paperclip::Interpolations
-    end
-
     # This method really shouldn't be called that often. It's expected use is
     # 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!(*style_args)
-      new_original = Tempfile.new("paperclip-reprocess")
-      new_original.binmode
-      if old_original = to_file(:original)
-        new_original.write( old_original.respond_to?(:get) ? old_original.get : old_original.read )
-        new_original.rewind
-
-        @queued_for_write = { :original => new_original }
-        instance_write(:updated_at, Time.now)
-        post_process(*style_args)
-
-        old_original.close if old_original.respond_to?(:close)
-        old_original.unlink if old_original.respond_to?(:unlink)
-
+      saved_only_process, @options[:only_process] = @options[:only_process], style_args
+      begin
+        assign(self)
         save
-      else
-        true
+      rescue Errno::EACCES => e
+        warn "#{e} - skipping file."
+        false
+      ensure
+        @options[:only_process] = saved_only_process
       end
-    rescue Errno::EACCES => e
-      warn "#{e} - skipping file"
-      false
     end
 
     # Returns true if a file has been assigned.
@@ -348,6 +293,12 @@ module Paperclip
 
     alias :present? :file?
 
+    # Determines whether the instance responds to this attribute. Used to prevent
+    # calculations on fields we won't even store.
+    def instance_respond_to?(attr)
+      instance.respond_to?(:"#{name}_#{attr}")
+    end
+
     # Writes the attachment-specific attribute on the instance. For example,
     # instance_write(:file_name, "me.jpg") will write "me.jpg" to the instance's
     # "avatar_file_name" field (assuming the attachment is called avatar).
@@ -377,7 +328,7 @@ module Paperclip
     def ensure_required_accessors! #:nodoc:
       %w(file_name).each do |field|
         unless @instance.respond_to?("#{name}_#{field}") && @instance.respond_to?("#{name}_#{field}=")
-          raise PaperclipError.new("#{@instance.class} model missing required attr_accessor for '#{name}_#{field}'")
+          raise Paperclip::Error.new("#{@instance.class} model missing required attr_accessor for '#{name}_#{field}'")
         end
       end
     end
@@ -395,7 +346,7 @@ module Paperclip
       begin
         storage_module = Paperclip::Storage.const_get(storage_class_name)
       rescue NameError
-        raise StorageMethodNotFound, "Cannot load storage module '#{storage_class_name}'"
+        raise Errors::StorageMethodNotFound, "Cannot load storage module '#{storage_class_name}'"
       end
       self.extend(storage_module)
     end
@@ -440,7 +391,8 @@ module Paperclip
         @queued_for_write[name] = style.processors.inject(@queued_for_write[:original]) do |file, processor|
           Paperclip.processor(processor).make(file, style.processor_options, self)
         end
-      rescue PaperclipError => e
+        @queued_for_write[name] = Paperclip.io_adapters.for(@queued_for_write[name])
+      rescue Paperclip::Error => e
         log("An error was received while processing: #{e.inspect}")
         (@errors[:processing] ||= []) << e.message if @options[:whiny]
       end
@@ -475,8 +427,8 @@ module Paperclip
     # called by storage after the writes are flushed and before @queued_for_writes is cleared
     def after_flush_writes
       @queued_for_write.each do |style, file|
-        file.close unless file.closed?
-        file.unlink if file.respond_to?(:unlink) && file.path.present? && File.exist?(file.path)
+        # file.close unless file.closed?
+        # file.unlink if file.respond_to?(:unlink) && file.path.present? && File.exist?(file.path)
       end
     end
 

data/lib/paperclip/attachment_options.rb

@@ -1,7 +1,6 @@
 module Paperclip
   class AttachmentOptions < Hash
     def initialize(options)
-      options = {:validations => []}.merge(options)
       options.each do |k, v|
         self.[]=(k, v)
       end

data/lib/paperclip/callbacks.rb

@@ -0,0 +1,30 @@
+module Paperclip
+  module Callbacks
+    def self.included(base)
+      base.extend(Defining)
+      base.send(:include, Running)
+    end
+
+    module Defining
+      def define_paperclip_callbacks(*callbacks)
+        define_callbacks *[callbacks, {:terminator => "result == false"}].flatten
+        callbacks.each do |callback|
+          eval <<-end_callbacks
+            def before_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :before, *args, &blk)
+            end
+            def after_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :after, *args, &blk)
+            end
+          end_callbacks
+        end
+      end
+    end
+
+    module Running
+      def run_paperclip_callbacks(callback, opts = nil, &block)
+        run_callbacks(callback, opts, &block)
+      end
+    end
+  end
+end

data/lib/paperclip/errors.rb

@@ -0,0 +1,27 @@
+module Paperclip
+  # A base error class for Paperclip. Most of the error that will be thrown
+  # from Paperclip will inherits from this class.
+  class Error < StandardError
+  end
+
+  module Errors
+    # Will be thrown when a storage method is not found.
+    class StorageMethodNotFound < Paperclip::Error
+    end
+
+    # Will be thrown when a command or executable is not found.
+    class CommandNotFoundError < Paperclip::Error
+    end
+
+    # Will be thrown when ImageMagic cannot determine the uploaded file's
+    # metadata, usually this would mean the file is not an image.
+    class NotIdentifiedByImageMagickError < Paperclip::Error
+    end
+
+    # Will be thrown if the interpolation is creating an infinite loop. If you
+    # are creating an interpolator which might cause an infinite loop, you
+    # should be throwing this error upon the infinite loop as well.
+    class InfiniteInterpolationError < Paperclip::Error
+    end
+  end
+end

data/lib/paperclip/geometry.rb

@@ -17,16 +17,18 @@ module Paperclip
     # a Tempfile object, which would be eligible for file deletion when no longer referenced.
     def self.from_file file
       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?
+      raise(Errors::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_path}[0]")
+                   silence_stream(STDERR) do
+                     Paperclip.run("identify", "-format %wx%h :file", :file => "#{file_path}[0]")
+                   end
                  rescue Cocaine::ExitStatusError
                    ""
                  rescue Cocaine::CommandNotFoundError => e
-                   raise Paperclip::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
+                   raise Errors::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
                  end
       parse(geometry) ||
-        raise(NotIdentifiedByImageMagickError.new("#{file_path} is not recognized by the 'identify' command."))
+        raise(Errors::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/glue.rb

@@ -0,0 +1,15 @@
+require 'paperclip/callbacks'
+
+module Paperclip
+  module Glue
+    def self.included base #:nodoc:
+      base.extend ClassMethods
+      base.send :include, Callbacks
+      base.send :include, Validators
+      base.class_attribute :attachment_definitions
+
+      locale_path = Dir.glob(File.dirname(__FILE__) + "/locales/*.{rb,yml}")
+      I18n.load_path += locale_path unless I18n.load_path.include?(locale_path)
+    end
+  end
+end

data/lib/paperclip/helpers.rb

@@ -0,0 +1,71 @@
+module Paperclip
+  module Helpers
+    def configure
+      yield(self) if block_given?
+    end
+
+    def interpolates key, &block
+      Paperclip::Interpolations[key] = block
+    end
+
+    # The run method takes the name of a binary to run, the arguments to that binary
+    # and some options:
+    #
+    #   :command_path -> A $PATH-like variable that defines where to look for the binary
+    #                    on the filesystem. Colon-separated, just like $PATH.
+    #
+    #   :expected_outcodes -> An array of integers that defines the expected exit codes
+    #                         of the binary. Defaults to [0].
+    #
+    #   :log_command -> Log the command being run when set to true (defaults to false).
+    #                   This will only log if logging in general is set to true as well.
+    #
+    #   :swallow_stderr -> Set to true if you don't care what happens on STDERR.
+    #
+    def run(cmd, arguments = "", local_options = {})
+      command_path = options[:command_path]
+      Cocaine::CommandLine.path = ( Cocaine::CommandLine.path ? [Cocaine::CommandLine.path].flatten | [command_path] : command_path )
+      local_options = local_options.merge(:logger => logger) if logging? && (options[:log_command] || local_options[:log_command])
+      Cocaine::CommandLine.new(cmd, arguments, local_options).run
+    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)
+      unscope_method = class_for(klass).respond_to?(:unscoped) ? :unscoped : :with_exclusive_scope
+      class_for(klass).send(unscope_method) do
+        class_for(klass).find_each(:conditions => "#{name}_file_name is not null") do |instance|
+          yield(instance)
+        end
+      end
+    end
+
+    def class_for(class_name)
+      # Ruby 1.9 introduces an inherit argument for Module#const_get and
+      # #const_defined? and changes their default behavior.
+      # https://github.com/rails/rails/blob/v3.0.9/activesupport/lib/active_support/inflector/methods.rb#L89
+      if Module.method(:const_get).arity == 1
+        class_name.split('::').inject(Object) do |klass, partial_class_name|
+          klass.const_defined?(partial_class_name) ? klass.const_get(partial_class_name) : klass.const_missing(partial_class_name)
+        end
+      else
+        class_name.split('::').inject(Object) do |klass, partial_class_name|
+          klass.const_defined?(partial_class_name) ? klass.const_get(partial_class_name, false) : klass.const_missing(partial_class_name)
+        end
+      end
+    end
+
+    def check_for_url_clash(name,url,klass)
+      @names_url ||= {}
+      default_url = url || Attachment.default_options[:url]
+      if @names_url[name] && @names_url[name][:url] == default_url && @names_url[name][:class] != klass && @names_url[name][:url] !~ /:class/
+        log("Duplicate URL for #{name} with #{default_url}. This will clash with attachment defined in #{@names_url[name][:class]} class")
+      end
+      @names_url[name] = {:url => default_url, :class => klass}
+    end
+
+    def reset_duplicate_clash_check!
+      @names_url = nil
+    end
+  end
+end

data/lib/paperclip/instance_methods.rb

@@ -0,0 +1,35 @@
+module Paperclip
+  module InstanceMethods #:nodoc:
+    def attachment_for name
+      @_paperclip_attachments ||= {}
+      @_paperclip_attachments[name] ||= Attachment.new(name, self, self.class.attachment_definitions[name])
+    end
+
+    def each_attachment
+      self.class.attachment_definitions.each do |name, definition|
+        yield(name, attachment_for(name))
+      end
+    end
+
+    def save_attached_files
+      Paperclip.log("Saving attachments.")
+      each_attachment do |name, attachment|
+        attachment.send(:save)
+      end
+    end
+
+    def destroy_attached_files
+      Paperclip.log("Deleting attachments.")
+      each_attachment do |name, attachment|
+        attachment.send(:flush_deletes)
+      end
+    end
+
+    def prepare_for_destroy
+      Paperclip.log("Scheduling attachments for deletion.")
+      each_attachment do |name, attachment|
+        attachment.send(:queue_existing_for_delete)
+      end
+    end
+  end
+end

data/lib/paperclip/interpolations.rb

@@ -46,7 +46,7 @@ module Paperclip
     # is used in the default :path to ease default specifications.
     RIGHT_HERE = "#{__FILE__.gsub(%r{^\./}, "")}:#{__LINE__ + 3}"
     def url attachment, style_name
-      raise InfiniteInterpolationError if caller.any?{|b| b.index(RIGHT_HERE) }
+      raise Errors::InfiniteInterpolationError if caller.any?{|b| b.index(RIGHT_HERE) }
       attachment.url(style_name, :timestamp => false, :escape => false)
     end
 
@@ -93,7 +93,7 @@ module Paperclip
     # If the style has a format defined, it will return the format instead
     # of the actual extension.
     def extension attachment, style_name
-      ((style = attachment.styles[style_name.to_sym]) && style[:format]) ||
+      ((style = attachment.styles[style_name.to_s.to_sym]) && style[:format]) ||
         File.extname(attachment.original_filename).gsub(/^\.+/, "")
     end
 

data/lib/paperclip/io_adapters/attachment_adapter.rb

@@ -0,0 +1,62 @@
+module Paperclip
+  class AttachmentAdapter
+
+    def initialize(target)
+      @target = target
+      cache_current_values
+    end
+
+    def original_filename
+      @original_filename
+    end
+
+    def content_type
+      @content_type
+    end
+
+    def size
+      @size
+    end
+
+    def nil?
+      false
+    end
+
+    def fingerprint
+      @fingerprint ||= Digest::MD5.file(path).to_s
+    end
+
+    def read(length = nil, buffer = nil)
+      @tempfile.read(length, buffer)
+    end
+
+    def eof?
+      @tempfile.eof?
+    end
+
+    def path
+      @tempfile.path
+    end
+
+    private
+
+    def cache_current_values
+      @tempfile = copy_to_tempfile(@target)
+      @original_filename = @target.original_filename
+      @content_type = @target.content_type
+      @size = @tempfile.size || @target.size
+    end
+
+    def copy_to_tempfile(src)
+      dest = Tempfile.new(src.original_filename)
+      dest.binmode
+      FileUtils.cp(src.path(:original), dest.path)
+      dest
+    end
+
+  end
+end
+
+Paperclip.io_adapters.register Paperclip::AttachmentAdapter do |target|
+  Paperclip::Attachment === target
+end