mongoid_paperclip_queue 0.1.1 → 0.1.3

data/README.textile

@@ -14,26 +14,36 @@ Install the gem:
 
 Or for Rails 3, to your Gemfile:
 
-<pre><code>
-gem 'mongoid_paperclip_queue'
-</code></pre>
+<pre><code>gem 'mongoid_paperclip_queue'</code></pre>
 
 h3. Dependencies:
 * Mongoid
 * Paperclip
 * Resque
 
+You don't need to include paperclip in your Gemfile.
+
 h2. Usage
 
 In your model:
-
+  
 <pre><code>
   class User 
+    include Mongoid::Document
     extend Mongoid::PaperclipQueue
 
     has_queued_attached_file :avatar, :styles => { :medium => "300x300>", :thumb => "100x100>" }
 
   end
+
+  # You can also embed attachments, too.
+  class Team 
+	include Mongoid::Document
+
+	embeds_many :users, :cascade_callbacks => true # this will save all the attachments when Team is saved.
+  end
+
+  
 </code></pre>
 
 Paperclip will behave exactly "like they describe":http://github.com/thoughtbot/paperclip.
@@ -44,7 +54,7 @@ Make sure that you have "Resque":http://github.com/defunkt/resque up and running
 
 h3. Detect the processing state
 
-Processing? detection is built in. We take advantage of Redis since it should already be running, and we can keep our <code>#{attachment_name}_processing</code> field out of our MongoDB and into a more temporary key store. The temporary image url isn't saved anywhere, so you'll have to specify that on your own, but it's easy to use:
+Processing detection is built in. We take advantage of Redis since it should already be running, and we can keep our <code>#{attachment_name}_processing</code> field out of our MongoDB and into a more temporary key store. The temporary image url isn't saved anywhere, so you'll have to specify that on your own, but it's easy to use:
 
 <pre><code>
   @user = User.find(1)

data/lib/mongoid_paperclip_queue.rb

@@ -12,11 +12,21 @@ module Mongoid::PaperclipQueue
       
       @queue = :paperclip
       
-      def self.enqueue(klass,field,id)
-        ::Resque.enqueue(self,klass,field,id)
+      def self.enqueue(klass,field,id,*parents)
+        ::Resque.enqueue(self,klass,field,id,*parents)
       end
-      def self.perform(klass,field,id)
-        klass.constantize.find(id).do_reprocessing_on field
+      def self.perform(klass,field,id,*parents)
+        if parents.empty?
+          klass = klass.constantize
+        else
+          p = parents.shift
+          parent = p[0].constantize.find(p[2])
+          parents.each do |p|
+            parent = parent.send(p[1].to_sym).find(p[2])
+          end
+          klass = parent.send(klass.to_sym)
+        end
+        klass.find(id).do_reprocessing_on field
       end
        
     end
@@ -60,8 +70,8 @@ module Mongoid::PaperclipQueue
         include ::Paperclip::Glue
       end
       
+      #send :include, InstanceMethods
       include InstanceMethods
-      
 
       # Invoke Paperclip's #has_attached_file method and passes in the
       # arguments specified by the user that invoked Mongoid::Paperclip#has_mongoid_attached_file
@@ -73,14 +83,38 @@ module Mongoid::PaperclipQueue
       # halt processing initially, but allow override for reprocess!
       self.send :"before_#{field}_post_process", :halt_processing
       
+      define_method "#{field}_processing!" do 
+        true
+      end
+      
       self.send :after_save do
         if self.changed.include? "#{field}_updated_at"
           # add a Redis key for the application to check if we're still processing
           # we don't need it for the processing, it's just a helpful tool
           Mongoid::PaperclipQueue::Redis.server.sadd(self.class.name, "#{field}:#{self.id}")
           
