paperclip 2.1.0

data/test/fixtures/bad.png

@@ -0,0 +1 @@
+This is not an image.

data/test/helper.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'tempfile'
+
+require 'active_record'
+begin
+  require 'ruby-debug'
+rescue LoadError
+  puts "ruby-debug not loaded"
+end
+
+ROOT       = File.join(File.dirname(__FILE__), '..')
+RAILS_ROOT = ROOT
+
+$LOAD_PATH << File.join(ROOT, 'lib')
+$LOAD_PATH << File.join(ROOT, 'lib', 'paperclip')
+
+require File.join(ROOT, 'lib', 'paperclip.rb')
+
+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")
+ActiveRecord::Base.establish_connection(config[ENV['RAILS_ENV'] || 'test'])
+
+def rebuild_model options = {}
+  ActiveRecord::Base.connection.create_table :dummies, :force => true do |table|
+    table.column :other, :string
+    table.column :avatar_file_name, :string
+    table.column :avatar_content_type, :string
+    table.column :avatar_file_size, :integer
+  end
+
+  ActiveRecord::Base.send(:include, Paperclip)
+  Object.send(:remove_const, "Dummy") rescue nil
+  Object.const_set("Dummy", Class.new(ActiveRecord::Base))
+  Dummy.class_eval do
+    include Paperclip
+    has_attached_file :avatar, options
+  end
+end

data/test/s3.yml

@@ -0,0 +1,2 @@
+access_key_id: 11196XQ35WGRKEVQN782
+secret_access_key: TczVRadcH5sealaWUMpbY/Hnex90iCmJ3LDM5w74

data/test/test_attachment.rb

