paperclip 3.0.3 → 3.5.1

data/lib/paperclip/attachment.rb

@@ -12,7 +12,9 @@ module Paperclip
         :convert_options       => {},
         :default_style         => :original,
         :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,
@@ -27,7 +29,8 @@ 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],
+        :check_validity_before_processing => true
       }
     end
 
@@ -36,7 +39,7 @@ module Paperclip
     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:
@@ -46,7 +49,7 @@ module Paperclip
     # +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
     # +default_url+ - a URL for the missing image
-    # +default_style+ - the style to use when don't specify an argument to e.g. #url, #path
+    # +default_style+ - the style to use when an argument is not specified e.g. #url, #path
     # +storage+ - the storage mechanism. Defaults to :filesystem
     # +use_timestamp+ - whether to append an anti-caching timestamp to image URLs. Defaults to true
     # +whiny+, +whiny_thumbnails+ - whether to raise when thumbnailing fails
@@ -57,9 +60,11 @@ module Paperclip
     # +convert_options+ - flags passed to the +convert+ command for processing
     # +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 to clearing the attachment. Defaults to false
+    # +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
       @instance          = instance
@@ -90,8 +95,8 @@ module Paperclip
       ensure_required_accessors!
       file = Paperclip.io_adapters.for(uploaded_file)
 
-      @options[:only_process].map!(&:to_sym)
-      self.clear(*@options[:only_process])
+      return nil if not file.assignment?
+      self.clear(*only_process)
       return nil if file.nil?
 
       @queued_for_write[:original]   = file
@@ -99,15 +104,18 @@ module Paperclip
       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(*@options[:only_process]) if post_processing
+      post_process(*only_process) if post_processing
 
       # 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)
+      updater = :"#{name}_file_name_will_change!"
+      instance.send updater if instance.respond_to? updater
     end
 
     # Returns the public URL of the attachment with a given style. This does
@@ -133,7 +141,7 @@ 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 => true}
+      default_options = {:timestamp => @options[:use_timestamp], :escape => @options[:escape_url]}
 
       if options == true || options == false # Backwards compatibility.
         @url_generator.for(style_name, default_options.merge(:timestamp => options))
@@ -142,6 +150,13 @@ module Paperclip
       end
     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
@@ -156,6 +171,10 @@ module Paperclip
       url(style_name)
     end
 
+    def as_json(options = nil)
+      to_s((options && options[:style]) || default_style)
+    end
+
     def default_style
       @options[:default_style]
     end
@@ -166,13 +185,19 @@ module Paperclip
         styles = styles.call(self) if styles.respond_to?(:call)
 
         @normalized_styles = styles.dup
-        @normalized_styles.each_pair do |name, options|
+        styles.each_pair do |name, options|
           @normalized_styles[name.to_sym] = Paperclip::Style.new(name.to_sym, options.dup, self)
         end
       end
       @normalized_styles
     end
 
+    def only_process
+      only_process = @options[:only_process].dup
+      only_process = only_process.call(self) if only_process.respond_to?(:call)
+      only_process.map(&:to_sym)
+    end
+
     def processors
       processing_option = @options[:processors]
 
@@ -219,10 +244,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.
@@ -243,7 +266,7 @@ module Paperclip
     end
 
     # Returns the fingerprint of the file, if one's defined. The fingerprint is
-    # stored in the <attachment>_fingerpring attribute of the model.
+    # stored in the <attachment>_fingerprint attribute of the model.
     def fingerprint
       instance_read(:fingerprint)
     end
@@ -254,6 +277,15 @@ module Paperclip
       instance_read(:content_type)
     end
 
+    # Returns the creation time of the file as originally assigned, and
+    # lives in the <attachment>_created_at attribute of the model.
+    def created_at
+      if able_to_store_created_at?
+        time = instance_read(:created_at)
+        time && time.to_f.to_i
+      end
+    end
+
     # 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
