avatar 0.0.4 → 0.0.5

data/test/lib/paperclip/lib/paperclip/iostream.rb

@@ -0,0 +1,43 @@
+# Provides method that can be included on File-type objects (IO, StringIO, Tempfile, etc) to allow stream copying
+# and Tempfile conversion.
+module IOStream
+
+  # Returns a Tempfile containing the contents of the readable object.
+  def to_tempfile
+    tempfile = Tempfile.new("stream")
+    tempfile.binmode
+    self.stream_to(tempfile)
+  end
+
+  # Copies one read-able object from one place to another in blocks, obviating the need to load
+  # the whole thing into memory. Defaults to 8k blocks. If this module is included in both
+  # both StringIO and Tempfile, then either can have its data copied anywhere else without typing
+  # worries or memory overhead worries. Returns a File if a String is passed in as the destination
+  # and returns the IO or Tempfile as passed in if one is sent as the destination.
+  def stream_to path_or_file, in_blocks_of = 8192
+    dstio = case path_or_file
+            when String   then File.new(path_or_file, "wb+")
+            when IO       then path_or_file
+            when Tempfile then path_or_file
+            end
+    buffer = ""
+    self.rewind
+    while self.read(in_blocks_of, buffer) do
+      dstio.write(buffer)
+    end
+    dstio.rewind
+    dstio
+  end
+end
+
+class IO
+  include IOStream
+end
+
+%w( Tempfile StringIO ).each do |klass|
+  if Object.const_defined? klass
+    Object.const_get(klass).class_eval do
+      include IOStream
+    end
+  end
+end

data/test/lib/paperclip/lib/paperclip/thumbnail.rb

@@ -0,0 +1,80 @@
+module Paperclip
+  # Handles thumbnailing images that are uploaded.
+  class Thumbnail
+
+    attr_accessor :file, :current_geometry, :target_geometry, :format, :whiny_thumbnails
+
+    # 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.
+    def initialize file, target_geometry, format = nil, whiny_thumbnails = true
+      @file             = file
+      @crop             = target_geometry[-1,1] == '#'
+      @target_geometry  = Geometry.parse target_geometry
+      @current_geometry = Geometry.from_file file
+      @whiny_thumbnails = whiny_thumbnails
+
+      @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, whiny_thumbnails = true
+      new(file, dimensions, format, whiny_thumbnails).make
+    end
+
+    # Returns true if the +target_geometry+ is meant to crop.
+    def crop?
+      @crop
+    end
+
+    # Performs the conversion of the +file+ into a thumbnail. Returns the Tempfile
+    # that contains the new image.
+    def make
+      src = @file
+      dst = Tempfile.new([@basename, @format].compact.join("."))
+      dst.binmode
+
+      command = <<-end_command
+        #{ Paperclip.path_for_command('convert') }
+        "#{ File.expand_path(src.path) }"
+        #{ transformation_command }
+        "#{ File.expand_path(dst.path) }"
+      end_command
+      success = system(command.gsub(/\s+/, " "))
+
+      if success && $?.exitstatus != 0 && @whiny_thumbnails
+        raise PaperclipError, "There was an error processing this thumbnail"
+      end
+
+      dst
+    end
+
+    # Returns the command ImageMagick's +convert+ needs to transform the image
+    # into the thumbnail.
+    def transformation_command
+      scale, crop = @current_geometry.transformation_to(@target_geometry, crop?)
+      trans = "-scale \"#{scale}\""
+      trans << " -crop \"#{crop}\" +repage" if crop
+      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/test/lib/paperclip/lib/paperclip/upfile.rb

@@ -0,0 +1,32 @@
+module Paperclip
+  # The Upfile module is a convenience module for adding uploaded-file-type methods
+  # to the +File+ class. Useful for testing.
+  #   user.avatar = File.new("test/test_avatar.jpg")
+  module Upfile
+
+    # Infer the MIME-type of the file from the extension.
+    def content_type
+      type = self.path.match(/\.(\w+)$/)[1] rescue "octet-stream"
+      case type
+      when "jpg", "png", "gif" then "image/#{type}"
+      when "txt", "csv", "xml", "html", "htm", "css", "js" then "text/#{type}"
+      else "x-application/#{type}"
+      end
+    end
+
+    # Returns the file's normal name.
+    def original_filename
+      File.basename(self.path)
+    end
+
+    # Returns the size of the file.
+    def size
+      File.size(self)
+    end
+  end
+
+end
+
+class File #:nodoc:
+  include Paperclip::Upfile
+end

data/test/lib/paperclip/tasks/paperclip_tasks.rake

@@ -0,0 +1,38 @@
+require 'environment'
+
+def obtain_class
+  class_name = ENV['CLASS'] || ENV['class']
+  @klass = Object.const_get(class_name)
+end
+
+def obtain_attachments
+  name = ENV['ATTACHMENT'] || ENV['attachment']
+  if !name.blank? && @klass.attachment_names.include?(name)
+    [ name ]
+  else
+    @klass.attachment_definitions.keys
+  end
+end
+
+namespace :paperclip do
+  desc "Regenerates thumbnails for a given CLASS (and optional ATTACHMENT)"
+  task :refresh do
+    klass     = obtain_class
+    instances = klass.find(:all)
+    names     = obtain_attachments
+    
+    puts "Regenerating thumbnails for #{instances.length} instances of #{klass.name}:"
+    instances.each do |instance|
+      names.each do |name|
+        result = if instance.send("#{ name }?")
+          instance.send(name).send("post_process")
+          instance.send(name).save
+        else
+          true
+        end
+        print result ? "." : "x"; $stdout.flush
+      end
+    end
+    puts " Done."
+  end
+end

data/test/lib/paperclip/test/database.yml

@@ -0,0 +1,5 @@
+test:
+  adapter: sqlite3
+  #dbfile: paperclip.db
+  database: ":memory:"
+

data/test/lib/paperclip/test/fixtures/bad.png

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

data/test/lib/paperclip/test/helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'tempfile'
+
+require 'active_record'
+require 'ruby-debug'
+
+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')
+
+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/lib/paperclip/test/test_attachment.rb

@@ -0,0 +1,99 @@
+require 'test/helper'
+
+class Dummy
+  # This is a dummy class
+end
+
+class AttachmentTest < Test::Unit::TestCase
+  context "An attachment" do
+    setup do
+      @default_options = {
+        :path => ":rails_root/tmp/:attachment/:class/:style/:id/:basename.:extension"
+      }
+      @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, @default_options)
+      @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
+        @attachment = Paperclip::Attachment.new(:test, @instance, @default_options.merge({
+          :styles => { :large  => ["400x400", :png],
+                       :medium => ["100x100", :gif],
+                       :small => ["32x32#", :jpg]}
+        }))
+      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|
+              out = `identify -format "%w %h %b %m" #{@attachment.to_io(style.first).path}`
+              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 @attachment.file == @attachment.to_io(:original)
+          end
+
+          should "still have its #file attribute not be nil" do
+            assert ! @attachment.file.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/test/lib/paperclip/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