paperclip 2.1.5 → 2.2.0

data/lib/paperclip/callback_compatability.rb

@@ -0,0 +1,33 @@
+module Paperclip
+  # This module is intended as a compatability shim for the differences in
+  # callbacks between Rails 2.0 and Rails 2.1.
+  module CallbackCompatability
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      # The implementation of this method is taken from the Rails 1.2.6 source,
+      # from rails/activerecord/lib/active_record/callbacks.rb, line 192.
+      def define_callbacks(*args)
+        args.each do |method|
+          self.class_eval <<-"end_eval"
+            def self.#{method}(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(#{method.to_sym.inspect}, callbacks)
+            end
+          end_eval
+        end
+      end
+    end
+
+    module InstanceMethods
+      # The callbacks in < 2.1 don't worry about the extra options or the
+      # block, so just run what we have available.
+      def run_callbacks(meth, opts = nil, &blk)
+        callback(meth)
+      end
+    end
+  end
+end

data/lib/paperclip/iostream.rb

@@ -30,7 +30,7 @@ module IOStream
   end
 end
 
-class IO
+class IO #:nodoc:
   include IOStream
 end
 

data/lib/paperclip/processor.rb

@@ -0,0 +1,47 @@
+module Paperclip
+  # Paperclip processors allow you to modify attached files when they are
+  # attached in any way you are able. Paperclip itself uses command-line
+  # programs for its included Thumbnail processor, but custom processors
+  # 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.
+  #
+  # All #make needs to do is return an instance of File (Tempfile is
+  # acceptable) which contains the results of the processing.
+  #
+  # See Paperclip.run for more information about using command-line
+  # utilities from within Processors.
+  class Processor
+    attr_accessor :file, :options
+
+    def initialize file, options = {}
+      @file = file
+      @options = options
+    end
+
+    def make
+    end
+
+    def self.make file, options = {}
+      new(file, options).make
+    end
+  end
+  
+  # Due to how ImageMagick handles its image format conversion and how Tempfile
+  # handles its naming scheme, it is necessary to override how Tempfile makes
+  # its names so as to allow for file extensions. Idea taken from the comments
+  # on this blog post:
+  # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
+  class Tempfile < ::Tempfile
+    # Replaces Tempfile's +make_tmpname+ with one that honors file extensions.
+    def make_tmpname(basename, n)
+      extension = File.extname(basename)
+      sprintf("%s,%d,%d%s", File.basename(basename, extension), $$, n, extension)
+    end
+  end
+end

data/lib/paperclip/storage.rb

@@ -56,6 +56,14 @@ module Paperclip
           rescue Errno::ENOENT => e
             # ignore file-not-found, let everything else pass
           end
+          begin
+            while(true)
+              path = File.dirname(path)
+              FileUtils.rmdir(path)
+            end
+          rescue Errno::ENOTEMPTY, Errno::ENOENT, Errno::EINVAL
+            # Stop trying to remove parent directories
+          end
         end
         @queued_for_delete = []
       end
@@ -91,6 +99,7 @@ module Paperclip
     # * +s3_protocol+: The protocol for the URLs generated to your S3 assets. Can be either 
     #   'http' or 'https'. Defaults to 'http' when your :s3_permissions are 'public-read' (the
     #   default), and 'https' when your :s3_permissions are anything else.
+    # * +s3_headers+: A hash of headers such as {'Expires' => 1.year.from_now.httpdate}
     # * +bucket+: This is the name of the S3 bucket that will store your files. Remember
     #   that the bucket must be unique across all of Amazon S3. If the bucket does not exist
     #   Paperclip will attempt to create it. The bucket name will not be interpolated.
@@ -113,6 +122,7 @@ module Paperclip
           @s3_options     = @options[:s3_options] || {}
           @s3_permissions = @options[:s3_permissions] || 'public-read'
           @s3_protocol    = @options[:s3_protocol] || (@s3_permissions == 'public-read' ? 'http' : 'https')
