paperclip 2.3.1.1 → 2.3.2

data/README.rdoc

@@ -138,7 +138,7 @@ For example, assuming we had this definition:
   has_attached_file :scan, :styles => { :text => { :quality => :better } },
                            :processors => [:rotator, :ocr]
 
-then both the :rotator processor and the :ocr processor would receive the 
+then both the :rotator processor and the :ocr processor would receive the
 options "{ :quality => :better }". This parameter may not mean anything to one
 or more or the processors, and they are expected to ignore it.
 
@@ -162,6 +162,11 @@ NOTE: Post processing will not even *start* if the attachment is not valid
 according to the validations. Your callbacks and processors will *only* be
 called with valid attachments.
 
+==Testing
+
+Paperclip provides rspec-compatible matchers for testing attachments. See the
+documentation on Paperclip::Shoulda::Matchers for more information.
+
 ==Contributing
 
 If you'd like to contribute a feature or bugfix: Thanks! To make sure your

data/Rakefile

@@ -8,6 +8,11 @@ require 'paperclip'
 desc 'Default: run unit tests.'
 task :default => [:clean, :test]
 
+desc 'Test the paperclip plugin under all supported Rails versions.'
+task :all do |t|
+  exec('rake RAILS_VERSION=2.1 && rake RAILS_VERSION=2.3 && rake RAILS_VERSION=3.0')
+end
+
 desc 'Test the paperclip plugin.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib' << 'profile'
@@ -40,47 +45,15 @@ task :clean do |t|
   FileUtils.rm_rf "doc"
   FileUtils.rm_rf "tmp"
   FileUtils.rm_rf "pkg"
+  FileUtils.rm_rf "public"
   FileUtils.rm "test/debug.log" rescue nil
   FileUtils.rm "test/paperclip.db" rescue nil
   Dir.glob("paperclip-*.gem").each{|f| FileUtils.rm f }
 end
 
-include_file_globs = ["README*",
-                      "LICENSE",
-                      "Rakefile",
-                      "init.rb",
-                      "{generators,lib,tasks,test,shoulda_macros}/**/*"]
-exclude_file_globs = ["test/s3.yml",
-                      "test/debug.log",
-                      "test/paperclip.db",
-                      "test/doc",
-                      "test/doc/*",
-                      "test/pkg",
-                      "test/pkg/*",
-                      "test/tmp",
-                      "test/tmp/*"]
-spec = Gem::Specification.new do |s| 
-  s.name              = "paperclip"
-  s.version           = Paperclip::VERSION
-  s.author            = "Jon Yurek"
-  s.email             = "jyurek@thoughtbot.com"
-  s.homepage          = "http://www.thoughtbot.com/projects/paperclip"
-  s.platform          = Gem::Platform::RUBY
-  s.summary           = "File attachments as attributes for ActiveRecord"
-  s.files             = FileList[include_file_globs].to_a - FileList[exclude_file_globs].to_a
-  s.require_path      = "lib"
-  s.test_files        = FileList["test/**/test_*.rb"].to_a
-  s.rubyforge_project = "paperclip"
-  s.has_rdoc          = true
-  s.extra_rdoc_files  = FileList["README*"].to_a
-  s.rdoc_options << '--line-numbers' << '--inline-source'
-  s.requirements << "ImageMagick"
-  s.add_development_dependency 'thoughtbot-shoulda'
-  s.add_development_dependency 'jferris-mocha', '= 0.9.5.0.1241126838'
-  s.add_development_dependency 'aws-s3'
-  s.add_development_dependency 'sqlite3-ruby'
-  s.add_development_dependency 'activerecord'
-  s.add_development_dependency 'activesupport'
+desc 'Build the gemspec.'
+task :gemspec do |t|
+  exec 'gem build paperclip.gemspec'
 end
 
 desc "Print a list of the files to be put into the gem"
@@ -89,13 +62,13 @@ task :manifest => :clean do
     puts file
   end
 end
- 
+
 desc "Generate a gemspec file for GitHub"
 task :gemspec => :clean do
   File.open("#{spec.name}.gemspec", 'w') do |f|
     f.write spec.to_ruby
   end
-end 
+end
 
 desc "Build the gem into the current directory"
 task :gem => :gemspec do

data/generators/paperclip/USAGE

@@ -1,5 +1,5 @@
 Usage:
 
   script/generate paperclip Class attachment1 (attachment2 ...)
-  
-This will create a migration that will add the proper columns to your class's table.
+
+This will create a migration that will add the proper columns to your class's table.