@@ -0,0 +1,207 @@
+require 'test/helper'
+
+class Dummy
+  # This is a dummy class
+end
+
+class AttachmentTest < Test::Unit::TestCase
+  context "Attachment default_options" do
+    setup do
+      rebuild_model
+      @old_default_options = Paperclip::Attachment.default_options.dup
+      @new_default_options = @old_default_options.merge({
+        :path => "argle/bargle",
+        :url => "fooferon",
+        :default_url => "not here.png"
+      })
+    end
+
+    teardown do
+      Paperclip::Attachment.default_options.merge! @old_default_options
+    end
+
+    should "be overrideable" do
+      Paperclip::Attachment.default_options.merge!(@new_default_options)
+      @new_default_options.keys.each do |key|
+        assert_equal @new_default_options[key],
+                     Paperclip::Attachment.default_options[key]
+      end
+    end
+
+    context "on an Attachment" do
+      setup do
+        @dummy = Dummy.new
+        @attachment = @dummy.avatar
+      end
+
+      Paperclip::Attachment.default_options.keys.each do |key|
+        should "be the default_options for #{key}" do
+          assert_equal @old_default_options[key], 
+                       @attachment.instance_variable_get("@#{key}"),
+                       key
+        end
+      end
+
+      context "when redefined" do
+        setup do
+          Paperclip::Attachment.default_options.merge!(@new_default_options)
+          @dummy = Dummy.new
+          @attachment = @dummy.avatar
+        end
+
+        Paperclip::Attachment.default_options.keys.each do |key|
+          should "be the new default_options for #{key}" do
+            assert_equal @new_default_options[key],
+                         @attachment.instance_variable_get("@#{key}"),
+                         key
+          end
+        end
+      end
+    end
+  end
+
+  context "An attachment with similarly named interpolations" do
+    setup do
+      rebuild_model :path => ":id.omg/:id-bbq/:idwhat/:id_partition.wtf"
+      @dummy = Dummy.new
+      @dummy.stubs(:id).returns(1024)
+      @file = File.new(File.join(File.dirname(__FILE__),
+                                 "fixtures",
+                                 "5k.png"))
+      @dummy.avatar = @file
+    end
+
+    should "make sure that they are interpolated correctly" do
+      assert_equal "1024.omg/1024-bbq/:idwhat/000/001/024.wtf", @dummy.avatar.path
+    end
+  end
+
+  context "An attachment" do
+    setup do
+      Paperclip::Attachment.default_options.merge!({
+        :path => ":rails_root/tmp/:attachment/:class/:style/:id/:basename.:extension"
+      })
+      FileUtils.rm_rf("tmp")
+      @instance = stub
+      @instance.stubs(:id).returns(41)
+      @instance.stubs(:class).returns(Dummy)
+      @instance.stubs(:[]).with(:test_file_name).returns("5k.png")
+      @instance.stubs(:[]).with(:test_content_type).returns("image/png")
+      @instance.stubs(:[]).with(:test_file_size).returns(12345)
+      @attachment = Paperclip::Attachment.new(:test,
+                                              @instance)
+      @file = File.new(File.join(File.dirname(__FILE__),
+                                 "fixtures",
+                                 "5k.png"))
+    end
+
+    should "return its default_url when no file assigned" do
+      assert @attachment.file.nil?
+      assert_equal "/tests/original/missing.png", @attachment.url
+      assert_equal "/tests/blah/missing.png", @attachment.url(:blah)
+    end
+
+    context "when expecting three styles" do
+      setup do
+        styles = {:styles => { :large  => ["400x400", :png],
+                               :medium => ["100x100", :gif],
+                               :small => ["32x32#", :jpg]}}
+        @attachment = Paperclip::Attachment.new(:test,
+                                                @instance,
+                                                styles)
+      end
+
+      context "and assigned a file" do
+        setup do
+          @instance.expects(:[]=).with(:test_file_name,
+                                       File.basename(@file.path))
+          @instance.expects(:[]=).with(:test_content_type, "image/png")
+          @instance.expects(:[]=).with(:test_file_size, @file.size)
+          @instance.expects(:[]=).with(:test_file_name, nil)
+          @instance.expects(:[]=).with(:test_content_type, nil)
+          @instance.expects(:[]=).with(:test_file_size, nil)
+          @attachment.assign(@file)
+        end
+
+        should "return the real url" do
+          assert @attachment.file
+          assert_equal "/tests/41/original/5k.png", @attachment.url
+          assert_equal "/tests/41/blah/5k.png", @attachment.url(:blah)
+        end
+
+        should "be dirty" do
+          assert @attachment.dirty?
+        end
+
+        should "have its image and attachments as tempfiles" do
+          [nil, :large, :medium, :small].each do |style|
+            assert File.exists?(@attachment.to_io(style))
+          end
+        end
+
+        context "and saved" do
+          setup do
+            @attachment.save
+          end
+
+          should "commit the files to disk" do
+            [nil, :large, :medium, :small].each do |style|
+              io = @attachment.to_io(style)
+              assert File.exists?(io)
+              assert ! io.is_a?(::Tempfile)
+            end
+          end
+
+          should "save the files as the right formats and sizes" do
+            [[:large, 400, 61, "PNG"],
+             [:medium, 100, 15, "GIF"],
+             [:small, 32, 32, "JPEG"]].each do |style|
+              cmd = "identify -format '%w %h %b %m' " + 
+                    "#{@attachment.to_io(style.first).path}"
+              out = `#{cmd}`
+              width, height, size, format = out.split(" ")
+              assert_equal style[1].to_s, width.to_s 
+              assert_equal style[2].to_s, height.to_s
+              assert_equal style[3].to_s, format.to_s
+            end
+          end
+
+          should "have #file be equal #to_io(:original)" do
+            assert_equal @attachment.file, @attachment.to_io(:original)
+          end
+
+          should "still have its #file attribute not be nil" do
+            assert ! @attachment.file.nil?
+          end
+
+          context "and deleted" do
+            setup do
+              @existing_names = @attachment.styles.keys.collect do |style|
+                @attachment.path(style)
+              end
+              @instance.expects(:[]=).with(:test_file_name, nil)
+              @instance.expects(:[]=).with(:test_content_type, nil)
+              @instance.expects(:[]=).with(:test_file_size, nil)
+              @attachment.assign nil
+              @attachment.save
+            end
+
+            should "delete the files" do
+              @existing_names.each{|f| assert ! File.exists?(f) }
+            end
+          end
+        end
+      end
+    end
+
+    context "when trying a nonexistant storage type" do
+      setup do
+        rebuild_model :storage => :not_here
+      end
+
+      should "not be able to find the module" do
+        assert_raise(NameError){ Dummy.new.avatar }
+      end
+    end
+  end
+end

data/test/test_geometry.rb

