paperclip 2.1.0 → 2.1.2

data/lib/paperclip.rb

@@ -36,7 +36,7 @@ require 'paperclip/attachment'
 # The base module that gets included in ActiveRecord::Base.
 module Paperclip
 
-  VERSION = "2.1.0"
+  VERSION = "2.1.2"
 
   class << self
     # Provides configurability to Paperclip. There are a number of options available, such as:
@@ -65,6 +65,9 @@ module Paperclip
   class PaperclipError < StandardError #:nodoc:
   end
 
+  class NotIdentifiedByImageMagickError < PaperclipError #:nodoc:
+  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. 
@@ -131,7 +134,7 @@ module Paperclip
       end
 
       define_method "#{name}?" do
-        ! attachment_for(name).file.nil?
+        ! attachment_for(name).original_filename.blank?
       end
 
       validates_each(name) do |record, attr, value|
@@ -144,6 +147,7 @@ module Paperclip
     # * +in+: a Range of bytes (i.e. +1..1.megabyte+),
     # * +less_than+: equivalent to :in => 0..options[:less_than]
     # * +greater_than+: equivalent to :in => options[:greater_than]..Infinity
+    # * +message+: error message to display, use :min and :max as replacements
     def validates_attachment_size name, options = {}
       attachment_definitions[name][:validations] << lambda do |attachment, instance|
         unless options[:greater_than].nil?
@@ -152,17 +156,48 @@ module Paperclip
         unless options[:less_than].nil?
           options[:in] = (0..options[:less_than])
         end
-        unless options[:in].include? instance[:"#{name}_file_size"].to_i
-          "file size is not between #{options[:in].first} and #{options[:in].last} bytes."
+        unless attachment.original_filename.blank? || options[:in].include?(instance[:"#{name}_file_size"].to_i)
+          min = options[:in].first
+          max = options[:in].last
+          
+          if options[:message]
+            options[:message].gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
+          else
+            "file size is not between #{min} and #{max} bytes."
+          end
         end
       end
     end
 
+    # Adds errors if thumbnail creation fails. The same as specifying :whiny_thumbnails => true.
+    def validates_attachment_thumbnails name, options = {}
+      attachment_definitions[name][:whiny_thumbnails] = true
+    end
+
     # Places ActiveRecord-style validations on the presence of a file.
-    def validates_attachment_presence name
+    def validates_attachment_presence name, options = {}
+      attachment_definitions[name][:validations] << lambda do |attachment, instance|
+        if attachment.original_filename.blank?
+          options[:message] || "must be set."
+        end
+      end
+    end
+    
+    # Places ActiveRecord-style validations on the content type of the file assigned. The
+    # possible options are:
+    # * +content_type+: Allowed content types.  Can be a single content type or an array.  Allows all by default.
+    # * +message+: The message to display when the uploaded file has an invalid content type.
+    def validates_attachment_content_type name, options = {}
       attachment_definitions[name][:validations] << lambda do |attachment, instance|
-        if attachment.file.nil? || !File.exist?(attachment.file.path)
-          "must be set."
+        valid_types = [options[:content_type]].flatten
+        
+        unless attachment.original_filename.nil?
+          unless options[:content_type].blank?
+            content_type = instance[:"#{name}_content_type"]
+            unless valid_types.any?{|t| t === content_type }
+              options[:message] || ActiveRecord::Errors.default_error_messages[:inclusion]
+            end
+          end
         end
       end
     end

data/lib/paperclip/attachment.rb

@@ -15,7 +15,7 @@ module Paperclip
       }
     end
 
-    attr_reader :name, :instance, :file, :styles, :default_style
+    attr_reader :name, :instance, :styles, :default_style
 
     # Creates an Attachment object. +name+ is the name of the attachment, +instance+ is the
     # ActiveRecord object instance it's attached to, and +options+ is the same as the hash
@@ -33,21 +33,16 @@ module Paperclip
       @validations       = options[:validations]
       @default_style     = options[:default_style]
       @storage           = options[:storage]
+      @whiny_thumbnails  = options[:whiny_thumbnails]
       @options           = options
       @queued_for_delete = []
-      @processed_files   = {}
+      @queued_for_write  = {}
       @errors            = []
-      @file              = nil
       @validation_errors = nil
       @dirty             = false
 
       normalize_style_definition
       initialize_storage
-
-      if original_filename
-        @processed_files = locate_files
-        @file            = @processed_files[@default_style]
-      end
     end
 
     # What gets called when you call instance.attachment = File. It clears errors,
@@ -58,11 +53,11 @@ module Paperclip
 
       queue_existing_for_delete
       @errors            = []
-      @validation_errors = nil 
+      @validation_errors = nil
 
       return nil if uploaded_file.nil?
 
-      @file                               = uploaded_file.to_tempfile
+      @queued_for_write[:original]        = uploaded_file.to_tempfile
       @instance[:"#{@name}_file_name"]    = uploaded_file.original_filename
       @instance[:"#{@name}_content_type"] = uploaded_file.content_type
       @instance[:"#{@name}_file_size"]    = uploaded_file.size
@@ -79,8 +74,8 @@ module Paperclip
     # 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.
-    def url style = nil
-      @file ? interpolate(@url, style) : interpolate(@default_url, style)
+    def url style = default_style
+      original_filename.nil? ? interpolate(@default_url, style) : interpolate(@url, style)
     end
 
     # Returns the path of the attachment as defined by the :path optionn. If the
@@ -118,7 +113,6 @@ module Paperclip
         flush_deletes
         flush_writes
         @dirty = false
-        @file = @processed_files[default_style]
         true
       else
         flush_errors
@@ -126,14 +120,6 @@ module Paperclip
       end
     end
 
-    # Returns representation of the data of the file assigned to the given
-    # style, in the format most representative of the current storage.
-    def to_file style = nil
-      @processed_files[style || default_style]
-    end
-
-    alias_method :to_io, :to_file
-
     # Returns the name of the file as originally assigned, and as lives in the
     # <attachment>_file_name attribute of the model.
     def original_filename
@@ -149,10 +135,10 @@ module Paperclip
       @interpolations ||= {
         :rails_root   => lambda{|attachment,style| RAILS_ROOT },
         :class        => lambda do |attachment,style|
-                           attachment.instance.class.to_s.downcase.pluralize
+                           attachment.instance.class.name.underscore.pluralize
                          end,
         :basename     => lambda do |attachment,style|
-                           attachment.original_filename.gsub(/\.(.*?)$/, "")
+                           attachment.original_filename.gsub(File.extname(attachment.original_filename), "")
                          end,
         :extension    => lambda do |attachment,style| 
                            ((style = attachment.styles[style]) && style.last) ||
@@ -167,6 +153,22 @@ module Paperclip
       }
     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!
+      new_original = Tempfile.new("paperclip-reprocess")
+      old_original = to_file(:original)
+      new_original.write( old_original.read )
+      new_original.rewind
+
+      @queued_for_write = { :original => new_original }
+      post_process
+
+      old_original.close if old_original.respond_to?(:close)
+    end
+
     private
 
     def valid_assignment? file #:nodoc:
@@ -196,38 +198,35 @@ module Paperclip
     end
 
     def post_process #:nodoc:
-      return nil if @file.nil?
+      return if @queued_for_write[:original].nil?
       @styles.each do |name, args|
         begin
           dimensions, format = args
-          @processed_files[name] = Thumbnail.make(self.file, 
-                                                  dimensions,
-                                                  format, 
-                                                  @whiny_thumnails)
-        rescue Errno::ENOENT  => e
-          @errors << "could not be processed because the file does not exist."
+          @queued_for_write[name] = Thumbnail.make(@queued_for_write[:original], 
+                                                   dimensions,
+                                                   format, 
+                                                   @whiny_thumnails)
         rescue PaperclipError => e
-          @errors << e.message
+          @errors << e.message if @whiny_thumbnails
         end
       end
-      @processed_files[:original] = @file
     end
 
