multi_worker 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eff1b67f7d6f0861193b1164fd5976aa053eaa37
-  data.tar.gz: 7d54dffeb1ce6da386919473cb194b0046658e34
+  metadata.gz: 58371d2a8351fc6f496e304c4e6c7907df5c9e92
+  data.tar.gz: fde9e1540640108d612c985814eb18e135b4646a
 SHA512:
-  metadata.gz: bbaca27df3e2b4c4aaff3faa79658934fd846ffab3da1f76dac7d24586955983099f34e858109bb723b85b91adb31a85061e2d6165aa100e1f79d0d590369b19
-  data.tar.gz: 688cc31e9c28ba87847fccf894dc2bf41cab53005fbe61f7b905fe44d2845df213adee4b574b4f97a6bf82c010daa452d1b69e3e332ee3cc4b63fa536628fcb5
+  metadata.gz: faa930571ed54febc0e974799ce547525718c0e81380052576fe0f62cd4340995642b648b806b902c2f4e5d597fd8869ba7b0a3e212d42f8d8ee443b815f7219
+  data.tar.gz: d7b6d3bd0fba6d269aa09e761ea678968006985659203684b73961c20b23e12dadd6ad1a80ba28ea2a08a1708bfa1e599d964d93210d6d953fadffbb444b46a7

data/.travis.yml

@@ -3,8 +3,9 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.1.1
   - jruby-19mode
   - rbx
 matrix:
   allow_failures:
-    - rvm: rbx
+    - rvm: rbx

data/Gemfile

@@ -3,4 +3,6 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in multi_worker.gemspec
 gemspec
 
-#gem 'pry-debugger'
+group :development do
+  gem 'pry'
+end

data/README.md

