paperclip 2.2.8 → 2.2.9.1

data/README.rdoc

@@ -79,8 +79,7 @@ validates_attachment_size.
 
 The files that are assigned as attachments are, by default, placed in the
 directory specified by the :path option to has_attached_file. By default, this
-location is
-":rails_root/public/system/:attachment/:id/:style/:basename.:extension". This
+location is ":rails_root/public/system/:attachment/:id/:style/:filename". This
 location was chosen because on standard Capistrano deployments, the
 public/system directory is symlinked to the app's shared directory, meaning it
 will survive between deployments. For example, using that :path, you may have a
@@ -89,7 +88,7 @@ file at
   /data/myapp/releases/20081229172410/public/system/avatars/13/small/my_pic.png
 
 NOTE: This is a change from previous versions of Paperclip, but is overall a
-safer choice for the defaul file store.
+safer choice for the default file store.
 
 You may also choose to store your files using Amazon's S3 service. You can find
 more information about S3 storage at the description for
@@ -104,9 +103,9 @@ variables.
 
 ==Post Processing
 
-Paperclip supports an extendible selection of post-processors. When you define
+Paperclip supports an extensible selection of post-processors. When you define
 a set of styles for an attachment, by default it is expected that those
-"styles" are actually "thumbnails". However, you can do more than just
+"styles" are actually "thumbnails". However, you can do much more than just
 thumbnail images. By defining a subclass of Paperclip::Processor, you can
 perform any processing you want on the files that are attached. Any file in
 your Rails app's lib/paperclip_processors directory is automatically loaded by
@@ -141,7 +140,10 @@ For example, assuming we had this definition:
 
 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 free to ignore it.
+or more or the processors, and they are expected to ignore it.
+
+NOTE: Because processors operate by turning the original attachment into the
+styles, no processors will be run if there are no styles defined.
 
 ==Events
 
@@ -157,7 +159,7 @@ will halt. Returning false in an after_ filter will not halt anything, but you
 can access the model and the attachment if necessary.
 
 NOTE: Post processing will not even *start* if the attachment is not valid
-according to the validations. Your callbacks (and processors) will only be
+according to the validations. Your callbacks and processors will *only* be
 called with valid attachments.
 
 ==Contributing

data/Rakefile

@@ -42,8 +42,23 @@ task :clean do |t|
   FileUtils.rm_rf "pkg"
   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
@@ -52,11 +67,7 @@ spec = Gem::Specification.new do |s|
   s.homepage          = "http://www.thoughtbot.com/projects/paperclip"
   s.platform          = Gem::Platform::RUBY
   s.summary           = "File attachments as attributes for ActiveRecord"
-  s.files             = FileList["README*",
-                                 "LICENSE",
-                                 "Rakefile",
-                                 "init.rb",
-                                 "{generators,lib,tasks,test,shoulda_macros}/**/*"].to_a
+  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"
@@ -64,14 +75,25 @@ spec = Gem::Specification.new do |s|
   s.extra_rdoc_files  = FileList["README*"].to_a
   s.rdoc_options << '--line-numbers' << '--inline-source'
   s.requirements << "ImageMagick"
-  s.add_runtime_dependency 'right_aws'
   s.add_development_dependency 'thoughtbot-shoulda'
   s.add_development_dependency 'mocha'
 end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest => :clean do
+  spec.files.each do |file|
+    puts file
+  end
+end
  
 desc "Generate a gemspec file for GitHub"
-task :gemspec do
+task :gemspec => :clean do
   File.open("#{spec.name}.gemspec", 'w') do |f|
     f.write spec.to_ruby
   end
+end 
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build #{spec.name}.gemspec`
 end

data/lib/paperclip.rb

@@ -5,7 +5,7 @@
 # columns to your table.
 #
 # Author:: Jon Yurek
-# Copyright:: Copyright (c) 2008 thoughtbot, inc.
+# Copyright:: Copyright (c) 2008-2009 thoughtbot, inc.
 # License:: MIT License (http://www.opensource.org/licenses/mit-license.php)
 #
 # Paperclip defines an attachment as any file, though it makes special considerations
@@ -32,6 +32,7 @@ require 'paperclip/geometry'
 require 'paperclip/processor'
 require 'paperclip/thumbnail'
 require 'paperclip/storage'
+require 'paperclip/interpolations'
 require 'paperclip/attachment'
 if defined? RAILS_ROOT
   Dir.glob(File.join(File.expand_path(RAILS_ROOT), "lib", "paperclip_processors", "*.rb")).each do |processor|
@@ -43,11 +44,11 @@ end
 # documentation for Paperclip::ClassMethods for more useful information.
 module Paperclip
 
-  VERSION = "2.2.8"
+  VERSION = "2.2.9.1"
 
   class << self
     # Provides configurability to Paperclip. There are a number of options available, such as:
-    # * whiny_thumbnails: 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.
@@ -57,10 +58,11 @@ module Paperclip
     # * image_magick_path: Deprecated alias of command_path.
     def options
       @options ||= {
-        :whiny_thumbnails  => true,
+        :whiny             => true,
         :image_magick_path => nil,
         :command_path      => nil,
         :log               => true,
+        :log_command       => false,
         :swallow_stderr    => true
       }
     end
@@ -74,7 +76,7 @@ module Paperclip
     end
 
     def interpolates key, &block
-      Paperclip::Attachment.interpolations[key] = block
+      Paperclip::Interpolations[key] = block
     end
 
     # The run method takes a command to execute and a string of parameters