-    def interpolate pattern, style = nil #:nodoc:
-      style ||= default_style
-      pattern = pattern.dup
-      self.class.interpolations.each do |tag, l|
-        pattern.gsub!(/:\b#{tag}\b/) do |match|
-          l.call( self, style )
+    def interpolate pattern, style = default_style #:nodoc:
+      interpolations = self.class.interpolations.sort{|a,b| a.first.to_s <=> b.first.to_s }
+      interpolations.reverse.inject( pattern.dup ) do |result, interpolation|
+        tag, blk = interpolation
+        result.gsub(/:#{tag}/) do |match|
+          blk.call( self, style )
         end
       end
-      pattern
     end
 
     def queue_existing_for_delete #:nodoc:
-      @queued_for_delete += @processed_files.values
-      @file               = nil
-      @processed_files    = {}
+      return if original_filename.blank?
+      @queued_for_delete += [:original, *@styles.keys].uniq.map do |style|
+        path(style) if exists?(style)
+      end.compact
       @instance[:"#{@name}_file_name"]    = nil
       @instance[:"#{@name}_content_type"] = nil
       @instance[:"#{@name}_file_size"]    = nil

data/lib/paperclip/geometry.rb

@@ -18,7 +18,7 @@ module Paperclip
     def self.from_file file
       file = file.path if file.respond_to? "path"
       parse(`#{Paperclip.path_for_command('identify')} "#{file}"`) ||
-        raise(Errno::ENOENT, file)
+        raise(NotIdentifiedByImageMagickError.new("#{file} 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/iostream.rb

@@ -25,7 +25,7 @@ module IOStream
     while self.read(in_blocks_of, buffer) do
       dstio.write(buffer)
     end
-    dstio.rewind
+    dstio.rewind    
     dstio
   end
 end

data/lib/paperclip/storage.rb

@@ -1,39 +1,47 @@
 module Paperclip
   module Storage
 
-    # With the Filesystem module installed, @file and @processed_files are just File instances.
     module Filesystem
       def self.extended base
       end
-
-      def locate_files
-        [:original, *@styles.keys].uniq.inject({}) do |files, style|
-          files[style] = File.new(path(style), "rb") if File.exist?(path(style))
-          files
+      
+      def exists?(style = default_style)
+        if original_filename
+          File.exist?(path(style))
+        else
+          false
         end
       end
 
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style = default_style
+        @queued_for_write[style] || (File.new(path(style)) if exists?(style))
+      end
+      alias_method :to_io, :to_file
+
       def flush_writes #:nodoc:
-        @processed_files.each do |style, file|
-          FileUtils.mkdir_p( File.dirname(path(style)) )
-          @processed_files[style] = file.stream_to(path(style)) unless file.path == path(style)
+        @queued_for_write.each do |style, file|
+          FileUtils.mkdir_p(File.dirname(path(style)))
+          result = file.stream_to(path(style))
+          file.close
+          result.close
         end
+        @queued_for_write = {}
       end
 
       def flush_deletes #:nodoc:
-        @queued_for_delete.compact.each do |file|
+        @queued_for_delete.each do |path|
           begin
-            FileUtils.rm(file.path)
+            FileUtils.rm(path) if File.exist?(path)
           rescue Errno::ENOENT => e
-            # ignore them
+            # ignore file-not-found, let everything else pass
           end
         end
         @queued_for_delete = []
       end
     end
 
-    # With the S3 module included, @file and the @processed_files will be
-    # RightAws::S3::Key instances.
     module S3
       def self.extended base
         require 'right_aws'
@@ -42,51 +50,62 @@ module Paperclip
           @s3_credentials     = parse_credentials(@options[:s3_credentials])
           @s3_options         = @options[:s3_options] || {}
           @s3_permissions     = @options[:s3_permissions] || 'public-read'
-
-          @s3                 = RightAws::S3.new(@s3_credentials[:access_key_id],
-                                                 @s3_credentials[:secret_access_key],
-                                                 @s3_options)
-          @s3_bucket          = @s3.bucket(@bucket, true, @s3_permissions)
           @url                = ":s3_url"
         end
         base.class.interpolations[:s3_url] = lambda do |attachment, style|
-          attachment.to_io(style).public_link
+          "https://s3.amazonaws.com/#{attachment.bucket_name}/#{attachment.path(style).gsub(%r{^/}, "")}"
         end
       end
 
+      def s3
+        @s3 ||= RightAws::S3.new(@s3_credentials[:access_key_id],
+                                 @s3_credentials[:secret_access_key],
+                                 @s3_options)
+      end
+
+      def s3_bucket
+        @s3_bucket ||= s3.bucket(@bucket, true, @s3_permissions)
+      end
+
+      def bucket_name
+        @bucket
+      end
+
       def parse_credentials creds
         creds = find_credentials(creds).stringify_keys
         (creds[ENV['RAILS_ENV']] || creds).symbolize_keys
       end
+      
+      def exists?(style = default_style)
+        s3_bucket.key(path(style)) ? true : false
+      end
 
-      def locate_files
-        [:original, *@styles.keys].uniq.inject({}) do |files, style|
-          files[style] = @s3_bucket.key(path(style))
-          files
-        end
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style = default_style
+        @queued_for_write[style] || s3_bucket.key(path(style))
       end
+      alias_method :to_io, :to_file
 
       def flush_writes #:nodoc:
-        return if not dirty?
-        @processed_files.each do |style, key|
+        @queued_for_write.each do |style, file|
           begin
-            unless key.is_a? RightAws::S3::Key
-              saved_data = key
-              key = @processed_files[style] = @s3_bucket.key(path(style))
-              key.data = saved_data
-            end
+            key = s3_bucket.key(path(style))
+            key.data = file
             key.put(nil, @s3_permissions)
           rescue RightAws::AwsError => e
-            @processed_files[style] = nil
             raise
           end
         end
+        @queued_for_write = {}
       end
 
       def flush_deletes #:nodoc:
-        @queued_for_delete.compact.each do |file|
+        @queued_for_delete.each do |path|
           begin
-            file.delete
+            if file = s3_bucket.key(path)
+              file.delete
+            end
           rescue RightAws::AwsError
             # Ignore this.
           end

data/lib/paperclip/upfile.rb

@@ -9,7 +9,8 @@ module Paperclip
       type = self.path.match(/\.(\w+)$/)[1] rescue "octet-stream"
       case type
       when "jpg", "png", "gif" then "image/#{type}"
-      when "txt", "csv", "xml", "html", "htm", "css", "js" then "text/#{type}"
+      when "txt" then "text/plain"
+      when "csv", "xml", "html", "htm", "css", "js" then "text/#{type}"
       else "x-application/#{type}"
       end
     end

data/tasks/paperclip_tasks.rake

@@ -1,11 +1,13 @@
 def obtain_class
   class_name = ENV['CLASS'] || ENV['class']
+  raise "Must specify CLASS" unless class_name
   @klass = Object.const_get(class_name)
 end
 
 def obtain_attachments
   name = ENV['ATTACHMENT'] || ENV['attachment']
-  if !name.blank? && @klass.attachment_names.include?(name)
+  raise "Class #{@klass.name} has no attachments specified" unless @klass.respond_to?(:attachment_definitions)
+  if !name.blank? && @klass.attachment_definitions.keys.include?(name)
     [ name ]
   else
     @klass.attachment_definitions.keys
@@ -16,14 +18,14 @@ namespace :paperclip do
   desc "Regenerates thumbnails for a given CLASS (and optional ATTACHMENT)"
   task :refresh => :environment do
     klass     = obtain_class
-    instances = klass.find(:all)
     names     = obtain_attachments
+    instances = klass.find(:all)
     
     puts "Regenerating thumbnails for #{instances.length} instances of #{klass.name}:"
     instances.each do |instance|
       names.each do |name|
         result = if instance.send("#{ name }?")
-          instance.send(name).send("post_process")
+          instance.send(name).reprocess!
           instance.send(name).save
         else
           true