+          @s3_headers     = @options[:s3_headers] || {}
           @url            = ":s3_path_url" unless @url.to_s.match(/^:s3.*url$/)
         end
         base.class.interpolations[:s3_path_url] = lambda do |attachment, style|
@@ -165,7 +175,7 @@ module Paperclip
             logger.info("[paperclip] -> #{path(style)}")
             key = s3_bucket.key(path(style))
             key.data = file
-            key.put(nil, @s3_permissions, {'Content-type' => instance_read(:content_type)})
+            key.put(nil, @s3_permissions, {'Content-type' => instance_read(:content_type)}.merge(@s3_headers))
           rescue RightAws::AwsError => e
             raise
           end

data/lib/paperclip/thumbnail.rb

@@ -1,33 +1,28 @@
 module Paperclip
   # Handles thumbnailing images that are uploaded.
-  class Thumbnail
+  class Thumbnail < Processor
 
-    attr_accessor :file, :current_geometry, :target_geometry, :format, :whiny_thumbnails, :convert_options
+    attr_accessor :current_geometry, :target_geometry, :format, :whiny, :convert_options
 
     # Creates a Thumbnail object set to work on the +file+ given. It
     # will attempt to transform the image into one defined by +target_geometry+
     # which is a "WxH"-style string. +format+ will be inferred from the +file+
     # unless specified. Thumbnail creation will raise no errors unless
-    # +whiny_thumbnails+ is true (which it is, by default. If +convert_options+ is
+    # +whiny+ is true (which it is, by default. If +convert_options+ is
     # set, the options will be appended to the convert command upon image conversion 
-    def initialize file, target_geometry, format = nil, convert_options = nil, whiny_thumbnails = true
+    def initialize file, options = {}
+      super
+      geometry          = options[:geometry]
       @file             = file
-      @crop             = target_geometry[-1,1] == '#'
-      @target_geometry  = Geometry.parse target_geometry
-      @current_geometry = Geometry.from_file file
-      @convert_options  = convert_options
-      @whiny_thumbnails = whiny_thumbnails
+      @crop             = geometry[-1,1] == '#'
+      @target_geometry  = Geometry.parse geometry
+      @current_geometry = Geometry.from_file @file
+      @convert_options  = options[:convert_options]
+      @whiny            = options[:whiny].nil? ? true : options[:whiny]
+      @format           = options[:format]
 
       @current_format   = File.extname(@file.path)
       @basename         = File.basename(@file.path, @current_format)
-      
-      @format = format
-    end
-
-    # Creates a thumbnail, as specified in +initialize+, +make+s it, and returns the
-    # resulting Tempfile.
-    def self.make file, dimensions, format = nil, convert_options = nil, whiny_thumbnails = true
-      new(file, dimensions, format, convert_options, whiny_thumbnails).make
     end
 
     # Returns true if the +target_geometry+ is meant to crop.
@@ -56,7 +51,7 @@ module Paperclip
       begin
         success = Paperclip.run("convert", command.gsub(/\s+/, " "))
       rescue PaperclipCommandLineError
-        raise PaperclipError, "There was an error processing the thumbnail for #{@basename}" if @whiny_thumbnails
+        raise PaperclipError, "There was an error processing the thumbnail for #{@basename}" if @whiny
       end
 
       dst
@@ -72,17 +67,4 @@ module Paperclip
       trans
     end
   end
-
-  # Due to how ImageMagick handles its image format conversion and how Tempfile
-  # handles its naming scheme, it is necessary to override how Tempfile makes
-  # its names so as to allow for file extensions. Idea taken from the comments
-  # on this blog post:
-  # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
-  class Tempfile < ::Tempfile
-    # Replaces Tempfile's +make_tmpname+ with one that honors file extensions.
-    def make_tmpname(basename, n)
-      extension = File.extname(basename)
-      sprintf("%s,%d,%d%s", File.basename(basename, extension), $$, n, extension)
-    end
-  end
 end

data/shoulda_macros/paperclip.rb

@@ -1,5 +1,15 @@
 module Paperclip
+  # =Paperclip Shoulda Macros
+  #
+  # These macros are intended for use with shoulda, and will be included into
+  # your tests automatically. All of the macros use the standard shoulda
+  # assumption that the name of the test is based on the name of the model
+  # you're testing (that is, UserTest is the test for the User model), and
+  # will load that class for testing purposes.
   module Shoulda
+    # This will test whether you have defined your attachment correctly by
+    # checking for all the required fields exist after the definition of the
+    # attachment.
     def should_have_attached_file name, options = {}
       klass = self.name.gsub(/Test$/, '').constantize
       context "Class #{klass.name} with attachment #{name}" do
@@ -8,20 +18,131 @@ module Paperclip
             assert klass.instance_methods.include?(meth), "#{klass.name} does not respond to #{name}."
           end
         end
+      end
+    end
 
-        should "have the correct definition" do
-          expected = options
-          actual   = klass.attachment_definitions[name]
-          expected.delete(:validations)      if not options.key?(:validations)
-          expected.delete(:whiny_thumbnails) if not options.key?(:whiny_thumbnails)
+    # Tests for validations on the presence of the attachment.
+    def should_validate_attachment_presence name
+      klass   = self.name.gsub(/Test$/, '').constantize
+      context "Class #{klass.name} validating presence on #{name}" do
+        context "when the assignment is nil" do
+          setup do
+            @attachment = klass.new.send(name)
+            @attachment.assign(nil)
+          end
+          should "have a :presence validation error" do
+            assert @assignment.errors[:presence]
+          end
+        end
+        context "when the assignment is valid" do
+          setup do
+            @attachment = klass.new.send(name)
+            @attachment.assign(nil)
+          end
+          should "have a :presence validation error" do
+            assert ! @assignment.errors[:presence]
+          end
+        end
+      end
+    end
 
-          assert_equal expected, actual
+    # Tests that you have content_type validations specified. There are two
+    # options, :valid and :invalid. Both accept an array of strings. The
+    # strings should be a list of content types which will pass and fail
+    # validation, respectively.
+    def should_validate_attachment_content_type name, options = {}
+      klass   = self.name.gsub(/Test$/, '').constantize
+      valid   = [options[:valid]].flatten
+      invalid = [options[:invalid]].flatten
+      context "Class #{klass.name} validating content_types on #{name}" do
+        valid.each do |type|
+          context "being assigned a file with a content_type of #{type}" do
+            setup do
+              @file = StringIO.new(".")
+              class << @file; attr_accessor :content_type; end
+              @file.content_type = type
+              @attachment = klass.new.send(name)
+              @attachment.assign(@file)
+            end
+            should "not have a :content_type validation error" do
+              assert ! @assignment.errors[:content_type]
+            end
+          end
         end
+        invalid.each do |type|
+          context "being assigned a file with a content_type of #{type}" do
+            setup do
+              @file = StringIO.new(".")
+              class << @file; attr_accessor :content_type; end
+              @file.content_type = type
+              @attachment = klass.new.send(name)
+              @attachment.assign(@file)
+            end
+            should "have a :content_type validation error" do
+              assert @assignment.errors[:content_type]
+            end
+          end
+        end
+      end
+    end
+
+    # Tests to ensure that you have file size validations turned on. You
+    # can pass the same options to this that you can to 
+    # validate_attachment_file_size - :less_than, :greater_than, and :in.
+    # :less_than checks that a file is less than a certain size, :greater_than
+    # checks that a file is more than a certain size, and :in takes a Range or
+    # Array which specifies the lower and upper limits of the file size.
+    def should_validate_attachment_size name, options = {}
+      klass   = self.name.gsub(/Test$/, '').constantize
+      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)
+      context "Class #{klass.name} validating file size on #{name}" do
+        context "with an attachment that is #{max+1} bytes" do
+          setup do
+            @file = StringIO.new("." * (max+1))
+            @attachment = klass.new.send(name)
+            @attachment.assign(@file)
+          end
+
+          should "have a :size validation error" do
+            assert @attachment.errors[:size]
+          end
+        end
+        context "with an attachment that us #{max-1} bytes" do
+          setup do
+            @file = StringIO.new("." * (max-1))
+            @attachment = klass.new.send(name)
+            @attachment.assign(@file)
+          end
+
+          should "not have a :size validation error" do
+            assert ! @attachment.errors[:size]
+          end
+        end
+
+        if min > 0
+          context "with an attachment that is #{min-1} bytes" do
+            setup do
+              @file = StringIO.new("." * (min-1))
+              @attachment = klass.new.send(name)
+              @attachment.assign(@file)
+            end
+
+            should "have a :size validation error" do
+              assert @attachment.errors[:size]
+            end
+          end
+          context "with an attachment that us #{min+1} bytes" do
+            setup do
+              @file = StringIO.new("." * (min+1))
+              @attachment = klass.new.send(name)
+              @attachment.assign(@file)
+            end
 
-        should "ensure that ImageMagick is available" do
-          %w( convert identify ).each do |command|
-            `#{Paperclip.path_for_command(command)}`
-            assert_equal 0, $?, "ImageMagick's #{command} returned with an error. Make sure that #{command} is available at #{Paperclip.path_for_command(command)}"
+            should "not have a :size validation error" do
+              assert ! @attachment.errors[:size]
+            end
           end
         end
       end

data/test/attachment_test.rb

@@ -81,6 +81,8 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar = @file
     end
 
+    teardown { @file.close }
+
     should "make sure that they are interpolated correctly" do
       assert_equal "1024.omg/1024-bbq/1024what/000/001/024.wtf", @dummy.avatar.path
     end
@@ -99,6 +101,8 @@ class AttachmentTest < Test::Unit::TestCase
       @dummy.avatar = @file
     end
 
+    teardown { @file.close }
+
     should "return the proper path" do
       temporary_rails_env(@rails_env) {
         assert_equal "#{@rails_env}/#{@id}.png", @dummy.avatar.path
@@ -117,6 +121,7 @@ class AttachmentTest < Test::Unit::TestCase
                       :thumb => "-thumbnailize"
                     }
       @dummy = Dummy.new
+      @dummy.avatar
     end
 
     should "report the correct options when sent #extra_options_for(:thumb)" do
@@ -127,48 +132,128 @@ class AttachmentTest < Test::Unit::TestCase
       assert_equal "-do_stuff", @dummy.avatar.send(:extra_options_for, :large)
     end
 
-    context "when given a file" do
-      setup do
-        @file = File.new(File.join(File.dirname(__FILE__),
-                                   "fixtures",
-                                   "5k.png"), 'rb')
-        Paperclip::Thumbnail.stubs(:make)
-        [:thumb, :large].each do |style|
-          @dummy.avatar.stubs(:extra_options_for).with(style)
-        end
+    before_should "call extra_options_for(:thumb/:large)" do
+      Paperclip::Attachment.any_instance.expects(:extra_options_for).with(:thumb)
+      Paperclip::Attachment.any_instance.expects(:extra_options_for).with(:large)
+    end
+  end
+
+  context "An attachment with both 'normal' and hash-style styles" do
+    setup do
+      rebuild_model :styles => {
+                      :normal => ["50x50#", :png],
+                      :hash => { :geometry => "50x50#", :format => :png }
+                    }
+      @dummy = Dummy.new
+      @attachment = @dummy.avatar
+    end
+
+    [:processors, :whiny, :convert_options, :geometry, :format].each do |field|
+      should "have the same #{field} field" do
+        assert_equal @attachment.styles[:normal][field], @attachment.styles[:hash][field]
       end
+    end
+  end
 
-      [:thumb, :large].each do |style|
-        should "call extra_options_for(#{style})" do
-          @dummy.avatar.expects(:extra_options_for).with(style)
-          @dummy.avatar = @file
-        end
+  context "An attachment with multiple processors" do
+    setup do
+      class Paperclip::Test < Paperclip::Processor; end
+      @style_params = { :once => {:one => 1, :two => 2} }
+      rebuild_model :processors => [:thumbnail, :test], :styles => @style_params
+      @dummy = Dummy.new
+      @file = StringIO.new("...")
+      @file.stubs(:to_tempfile).returns(@file)
+      Paperclip::Test.stubs(:make).returns(@file)
+      Paperclip::Thumbnail.stubs(:make).returns(@file)
+    end
+
+    context "when assigned" do
+      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 => ""})
+        Paperclip::Thumbnail.expects(:make).with(@file, expected_params).returns(@file)
+        Paperclip::Test.expects(:make).with(@file, expected_params).returns(@file)
       end
     end
   end
 
+  context "Assigning an attachment with post_process hooks" do
+    setup do
+      rebuild_model :styles => { :something => "100x100#" }
+      Dummy.class_eval do
+        before_avatar_post_process :do_before_avatar
+        after_avatar_post_process :do_after_avatar
+        before_post_process :do_before_all
+        after_post_process :do_after_all
+        def do_before_avatar; end
+        def do_after_avatar; end
+        def do_before_all; end
+        def do_after_all; end
+      end
+      @file  = File.new(File.join(FIXTURES_DIR, "5k.png"), 'rb')
+      @file.stubs(:to_tempfile).returns(@file)
+      @dummy = Dummy.new
+      Paperclip::Thumbnail.stubs(:make).returns(@file)
+      @attachment = @dummy.avatar
+    end
+
+    should "call the defined callbacks when assigned" do
+      @dummy.expects(:do_before_avatar).with()
+      @dummy.expects(:do_after_avatar).with()
+      @dummy.expects(:do_before_all).with()
+      @dummy.expects(:do_after_all).with()
+      Paperclip::Thumbnail.expects(:make).returns(@file)
+      @dummy.avatar = @file
+    end
+
+    should "not cancel the processing if a before_post_process returns nil" do
+      @dummy.expects(:do_before_avatar).with().returns(nil)
+      @dummy.expects(:do_after_avatar).with()
+      @dummy.expects(:do_before_all).with().returns(nil)
+      @dummy.expects(:do_after_all).with()
+      Paperclip::Thumbnail.expects(:make).returns(@file)
+      @dummy.avatar = @file
+    end
+
+    should "cancel the processing if a before_post_process returns false" do
+      @dummy.expects(:do_before_avatar).never
+      @dummy.expects(:do_after_avatar).never
+      @dummy.expects(:do_before_all).with().returns(false)
+      @dummy.expects(:do_after_all).never
+      Paperclip::Thumbnail.expects(:make).never
+      @dummy.avatar = @file
+    end
+
+    should "cancel the processing if a before_avatar_post_process returns false" do
+      @dummy.expects(:do_before_avatar).with().returns(false)
+      @dummy.expects(:do_after_avatar).never
+      @dummy.expects(:do_before_all).with().returns(true)
+      @dummy.expects(:do_after_all).never
+      Paperclip::Thumbnail.expects(:make).never
+      @dummy.avatar = @file
+    end
+  end
+
   context "Assigning an attachment" do
     setup do
-      rebuild_model
-      
-      @not_file = mock
-      @not_file.stubs(:nil?).returns(false)
-      @not_file.expects(:to_tempfile).returns(self)
-      @not_file.expects(:original_filename).returns("filename.png\r\n")
-      @not_file.expects(:content_type).returns("image/png\r\n")
-      @not_file.expects(:size).returns(10).times(2)
-      
+      rebuild_model :styles => { :something => "100x100#" }
+      @file  = File.new(File.join(FIXTURES_DIR, "5k.png"), 'rb')
+      @file.expects(:original_filename).returns("5k.png\n\n")
+      @file.expects(:content_type).returns("image/png\n\n")
+      @file.stubs(:to_tempfile).returns(@file)
       @dummy = Dummy.new