data/generators/paperclip/paperclip_generator.rb

@@ -1,12 +1,12 @@
 class PaperclipGenerator < Rails::Generator::NamedBase
   attr_accessor :attachments, :migration_name
- 
+
   def initialize(args, options = {})
     super
     @class_name, @attachments = args[0], args[1..-1]
   end
- 
-  def manifest    
+
+  def manifest
     file_name = generate_file_name
     @migration_name = file_name.camelize
     record do |m|
@@ -14,14 +14,14 @@ class PaperclipGenerator < Rails::Generator::NamedBase
                            File.join('db', 'migrate'),
                            :migration_file_name => file_name
     end
-  end 
-  
-  private 
-  
+  end
+
+  private
+
   def generate_file_name
     names = attachments.map{|a| a.underscore }
     names = names[0..-2] + ["and", names[-1]] if names.length > 1
     "add_attachments_#{names.join("_")}_to_#{@class_name.underscore}"
   end
- 
+
 end

data/lib/generators/paperclip/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate paperclip Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/paperclip/paperclip_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators/active_record'
+
+class PaperclipGenerator < ActiveRecord::Generators::Base
+  desc "Create a migration to add paperclip-specific fields to your model."
+
+  argument :attachment_names, :required => true, :type => :array, :desc => "The names of the attachment(s) to add.",
+           :banner => "attachment_one attachment_two attachment_three ..."
+
+  def self.source_root
+    @source_root ||= File.expand_path('../templates', __FILE__)
+  end
+
+  def generate_migration
+    migration_template "paperclip_migration.rb.erb", "db/migrate/#{migration_file_name}"
+  end
+
+  protected
+
+  def migration_name
+    "add_attachment_#{attachment_names.join("_")}_to_#{name.underscore}"
+  end
+
+  def migration_file_name
+    "#{migration_name}.rb"
+  end
+
+  def migration_class_name
+    migration_name.camelize
+  end
+
+end

data/lib/generators/paperclip/templates/paperclip_migration.rb.erb

@@ -0,0 +1,19 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+<% attachment_names.each do |attachment| -%>
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_name, :string
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_content_type, :string
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_size, :integer
+    add_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_updated_at, :datetime
+<% end -%>
+  end
+
+  def self.down
+<% attachment_names.each do |attachment| -%>
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_name
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_content_type
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_file_size
+    remove_column :<%= name.underscore.camelize.tableize %>, :<%= attachment %>_updated_at
+<% end -%>
+  end
+end

data/lib/paperclip.rb

@@ -27,6 +27,7 @@
 
 require 'erb'
 require 'tempfile'
+require 'paperclip/version'
 require 'paperclip/upfile'
 require 'paperclip/iostream'
 require 'paperclip/geometry'
@@ -34,9 +35,12 @@ require 'paperclip/processor'
 require 'paperclip/thumbnail'
 require 'paperclip/storage'
 require 'paperclip/interpolations'
+require 'paperclip/style'
 require 'paperclip/attachment'
-if defined? RAILS_ROOT
-  Dir.glob(File.join(File.expand_path(RAILS_ROOT), "lib", "paperclip_processors", "*.rb")).each do |processor|
+require 'paperclip/callback_compatability'
+require 'paperclip/railtie'
+if defined?(Rails.root) && Rails.root
+  Dir.glob(File.join(File.expand_path(Rails.root), "lib", "paperclip_processors", "*.rb")).each do |processor|
     require processor
   end
 end
@@ -45,16 +49,14 @@ end
 # documentation for Paperclip::ClassMethods for more useful information.
 module Paperclip
 
-  VERSION = "2.3.1.1"
-
   class << self
     # Provides configurability to Paperclip. There are a number of options available, such as:
-    # * whiny: Will raise an error if Paperclip cannot process thumbnails of 
+    # * whiny: Will raise an error if Paperclip cannot process thumbnails of
     #   an uploaded image. Defaults to true.
     # * log: Logs progress to the Rails log. Uses ActiveRecord's logger, so honors
     #   log levels, etc. Defaults to true.
     # * command_path: Defines the path at which to find the command line
-    #   programs if they are not visible to Rails the system's search path. Defaults to 
+    #   programs if they are not visible to Rails the system's search path. Defaults to
     #   nil, which uses the first executable found in the user's search path.
     # * image_magick_path: Deprecated alias of command_path.
     def options
@@ -63,11 +65,15 @@ module Paperclip
         :image_magick_path => nil,
         :command_path      => nil,
         :log               => true,
-        :log_command       => false,
+        :log_command       => true,
         :swallow_stderr    => true
       }
     end
 