@@ -86,9 +88,14 @@ 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.
+    #
+    # 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<#{%Q[#{path_for_command(cmd)} #{params}].gsub(/\s+/, " ")}>
       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}"
@@ -115,6 +122,20 @@ module Paperclip
       end
       processor
     end
+
+    # Log a paperclip-specific line. Uses ActiveRecord::Base.logger
+    # by default. Set Paperclip.options[:log] to false to turn off.
+    def log message
+      logger.info("[paperclip] #{message}") if logging?
+    end
+
+    def logger #:nodoc:
+      ActiveRecord::Base.logger
+    end
+
+    def logging? #:nodoc:
+      options[:log]
+    end
   end
 
   class PaperclipError < StandardError #:nodoc:
@@ -125,6 +146,9 @@ module Paperclip
 
   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
@@ -141,9 +165,9 @@ module Paperclip
     #   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 
-    #   "/system/:attachment/:id/:style/:basename.:extension". See
+    #   "/system/:attachment/:id/:style/:filename". See
     #   Paperclip::Attachment#interpolate for more information on variable interpolaton.
-    #     :url => "/:class/:attachment/:id/:style_:basename.:extension"
+    #     :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 
@@ -161,9 +185,10 @@ module Paperclip
     #     has_attached_file :avatar, :styles => { :normal => "100x100#" },
     #                       :default_style => :normal
     #     user.avatar.url # => "/avatars/23/normal_me.png"
-    # * +whiny_thumbnails+: Will raise an error if Paperclip cannot post_process an uploaded file due
+    # * +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. 
-    #   Defaults to true. 
+    #   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
     #   remove all Exif data from the image (save space for thumbnails and avatars) or
@@ -179,6 +204,9 @@ module Paperclip
     #                                  :all => "-strip",
     #                                  :negative => "-negate"
     #                                }
+    #   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.
     # * +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
@@ -187,7 +215,7 @@ module Paperclip
       include InstanceMethods
 
       write_inheritable_attribute(:attachment_definitions, {}) if attachment_definitions.nil?
-      attachment_definitions[name] = {:validations => {}}.merge(options)
+      attachment_definitions[name] = {:validations => []}.merge(options)
 
       after_save :save_attached_files
       before_destroy :destroy_attached_files
@@ -220,30 +248,39 @@ module Paperclip
     # * +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
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +unless+: Same as +if+ but validates if lambda or method returns false.
     def validates_attachment_size name, options = {}
       min     = options[:greater_than] || (options[:in] && options[:in].first) || 0
       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."
 
-      attachment_definitions[name][:validations][:size] = lambda do |attachment, instance|
-        if attachment.file? && !range.include?(attachment.size.to_i)
-          message.gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
-        end
-      end
+      attachment_definitions[name][:validations] << [:size, {:range   => range,
+                                                             :message => message,
+                                                             :if      => options[:if],
+                                                             :unless  => options[:unless]}]
     end
 
     # Adds errors if thumbnail creation fails. The same as specifying :whiny_thumbnails => true.
     def validates_attachment_thumbnails name, options = {}
+      warn('[DEPRECATION] validates_attachment_thumbnail is deprecated. ' +
+           'This validation is on by default and will be removed from future versions. ' +
+           'If you wish to turn it off, supply :whiny => false in your definition.')
       attachment_definitions[name][:whiny_thumbnails] = true
     end
 
     # Places ActiveRecord-style validations on the presence of a file.
+    # Options:
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +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] = lambda do |attachment, instance|
-        message unless attachment.file?
-      end
+      attachment_definitions[name][:validations] << [:presence, {:message => message,
+                                                                 :if      => options[:if],
+                                                                 :unless  => options[:unless]}]
     end
     
     # Places ActiveRecord-style validations on the content type of the file
@@ -256,22 +293,17 @@ module Paperclip
     #   match.  Allows all by default.
     # * +message+: The message to display when the uploaded file has an invalid
     #   content type.
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +unless+: Same as +if+ but validates if lambda or method returns false.
     # NOTE: If you do not specify an [attachment]_content_type field on your
     # 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] = lambda do |attachment, instance|
-        valid_types = [options[:content_type]].flatten
-        
-        unless attachment.original_filename.blank?
-          unless valid_types.blank?
-            content_type = attachment.instance_read(:content_type)
-            unless valid_types.any?{|t| content_type.nil? || t === content_type }
-              options[:message] || "is not one of the allowed file types."
-            end
-          end
-        end
-      end
+      attachment_definitions[name][:validations] << [:content_type, {:content_type => options[:content_type],
+                                                                     :message      => options[:message],
+                                                                     :if           => options[:if],
+                                                                     :unless       => options[:unless]}]
     end
 
     # Returns the attachment definitions defined by each call to

data/lib/paperclip/attachment.rb

@@ -6,17 +6,18 @@ module Paperclip
     
     def self.default_options
       @default_options ||= {
-        :url           => "/system/:attachment/:id/:style/:basename.:extension",
-        :path          => ":rails_root/public/system/:attachment/:id/:style/:basename.:extension",
+        :url           => "/system/:attachment/:id/:style/:filename",
+        :path          => ":rails_root/public:url",
         :styles        => {},
         :default_url   => "/:attachment/:style/missing.png",
         :default_style => :original,
-        :validations   => {},
-        :storage       => :filesystem
+        :validations   => [],
+        :storage       => :filesystem,
+        :whiny         => Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails]
       }
     end
 
