quebert 0.0.4 → 0.0.6

data/Gemfile

@@ -9,4 +9,5 @@ group :test do
   gem 'ruby-debug'
   gem 'activerecord'
   gem 'sqlite3-ruby'
+  gem 'autotest-fsevent'
 end

data/README.rdoc

@@ -6,12 +6,15 @@ A worker queue framework designed around Beanstalk. Features include:
 
 = Features
 
-* [x] Multiple back-ends (InProcess, Sync, and Beanstalk)
-* [ ] Rails/ActiveRecord integration similar to async_observer
-* [ ] Pluggable exception handling (for Hoptoad integration)
-* [ ] Reliable daemonization with pidfile support
+* Multiple back-ends (InProcess, Sync, and Beanstalk)
+* Rails/ActiveRecord integration similar to async_observer
+* Pluggable exception handling (for Hoptoad integration)
+* Run workers with pid, log, and config files. These do not daemonize (do it yourself punk!)
 
-  [x] = Completed, [ ] = Not Started
+Some features that are currently missing that I will soon add include:
+
+* Rails plugin support (The AR integrations have to be done manually today)
+* Auto-detecting serializers. Enhanced ClassRegistry to more efficiently look up serializers for objects.
 
 = How to use
 
@@ -31,11 +34,11 @@ Quebert includes a Job class so you can implement how you want certain types of
 
 You can either drop a job in a queue:
 
-    Quebert.backend.put WackyMathWizard, 1, 2, 3
+    Quebert.backend.put WackyMathWizard.new(1, 2, 3)
 
 Or drop it in right from the job:
 
-    WackyMathWizard.enqueue 4, 5, 6
+    WackyMathWizard.new(4, 5, 6).enqueue
 
 Then perform the jobs!
 

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.6

data/lib/quebert.rb

@@ -1,7 +1,8 @@
 module Quebert
+  autoload :Serializer,         'quebert/serializer'
   autoload :Configuration,      'quebert/configuration'
   autoload :Job,                'quebert/job'
-  autoload :Consumer,           'quebert/consumer'
+  autoload :Controller,         'quebert/controller'
   autoload :Backend,            'quebert/backend'
   autoload :Support,            'quebert/support'
   autoload :Worker,             'quebert/worker'
@@ -19,6 +20,10 @@ module Quebert
       @backends ||= Support::Registry.new
     end
     
+    def serializers
+      @serializers ||= Support::ClassRegistry.new
+    end
+    
     # Make this easier for elsewhere in the app
     def logger
       config.logger
@@ -26,7 +31,7 @@ module Quebert
   end
   
   # Register built-in Quebert backends
-  Quebert.backends.register :beanstalk,  Backend::Beanstalk
-  Quebert.backends.register :in_process, Backend::InProcess
-  Quebert.backends.register :sync,       Backend::Sync
+  Quebert.backends.register :beanstalk,       Backend::Beanstalk
+  Quebert.backends.register :in_process,      Backend::InProcess
+  Quebert.backends.register :sync,            Backend::Sync
 end

data/lib/quebert/async_sender/active_record.rb

@@ -1,59 +1,26 @@
 module Quebert
   module AsyncSender
+    
     # I'm not sure if I want to do this or build serializers per type of object...
     module ActiveRecord
-      # Reference an AR with the pk
-      class PersistedRecordJob < Job
-        def perform(model_name, pk, meth, args)
-          Support.constantize(model_name).find(pk).send(meth, *args)
-        end
-      end
-      
-      # Serialize an unpersisted AR with the attributes on the thing.
-      class UnpersistedRecordJob < Job
-        def perform(model_name, attrs, meth, args)
-          self.class.deserialize(Support.constantize(model_name), attrs).send(meth, *args)
-        end
-        
-        # Deal with converting an AR to/from a hash that we can send over the wire.
-        def self.serialize(record)
-          record.attributes.inject({}) do |hash, (attr, val)|
-            hash[attr] = val
-            hash
-          end
-        end
-        
-        def self.deserialize(model, attrs)
-          record = model.new
-          record.attributes.each do |attr, val|
-            record.send("#{attr}=", attrs[attr])
-          end
-          record
+      class RecordJob < Job
+        def perform(record, meth, args)
+          record.send(meth, *args)
         end
       end
       
       def self.included(base)
         base.send(:include, InstanceMethods)