@@ -1,4 +1,5 @@
-# MultiWorker [![Build Status](https://travis-ci.org/dwbutler/multi_worker.png?branch=master)](https://travis-ci.org/dwbutler/multi_worker)
+# MultiWorker
+[![Build Status](https://travis-ci.org/dwbutler/multi_worker.png?branch=master)](https://travis-ci.org/dwbutler/multi_worker) [![Code Climate](https://codeclimate.com/github/dwbutler/multi_worker.png)](https://codeclimate.com/github/dwbutler/multi_worker) [![Dependency Status](https://gemnasium.com/dwbutler/multi_worker.svg)](https://gemnasium.com/dwbutler/multi_worker)
 
 MultiWorker provides a common interface to the (many) Ruby queueing/worker libraries.
 They are all very similar, but provide slightly different interfaces. This makes it difficult
@@ -94,6 +95,7 @@ end
 | Qu                       | Redis, Mongo, SQS    |        |       |      |        |            |          |                    | ✓         | ✓      |
 | Queue Classic            | PostgreSQL           |        |       |      |        |            |          |                    | ✓         | ✗      |
 | Que                      | PostgreSQL           |        |       |      |        | ✓          | ✓        |                    | ✓         | ✓      |
+| Toro                     | PostgreSQL           | ✓      | ✓     |      |        | ✓          |          |                    | ✓         | ✗      |
 | Sneakers                 | RabbitMQ             |        |       |      |        |            |          |                    | ✗         | ✗      |
 | TorqueBox Backgroundable | HornetQ              | ✓      |       |      |        |            |          | ✓                  | ✗         | ✗      |
 | Backburner               | Beanstalkd           |        | ✓     |      |        | ✓          | ✓        | ✓                  | ✓         | ✓      |

data/lib/multi_worker.rb

@@ -31,12 +31,12 @@ module MultiWorker
 
     def default_options(opts={})
       @default_options ||= {
-        :adapter => default_adapter,
-        :queue => default_queue,
-        :status => false,
-        :retry => false,
-        :lock => false,
-        :unique => false
+        adapter: default_adapter,
+        queue: default_queue,
+        status: false,
+        retry: false,
+        lock: false,
+        unique: false
       }
 
       if opts && !opts.empty?
@@ -63,6 +63,7 @@ module MultiWorker
         when defined?(::ThreadedInMemoryQueue) then :threaded_in_memory_queue
         when defined?(::SuckerPunch::Job) then :sucker_punch
         when defined?(::Backburner) then :backburner
+        when defined?(::Toro) then :toro
         else :inline
       end
     end

data/lib/multi_worker/adapters/delayed_job.rb

@@ -10,7 +10,7 @@ module MultiWorker
           end
 
           def self.perform_async(*args)
-            delay(:queue => @queue).perform(*args)
+            delay(queue: @queue).perform(*args)
           end
 
           def perform_async(*args)

data/lib/multi_worker/adapters/sidekiq.rb

@@ -11,20 +11,20 @@ module MultiWorker
           end
           
           @sidekiq_options = ::Sidekiq.default_worker_options.symbolize_keys
-          @sidekiq_options.merge! :queue => opts[:queue]
+          @sidekiq_options.merge! queue: opts[:queue]
 
           if opts.has_key?(:backtrace)
-            @sidekiq_options.merge! :backtrace => opts[:backtrace]
+            @sidekiq_options.merge! backtrace: opts[:backtrace]
           end
 
           if opts.has_key?(:retry)
             @retry = opts[:retry]
             case @retry
             when Hash
-              @sidekiq_options.merge!(:retry => @retry[:limit])
+              @sidekiq_options.merge!(retry: @retry[:limit])
               sidekiq_retry_in(&@retry[:delay])
             when true, false, Fixnum
-              @sidekiq_options.merge!(:retry => @retry)
+              @sidekiq_options.merge!(retry: @retry)
             end
           end
 
@@ -32,12 +32,12 @@ module MultiWorker
             require 'sidekiq-lock'
             include ::Sidekiq::Lock::Worker
 
-            @sidekiq_options.merge!(:lock => opts[:lock])
+            @sidekiq_options.merge!(lock: opts[:lock])
           end
 
           if opts[:unique]
             require "sidekiq-unique-jobs"
-            @sidekiq_options.merge!(:unique => true)
+            @sidekiq_options.merge!(unique: true)
           end
 
           sidekiq_options @sidekiq_options

data/lib/multi_worker/adapters/sneakers.rb

@@ -18,7 +18,7 @@ module MultiWorker
           end
 
           def self.perform_async(*args)
-            ::Sneakers.publish(args.to_json, :to_queue => @queue)
+            ::Sneakers.publish(args.to_json, to_queue: @queue)
           end
 
           def perform_async(*args)

data/lib/multi_worker/adapters/toro.rb

@@ -0,0 +1,42 @@
+module MultiWorker
+  module Adapters
+    class Toro
+      def self.configure(base, opts={})
+        base.class_eval do
+          include ::Toro::Worker
+
+          @queue = opts[:queue]
+          @toro_options = {queue: @queue}
+
+          if opts.has_key?(:retry)
+            @retry = opts[:retry]
+            case @retry
+              when Hash
+                @toro_options.merge!(retry_interval: @retry[:delay])
+              when Fixnum, ActiveSupport::Duration
+                @toro_options.merge!(retry_interval: @retry)
+            end
+          end
+
+          toro_options @toro_options
+
+          def self.perform(*args)
+            self.new.perform(*args)
+          end
+
+          def perform_async(*args)
+            self.class.perform_async(*args)
+          end
+        end
+      end
+
+      def self.rake_task
+        require 'rake'
+        require 'toro'
+        require 'tasks/tasks'
+        ::Rake::Task["toro"]
+      end
+    end
+  end
+end
+

data/lib/multi_worker/tasks.rb

@@ -6,7 +6,7 @@ task :environment
 
 namespace :multi_worker do
   desc "Start a new worker for #{MultiWorker.default_adapter}"
-  task :work => :environment do
+  task work: :environment do
     rake_task = MultiWorker.adapter.rake_task rescue fail("No rake task available for #{MultiWorker.default_adapter}")
     rake_task.execute
   end

data/lib/multi_worker/version.rb

@@ -1,3 +1,3 @@
 module MultiWorker
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/multi_worker.gemspec

@@ -40,8 +40,13 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "qu", "0.2.0"
 
-  spec.add_development_dependency "queue_classic" unless (RUBY_ENGINE == "jruby")
-  
+  if RUBY_ENGINE == "jruby"
+    spec.add_development_dependency "torquebox-messaging"
+  else
+    spec.add_development_dependency "queue_classic"
+    spec.add_development_dependency "toro"
+  end
+
   spec.add_development_dependency "que"
 
   spec.add_development_dependency "sneakers"
@@ -51,6 +56,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "sucker_punch"
 
   spec.add_development_dependency "backburner"
-
-  spec.add_development_dependency "torquebox-messaging" if (RUBY_ENGINE == "jruby")
 end

data/spec/adapters/backburner_spec.rb

@@ -1,32 +1,32 @@
-require 'backburner'
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-
-  it { should be_a ::Backburner::Queue }
-end
-
-describe MultiWorker do
-  context "when Backburner is loaded" do
-    it "defaults to the :backburner adapter" do
-      MultiWorker.default_adapter.should == :backburner
-    end
-  end
-
-  context "when using the :backburner adapter" do
-    it "::perform_async uses Backburner" do
-      Backburner.should_receive(:enqueue).once.with(TestWorker, "foo")
-      TestWorker.perform_async("foo")
-    end
-
-    it "MultiWorker.enqueue uses Backburner" do
-      Backburner.should_receive(:enqueue).once.with(TestWorker, "foo")
-      MultiWorker.enqueue(TestWorker, "foo")
-    end
-
-    it "exposes the Backburner rake task" do
-      MultiWorker.adapter.rake_task.name.should == "backburner:work"
-    end
-  end
+require 'backburner'
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { should be_a ::Backburner::Queue }
+end
+
+describe MultiWorker do
+  context "when Backburner is loaded" do
+    it "defaults to the :backburner adapter" do
+      expect(MultiWorker.default_adapter).to eq(:backburner)
+    end
+  end
+
+  context "when using the :backburner adapter" do
+    it "::perform_async uses Backburner" do
+      expect(Backburner).to receive(:enqueue).once.with(TestWorker, "foo")
+      TestWorker.perform_async("foo")
+    end
+
+    it "MultiWorker.enqueue uses Backburner" do
+      expect(Backburner).to receive(:enqueue).once.with(TestWorker, "foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+    end
+
+    it "exposes the Backburner rake task" do
+      expect(MultiWorker.adapter.rake_task.name).to eq("backburner:work")
+    end
+  end
 end

data/spec/adapters/delayed_job_spec.rb

@@ -1,32 +1,32 @@
-require 'delayed_job'
-require 'delayed/backend/test'
-Delayed::Worker.backend = :test
-#require 'delayed_job_active_record'
-Delayed::Worker.delay_jobs = false
-
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-end
-
-describe MultiWorker do
-  context "when Delayed::Job is loaded" do
-    it "defaults to the :delayed_job adapter" do
-      MultiWorker.default_adapter.should == :delayed_job
-    end
-  end
-
-  context "when using the :delayed_job adapter" do
-    it "performs the work using Delayed::Job" do
-      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
-      TestWorker.perform_async("foo")
-      MultiWorker.enqueue(TestWorker, "foo")
-      TestWorker.perform("foo")
-    end
-
-    it "exposes the Delayed Job rake task" do
-      MultiWorker.adapter.rake_task.name.should == "jobs:work"
-    end
-  end
+require 'delayed_job'
+require 'delayed/backend/test'
+Delayed::Worker.backend = :test
+#require 'delayed_job_active_record'
+Delayed::Worker.delay_jobs = false
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Delayed::Job is loaded" do
+    it "defaults to the :delayed_job adapter" do
+      expect(MultiWorker.default_adapter).to eq(:delayed_job)
+    end
+  end
+
+  context "when using the :delayed_job adapter" do
+    it "performs the work using Delayed::Job" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    it "exposes the Delayed Job rake task" do
+      expect(MultiWorker.adapter.rake_task.name).to eq("jobs:work")
+    end
+  end
 end

data/spec/adapters/inline_spec.rb

@@ -1,18 +1,18 @@
-require 'test_workers'
-
-describe MultiWorker do
-  context "when no other adapter is available" do
-    it "defaults to the :inline adapter" do
-      MultiWorker.default_adapter.should == :inline
-    end
-  end
-
-  context "when using the :inline adapter" do
-    it "performs the work immediately" do
-      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
-      TestWorker.perform_async("foo")
-      MultiWorker.enqueue(TestWorker, "foo")
-      TestWorker.perform("foo")
-    end
-  end
+require 'test_workers'
+
+describe MultiWorker do
+  context "when no other adapter is available" do
+    it "defaults to the :inline adapter" do
+      expect(MultiWorker.default_adapter).to eq(:inline)
+    end
+  end
+
+  context "when using the :inline adapter" do
+    it "performs the work immediately" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+  end
 end

data/spec/adapters/qu_spec.rb

@@ -1,29 +1,29 @@
-require 'qu'
-require 'qu-immediate'
-
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-end
-
-describe MultiWorker do
-  context "when Qu is loaded" do
-    it "defaults to the :qu adapter" do
-      MultiWorker.default_adapter.should == :qu
-    end
-  end
-
-  context "when using the :qu adapter" do
-    it "performs the work using Qu's backend" do
-      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
-      TestWorker.perform_async("foo")
-      MultiWorker.enqueue(TestWorker, "foo")
-      TestWorker.perform("foo")
-    end
-
-    it "exposes the Qu rake task" do
-      MultiWorker.adapter.rake_task.name.should == "qu:work"
-    end
-  end
+require 'qu'
+require 'qu-immediate'
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+end
+
+describe MultiWorker do
+  context "when Qu is loaded" do
+    it "defaults to the :qu adapter" do
+      expect(MultiWorker.default_adapter).to eq(:qu)
+    end
+  end
+
+  context "when using the :qu adapter" do
+    it "performs the work using Qu's backend" do
+      expect(TestWorker).to receive(:perform).exactly(3).times.with("foo")
+      TestWorker.perform_async("foo")
+      MultiWorker.enqueue(TestWorker, "foo")
+      TestWorker.perform("foo")
+    end
+
+    it "exposes the Qu rake task" do
+      expect(MultiWorker.adapter.rake_task.name).to eq("qu:work")
+    end
+  end
 end

data/spec/adapters/que_spec.rb

@@ -1,44 +1,44 @@
-require 'que'
-require 'active_record'
-::Que.mode = :sync
-
-require 'test_workers'
-
-describe TestWorker do
-  it_behaves_like "a worker"
-
-  it { TestWorker::Job.should be < ::Que::Job }
-end
-
-describe MultiWorker do
-  context "when Que is loaded" do
-    it "defaults to the :que adapter" do
-      MultiWorker.default_adapter.should == :que
-    end
-  end
-
-  context "when using the :que adapter" do
-    before(:each) do
-      Que::Job.any_instance.stub(:destroy => true)
-    end
-
-    it "forwards ::perform to #perform" do
-      expect_any_instance_of(TestWorker).to receive(:perform).once.with("foo")
-      TestWorker.perform("foo")
-    end
-
-    it "::perform_async performs the work using Que" do
-      expect_any_instance_of(TestWorker).to receive(:perform).once
-      TestWorker.perform_async("foo")
-    end
-
-    it "MultiWorker.enqueue performs the work using Que" do
-      expect_any_instance_of(TestWorker).to receive(:perform).once
-      MultiWorker.enqueue(TestWorker, "foo")
-    end
-
-    it "exposes the Que rake task" do
-      MultiWorker.adapter.rake_task.name.should == "que:work"
-    end
-  end
+require 'que'
+require 'active_record'
+::Que.mode = :sync
+
+require 'test_workers'
+
+describe TestWorker do
+  it_behaves_like "a worker"
+
+  it { expect(TestWorker::Job).to be < ::Que::Job }
+end
+
+describe MultiWorker do
+  context "when Que is loaded" do
+    it "defaults to the :que adapter" do
+      expect(MultiWorker.default_adapter).to eq(:que)
+    end
+  end
+
+  context "when using the :que adapter" do
+    before(:each) do
+      Que::Job.any_instance.stub(destroy: true)
+    end
+
+    it "forwards ::perform to #perform" do
+      expect_any_instance_of(TestWorker).to receive(:perform).once.with("foo")
+      TestWorker.perform("foo")
+    end
+
+    it "::perform_async performs the work using Que" do
+      expect_any_instance_of(TestWorker).to receive(:perform).once
+      TestWorker.perform_async("foo")
+    end
+
+    it "MultiWorker.enqueue performs the work using Que" do
+      expect_any_instance_of(TestWorker).to receive(:perform).once
+      MultiWorker.enqueue(TestWorker, "foo")
+    end
+
+    it "exposes the Que rake task" do
+      expect(MultiWorker.adapter.rake_task.name).to eq("que:work")
+    end
+  end
 end