+    def configure
+      yield(self) if block_given?
+    end
+
     def path_for_command command #:nodoc:
       if options[:image_magick_path]
         warn("[DEPRECATION] :image_magick_path is deprecated and will be removed. Use :command_path instead")
@@ -80,7 +86,7 @@ module Paperclip
       Paperclip::Interpolations[key] = block
     end
 
-    # The run method takes a command to execute and a string of parameters
+    # The run method takes a command to execute and an array of parameters
     # that get passed to it. The command is prefixed with the :command_path
     # option from Paperclip.options. If you have many commands to run and
     # they are in different paths, the suggested course of action is to
@@ -89,29 +95,55 @@ module Paperclip
     # If the command returns with a result code that is not one of the
     # expected_outcodes, a PaperclipCommandLineError will be raised. Generally
     # a code of 0 is expected, but a list of codes may be passed if necessary.
+    # These codes should be passed as a hash as the last argument, like so:
     #
-    # This method can log the command being run when 
+    #   Paperclip.run("echo", "something", :expected_outcodes => [0,1,2,3])
+    #
+    # This method can log the command being run when
     # Paperclip.options[:log_command] is set to true (defaults to false). This
     # will only log if logging in general is set to true as well.
-    def run cmd, params = "", expected_outcodes = 0
-      command = %Q[#{path_for_command(cmd)} #{params}].gsub(/\s+/, " ")
+    def run cmd, *params
+      options           = params.last.is_a?(Hash) ? params.pop : {}
+      expected_outcodes = options[:expected_outcodes] || [0]
+      params            = quote_command_options(*params).join(" ")
+
+      command = %Q[#{path_for_command(cmd)} #{params}]
       command = "#{command} 2>#{bit_bucket}" if Paperclip.options[:swallow_stderr]
       Paperclip.log(command) if Paperclip.options[:log_command]
-      output = `#{command}`
-      unless [expected_outcodes].flatten.include?($?.exitstatus)
-        raise PaperclipCommandLineError, "Error while running #{cmd}"
+
+      begin
+        output = `#{command}`
+
+        raise CommandNotFoundError if $?.exitstatus == 127
+
+        unless expected_outcodes.include?($?.exitstatus)
+          raise PaperclipCommandLineError,
+            "Error while running #{cmd}. Expected return code to be #{expected_outcodes.join(", ")} but was #{$?.exitstatus}",
+            output
+        end
+      rescue Errno::ENOENT => e
+        raise CommandNotFoundError
       end
+
       output
     end
 
+    def quote_command_options(*options)
+      options.map do |option|
+        option.split("'").map{|m| "'#{m}'" }.join("\\'")
+      end
+    end
+
     def bit_bucket #:nodoc:
       File.exists?("/dev/null") ? "/dev/null" : "NUL"
     end
 
     def included base #:nodoc:
       base.extend ClassMethods
-      unless base.respond_to?(:define_callbacks)
-        base.send(:include, Paperclip::CallbackCompatability)
+      if base.respond_to?("set_callback")
+        base.send :include, Paperclip::CallbackCompatability::Rails3
+      else
+        base.send :include, Paperclip::CallbackCompatability::Rails21
       end
     end
 
@@ -119,7 +151,7 @@ module Paperclip
       name = name.to_s.camelize
       processor = Paperclip.const_get(name)
       unless processor.ancestors.include?(Paperclip::Processor)
-        raise PaperclipError.new("Processor #{name} was not found") 
+        raise PaperclipError.new("Processor #{name} was not found")
       end
       processor
     end
@@ -142,56 +174,64 @@ module Paperclip
   class PaperclipError < StandardError #:nodoc:
   end
 
-  class PaperclipCommandLineError < StandardError #:nodoc:
+  class PaperclipCommandLineError < PaperclipError #:nodoc:
+    attr_accessor :output
+    def initialize(msg = nil, output = nil)
+      super(msg)
+      @output = output
+    end
+  end
+
+  class CommandNotFoundError < PaperclipError
   end
 
   class NotIdentifiedByImageMagickError < PaperclipError #:nodoc:
   end
-  
+
   class InfiniteInterpolationError < 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. 
+    # is typically a file stored somewhere on the filesystem and has been uploaded by a user.
     # The attribute returns a Paperclip::Attachment object which handles the management of
-    # that file. The intent is to make the attachment as much like a normal attribute. The 
-    # thumbnails will be created when the new file is assigned, but they will *not* be saved 
-    # until +save+ is called on the record. Likewise, if the attribute is set to +nil+ is 
-    # called on it, the attachment will *not* be deleted until +save+ is called. See the 
-    # Paperclip::Attachment documentation for more specifics. There are a number of options 
+    # that file. The intent is to make the attachment as much like a normal attribute. The
+    # thumbnails will be created when the new file is assigned, but they will *not* be saved
+    # until +save+ is called on the record. Likewise, if the attribute is set to +nil+ is
+    # called on it, the attachment will *not* be deleted until +save+ is called. See the
+    # Paperclip::Attachment documentation for more specifics. There are a number of options
     # you can set to change the behavior of a Paperclip attachment:
     # * +url+: The full URL of where the attachment is publically accessible. This can just
     #   as easily point to a directory served directly through Apache as it can to an action
     #   that can control permissions. You can specify the full domain and path, but usually
-    #   just an absolute path is sufficient. The leading slash *must* be included manually for 
-    #   absolute paths. The default value is 
+    #   just an absolute path is sufficient. The leading slash *must* be included manually for
+    #   absolute paths. The default value is
     #   "/system/:attachment/:id/:style/:filename". See
     #   Paperclip::Attachment#interpolate for more information on variable interpolaton.
     #     :url => "/:class/:attachment/:id/:style_:filename"
     #     :url => "http://some.other.host/stuff/:class/:id_:extension"
-    # * +default_url+: The URL that will be returned if there is no attachment assigned. 
-    #   This field is interpolated just as the url is. The default value is 
+    # * +default_url+: The URL that will be returned if there is no attachment assigned.
+    #   This field is interpolated just as the url is. The default value is
     #   "/:attachment/:style/missing.png"
     #     has_attached_file :avatar, :default_url => "/images/default_:style_avatar.png"
     #     User.new.avatar_url(:small) # => "/images/default_small_avatar.png"
-    # * +styles+: A hash of thumbnail styles and their geometries. You can find more about 
-    #   geometry strings at the ImageMagick website 
+    # * +styles+: A hash of thumbnail styles and their geometries. You can find more about
+    #   geometry strings at the ImageMagick website
     #   (http://www.imagemagick.org/script/command-line-options.php#resize). Paperclip
-    #   also adds the "#" option (e.g. "50x50#"), which will resize the image to fit maximally 
-    #   inside the dimensions and then crop the rest off (weighted at the center). The 
+    #   also adds the "#" option (e.g. "50x50#"), which will resize the image to fit maximally
+    #   inside the dimensions and then crop the rest off (weighted at the center). The
     #   default value is to generate no thumbnails.
-    # * +default_style+: The thumbnail style that will be used by default URLs. 
+    # * +default_style+: The thumbnail style that will be used by default URLs.
     #   Defaults to +original+.
     #     has_attached_file :avatar, :styles => { :normal => "100x100#" },
     #                       :default_style => :normal
     #     user.avatar.url # => "/avatars/23/normal_me.png"
     # * +whiny+: Will raise an error if Paperclip cannot post_process an uploaded file due
-    #   to a command line error. This will override the global setting for this attachment. 
+    #   to a command line error. This will override the global setting for this attachment.
     #   Defaults to true. This option used to be called :whiny_thumbanils, but this is
     #   deprecated.
     # * +convert_options+: When creating thumbnails, use this free-form options
-    #   field to pass in various convert command options.  Typical options are "-strip" to
+    #   array to pass in various convert command options.  Typical options are "-strip" to
     #   remove all Exif data from the image (save space for thumbnails and avatars) or
     #   "-depth 8" to specify the bit depth of the resulting conversion.  See ImageMagick
     #   convert documentation for more options: (http://www.imagemagick.org/script/convert.php)
@@ -208,6 +248,9 @@ module Paperclip
     #   NOTE: While not deprecated yet, it is not recommended to specify options this way.
     #   It is recommended that :convert_options option be included in the hash passed to each
     #   :styles for compatability with future versions.
+    #   NOTE: Strings supplied to :convert_options are split on space in order to undergo
+    #   shell quoting for safety. If your options require a space, please pre-split them
+    #   and pass an array to :convert_options instead.
     # * +storage+: Chooses the storage backend where the files will be stored. The current
     #   choices are :filesystem and :s3. The default is :filesystem. Make sure you read the
     #   documentation for Paperclip::Storage::Filesystem and Paperclip::Storage::S3
@@ -221,9 +264,8 @@ module Paperclip
       after_save :save_attached_files
       before_destroy :destroy_attached_files
 
-      define_callbacks :before_post_process, :after_post_process
-      define_callbacks :"before_#{name}_post_process", :"after_#{name}_post_process"
-     
+      define_paperclip_callbacks :post_process, :"#{name}_post_process"
+
       define_method name do |*args|
         a = attachment_for(name)
         (args.length > 0) ? a.to_s(args.first) : a
@@ -239,7 +281,7 @@ module Paperclip
 
       validates_each(name) do |record, attr, value|
         attachment = record.attachment_for(name)
-        attachment.send(:flush_errors) unless attachment.valid?
+        attachment.send(:flush_errors)
       end
     end
 
@@ -257,13 +299,13 @@ module Paperclip
       max     = options[:less_than]    || (options[:in] && options[:in].last)  || (1.0/0)
       range   = (min..max)
       message = options[:message] || "file size must be between :min and :max bytes."
+      message = message.gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
 
-      attachment_definitions[name][:validations] << [:size, {:min     => min,
-                                                             :max     => max,
-                                                             :range   => range,
-                                                             :message => message,
-                                                             :if      => options[:if],
-                                                             :unless  => options[:unless]}]
+      validates_inclusion_of :"#{name}_file_size",
+                             :in      => range,
+                             :message => message,
+                             :if      => options[:if],
+                             :unless  => options[:unless]
     end
 
     # Adds errors if thumbnail creation fails. The same as specifying :whiny_thumbnails => true.
@@ -281,18 +323,19 @@ module Paperclip
     # * +unless+: Same as +if+ but validates if lambda or method returns false.
     def validates_attachment_presence name, options = {}
       message = options[:message] || "must be set."
-      attachment_definitions[name][:validations] << [:presence, {:message => message,
-                                                                 :if      => options[:if],
-                                                                 :unless  => options[:unless]}]
+      validates_presence_of :"#{name}_file_name",
+                            :message => message,
+                            :if      => options[:if],
+                            :unless  => options[:unless]
     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.  Each type can be a String or a Regexp. It should be 
-    #   noted that Internet Explorer upload files with content_types that you 
-    #   may not expect. For example, JPEG images are given image/pjpeg and 
-    #   PNGs are image/x-png, so keep that in mind when determining how you 
+    # assigned. The possible options are:
+    # * +content_type+: Allowed content types.  Can be a single content type
+    #   or an array.  Each type can be a String or a Regexp. It should be
+    #   noted that Internet Explorer upload files with content_types that you
+    #   may not expect. For example, JPEG images are given image/pjpeg and
+    #   PNGs are image/x-png, so keep that in mind when determining how you
     #   match.  Allows all by default.
     # * +message+: The message to display when the uploaded file has an invalid
     #   content type.
@@ -303,10 +346,17 @@ module Paperclip
     # model, content_type validation will work _ONLY upon assignment_ and
     # re-validation after the instance has been reloaded will always succeed.
     def validates_attachment_content_type name, options = {}
-      attachment_definitions[name][:validations] << [:content_type, {:content_type => options[:content_type],
-                                                                     :message      => options[:message],
-                                                                     :if           => options[:if],
-                                                                     :unless       => options[:unless]}]
+      types = [options.delete(:content_type)].flatten
+      validates_each(:"#{name}_content_type", options) do |record, attr, value|
+        unless types.any?{|t| t === value }
+          if record.errors.method(:add).arity == -2
+            message = options[:message] || "is not one of #{types.join(", ")}"
+            record.errors.add(:"#{name}_content_type", message)
+          else
+            record.errors.add(:"#{name}_content_type", :inclusion, :default => options[:message], :value => value)
+          end
+        end
+      end
     end
 
     # Returns the attachment definitions defined by each call to
@@ -321,7 +371,7 @@ module Paperclip
       @_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))
@@ -329,14 +379,14 @@ module Paperclip
     end
 
     def save_attached_files
-      logger.info("[paperclip] Saving attachments.")
+      Paperclip.log("Saving attachments.")
       each_attachment do |name, attachment|
         attachment.send(:save)
       end
     end
 
     def destroy_attached_files
-      logger.info("[paperclip] Deleting attachments.")
+      Paperclip.log("Deleting attachments.")
       each_attachment do |name, attachment|
         attachment.send(:queue_existing_for_delete)
         attachment.send(:flush_deletes)
@@ -345,9 +395,3 @@ module Paperclip
   end
 
 end
-
-# Set it all up.
-if Object.const_defined?("ActiveRecord")
-  ActiveRecord::Base.send(:include, Paperclip)
-  File.send(:include, Paperclip::Upfile)
-end