paperclip 3.4.0 → 6.1.0

data/lib/paperclip/attachment.rb

@@ -1,6 +1,7 @@
-# encoding: utf-8
 require 'uri'
 require 'paperclip/url_generator'
+require 'active_support/deprecation'
+require 'active_support/core_ext/string/inflections'
 
 module Paperclip
   # The Attachment class manages the files for a given attachment. It saves
@@ -14,6 +15,7 @@ module Paperclip
         :default_url           => "/:attachment/:style/missing.png",
         :escape_url            => true,
         :restricted_characters => /[&$+,\/:;=?@<>\[\]\{\}\|\\\^~%# ]/,
+        :filename_cleaner      => nil,
         :hash_data             => ":class/:attachment/:id/:style/:updated_at",
         :hash_digest           => "SHA1",
         :interpolator          => Paperclip::Interpolations,
@@ -28,16 +30,19 @@ module Paperclip
         :url_generator         => Paperclip::UrlGenerator,
         :use_default_time_zone => true,
         :use_timestamp         => true,
-        :whiny                 => Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails]
+        :whiny                 => Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails],
+        :validate_media_type   => true,
+        :adapter_options       => { hash_digest: Digest::MD5 },
+        :check_validity_before_processing => true
       }
     end
 
     attr_reader :name, :instance, :default_style, :convert_options, :queued_for_write, :whiny,
-                :options, :interpolator, :source_file_options, :whiny
+                :options, :interpolator, :source_file_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
+    # +instance+ is the model object instance it's attached to, and
     # +options+ is the same as the hash passed to +has_attached_file+.
     #
     # Options include:
@@ -45,7 +50,8 @@ module Paperclip
     # +url+ - a relative URL of the attachment. This is interpolated using +interpolator+
     # +path+ - where on the filesystem to store the attachment. This is interpolated using +interpolator+
     # +styles+ - a hash of options for processing the attachment. See +has_attached_file+ for the details
-    # +only_process+ - style args to be run through the post-processor. This defaults to the empty list
+    # +only_process+ - style args to be run through the post-processor. This defaults to the empty list (which is
+    #                  a special case that indicates all styles should be processed)
     # +default_url+ - a URL for the missing image
     # +default_style+ - the style to use when an argument is not specified e.g. #url, #path
     # +storage+ - the storage mechanism. Defaults to :filesystem
@@ -59,14 +65,16 @@ module Paperclip
     # +source_file_options+ - flags passed to the +convert+ command that controls how the file is read
     # +processors+ - classes that transform the attachment. Defaults to [:thumbnail]
     # +preserve_files+ - whether to keep files on the filesystem when deleting or clearing the attachment. Defaults to false
+    # +filename_cleaner+ - An object that responds to #call(filename) that will strip unacceptable charcters from filename
     # +interpolator+ - the object used to interpolate filenames and URLs. Defaults to Paperclip::Interpolations
     # +url_generator+ - the object used to generate URLs, using the interpolator. Defaults to Paperclip::UrlGenerator
     # +escape_url+ - Perform URI escaping to URLs. Defaults to true
     def initialize(name, instance, options = {})
-      @name              = name
+      @name              = name.to_sym
+      @name_string       = name.to_s
       @instance          = instance
 
-      options = self.class.default_options.merge(options)
+      options = self.class.default_options.deep_merge(options)
 
       @options               = options
       @post_processing       = true
@@ -75,7 +83,7 @@ module Paperclip
       @errors                = {}
       @dirty                 = false
       @interpolator          = options[:interpolator]
-      @url_generator         = options[:url_generator].new(self, @options)
+      @url_generator         = options[:url_generator].new(self)
       @source_file_options   = options[:source_file_options]
       @whiny                 = options[:whiny]
 
@@ -83,33 +91,30 @@ module Paperclip
     end
 
     # What gets called when you call instance.attachment = File. It clears
-    # 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:
+    # 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
-    def assign uploaded_file
+    def assign(uploaded_file)
+      @file = Paperclip.io_adapters.for(uploaded_file,
+                                        @options[:adapter_options])
       ensure_required_accessors!
-      file = Paperclip.io_adapters.for(uploaded_file)
+      ensure_required_validations!
 
-      self.clear(*only_process)
-      return nil if file.nil?
+      if @file.assignment?
+        clear(*only_process)
 