-    attr_reader :name, :instance, :styles, :default_style, :convert_options, :queued_for_write
+    attr_reader :name, :instance, :styles, :default_style, :convert_options, :queued_for_write, :options
 
     # Creates an Attachment object. +name+ is the name of the attachment,
     # +instance+ is the ActiveRecord object instance it's attached to, and
@@ -37,7 +38,7 @@ module Paperclip
       @validations       = options[:validations]
       @default_style     = options[:default_style]
       @storage           = options[:storage]
-      @whiny             = options[:whiny_thumbnails]
+      @whiny             = options[:whiny_thumbnails] || options[:whiny]
       @convert_options   = options[:convert_options] || {}
       @processors        = options[:processors] || [:thumbnail]
       @options           = options
@@ -60,11 +61,7 @@ module Paperclip
     # If the file that is assigned is not valid, the processing (i.e.
     # thumbnailing, etc) will NOT be run.
     def assign uploaded_file
-      %w(file_name).each do |field|
-        unless @instance.class.column_names.include?("#{name}_#{field}")
-          raise PaperclipError.new("#{@instance.class} model does not have required column '#{name}_#{field}'")
-        end
-      end
+      ensure_required_accessors!
 
       if uploaded_file.is_a?(Paperclip::Attachment)
         uploaded_file = uploaded_file.to_file(:original)
@@ -111,7 +108,7 @@ module Paperclip
     # 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
     # URL, and the :bucket option refers to the S3 bucket.
-    def path style = nil #:nodoc:
+    def path style = default_style
       original_filename.nil? ? nil : interpolate(@path, style)
     end
 
@@ -192,32 +189,16 @@ module Paperclip
       time && time.to_i
     end
 
-    # A hash of procs that are run during the interpolation of a path or url.
-    # A variable of the format :name will be replaced with the return value of
-    # the proc named ":name". Each lambda takes the attachment and the current
-    # style as arguments. This hash can be added to with your own proc if
-    # necessary.
+    # Paths and URLs can have a number of variables interpolated into them
+    # to vary the storage location based on name, id, style, class, etc.
+    # This method is a deprecated access into supplying and retrieving these
+    # interpolations. Future access should use either Paperclip.interpolates
+    # or extend the Paperclip::Interpolations module directly.
     def self.interpolations
