carrierwave_backgrounder 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: abc9a18253e5769acf85ec7fe57cd8778d331f09
-  data.tar.gz: 8317e2803900b1c724064ec3c759558946927aca
+SHA256:
+  metadata.gz: c08d7bdb01034545507f0ef13305aa12764e2771148c4ddc22f1291fbba8f7f9
+  data.tar.gz: 21d4f4a1cd200c5b05f9b967d4fda436e7d11752ba6fb6307f619a7b32ae1924
 SHA512:
-  metadata.gz: 469bc208573057e5934e8f42e21f0d95ff955b3b377b709b6aa504a4931ac80b29f42f83bd26986fa601b777b3ed9fa4b4af14b59981ca59cc14a7dc314ba4d0
-  data.tar.gz: b4fcd8692e900393d94a9ee779a605d0c733785b425312b14c5c825464e21ed07aafc3c458b398dc42bafac88562716adbb2ddf31cfb4d252e915b00a28d039e
+  metadata.gz: 683938ec5318b2727ae40e177a717fc6135f479f397cbdd39e0b3639a70ff3508ef98406ced8fd203b6d34d4017a84d2a2eab64f164d69bd8d24c64e2ff1786c
+  data.tar.gz: 44b9e651e679fa450dfbe9620e58e5472c0be9bc20bd7f4ce29894de28c30c7f6d5c04f7dd9aa56fc4277bd8d0a3ff0205aa287fb31439e8bfaa5d6158ccbe0b

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+vendor/*

data/.travis.yml

@@ -1,10 +1,16 @@
 language: ruby
 
 rvm:
- - 1.9.3
- - 2.0.0
+ - 2.3
+ - 2.4
+ - 2.5
+ - 2.6
  - ruby-head
 
+before_install:
+ - yes | gem update --system --force
+ - gem install bundler
+
 matrix:
   allow_failures:
     - rvm: ruby-head

data/CHANGELOG.md

@@ -1,4 +1,19 @@
 
+## 0.4.3
+
+### enhancements
+  * [#307] Add support for Sidekiq 7 [holstvoogd]
+  * [#278] Add sidekiq queue config [IlkhamGaysin]
+
+## 0.4.2
+
+### enhancements
+  * Allow overridden worker to set a queue name
+  * [#190] Respect Carrierwave's enable_processing flag if set to false [jherdman]
+
+### bug fixes
+  * [#216] Fix for NoMethodError: undefined method `read' for nil:NilClass [kntmrkm]
+
 ## 0.4.1
 
 ### enhancements
@@ -88,4 +103,3 @@
 ### bug fixes
   * Girl Friday incorrectly referenses class #92
   * Add documentation for testing with rspec #84.
-

data/README.md

@@ -2,7 +2,6 @@
 
 [![Build Status](https://secure.travis-ci.org/lardawge/carrierwave_backgrounder.png)](http://travis-ci.org/lardawge/carrierwave_backgrounder)
 [![Code Climate](https://codeclimate.com/github/lardawge/carrierwave_backgrounder.png)](https://codeclimate.com/github/lardawge/carrierwave_backgrounder)
-[![Still Maintained](http://stillmaintained.com/lardawge/carrierwave_backgrounder.png)](http://stillmaintained.com/lardawge/carrierwave_backgrounder)
 
 I like CarrierWave. That being said, I don't like tying up app instances waiting for images to process.
 
@@ -34,7 +33,7 @@ Backgrounder::ORM::Base::store_in_background
 
 ## Installation and Usage
 
-These instructions assume you have previously set up [CarrierWave](https://github.com/jnicklas/carrierwave) and your queing lib of choice.
+These instructions assume you have previously set up [CarrierWave](https://github.com/jnicklas/carrierwave) and your queuing lib of choice.
 
 In Rails, add the following your Gemfile:
 
@@ -55,6 +54,14 @@ CarrierWave::Backgrounder.configure do |c|
 end
 ```
 
+**IMPORTANT FOR SIDEKIQ BACKEND** - Custom queue should be defined inside the Sidekiq configuration otherwise jobs won't be processed:
+
+```yml
+:queues:
+  - [awesome_queue, 1]
+  - default
+```
+
 In your CarrierWave uploader file:
 
 ```ruby
@@ -74,10 +81,11 @@ mount_uploader :avatar, AvatarUploader
 process_in_background :avatar
 ```
 
-Optionally you can add a column to the database which will be set to nil when the background processing is complete.
+Optionally you can add a column to the database which will be set to `true` when
+the background processing is started and to `false` when the background processing is complete.
 
 ```ruby
-add_column :users, :avatar_processing, :boolean
+add_column :users, :avatar_processing, :boolean, null: false, default: false
 ```
 
 ### To use store_in_background
@@ -114,7 +122,7 @@ This must be set before you assign an upload:
 ```
 
 ### Override worker
-To overide the worker in cases where additional methods need to be called or you have app specific requirements, pass the worker class as the
+To override the worker in cases where additional methods need to be called or you have app specific requirements, pass the worker class as the
 second argument:
 
 ```ruby
@@ -134,9 +142,36 @@ class MyParanoidWorker < ::CarrierWave::Workers::ProcessAsset
   # other hooks you might care about
 end
 ```
+
+### ActiveJob
+Use overriden worker that inherits from ActiveJob::Base and includes relevant worker mixin:
+```ruby
+class MyActiveJobWorker < ActiveJob::Base
+  include ::CarrierWave::Workers::ProcessAssetMixin
+  # ... or include ::CarrierWave::Workers::StoreAssetMixin
+
+  after_perform do
+    # your code here
+  end
+
+  # Sometimes job gets performed before the file is uploaded and ready.
+  # You can define how to handle that case by overriding `when_not_ready` method
+  # (by default it does nothing)
+  def when_not_ready
+    retry_job
+  end
+end
+```
+Don't forget to set `active_job` as a backend in the config:
+```ruby
+CarrierWave::Backgrounder.configure do |c|
+  c.backend :active_job, queue: :carrierwave
+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
-if you're using trasactional fixtures. One solution to the problem is to use the [TestAfterCommit gem](https://github.com/grosser/test_after_commit).
+if you're using transactional fixtures. One solution to the problem is to use the [TestAfterCommit gem](https://github.com/grosser/test_after_commit).
 There are various other solutions in which case google is your friend.
 
 ### Uploaders mounted on mongoid embedded documents

data/carrierwave_backgrounder.gemspec

@@ -17,9 +17,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "carrierwave", ["~> 0.5"]
+  s.add_dependency "carrierwave", [">= 0.5", "< 2.2"]
 
-  s.add_development_dependency "rspec", ["~> 2.12.0"]
-  s.add_development_dependency "mocha", ["~> 0.13.0"]
+  s.add_development_dependency "rspec", ["~> 3.10.0"]
   s.add_development_dependency "rake"
 end

data/lib/backgrounder/delay.rb

@@ -17,7 +17,8 @@ module CarrierWave
       private
 
       def proceed_with_versioning?
-        !model.respond_to?(:"process_#{mounted_as}_upload") || model.send(:"process_#{mounted_as}_upload")
+        !model.respond_to?(:"process_#{mounted_as}_upload") && enable_processing ||
+          !!(model.send(:"process_#{mounted_as}_upload") && enable_processing)
       end
     end # Delay
 

data/lib/backgrounder/orm/base.rb

@@ -82,7 +82,7 @@ module CarrierWave
 
             def write_#{column}_identifier
               super and return if process_#{column}_upload
-              self.#{column}_tmp = _mounter(:#{column}).cache_name if _mounter(:#{column}).cache_name
+              self.#{column}_tmp = #{column}_cache if #{column}_cache
             end
 
             def store_#{column}!

data/lib/backgrounder/orm/data_mapper.rb

@@ -26,7 +26,7 @@ module CarrierWave
 
             def write_#{column}_identifier
               super and return if process_#{column}_upload
-              self.#{column}_tmp = _mounter(:#{column}).cache_name
+              self.#{column}_tmp = #{column}_cache
             end
           RUBY
         end

data/lib/backgrounder/support/backends.rb

@@ -22,11 +22,19 @@ module CarrierWave
 
           private
 
+          def enqueue_active_job(worker, *args)
+            worker.perform_later(*args.map(&:to_s))
+          end
+
           def enqueue_delayed_job(worker, *args)
+            worker_args = {}
             if ::Delayed::Job.new.respond_to?(:queue)
-              ::Delayed::Job.enqueue worker.new(*args), :queue => queue_options[:queue]
+              worker_args[:queue] = queue_options[:queue] if queue_options[:queue]
+              worker_args[:priority] = queue_options[:priority] if queue_options[:priority]
+              ::Delayed::Job.enqueue worker.new(*args), worker_args
             else
-              ::Delayed::Job.enqueue worker.new(*args)
+              worker_args[:priority] = queue_options[:priority] if queue_options[:priority]
+              ::Delayed::Job.enqueue worker.new(*args), worker_args
               if queue_options[:queue]
                 ::Rails.logger.warn("Queue name given but no queue column exists for Delayed::Job")
               end
@@ -39,7 +47,8 @@ module CarrierWave
           end
 
           def enqueue_sidekiq(worker, *args)
-            args = sidekiq_queue_options('class' => worker, 'args' => args)
+            override_queue_name = worker.sidekiq_options['queue'] == 'default' || worker.sidekiq_options['queue'].nil?
+            args = sidekiq_queue_options(override_queue_name, 'class' => worker, 'args' => args.map(&:to_s))
             worker.client_push(args)
           end
 
@@ -69,8 +78,10 @@ module CarrierWave
             worker.new(*args).perform
           end
 
-          def sidekiq_queue_options(args)
-            args['queue'] = queue_options[:queue] if queue_options[:queue]
+          def sidekiq_queue_options(override_queue_name, args)
+            if override_queue_name && queue_options[:queue]
+              args['queue'] = queue_options[:queue]
+            end
             args['retry'] = queue_options[:retry] unless queue_options[:retry].nil?
             args['timeout'] = queue_options[:timeout] if queue_options[:timeout]
             args['backtrace'] = queue_options[:backtrace] if queue_options[:backtrace]

data/lib/backgrounder/version.rb

@@ -1,5 +1,5 @@
 module CarrierWave
   module Backgrounder
-    VERSION = "0.4.1"
+    VERSION = "0.4.3"
   end
 end

data/lib/backgrounder/workers/base.rb

@@ -1,14 +1,18 @@
+# encoding: utf-8
 module CarrierWave
   module Workers
-    class Base < Struct.new(:klass, :id, :column)
 
-      def self.perform(*args)
-        new(*args).perform
+    module Base
+      attr_accessor :klass, :id, :column, :record
+
+      def initialize(*args)
+        super(*args) unless self.class.superclass == Object
+        set_args(*args) if args.present?
       end
 
       def perform(*args)
         set_args(*args) if args.present?
-        constantized_resource.find id
+        self.record = constantized_resource.find id
       rescue *not_found_errors
       end
 
@@ -29,6 +33,10 @@ module CarrierWave
         klass.is_a?(String) ? klass.constantize : klass
       end
 
-    end
-  end
-end
+      def when_not_ready
+      end
+
+    end # Base
+
+  end # Workers
+end # CarrierWave

data/lib/backgrounder/workers/class_methods.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module ClassMethods
+
+      def perform(*args)
+        new(*args).perform
+      end
+
+    end # ClassMethods
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers/process_asset.rb

@@ -2,19 +2,8 @@
 module CarrierWave
   module Workers
 
-    class ProcessAsset < Base
-
-      def perform(*args)
-        record = super(*args)
-
-        if record
-          record.send(:"process_#{column}_upload=", true)
-          if record.send(:"#{column}").recreate_versions! && record.respond_to?(:"#{column}_processing")
-            record.update_attribute :"#{column}_processing", false
-          end
-        end
-      end
-
+    class ProcessAsset
+      include CarrierWave::Workers::ProcessAssetMixin
     end # ProcessAsset
 
   end # Workers

data/lib/backgrounder/workers/process_asset_mixin.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module ProcessAssetMixin
+      include CarrierWave::Workers::Base
+
+      def self.included(base)
+        base.extend CarrierWave::Workers::ClassMethods
+      end
+
+      def perform(*args)
+        record = super(*args)
+
+        if record && record.send(:"#{column}").present?
+          record.send(:"process_#{column}_upload=", true)
+          if record.send(:"#{column}").recreate_versions! && record.respond_to?(:"#{column}_processing")
+            record.update_attribute :"#{column}_processing", false
+          end
+        else
+          when_not_ready
+        end
+      end
+
+    end # ProcessAssetMixin
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers/store_asset.rb

@@ -2,32 +2,8 @@
 module CarrierWave
   module Workers
 
-    class StoreAsset < Base
-      attr_reader :cache_path, :tmp_directory
-
-      def perform(*args)
-        record = super(*args)
-
-        if record && record.send(:"#{column}_tmp")
-          store_directories(record)
-          record.send :"process_#{column}_upload=", true
-          record.send :"#{column}_tmp=", nil
-          record.send :"#{column}_processing=", false if record.respond_to?(:"#{column}_processing")
-          File.open(cache_path) { |f| record.send :"#{column}=", f }
-          if record.save!
-            FileUtils.rm_r(tmp_directory, :force => true)
-          end
-        end
-      end
-
-      private
-
-      def store_directories(record)
-        asset, asset_tmp = record.send(:"#{column}"), record.send(:"#{column}_tmp")
-        cache_directory  = File.expand_path(asset.cache_dir, asset.root)
-        @cache_path      = File.join(cache_directory, asset_tmp)
-        @tmp_directory   = File.join(cache_directory, asset_tmp.split("/").first)
-      end
+    class StoreAsset
+      include CarrierWave::Workers::StoreAssetMixin
     end # StoreAsset
 
   end # Workers

data/lib/backgrounder/workers/store_asset_mixin.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module StoreAssetMixin
+      include CarrierWave::Workers::Base
+
+      def self.included(base)
+        base.extend CarrierWave::Workers::ClassMethods
+      end
+
+      attr_reader :cache_path, :tmp_directory
+
+      def perform(*args)
+        record = super(*args)
+
+        if record && record.send(:"#{column}_tmp")
+          store_directories(record)
+          record.send :"process_#{column}_upload=", true
+          record.send :"#{column}_tmp=", nil
+          record.send :"#{column}_processing=", false if record.respond_to?(:"#{column}_processing")
+          File.open(cache_path) { |f| record.send :"#{column}=", f }
+          if record.save!
+            FileUtils.rm_r(tmp_directory, :force => true)
+          end
+        else
+          when_not_ready
+        end
+      end
+
+      private
+
+      def store_directories(record)
+        asset, asset_tmp = record.send(:"#{column}"), record.send(:"#{column}_tmp")
+        cache_directory  = File.expand_path(asset.cache_dir, asset.root)
+        @cache_path      = File.join(cache_directory, asset_tmp)
+        @tmp_directory   = File.join(cache_directory, asset_tmp.split("/").first)
+      end
+
+    end # StoreAssetMixin
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers.rb

@@ -1,3 +1,6 @@
 require 'backgrounder/workers/base'
+require 'backgrounder/workers/class_methods'
+require 'backgrounder/workers/process_asset_mixin'
+require 'backgrounder/workers/store_asset_mixin'
 require 'backgrounder/workers/process_asset'
 require 'backgrounder/workers/store_asset'

data/lib/generators/carrierwave_backgrounder/templates/config/initializers/carrierwave_backgrounder.rb

@@ -1,5 +1,6 @@
 CarrierWave::Backgrounder.configure do |c|
   c.backend :delayed_job, queue: :carrierwave
+  # c.backend :active_job, queue: :carrierwave
   # c.backend :resque, queue: :carrierwave
   # c.backend :sidekiq, queue: :carrierwave
   # c.backend :girl_friday, queue: :carrierwave

data/spec/backgrounder/orm/activemodel_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'ostruct'
 require 'backgrounder/orm/activemodel'
 
-describe CarrierWave::Backgrounder::ORM::ActiveModel do
+RSpec.describe CarrierWave::Backgrounder::ORM::ActiveModel do
   before do
     @mock_class = Class.new do
       def self.before_save(method, opts); nil; end
@@ -20,7 +20,7 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
   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?)
+        expect(@mock_class).to receive(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
         @mock_class.store_in_background :avatar
       end
     end
@@ -29,12 +29,12 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
   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?)
+        expect(@mock_class).to receive(: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?)
+        expect(@mock_class).to receive(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
         @mock_class.process_in_background :avatar
       end
     end
@@ -50,48 +50,48 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
     context 'mount_on option is set' do
       before do
         options_hash = {:avatar => {:mount_on => :some_other_column}}
-        @mock_class.expects(:uploader_options).returns(options_hash)
+        expect(@mock_class).to receive(:uploader_options).and_return(options_hash)
       end
 
       it "returns true if alternate column is changed" do
-        instance.expects(:some_other_column_changed?).returns(true)
-        expect(instance.avatar_updated?).to be_true
+        expect(instance).to receive(:some_other_column_changed?).and_return(true)
+        expect(instance.avatar_updated?).to be_truthy
       end
     end
 
     it "returns true if process_avatar_upload is false" do
-      instance.expects(:process_avatar_upload)
-      expect(instance.enqueue_avatar_background_job?).to be_true
+      expect(instance).to receive(:process_avatar_upload)
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     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
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?)
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     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
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?).and_return(false)
+      expect(instance).to receive(:previous_changes).and_return({:avatar => true})
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     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
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?).and_return(false)
+      expect(instance).to receive(:previous_changes).and_return({})
+      expect(instance).to receive(:remote_avatar_url).and_return('yup')
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     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
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?).and_return(false)
+      expect(instance).to receive(:previous_changes).and_return({})
+      expect(instance).to receive(:remote_avatar_url).and_return(nil)
+      expect(instance).to receive(:avatar_cache).and_return('yup')
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     end
   end
 end

data/spec/backgrounder/orm/base_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 
-describe CarrierWave::Backgrounder::ORM::Base do
+RSpec.describe CarrierWave::Backgrounder::ORM::Base do
   before do
     @mock_class = Class.new do
       def self.before_save(method, opts); nil; end

data/spec/backgrounder/support/backends_spec.rb

@@ -3,7 +3,7 @@ require 'support/backend_constants'
 require 'support/mock_worker'
 
 module CarrierWave::Backgrounder
-  describe Support::Backends do
+  RSpec.describe Support::Backends do
     let(:mock_module) { Module.new }
 
     before do
@@ -31,25 +31,43 @@ module CarrierWave::Backgrounder
     describe '#enqueue_for_backend' do
       let!(:worker) { MockWorker.new('FakeClass', 1, :image) }
 
+      context 'active_job' do
+        let(:args) { ['FakeClass', 1, :image] }
+
+        it 'invokes perform_later with string arguments' do
+          expect(MockWorker).to receive(:perform_later).with('FakeClass', '1', 'image')
+          mock_module.backend :active_job
+          mock_module.enqueue_for_backend(MockWorker, *args)
+        end
+      end
+
       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)
+          allow(MockWorker).to receive(:new).and_return(worker)
         end
 
         context 'queue column exists' do
-          it 'defaults the queue name to nil if none passed to #backend' do
+          it 'does not pass the queue name if none passed to #backend' do
             mock_module.backend :delayed_job
-            Delayed::Job.expects(:enqueue).with(worker, :queue => nil)
+            expect(Delayed::Job).to receive(:enqueue).with(worker, {})
             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)
+            expect(Delayed::Job).to receive(:enqueue).with(worker, :queue => :awesome_queue)
+            mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
+          end
+        end
+
+        context 'priority set in config' do
+          it 'sets the priority which is passed to #backend' do
+            mock_module.backend :delayed_job, :priority => 5
+            expect(Delayed::Job).to receive(:enqueue).with(worker, :priority => 5)
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
         end
@@ -57,7 +75,7 @@ module CarrierWave::Backgrounder
         context 'queue column does not exist' do
           before do
             column_names = Delayed::Job.column_names.tap { |cn| cn.delete('queue') }
-            Delayed::Job.stubs(:column_names).returns(column_names)
+            allow(Delayed::Job).to receive(:column_names).and_return(column_names)
             Delayed::Job.class_eval { remove_method(:queue) }
           end
 
@@ -67,14 +85,14 @@ module CarrierWave::Backgrounder
 
           it 'does not pass a queue name if none passed to #backend' do
             mock_module.backend :delayed_job
-            Delayed::Job.expects(:enqueue).with(worker)
+            expect(Delayed::Job).to receive(:enqueue).with(worker, {})
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
 
           it 'does not pass a queue name and logs a warning message if a queue name is passed to #backend' do
             mock_module.backend :delayed_job, :queue => :awesome_queue
-            Delayed::Job.expects(:enqueue).with(worker)
-            Rails.logger.expects(:warn).with(instance_of(String))
+            expect(Rails.logger).to receive(:warn).with(instance_of(String))
+            expect(Delayed::Job).to receive(:enqueue).with(worker, {})
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
         end
@@ -84,7 +102,7 @@ module CarrierWave::Backgrounder
         let(:args) { [MockWorker, 'FakeClass', 1, :image] }
 
         before do
-          Resque.expects(:enqueue).with(*args)
+          allow(Resque).to receive(:enqueue).with(*args)
         end
 
         it 'sets a variable with the queue name, defaults to :carrierwave' do
@@ -104,21 +122,31 @@ module CarrierWave::Backgrounder
         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 })
+          expect(MockSidekiqWorker).to receive(:client_push).with({ 'class' => MockSidekiqWorker, 'args' => args.map(&:to_s) })
           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 })
+          expect(MockSidekiqWorker).to receive(:client_push).with({ 'class' => MockSidekiqWorker,
+                                                                    'retry' => false,
+                                                                    'timeout' => 60,
+                                                                    'queue' => :awesome_queue,
+                                                                    'args' => args.map(&:to_s) })
           options = {:retry => false, :timeout => 60, :queue => :awesome_queue}
           mock_module.backend :sidekiq, options
           mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
         end
+
+        it 'does not override queue name if set it worker' do
+          expect(MockNamedSidekiqWorker).to receive(:client_push).with({ 'class' => MockNamedSidekiqWorker,
+                                                                    'retry' => false,
+                                                                    'timeout' => 60,
+                                                                    'args' => args.map(&:to_s) })
+          options = {:retry => false, :timeout => 60}
+          mock_module.backend :sidekiq, options
+          mock_module.enqueue_for_backend(MockNamedSidekiqWorker, *args)
+        end
       end
 
       context 'girl_friday' do
@@ -126,20 +154,20 @@ module CarrierWave::Backgrounder
 
         it 'instantiates a GirlFriday work queue if one does not exist' do
           mock_module.backend :girl_friday
-          GirlFriday::WorkQueue.expects(:new).with(:carrierwave, {}).returns([])
+          expect(GirlFriday::WorkQueue).to receive(:new).with(:carrierwave, {}).and_return([])
           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([])
+          expect(GirlFriday::WorkQueue).to receive(:new).with(:awesome_queue, {:size => 3}).and_return([])
           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
+          expect(GirlFriday::WorkQueue).to receive(:new).never
           mock_module.enqueue_for_backend(*args)
         end
 
@@ -154,12 +182,12 @@ module CarrierWave::Backgrounder
 
       context 'sucker_punch' do
         let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-        let(:job) { mock('job') }
+        let(:job) { double('job') }
 
         it 'invokes a new worker' do
-          MockWorker.expects(:new).returns(worker)
-          worker.expects(:async).returns(job)
-          job.expects(:perform).with('FakeClass', 1, :image)
+          expect(MockWorker).to receive(:new).and_return(worker)
+          expect(worker).to receive(:async).and_return(job)
+          expect(job).to receive(:perform).with('FakeClass', 1, :image)
           mock_module.backend :sucker_punch
           mock_module.enqueue_for_backend(*args)
         end
@@ -168,7 +196,7 @@ module CarrierWave::Backgrounder
       context 'qu' do
         let(:args) { [MockWorker, 'FakeClass', 1, :image] }
         before do
-          Qu.expects(:enqueue).with(*args)
+          allow(Qu).to receive(:enqueue).with(*args)
         end
 
         it 'sets a variable with the queue name, defaults to :carrierwave' do
@@ -186,7 +214,7 @@ module CarrierWave::Backgrounder
 
       context 'qc' do
         it 'calls enqueue with the passed args' do
-          QC.expects(:enqueue).with("MockWorker.perform", 'FakeClass', 1, 'image')
+          expect(QC).to receive(:enqueue).with("MockWorker.perform", 'FakeClass', 1, 'image')
           mock_module.backend :qc
           mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
         end
@@ -194,14 +222,13 @@ module CarrierWave::Backgrounder
 
       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)
+          worker = double('Worker')
+          expect(MockWorker).to receive(:new).with('FakeClass', 1, :image).and_return(worker)
+          expect(worker).to receive(:perform)
           mock_module.backend :immediate
           mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
         end
       end
-
     end
   end
 end

data/spec/backgrounder/workers/process_asset_spec.rb

@@ -2,55 +2,55 @@
 require 'spec_helper'
 require 'backgrounder/workers/process_asset'
 
-describe CarrierWave::Workers::ProcessAsset do
+RSpec.describe CarrierWave::Workers::ProcessAsset do
   let(:worker_class) { CarrierWave::Workers::ProcessAsset }
-  let(:user)   { mock('User') }
+  let(:user)   { double('User') }
   let!(:worker) { worker_class.new(user, '22', :image) }
 
   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)
+      expect(worker_class).to receive(:new).with(*args).and_return(worker)
+      expect_any_instance_of(worker_class).to receive(:perform)
 
       worker_class.perform(*args)
     end
   end
 
   describe "#perform" do
-    let(:image)  { mock('UserAsset') }
+    let(:image)  { double('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)
+      allow(user).to receive(:find).with('22').and_return(user).once
+      allow(user).to receive(:image).twice.and_return(image)
+      allow(user).to receive(:process_image_upload=).with(true).once
+      allow(image).to receive(:recreate_versions!).once.and_return(true)
     end
 
     it 'processes versions with image_processing column' do
-      user.expects(:respond_to?).with(:image_processing).once.returns(true)
-      user.expects(:update_attribute).with(:image_processing, false).once
+      expect(user).to receive(:respond_to?).with(:image_processing).once.and_return(true)
+      expect(user).to receive(:update_attribute).with(:image_processing, false).once
       worker.perform
     end
 
     it 'processes versions without image_processing column' do
-      user.expects(:respond_to?).with(:image_processing).once.returns(false)
-      user.expects(:update_attribute).never
+      expect(user).to receive(:respond_to?).with(:image_processing).once.and_return(false)
+      expect(user).to receive(:update_attribute).never
       worker.perform
     end
   end
 
   describe '#perform with args' do
-    let(:admin) { mock('Admin') }
-    let(:avatar)  { mock('AdminAsset') }
+    let(:admin) { double('Admin') }
+    let(:avatar)  { double('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)
+      allow(admin).to receive(:find).with('23').and_return(admin).once
+      allow(admin).to receive(:avatar).twice.and_return(avatar)
+      allow(admin).to receive(:process_avatar_upload=).with(true).once
+      allow(admin).to receive(:respond_to?).with(:avatar_processing).once.and_return(false)
+      allow(avatar).to receive(:recreate_versions!).once.and_return(true)
 
       worker.perform admin, '23', :avatar
     end

data/spec/backgrounder/workers/store_asset_spec.rb

@@ -2,75 +2,75 @@
 require 'spec_helper'
 require 'backgrounder/workers/store_asset'
 
-describe CarrierWave::Workers::StoreAsset do
+RSpec.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(:user) { double('User') }
   let!(:worker) { worker_class.new(user, '22', :image) }
 
   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)
+      expect(worker_class).to receive(:new).with(*args).and_return(worker)
+      expect_any_instance_of(worker_class).to receive(:perform)
       worker_class.perform(*args)
     end
   end
 
   describe "#perform" do
-    let(:image)  { mock('UserAsset') }
+    let(:image)  { double('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
+      allow(image).to receive(:root).once.and_return(File.expand_path('..', __FILE__))
+      allow(image).to receive(:cache_dir).once.and_return('fixtures')
+      allow(user).to receive(:image_tmp).twice.and_return('images/test.jpg')
+      allow(user).to receive(:find).with('22').once.and_return(user)
+      allow(user).to receive(:image).once.and_return(image)
+      allow(user).to receive(:process_image_upload=).with(true).once
+      allow(user).to receive(:image=).once
+      allow(user).to receive(: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)
+      expect(FileUtils).to receive(:rm_r).with(fixtures_path, :force => true).once
+      expect(user).to receive(:save!).once.and_return(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)
+      expect(FileUtils).to receive(:rm_r).never
+      expect(user).to receive(:save!).once.and_return(false)
       worker.perform
     end
 
     it 'sets the cache_path' do
-      user.expects(:save!).once.returns(false)
+      expect(user).to receive(:save!).once.and_return(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)
+      expect(user).to receive(:save!).once.and_return(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(:admin) { double('Admin') }
+    let(:image)  { double('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)
+      allow(image).to receive(:root).once.and_return(File.expand_path('..', __FILE__))
+      allow(image).to receive(:cache_dir).once.and_return('fixtures')
+      allow(admin).to receive(:avatar_tmp).twice.and_return('images/test.jpg')
+      allow(admin).to receive(:find).with('23').once.and_return(admin)
+      allow(admin).to receive(:avatar).once.and_return(image)
+      allow(admin).to receive(:process_avatar_upload=).with(true).once
+      allow(admin).to receive(:avatar=).once
+      allow(admin).to receive(:avatar_tmp=).with(nil).once
+      allow(admin).to receive(:save!).once.and_return(false)
       worker.perform admin, '23', :avatar
     end
 
@@ -88,15 +88,15 @@ describe CarrierWave::Workers::StoreAsset do
   end
 
   describe '#store_directories' do
-    let(:record) { mock('Record') }
+    let(:record) { double('Record') }
 
     context 'cache_path' do
       it 'sets the cache_path correctly if a full path is set for the cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = '/Users/lar/Sites/bunker/tmp/uploads'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.cache_path).to eql('/Users/lar/Sites/bunker/tmp/uploads/images/test.jpg')
       end
@@ -104,9 +104,9 @@ describe CarrierWave::Workers::StoreAsset do
       it 'sets the cache_path correctly if a partial path is set for cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = 'uploads/tmp'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.cache_path).to eql('/Users/lar/Sites/bunker/public/uploads/tmp/images/test.jpg')
       end
@@ -116,9 +116,9 @@ describe CarrierWave::Workers::StoreAsset do
       it 'sets the tmp_directory correctly if a full path is set for the cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = '/Users/lar/Sites/bunker/tmp/uploads'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.tmp_directory).to eql('/Users/lar/Sites/bunker/tmp/uploads/images')
       end
@@ -126,9 +126,9 @@ describe CarrierWave::Workers::StoreAsset do
       it 'sets the tmp_directory correctly if a partial path is set for cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = 'uploads/tmp'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.tmp_directory).to eql('/Users/lar/Sites/bunker/public/uploads/tmp/images')
       end

data/spec/spec_helper.rb

@@ -15,7 +15,6 @@ module WarningSuppression
 end
 
 RSpec.configure do |c|
-  c.mock_with :mocha
   c.include WarningSuppression
 end
 

data/spec/support/backend_constants.rb

@@ -34,6 +34,7 @@ module Sidekiq
 
     module ClassMethods
       def sidekiq_options(opts = {})
+        opts
       end
 
       def client_push(item)
@@ -52,6 +53,6 @@ end
 
 module Rails
   def self.logger
-    @logger ||= Object.new
+    @logger ||= Logger.new(STDOUT)
   end
 end

data/spec/support/mock_worker.rb

@@ -15,3 +15,8 @@ end
 class MockSidekiqWorker < MockWorker
   include Sidekiq::Worker
 end
+
+class MockNamedSidekiqWorker < MockWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: :even_better_name
+end

metadata

@@ -1,81 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave_backgrounder
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.3
 platform: ruby
 authors:
 - Larry Sprock
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2023-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carrierwave
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 2.12.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 3.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 3.10.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - larry@lucidbleu.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -90,8 +82,11 @@ files:
 - lib/backgrounder/version.rb
 - lib/backgrounder/workers.rb
 - lib/backgrounder/workers/base.rb
+- lib/backgrounder/workers/class_methods.rb
 - lib/backgrounder/workers/process_asset.rb
+- lib/backgrounder/workers/process_asset_mixin.rb
 - lib/backgrounder/workers/store_asset.rb
+- lib/backgrounder/workers/store_asset_mixin.rb
 - lib/carrierwave_backgrounder.rb
 - lib/generators/carrierwave_backgrounder/USAGE
 - lib/generators/carrierwave_backgrounder/install_generator.rb
@@ -109,24 +104,23 @@ homepage: https://github.com/lardawge/carrierwave_backgrounder
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.6
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Offload CarrierWave's image processing and storage to a background process
   using Delayed Job, Resque, Sidekiq, Qu, Queue Classic or Girl Friday