delayed_paperclip 0.5.2 → 0.6.0

data/README.textile

@@ -4,7 +4,7 @@ Delayed_paperclip lets you process your "Paperclip":http://github.com/thoughtbot
 
 h2. Why?
 
-The most common use case for Paperclip is to easily attach image files to ActiveRecord models. Most of the time these image files will have multiple styles and will need to be resized when they are created. This is usually a pretty "slow operation":http://www.jstorimer.com/ruby/2010/01/05/speep-up-your-paperclip-tests.html and should be handled in a background task. 
+The most common use case for Paperclip is to easily attach image files to ActiveRecord models. Most of the time these image files will have multiple styles and will need to be resized when they are created. This is usually a pretty "slow operation":http://www.jstorimer.com/ruby/2010/01/05/speep-up-your-paperclip-tests.html and should be handled in a background task.
 
 I'm sure that everyone knows this, this gem just makes it easy to do.
 
@@ -39,9 +39,9 @@ In your model:
 <pre><code>
   class User < ActiveRecord::Base
     has_attached_file :avatar, :styles => { :medium => "300x300>", :thumb => "100x100>" }
-    
+
     process_in_background :avatar
-  end  
+  end
 </code></pre>
 
 Use your Paperclip attachment just like always in controllers and views.
@@ -56,6 +56,32 @@ h3. DJ
 
 Just make sure that you have DJ up and running.
 
+h3. Displaying images during processing
+
+In the default setup, when you upload an image for the first time and try to display it before the job has been completed, Paperclip will be none the wiser and output the url of the image which is yet to be processed, which will result in a broken image link being displayed on the page.
+
+To have the missing image url be outputted by paperclip while the image is being processed, all you need to do is add a #{attachment_name}_processing column to the specific model you want to enable this feature for. This feature gracefully degrades and will not affect models which do not have the column added to them.
+
+<pre><code>
+  class AddAvatarProessingToUser < ActiveRecord::Migration
+    def self.up
+      add_column :users, :avatar_processing, :boolean
+    end
+    
+    def self.down
+      remove_column :users, :avatar_processing
+    end
+  end
+  
+  @user = User.new(:avatar => File.new(...))
+  @user.save
+  @user.avatar.url #=> "/images/original/missing.png"
+  Delayed::Job.work_off
+
+  @user.reload
+  @user.avatar.url #=> "/system/images/3/original/IMG_2772.JPG?1267562148"
+</code></pre>
+
 h2. What if I'm not using images?
 
 AFAIK this library should work no matter what kind of post-processing you are doing with Paperclip.

data/VERSION

@@ -1 +1 @@
-0.5.2
+0.6.0