-      @interpolations ||= {
-        :rails_root   => lambda{|attachment,style| RAILS_ROOT },
-        :rails_env    => lambda{|attachment,style| RAILS_ENV },
-        :class        => lambda do |attachment,style|
-                           attachment.instance.class.name.underscore.pluralize
-                         end,
-        :basename     => lambda do |attachment,style|
-                           attachment.original_filename.gsub(/#{File.extname(attachment.original_filename)}$/, "")
-                         end,
-        :extension    => lambda do |attachment,style| 
-                           ((style = attachment.styles[style]) && style[:format]) ||
-                           File.extname(attachment.original_filename).gsub(/^\.+/, "")
-                         end,
-        :id           => lambda{|attachment,style| attachment.instance.id },
-        :id_partition => lambda do |attachment, style|
-                           ("%09d" % attachment.instance.id).scan(/\d{3}/).join("/")
-                         end,
-        :attachment   => lambda{|attachment,style| attachment.name.to_s.downcase.pluralize },
-        :style        => lambda{|attachment,style| style || attachment.default_style },
-      }
+      warn('[DEPRECATION] Paperclip::Attachment.interpolations is deprecated ' +
+           'and will be removed from future versions. ' +
+           'Use Paperclip.interpolates instead')
+      Paperclip::Interpolations
     end
 
     # This method really shouldn't be called that often. It's expected use is
@@ -269,16 +250,16 @@ module Paperclip
 
     private
 
-    def logger #:nodoc:
-      instance.logger
+    def ensure_required_accessors! #:nodoc:
+      %w(file_name).each do |field|
+        unless @instance.respond_to?("#{name}_#{field}") && @instance.respond_to?("#{name}_#{field}=")
+          raise PaperclipError.new("#{@instance.class} model missing required attr_accessor for '#{name}_#{field}'")
+        end
+      end
     end
 
     def log message #:nodoc:
-      logger.info("[paperclip] #{message}") if logging?
-    end
-
-    def logging? #:nodoc:
-      Paperclip.options[:log]
+      Paperclip.log(message)
     end
 
     def valid_assignment? file #:nodoc:
@@ -288,8 +269,8 @@ module Paperclip
     def validate #:nodoc:
       unless @validation_errors
         @validation_errors = @validations.inject({}) do |errors, validation|
-          name, block = validation
-          errors[name] = block.call(self, instance) if block
+          name, options = validation
+          errors[name] = send(:"validate_#{name}", options) if allow_validation?(options)
           errors
         end
         @validation_errors.reject!{|k,v| v == nil }
@@ -298,6 +279,40 @@ module Paperclip
       @validation_errors
     end
 
+    def allow_validation? options #:nodoc:
+      (options[:if].nil? || check_guard(options[:if])) && (options[:unless].nil? || !check_guard(options[:unless]))
+    end
+
+    def check_guard guard #:nodoc:
+      if guard.respond_to? :call
+        guard.call(instance)
+      elsif ! guard.blank?
+        instance.send(guard.to_s)
+      end
+    end
+
+    def validate_size options #:nodoc:
+      if file? && !options[:range].include?(size.to_i)
+        options[:message].gsub(/:min/, options[:min].to_s).gsub(/:max/, options[:max].to_s)
+      end
+    end
+
+    def validate_presence options #:nodoc:
+      options[:message] unless file?
+    end
+
+    def validate_content_type options #:nodoc:
+      valid_types = [options[:content_type]].flatten
+      unless original_filename.blank?
+        unless valid_types.blank?
+          content_type = instance_read(:content_type)
+          unless valid_types.any?{|t| content_type.nil? || t === content_type }
+            options[:message] || "is not one of the allowed file types."
+          end
+        end
+      end
+    end
+
     def normalize_style_definition #:nodoc:
       @styles.each do |name, args|
         unless args.is_a? Hash
@@ -349,7 +364,7 @@ module Paperclip
       return if fire_events(:after)
     end
 
-    def fire_events(which)
+    def fire_events(which) #:nodoc:
       return true if callback(:"#{which}_post_process") == false
       return true if callback(:"#{which}_#{name}_post_process") == false
     end
@@ -358,7 +373,7 @@ module Paperclip
       instance.run_callbacks(which, @queued_for_write){|result, obj| result == false }
     end
 
-    def post_process_styles
+    def post_process_styles #:nodoc:
       @styles.each do |name, args|
         begin
           raise RuntimeError.new("Style #{name} has no processors defined.") if args[:processors].blank?
@@ -373,13 +388,7 @@ module Paperclip
     end
 
     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
+      Paperclip::Interpolations.interpolate(pattern, self, style)
     end
 
     def queue_existing_for_delete #:nodoc:

data/lib/paperclip/geometry.rb

@@ -26,7 +26,7 @@ module Paperclip
 
     # 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([\>\<\#\@\%^!])?/))
+      if match = (string && string.match(/\b(\d*)x?(\d*)\b([\>\<\#\@\%^!])?/i))
         Geometry.new(*match[1,3])
       end
     end

data/lib/paperclip/interpolations.rb

@@ -0,0 +1,105 @@
+module Paperclip
+  # This module contains all the methods that are available for interpolation
+  # in paths and urls. To add your own (or override an existing one), you
+  # can either open this module and define it, or call the
+  # Paperclip.interpolates method.
+  module Interpolations
+    extend self
+
+    # Hash assignment of interpolations. Included only for compatability,
+    # and is not intended for normal use.
+    def self.[]= name, block
+      define_method(name, &block)
+    end
+
+    # Hash access of interpolations. Included only for compatability,
+    # and is not intended for normal use.
+    def self.[] name
+      method(name)
+    end
+
+    # Returns a sorted list of all interpolations.
+    def self.all
+      self.instance_methods(false).sort
+    end
+
+    # Perform the actual interpolation. Takes the pattern to interpolate
+    # and the arguments to pass, which are the attachment and style name.
+    def self.interpolate pattern, *args
+      all.reverse.inject( pattern.dup ) do |result, tag|
+        result.gsub(/:#{tag}/) do |match|
+          send( tag, *args )
+        end
+      end
+    end
+
+    # Returns the filename, the same way as ":basename.:extension" would.
+    def filename attachment, style
+      "#{basename(attachment, style)}.#{extension(attachment, style)}"
+    end
+
+    # Returns the interpolated URL. Will raise an error if the url itself
+    # contains ":url" to prevent infinite recursion. This interpolation
+    # is used in the default :path to ease default specifications.
+    def url attachment, style
+      raise InfiniteInterpolationError if attachment.options[:url].include?(":url")
+      attachment.url(style, false)
+    end
+
+    # Returns the timestamp as defined by the <attachment>_updated_at field
+    def timestamp attachment, style
+      attachment.instance_read(:updated_at).to_s
+    end
+
+    # Returns the RAILS_ROOT constant.
+    def rails_root attachment, style
+      RAILS_ROOT
+    end
+
+    # Returns the RAILS_ENV constant.
+    def rails_env attachment, style
+      RAILS_ENV
+    end
+
+    # Returns the underscored, pluralized version of the class name.
+    # e.g. "users" for the User class.
+    def class attachment, style
+      attachment.instance.class.to_s.underscore.pluralize
+    end
+
+    # Returns the basename of the file. e.g. "file" for "file.jpg"
+    def basename attachment, style
+      attachment.original_filename.gsub(/#{File.extname(attachment.original_filename)}$/, "")
+    end
+
+    # Returns the extension of the file. e.g. "jpg" for "file.jpg"
+    # If the style has a format defined, it will return the format instead
+    # of the actual extension.
+    def extension attachment, style 
+      ((style = attachment.styles[style]) && style[:format]) ||
+        File.extname(attachment.original_filename).gsub(/^\.+/, "")
+    end
+
+    # Returns the id of the instance.
+    def id attachment, style
+      attachment.instance.id
+    end
+
+    # Returns the id of the instance in a split path form. e.g. returns
+    # 000/001/234 for an id of 1234.
+    def id_partition attachment, style
+      ("%09d" % attachment.instance.id).scan(/\d{3}/).join("/")
+    end
+
+    # Returns the pluralized form of the attachment name. e.g.
+    # "avatars" for an attachment of :avatar
+    def attachment attachment, style
+      attachment.name.to_s.downcase.pluralize
+    end
+
+    # Returns the style, or the default style if nil is supplied.
+    def style attachment, style
+      style || attachment.default_style
+    end
+  end
+end

data/lib/paperclip/processor.rb

@@ -5,13 +5,14 @@ module Paperclip
   # are not required to follow suit.
   #
   # Processors are required to be defined inside the Paperclip module and
-  # are also required to be a subclass of Paperclip::Processor. There are
-  # only two methods you must implement to properly be a subclass: 
-  # #initialize and #make. Initialize's arguments are the file that will
-  # be operated on (which is an instance of File), and a hash of options
-  # that were defined in has_attached_file's style hash.
+  # are also required to be a subclass of Paperclip::Processor. There is
+  # only one method you *must* implement to properly be a subclass: 
+  # #make, but #initialize may also be of use. Both methods accept 3
+  # arguments: the file that will be operated on (which is an instance of
+  # File), a hash of options that were defined in has_attached_file's
+  # style hash, and the Paperclip::Attachment itself.
   #
-  # All #make needs to do is return an instance of File (Tempfile is
+  # All #make needs to return is an instance of File (Tempfile is
   # acceptable) which contains the results of the processing.
   #
   # See Paperclip.run for more information about using command-line

data/lib/paperclip/storage.rb

@@ -39,7 +39,7 @@ module Paperclip
         @queued_for_write.each do |style, file|
           file.close
           FileUtils.mkdir_p(File.dirname(path(style)))
-          logger.info("[paperclip] saving #{path(style)}")
+          log("saving #{path(style)}")
           FileUtils.mv(file.path, path(style))
           FileUtils.chmod(0644, path(style))
         end
@@ -49,7 +49,7 @@ module Paperclip
       def flush_deletes #:nodoc:
         @queued_for_delete.each do |path|
           begin
-            logger.info("[paperclip] deleting #{path}")
+            log("deleting #{path}")
             FileUtils.rm(path) if File.exist?(path)
           rescue Errno::ENOENT => e
             # ignore file-not-found, let everything else pass
@@ -62,7 +62,7 @@ module Paperclip
           rescue Errno::EEXIST, Errno::ENOTEMPTY, Errno::ENOENT, Errno::EINVAL, Errno::ENOTDIR
             # Stop trying to remove parent directories
           rescue SystemCallError => e
-            logger.info("[paperclip] There was an unexpected error while deleting directories: #{e.class}")
+            log("There was an unexpected error while deleting directories: #{e.class}")
             # Ignore it
           end
         end
@@ -128,6 +128,8 @@ module Paperclip
     #   separate parts of your file name.
     module S3
       def self.extended base
+        warn('[DEPRECATION] S3 support through RightAWS is deprecated. S3 support will ' + 
+             'be changed to AWS::S3 in a future version.')
         require 'right_aws'
         base.instance_eval do
           @s3_credentials = parse_credentials(@options[:s3_credentials])
@@ -140,13 +142,13 @@ module Paperclip
           @s3_host_alias  = @options[:s3_host_alias]
           @url            = ":s3_path_url" unless @url.to_s.match(/^:s3.*url$/)
         end
-        base.class.interpolations[:s3_alias_url] = lambda do |attachment, style|
+        Paperclip.interpolates(:s3_alias_url) do |attachment, style|
           "#{attachment.s3_protocol}://#{attachment.s3_host_alias}/#{attachment.path(style).gsub(%r{^/}, "")}"
         end
-        base.class.interpolations[:s3_path_url] = lambda do |attachment, style|
+        Paperclip.interpolates(:s3_path_url) do |attachment, style|
           "#{attachment.s3_protocol}://s3.amazonaws.com/#{attachment.bucket_name}/#{attachment.path(style).gsub(%r{^/}, "")}"
         end
-        base.class.interpolations[:s3_domain_url] = lambda do |attachment, style|
+        Paperclip.interpolates(:s3_domain_url) do |attachment, style|
           "#{attachment.s3_protocol}://#{attachment.bucket_name}.s3.amazonaws.com/#{attachment.path(style).gsub(%r{^/}, "")}"
         end
       end
@@ -171,7 +173,7 @@ module Paperclip
 
       def parse_credentials creds
         creds = find_credentials(creds).stringify_keys
-        (creds[ENV['RAILS_ENV']] || creds).symbolize_keys
+        (creds[RAILS_ENV] || creds).symbolize_keys
       end
       
       def exists?(style = default_style)
@@ -192,7 +194,7 @@ module Paperclip
       def flush_writes #:nodoc:
         @queued_for_write.each do |style, file|
           begin
-            logger.info("[paperclip] saving #{path(style)}")
+            log("saving #{path(style)}")
             key = s3_bucket.key(path(style))
             key.data = file
             key.put(nil, @s3_permissions, {'Content-type' => instance_read(:content_type)}.merge(@s3_headers))
@@ -206,7 +208,7 @@ module Paperclip
       def flush_deletes #:nodoc:
         @queued_for_delete.each do |path|
           begin
-            logger.info("[paperclip] deleting #{path}")
+            log("deleting #{path}")
             if file = s3_bucket.key(path)
               file.delete
             end

data/test/attachment_test.rb

@@ -5,6 +5,14 @@ class Dummy
 end
 
 class AttachmentTest < Test::Unit::TestCase
+  should "return the path based on the url by default" do
+    @attachment = attachment :url => "/:class/:id/:basename"
+    @model = @attachment.instance
+    @model.id = 1234
+    @model.avatar_file_name = "fake.jpg"
+    assert_equal "#{RAILS_ROOT}/public/fake_models/1234/fake", @attachment.path
+  end
+
   context "Attachment default_options" do
     setup do
       rebuild_model
@@ -106,6 +114,20 @@ class AttachmentTest < Test::Unit::TestCase
     end
   end
 
+  context "An attachment with a default style and an extension interpolation" do
+    setup do
+      @attachment = attachment :path => ":basename.:extension",
+                               :styles => { :default => ["100x100", :png] },
+                               :default_style => :default
+      @file = StringIO.new("...")
+      @file.expects(:original_filename).returns("file.jpg")
+    end
+    should "return the right extension for the path" do
+      @attachment.assign(@file)
+      assert_equal "file.png", @attachment.path
+    end
+  end
+
   context "An attachment with :convert_options" do
     setup do
       rebuild_model :styles => {
@@ -319,13 +341,13 @@ class AttachmentTest < Test::Unit::TestCase
       setup { @dummy.avatar = @file }
 
       before_should "call #make on all specified processors" do
-        expected_params = @style_params[:once].merge({:processors => [:thumbnail, :test], :whiny => nil, :convert_options => ""})
+        expected_params = @style_params[:once].merge({:processors => [:thumbnail, :test], :whiny => true, :convert_options => ""})
         Paperclip::Thumbnail.expects(:make).with(@file, expected_params, @dummy.avatar).returns(@file)
         Paperclip::Test.expects(:make).with(@file, expected_params, @dummy.avatar).returns(@file)
       end
       
       before_should "call #make with attachment passed as third argument" do
-        expected_params = @style_params[:once].merge({:processors => [:thumbnail, :test], :whiny => nil, :convert_options => ""})
+        expected_params = @style_params[:once].merge({:processors => [:thumbnail, :test], :whiny => true, :convert_options => ""})
         Paperclip::Test.expects(:make).with(@file, expected_params, @dummy.avatar).returns(@file)
       end
     end
@@ -456,6 +478,7 @@ class AttachmentTest < Test::Unit::TestCase
 
   context "An attachment" do
     setup do
+      @old_defaults = Paperclip::Attachment.default_options.dup
       Paperclip::Attachment.default_options.merge!({
         :path => ":rails_root/tmp/:attachment/:class/:style/:id/:basename.:extension"
       })
@@ -468,7 +491,10 @@ class AttachmentTest < Test::Unit::TestCase
                                  "5k.png"), 'rb')
     end
 
-    teardown { @file.close }
+    teardown do 
+      @file.close
+      Paperclip::Attachment.default_options.merge!(@old_defaults)
+    end
 
     should "raise if there are not the correct columns when you try to assign" do
       @other_attachment = Paperclip::Attachment.new(:not_here, @instance)

data/test/fixtures/s3.yml

@@ -0,0 +1,4 @@
+development:
+  key: 54321
+production:
+  key: 12345

data/test/geometry_test.rb

@@ -49,6 +49,15 @@ class GeometryTest < Test::Unit::TestCase
       assert_nil @geo.modifier
     end
 
+    should "treat x and X the same in geometries" do
+      @lower = Paperclip::Geometry.parse("123x456")
+      @upper = Paperclip::Geometry.parse("123X456")
+      assert_equal 123, @lower.width
+      assert_equal 123, @upper.width
+      assert_equal 456, @lower.height
+      assert_equal 456, @upper.height
+    end
+
     ['>', '<', '#', '@', '%', '^', '!', nil].each do |mod|
       should "ensure the modifier #{mod.inspect} is preserved" do
         assert @geo = Paperclip::Geometry.parse("123x456#{mod}")

data/test/helper.rb

@@ -17,6 +17,7 @@ end
 
 ROOT       = File.join(File.dirname(__FILE__), '..')
 RAILS_ROOT = ROOT
+RAILS_ENV  = "test"
 
 $LOAD_PATH << File.join(ROOT, 'lib')
 $LOAD_PATH << File.join(ROOT, 'lib', 'paperclip')
@@ -25,8 +26,6 @@ require File.join(ROOT, 'lib', 'paperclip.rb')
 
 require 'shoulda_macros/paperclip'
 
-ENV['RAILS_ENV'] ||= 'test'
-
 FIXTURES_DIR = File.join(File.dirname(__FILE__), "fixtures") 
 config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
 ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
@@ -71,7 +70,7 @@ def rebuild_class options = {}
 end
 
 def temporary_rails_env(new_env)
-  old_env = defined?(RAILS_ENV) ? RAILS_ENV : nil
+  old_env = Object.const_defined?("RAILS_ENV") ? RAILS_ENV : nil
   silence_warnings do
     Object.const_set("RAILS_ENV", new_env)
   end
@@ -80,3 +79,22 @@ def temporary_rails_env(new_env)
     Object.const_set("RAILS_ENV", old_env)
   end
 end
+
+class FakeModel
+  attr_accessor :avatar_file_name,
+                :avatar_file_size,
+                :avatar_last_updated,
+                :avatar_content_type,
+                :id
+
+  def errors
+    @errors ||= []
+  end
+
+  def run_callbacks name, *args
+  end
+end
+
+def attachment options
+  Paperclip::Attachment.new(:avatar, FakeModel.new, options)
+end

data/test/interpolations_test.rb

@@ -0,0 +1,120 @@
+require 'test/helper'
+
+class InterpolationsTest < Test::Unit::TestCase
+  should "return all methods but the infrastructure when sent #all" do
+    methods = Paperclip::Interpolations.all
+    assert ! methods.include?(:[])
+    assert ! methods.include?(:[]=)
+    assert ! methods.include?(:all)
+    methods.each do |m|
+      assert Paperclip::Interpolations.respond_to? m
+    end
+  end
+
+  should "return the RAILS_ROOT" do
+    assert_equal RAILS_ROOT, Paperclip::Interpolations.rails_root(:attachment, :style)
+  end
+
+  should "return the RAILS_ENV" do
+    assert_equal RAILS_ENV, Paperclip::Interpolations.rails_env(:attachment, :style)
+  end
+
+  should "return the class of the instance" do
+    attachment = mock
+    attachment.expects(:instance).returns(attachment)
+    attachment.expects(:class).returns("Thing")
+    assert_equal "things", Paperclip::Interpolations.class(attachment, :style)
+  end
+
+  should "return the basename of the file" do
+    attachment = mock
+    attachment.expects(:original_filename).returns("one.jpg").times(2)
+    assert_equal "one", Paperclip::Interpolations.basename(attachment, :style)
+  end
+
+  should "return the extension of the file" do
+    attachment = mock
+    attachment.expects(:original_filename).returns("one.jpg")
+    attachment.expects(:styles).returns({})
+    assert_equal "jpg", Paperclip::Interpolations.extension(attachment, :style)
+  end
+
+  should "return the extension of the file as the format if defined in the style" do
+    attachment = mock
+    attachment.expects(:original_filename).never
+    attachment.expects(:styles).returns({:style => {:format => "png"}})
+    assert_equal "png", Paperclip::Interpolations.extension(attachment, :style)
+  end
+
+  should "return the id of the attachment" do
+    attachment = mock
+    attachment.expects(:id).returns(23)
+    attachment.expects(:instance).returns(attachment)
+    assert_equal 23, Paperclip::Interpolations.id(attachment, :style)
+  end
+
+  should "return the partitioned id of the attachment" do
+    attachment = mock
+    attachment.expects(:id).returns(23)
+    attachment.expects(:instance).returns(attachment)
+    assert_equal "000/000/023", Paperclip::Interpolations.id_partition(attachment, :style)
+  end
+
+  should "return the name of the attachment" do
+    attachment = mock
+    attachment.expects(:name).returns("file")
+    assert_equal "files", Paperclip::Interpolations.attachment(attachment, :style)
+  end
+
+  should "return the style" do
+    assert_equal :style, Paperclip::Interpolations.style(:attachment, :style)
+  end
+
+  should "return the default style" do
+    attachment = mock
+    attachment.expects(:default_style).returns(:default_style)
+    assert_equal :default_style, Paperclip::Interpolations.style(attachment, nil)
+  end
+
+  should "reinterpolate :url" do
+    attachment = mock
+    attachment.expects(:options).returns({:url => ":id"})
+    attachment.expects(:url).with(:style, false).returns("1234")
+    assert_equal "1234", Paperclip::Interpolations.url(attachment, :style)
+  end
+
+  should "raise if infinite loop detcted reinterpolating :url" do
+    attachment = mock
+    attachment.expects(:options).returns({:url => ":url"})
+    assert_raises(Paperclip::InfiniteInterpolationError){ Paperclip::Interpolations.url(attachment, :style) }
+  end
+
+  should "return the filename as basename.extension" do
+    attachment = mock
+    attachment.expects(:styles).returns({})
+    attachment.expects(:original_filename).returns("one.jpg").times(3)
+    assert_equal "one.jpg", Paperclip::Interpolations.filename(attachment, :style)
+  end
+
+  should "return the filename as basename.extension when format supplied" do
+    attachment = mock
+    attachment.expects(:styles).returns({:style => {:format => :png}})
+    attachment.expects(:original_filename).returns("one.jpg").times(2)
+    assert_equal "one.png", Paperclip::Interpolations.filename(attachment, :style)
+  end
+
+  should "return the timestamp" do
+    now = Time.now
+    attachment = mock
+    attachment.expects(:instance_read).with(:updated_at).returns(now)
+    assert_equal now.to_s, Paperclip::Interpolations.timestamp(attachment, :style)
+  end
+
+  should "call all expected interpolations with the given arguments" do
+    Paperclip::Interpolations.expects(:id).with(:attachment, :style).returns(1234)
+    Paperclip::Interpolations.expects(:attachment).with(:attachment, :style).returns("attachments")
+    Paperclip::Interpolations.expects(:notreal).never
+    value = Paperclip::Interpolations.interpolate(":notreal/:id/:attachment", :attachment, :style)
+    assert_equal ":notreal/1234/attachments", value
+  end
+end

data/test/paperclip_test.rb

@@ -30,6 +30,14 @@ class PaperclipTest < Test::Unit::TestCase
       Paperclip.expects(:"`").with("convert one.jpg two.jpg 2>/dev/null")
       Paperclip.run("convert", "one.jpg two.jpg")
     end
+
+    should "log the command when :log_command is set" do
+      Paperclip.options[:log_command] = true
+      Paperclip.expects(:bit_bucket).returns("/dev/null")
+      Paperclip.expects(:log).with("this is the command 2>/dev/null")
+      Paperclip.expects(:"`").with("this is the command 2>/dev/null")
+      Paperclip.run("this","is the command")
+    end
   end
 
   should "raise when sent #processor and the name of a class that exists but isn't a subclass of Processor" do
@@ -44,6 +52,18 @@ class PaperclipTest < Test::Unit::TestCase
     assert_equal ::Paperclip::Thumbnail, Paperclip.processor(:thumbnail)
   end
 
+  should "call a proc sent to check_guard" do
+    @dummy = Dummy.new
+    @dummy.expects(:one).returns(:one)
+    assert_equal :one, @dummy.avatar.send(:check_guard, lambda{|x| x.one })
+  end
+
+  should "call a method name sent to check_guard" do
+    @dummy = Dummy.new
+    @dummy.expects(:one).returns(:one)
+    assert_equal :one, @dummy.avatar.send(:check_guard, :one)
+  end
+
   context "Paperclip.bit_bucket" do
     context "on systems without /dev/null" do
       setup do
@@ -167,6 +187,44 @@ class PaperclipTest < Test::Unit::TestCase
       end
     end
 
+    context "a validation with an if guard clause" do
+      setup do
+        Dummy.send(:"validates_attachment_presence", :avatar, :if => lambda{|i| i.foo })
+        @dummy = Dummy.new
+      end
+
+      should "attempt validation if the guard returns true" do
+        @dummy.expects(:foo).returns(true)
+        @dummy.avatar.expects(:validate_presence).returns(nil)
+        @dummy.valid?
+      end
+
+      should "not attempt validation if the guard returns false" do
+        @dummy.expects(:foo).returns(false)
+        @dummy.avatar.expects(:validate_presence).never
+        @dummy.valid?
+      end
+    end
+
+    context "a validation with an unless guard clause" do
+      setup do
+        Dummy.send(:"validates_attachment_presence", :avatar, :unless => lambda{|i| i.foo })
+        @dummy = Dummy.new
+      end
+
+      should "attempt validation if the guard returns true" do
+        @dummy.expects(:foo).returns(false)
+        @dummy.avatar.expects(:validate_presence).returns(nil)
+        @dummy.valid?
+      end
+
+      should "not attempt validation if the guard returns false" do
+        @dummy.expects(:foo).returns(true)
+        @dummy.avatar.expects(:validate_presence).never
+        @dummy.valid?
+      end
+    end
+
     def self.should_validate validation, options, valid_file, invalid_file
       context "with #{validation} validation and #{options.inspect} options" do
         setup do

data/test/storage_test.rb

@@ -10,29 +10,29 @@ class StorageTest < Test::Unit::TestCase
       @dummy = Dummy.new
       @avatar = @dummy.avatar
 
-      @current_env = ENV['RAILS_ENV']
+      @current_env = RAILS_ENV
     end
 
     teardown do
-      ENV['RAILS_ENV'] = @current_env
+      Object.const_set("RAILS_ENV", @current_env)
     end
 
     should "get the correct credentials when RAILS_ENV is production" do
-      ENV['RAILS_ENV'] = 'production'
+      Object.const_set('RAILS_ENV', "production")
       assert_equal({:key => "12345"},
                    @avatar.parse_credentials('production' => {:key => '12345'},
                                              :development => {:key => "54321"}))
     end
 
     should "get the correct credentials when RAILS_ENV is development" do
-      ENV['RAILS_ENV'] = 'development'
+      Object.const_set('RAILS_ENV', "development")
       assert_equal({:key => "54321"},
                    @avatar.parse_credentials('production' => {:key => '12345'},
                                              :development => {:key => "54321"}))
     end
 
     should "return the argument if the key does not exist" do
-      ENV['RAILS_ENV'] = "not really an env"
+      Object.const_set('RAILS_ENV', "not really an env")
       assert_equal({:test => "12345"}, @avatar.parse_credentials(:test => "12345"))
     end
   end
@@ -94,13 +94,18 @@ class StorageTest < Test::Unit::TestCase
                       :development  => { :bucket => "dev_bucket" }
                     }
       @dummy = Dummy.new
+      @old_env = RAILS_ENV
     end
 
-    should "get the right bucket in production", :before => lambda{ ENV.expects(:[]).returns('production') } do
+    teardown{ Object.const_set("RAILS_ENV", @old_env) }
+
+    should "get the right bucket in production" do
+      Object.const_set("RAILS_ENV", "production")
       assert_equal "prod_bucket", @dummy.avatar.bucket_name
     end
 
-    should "get the right bucket in development", :before => lambda{ ENV.expects(:[]).returns('development') } do
+    should "get the right bucket in development" do
+      Object.const_set("RAILS_ENV", "development")
       assert_equal "dev_bucket", @dummy.avatar.bucket_name
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: paperclip
 version: !ruby/object:Gem::Version 
-  version: 2.2.8
+  version: 2.2.9.1
 platform: ruby
 authors: 
 - Jon Yurek
@@ -9,19 +9,9 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-02 00:00:00 -04:00
+date: 2009-05-15 00:00:00 -04:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: right_aws
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda
   type: :development
@@ -61,6 +51,7 @@ files:
 - lib/paperclip/attachment.rb
 - lib/paperclip/callback_compatability.rb
 - lib/paperclip/geometry.rb
+- lib/paperclip/interpolations.rb
 - lib/paperclip/iostream.rb
 - lib/paperclip/matchers/have_attached_file_matcher.rb
 - lib/paperclip/matchers/validate_attachment_content_type_matcher.rb
@@ -75,7 +66,6 @@ files:
 - tasks/paperclip_tasks.rake
 - test/attachment_test.rb
 - test/database.yml
-- test/debug.log
 - test/fixtures/12k.png
 - test/fixtures/50x50.png
 - test/fixtures/5k.png
@@ -86,6 +76,7 @@ files:
 - test/geometry_test.rb
 - test/helper.rb
 - test/integration_test.rb
+- test/interpolations_test.rb
 - test/iostream_test.rb
 - test/matchers/have_attached_file_matcher_test.rb
 - test/matchers/validate_attachment_content_type_matcher_test.rb
@@ -93,10 +84,8 @@ files:
 - test/matchers/validate_attachment_size_matcher_test.rb
 - test/paperclip_test.rb
 - test/processor_test.rb
-- test/s3.yml
 - test/storage_test.rb
 - test/thumbnail_test.rb
-- test/tmp/storage.txt
 - shoulda_macros/paperclip.rb
 has_rdoc: true
 homepage: http://www.thoughtbot.com/projects/paperclip