-      @queued_for_write[:original]   = file
-      instance_write(:file_name,       cleanup_filename(file.original_filename))
-      instance_write(:content_type,    file.content_type.to_s.strip)
-      instance_write(:file_size,       file.size)
-      instance_write(:fingerprint,     file.fingerprint) if instance_respond_to?(:fingerprint)
-      instance_write(:created_at,      Time.now) if has_enabled_but_unset_created_at?
-      instance_write(:updated_at,      Time.now)
-
-      @dirty = true
-
-      post_process(*only_process) if post_processing && valid_assignment?
-
-      # Reset the file size if the original file was reprocessed.
-      instance_write(:file_size,   @queued_for_write[:original].size)
-      instance_write(:fingerprint, @queued_for_write[:original].fingerprint) if instance_respond_to?(:fingerprint)
+        if @file.nil?
+          nil
+        else
+          assign_attributes
+          post_process_file
+          reset_file_if_original_reprocessed
+        end
+      else
+        nil
+      end
     end
 
     # Returns the public URL of the attachment with a given style. This does
@@ -134,9 +139,8 @@ module Paperclip
     #
     # +#new(Paperclip::Attachment, options_hash)+
     # +#for(style_name, options_hash)+
-    def url(style_name = default_style, options = {})
-      default_options = {:timestamp => @options[:use_timestamp], :escape => @options[:escape_url]}
 
+    def url(style_name = default_style, options = {})
       if options == true || options == false # Backwards compatibility.
         @url_generator.for(style_name, default_options.merge(:timestamp => options))
       else
@@ -144,6 +148,20 @@ module Paperclip
       end
     end
 
+    def default_options
+      {
+        :timestamp => @options[:use_timestamp],
+        :escape => @options[:escape_url]
+      }
+    end
+
+    # Alias to +url+ that allows using the expiring_url method provided by the cloud
+    # storage implementations, but keep using filesystem storage for development and
+    # testing.
+    def expiring_url(time = 3600, style_name = default_style)
+      url(style_name)
+    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
@@ -153,6 +171,18 @@ module Paperclip
       path.respond_to?(:unescape) ? path.unescape : path
     end
 
+    # :nodoc:
+    def staged_path(style_name = default_style)
+      if staged?
+        @queued_for_write[style_name].path
+      end
+    end
+
+    # :nodoc:
+    def staged?
+      ! @queued_for_write.empty?
+    end
+
     # Alias to +url+
     def to_s style_name = default_style
       url(style_name)
@@ -209,6 +239,10 @@ module Paperclip
     # the instance's errors and returns false, cancelling the save.
     def save
       flush_deletes unless @options[:keep_old_files]
+      process = only_process
+      if process.any? && !process.include?(:original)
+        @queued_for_write.except!(:original)
+      end
       flush_writes
       @dirty = false
       true
@@ -231,10 +265,8 @@ 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 @options[:preserve_files]
-        clear
-        save
-      end
+      clear
+      save
     end
 
     # Returns the uploaded file if present.
@@ -297,12 +329,23 @@ module Paperclip
       OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@options[:hash_digest]).new, @options[:hash_secret], data)
     end
 
-    # This method really shouldn't be called that often. It's expected use is
+    # This method really shouldn't be called that often. Its 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.
+    # NOTE: Calling reprocess WILL NOT delete existing files. This is due to
+    # inconsistencies in timing of S3 commands. It's possible that calling
+    # #reprocess! will lose data if the files are not kept.
     def reprocess!(*style_args)
-      saved_only_process, @options[:only_process] = @options[:only_process], style_args
+      saved_flags = @options.slice(
+        :only_process,
+        :preserve_files,
+        :check_validity_before_processing
+      )
+      @options[:only_process] = style_args
+      @options[:preserve_files] = true
+      @options[:check_validity_before_processing] = false
+
       begin
         assign(self)
         save
@@ -311,13 +354,13 @@ module Paperclip
         warn "#{e} - skipping file."
         false
       ensure
-        @options[:only_process] = saved_only_process
+        @options.merge!(saved_flags)
       end
     end
 
     # Returns true if a file has been assigned.
     def file?
-      !original_filename.blank?
+      original_filename.present?
     end
 
     alias :present? :file?
@@ -336,7 +379,7 @@ module Paperclip
     # instance_write(:file_name, "me.jpg") will write "me.jpg" to the instance's
     # "avatar_file_name" field (assuming the attachment is called avatar).
     def instance_write(attr, value)
-      setter = :"#{name}_#{attr}="
+      setter = :"#{@name_string}_#{attr}="
       if instance.respond_to?(setter)
         instance.send(setter, value)
       end
@@ -345,7 +388,7 @@ module Paperclip
     # Reads the attachment-specific attribute on the instance. See instance_write
     # for more details.
     def instance_read(attr)
