carrierwave_backgrounder 0.1.2 → 0.1.3

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+
+rvm:
+ - 1.8.7
+ - 1.9.2
+ - 1.9.3
+ - 2.0.0
+ - ree

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.1.3
+
+### enhancements
+  * CarrierWave::Workers::ProcessAsset now uses #update_attribute when setting [column]_processing.
+
 ## 0.1.2
 
 ### enhancements
@@ -7,7 +12,7 @@
 ```
 
 ### bug fixes
-  * Check [column]_cache to make sure we are processessing when a form fails and [column]_cache is used.
+  * Check [column]_cache to make sure we are processing when a form fails and [column]_cache is used.
 
 ## 0.1.1
 

data/README.md

@@ -1,4 +1,7 @@
-# CarrierWave Backgrounder [![Build Status](https://secure.travis-ci.org/lardawge/carrierwave_backgrounder.png)](http://travis-ci.org/lardawge/carrierwave_backgrounder)
+# CarrierWave Backgrounder 
+
+[![Build Status](https://secure.travis-ci.org/lardawge/carrierwave_backgrounder.png)](http://travis-ci.org/lardawge/carrierwave_backgrounder)
+[![Code Quality](https://codeclimate.com/badge.png)](https://codeclimate.com/github/lardawge/carrierwave_backgrounder)
 
 I like CarrierWave. That being said, I don't like tying up app instances waiting for images to process.
 
@@ -35,6 +38,8 @@ These instructions assume you have previously set up [CarrierWave](https://githu
 In Rails, add the following your Gemfile:
 
 ```ruby
+# IMPORTANT: Be sure to list the backend job processor you intend to use, before carrierwave_backgrounder
+gem 'sidekiq' # or delayed_job, resque, ect...
 gem 'carrierwave_backgrounder'
 ```
 
@@ -105,7 +110,21 @@ To overide the worker in cases where additional methods need to be called or you
 second argument:
 
 ```ruby