+          # check if the document is embedded. if so, we need that to find it later
+          if self.embedded?
+            parents = []
+            path = self
+            associations = path.reflect_on_all_associations(:embedded_in)
+            until associations.empty?
+              # there should only be one :embedded_in per model, correct me if I'm wrong
+              association = associations.first
+              path = path.send(association.name.to_sym)
+              parents << [association.class_name,association.name, path.id]
+              associations = path.reflect_on_all_associations(:embedded_in)
+              
+            end
+            # we need the relation name, not the class name
+            args = [ self.metadata.name, field, self.id] + parents.reverse
+          else 
+            # or just use our default params like any other Paperclip model
+            args = [self.class.name, field, self.id]
+          end
+          
           # then queue up our processing
-          Mongoid::PaperclipQueue::Queue.enqueue(self.class.name, field, self.id)
+          Mongoid::PaperclipQueue::Queue.enqueue(*args)
         end
       end
  
@@ -95,7 +129,7 @@ module Mongoid::PaperclipQueue
     module InstanceMethods
       
       def halt_processing
-        @is_processing || false
+        false if @is_processing.nil?  # || false
       end
             
       def do_reprocessing_on(field)
@@ -109,7 +143,8 @@ end
 module Paperclip
   class Attachment
     def processing?
-      @instance.new_record? || Mongoid::PaperclipQueue::Redis.server.sismember(@instance.class.name, "#{@name}:#{@instance.id}")
+      @instance.respond_to?(:"#{name}_processing!") && (@instance.new_record? || Mongoid::PaperclipQueue::Redis.server.sismember(@instance.class.name, "#{@name}:#{@instance.id}"))
     end    
+    
   end
 end

data/mongoid_paperclip_queue.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = %q{mongoid_paperclip_queue}
-  s.version = "0.1.1"
-
+  s.version = "0.1.3"
+ 
   s.authors = ["Kelly Martin"]
   s.summary = %q{Process your Paperclip attachments in the background using Mongoid and Resque.}
   s.description = %q{Process your Paperclip attachments in the background using Mongoid and Resque. Loosely based on delayed_paperclip and mongoid-paperclip.}
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'paperclip', ["~> 2.3.6"]
   s.add_dependency 'redis-namespace'
-  s.add_dependency 'mongoid'
+  s.add_dependency 'mongoid', [">= 2.3.0"]
   s.add_dependency 'resque'
   
 end

data/test/base_mongoid_paperclip_queue_test.rb

