dm-paperclip 2.1.2

data/lib/dm-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/lib/dm-paperclip/upfile.rb

@@ -0,0 +1,33 @@
+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" then "text/plain"
+      when "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/lib/dm-paperclip/validations.rb

@@ -0,0 +1,89 @@
+module Paperclip
+  module Validate
+
+    class SizeValidator < DataMapper::Validate::GenericValidator #:nodoc:
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        field_value = target.validation_property_value(:"#{@field_name}_file_size")
+        return true if field_value.nil?
+
+        @options[:in] = (@options[:greater_than]..(1/0)) unless @options[:greater_than].nil?
+        @options[:in] = (0..@options[:less_than])        unless @options[:less_than].nil?
+        return true if @options[:in].include? field_value.to_i
+
+        error_message ||= @options[:message] unless @options[:message].nil?
+        error_message ||= "%s must be less than %s bytes".t(DataMapper::Inflection.humanize(@field_name), @options[:less_than]) unless @options[:less_than].nil?
+        error_message ||= "%s must be greater than %s bytes".t(DataMapper::Inflection.humanize(@field_name), @options[:greater_than]) unless @options[:greater_than].nil?
+        error_message ||= "%s must be between %s and %s bytes".t(DataMapper::Inflection.humanize(@field_name), @options[:in].first, @options[:in].last)
+        add_error(target, error_message , @field_name)
+        return false
+      end
+    end
+
+    class RequiredFieldValidator < DataMapper::Validate::GenericValidator #:nodoc:
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        field_value = target.validation_property_value(@field_name)
+        if field_value.nil? || field_value.original_filename.blank?
+          error_message = @options[:message] || "%s must be set".t(DataMapper::Inflection.humanize(@field_name))
+          add_error(target, error_message , @field_name)
+          return false
+        end
+        return true
+      end
+    end
+
+    class ContentTypeValidator < DataMapper::Validate::GenericValidator #:nodoc:
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        valid_types = [@options[:content_type]].flatten
+        field_value = target.validation_property_value(@field_name)
+
+        unless field_value.nil? || field_value.original_filename.blank?
+          unless @options[:content_type].blank?
+            content_type = target.validation_property_value(:"#{@field_name}_content_type")
+            unless valid_types.any?{|t| t === content_type }
+              error_message ||= @options[:message] unless @options[:message].nil?
+              error_message ||= "%s's content type of '%s' is not a valid content type".t(DataMapper::Inflection.humanize(@field_name), content_type)
+              add_error(target, error_message , @field_name)
+              return false
+            end
+          end
+        end
+
+        return true
+      end
+    end
+
+    class CopyAttachmentErrors < DataMapper::Validate::GenericValidator #:nodoc:
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        field_value = target.validation_property_value(@field_name)
+        unless field_value.nil? || field_value.original_filename.blank?
+          return true if field_value.errors.length == 0
+          field_value.errors.each { |message| add_error(target, message, @field_name) }
+          return false
+        end
+        return true
+      end
+    end
+
+  end
+end
+

data/tasks/paperclip_tasks.rake

@@ -0,0 +1,38 @@
+def obtain_class
+  class_name = ENV['CLASS'] || ENV['class']
+  raise "Must specify CLASS" unless class_name
+  @klass = Object.const_get(class_name)
+end
+
+def obtain_attachments
+  name = ENV['ATTACHMENT'] || ENV['attachment']
+  raise "Class #{@klass.name} has no attachments specified" unless @klass.respond_to?(:attachment_definitions)
+  if !name.blank? && @klass.attachment_definitions.keys.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 => :environment do
+    klass     = obtain_class
+    names     = obtain_attachments
+    instances = klass.all
+
+    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).reprocess!
+          instance.send(name).save
+        else
+          true
+        end
+        print result ? "." : "x"; $stdout.flush
+      end
+    end
+    puts " Done."
+  end
+end

data/test/fixtures/bad.png

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

data/test/helper.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'tempfile'
+
+require 'data_mapper'
+require 'dm-validations'
+require 'dm-migrations'
+begin
+  require 'ruby-debug'
+rescue LoadError
+  puts "ruby-debug not loaded"
+end
+
+ROOT       = File.join(File.dirname(__FILE__), '..')
+RAILS_ROOT = ROOT
+
+Object.const_set("Merb", Class.new())
+Merb.class_eval do
+  def self.root
+    "#{ROOT}"
+  end
+  def self.env
+    ENV['RAILS_ENV']
+  end
+end
+
+$LOAD_PATH << File.join(ROOT, 'lib')
+$LOAD_PATH << File.join(ROOT, 'lib', 'dm-paperclip')
+
+require File.join(ROOT, 'lib', 'dm-paperclip.rb')
+
+ENV['RAILS_ENV'] ||= 'test'
+
+FIXTURES_DIR = File.join(File.dirname(__FILE__), "fixtures") 
+DataMapper.setup(:default, 'sqlite3::memory:')
+
+def rebuild_model options = {}
+  DataMapper::Migration.new( 1, :drop_dummies_table ) do
+    up do
+      create_table :dummies do
+        column :id, "integer", true
+        column :other, "varchar(255)"
+        column :avatar_file_name, "varchar(255)"
+        column :avatar_content_type, "varchar(255)"
+        column :avatar_file_size, "integer"
+      end
+    end
+    down do
+      drop_table :dummies
+    end
+    perform_down
+    perform_up
+  end
+
+  Object.send(:remove_const, "Dummy") rescue nil
+  Object.const_set("Dummy", Class.new())
+  Dummy.class_eval do
+    include DataMapper::Resource
+    include DataMapper::Validate
+    include Paperclip::Resource
+    property :id, Integer, :serial => true
+    property :other, String
+    has_attached_file :avatar, options
+  end
+end

data/test/test_attachment.rb

@@ -0,0 +1,225 @@
+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 "without an Attachment" do
+      setup do
+        @dummy = Dummy.new
+      end
+      
+      should "return false when asked exists?" do
+        assert !@dummy.avatar.exists?
+      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/1024what/000/001/024.wtf", @dummy.avatar.path
+    end
+  end
+
+  context "An attachment" do
+    setup do
+      Paperclip::Attachment.default_options.merge!({
+        :path => ":merb_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(:attribute_get).with(:test_file_name).returns(nil)
+      @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.to_file.nil?
+      assert_equal "/tests/original/missing.png", @attachment.url
+      assert_equal "/tests/blah/missing.png", @attachment.url(:blah)
+    end
+    
+    context "with a file assigned in the database" do
+      setup do
+        @instance.stubs(:attribute_get).with(:test_file_name).returns('5k.png')
+      end
+
+      should "return a correct url even if the file does not exist" do
+        assert_nil @attachment.to_file
+        assert_equal "/tests/41/blah/5k.png", @attachment.url(:blah)
+      end
+
+      should "return the proper path when filename has a single .'s" do
+        assert_equal "./test/../tmp/tests/dummies/original/41/5k.png", @attachment.path
+      end
+
+      should "return the proper path when filename has multiple .'s" do
+        @instance.stubs(:attribute_get).with(:test_file_name).returns("5k.old.png")      
+        assert_equal "./test/../tmp/tests/dummies/original/41/5k.old.png", @attachment.path
+      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(:update_attributes).with({ :test_file_name => nil,
+              :test_content_type => nil,
+              :test_file_size => nil })
+            @instance.expects(:update_attributes).with(  { :test_file_name => File.basename(@file.path),
+                :test_content_type => "image/png",
+                :test_file_size => @file.size })
+            @attachment.assign(@file)
+          end
+
+          should "be dirty" do
+            assert @attachment.dirty?
+          end
+
+          context "and saved" do
+            setup do
+              @attachment.save
+            end
+
+            should "return the real url" do
+              assert @attachment.to_file
+              assert_equal "/tests/41/original/5k.png", @attachment.url
+              assert_equal "/tests/41/small/5k.jpg", @attachment.url(:small)
+            end
+
+            should "commit the files to disk" do
+              [: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 "still have its #file attribute not be nil" do
+              assert ! @attachment.to_file.nil?
+            end
+
+            context "and deleted" do
+              setup do
+                @existing_names = @attachment.styles.keys.collect do |style|
+                  @attachment.path(style)
+                end
+                @instance.expects(:update_attributes).with({ :test_file_name => nil,
+                  :test_content_type => nil,
+                  :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
+
+    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