-process_in_background :avatar, MyAppsAwesomeProcessingWorker
+process_in_background :avatar, MyParanoidWorker
+```
+
+Then create a worker that subclasses carrierwave_backgrounder's worker:
+
+```ruby
+class MyParanoidWorker < ::CarrierWave::Workers::ProcessAsset
+  # ...or subclass CarrierWave::Workers::StoreAsset if you're using store_in_background
+
+  def error(job, exception)
+    report_job_failure  # or whatever
+  end
+
+  # other hooks you might care about
+end
 ```
 ### Testing with Rspec
 We use the after_commit hook when using active_record. This creates a problem when testing with Rspec because after_commit never gets fired

data/carrierwave_backgrounder.gemspec

@@ -8,10 +8,9 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Larry Sprock"]
   s.email       = ["larry@lucidbleu.com"]
-  s.homepage    = ""
-  s.summary     = %q{Offload CarrierWave's image processing and storage to a background process using Delayed Job}
-
-  s.rubyforge_project = "carrierwave_backgrounder"
+  s.homepage    = "https://github.com/lardawge/carrierwave_backgrounder"
+  s.licenses    = ["MIT"]
+  s.summary     = %q{Offload CarrierWave's image processing and storage to a background process using Delayed Job, Resque, Sidekiq, Qu, Queue Classic or Girl Friday}
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/backgrounder/orm/activemodel.rb

@@ -8,25 +8,31 @@ module CarrierWave
         include CarrierWave::Backgrounder::ORM::Base
 
         def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
+          before_save :"set_#{column}_processing", :if => :"enqueue_#{column}_background_job?"
+          send _supported_am_after_callback, :"enqueue_#{column}_background_job", :if => :"enqueue_#{column}_background_job?"
           super
-
-          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
-            def trigger_#{column}_background_processing?
-              process_#{column}_upload != true &&
-              (#{column}_changed? || previous_changes.has_key?(:#{column}) || remote_#{column}_url.present? || #{column}_cache.present?)
-            end
-          RUBY
         end
 
         def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
+          send _supported_am_after_callback, :"enqueue_#{column}_background_job", :if => :"enqueue_#{column}_background_job?"
+          super
+        end
+
+        private
+
+        def _supported_am_after_callback
+          respond_to?(:after_commit) ? :after_commit : :after_save
+        end
+
+        def _define_shared_backgrounder_methods(mod, column, worker)
           super
 
-          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
-            def trigger_#{column}_background_storage?
-              process_#{column}_upload != true &&
-              (#{column}_changed? || previous_changes.has_key?(:#{column}) || remote_#{column}_url.present? || #{column}_cache.present?)
-            end
-          RUBY
+          define_method :"#{column}_updated?" do
+            send(:"#{column}_changed?") ||              # after_save support
+            previous_changes.has_key?(:"#{column}") ||  # after_commit support
+            send(:"remote_#{column}_url").present? ||   # Remote upload support
+            send(:"#{column}_cache").present?           # Form failure support
+          end
         end
       end # ActiveModel
 

data/lib/backgrounder/orm/base.rb

@@ -39,27 +39,17 @@ module CarrierWave
         #   end
         #
         def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
-          send :attr_accessor, :"process_#{column}_upload"
-
-          send :before_save, :"set_#{column}_processing", :if => :"trigger_#{column}_background_processing?"
-          callback = self.respond_to?(:after_commit) ? :after_commit : :after_save
-          send callback, :"enqueue_#{column}_background_job", :if => :"trigger_#{column}_background_processing?"
-
-          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+          attr_accessor :"process_#{column}_upload"
 
+          mod = Module.new
+          include mod
+          mod.class_eval  <<-RUBY, __FILE__, __LINE__ + 1
             def set_#{column}_processing
               self.#{column}_processing = true if respond_to?(:#{column}_processing)
             end
-
-            def enqueue_#{column}_background_job
-              CarrierWave::Backgrounder.enqueue_for_backend(#{worker}, self.class.name, id.to_s, #{column}.mounted_as)
-            end
-
-            def trigger_#{column}_background_processing?
-              process_#{column}_upload != true
-            end
-
           RUBY
+
+          _define_shared_backgrounder_methods(mod, column, worker)
         end
 
         ##
@@ -85,30 +75,37 @@ module CarrierWave
         #   end
         #
         def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
-          send :attr_accessor, :"process_#{column}_upload"
-
-          callback = self.respond_to?(:after_commit) ? :after_commit : :after_save
-          send callback, :"enqueue_#{column}_background_job", :if => :"trigger_#{column}_background_storage?"
-
-          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+          attr_accessor :"process_#{column}_upload"
 
+          mod = Module.new
+          include mod
+          mod.class_eval  <<-RUBY, __FILE__, __LINE__ + 1
             def write_#{column}_identifier
-              super() and return if process_#{column}_upload
+              super and return if process_#{column}_upload
               self.#{column}_tmp = _mounter(:#{column}).cache_name if _mounter(:#{column}).cache_name
             end
 
             def store_#{column}!
-              super() if process_#{column}_upload
+              super if process_#{column}_upload
             end
+          RUBY
 
-            def enqueue_#{column}_background_job
-              CarrierWave::Backgrounder.enqueue_for_backend(#{worker}, self.class.name, id.to_s, #{column}.mounted_as)
-            end
+          _define_shared_backgrounder_methods(mod, column, worker)
+        end
 
-            def trigger_#{column}_background_storage?
-              process_#{column}_upload != true
+        private
+
+        def _define_shared_backgrounder_methods(mod, column, worker)
+          mod.class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            def #{column}_updated?; true; end
+
+            def enqueue_#{column}_background_job?
+              !process_#{column}_upload && #{column}_updated?
             end
 
+            def enqueue_#{column}_background_job
+              CarrierWave::Backgrounder.enqueue_for_backend(#{worker}, self.class.name, id.to_s, #{column}.mounted_as)
+            end
           RUBY
         end
 

data/lib/backgrounder/orm/data_mapper.rb

@@ -10,60 +10,46 @@ module CarrierWave
           after  :save, :"enqueue_#{column}_background_job"
 
           class_eval  <<-RUBY, __FILE__, __LINE__ + 1
-            attr_accessor :process_#{column}_upload
-            attr_reader :#{column}_changed
-
             def set_#{column}_processing
               @#{column}_changed = attribute_dirty?(:#{column})
-              self.#{column}_processing = true if respond_to?(:#{column}_processing) 
+              self.#{column}_processing = true if respond_to?(:#{column}_processing)
             end
-
-            def enqueue_#{column}_background_job
-              if trigger_#{column}_background_processing?
-                CarrierWave::Backgrounder.enqueue_for_backend(#{worker}, self.class.name, id, #{column}.mounted_as)
-                @#{column}_changed = false
-              end
-            end
-
-            def trigger_#{column}_background_processing?
-              process_#{column}_upload != true && #{column}_changed
-            end
-
           RUBY
         end
 
         def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
           before :save, :"set_#{column}_changed"
-          after :save, :"enqueue_#{column}_background_job"
+          after  :save, :"enqueue_#{column}_background_job"
 
           class_eval  <<-RUBY, __FILE__, __LINE__ + 1
-            attr_accessor :process_#{column}_upload
-            attr_reader :#{column}_changed
-
             def set_#{column}_changed
               @#{column}_changed = attribute_dirty?(:#{column})
             end
 
             def write_#{column}_identifier
-              super() and return if process_#{column}_upload
+              super and return if process_#{column}_upload
               self.#{column}_tmp = _mounter(:#{column}).cache_name
             end
+          RUBY
+        end
 
-            def store_#{column}!
-              super() if process_#{column}_upload
-            end
+        private
+
+        def _define_shared_backgrounder_methods(mod, column, worker)
+          super
+          class_eval  <<-RUBY, __FILE__, __LINE__ + 1
+            attr_reader :#{column}_changed
 
             def enqueue_#{column}_background_job
-              if trigger_#{column}_background_storage?
+              if enqueue_#{column}_background_job?
                 CarrierWave::Backgrounder.enqueue_for_backend(#{worker}, self.class.name, id, #{column}.mounted_as)
                 @#{column}_changed = false
               end
             end
 
-            def trigger_#{column}_background_storage?
-              process_#{column}_upload != true && #{column}_changed
+            def #{column}_updated?
+              #{column}_changed
             end
-
           RUBY
         end
       end # DataMapper

data/lib/backgrounder/support/backends.rb

@@ -25,34 +25,12 @@ module Support
           backends << :qu          if defined? ::Qu
           backends << :sidekiq     if defined? ::Sidekiq
           backends << :qc          if defined? ::QC
-          backends << :immediate
+          backends
         end
       end
 
       def enqueue_for_backend(worker, class_name, subject_id, mounted_as)
-        case backend
-        when :girl_friday
-          @girl_friday_queue ||= GirlFriday::WorkQueue.new(queue_options.delete(:queue) || :carrierwave, queue_options) do |msg|
-            worker = msg[:worker]
-            worker.perform
-          end
-          @girl_friday_queue << { :worker => worker.new(class_name, subject_id, mounted_as) }
-        when :delayed_job
-          ::Delayed::Job.enqueue worker.new(class_name, subject_id, mounted_as), :queue => queue_options[:queue]
-        when :resque
-          worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
-          ::Resque.enqueue worker, class_name, subject_id, mounted_as
-        when :qu
-          worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
-          ::Qu.enqueue worker, class_name, subject_id, mounted_as
-        when :sidekiq
-          worker.sidekiq_options queue_options
-          ::Sidekiq::Client.enqueue worker, class_name, subject_id, mounted_as
-        when :qc
-          ::QC.enqueue "#{worker.name}.perform", class_name, subject_id, mounted_as.to_s
-        when :immediate
-          worker.new(class_name, subject_id, mounted_as).perform
-        end
+        self.send :"enqueue_#{backend}", worker, class_name, subject_id, mounted_as
       end
 
       private
@@ -62,13 +40,52 @@ module Support
           warn 'WARNING: No available queue backends found for CarrierWave::Backgrounder. Using the :immediate.'
           :immediate
         elsif available_backends.size > 1
-          raise ::CarrierWave::Backgrounder::ToManyBackendsAvailableError,
-            "You have to many backends available: #{available_backends.inspect}. Please specify which one to use in configuration block"
+          raise ::CarrierWave::Backgrounder::TooManyBackendsAvailableError,
+            "You have too many backends available: #{available_backends.inspect}. Please specify which one to use in configuration block"
         else
           available_backends.first
         end
       end
 
+      def enqueue_delayed_job(worker, *args)
+        ::Delayed::Job.enqueue worker.new(*args), :queue => queue_options[:queue]
+      end
+
+      def enqueue_resque(worker, *args)
+        worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
+        ::Resque.enqueue worker, *args
+      end
+
+      def enqueue_sidekiq(worker, *args)
+        sidekiq_client_args = { 'class' => worker, 'args' => args }
+        sidekiq_client_args['queue'] = queue_options[:queue] unless queue_options[:queue].nil?
+        sidekiq_client_args['retry'] = queue_options[:retry] unless queue_options[:retry].nil?
+        sidekiq_client_args['timeout'] = queue_options[:timeout] unless queue_options[:timeout].nil?
+        sidekiq_client_args['backtrace'] = queue_options[:backtrace] unless queue_options[:backtrace].nil?
+        worker.client_push(sidekiq_client_args)
+      end
+
+      def enqueue_girl_friday(worker, *args)
+        @girl_friday_queue ||= GirlFriday::WorkQueue.new(queue_options.delete(:queue) || :carrierwave, queue_options) do |msg|
+          worker = msg[:worker]
+          worker.perform
+        end
+        @girl_friday_queue << { :worker => worker.new(*args) }
+      end
+
+      def enqueue_qu(worker, *args)
+        worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
+        ::Qu.enqueue worker, *args
+      end
+
+      def enqueue_qc(worker, *args)
+        class_name, subject_id, mounted_as = args
+        ::QC.enqueue "#{worker.name}.perform", class_name, subject_id, mounted_as.to_s
+      end
+
+      def enqueue_immediate(worker, *args)
+        worker.new(*args).perform
+      end
     end
   end
 end

data/lib/backgrounder/version.rb

@@ -1,5 +1,5 @@
 module CarrierWave
   module Backgrounder
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/backgrounder/workers/process_asset.rb

@@ -10,23 +10,27 @@ module CarrierWave
       end
 
       def perform(*args)
-        set_args(*args) unless args.empty?
-        resource = klass.is_a?(String) ? klass.constantize : klass
-        record = resource.find id
+        set_args(*args) if args.present?
+        record = constantized_resource.find id
 
         if record
           record.send(:"process_#{column}_upload=", true)
           if record.send(:"#{column}").recreate_versions! && record.respond_to?(:"#{column}_processing")
-            record.send :"#{column}_processing=", nil
-            record.save!
+            record.update_attribute :"#{column}_processing", nil
           end
         end
       end
 
+      private
+
       def set_args(klass, id, column)
         self.klass, self.id, self.column = klass, id, column
       end
 
+      def constantized_resource
+        klass.is_a?(String) ? klass.constantize : klass
+      end
+
     end # ProcessAsset
 
   end # Workers

data/lib/backgrounder/workers/store_asset.rb

@@ -4,33 +4,43 @@ module CarrierWave
 
     class StoreAsset < Struct.new(:klass, :id, :column)
       include ::Sidekiq::Worker if defined?(::Sidekiq)
+      attr_reader :cache_path, :tmp_directory
 
       def self.perform(*args)
         new(*args).perform
       end
 
       def perform(*args)
-        set_args(*args) unless args.empty?
-        resource = klass.is_a?(String) ? klass.constantize : klass
-        record = resource.find id
-        if tmp = record.send(:"#{column}_tmp")
-          asset = record.send(:"#{column}")
-          cache_dir  = [asset.root, asset.cache_dir].join("/")
-          cache_path = [cache_dir, tmp].join("/")
-          tmp_dir = [cache_dir, tmp.split("/")[0]].join("/")
+        set_args(*args) if args.present?
+        record = constantized_resource.find id
+
+        if record.send(:"#{column}_tmp")
+          store_directories(record)
           record.send :"process_#{column}_upload=", true
           record.send :"#{column}_tmp=", nil
           File.open(cache_path) { |f| record.send :"#{column}=", f }
           if record.save!
-            FileUtils.rm_r(tmp_dir, :force => true)
+            FileUtils.rm_r(tmp_directory, :force => true)
           end
         end
       end
 
+      private
+
       def set_args(klass, id, column)
         self.klass, self.id, self.column = klass, id, column
       end
 
+      def constantized_resource
+        klass.is_a?(String) ? klass.constantize : klass
+      end
+
+      def store_directories(record)
+        asset, asset_tmp = record.send(:"#{column}"), record.send(:"#{column}_tmp")
+        cache_directory  = File.join(asset.root, asset.cache_dir)
+        @cache_path      = File.join(cache_directory, asset_tmp)
+        @tmp_directory   = File.join(cache_directory, asset_tmp.split("/").first)
+      end
     end # StoreAsset
 
   end # Workers

data/lib/carrierwave_backgrounder.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/object'
 require 'backgrounder/support/backends'
 require 'backgrounder/orm/base'
 require 'backgrounder/delay'
@@ -7,7 +8,7 @@ module CarrierWave
     include Support::Backends
 
     class UnsupportedBackendError < StandardError ; end
-    class ToManyBackendsAvailableError < StandardError ; end
+    class TooManyBackendsAvailableError < StandardError ; end
 
     def self.configure
       yield self

data/spec/backgrounder/orm/activemodel_spec.rb

@@ -13,14 +13,71 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
     end
 
     @mock_class.extend CarrierWave::Backgrounder::ORM::ActiveModel
-    @mock_class.process_in_background :avatar
+  end
+
+  describe '.store_in_background' do
+    context 'setting up callbacks' do
+      it 'creates an after_commit hook' do
+        @mock_class.expects(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
+        @mock_class.store_in_background :avatar
+      end
+    end
+  end
+
+  describe '.process_in_background' do
+    context 'setting up callbacks' do
+      it 'creates a before_save hook' do
+        @mock_class.expects(:before_save).with(:set_avatar_processing, :if => :enqueue_avatar_background_job?)
+        @mock_class.process_in_background :avatar
+      end
+
+      it 'creates an after_save hook' do
+        @mock_class.expects(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
+        @mock_class.process_in_background :avatar
+      end
+    end
   end
 
   describe '#trigger_column_background_processing?' do
-    it "calls up to processs column upload getter in the base class" do
-      instance = @mock_class.new
+    let(:instance) { @mock_class.new }
+
+    before do
+      @mock_class.process_in_background :avatar
+    end
+
+    it "returns true if process_avatar_upload is false" do
       instance.expects(:process_avatar_upload)
-      instance.trigger_avatar_background_processing?
+      expect(instance.enqueue_avatar_background_job?).to be_true
+    end
+
+    it "calls column_changed?" do
+      instance.expects(:process_avatar_upload).returns(false)
+      instance.expects(:avatar_changed?)
+      expect(instance.enqueue_avatar_background_job?).to be_true
+    end
+
+    it "calls previous_changes" do
+      instance.expects(:process_avatar_upload).returns(false)
+      instance.expects(:avatar_changed?).returns(false)
+      instance.expects(:previous_changes).returns({:avatar => true})
+      expect(instance.enqueue_avatar_background_job?).to be_true
+    end
+
+    it "calls avatar_remote_url" do
+      instance.expects(:process_avatar_upload).returns(false)
+      instance.expects(:avatar_changed?).returns(false)
+      instance.expects(:previous_changes).returns({})
+      instance.expects(:remote_avatar_url).returns('yup')
+      expect(instance.enqueue_avatar_background_job?).to be_true
+    end
+
+    it "calls avatar_cache" do
+      instance.expects(:process_avatar_upload).returns(false)
+      instance.expects(:avatar_changed?).returns(false)
+      instance.expects(:previous_changes).returns({})
+      instance.expects(:remote_avatar_url).returns(nil)
+      instance.expects(:avatar_cache).returns('yup')
+      expect(instance.enqueue_avatar_background_job?).to be_true
     end
   end
 end

data/spec/backgrounder/orm/base_spec.rb

@@ -12,64 +12,37 @@ describe CarrierWave::Backgrounder::ORM::Base do
   end
 
   it 'mixes in the two DSL methods' do
-    @mock_class.should respond_to(:process_in_background)
-    @mock_class.should respond_to(:store_in_background)
+    expect(@mock_class).to respond_to(:process_in_background)
+    expect(@mock_class).to respond_to(:store_in_background)
   end
 
-  describe 'process in background' do
-
-    describe 'setting up callbacks' do
-
-      it 'creates a before_save hook' do
-        @mock_class.expects(:before_save).with(:set_avatar_processing, :if => :trigger_avatar_background_processing?)
-        @mock_class.process_in_background :avatar
-      end
-
-      it 'creates an after_save hook' do
-        @mock_class.expects(:after_commit).with(:enqueue_avatar_background_job, :if => :trigger_avatar_background_processing?)
-        @mock_class.process_in_background :avatar
-      end
-
-    end
-
-    describe 'including new methods' do
+  describe '.process_in_background' do
+    context 'including new methods' do
       before do
         @mock_class.process_in_background :avatar
         @instance = @mock_class.new
       end
 
       it 'creates a processing enabled accessor' do
-        @instance.should respond_to(:process_avatar_upload)
-        @instance.should respond_to(:process_avatar_upload=)
+        expect(@instance).to respond_to(:process_avatar_upload)
+        expect(@instance).to respond_to(:process_avatar_upload=)
       end
 
       it 'create a setter for the processing attribute' do
-        @instance.should respond_to(:set_avatar_processing)
+        expect(@instance).to respond_to(:set_avatar_processing)
       end
 
       it 'create a background job queuer' do
-        @instance.should respond_to(:enqueue_avatar_background_job)
+        expect(@instance).to respond_to(:enqueue_avatar_background_job)
       end
 
       it 'create a trigger interrogator' do
-        @instance.should respond_to(:trigger_avatar_background_processing?)
+        expect(@instance).to respond_to(:enqueue_avatar_background_job?)
       end
-
     end
-
   end
 
   describe 'store in background' do
-
-    describe 'setting up callbacks' do
-
-      it 'creates an after_save hook' do
-        @mock_class.expects(:after_commit).with(:enqueue_avatar_background_job, :if => :trigger_avatar_background_storage?)
-        @mock_class.store_in_background :avatar
-      end
-
-    end
-
     describe 'including new methods' do
       before do
         @mock_class.store_in_background :avatar
@@ -77,27 +50,25 @@ describe CarrierWave::Backgrounder::ORM::Base do
       end
 
       it 'creates a processing enabled accessor' do
-        @instance.should respond_to(:process_avatar_upload)
-        @instance.should respond_to(:process_avatar_upload=)
+        expect(@instance).to respond_to(:process_avatar_upload)
+        expect(@instance).to respond_to(:process_avatar_upload=)
       end
 
       it 'overrides the write column identifier method from carrierwave' do
-        @instance.should respond_to(:write_avatar_identifier)
+        expect(@instance).to respond_to(:write_avatar_identifier)
       end
 
       it 'overrides the store column method from carrierwave' do
-        @instance.should respond_to(:store_avatar!)
+        expect(@instance).to respond_to(:store_avatar!)
       end
 
       it 'create a background job queuer' do
-        @instance.should respond_to(:enqueue_avatar_background_job)
+        expect(@instance).to respond_to(:enqueue_avatar_background_job)
       end
 
       it 'create a trigger interrogator' do
-        @instance.should respond_to(:trigger_avatar_background_storage?)
+        expect(@instance).to respond_to(:enqueue_avatar_background_job?)
       end
-
     end
   end
-
 end

data/spec/backgrounder/support/backends_spec.rb

@@ -1,87 +1,221 @@
 require 'spec_helper'
+require 'support/backend_constants'
+require 'support/mock_worker'
 
 describe Support::Backends do
-  let(:test_module) { Module.new }
+  let(:mock_module) { Module.new }
 
   before do
-    test_module.send :include, Support::Backends
+    mock_module.send :include, Support::Backends
   end
 
   describe 'enumerating available backends' do
     it 'detects GirlFriday' do
-      test_module.available_backends.should include(:girl_friday)
+      expect(mock_module.available_backends).to include(:girl_friday)
     end
 
     it 'detects Delayed::Job' do
-      test_module.available_backends.should include(:delayed_job)
+      expect(mock_module.available_backends).to include(:delayed_job)
     end
     
     it 'detects Resque' do
-      test_module.available_backends.should include(:resque)
+      expect(mock_module.available_backends).to include(:resque)
     end
     
     it 'detects Qu' do
-      test_module.available_backends.should include(:qu)
+      expect(mock_module.available_backends).to include(:qu)
     end
     
     it 'detects Sidekiq' do
-      test_module.available_backends.should include(:sidekiq)
+      expect(mock_module.available_backends).to include(:sidekiq)
     end
     
     it 'detects QC' do
-      test_module.available_backends.should include(:qc)
-    end
-
-    it 'detects Immediate' do
-      test_module.available_backends.should include(:immediate)
+      expect(mock_module.available_backends).to include(:qc)
     end
   end
 
   describe 'setting backend' do
     it 'using #backend=' do
-      test_module.backend = :delayed_job
-      expect(test_module.backend).to eql(:delayed_job)
+      mock_module.backend = :delayed_job
+      expect(mock_module.backend).to eql(:delayed_job)
     end
 
     it 'using #backend' do
-      test_module.backend(:delayed_job)
-      expect(test_module.backend).to eql(:delayed_job)
+      mock_module.backend(:delayed_job)
+      expect(mock_module.backend).to eql(:delayed_job)
     end
 
     it 'allows passing of queue_options' do
-      test_module.backend(:delayed_job, queue: :awesome_queue)
-      expect(test_module.queue_options).to eql({queue: :awesome_queue})
+      mock_module.backend(:delayed_job, :queue => :awesome_queue)
+      expect(mock_module.queue_options).to eql({:queue => :awesome_queue})
     end
   end
 
-  describe 'automatically setting backends' do
+  describe 'auto detect backends' do
     before do
-      test_module.instance_variable_set('@backend', nil)
+      mock_module.instance_variable_set('@backend', nil)
     end
 
     it 'sets the backend to immediate if none available' do
       suppress_warnings do
-        test_module.stubs(:available_backends).returns([])
-        expect(test_module.backend).to eql(:immediate)
+        mock_module.stubs(:available_backends).returns([])
+        expect(mock_module.backend).to eql(:immediate)
       end
     end
 
     it 'sets a backend automatically if only one is available' do
-      test_module.stubs(:available_backends).returns([ :qu ])
-      test_module.backend.should eq(:qu)
+      mock_module.stubs(:available_backends).returns([ :qu ])
+      expect(mock_module.backend).to eql(:qu)
     end
     
     it 'raises an error if more than one backend is available' do
-      test_module.stubs(:available_backends).returns([:qu, :resque])
+      mock_module.stubs(:available_backends).returns([:qu, :resque])
       expect {
-       test_module.backend
-      }.to raise_error(CarrierWave::Backgrounder::ToManyBackendsAvailableError)
+       mock_module.backend
+      }.to raise_error(CarrierWave::Backgrounder::TooManyBackendsAvailableError)
     end
 
     it 'does not clobber a manually set backend' do
-      test_module.backend = :not_a_backend
-      test_module.backend.should eq(:not_a_backend)
+      mock_module.backend = :not_a_backend
+      expect(mock_module.backend).to eql(:not_a_backend)
+    end
+  end
+
+  describe '#enqueue_for_backend' do
+    let!(:worker) { MockWorker.new('FakeClass', 1, :image) }
+
+    context 'delayed_job' do
+      before do
+        @mock_worker = Class.new do
+          def self.perform(*args); new(*args).perform; end
+        end
+
+        MockWorker.expects(:new).returns(worker)
+      end
+
+      it 'defaults the queue name to nil if none passed to #backend' do
+        mock_module.backend :delayed_job
+        Delayed::Job.expects(:enqueue).with(worker, :queue => nil)
+        mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
+      end
+
+      it 'sets the queue name to the queue name passed to #backend' do
+        mock_module.backend :delayed_job, :queue => :awesome_queue
+        Delayed::Job.expects(:enqueue).with(worker, :queue => :awesome_queue)
+        mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
+      end
+    end
+
+    context 'resque' do
+      let(:args) { [MockWorker, 'FakeClass', 1, :image] }
+
+      before do
+        Resque.expects(:enqueue).with(*args)
+      end
+
+      it 'sets a variable with the queue name, defaults to :carrierwave' do
+        mock_module.backend :resque
+        mock_module.enqueue_for_backend(*args)
+        expect(MockWorker.instance_variable_get '@queue').to eql(:carrierwave)
+      end
+
+      it 'sets a variable to the queue name passed to #backend' do
+        mock_module.backend :resque, :queue => :awesome_queue
+        mock_module.enqueue_for_backend(*args)
+        expect(MockWorker.instance_variable_get '@queue').to eql(:awesome_queue)
+      end
+    end
+
+    context 'sidekiq' do
+      let(:args) { ['FakeClass', 1, :image] }
+
+      it 'invokes client_push on the class with passed args' do
+        MockSidekiqWorker.expects(:client_push).with({ 'class' => MockSidekiqWorker, 'args' => args })
+        mock_module.backend :sidekiq
+        mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
+      end
+
+      it 'invokes client_push and includes the options passed to backend' do
+        MockSidekiqWorker.expects(:client_push).with({ 'class' => MockSidekiqWorker, 
+                                                       'retry' => false,
+                                                       'timeout' => 60,
+                                                       'queue' => :awesome_queue,
+                                                       'args' => args })
+        options = {:retry => false, :timeout => 60, :queue => :awesome_queue}
+        mock_module.backend :sidekiq, options
+        mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
+      end
     end
+
+    context 'girl_friday' do
+      let(:args) { [MockWorker, 'FakeClass', 1, :image] }
+
+      it 'instantiates a GirlFriday work queue if one does not exist' do
+        mock_module.backend :girl_friday
+        GirlFriday::WorkQueue.expects(:new).with(:carrierwave, {}).returns([])
+        mock_module.enqueue_for_backend(*args)
+      end
+
+      it 'instantiates a GirlFriday work queue passing the args to the queue' do
+        mock_module.backend :girl_friday, :queue => :awesome_queue, :size => 3
+        GirlFriday::WorkQueue.expects(:new).with(:awesome_queue, {:size => 3}).returns([])
+        mock_module.enqueue_for_backend(*args)
+      end
+
+      it 'does not instantiate a GirlFriday work queue if one exists' do
+        mock_module.backend :girl_friday
+        mock_module.instance_variable_set('@girl_friday_queue', [])
+        GirlFriday::WorkQueue.expects(:new).never
+        mock_module.enqueue_for_backend(*args)
+      end
+
+      it 'add a worker to the girl_friday queue' do
+        expected = [{ :worker => MockWorker.new('FakeClass', 1, :image) }]
+        mock_module.backend :girl_friday
+        mock_module.instance_variable_set('@girl_friday_queue', [])
+        mock_module.enqueue_for_backend(*args)
+        expect(mock_module.instance_variable_get '@girl_friday_queue').to eql(expected)
+      end
+    end
+
+    context 'qu' do
+      let(:args) { [MockWorker, 'FakeClass', 1, :image] }
+      before do
+        Qu.expects(:enqueue).with(*args)
+      end
+
+      it 'sets a variable with the queue name, defaults to :carrierwave' do
+        mock_module.backend :qu
+        mock_module.enqueue_for_backend(*args)
+        expect(MockWorker.instance_variable_get '@queue').to eql(:carrierwave)
+      end
+
+      it 'sets a variable to the queue name passed to #backend' do
+        mock_module.backend :qu, :queue => :awesome_queue
+        mock_module.enqueue_for_backend(*args)
+        expect(MockWorker.instance_variable_get '@queue').to eql(:awesome_queue)
+      end
+    end
+
+    context 'qc' do
+      it 'calls enqueue with the passed args' do
+        QC.expects(:enqueue).with("MockWorker.perform", 'FakeClass', 1, 'image')
+        mock_module.backend :qc
+        mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
+      end
+    end
+
+    context 'immediate' do
+      it 'instantiates a worker passing the args and calls perform' do
+        worker = mock('Worker')
+        MockWorker.expects(:new).with('FakeClass', 1, :image).returns(worker)
+        worker.expects(:perform)
+        mock_module.backend :immediate
+        mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
+      end
+    end
+
   end
 end
 

data/spec/backgrounder/workers/process_asset_spec.rb

@@ -5,10 +5,9 @@ require 'backgrounder/workers/process_asset'
 describe CarrierWave::Workers::ProcessAsset do
   let(:worker_class) { CarrierWave::Workers::ProcessAsset }
   let(:user)   { mock('User') }
-  let(:image)  { mock('UserAsset') }
   let!(:worker) { worker_class.new(user, '22', :image) }
 
-  context ".perform" do
+  describe ".perform" do
     it 'creates a new instance and calls perform' do
       args = [user, '22', :image]
       worker_class.expects(:new).with(*args).returns(worker)
@@ -18,29 +17,54 @@ describe CarrierWave::Workers::ProcessAsset do
     end
   end
 
-  context "#perform" do
-    it 'processes versions with image_processing column' do
+  describe "#perform" do
+    let(:image)  { mock('UserAsset') }
+
+    before do
       user.expects(:find).with('22').returns(user).once
       user.expects(:image).once.returns(image)
       user.expects(:process_image_upload=).with(true).once
-
       image.expects(:recreate_versions!).once.returns(true)
+    end
+
+    it 'processes versions with image_processing column' do
       user.expects(:respond_to?).with(:image_processing).once.returns(true)
-      user.expects(:image_processing=).with(nil).once
-      user.expects(:save!)
+      user.expects(:update_attribute).with(:image_processing, nil).once
       worker.perform
     end
 
     it 'processes versions without image_processing column' do
-      user.expects(:find).with('22').returns(user).once
-      user.expects(:image).once.returns(image)
-      user.expects(:process_image_upload=).with(true).once
-
-      image.expects(:recreate_versions!).once.returns(true)
       user.expects(:respond_to?).with(:image_processing).once.returns(false)
-      user.expects(:image_processing=).never
-      user.expects(:save!).never
+      user.expects(:update_attribute).never
       worker.perform
     end
   end
+
+  describe '#perform with args' do
+    let(:admin) { mock('Admin') }
+    let(:avatar)  { mock('AdminAsset') }
+    let(:worker) { worker_class.new }
+
+    before do
+      admin.expects(:find).with('23').returns(admin).once
+      admin.expects(:avatar).once.returns(avatar)
+      admin.expects(:process_avatar_upload=).with(true).once
+      admin.expects(:respond_to?).with(:avatar_processing).once.returns(false)
+      avatar.expects(:recreate_versions!).once.returns(true)
+
+      worker.perform admin, '23', :avatar
+    end
+
+    it 'sets klass' do
+      expect(worker.klass).to eql(admin)
+    end
+
+    it 'sets column' do
+      expect(worker.id).to eql('23')
+    end
+
+    it 'sets id' do
+      expect(worker.column).to eql(:avatar)
+    end
+  end
 end

data/spec/backgrounder/workers/store_asset_spec.rb

@@ -3,35 +3,87 @@ require 'spec_helper'
 require 'backgrounder/workers/store_asset'
 
 describe CarrierWave::Workers::StoreAsset do
+  let(:fixtures_path) { File.expand_path('../fixtures/images', __FILE__) }
   let(:worker_class) { CarrierWave::Workers::StoreAsset }
-  let(:user)   { mock('User') }
-  let(:image)  { mock('UserAsset') }
+  let(:user) { mock('User') }
   let!(:worker) { worker_class.new(user, '22', :image) }
 
-  context ".perform" do
+  describe ".perform" do
     it 'creates a new instance and calls perform' do
       args = [user, '22', :image]
       worker_class.expects(:new).with(*args).returns(worker)
       worker_class.any_instance.expects(:perform)
-
       worker_class.perform(*args)
     end
   end
 
-  context "#perform" do
-    it 'processes versions' do
-      FileUtils.expects(:rm_r).with(File.expand_path('../fixtures/test.jpg', __FILE__),:force=>true).once
-      user.expects(:find).with('22').once.returns(user)
-      user.expects(:image_tmp).once.returns('test.jpg')
-      user.expects(:image).once.returns(image)
+  describe "#perform" do
+    let(:image)  { mock('UserAsset') }
+
+    before do
       image.expects(:root).once.returns(File.expand_path('..', __FILE__))
       image.expects(:cache_dir).once.returns('fixtures')
+      user.expects(:image_tmp).twice.returns('images/test.jpg')
+      user.expects(:find).with('22').once.returns(user)
+      user.expects(:image).once.returns(image)
       user.expects(:process_image_upload=).with(true).once
       user.expects(:image=).once
       user.expects(:image_tmp=).with(nil).once
+    end
+
+    it 'removes tmp directory on success' do
+      FileUtils.expects(:rm_r).with(fixtures_path, :force => true).once
       user.expects(:save!).once.returns(true)
+      worker.perform
+    end
+
+    it 'does not remove the tmp directory if save! fails' do
+      FileUtils.expects(:rm_r).never
+      user.expects(:save!).once.returns(false)
+      worker.perform
+    end
+
+    it 'sets the cache_path' do
+      user.expects(:save!).once.returns(false)
+      worker.perform
+      expect(worker.cache_path).to eql(fixtures_path + '/test.jpg')
+    end
 
+    it 'sets the tmp_directory' do
+      user.expects(:save!).once.returns(false)
       worker.perform
+      expect(worker.tmp_directory).to eql(fixtures_path)
+    end
+  end
+
+  describe '#perform with args' do
+    let(:admin) { mock('Admin') }
+    let(:image)  { mock('AdminAsset') }
+    let(:worker) { worker_class.new }
+
+    before do
+      image.expects(:root).once.returns(File.expand_path('..', __FILE__))
+      image.expects(:cache_dir).once.returns('fixtures')
+      admin.expects(:avatar_tmp).twice.returns('images/test.jpg')
+      admin.expects(:find).with('23').once.returns(admin)
+      admin.expects(:avatar).once.returns(image)
+      admin.expects(:process_avatar_upload=).with(true).once
+      admin.expects(:avatar=).once
+      admin.expects(:avatar_tmp=).with(nil).once
+      admin.expects(:save!).once.returns(false)
+      worker.perform admin, '23', :avatar
+    end
+
+    it 'sets klass' do
+      expect(worker.klass).to eql(admin)
+    end
+
+    it 'sets column' do
+      expect(worker.id).to eql('23')
+    end
+
+    it 'sets id' do
+      expect(worker.column).to eql(:avatar)
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 require 'rubygems'
 require 'bundler/setup'
-require 'support/backend_constants'
 require 'logger'
 require 'carrierwave_backgrounder'
 

data/spec/support/backend_constants.rb

@@ -1,6 +1,8 @@
 # Fixture module declarations for backend detection testing
 
 module GirlFriday
+  class WorkQueue
+  end
 end
 
 module Delayed
@@ -15,6 +17,9 @@ module Qu
 end
 
 module Sidekiq
+  module Client
+  end
+
   module Worker
     def self.included(base)
       base.extend(ClassMethods)
@@ -23,6 +28,9 @@ module Sidekiq
     module ClassMethods
       def sidekiq_options(opts = {})
       end
+
+      def client_push(item)
+      end
     end
   end
 end

data/spec/support/mock_worker.rb

@@ -0,0 +1,17 @@
+class MockWorker < Struct.new(:klass, :id, :column)
+  def self.perform(*args)
+    new(*args).perform
+  end
+
+  def perform(*args)
+    set_args(*args) unless args.empty?
+  end
+
+  def set_args(klass, id, column)
+    self.klass, self.id, self.column = klass, id, column
+  end
+end
+
+class MockSidekiqWorker < MockWorker
+  include Sidekiq::Worker
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave_backgrounder
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-15 00:00:00.000000000 Z
+date: 2013-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carrierwave
@@ -84,6 +84,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -105,13 +106,15 @@ files:
 - spec/backgrounder/orm/activemodel_spec.rb
 - spec/backgrounder/orm/base_spec.rb
 - spec/backgrounder/support/backends_spec.rb
-- spec/backgrounder/workers/fixtures/test.jpg
+- spec/backgrounder/workers/fixtures/images/test.jpg
 - spec/backgrounder/workers/process_asset_spec.rb
 - spec/backgrounder/workers/store_asset_spec.rb
 - spec/spec_helper.rb
 - spec/support/backend_constants.rb
-homepage: ''
-licenses: []
+- spec/support/mock_worker.rb
+homepage: https://github.com/lardawge/carrierwave_backgrounder
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -124,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4429973419830496543
+      hash: -2596358502417703338
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -133,20 +136,21 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4429973419830496543
+      hash: -2596358502417703338
 requirements: []
-rubyforge_project: carrierwave_backgrounder
+rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Offload CarrierWave's image processing and storage to a background process
-  using Delayed Job
+  using Delayed Job, Resque, Sidekiq, Qu, Queue Classic or Girl Friday
 test_files:
 - spec/backgrounder/orm/activemodel_spec.rb
 - spec/backgrounder/orm/base_spec.rb
 - spec/backgrounder/support/backends_spec.rb
-- spec/backgrounder/workers/fixtures/test.jpg
+- spec/backgrounder/workers/fixtures/images/test.jpg
 - spec/backgrounder/workers/process_asset_spec.rb
 - spec/backgrounder/workers/store_asset_spec.rb
 - spec/spec_helper.rb
 - spec/support/backend_constants.rb
+- spec/support/mock_worker.rb