-        base.send(:extend, ClassMethods)
+        base.send(:include, AsyncSender::Object)
       end
       
       module InstanceMethods
         # The meat of dealing with ActiveRecord instances.
         def async_send(meth, *args)
-          if self.new_record?
-            UnpersistedRecordJob.enqueue(self.class.model_name, UnpersistedRecordJob.serialize(self), meth, args)
-          else
-            PersistedRecordJob.enqueue(self.class.model_name, id, meth, args)
-          end
-        end
-      end
-      
-      # Get the model name of the Model. Can't just do class.name on this...
-      module ClassMethods
-        def async_send(meth, *args)
-          Object::ObjectJob.enqueue(self.model_name, meth, args)
+          RecordJob.new(self, meth, args).enqueue
         end
       end
     end
+    
   end
 end

data/lib/quebert/async_sender/instance.rb

@@ -44,7 +44,7 @@ module Quebert
       end
       
       def async_send(meth, *args)
-        InstanceJob.enqueue(self.class.name, @_init_args, meth, args)
+        InstanceJob.new(self.class.name, @_init_args, meth, args).enqueue
       end
     end
   end

data/lib/quebert/async_sender/object.rb

@@ -14,7 +14,7 @@ module Quebert
       
       module ClassMethods
         def async_send(meth, *args)
-          ObjectJob.enqueue(self.name, meth, args)
+          ObjectJob.new(self.name, meth, args).enqueue
         end
       end
     end

data/lib/quebert/backend/beanstalk.rb

@@ -5,24 +5,24 @@ module Quebert
     
     # Manage jobs on a Beanstalk queue out of process
     class Beanstalk < Beanstalk::Pool
-      def put(job, *args)
-        super Job.to_json(job, *args)
+      def put(job)
+        super job.to_json
       end
       
-      def reserve_with_consumer
-        Consumer::Beanstalk.new(reserve_without_consumer, self)
+      def reserve_with_controller
+        Controller::Beanstalk.new(reserve_without_controller, self)
       end
-      alias :reserve_without_consumer :reserve
-      alias :reserve :reserve_with_consumer
+      alias :reserve_without_controller :reserve
+      alias :reserve :reserve_with_controller
       
       # For testing purposes... I think there's a better way to do this though.
       def drain!
         while peek_ready do
-          reserve_without_consumer.delete
+          reserve_without_controller.delete
         end
         while job = peek_buried do
           last_conn.kick 1 # what? Why the 1? it kicks them all?
-          reserve_without_consumer.delete
+          reserve_without_controller.delete
         end
       end
       

data/lib/quebert/backend/in_process.rb

@@ -2,12 +2,12 @@ module Quebert
   module Backend
     # Drops jobs on an array in-process.
     class InProcess < Array
-      def put(job, *args)
-        unshift Job.to_json(job, *args)
+      def put(job)
+        unshift job.to_json
       end
       
       def reserve
-        json = pop and Consumer::Base.new(Job.from_json(json))
+        json = pop and Controller::Base.new(Job.from_json(json))
       end
     end
   end

data/lib/quebert/backend/sync.rb

@@ -4,7 +4,7 @@ module Quebert
     # or could be used as a fallback if other backends fail to initialize
     class Sync
       def put(job, *args)
-        Consumer::Base.new(job.new(args)).perform
+        Controller::Base.new(job).perform
       end
     end
   end

data/lib/quebert/{consumer.rb → controller.rb}

@@ -2,8 +2,8 @@ module Quebert
   # The basic glue between a job and the specific queue implementation. This
   # handles exceptions that may be thrown by the Job and how the Job should
   # be put back on the queue, if at all.
-  module Consumer
-    autoload :Base,       'quebert/consumer/base'
-    autoload :Beanstalk,  'quebert/consumer/beanstalk'
+  module Controller
+    autoload :Base,       'quebert/controller/base'
+    autoload :Beanstalk,  'quebert/controller/beanstalk'
   end
 end

data/lib/quebert/{consumer → controller}/base.rb

@@ -1,6 +1,6 @@
 module Quebert
-  module Consumer
-    # The most Consumer. Doesn't even accept the queue as an argument because there's nothing
+  module Controller
+    # The most Controller. Doesn't even accept the queue as an argument because there's nothing
     # a job can do to be rescheduled, etc.
     class Base
       attr_reader :job
@@ -11,7 +11,7 @@ module Quebert
       
       def perform
         begin
-          job.perform(*job.args)
+          job.perform!
         rescue Job::Action
           # Nothing to do chief!
         end

data/lib/quebert/{consumer → controller}/beanstalk.rb

@@ -1,5 +1,5 @@
 module Quebert
-  module Consumer
+  module Controller
     # Handle interactions between a job and a Beanstalk queue.
     class Beanstalk < Base
       attr_reader :beanstalk_job, :queue, :job
@@ -11,7 +11,7 @@ module Quebert
       
       def perform
         begin
-          result = job.perform(*job.args)
+          result = job.perform!
           beanstalk_job.delete
           result
         rescue Job::Delete

data/lib/quebert/job.rb

@@ -12,7 +12,7 @@ module Quebert
     Delete  = Class.new(Action)
     Release = Class.new(Action)
     
-    def initialize(args=[])
+    def initialize(*args)
       @args = args.dup.freeze
     end
     
@@ -20,22 +20,22 @@ module Quebert
       raise NotImplemented
     end
     
-    def self.enqueue(*args)
-      backend.put(self, *args)
+    # Runs the perform method that somebody else should be implementing
+    def perform!
+      perform(*args)
     end
     
-    def to_json
-      self.class.to_json(self)
+    def enqueue
+      self.class.backend.put self
     end
     
-    def self.to_json(job, *args)
-      args, job = job.args, job.class if job.respond_to?(:args)
-      JSON.generate('job' => job.name, 'args' => args)
+    def to_json
+      JSON.generate(Serializer::Job.serialize(self))
     end
     
     def self.from_json(json)
-      if data = JSON.parse(json)
-        Support.constantize(data['job']).new(data['args'])
+      if hash = JSON.parse(json) and not hash.empty?
+        Serializer::Job.deserialize(hash)
       end
     end
     

data/lib/quebert/serializer.rb

@@ -0,0 +1,79 @@
+module Quebert
+  module Serializer
+    
+    # Does this mean you could queue a job that could queue a job? Whoa!
+    class Job
+      def self.serialize(job)
+        {
+          'job' => job.class.name,
+          'args' => serialize_args(job.args)
+        }
+      end
+      
+      def self.deserialize(hash)
+        hash = Support.stringify_keys(hash)
+        Support.constantize(hash['job']).new(*deserialize_args(hash['args']))
+      end
+      
+    private
+    
+      # Reflect on each arg and see if it has a seralizer
+      def self.serialize_args(args)
+        args.map do |arg|
+          hash = Hash.new
+          if serializer = Quebert.serializers[arg.class]
+            hash['serializer'] = serializer.name
+            hash['payload'] = serializer.serialize(arg)
+          else
+            hash['payload'] = arg
+          end
+          hash
+        end
+      end
+      
+      # Find a serializer and/or push out a value
+      def self.deserialize_args(args)
+        args.map do |arg|
+          arg = Support.stringify_keys(arg)
+          if arg.key? 'serializer' and serializer = Support.constantize(arg['serializer'])
+            serializer.deserialize(arg['payload'])
+          else
+            arg['payload']
+          end
+        end
+      end
+    end
+    
+    # Deal with converting an AR to/from a hash that we can send over the wire.
+    class ActiveRecord
+      def self.serialize(record)
+        attrs = record.attributes.inject({}) do |hash, (attr, val)|
+          hash[attr] = val
+          hash
+        end
+        { 'model' => record.class.model_name, 'attributes' => attrs }
+      end
+      
+      def self.deserialize(hash)
+        hash = Support.stringify_keys(hash)
+        model = Support.constantize(hash.delete('model'))
+        if attrs = Support.stringify_keys(hash.delete('attributes'))
+          if id = hash.delete('id')
+            # This has been persisited, so just find it from the db
+            model.find(id)
+          else
+            # Looks like its not around! Better generate it from attributes
+            record = model.new
+            record.attributes.each do |attr, val|
+              record.send("#{attr}=", attrs[attr])
+            end
+            record
+          end
+        else
+          model.new
+        end
+      end
+    end
+    
+  end
+end

data/lib/quebert/support.rb

@@ -6,9 +6,9 @@ module Quebert
     
     # Borrowed from Rails ActiveSupport
     def self.constantize(camel_cased_word) #:nodoc:
-      names = camel_cased_word.split('::')
+      names = camel_cased_word.to_s.split('::')
       names.shift if names.empty? || names.first.empty?
-
+      
       constant = Object
       names.each do |name|
         constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)

data/lib/quebert/support/registry.rb

@@ -9,5 +9,24 @@ module Quebert
         self.delete(key.to_sym)
       end
     end
+    
+    # Stores classes at retreives a key for class and subclasses.
+    # TODO 
+    #   * make this thing match on most specific subclass
+    class ClassRegistry < Registry
+      # Returns a class from a given instance
+      def[](key)
+        case key
+        when Class
+          # Find the class key based on the class or subclass of the incoming key/klass
+          if klass = keys.map{|klass| Support.constantize(klass) }.find{|k| k >= key}
+            # If we find a matching class/subclass then pull this out
+            super klass.name.to_sym
+          end
+        else
+          super
+        end
+      end
+    end
   end
 end

data/lib/quebert/worker.rb

@@ -10,19 +10,26 @@ module Quebert
     
     # Start the worker backend and intercept exceptions if a handler is provided
     def start
+      Signal.trap('TERM'){ stop }
+      
       logger.info "Worker pid##{Process.pid} started with #{backend.class.name} backend"
-      while consumer = backend.reserve do
+      while controller = backend.reserve do
         begin
-          log consumer.job, "performing with args #{consumer.job.args.inspect}"
-          consumer.perform
-          log consumer.job, "complete"
+          log controller.job, "performing with args #{controller.job.args.inspect}"
+          controller.perform
+          log controller.job, "complete"
         rescue Exception => e
-          log consumer.job, "fault #{e}", :error
+          log controller.job, "fault #{e}", :error
           exception_handler ? exception_handler.call(e) : raise(e)
         end
       end
     end
     
+    def stop
+      logger.info "Worker pid##{Process.pid} stopping"
+      exit 0
+    end
+    
   protected
     # Setup a bunch of stuff with Quebert config defaults the we can override later.
     def logger

data/quebert.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{quebert}
-  s.version = "0.0.4"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brad Gessler"]
-  s.date = %q{2010-10-05}
+  s.date = %q{2010-10-11}
   s.default_executable = %q{quebert}
   s.description = %q{A worker queue framework built around beanstalkd}
   s.email = %q{brad@bradgessler.com}
@@ -39,10 +39,11 @@ Gem::Specification.new do |s|
      "lib/quebert/backend/sync.rb",
      "lib/quebert/command_line_runner.rb",
      "lib/quebert/configuration.rb",
-     "lib/quebert/consumer.rb",
-     "lib/quebert/consumer/base.rb",
-     "lib/quebert/consumer/beanstalk.rb",
+     "lib/quebert/controller.rb",
+     "lib/quebert/controller/base.rb",
+     "lib/quebert/controller/beanstalk.rb",
      "lib/quebert/job.rb",
+     "lib/quebert/serializer.rb",
      "lib/quebert/support.rb",
      "lib/quebert/support/pid_file.rb",
      "lib/quebert/support/registry.rb",
@@ -54,10 +55,13 @@ Gem::Specification.new do |s|
      "spec/configuration_spec.rb",
      "spec/consumer_spec.rb",
      "spec/job_spec.rb",
-     "spec/jobs.rb",
      "spec/quebert_spec.rb",
+     "spec/serializer_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
+     "spec/support/active_record.rb",
+     "spec/support/jobs.rb",
+     "spec/support_spec.rb",
      "spec/worker_spec.rb"
   ]
   s.homepage = %q{http://github.com/bradgessler/quebert}
@@ -72,9 +76,12 @@ Gem::Specification.new do |s|
      "spec/configuration_spec.rb",
      "spec/consumer_spec.rb",
      "spec/job_spec.rb",
-     "spec/jobs.rb",
      "spec/quebert_spec.rb",
+     "spec/serializer_spec.rb",
      "spec/spec_helper.rb",
+     "spec/support/active_record.rb",
+     "spec/support/jobs.rb",
+     "spec/support_spec.rb",
      "spec/worker_spec.rb"
   ]
 

data/spec/async_sender_spec.rb

@@ -1,10 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'active_record'
 
 describe AsyncSender::Class do
   
   before(:all) do
-    @q = Backend::InProcess.new
+    @q = Quebert::Backend::InProcess.new
     Quebert::AsyncSender::Object::ObjectJob.backend = @q
     Quebert::AsyncSender::Instance::InstanceJob.backend = @q
   end
@@ -39,38 +38,18 @@ end
 
 describe AsyncSender::ActiveRecord do
   
-  ActiveRecord::Base.establish_connection({
-    :adapter => 'sqlite3',
-    :database => ':memory:'
-  })
-  
-  ActiveRecord::Schema.define do
-    create_table "users", :force => true do |t|
-      t.column "first_name",  :text
-      t.column "last_name",  :text
-      t.column "email", :text
-    end
-  end
-  
-  class User < ActiveRecord::Base
-    include Quebert::AsyncSender::ActiveRecord
-    
-    def name
-      "#{first_name} #{last_name}"
-    end
-    
-    def self.emailizer(address)
-      address
-    end
-  end
-  
   before(:all) do
+    Quebert.serializers.register :'ActiveRecord::Base', Serializer::ActiveRecord
+    
     @q = Backend::InProcess.new
-    Quebert::AsyncSender::ActiveRecord::PersistedRecordJob.backend = @q
-    Quebert::AsyncSender::ActiveRecord::UnpersistedRecordJob.backend = @q
+    Quebert::AsyncSender::ActiveRecord::RecordJob.backend = @q
     Quebert::AsyncSender::Object::ObjectJob.backend = @q
   end
   
+  after(:all) do
+    Quebert.serializers.unregister :'ActiveRecord::Base'
+  end
+  
   context "persisted" do
     before(:each) do
       @user = User.create!(:first_name => 'Brad', :last_name => 'Gessler', :email => 'brad@bradgessler.com')
@@ -99,4 +78,5 @@ describe AsyncSender::ActiveRecord do
     User.async_send(:emailizer, email)
     @q.reserve.perform.should eql(email)
   end
+  
 end

data/spec/backend_spec.rb

@@ -23,7 +23,7 @@ describe Backend::InProcess do
   
   it "should put on queue" do
     3.times do |num|
-      @q.put Adder, num
+      @q.put Adder.new(num)
     end
   end
   
@@ -42,7 +42,7 @@ describe Backend::Beanstalk  do
   
   it "should put on queue" do
     3.times do |num|
-      @q.put Adder, num
+      @q.put Adder.new(num)
     end
   end
   
@@ -53,7 +53,6 @@ describe Backend::Beanstalk  do
   end
 end
 
-
 describe Backend::Sync do
   before(:all) do
     @q = Backend::Sync.new
@@ -61,7 +60,7 @@ describe Backend::Sync do
   
   it "should put on queue" do
     3.times do |num|
-      @q.put(Adder, num).should eql(num)
+      @q.put(Adder.new(num)).should eql(num)
     end
   end
   

data/spec/consumer_spec.rb

@@ -1,21 +1,21 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'ruby-debug'
 
-describe Consumer::Base do
+describe Controller::Base do
   it "should perform job" do
-    Consumer::Base.new(Adder.new([1,2])).perform.should eql(3)
+    Controller::Base.new(Adder.new(1,2)).perform.should eql(3)
   end
   
   it "should rescue all raised job actions" do
     [ReleaseJob, DeleteJob, BuryJob].each do |job|
       lambda{
-        Consumer::Base.new(job.new).perform
+        Controller::Base.new(job.new).perform
       }.should_not raise_exception
     end
   end
 end
 
-describe Consumer::Beanstalk do
+describe Controller::Beanstalk do
   before(:all) do
     @q = Backend::Beanstalk.configure(:host => 'localhost:11300', :tube => 'quebert-test-jobs-actions')
   end
@@ -25,14 +25,14 @@ describe Consumer::Beanstalk do
   end
   
   it "should delete job off queue after succesful run" do
-    @q.put(Adder, 1, 2)
+    @q.put Adder.new(1, 2)
     @q.peek_ready.should_not be_nil
     @q.reserve.perform.should eql(3)
     @q.peek_ready.should be_nil
   end
   
   it "should bury job if an exception occurs in job" do
-    @q.put Exceptional
+    @q.put Exceptional.new
     @q.peek_ready.should_not be_nil
     lambda{ @q.reserve.perform }.should raise_exception
     @q.peek_buried.should_not be_nil
@@ -40,21 +40,21 @@ describe Consumer::Beanstalk do
   
   context "job actions" do
     it "should delete job" do
-      @q.put DeleteJob
+      @q.put DeleteJob.new
       @q.peek_ready.should_not be_nil
       @q.reserve.perform
       @q.peek_ready.should be_nil
     end
     
     it "should release job" do
-      @q.put ReleaseJob
+      @q.put ReleaseJob.new
       @q.peek_ready.should_not be_nil
       @q.reserve.perform
       @q.peek_ready.should_not be_nil
     end
     
     it "should bury job" do
-      @q.put BuryJob
+      @q.put BuryJob.new
       @q.peek_ready.should_not be_nil
       @q.peek_buried.should be_nil
       @q.reserve.perform

data/spec/job_spec.rb

@@ -6,6 +6,14 @@ describe Quebert::Job do
     Adder.backend = @q = Quebert::Backend::InProcess.new
   end
 
+  it "should perform!" do
+    Adder.new(1,2,3).perform!.should eql(6)
+  end
+  
+  it "should perform 0 arg jobs" do
+    Adder.new.perform!.should eql(0)
+  end
+  
   it "should raise not implemented on base job" do
     lambda {
       Job.new.perform
@@ -14,7 +22,7 @@ describe Quebert::Job do
   
   it "should convert job to and from JSON" do
     args = [1,2,3]
-    serialized = Adder.new(args).to_json
+    serialized = Adder.new(*args).to_json
     unserialized = Adder.from_json(serialized)
     unserialized.should be_instance_of(Adder)
     unserialized.args.should eql(args)
@@ -44,7 +52,7 @@ describe Quebert::Job do
   context "job queue" do
     it "should enqueue" do
       lambda{
-        Adder.enqueue(1,2,3)
+        Adder.new(1,2,3).enqueue
       }.should change(@q, :size).by(1)
     end
   end

data/spec/serializer_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Serializer::ActiveRecord do
+  context "persisted" do
+    before(:all) do
+      @user = User.create!(:first_name => 'Tom', :last_name => 'Jones')
+    end
+    
+    it "should serialize" do
+      h = Serializer::ActiveRecord.serialize(@user)
+      h['model'].should eql('User')
+      h['attributes']['first_name'].should eql('Tom')
+      h['attributes']['id'].should eql(@user.id)
+    end
+    
+    it "should deserialize" do
+      u = Serializer::ActiveRecord.deserialize(Serializer::ActiveRecord.serialize(@user))
+      u.first_name.should eql('Tom')
+    end
+  end
+  
+  context "unpersisted" do
+    before(:all) do
+      @user = User.new(:first_name => 'brad')
+    end
+    
+    it "should serialize" do
+      h = Serializer::ActiveRecord.serialize(@user)
+      h['model'].should eql('User')
+      h['attributes']['first_name'].should eql('brad')
+      h['attributes']['id'].should be_nil
+    end
+    
+    it "should deserialize" do
+      u = Serializer::ActiveRecord.deserialize(Serializer::ActiveRecord.serialize(@user))
+      u.first_name.should eql('brad')
+    end
+  end
+end
+
+describe Serializer::Job do
+  before(:all) do
+    @args = [100, User.new(:first_name => 'Brad')]
+    @job = Job.new(*@args)
+  end
+  
+  it "should serialize job" do
+    h = Serializer::Job.serialize(@job)
+    h['job'].should eql('Quebert::Job')
+    h['args'][0]['payload'].should eql(100)
+    h['args'][1]['payload'].should eql(Serializer::ActiveRecord.serialize(@args[1]))
+    h['args'][1]['serializer'].should eql('Quebert::Serializer::ActiveRecord')
+  end
+  
+  it "should deserialize job" do
+    job = Serializer::Job.deserialize(Serializer::Job.serialize(@job))
+    job.args[0].should eql(100)
+    job.args[1].first_name.should eql('Brad')
+  end
+end

data/spec/spec_helper.rb

@@ -15,8 +15,6 @@ end
 include Quebert
 Quebert.config.logger = Logger.new('/dev/null') # Shhh...
 
-require 'jobs'
-
 def clean_file(path, contents=nil, &block)
   FileUtils.remove_entry(path) if File.exists?(path)
   FileUtils.mkdir_p(File.dirname(path))
@@ -26,4 +24,8 @@ def clean_file(path, contents=nil, &block)
   ensure
     FileUtils.remove_entry(path) if File.exists?(path) and path != './'  # Yeah! This has happened before :(
   end
-end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'support/*.rb')].each {|file| require file }
+
+Quebert.serializers.register 'ActiveRecord::Base', Serializer::ActiveRecord

data/spec/support/active_record.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection({
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+})
+
+ActiveRecord::Schema.define do
+  create_table "users", :force => true do |t|
+    t.column "first_name",  :text
+    t.column "last_name",  :text
+    t.column "email", :text
+  end
+end
+
+class User < ActiveRecord::Base
+  include Quebert::AsyncSender::ActiveRecord
+  
+  def name
+    "#{first_name} #{last_name}"
+  end
+  
+  def self.emailizer(address)
+    address
+  end
+end

data/spec/support_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Support::ClassRegistry do
+  Super = Class.new
+  Sub   = Class.new(Super)
+  
+  before(:all) do
+    @registry = Support::ClassRegistry.new
+  end
+  
+  it "should store class symbols" do
+    @registry[:'Super'] = Super
+    @registry[:'Super'].should eql(Super)
+  end
+  
+  it "should retrieve class keys" do
+    @registry[Super].should eql(Super)
+  end
+  
+  it "should retrieve subclass keys" do
+    @registry[Sub].should eql(Super)
+  end
+end

data/spec/worker_spec.rb

@@ -14,19 +14,19 @@ describe Worker do
   
   context "pluggable exception handler" do
     it "should raise exception if nothing is provided" do
-      @q.put Exceptional
+      @q.put Exceptional.new
       lambda{ @w.start }.should raise_exception
     end
 
     it "should default to Quebert.config.worker.exception_handler handler" do
-      @q.put Exceptional
+      @q.put Exceptional.new
       Quebert.config.worker.exception_handler = Proc.new{|e| e.should be_instance_of(Exception) }
       @w.exception_handler = Proc.new{|e| e.should be_instance_of(Exception) }
       lambda{ @w.start }.should_not raise_exception
     end
     
     it "should intercept exceptions" do
-      @q.put Exceptional
+      @q.put Exceptional.new
       @w.exception_handler = Proc.new{|e| e.should be_instance_of(Exception) }
       lambda{ @w.start }.should_not raise_exception
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: quebert
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Brad Gessler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-05 00:00:00 -07:00
+date: 2010-10-11 00:00:00 -07:00
 default_executable: quebert
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -92,10 +92,11 @@ files:
 - lib/quebert/backend/sync.rb
 - lib/quebert/command_line_runner.rb
 - lib/quebert/configuration.rb
-- lib/quebert/consumer.rb
-- lib/quebert/consumer/base.rb
-- lib/quebert/consumer/beanstalk.rb
+- lib/quebert/controller.rb
+- lib/quebert/controller/base.rb
+- lib/quebert/controller/beanstalk.rb
 - lib/quebert/job.rb
+- lib/quebert/serializer.rb
 - lib/quebert/support.rb
 - lib/quebert/support/pid_file.rb
 - lib/quebert/support/registry.rb
@@ -107,10 +108,13 @@ files:
 - spec/configuration_spec.rb
 - spec/consumer_spec.rb
 - spec/job_spec.rb
-- spec/jobs.rb
 - spec/quebert_spec.rb
+- spec/serializer_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/jobs.rb
+- spec/support_spec.rb
 - spec/worker_spec.rb
 has_rdoc: true
 homepage: http://github.com/bradgessler/quebert
@@ -153,7 +157,10 @@ test_files:
 - spec/configuration_spec.rb
 - spec/consumer_spec.rb
 - spec/job_spec.rb
-- spec/jobs.rb
 - spec/quebert_spec.rb
+- spec/serializer_spec.rb
 - spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/jobs.rb
+- spec/support_spec.rb
 - spec/worker_spec.rb