-      getter = :"#{name}_#{attr}"
+      getter = :"#{@name_string}_#{attr}"
       if instance.respond_to?(getter)
         instance.send(getter)
       end
@@ -357,10 +400,24 @@ module Paperclip
       @options[:path].respond_to?(:call) ? @options[:path].call(self) : @options[:path]
     end
 
+    def active_validator_classes
+      @instance.class.validators.map(&:class)
+    end
+
+    def missing_required_validator?
+      (active_validator_classes.flat_map(&:ancestors) & Paperclip::REQUIRED_VALIDATORS).empty?
+    end
+
+    def ensure_required_validations!
+      if missing_required_validator?
+        raise Paperclip::Errors::MissingRequiredValidatorError
+      end
+    end
+
     def ensure_required_accessors! #:nodoc:
       %w(file_name).each do |field|
-        unless @instance.respond_to?("#{name}_#{field}") && @instance.respond_to?("#{name}_#{field}=")
-          raise Paperclip::Error.new("#{@instance.class} model missing required attr_accessor for '#{name}_#{field}'")
+        unless @instance.respond_to?("#{@name_string}_#{field}") && @instance.respond_to?("#{@name_string}_#{field}=")
+          raise Paperclip::Error.new("#{@instance.class} model missing required attr_accessor for '#{@name_string}_#{field}'")
         end
       end
     end
@@ -369,16 +426,6 @@ module Paperclip
       Paperclip.log(message)
     end
 
-    def valid_assignment? #:nodoc:
-      if instance.valid?
-        true
-      else
-        instance.errors.none? do |attr, message|
-          attr.to_s.start_with?(@name.to_s)
-        end
-      end
-    end
-
     def initialize_storage #:nodoc:
       storage_class_name = @options[:storage].to_s.downcase.camelize
       begin
@@ -389,19 +436,73 @@ module Paperclip
       self.extend(storage_module)
     end
 
-    def extra_options_for(style) #:nodoc:
-      all_options   = @options[:convert_options][:all]
-      all_options   = all_options.call(instance)   if all_options.respond_to?(:call)
-      style_options = @options[:convert_options][style]
-      style_options = style_options.call(instance) if style_options.respond_to?(:call)
+    def assign_attributes
+      @queued_for_write[:original] = @file
+      assign_file_information
+      assign_fingerprint { @file.fingerprint }
+      assign_timestamps
+    end
 
-      [ style_options, all_options ].compact.join(" ")
+    def assign_file_information
+      instance_write(:file_name, cleanup_filename(@file.original_filename))
+      instance_write(:content_type, @file.content_type.to_s.strip)
+      instance_write(:file_size, @file.size)
+    end
+
+    def assign_fingerprint
+      if instance_respond_to?(:fingerprint)
+        instance_write(:fingerprint, yield)
+      end
+    end
+
+    def assign_timestamps
+      if has_enabled_but_unset_created_at?
+        instance_write(:created_at, Time.now)
+      end
+
+      instance_write(:updated_at, Time.now)
+    end
+
+    def post_process_file
+      dirty!
+
+      if post_processing
+        post_process(*only_process)
+      end
+    end
+
+    def dirty!
+      @dirty = true
+    end
+
+    def reset_file_if_original_reprocessed
+      instance_write(:file_size, @queued_for_write[:original].size)
+      assign_fingerprint { @queued_for_write[:original].fingerprint }
+      reset_updater
+    end
+
+    def reset_updater
+      if instance.respond_to?(updater)
+        instance.send(updater)
+      end
+    end
+
+    def updater
+      :"#{name}_file_name_will_change!"
+    end
+
+    def extra_options_for(style) #:nodoc:
+      process_options(:convert_options, style)
     end
 
     def extra_source_file_options_for(style) #:nodoc:
-      all_options   = @options[:source_file_options][:all]
+      process_options(:source_file_options, style)
+    end
+
+    def process_options(options_type, style) #:nodoc:
+      all_options   = @options[options_type][:all]
       all_options   = all_options.call(instance)   if all_options.respond_to?(:call)
-      style_options = @options[:source_file_options][style]
+      style_options = @options[options_type][style]
       style_options = style_options.call(instance) if style_options.respond_to?(:call)
 
       [ style_options, all_options ].compact.join(" ")
@@ -412,7 +513,9 @@ module Paperclip
 
       instance.run_paperclip_callbacks(:post_process) do
         instance.run_paperclip_callbacks(:"#{name}_post_process") do
-          post_process_styles(*style_args)
+          if !@options[:check_validity_before_processing] || !instance.errors.any?
+            post_process_styles(*style_args)
+          end
         end
       end
     end
@@ -427,13 +530,30 @@ module Paperclip
     def post_process_style(name, style) #:nodoc:
       begin
         raise RuntimeError.new("Style #{name} has no processors defined.") if style.processors.blank?
-        @queued_for_write[name] = style.processors.inject(@queued_for_write[:original]) do |file, processor|
-          Paperclip.processor(processor).make(file, style.processor_options, self)
+        intermediate_files = []
+        original = @queued_for_write[:original]
+
+        @queued_for_write[name] = style.processors.
+          reduce(original) do |file, processor|
+          file = Paperclip.processor(processor).make(file, style.processor_options, self)
+          intermediate_files << file unless file == @queued_for_write[:original]
+          # if we're processing the original, close + unlink the source tempfile
+          if name == :original
+            @queued_for_write[:original].close(true)
+          end
+          file
         end
-        @queued_for_write[name] = Paperclip.io_adapters.for(@queued_for_write[name])
-      rescue Paperclip::Error => e
+
+        unadapted_file = @queued_for_write[name]
+        @queued_for_write[name] = Paperclip.io_adapters.
+          for(@queued_for_write[name], @options[:adapter_options])
+        unadapted_file.close if unadapted_file.respond_to?(:close)
+        @queued_for_write[name]
+      rescue Paperclip::Errors::NotIdentifiedByImageMagickError => e
         log("An error was received while processing: #{e.inspect}")
         (@errors[:processing] ||= []) << e.message if @options[:whiny]
+      ensure
+        unlink_files(intermediate_files)
       end
     end
 
@@ -452,10 +572,12 @@ module Paperclip
     end
 
     def queue_all_for_delete #:nodoc:
-      return if @options[:preserve_files] || !file?
-      @queued_for_delete += [:original, *styles.keys].uniq.map do |style|
-        path(style) if exists?(style)
-      end.compact
+      return if !file?
+      unless @options[:preserve_files]
+        @queued_for_delete += [:original, *styles.keys].uniq.map do |style|
+          path(style) if exists?(style)
+        end.compact
+      end
       instance_write(:file_name, nil)
       instance_write(:content_type, nil)
       instance_write(:file_size, nil)
@@ -470,22 +592,33 @@ module Paperclip
       end
     end
 
-    # called by storage after the writes are flushed and before @queued_for_writes is cleared
+    # called by storage after the writes are flushed and before @queued_for_write 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)
-       end
+      unlink_files(@queued_for_write.values)
     end
 
-    def cleanup_filename(filename)
-      if @options[:restricted_characters]
-        filename.gsub(@options[:restricted_characters], '_')
-      else
-        filename
+    def unlink_files(files)
+      Array(files).each do |file|
+        file.close unless file.closed?
+
+        begin
+          file.unlink if file.respond_to?(:unlink)
+        rescue Errno::ENOENT
+        end
       end
     end
 
+    # You can either specifiy :restricted_characters or you can define your own
+    # :filename_cleaner object. This object needs to respond to #call and takes
+    # the filename that will be cleaned. It should return the cleaned filename.
+    def filename_cleaner
+      @options[:filename_cleaner] || FilenameCleaner.new(@options[:restricted_characters])
+    end
+
+    def cleanup_filename(filename)
+      filename_cleaner.call(filename)
+    end
+
     # Check if attachment database table has a created_at field
     def able_to_store_created_at?
       @instance.respond_to?("#{name}_created_at".to_sym)

data/lib/paperclip/attachment_registry.rb

@@ -0,0 +1,60 @@
+require 'singleton'
+
+module Paperclip
+  class AttachmentRegistry
+    include Singleton
+
+    def self.register(klass, attachment_name, attachment_options)
+      instance.register(klass, attachment_name, attachment_options)
+    end
+
+    def self.clear
+      instance.clear
+    end
+
+    def self.names_for(klass)
+      instance.names_for(klass)
+    end
+
+    def self.each_definition(&block)
+      instance.each_definition(&block)
+    end
+
+    def self.definitions_for(klass)
+      instance.definitions_for(klass)
+    end
+
+    def initialize
+      clear
+    end
+
+    def register(klass, attachment_name, attachment_options)
+      @attachments ||= {}
+      @attachments[klass] ||= {}
+      @attachments[klass][attachment_name] = attachment_options
+    end
+
+    def clear
+      @attachments = Hash.new { |h,k| h[k] = {} }
+    end
+
+    def names_for(klass)
+      @attachments[klass].keys
+    end
+
+    def each_definition
+      @attachments.each do |klass, attachments|
+        attachments.each do |name, options|
+          yield klass, name, options
+        end
+      end
+    end
+
+    def definitions_for(klass)
+      parent_classes = klass.ancestors.reverse
+      parent_classes.each_with_object({}) do |ancestor, inherited_definitions|
+        inherited_definitions.deep_merge! @attachments[ancestor]
+      end
+    end
+  end
+end

data/lib/paperclip/callbacks.rb

@@ -7,7 +7,7 @@ module Paperclip
 
     module Defining
       def define_paperclip_callbacks(*callbacks)
-        define_callbacks *[callbacks, {:terminator => "result == false"}].flatten
+        define_callbacks(*[callbacks, { terminator: hasta_la_vista_baby }].flatten)
         callbacks.each do |callback|
           eval <<-end_callbacks
             def before_#{callback}(*args, &blk)
@@ -19,6 +19,18 @@ module Paperclip
           end_callbacks
         end
       end
+
+      private
+
+      def hasta_la_vista_baby
+        lambda do |_, result|
+          if result.respond_to?(:call)
+            result.call == false
+          else
+            result == false
+          end
+        end
+      end
     end
 
     module Running

data/lib/paperclip/content_type_detector.rb

@@ -1,56 +1,80 @@
 module Paperclip
   class ContentTypeDetector
+    # The content-type detection strategy is as follows:
+    #
+    # 1. Blank/Empty files: If there's no filepath or the file is empty,
+    #    provide a sensible default (application/octet-stream or inode/x-empty)
+    #
+    # 2. Calculated match: Return the first result that is found by both the
+    #    `file` command and MIME::Types.
+    #
+    # 3. Standard types: Return the first standard (without an x- prefix) entry
+    #    in MIME::Types
+    #
+    # 4. Experimental types: If there were no standard types in MIME::Types
+    #    list, try to return the first experimental one
+    #
+    # 5. Raw `file` command: Just use the output of the `file` command raw, or
+    #    a sensible default. This is cached from Step 2.
+
     EMPTY_TYPE = "inode/x-empty"
     SENSIBLE_DEFAULT = "application/octet-stream"
 
-    def initialize(filename)
-      @filename = filename
+    def initialize(filepath)
+      @filepath = filepath
     end
 
+    # Returns a String describing the file's content type
     def detect
-      if blank?
+      if blank_name?
         SENSIBLE_DEFAULT
-      elsif empty?
+      elsif empty_file?
         EMPTY_TYPE
-      elsif !match?
-        type_from_file_command
-      elsif !multiple?
-        possible_types.first
+      elsif calculated_type_matches.any?
+        calculated_type_matches.first
       else
-        best_type_match
+        type_from_file_contents || SENSIBLE_DEFAULT
       end.to_s
     end
 
     private
 
-    def empty?
-      File.exists?(@filename) && File.size(@filename) == 0
+    def blank_name?
+      @filepath.nil? || @filepath.empty?
     end
 
-    def blank?
-      @filename.nil? || @filename.empty?
+    def empty_file?
+      File.exist?(@filepath) && File.size(@filepath) == 0
     end
 
-    def possible_types
-      @possible_types ||= MIME::Types.type_for(@filename)
+    alias :empty? :empty_file?
+
+    def calculated_type_matches
+      possible_types.select do |content_type|
+        content_type == type_from_file_contents
+      end
     end
 
-    def match?
-      possible_types.length > 0
+    def possible_types
+      MIME::Types.type_for(@filepath).collect(&:content_type)
     end
 
-    def multiple?
-      possible_types.length > 1
+    def type_from_file_contents
+      type_from_mime_magic || type_from_file_command
+    rescue Errno::ENOENT => e
+      Paperclip.log("Error while determining content type: #{e}")
+      SENSIBLE_DEFAULT
     end
 
-    def best_type_match
-      official_types = possible_types.reject {|type| type.content_type.match(/\/x-/) }
-      (official_types.first || possible_types.first).content_type
+    def type_from_mime_magic
+      @type_from_mime_magic ||= File.open(@filepath) do |file|
+        MimeMagic.by_magic(file).try(:type)
+      end
     end
 
     def type_from_file_command
-      FileCommandContentTypeDetector.new(@filename).detect
+      @type_from_file_command ||=
+        FileCommandContentTypeDetector.new(@filepath).detect
     end
-
   end
 end