@@ -285,6 +317,7 @@ module Paperclip
       begin
         assign(self)
         save
+        instance.save
       rescue Errno::EACCES => e
         warn "#{e} - skipping file."
         false
@@ -300,6 +333,10 @@ module Paperclip
 
     alias :present? :file?
 
+    def blank?
+      not present?
+    end
+
     # Determines whether the instance responds to this attribute. Used to prevent
     # calculations on fields we won't even store.
     def instance_respond_to?(attr)
@@ -311,19 +348,18 @@ module Paperclip
     # "avatar_file_name" field (assuming the attachment is called avatar).
     def instance_write(attr, value)
       setter = :"#{name}_#{attr}="
-      responds = instance.respond_to?(setter)
-      self.instance_variable_set("@_#{setter.to_s.chop}", value)
-      instance.send(setter, value) if responds || attr.to_s == "file_name"
+      if instance.respond_to?(setter)
+        instance.send(setter, value)
+      end
     end
 
     # Reads the attachment-specific attribute on the instance. See instance_write
     # for more details.
     def instance_read(attr)
       getter = :"#{name}_#{attr}"
-      responds = instance.respond_to?(getter)
-      cached = self.instance_variable_get("@_#{getter}")
-      return cached if cached
-      instance.send(getter) if responds || attr.to_s == "file_name"
+      if instance.respond_to?(getter)
+        instance.send(getter)
+      end
     end
 
     private
@@ -344,10 +380,6 @@ module Paperclip
       Paperclip.log(message)
     end
 
-    def valid_assignment? file #:nodoc:
-      file.nil? || (file.respond_to?(:original_filename) && file.respond_to?(:content_type))
-    end
-
     def initialize_storage #:nodoc:
       storage_class_name = @options[:storage].to_s.downcase.camelize
       begin
@@ -359,18 +391,17 @@ module Paperclip
     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)
-
-      [ style_options, all_options ].compact.join(" ")
+      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(" ")
@@ -381,7 +412,9 @@ module Paperclip
 
       instance.run_paperclip_callbacks(:post_process) do
         instance.run_paperclip_callbacks(:"#{name}_post_process") do
-          post_process_styles(*style_args)
+          unless @options[:check_validity_before_processing] && instance.errors.any?
+            post_process_styles(*style_args)
+          end
         end
       end
     end
@@ -421,14 +454,17 @@ 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)
       instance_write(:fingerprint, nil)
+      instance_write(:created_at, nil) if has_enabled_but_unset_created_at?
       instance_write(:updated_at, nil)
     end
 
@@ -440,14 +476,31 @@ 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)
+       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 filenme.
+    def filename_cleaner
+      @options[:filename_cleaner] || FilenameCleaner.new(@options[:restricted_characters])
     end
 
     def cleanup_filename(filename)
-      if @options[:restricted_characters]
-        filename.gsub(@options[:restricted_characters], '_')
-      else
-        filename
-      end
+      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)
+    end
+
+    # Check if attachment database table has a created_at field which is not yet set
+    def has_enabled_but_unset_created_at?
+      able_to_store_created_at? && !instance_read(:created_at)
     end
   end
 end

data/lib/paperclip/attachment_registry.rb

@@ -0,0 +1,57 @@
+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)
+      @attachments[klass]
+    end
+  end
+end

data/lib/paperclip/callbacks.rb

@@ -22,8 +22,8 @@ module Paperclip
     end
 
     module Running
-      def run_paperclip_callbacks(callback, opts = nil, &block)
-        run_callbacks(callback, opts, &block)
+      def run_paperclip_callbacks(callback, &block)
+        run_callbacks(callback, &block)
       end
     end
   end

data/lib/paperclip/content_type_detector.rb

@@ -0,0 +1,78 @@
+module Paperclip
+  class ContentTypeDetector
+    # The content-type detection strategy is as follows:
+    #
+    # 1. Blank/Empty files: If there's no filename 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
+    end
+
+    # Returns a String describing the file's content type
+    def detect
+      if blank_name?
+        SENSIBLE_DEFAULT
+      elsif empty_file?
+        EMPTY_TYPE
+      elsif calculated_type_matches.any?
+        calculated_type_matches.first
+      elsif official_type_matches.any?
+        official_type_matches.first
+      elsif unofficial_type_matches.any?
+        unofficial_type_matches.first
+      else
+        type_from_file_command || SENSIBLE_DEFAULT
+      end.to_s
+    end
+
+    private
+
+    def empty_file?
+      File.exists?(@filename) && File.size(@filename) == 0
+    end
+
+    def blank_name?
+      @filename.nil? || @filename.empty?
+    end
+
+    def empty?
+      File.exists?(@filename) && File.size(@filename) == 0
+    end
+
+    def possible_types
+      MIME::Types.type_for(@filename).collect(&:content_type)
+    end
+
+    def calculated_type_matches
+      possible_types.select{|content_type| content_type == type_from_file_command }
+    end
+
+    def official_type_matches
+      possible_types.reject{|content_type| content_type.match(/\/x-/) }
+    end
+
+    def unofficial_type_matches
+      possible_types.select{|content_type| content_type.match(/\/x-/) }
+    end
+
+    def type_from_file_command
+      @type_from_file_command ||= FileCommandContentTypeDetector.new(@filename).detect
+    end
+  end
+end

data/lib/paperclip/file_command_content_type_detector.rb

@@ -0,0 +1,32 @@
+module Paperclip
+  class FileCommandContentTypeDetector
+    SENSIBLE_DEFAULT = "application/octet-stream"
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def detect
+      type_from_file_command
+    end
+
+    private
+
+    def type_from_file_command
+      type = begin
+        # On BSDs, `file` doesn't give a result code of 1 if the file doesn't exist.
+        Paperclip.run("file", "-b --mime :file", :file => @filename)
+      rescue Cocaine::CommandLineError => e
+        Paperclip.log("Error while determining content type: #{e}")
+        SENSIBLE_DEFAULT
+      end
+
+      if type.nil? || type.match(/\(.*?\)/)
+        type = SENSIBLE_DEFAULT
+      end
+      type.split(/[:;\s]+/)[0]
+    end
+
+  end
+end
+

data/lib/paperclip/filename_cleaner.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Paperclip
+  class FilenameCleaner
+    def initialize(invalid_character_regex)
+      @invalid_character_regex = invalid_character_regex
+    end
+
+    def call(filename)
+      if @invalid_character_regex
+        filename.gsub(@invalid_character_regex, "_")
+      else
+        filename
+      end
+    end
+  end
+end

data/lib/paperclip/geometry.rb

@@ -4,37 +4,40 @@ module Paperclip
   class Geometry
     attr_accessor :height, :width, :modifier
 
+    EXIF_ROTATED_ORIENTATION_VALUES = [5, 6, 7, 8]
+
     # Gives a Geometry representing the given height and width