@@ -0,0 +1,142 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'paperclip', 'geometry.rb')
+
+class GeometryTest < Test::Unit::TestCase
+  context "Paperclip::Geometry" do
+    should "correctly report its given dimensions" do
+      assert @geo = Paperclip::Geometry.new(1024, 768)
+      assert_equal 1024, @geo.width
+      assert_equal 768, @geo.height
+    end
+
+    should "correctly create a square if the height dimension is missing" do
+      assert @geo = Paperclip::Geometry.new(1024)
+      assert_equal 1024, @geo.width
+      assert_equal 1024, @geo.height
+    end
+
+    should "correctly create a square if the width dimension is missing" do
+      assert @geo = Paperclip::Geometry.new(nil, 768)
+      assert_equal 768, @geo.width
+      assert_equal 768, @geo.height
+    end
+
+    should "be generated from a WxH-formatted string" do
+      assert @geo = Paperclip::Geometry.parse("800x600")
+      assert_equal 800, @geo.width
+      assert_equal 600, @geo.height
+    end
+
+    should "be generated from a xH-formatted string" do
+      assert @geo = Paperclip::Geometry.parse("x600")
+      assert_equal 600, @geo.width
+      assert_equal 600, @geo.height
+    end
+      
+    should "be generated from a Wx-formatted string" do
+      assert @geo = Paperclip::Geometry.parse("800x")
+      assert_equal 800, @geo.width
+      assert_equal 800, @geo.height
+    end
+
+    should "ensure the modifier is nil if only one dimension present" do
+      assert @geo = Paperclip::Geometry.parse("123x")
+      assert_nil @geo.modifier
+    end
+
+    should "ensure the modifier is nil if not present" do
+      assert @geo = Paperclip::Geometry.parse("123x456")
+      assert_nil @geo.modifier
+    end
+
+    ['>', '<', '#', '@', '%', '^', '!'].each do |mod|
+      should "ensure the modifier #{mod} is preserved" do
+        assert @geo = Paperclip::Geometry.parse("123x456#{mod}")
+        assert_equal mod, @geo.modifier
+      end
+    end
+
+    should "make sure the modifier gets passed during transformation_to" do
+      assert @src = Paperclip::Geometry.parse("123x456")
+      assert @dst = Paperclip::Geometry.parse("123x456>")
+      assert_equal "123x456>", @src.transformation_to(@dst).to_s
+    end
+
+    should "be generated from a file" do
+      file = File.join(File.dirname(__FILE__), "fixtures", "5k.png")
+      file = File.new(file)
+      assert_nothing_raised{ @geo = Paperclip::Geometry.from_file(file) }
+      assert @geo.height > 0
+      assert @geo.width > 0
+    end
+
+    should "be generated from a file path" do
+      file = File.join(File.dirname(__FILE__), "fixtures", "5k.png")
+      assert_nothing_raised{ @geo = Paperclip::Geometry.from_file(file) }
+      assert @geo.height > 0
+      assert @geo.width > 0
+    end
+
+    should "not generate from a bad file" do
+      file = "/home/This File Does Not Exist.omg"
+      assert_raise(Errno::ENOENT){ @geo = Paperclip::Geometry.from_file(file) }
+    end
+
+    [['vertical',   900,  1440, true,  false, false, 1440, 900, 0.625],
+     ['horizontal', 1024, 768,  false, true,  false, 1024, 768, 1.3333],
+     ['square',     100,  100,  false, false, true,  100,  100, 1]].each do |args|
+      context "performing calculations on a #{args[0]} viewport" do
+        setup do
+          @geo = Paperclip::Geometry.new(args[1], args[2])
+        end
+
+        should "#{args[3] ? "" : "not"} be vertical" do
+          assert_equal args[3], @geo.vertical?
+        end
+
+        should "#{args[4] ? "" : "not"} be horizontal" do
+          assert_equal args[4], @geo.horizontal?
+        end
+
+        should "#{args[5] ? "" : "not"} be square" do
+          assert_equal args[5], @geo.square?
+        end
+
+        should "report that #{args[6]} is the larger dimension" do
+          assert_equal args[6], @geo.larger
+        end
+
+        should "report that #{args[7]} is the smaller dimension" do
+          assert_equal args[7], @geo.smaller
+        end
+
+        should "have an aspect ratio of #{args[8]}" do
+          assert_in_delta args[8], @geo.aspect, 0.0001
+        end
+      end
+    end
+
+    [[ [1000, 100], [64, 64],  "x64", "64x64+288+0" ],
+     [ [100, 1000], [50, 950], "x950", "50x950+22+0" ],
+     [ [100, 1000], [50, 25],  "50x", "50x25+0+237" ]]. each do |args|
+      context "of #{args[0].inspect} and given a Geometry #{args[1].inspect} and sent transform_to" do
+        setup do
+          @geo = Paperclip::Geometry.new(*args[0])
+          @dst = Paperclip::Geometry.new(*args[1])
+          @scale, @crop = @geo.transformation_to @dst, true
+        end
+
+        should "be able to return the correct scaling transformation geometry #{args[2]}" do
+          assert_equal args[2], @scale
+        end
+
+        should "be able to return the correct crop transformation geometry #{args[3]}" do
+          assert_equal args[3], @crop
+        end
+      end
+    end
+  end
+end