data/delayed_paperclip.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{delayed_paperclip}
-  s.version = "0.5.2"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jesse Storimer"]
-  s.date = %q{2010-02-25}
+  s.date = %q{2010-03-02}
   s.description = %q{Process your Paperclip attachments in the background with delayed_job.}
   s.email = %q{jesse@jstorimer.com}
   s.extra_rdoc_files = [

data/lib/delayed/jobs/delayed_paperclip_job.rb

@@ -2,6 +2,7 @@ class DelayedPaperclipJob < Struct.new(:instance_klass, :instance_id, :attachmen
   def perform
     instance = instance_klass.constantize.find(instance_id)
 
-    instance.send(attachment_name).reprocess!    
+    instance.send(attachment_name).reprocess!
+    instance.send("#{attachment_name}_processed!")
   end
 end

data/lib/delayed/jobs/resque_paperclip_job.rb

@@ -1,9 +1,10 @@
 class ResquePaperclipJob
   @queue = :paperclip
-  
+
   def self.perform(instance_klass, instance_id, attachment_name)
     instance = instance_klass.constantize.find(instance_id)
 
-    instance.send(attachment_name).reprocess!    
+    instance.send(attachment_name).reprocess!
+    instance.send("#{attachment_name}_processed!")
   end
 end

data/lib/delayed/paperclip.rb

@@ -3,57 +3,92 @@ module Delayed
     def self.included(base) #:nodoc:
       base.extend(ClassMethods)
     end
-    
+
     module ClassMethods
       def process_in_background(name)
         include InstanceMethods
 
         define_method "#{name}_changed?" do
-          attachment_has_changed?(name)
+          attachment_changed?(name)
         end
-        
+
         define_method "halt_processing_for_#{name}" do
-          if self.send("#{name}_changed?")
-            false # halts processing
-          end
+          return unless self.send("#{name}_changed?")
+
+          false # halts processing
         end
-        
+
         define_method "enqueue_job_for_#{name}" do
-          if self.send("#{name}_changed?")
-            if delayed_job?
-              Delayed::Job.enqueue DelayedPaperclipJob.new(self.class.name, read_attribute(:id), name.to_sym)
-            elsif resque?
-              Resque.enqueue(ResquePaperclipJob, self.class.name, read_attribute(:id), name.to_sym)
-            end
+          return unless self.send("#{name}_changed?")
+
+          if delayed_job?
+            Delayed::Job.enqueue DelayedPaperclipJob.new(self.class.name, read_attribute(:id), name.to_sym)
+          elsif resque?
+            Resque.enqueue(ResquePaperclipJob, self.class.name, read_attribute(:id), name.to_sym)
           end
         end
-        
+
+        define_method "#{name}_processed!" do
+          return unless column_exists?(:"#{name}_processing")
+          return unless self.send(:"#{name}_processing?")
+
+          self.send("#{name}_processing=", false)
+          self.save(false)
+        end
+
+        define_method "#{name}_processing!" do
+          return unless column_exists?(:"#{name}_processing")
+          return if self.send(:"#{name}_processing?")
+          return unless self.send(:"#{name}_changed?")
+
+          self.send("#{name}_processing=", true)
+        end
+
         self.send("before_#{name}_post_process", :"halt_processing_for_#{name}")
-        after_save :"enqueue_job_for_#{name}"
+
+        before_save :"#{name}_processing!"
+        after_save  :"enqueue_job_for_#{name}"
       end
     end
-    
+
     module InstanceMethods
       PAPERCLIP_ATTRIBUTES = ['_file_size', '_file_name', '_content_type', '_updated_at']
-      
-      def attachment_has_changed?(name)
+
+      def attachment_changed?(name)
         PAPERCLIP_ATTRIBUTES.each do |attribute|
           full_attribute = "#{name}#{attribute}_changed?".to_sym
 
           next unless self.respond_to?(full_attribute)
           return true if self.send("#{name}#{attribute}_changed?")
         end
-        
+
         false
       end
-      
+
       def delayed_job?
         defined? Delayed::Job
       end
-      
+
       def resque?
         defined? Resque
       end
+      
+      def column_exists?(column)
+        self.class.columns_hash.has_key?(column.to_s)
+      end
+    end
+  end
+end
+
+module Paperclip
+  class Attachment
+    def url_with_processed style = default_style, include_updated_timestamp = true
+      if @instance.column_exists?(:"#{@name}_processing") && !@instance.send(:"#{@name}_processing?")
+        url_without_processed style, include_updated_timestamp
+      else
+        interpolate(@default_url, style)
+      end
     end
+    alias_method_chain :url, :processed
   end
 end

data/test/delayed_paperclip_test.rb

@@ -7,40 +7,42 @@ class DelayedPaperclipTest < Test::Unit::TestCase
     build_delayed_jobs
     reset_dummy
   end
-  
+
   def test_attachment_changed
     @dummy.stubs(:image_file_size_changed?).returns(false)
     @dummy.stubs(:image_file_name_changed?).returns(false)
-    
+    @dummy.stubs(:image_content_type_changed?).returns(false)
+    @dummy.stubs(:image_updated_at_changed?).returns(false)
+
     assert !@dummy.image_changed?
   end
-  
+
   def test_attachment_changed_when_image_changes
     @dummy.stubs(:image_file_size_changed?).returns(true)
 
     assert @dummy.image_changed?
   end
-  
+
   def test_before_post_process
     Dummy.expects(:before_image_post_process)
     @dummy_class.process_in_background :image
   end
-  
+
   def test_halt_processing_if_source_changed
     @dummy.stubs(:image_changed?).returns(true)
     assert !@dummy.halt_processing_for_image
   end
-  
+
   def test_halt_processing_if_source_has_not_changed
     @dummy.stubs(:image_changed?).returns(false)
     assert_not_equal false, @dummy.halt_processing_for_image
   end
-  
+
   def test_after_save
     Dummy.expects(:after_save)
     @dummy_class.process_in_background :image
   end
-  
+
   def test_enqueue_job_if_source_changed
     @dummy.stubs(:image_changed?).returns(true)
 
@@ -57,13 +59,48 @@ class DelayedPaperclipTest < Test::Unit::TestCase
     @dummy.save!
     Delayed::Job.last.payload_object.perform
   end
-  
+
   def test_after_callback_is_functional
     @dummy_class.send(:define_method, :done_processing) { puts 'done' }
-    @dummy_class.after_image_post_process :done_processing    
+    @dummy_class.after_image_post_process :done_processing
     Dummy.any_instance.expects(:done_processing)
 
     @dummy.save!
     DelayedPaperclipJob.new(@dummy.class.name, @dummy.id, :image).perform
   end
+
+  def test_processed_method_returns_nil_if_column_does_not_exist
+    assert_equal nil, @dummy.image_processed!
+  end
+
+  def test_processing_true_when_new_image_added
+    @dummy = reset_dummy(true)
+
+    assert !@dummy.image_processing?
+    assert @dummy.new_record?
+    @dummy.save!
+    assert @dummy.reload.image_processing?
+  end
+
+  def test_processed_true_when_delayed_jobs_completed
+    @dummy = reset_dummy(true)    
+    @dummy.save!
+
+    Delayed::Job.work_off
+
+    @dummy.reload
+    assert !@dummy.image_processing?
+  end
+
+  def test_unprocessed_image_returns_missing_url
+    @dummy = reset_dummy(true)    
+    @dummy.save!
+
+    assert_equal "/images/original/missing.png", @dummy.image.url
+
+    Delayed::Job.first.invoke_job
+
+    @dummy.reload
+    assert_match(/\/system\/images\/1\/original\/12k.png/, @dummy.image.url)
+  end  
 end

data/test/test_helper.rb

@@ -10,7 +10,7 @@ gem 'sqlite3-ruby'
 gem 'paperclip'
 require 'paperclip'
 
-FIXTURES_DIR = File.join(File.dirname(__FILE__), "fixtures") 
+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['test'])
@@ -20,59 +20,40 @@ RAILS_ROOT = ROOT
 RAILS_ENV  = "test"
 
 $LOAD_PATH << File.join(ROOT, 'lib')
-$LOAD_PATH << File.join(ROOT, 'lib', 'delayed', 'paperclip') 
-$LOAD_PATH << File.join(ROOT, 'test') 
+$LOAD_PATH << File.join(ROOT, 'lib', 'delayed', 'paperclip')
+$LOAD_PATH << File.join(ROOT, 'test')
 
 require File.join(ROOT, 'lib', 'delayed_paperclip.rb')
 
-def reset_class class_name
-  ActiveRecord::Base.send(:include, Paperclip)
-  Object.send(:remove_const, class_name) rescue nil
-  klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
-  klass.class_eval{ include Paperclip }
-  klass
-end
 
-def reset_table table_name, &block
-  block ||= lambda { |table| true }
-  ActiveRecord::Base.connection.create_table :dummies, {:force => true}, &block
-end
+def reset_dummy(with_processed = false)
+  build_dummy_table(with_processed)
 
-def modify_table table_name, &block
-  ActiveRecord::Base.connection.change_table :dummies, &block
-end
+  reset_class "Dummy"
 
-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
-    table.column :avatar_updated_at, :datetime
-  end
-  rebuild_class options
+  @dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
 end
 
-def rebuild_class options = {}
+def reset_class class_name
   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
+  Object.send(:remove_const, class_name) rescue nil
+  klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
+  klass.class_eval do
+    has_attached_file     :image
+    process_in_background :image
   end
+  @dummy_class = klass
 end
 
-def reset_dummy
-  reset_table("dummies") do |d|
-    d.string :image_file_name
-    d.integer :image_file_size
+def build_dummy_table(with_processed)
+  ActiveRecord::Base.connection.create_table :dummies, { :force => true } do |t|
+    t.string   :image_file_name
+    t.string   :image_content_type
+    t.integer  :image_file_size
+    t.datetime :image_updated_at
+
+    t.boolean(:image_processing, :default => false) if with_processed
   end
-  @dummy_class = reset_class "Dummy"
-  @dummy_class.has_attached_file :image
-  @dummy_class.process_in_background :image
-  
-  @dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
 end
 
 def build_delayed_jobs

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 2
-  version: 0.5.2
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Jesse Storimer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-25 00:00:00 -05:00
+date: 2010-03-02 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency