sucker_punch 0.5.1 → 1.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfa065a0910c2a661bcf6e4b084d335e69d0eaf0
-  data.tar.gz: b7adbddd6cfef43dd535daa1e53be3e95361d663
+  metadata.gz: d30899558c37fb7f4f048e63520446ab0713746e
+  data.tar.gz: d1d3aa2d0e641b78b30c17fc49f48ddab368cbb9
 SHA512:
-  metadata.gz: 4f4e52fbf2fd0dadeaed1a6629f4b4d1a27bf46adbb9c96756b5001cdc8da32ea6a253f7851dabef5099874c6417373b40c2c6dbe9d848308d1d6c6c456cbc1d
-  data.tar.gz: 1a2dde0085716b865decb16a9c5933fa696fcd6e98269549133e0ec7e7b33773f35b277f098301ef981d05a779aff499d64d64739a898208aba4994c0af6b798
+  metadata.gz: 2568a1953bedf82b39675ce6a4d55ec0d60266aaf5c6e5c7203b0ccd6cab8d4bdd9a5e393a4badd9e3bc6a4e75e7e320c8657ce548828c617da2b2b755d1e292
+  data.tar.gz: 4b9355da76ac828677c9081330e64c48b9c85618f466c4b3149afc47233e3b163b2b9a7871dbb9b781efe3abd3eb8d00e67d83d7bf3161997dfebffc0c620391

data/CHANGES.md

@@ -1,3 +1,10 @@
+1.0.0.pre
+--------
+
+- Removed the need for a configuration initializer
+- include `SuckerPunch::Job` instead of `SuckerPunch::Worker`
+- Use standard Ruby job class instantiation to perform a job (ie. LogJob.new.async.perform)
+
 0.5.1
 --------
 

data/README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://travis-ci.org/brandonhilkert/sucker_punch.png?branch=master)](https://travis-ci.org/brandonhilkert/sucker_punch)
 [![Code Climate](https://codeclimate.com/github/brandonhilkert/sucker_punch.png)](https://codeclimate.com/github/brandonhilkert/sucker_punch)
 
-Sucker Punch is a single-process Ruby asynchronous processing library. It's [girl_friday](https://github.com/mperham/girl_friday) with syntax from [Sidekiq](https://github.com/mperham/sidekiq) and DSL sugar on top of [Celluloid](https://github.com/celluloid/celluloid/). With Celluloid's actor pattern, we can do asynchronous processing within a single process. This reduces costs of hosting on a service like Heroku along with the memory footprint of having to maintain additional workers if hosting on a dedicated server. All queues can run within a single Rails/Sinatra process.
+Sucker Punch is a single-process Ruby asynchronous processing library. It's [girl_friday](https://github.com/mperham/girl_friday)  and DSL sugar on top of [Celluloid](https://github.com/celluloid/celluloid/). With Celluloid's actor pattern, we can do asynchronous processing within a single process. This reduces costs of hosting on a service like Heroku along with the memory footprint of having to maintain additional jobs if hosting on a dedicated server. All queues can run within a single Rails/Sinatra process.
 
 Sucker Punch is perfect for asynchronous processes like emailing, data crunching, or social platform manipulation. No reason to hold up a user when you can do these things in the background within the same process as your web application...
 
@@ -21,25 +21,19 @@ Or install it yourself as:
 
     $ gem install sucker_punch
 
-## Configuration
+## Usage
 
+Each job should be a separate Ruby class and should:
 
-```Ruby
-# config/initializers/sucker_punch.rb
+* Add `include SuckerPunch::Job`
+* Define the instance method `perform`, which should be the code the job will run when enqueued
 
-SuckerPunch.config do
-  queue name: :log_queue, worker: LogWorker, workers: 10
-  queue name: :awesome_queue, worker: AwesomeWorker, workers: 2
-end
-```
-
-## Usage
 
 ```Ruby
-# app/workers/log_worker.rb
+# app/jobs/log_job.rb
 
-class LogWorker
-  include SuckerPunch::Worker
+class LogJob
+  include SuckerPunch::Job
 
   def perform(event)
     Log.new(event).track
@@ -47,16 +41,25 @@ class LogWorker
 end
 ```
 
-All workers should define an instance method `perform`, of which the job being queued will adhere to.
+Synchronous:
+
+```Ruby
+LogJob.new.perform("login")
+```
+
+Asynchronous:
 
-Workers interacting with `ActiveRecord` should take special precaution not to exhaust connections in the pool. This can be done with `ActiveRecord::Base.connection_pool.with_connection`, which ensures the connection is returned back to the pool when completed.
+```Ruby
+LogJob.new.async.perform("login") # => nil
+```
 
+Jobs interacting with `ActiveRecord` should take special precaution not to exhaust connections in the pool. This can be done with `ActiveRecord::Base.connection_pool.with_connection`, which ensures the connection is returned back to the pool when completed.
 
 ```Ruby
-# app/workers/awesome_worker.rb
+# app/jobs/awesome_job.rb
 
-class AwesomeWorker
-  include SuckerPunch::Worker
+class AwesomeJob
+  include SuckerPunch::Job
 
   def perform(user_id)
     ActiveRecord::Base.connection_pool.with_connection do
@@ -70,47 +73,19 @@ end
 We can create a job from within another job:
 
 ```Ruby
-class AwesomeWorker
-  include SuckerPunch::Worker
+class AwesomeJob
+  include SuckerPunch::Job
 
   def perform(user_id)
     ActiveRecord::Base.connection_pool.with_connection do
       user = User.find(user_id)
       user.update_attributes(is_awesome: true)
-      SuckerPunch::Queue[:log_queue].async.perform("User #{user.id} became awesome!")
+      LogJob.new.async.perform("User #{user.id} became awesome!")
     end
   end
 end
 ```
 
-Queues:
-
-```Ruby
-SuckerPunch::Queue[:log_queue] # Just a wrapper for the LogWorker class
-SuckerPunch::Queue.new(:log_queue)
-```
-
-Synchronous:
-
-```Ruby
-SuckerPunch::Queue[:log_queue].perform("login")
-```
-
-Asynchronous:
-
-```Ruby
-SuckerPunch::Queue[:log_queue].async.perform("login") # => nil
-```
-
-## Stats
-
-```Ruby
-SuckerPunch::Queue[:log_queue].workers # => 10
-SuckerPunch::Queue[:log_queue].size # => 23 # # of jobs enqueued
-SuckerPunch::Queue[:log_queue].busy_size # => 7
-SuckerPunch::Queue[:log_queue].idle_size # => 3
-```
-
 ## Logger
 
 ```Ruby
@@ -118,76 +93,24 @@ SuckerPunch.logger = Logger.new('sucker_punch')
 SuckerPunch.logger # => #<Logger:0x007fa1f28b83f0>
 ```
 
-If SuckerPunch is being within a Rails application, SuckerPunch's logger is set to Rails.logger.
-
-## Testing (Only 0.3.1+)
-
-```Ruby
-# spec/spec_helper.rb
-require 'sucker_punch/testing'
-```
-
-Requiring this library completely stubs out the internals of Sucker Punch, but will provide the necessary tools to confirm your jobs are being enqueud.
-
-```Ruby
-# spec/spec_helper.rb
-require 'sucker_punch/testing'
-
-RSpec.configure do |config|
-  config.after do
-    SuckerPunch.reset! # => Resets the queues and jobs in the queues before each test
-  end
-end
-
-# config/initializer/sucker_punch.rb
-SuckerPunch.config do
-  queue name: :email, worker: EmailWorker, workers: 2
-end
+If Sucker Punch is being used within a Rails application, Sucker Punch's logger is set to Rails.logger by default.
 
-# app/workers/email_worker.rb
-class EmailWorker
-  include SuckerPunch::Worker
+## Testing
 
-  def perform(email, user_id)
-    user = User.find(user_id)
-    UserMailer.send(email.to_sym, user)
-  end
-end
-
-# spec/models/user.rb
-class User < ActiveRecord::Base
-  def send_welcome_email
-    SuckerPunch::Queue.new(:email).async.perform(:welcome, self.id)
-  end
-end
-
-# spec/models/user_spec.rb
-require 'spec_helper'
-
-describe User do
-  describe "#send_welcome_email" do
-    user = FactoryGirl.create(:user)
-    expect{
-      user.send_welcome_email
-     }.to change{ SuckerPunch::Queue.new(:email).jobs.size }.by(1)
-  end
-end
-```
+Requiring this library causes your jobs to run everything inline. So a call to the following will actually be SYNCHRONOUS:
 
 ```Ruby
 # spec/spec_helper.rb
 require 'sucker_punch/testing/inline'
 ```
 
-Requiring this library causes your workers to run everything inline. So a call to the following will actually be SYNCHRONOUS.
-
 ```Ruby
-SuckerPunch::Queue[:log_queue].async.perform("login")
+Log.new.async.perform("login") # => Will be synchronous and block until job is finished
 ```
 
 ## Troubleshooting
 
-If you're running tests in transactions (using DatabaseCleaner or a native solution), Sucker Punch workers may have trouble finding database records that were created during test setup because the worker class is running in a separate thread and the Transaction operates on a different thread so it clears out the data before the worker can do its business. The best thing to do is cleanup data created for tests workers through a truncation strategy by tagging the rspec tests as workers and then specifying the strategy in `spec_helper` like below:
+If you're running tests in transactions (using DatabaseCleaner or a native solution), Sucker Punch jobs may have trouble finding database records that were created during test setup because the job class is running in a separate thread and the Transaction operates on a different thread so it clears out the data before the jojob can do its business. The best thing to do is cleanup data created for tests jobs through a truncation strategy by tagging the rspec tests as jobs and then specifying the strategy in `spec_helper` like below:
 
 ```Ruby
 # spec/spec_helper.rb
@@ -196,8 +119,8 @@ RSpec.configure do |config|
     DatabaseCleaner.strategy = :transaction
   end
 
-  # Clean up all worker specs with truncation
-  config.before(:each, :worker => true) do
+  # Clean up all jobs specs with truncation
+  config.before(:each, :job => true) do
     DatabaseCleaner.strategy = :truncation
   end
 
@@ -209,49 +132,23 @@ RSpec.configure do |config|
     DatabaseCleaner.clean
   end
 
-# spec/workers/email_worker_spec.rb
+# spec/jobs/email_job_spec.rb
 require 'spec_helper'
 
-# Tag the spec as a worker spec so data is persisted long enough for the test
-describe EmailWorker, worker: true do
+# Tag the spec as a job spec so data is persisted long enough for the test
+describe EmailJob, job: true do
   describe "#perform" do
     let(:user) { FactoryGirl.create(:user) }
 
     it "delivers an email" do
       expect {
-        EmailWorker.new.perform(user.id)
+        EmailJob.new.perform(user.id)
       }.to change{ ActionMailer::Base.deliveries.size }.by(1)
     end
   end
 end
 ```
 
-When using Passenger or Unicorn, you should configure the queues within a block that runs after the child process is forked.
-
-```Ruby
-# config/unicorn.rb
-#
-# The following is only need if in your unicorn config
-# you set:
-# preload_app true
-after_fork do |server, worker|
-  SuckerPunch.config do
-    queue name: :log_queue, worker: LogWorker, workers: 10
-  end
-end
-```
-```Ruby
-# config/initializers/sucker_punch.rb
-#
-if defined?(PhusionPassenger)
-  PhusionPassenger.on_event(:starting_worker_process) do |forked|
-    SuckerPunch.config do
-      queue name: :log_queue, worker: LogWorker, workers: 10
-    end
-  end
-end
-```
-
 ## Gem Name
 
 ...is awesome. But I can't take credit for it. Thanks to [@jmazzi](https://twitter.com/jmazzi) for his superior naming skills. If you're looking for a name for something, he is the one to go to.

data/lib/sucker_punch.rb

@@ -1,26 +1,11 @@
 require 'celluloid'
-require 'sucker_punch/exceptions'
+require 'sucker_punch/core_ext'
+require 'sucker_punch/job'
 require 'sucker_punch/queue'
-require 'sucker_punch/worker'
+require 'sucker_punch/queues'
 require 'sucker_punch/version'
 
 module SuckerPunch
-  def self.config(&block)
-    instance_eval &block
-  end
-
-  def self.queue(options = {})
-    raise MissingQueueName unless options[:name]
-    raise MissingWorkerName unless options[:worker]
-
-    klass = options.fetch(:worker)
-    registry_name = options.fetch(:name)
-    workers = options.fetch(:workers, nil)
-
-    q = Queue.new(registry_name)
-    q.register(klass, workers)
-  end
-
   def self.logger
     Celluloid.logger
   end

data/lib/sucker_punch/core_ext.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end if !defined?(::ActiveSupport) && !"".respond_to?(:underscore)

data/lib/sucker_punch/job.rb

@@ -0,0 +1,21 @@
+module SuckerPunch
+  module Job
+    def self.included(base)
+      base.send(:include, ::Celluloid)
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        def self.new
+          define_celluloid_pool(self)
+        end
+      end
+    end
+
+    module ClassMethods
+      def define_celluloid_pool(klass)
+        SuckerPunch::Queue.new(klass).register
+      end
+    end
+
+  end
+end

data/lib/sucker_punch/queue.rb

@@ -1,36 +1,54 @@
+require 'thread'
+
 module SuckerPunch
   class Queue
-    attr_reader :name
+    attr_reader :klass
+    attr_accessor :pool
+
+    def self.find(klass)
+      queue = self.new(klass)
+      Celluloid::Actor[queue.name]
+    end
+
+    def initialize(klass)
+      @klass = klass
+      @pool = nil
+      @mutex = Mutex.new
+    end
 
-    def initialize(name)
-      @name = name
+    def register
+      @mutex.synchronize {
+        unless registered?
+          initialize_celluloid_pool
+          register_celluloid_pool
+          register_queue_with_master_list
+        end
+      }
+      self.class.find(klass)
     end
 
-    def self.[](name)
-      Celluloid::Actor[name]
+    def registered?
+      SuckerPunch::Queues.all.include?(name)
     end
 
-    def register(klass, size)
-      opts = {}
-      opts[:size] = size if size
-      Celluloid::Actor[name] = klass.send(:pool, opts)
+    def name
+      klass.to_s.underscore.to_sym
     end
 
-    # Equivalent to size of the Celluloid Pool
-    # However, in context of a "queue" workers
-    # makes more sense here
-    def workers
-      Celluloid::Actor[name].size
+    private
+
+    def initialize_celluloid_pool
+      self.pool = klass.send(:pool)
     end
 
-    # Equivalent to number of messages queued
-    # in the Celluloid mailbox
-    def size
-      Celluloid::Actor[name].mailbox.size
+    def register_celluloid_pool
+      Celluloid::Actor[name] = pool
     end
 
-    def method_missing(method_name, *args, &block)
-      Celluloid::Actor[name].send(method_name, *args, &block)
+    def register_queue_with_master_list
+      SuckerPunch::Queues.register(name)
     end
   end
 end
+
+

data/lib/sucker_punch/queues.rb

@@ -0,0 +1,14 @@
+module SuckerPunch
+  class Queues
+    @queues = Set.new
+
+    def self.all
+      @queues.to_a
+    end
+
+    def self.register(name)
+      @queues.add(name)
+    end
+  end
+end
+

data/lib/sucker_punch/testing/inline.rb

@@ -5,4 +5,3 @@ module Celluloid
     end
   end
 end
-

data/lib/sucker_punch/version.rb

@@ -1,3 +1,3 @@
 module SuckerPunch
-  VERSION = "0.5.1"
+  VERSION = "1.0.0.beta"
 end

data/spec/spec_helper.rb

@@ -4,3 +4,10 @@ rescue LoadError
 end
 
 require 'sucker_punch'
+
+RSpec.configure do |config|
+  config.after(:each) do
+    # Clean up the master queue list
+    SuckerPunch::Queues.instance_variable_set(:@queues, Set.new)
+  end
+end

data/spec/sucker_punch/core_ext_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe "Core extensions" do
+  describe String do
+    before :each do
+      class FakeQueue; end
+    end
+
+    it "underscores a class name" do
+      expect(FakeQueue.to_s.underscore).to eq("fake_queue")
+    end
+  end
+end

data/spec/sucker_punch/job_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe SuckerPunch::Job do
+  before :each do
+    class ::FakeJob
+      include SuckerPunch::Job
+
+      def perform(name)
+        "response #{name}"
+      end
+    end
+  end
+
+  it "includes Celluloid into requesting class when included" do
+    FakeJob.should respond_to(:pool)
+  end
+
+  describe "#perform" do
+    context "when pool hasn't been created" do
+      it "creates pool and registers queue" do
+        expect(Celluloid::Actor[:fake_job]).to eq(nil)
+        expect(SuckerPunch::Queues.all).to eq([])
+
+        # Don't use #async here b/c of a race condition
+        # The expectation will run before the asynchronous
+        # job is executed
+        FakeJob.new.perform("test")
+
+        expect(Celluloid::Actor[:fake_job]).to be
+        expect(SuckerPunch::Queues.all).to eq([:fake_job])
+      end
+    end
+  end
+end

data/spec/sucker_punch/queue_spec.rb

@@ -1,53 +1,53 @@
 require 'spec_helper'
 
-class FakeWorker
-  include Celluloid
-end
-
 describe SuckerPunch::Queue do
-  describe ".[]" do
-    it "delegates to Celluloid" do
-      Celluloid::Actor[:fake] = FakeWorker.pool
-      Celluloid::Actor.should_receive(:[]).with(:fake)
-      SuckerPunch::Queue[:fake]
+  before :each do
+    class ::FakeJob
+      include SuckerPunch::Job
+
+      def perform(name)
+        "response #{name}"
+      end
     end
   end
 
-  describe "#register" do
-    before(:each) do
-      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 2)
+  describe "#find" do
+    it "returns the Celluloid Actor from the registry" do
+      SuckerPunch::Queue.new(FakeJob).register
+      queue = SuckerPunch::Queue.find(FakeJob)
+      queue.class == Celluloid::PoolManager
     end
+  end
 
-    it "turns the class into an actor" do
-      Celluloid::Actor[:crazy_queue].should be_a(Celluloid)
-      Celluloid::Actor[:crazy_queue].should be_a(FakeWorker)
-      Celluloid::Actor[:crazy_queue].methods.should include(:async)
+  describe "#register" do
+    let(:job) { FakeJob }
+    let(:queue) { SuckerPunch::Queue.new(job) }
+
+    it "initializes a celluloid pool" do
+      queue.register
+      expect(queue.pool.class).to eq(Celluloid::PoolManager)
     end
 
-    it "sets worker size" do
-      Celluloid::Actor[:crazy_queue].size.should == 2
+    it "registers the pool with Celluloid" do
+      pool = queue.register
+      expect(Celluloid::Actor[:fake_job]).to eq(pool)
     end
-  end
 
-  describe "#workers" do
-    it "returns number of workers" do
-      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 2)
-      SuckerPunch::Queue.new(:crazy_queue).workers.should == 2
+    it "registers with master list of queues" do
+      queue.register
+      queues = SuckerPunch::Queues.all
+      expect(queues.size).to be(1)
     end
   end
 
-  describe "delegation" do
-    let(:queue) { SuckerPunch::Queue.new(:crazy_queue) }
+  describe "#registered?" do
+    it "returns true if queue has already been registered" do
+      queue = SuckerPunch::Queue.new(FakeJob)
 
-    before(:each) do
-      SuckerPunch::Queue.new(:crazy_queue).register(FakeWorker, 2)
-    end
-
-    it "sends messages to Actor" do
-      queue.workers.should == 2
-      queue.idle_size.should == 2
-      queue.busy_size.should == 0
-      queue.size.should == 0
+      expect{
+        queue.register
+      }.to change{ queue.registered? }.from(false).to(true)
     end
   end
 end
+

data/spec/sucker_punch/queues_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe SuckerPunch::Queues do
+  describe "queue registration and querying" do
+    it "adds a queue to the master queue list" do
+      SuckerPunch::Queues.register(:fake)
+      expect(SuckerPunch::Queues.all).to eq([:fake])
+    end
+  end
+
+  describe ".registered?" do
+    it "returns true if queue has already been registered" do
+      SuckerPunch::Queues.register(:fake)
+      expect{ SuckerPunch::Queues.registered?(:fake) }.to be_true
+    end
+  end
+end

data/spec/sucker_punch/testing/inline_spec.rb

@@ -1,20 +1,18 @@
 require 'spec_helper'
 require_relative '../../../lib/sucker_punch/testing/inline'
 
-class PatchedWorker
-  include SuckerPunch::Worker
-
-  def perform
-    "do stuff"
-  end
-end
-SuckerPunch::Queue.new(:patched_queue).register(PatchedWorker, 2)
-
 describe "SuckerPunch Inline Testing" do
-  let(:queue) { SuckerPunch::Queue.new(:patched_queue) }
+  before :each do
+    class PatchedJob
+      def perform
+        "do stuff"
+      end
+      include SuckerPunch::Job
+    end
+  end
 
   it "processes jobs inline" do
-    job = queue.async.perform
+    job = PatchedJob.new.async.perform
     expect(job).to eq "do stuff"
   end
 end

data/spec/sucker_punch_spec.rb

@@ -1,44 +1,6 @@
 require 'spec_helper'
 
-class FakeWorker
-  include Celluloid
-end
-
 describe SuckerPunch do
-  context "config" do
-
-    context "properly configured" do
-      it "registers the queue" do
-        SuckerPunch::Queue.any_instance.should_receive(:register).with(FakeWorker, 3)
-
-        SuckerPunch.config do
-          queue name: :crazy_queue, worker: FakeWorker, workers: 3
-        end
-      end
-    end
-
-    context "with no queue name" do
-      it "raises an exception" do
-        expect {
-          SuckerPunch.config do
-            queue worker: FakeWorker
-          end
-        }.to raise_error(SuckerPunch::MissingQueueName)
-      end
-    end
-
-    context "with no worker name" do
-      it "raises an exception" do
-        expect {
-          SuckerPunch.config do
-            queue name: :fake
-          end
-        }.to raise_error(SuckerPunch::MissingWorkerName)
-      end
-    end
-
-  end
-
   describe 'logger' do
     it "delegates get to Celluloid's logger" do
       SuckerPunch.logger.should == Celluloid.logger

data/sucker_punch.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "rake"
+  gem.add_development_dependency "pry"
 
   gem.add_dependency "celluloid", "~> 0.14.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sucker_punch
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 1.0.0.beta
 platform: ruby
 authors:
 - Brandon Hilkert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-14 00:00:00.000000000 Z
+date: 2013-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
 - !ruby/object:Gem::Dependency
   name: celluloid
   requirement: !ruby/object:Gem::Requirement
@@ -67,18 +81,19 @@ files:
 - README.md
 - Rakefile
 - lib/sucker_punch.rb
-- lib/sucker_punch/exceptions.rb
+- lib/sucker_punch/core_ext.rb
+- lib/sucker_punch/job.rb
 - lib/sucker_punch/queue.rb
+- lib/sucker_punch/queues.rb
 - lib/sucker_punch/railtie.rb
-- lib/sucker_punch/testing.rb
 - lib/sucker_punch/testing/inline.rb
 - lib/sucker_punch/version.rb
-- lib/sucker_punch/worker.rb
 - spec/spec_helper.rb
+- spec/sucker_punch/core_ext_spec.rb
+- spec/sucker_punch/job_spec.rb
 - spec/sucker_punch/queue_spec.rb
+- spec/sucker_punch/queues_spec.rb
 - spec/sucker_punch/testing/inline_spec.rb
-- spec/sucker_punch/testing_spec.rb
-- spec/sucker_punch/worker_spec.rb
 - spec/sucker_punch_spec.rb
 - sucker_punch.gemspec
 homepage: https://github.com/brandonhilkert/sucker_punch
@@ -95,9 +110,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.2
@@ -107,8 +122,9 @@ summary: Sucker Punch is a Ruby asynchronous processing using Celluloid, heavily
   by Sidekiq and girl_friday.
 test_files:
 - spec/spec_helper.rb
+- spec/sucker_punch/core_ext_spec.rb
+- spec/sucker_punch/job_spec.rb
 - spec/sucker_punch/queue_spec.rb
+- spec/sucker_punch/queues_spec.rb
 - spec/sucker_punch/testing/inline_spec.rb
-- spec/sucker_punch/testing_spec.rb
-- spec/sucker_punch/worker_spec.rb
 - spec/sucker_punch_spec.rb

data/lib/sucker_punch/exceptions.rb

@@ -1,5 +0,0 @@
-module SuckerPunch
-  class Error < StandardError; end
-  class MissingQueueName < Error; end
-  class MissingWorkerName < Error; end
-end

data/lib/sucker_punch/testing.rb

@@ -1,44 +0,0 @@
-module SuckerPunch
-  class << self
-    attr_accessor :queues
-
-    def reset!
-      self.queues = {}
-    end
-  end
-
-  SuckerPunch.reset!
-
-  class Queue
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
-      SuckerPunch.queues[name] ||= []
-    end
-
-    def self.[](name)
-      new(name)
-    end
-
-    def register(klass, size)
-      nil
-    end
-
-    def workers
-      raise "Not implemented"
-    end
-
-    def jobs
-      SuckerPunch.queues[@name]
-    end
-
-    def async
-      self
-    end
-
-    def method_missing(name, *args, &block)
-      SuckerPunch.queues[@name] << { method: name, args: Array(args) }
-    end
-  end
-end

data/lib/sucker_punch/worker.rb

@@ -1,7 +0,0 @@
-module SuckerPunch
-  module Worker
-    def self.included(base)
-      base.send :include, ::Celluloid
-    end
-  end
-end

data/spec/sucker_punch/testing_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-class TestingWorker
-  include Celluloid
-
-  def perform(input)
-    input = "after"
-  end
-end
-
-SuckerPunch.config do
-  queue name: :queue, worker: TestingWorker
-end
-
-describe "SuckerPunch Testing" do
-  before :each do
-    require_relative '../../lib/sucker_punch/testing'
-    SuckerPunch.reset!
-  end
-
-  describe ".reset!" do
-    it "resets the queues to be empty" do
-      4.times { SuckerPunch::Queue.new(:queue).async.perform("before") }
-      SuckerPunch.reset!
-      queue = SuckerPunch::Queue.new(:queue)
-      expect(queue.jobs.count).to eq 0
-    end
-  end
-
-  describe Queue do
-    it "returns previous instance when queried again" do
-      queue = SuckerPunch::Queue.new(:queue)
-      queue.async.perform("before")
-      expect(SuckerPunch::Queue.new(:queue).jobs.count).to eq 1
-    end
-
-    describe ".[]" do
-      it "returns the queue instance" do
-        queue = SuckerPunch::Queue.new(:queue)
-        queue.async.perform("before")
-        expect(SuckerPunch::Queue[:queue].jobs.count).to eq 1
-      end
-    end
-
-    describe "#register" do
-      it "returns nil" do
-        queue = SuckerPunch::Queue.new(:queue)
-        expect(queue.register(TestingWorker, 3)).to eq nil
-      end
-    end
-
-    describe "#workers" do
-      it "raises an exception if called" do
-        queue = SuckerPunch::Queue.new(:queue)
-        expect{ queue.workers }.to raise_error "Not implemented"
-      end
-    end
-
-    describe "#jobs" do
-      it "returns an array of the jobs in the queue" do
-        queue = SuckerPunch::Queue.new(:queue)
-        queue.async.perform("before")
-        expect(queue.jobs).to eq [{ method: :perform, args: ["before"] }]
-      end
-
-      it "returns the number of jobs in the queue" do
-        queue = SuckerPunch::Queue.new(:queue)
-        4.times { queue.async.perform("before") }
-        expect(queue.jobs.count).to eq 4
-      end
-    end
-
-    describe "#async" do
-      it "returns self" do
-        queue = SuckerPunch::Queue.new(:queue)
-        expect(queue.async).to eq queue
-      end
-    end
-
-    describe "enqueueing a job" do
-      it "adds the job to the queue" do
-        queue = SuckerPunch::Queue.new(:queue)
-        queue.async.perform("before")
-        expect(queue.jobs).to eq [{ method: :perform, args: ["before"] }]
-      end
-    end
-  end
-end

data/spec/sucker_punch/worker_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-class FakeWorker
-  include SuckerPunch::Worker
-
-  def perform
-    puts "do stuff"
-  end
-end
-
-describe SuckerPunch::Worker do
-  it "should include Celluloid into requesting class when included" do
-    FakeWorker.should respond_to(:pool)
-  end
-end