delayed_paperclip 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+*.log
+public/

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'paperclip'
+
+desc 'Default: run unit tests.'
+task :default => [:clean, :test]
+
+desc 'Test the paperclip plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the paperclip plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'Delayed::Paperclip'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Clean up files.'
+task :clean do |t|
+  FileUtils.rm_rf "doc"
+  FileUtils.rm_rf "tmp"
+  FileUtils.rm_rf "pkg"
+  FileUtils.rm "test/debug.log" rescue nil
+  FileUtils.rm "test/paperclip.db" rescue nil
+  Dir.glob("paperclip-*.gem").each{|f| FileUtils.rm f }
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "delayed_paperclip"
+    gemspec.summary = "Process your Paperclip attachments in the background with delayed_job."
+    gemspec.description = "Process your Paperclip attachments in the background with delayed_job."
+    gemspec.email = "jesse@jstorimer.com"
+    gemspec.homepage = "http://github.com/jstorimer/delayed_paperclip"
+    gemspec.authors = ["Jesse Storimer"]
+    gemspec.add_dependency('paperclip', '>= 2.3.0')
+    gemspec.add_dependency('delayed_job', '>= 1.8.0')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/delayed/paperclip.rb

@@ -0,0 +1,72 @@
+module Delayed
+  module Paperclip
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      # +process_in_background+ gives the class it is called on an attribute that maps to a file. This
+      # is typically a file stored somewhere on the filesystem and has been uploaded by a user. 
+      # The attribute returns a Paperclip::Attachment object which handles the management of
+      # that file. The intent is to make the attachment as much like a normal attribute. The 
+      # thumbnails will be created when the new file is assigned, but they will *not* be saved 
+      # until +save+ is called on the record. Likewise, if the attribute is set to +nil+ is 
+      # called on it, the attachment will *not* be deleted until +save+ is called. See the 
+      # Paperclip::Attachment documentation for more specifics. There are a number of options 
+      # you can set to change the behavior of a Paperclip attachment:
+      # * +url+: The full URL of where the attachment is publically accessible. This can just
+      #   as easily point to a directory served directly through Apache as it can to an action
+      #   that can control permissions. You can specify the full domain and path, but usually
+      #   just an absolute path is sufficient. The leading slash *must* be included manually for 
+      #   absolute paths. The default value is 
+      #   "/system/:attachment/:id/:style/:filename". See
+      #   Paperclip::Attachment#interpolate for more information on variable interpolaton.
+      #     :url => "/:class/:attachment/:id/:style_:filename"
+      #     :url => "http://some.other.host/stuff/:class/:id_:extension"
+      # * +default_url+: The URL that will be returned if there is no attachment assigned. 
+      #   This field is interpolated just as the url is. The default value is 
+      #   "/:attachment/:style/missing.png"
+      #     has_attached_file :avatar, :default_url => "/images/default_:style_avatar.png"
+      #     User.new.avatar_url(:small) # => "/images/default_small_avatar.png"
+
+      def process_in_background(name)
+        include InstanceMethods
+
+        define_method "#{name}_changed?" do
+          attachment_changed?(name)
+        end
+        
+        define_method "halt_processing_for_#{name}" do
+          if self.send("#{name}_changed?")
+            self.processing = true if self.respond_to?(:processing)
+            false # halts processing
+          end
+        end
+        
+        define_method "enqueue_job_for_#{name}" do
+          if self.send("#{name}_changed?")
+            Delayed::Job.enqueue DelayedPaperclipJob.new(read_attribute(:id), self.class.name, name.to_sym)
+          end
+        end
+        
+        self.send("before_#{name}_post_process", :"halt_processing_for_#{name}")
+        after_save :"enqueue_job_for_#{name}"
+      end
+    end
+    
+    module InstanceMethods
+      PAPERCLIP_ATTRIBUTES = ['_file_size', '_file_name', '_content_type', '_updated_at']
+      
+      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
+    end
+  end
+end

data/lib/delayed/paperclip_job.rb

@@ -0,0 +1,12 @@
+class DelayedPaperclipJob < Struct.new(:instance_id, :instance_klass, :attachment_name)
+  def perform
+    instance = instance_klass.constantize.find(instance_id)
+
+    instance.send(attachment_name).reprocess!
+    
+    if instance.respond_to?(:processing)
+      instance.processing = false 
+      instance.save
+    end
+  end
+end

data/lib/delayed_paperclip.rb

@@ -0,0 +1,6 @@
+require 'delayed/paperclip'
+require 'delayed/paperclip_job'
+
+if Object.const_defined?("ActiveRecord")
+  ActiveRecord::Base.send(:include, Delayed::Paperclip)
+end

data/test/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"
+

data/test/delayed_paperclip_test.rb

@@ -0,0 +1,107 @@
+require 'test/test_helper'
+
+class DelayedPaperclipTest < Test::Unit::TestCase
+  def setup
+    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)
+    
+    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_changed_and_processing_attribute_defined
+    reset_table("dummies") do |d|
+      d.string :image_file_name
+      d.integer :image_file_size
+      d.boolean :processing
+    end
+    @dummy_class = reset_class "Dummy"
+    @dummy_class.has_attached_file :image
+    @dummy_class.process_in_background :image
+    @dummy = Dummy.new(:image => File.read("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    
+    @dummy.stubs(:image_changed?).returns(true)
+    assert !@dummy.halt_processing_for_image
+    assert @dummy.processing
+  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)
+
+    original_job_count = Delayed::Job.count
+    @dummy.enqueue_job_for_image
+    
+    assert_equal original_job_count + 1, Delayed::Job.count
+  end
+  
+  def test_perform_job
+    Paperclip::Attachment.any_instance.expects(:reprocess!)
+    
+    @dummy.save!
+    DelayedPaperclipJob.new(@dummy.id, @dummy.class.name, :image).perform
+  end
+  
+  def test_perform_job_with_processing_attribute
+    reset_table("dummies") do |d|
+      d.string :image_file_name
+      d.integer :image_file_size
+      d.boolean :processing
+    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"))
+
+    Paperclip::Attachment.any_instance.expects(:reprocess!)
+    
+    @dummy.processing = true
+    @dummy.save!
+    DelayedPaperclipJob.new(@dummy.id, @dummy.class.name, :image).perform
+    
+    assert !@dummy.reload.processing
+  end
+  
+  private 
+  def reset_dummy
+    reset_table("dummies") do |d|
+      d.string :image_file_name
+      d.integer :image_file_size
+    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
+end

data/test/test_helper.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+require 'active_record'
+require 'active_support'
+
+gem 'sqlite3-ruby'
+gem 'paperclip'
+require 'paperclip'
+gem 'delayed_job'
+require 'delayed_job'
+
+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'])
+
+ROOT       = File.join(File.dirname(__FILE__), '..')
+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') 
+
+module ActiveRecord
+  class Base
+  end
+end
+ 
+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 modify_table table_name, &block
+  ActiveRecord::Base.connection.change_table :dummies, &block
+end
+
+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
+end
+
+def rebuild_class options = {}
+  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
+
+def build_delayed_jobs
+  ActiveRecord::Base.connection.create_table :delayed_jobs, :force => true do |table|
+    table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
+    table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
+    table.text     :handler                      # YAML-encoded string of the object that will do work
+    table.string   :last_error                   # reason for last failure (See Note below)
+    table.datetime :run_at                       # When to run. Could be Time.now for immediately, or sometime in the future.
+    table.datetime :locked_at                    # Set when a client is working on this object
+    table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
+    table.string   :locked_by                    # Who is working on this object (if locked)
+    table.timestamps
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: delayed_paperclip
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jesse Storimer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-26 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: paperclip
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: delayed_job
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: Process your Paperclip attachments in the background with delayed_job.
+email: jesse@jstorimer.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- VERSION
+- dev/null
+- lib/delayed/paperclip.rb
+- lib/delayed/paperclip_job.rb
+- lib/delayed_paperclip.rb
+- test/database.yml
+- test/delayed_paperclip_test.rb
+- test/fixtures/12k.png
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/jstorimer/delayed_paperclip
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Process your Paperclip attachments in the background with delayed_job.
+test_files: 
+- test/delayed_paperclip_test.rb
+- test/test_helper.rb