-    def initialize width = nil, height = nil, modifier = nil
-      @height = height.to_f
-      @width  = width.to_f
-      @modifier = modifier
-    end
-
-    # 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_path = file.respond_to?(:path) ? file.path : file
-      raise(Errors::NotIdentifiedByImageMagickError.new("Cannot find the geometry of a file with a blank name")) if file_path.blank?
-      geometry = begin
-                   silence_stream(STDERR) do
-                     Paperclip.run("identify", "-format %wx%h :file", :file => "#{file_path}[0]")
-                   end
-                 rescue Cocaine::ExitStatusError
-                   ""
-                 rescue Cocaine::CommandNotFoundError => e
-                   raise Errors::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
-                 end
-      parse(geometry) ||
-        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.
-    def self.parse string
-      if match = (string && string.match(/\b(\d*)x?(\d*)\b([\>\<\#\@\%^!])?/i))
-        Geometry.new(*match[1,3])
+    def initialize(width = nil, height = nil, modifier = nil)
+      if width.is_a?(Hash)
+        options = width
+        @height = options[:height].to_f
+        @width = options[:width].to_f
+        @modifier = options[:modifier]
+        @orientation = options[:orientation].to_i
+      else
+        @height = height.to_f
+        @width  = width.to_f
+        @modifier = modifier
+      end
+    end
+
+    # Extracts the Geometry from a file (or path to a file)
+    def self.from_file(file)
+      GeometryDetector.new(file).make
+    end
+
+    # Extracts the Geometry from a "WxH,O" string
+    # Where W is the width, H is the height,
+    # and O is the EXIF orientation
+    def self.parse(string)
+      GeometryParser.new(string).make
+    end
+
+    # Swaps the height and width if necessary
+    def auto_orient
+      if EXIF_ROTATED_ORIENTATION_VALUES.include?(@orientation)
+        @height, @width = @width, @height
+        @orientation -= 4
       end
     end
 
@@ -101,6 +104,33 @@ module Paperclip
       [ scale_geometry, crop_geometry ]
     end
 
+    # resize to a new geometry
+    # @param geometry [String] the Paperclip geometry definition to resize to
+    # @example
+    #   Paperclip::Geometry.new(150, 150).resize_to('50x50!')
+    #   #=> Paperclip::Geometry(50, 50)
+    def resize_to(geometry)
+      new_geometry = Paperclip::Geometry.parse geometry
+      case new_geometry.modifier
+      when '!', '#'
+        new_geometry
+      when '>'
+        if new_geometry.width >= self.width && new_geometry.height >= self.height
+          self
+        else
+          scale_to new_geometry
+        end
+      when '<'
+        if new_geometry.width <= self.width || new_geometry.height <= self.height
+          self
+        else
+          scale_to new_geometry
+        end
+      else
+        scale_to new_geometry
+      end
+    end
+
     private
 
     def scaling dst, ratio
@@ -118,5 +148,11 @@ module Paperclip
         "%dx%d+%d+%d" % [ dst.width, dst.height, (self.width * scale - dst.width) / 2, 0 ]
       end
     end
+
+    # scale to the requested geometry and preserve the aspect ratio
+    def scale_to(new_geometry)
+      scale = [new_geometry.width.to_f / self.width.to_f , new_geometry.height.to_f / self.height.to_f].min
+      Paperclip::Geometry.new((self.width * scale).round, (self.height * scale).round)
+    end
   end
 end

data/lib/paperclip/geometry_detector_factory.rb

@@ -0,0 +1,41 @@
+module Paperclip
+  class GeometryDetector
+    def initialize(file)
+      @file = file
+      raise_if_blank_file
+    end
+
+    def make
+      geometry = GeometryParser.new(geometry_string.strip).make
+      geometry || raise(Errors::NotIdentifiedByImageMagickError.new)
+    end
+
+    private
+
+    def geometry_string
+      begin
+        silence_stream(STDERR) do
+          Paperclip.run("identify", "-format '%wx%h,%[exif:orientation]' :file", :file => "#{path}[0]")
+        end
+      rescue Cocaine::ExitStatusError
+        ""
+      rescue Cocaine::CommandNotFoundError => e
+        raise_because_imagemagick_missing
+      end
+    end
+
+    def path
+      @file.respond_to?(:path) ? @file.path : @file
+    end
+
+    def raise_if_blank_file
+      if path.blank?
+        raise Errors::NotIdentifiedByImageMagickError.new("Cannot find the geometry of a file with a blank name")
+      end
+    end
+
+    def raise_because_imagemagick_missing
+      raise Errors::CommandNotFoundError.new("Could not run the `identify` command. Please install ImageMagick.")
+    end
+  end
+end