@@ -0,0 +1,107 @@
+module BaseMongoidPaperclipQueueTest
+  def setup
+    super
+  end
+
+  def test_normal_paperclip_functioning
+    Paperclip::Attachment.any_instance.expects(:post_process)
+    dummy = DummyPaperclip.new(:image => File.open("#{ROOT}/test/fixtures/12k.png"))
+    assert !dummy.image.processing?, "Image should not be processing"
+    assert dummy.image.post_processing, "Image should have post processing"
+    assert dummy.save, "Image should save"
+    assert File.exists?(dummy.image.path), "Path #{dummy.image.path} should exist"
+  end
+
+  def test_mongoid_paperclip_queue_functioning
+    Paperclip::Attachment.any_instance.expects(:after_image_post_process).never
+    dummy = Dummy.new(:image => File.open("#{ROOT}/test/fixtures/12k.png"))
+    #assert !dummy.image.post_processing
+    assert dummy.save
+    assert File.exists?(dummy.image.path), "Path #{dummy.image.path} should exist"
+  end
+
+  def test_enqueue_job_if_source_changed
+    dummy = Dummy.new(:image => File.open("#{ROOT}/test/fixtures/12k.png"))
+    dummy.image = File.open("#{RAILS_ROOT}/test/fixtures/12k.png")
+    original_job_count = jobs_count
+    dummy.save
+    assert_equal original_job_count + 1, jobs_count
+  end
+
+  def test_processing_column_kept_intact
+    Paperclip::Attachment.any_instance.stubs(:reprocess!).raises(StandardError.new('oops'))
+    dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    dummy.save!
+    assert dummy.image.processing?
+    process_jobs
+    assert dummy.image.processing?
+    assert dummy.reload.image.processing?
+  end
+
+  def test_processing_true_when_new_image_added
+    dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    assert dummy.image.processing?, "Image should be processing"
+    assert dummy.new_record?, "Image should be new record"
+    dummy.save!
+    assert dummy.reload.image.processing?, "Image should be processing again"
+  end
+
+  def test_processed_true_when_jobs_completed
+    dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    dummy.save!
+    process_jobs
+    dummy.reload
+    assert !dummy.image.processing?, "Image should no longer be processing"
+  end
+
+  def test_unprocessed_image_returns_still_processing
+    # we removed missing url functionality in MongoidPaperclipQueue
+    dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    dummy.save!
+    assert dummy.image.processing?
+    process_jobs
+    dummy.reload
+    assert_match /\/system\/images\/#{dummy.id}\/original\/12k.png/, dummy.image.url
+  end
+
+  def test_original_url_when_no_processing_column
+    dummy = DummyPaperclip.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    dummy.save!
+    assert_match(/\/system\/images\/#{dummy.id}\/original\/12k.png/, dummy.image.url)
+  end
+
+  def test_original_url_if_image_changed
+    dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    dummy.save!
+    dummy.image = File.open("#{RAILS_ROOT}/test/fixtures/12k.png")
+    dummy.save!
+    assert dummy.image.processing?
+    process_jobs
+    assert_match(/system\/images\/.*original.*/, dummy.reload.image.url)
+  end
+
+  def test_should_not_blow_up_if_dsl_unused
+    dummy = DummyPaperclip.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    assert dummy.image.url
+  end
+
+  def test_after_callback_is_functional_for_paperclip
+    DummyPaperclip.send(:define_method, :done_processing) { puts 'done' }
+    DummyPaperclip.after_image_post_process :done_processing
+    DummyPaperclip.any_instance.expects(:done_processing)
+    dummy = DummyPaperclip.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    dummy.save! 
+  end
+
+  def test_embedded_queued_attachments
+    embeds_dummy = EmbedsDummy.new
+    embeds_dummy.dummies.build(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    assert embeds_dummy.dummies.first.image.processing?, "Embedded document should be processing"
+    embeds_dummy.save!
+    process_jobs
+    embeds_dummy.reload
+    assert !embeds_dummy.dummies.empty?, "Embedded dummy should still exist"
+    assert !embeds_dummy.dummies.first.image.processing?, "Embedded document should be done processing"
+  end
+
+end

data/test/resque_paperclip_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+require 'base_mongoid_paperclip_queue_test'
+require 'resque'
+
+class ResquePaperclipTest < Test::Unit::TestCase
+  include BaseMongoidPaperclipQueueTest
+
+  def setup
+    super
+    # Make sure that we just test Resque in here
+    Resque.remove_queue(:paperclip)
+  end
+
+  def process_jobs
+    worker = Resque::Worker.new(:paperclip)
+    worker.process
+  end
+
+  def jobs_count
+    Resque.size(:paperclip)
+  end
+
+  def test_perform_job
+    dummy = Dummy.new(:image => File.open("#{RAILS_ROOT}/test/fixtures/12k.png"))
+    dummy.image = File.open("#{RAILS_ROOT}/test/fixtures/12k.png")
+    Paperclip::Attachment.any_instance.expects(:reprocess!)
+    dummy.save!
+    Mongoid::PaperclipQueue::Queue.perform(dummy.class.name, :image, dummy.id)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,85 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'mongoid'
+require 'logger'
+require 'paperclip/railtie'
+require 'resque_unit'
+#require 'redis-namespace'
+
+#Paperclip::Railtie.insert
+
+ROOT       = File.join(File.dirname(__FILE__), '..')
+RAILS_ROOT = ROOT
+$LOAD_PATH << File.join(ROOT, 'lib')
+
+REDIS_PID = "#{ROOT}/test/tmp/redis-test.pid"
+REDIS_CACHE_PATH = "#{ROOT}/test/tmp/cache/"
+
+require 'mongoid_paperclip_queue'
+
+class Test::Unit::TestCase
+  def setup
+    silence_warnings do
+      Object.const_set(:Rails, stub('Rails', :root => ROOT, :env => 'test'))
+    end
+
+    redis_options = {
+      "daemonize"     => 'yes',
+      "pidfile"       => REDIS_PID,
+      "port"          => 9736,
+      "timeout"       => 300,
+      "save 900"      => 1,
+      "save 300"      => 1,
+      "save 60"       => 10000,
+      "dbfilename"    => "dump.rdb",
+      "dir"           => REDIS_CACHE_PATH,
+      "loglevel"      => "debug",
+      "logfile"       => "stdout",
+      "databases"     => 16
+    }.map { |k, v| "#{k} #{v}" }.join('\n')
+    `echo '#{redis_options}' | redis-server -`
+  
+  end
+  
+  def teardown
+    %x{
+      cat #{REDIS_PID} | xargs kill -QUIT
+      rm -f #{REDIS_CACHE_PATH}dump.rdb
+    }
+  end
+
+end
+
+  
+  
+FIXTURES_DIR = File.join(File.dirname(__FILE__), "fixtures")
+Mongoid.configure do |config|
+  config.master = Mongo::Connection.new.db("mongoid_paperclip_queue_test")
+end
+Mongoid.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+
+class EmbedsDummy
+  
+  include Mongoid::Document  
+  embeds_many :dummies, cascade_callbacks: true
+  
+end 
+
+class DummyPaperclip
+  include Mongoid::Document
+  include Paperclip::Glue
+  field(:image_file_name, :type => String)
+  field(:image_content_type, :type => String)
+  field(:image_file_size, :type => Integer)
+  field(:image_updated_at, :type => DateTime)
+            
+  has_attached_file :image
+end
+
+class Dummy
+  include Mongoid::Document
+  extend Mongoid::PaperclipQueue
+  has_queued_attached_file :image
+end
+

data/test/tmp/redis-test.pid

@@ -0,0 +1 @@
+80432

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_paperclip_queue
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-23 00:00:00.000000000Z
+date: 2011-10-05 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: paperclip
-  requirement: &70189938337600 !ruby/object:Gem::Requirement
+  requirement: &70132006491020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.3.6
   type: :runtime
   prerelease: false
-  version_requirements: *70189938337600
+  version_requirements: *70132006491020
 - !ruby/object:Gem::Dependency
   name: redis-namespace
-  requirement: &70189938337200 !ruby/object:Gem::Requirement
+  requirement: &70132006490620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,21 +32,21 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70189938337200
+  version_requirements: *70132006490620
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &70189938336740 !ruby/object:Gem::Requirement
+  requirement: &70132006490060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.3.0
   type: :runtime
   prerelease: false
-  version_requirements: *70189938336740
+  version_requirements: *70132006490060
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &70189938336300 !ruby/object:Gem::Requirement
+  requirement: &70132006489620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70189938336300
+  version_requirements: *70132006489620
 description: Process your Paperclip attachments in the background using Mongoid and
   Resque. Loosely based on delayed_paperclip and mongoid-paperclip.
 email: kelly@fullybrand.com
@@ -72,6 +72,11 @@ files:
 - lib/mongoid_paperclip_queue.rb
 - mongoid_paperclip_queue.gemspec
 - rails/init.rb
+- test/base_mongoid_paperclip_queue_test.rb
+- test/fixtures/12k.png
+- test/resque_paperclip_test.rb
+- test/test_helper.rb
+- test/tmp/redis-test.pid
 homepage: http://github.com/kellym/mongoid_paperclip_queue
 licenses: []
 post_install_message: 
@@ -92,8 +97,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.8
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Process your Paperclip attachments in the background using Mongoid and Resque.
-test_files: []
+test_files:
+- test/base_mongoid_paperclip_queue_test.rb
+- test/fixtures/12k.png
+- test/resque_paperclip_test.rb
+- test/test_helper.rb
+- test/tmp/redis-test.pid