+      Paperclip::Thumbnail.expects(:make).returns(@file)
+      @dummy.expects(:run_callbacks).with(:before_avatar_post_process, {:original => @file})
+      @dummy.expects(:run_callbacks).with(:before_post_process, {:original => @file})
+      @dummy.expects(:run_callbacks).with(:after_avatar_post_process, {:original => @file, :something => @file})
+      @dummy.expects(:run_callbacks).with(:after_post_process, {:original => @file, :something => @file})
       @attachment = @dummy.avatar
-      @attachment.expects(:valid_assignment?).with(@not_file).returns(true)
-      @attachment.expects(:queue_existing_for_delete)
-      @attachment.expects(:post_process)
-      @attachment.expects(:validate)
-      @dummy.avatar = @not_file
+      @dummy.avatar = @file
     end
 
     should "strip whitespace from original_filename field" do
-      assert_equal "filename.png", @dummy.avatar.original_filename
+      assert_equal "5k.png", @dummy.avatar.original_filename
     end
 
     should "strip whitespace from content_type field" do
@@ -192,6 +277,7 @@ class AttachmentTest < Test::Unit::TestCase
       @attachment.expects(:valid_assignment?).with(@not_file).returns(true)
       @attachment.expects(:queue_existing_for_delete)
       @attachment.expects(:post_process)
+      @attachment.expects(:valid?).returns(true)
       @attachment.expects(:validate)
       @dummy.avatar = @not_file
     end
@@ -216,6 +302,8 @@ class AttachmentTest < Test::Unit::TestCase
                                  "5k.png"), 'rb')
     end
 
+    teardown { @file.close }
+
     should "raise if there are not the correct columns when you try to assign" do
       @other_attachment = Paperclip::Attachment.new(:not_here, @instance)
       assert_raises(Paperclip::PaperclipError) do
@@ -247,12 +335,16 @@ class AttachmentTest < Test::Unit::TestCase
 
       should "return a correct url even if the file does not exist" do
         assert_nil @attachment.to_file
-        assert_match %r{^/avatars/#{@instance.id}/blah/5k\.png}, @attachment.url(:blah)
+        assert_match %r{^/system/avatars/#{@instance.id}/blah/5k\.png}, @attachment.url(:blah)
       end
 
       should "make sure the updated_at mtime is in the url if it is defined" do
         assert_match %r{#{Time.now.to_i}$}, @attachment.url(:blah)
       end
+ 
+      should "make sure the updated_at mtime is NOT in the url if false is passed to the url method" do
+        assert_no_match %r{#{Time.now.to_i}$}, @attachment.url(:blah, false)
+      end
 
       context "with the updated_at field removed" do
         setup do
@@ -302,8 +394,8 @@ class AttachmentTest < Test::Unit::TestCase
             should "return the real url" do
               file = @attachment.to_file
               assert file
-              assert_match %r{^/avatars/#{@instance.id}/original/5k\.png}, @attachment.url
-              assert_match %r{^/avatars/#{@instance.id}/small/5k\.jpg}, @attachment.url(:small)
+              assert_match %r{^/system/avatars/#{@instance.id}/original/5k\.png}, @attachment.url
+              assert_match %r{^/system/avatars/#{@instance.id}/small/5k\.jpg}, @attachment.url(:small)
               file.close
             end
 
@@ -378,6 +470,8 @@ class AttachmentTest < Test::Unit::TestCase
       @file = File.new(File.join(File.dirname(__FILE__), "fixtures", "5k.png"), 'rb')
     end
 
+    teardown { @file.close }
+
     should "not error when assigned an attachment" do
       assert_nothing_raised { @dummy.avatar = @file }
     end