data/test/test_integration.rb

@@ -0,0 +1,238 @@
+require 'test/helper.rb'
+
+class IntegrationTest < Test::Unit::TestCase
+  context "A model with a filesystem attachment" do
+    setup do
+      rebuild_model :styles => { :large => "300x300>",
+                                 :medium => "100x100",
+                                 :thumb => ["32x32#", :gif] },
+                    :default_style => :medium,
+                    :url => "/:attachment/:class/:style/:id/:basename.:extension",
+                    :path => ":rails_root/tmp/:attachment/:class/:style/:id/:basename.:extension"
+      @dummy     = Dummy.new
+      @file      = File.new(File.join(FIXTURES_DIR, "5k.png"))
+      @bad_file  = File.new(File.join(FIXTURES_DIR, "bad.png"))
+
+      assert @dummy.avatar = @file
+      assert @dummy.valid?
+      assert @dummy.save
+    end
+
+    should "write and delete its files" do
+      [["100x15", nil],
+       ["434x66", :original],
+       ["300x46", :large],
+       ["100x15", :medium],
+       ["32x32", :thumb]].each do |geo, style|
+        cmd = %Q[identify -format "%wx%h" #{@dummy.avatar.to_file(style).path}]
+        assert_equal geo, `#{cmd}`.chomp, cmd
+      end
+
+      saved_paths = [:thumb, :medium, :large, :original].collect{|s| @dummy.avatar.to_file(s).path }
+
+      @d2 = Dummy.find(@dummy.id)
+      assert_equal "100x15", `identify -format "%wx%h" #{@d2.avatar.to_file.path}`.chomp
+      assert_equal "434x66", `identify -format "%wx%h" #{@d2.avatar.to_file(:original).path}`.chomp
+      assert_equal "300x46", `identify -format "%wx%h" #{@d2.avatar.to_file(:large).path}`.chomp
+      assert_equal "100x15", `identify -format "%wx%h" #{@d2.avatar.to_file(:medium).path}`.chomp
+      assert_equal "32x32",  `identify -format "%wx%h" #{@d2.avatar.to_file(:thumb).path}`.chomp
+
+      @dummy.avatar = "not a valid file but not nil"
+      assert_equal File.basename(@file.path), @dummy.avatar_file_name
+      assert @dummy.valid?
+      assert @dummy.save
+
+      saved_paths.each do |p|
+        assert File.exists?(p)
+      end
+
+      @dummy.avatar = nil
+      assert_nil @dummy.avatar_file_name
+      assert @dummy.valid?
+      assert @dummy.save
+
+      saved_paths.each do |p|
+        assert ! File.exists?(p)
+      end
+
+      @d2 = Dummy.find(@dummy.id)
+      assert_nil @d2.avatar_file_name
+    end
+
+    should "work exactly the same when new as when reloaded" do
+      @d2 = Dummy.find(@dummy.id)
+
+      assert_equal @dummy.avatar_file_name, @d2.avatar_file_name
+      [:thumb, :medium, :large, :original].each do |style|
+        assert_equal @dummy.avatar.to_file(style).path, @d2.avatar.to_file(style).path
+      end
+
+      saved_paths = [:thumb, :medium, :large, :original].collect{|s| @dummy.avatar.to_file(s).path }
+
+      @d2.avatar = nil
+      assert @d2.save
+
+      saved_paths.each do |p|
+        assert ! File.exists?(p)
+      end
+    end
+
+    should "know the difference between good files, bad files, not files, and nil" do
+      expected = @dummy.avatar.file
+      @dummy.avatar = "not a file"
+      assert @dummy.valid?
+      assert_equal expected.path, @dummy.avatar.file.path
+
+      @dummy.avatar = @bad_file
+      assert ! @dummy.valid?
+      @dummy.avatar = nil
+      assert @dummy.valid?
+
+      Dummy.validates_attachment_presence :avatar
+      @d2 = Dummy.find(@dummy.id)
+      @d2.avatar = @file
+      assert   @d2.valid?
+      @d2.avatar = @bad_file
+      assert ! @d2.valid?
+      @d2.avatar = nil
+      assert ! @d2.valid?
+    end
+
+    should "be able to reload without saving an not have the file disappear" do
+      @dummy.avatar = @file
+      assert @dummy.save
+      @dummy.avatar = nil
+      assert_nil @dummy.avatar_file_name
+      @dummy.reload
+      assert_equal "5k.png", @dummy.avatar_file_name
+    end
+  end
+
+  if ENV['S3_TEST_BUCKET']
+    def s3_files_for attachment
+      [:thumb, :medium, :large, :original].inject({}) do |files, style|
+        data = `curl '#{attachment.url(style)}' 2>/dev/null`.chomp
+        t = Tempfile.new("paperclip-test")
+        t.write(data)
+        t.rewind
+        files[style] = t
+        files
+      end
+    end
+
+    context "A model with an S3 attachment" do
+      setup do
+        rebuild_model :styles => { :large => "300x300>",
+                                   :medium => "100x100",
+                                   :thumb => ["32x32#", :gif] },
+                      :storage => :s3,
+                      # :s3_options => {:logger => Logger.new(StringIO.new)},
+                      :s3_credentials => File.new(File.join(File.dirname(__FILE__), "s3.yml")),
+                      :default_style => :medium,
+                      :bucket => ENV['S3_TEST_BUCKET'],
+                      :path => ":class/:attachment/:id/:style/:basename.:extension"
+        @dummy     = Dummy.new
+        @file      = File.new(File.join(FIXTURES_DIR, "5k.png"))
+        @bad_file  = File.new(File.join(FIXTURES_DIR, "bad.png"))
+
+        assert @dummy.avatar = @file
+        assert @dummy.valid?
+        assert @dummy.save
+
+        @files_on_s3 = s3_files_for @dummy.avatar
+      end
+
+      should "write and delete its files" do
+        [["434x66", :original],
+         ["300x46", :large],
+         ["100x15", :medium],
+         ["32x32", :thumb]].each do |geo, style|
+          cmd = %Q[identify -format "%wx%h" #{@files_on_s3[style].path}]
+          assert_equal geo, `#{cmd}`.chomp, cmd
+        end
+
+        @d2 = Dummy.find(@dummy.id)
+        @d2_files = s3_files_for @d2.avatar
+        [["434x66", :original],
+         ["300x46", :large],
+         ["100x15", :medium],
+         ["32x32", :thumb]].each do |geo, style|
+          cmd = %Q[identify -format "%wx%h" #{@d2_files[style].path}]
+          assert_equal geo, `#{cmd}`.chomp, cmd
+        end
+
+        @dummy.avatar = "not a valid file but not nil"
+        assert_equal File.basename(@file.path), @dummy.avatar_file_name
+        assert @dummy.valid?
+        assert @dummy.save
+
+        saved_keys = [:thumb, :medium, :large, :original].collect{|s| @dummy.avatar.to_file(s) }
+
+        saved_keys.each do |key|
+          assert key.exists?
+        end
+
+        @dummy.avatar = nil
+        assert_nil @dummy.avatar_file_name
+        assert @dummy.valid?
+        assert @dummy.save
+
+        saved_keys.each do |key|
+          assert ! key.exists?
+        end
+
+        @d2 = Dummy.find(@dummy.id)
+        assert_nil @d2.avatar_file_name
+      end
+
+      should "work exactly the same when new as when reloaded" do
+        @d2 = Dummy.find(@dummy.id)
+
+        assert_equal @dummy.avatar_file_name, @d2.avatar_file_name
+        [:thumb, :medium, :large, :original].each do |style|
+          assert_equal @dummy.avatar.to_file(style).to_s, @d2.avatar.to_file(style).to_s
+        end
+
+        saved_keys = [:thumb, :medium, :large, :original].collect{|s| @dummy.avatar.to_file(s) }
+
+        @d2.avatar = nil
+        assert @d2.save
+
+        saved_keys.each do |key|
+          assert ! key.exists?
+        end
+      end
+
+      should "know the difference between good files, bad files, not files, and nil" do
+        expected = @dummy.avatar.file
+        @dummy.avatar = "not a file"
+        assert @dummy.valid?
+        assert_equal expected, @dummy.avatar.file
+
+        @dummy.avatar = @bad_file
+        assert ! @dummy.valid?
+        @dummy.avatar = nil
+        assert @dummy.valid?
+
+        Dummy.validates_attachment_presence :avatar
+        @d2 = Dummy.find(@dummy.id)
+        @d2.avatar = @file
+        assert   @d2.valid?
+        @d2.avatar = @bad_file
+        assert ! @d2.valid?
+        @d2.avatar = nil
+        assert ! @d2.valid?
+      end
+
+      should "be able to reload without saving an not have the file disappear" do
+        @dummy.avatar = @file
+        assert @dummy.save
+        @dummy.avatar = nil
+        assert_nil @dummy.avatar_file_name
+        @dummy.reload
+        assert_equal "5k.png", @dummy.avatar_file_name
+      end
+    end
+  end
+end
+