quebert 0.0.3 → 0.0.4

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/quebert/async_sender.rb

@@ -1,99 +1,8 @@
 module Quebert
   module AsyncSender
-    
-    # Perform jobs on Object methods (not instances)
-    module Object
-      class ObjectJob < Job
-        def perform(const, meth, args)
-          Support.constantize(const).send(meth, *args)
-        end
-      end
-      
-      def self.included(base)
-        base.send(:extend, ClassMethods)
-      end
-      
-      module ClassMethods
-        def async_send(meth, *args)
-          ObjectJob.enqueue(self.name, meth, args)
-        end
-      end
-    end
-    
-    # Perform jobs on instances of classes
-    module Instance
-      class InstanceJob < Job
-        def perform(klass, init_args, meth, args)
-          Support.constantize(klass).new(init_args).send(meth, *args)
-        end
-      end
-      
-      def self.included(base)
-        # Its not as simple as including initialize in a class, we
-        # have to do some tricks to make it work so we can put the include
-        # before the initialize method as opposed to after. Ah, and thanks PivotalLabs for this.
-        base.extend ClassMethods
-        base.overwrite_initialize
-        base.instance_eval do
-          def method_added(name)
-            return if name != :initialize
-            overwrite_initialize
-          end
-        end
-      end
-      
-      def initialize_with_async_sender(*args)
-        initialize_without_async_sender(*(@_init_args = args))
-      end
-      
-      module ClassMethods
-        def overwrite_initialize
-          class_eval do
-            unless method_defined?(:initialize_with_async_sender)
-              define_method(:initialize_with_async_sender) do
-                initialize_without_async_sender
-              end
-            end
-            
-            if instance_method(:initialize) != instance_method(:initialize_with_async_sender)
-              alias_method :initialize_without_async_sender, :initialize
-              alias_method :initialize, :initialize_with_async_sender
-            end
-          end
-        end
-      end
-      
-      def async_send(meth, *args)
-        InstanceJob.enqueue(self.class.name, @_init_args, meth, args)
-      end
-    end
-    
-    # Extend a class with both the object and instance async_send
-    module Class
-      def self.included(base)
-        base.send(:include, AsyncSender::Object)
-        base.send(:include, AsyncSender::Instance)
-      end
-    end
-    
-    module ActiveRecord
-      class RecordJob < Job
-        def perform(klass, id, meth, args)
-          Support.constantize(klass).find(id).send(meth, *args)
-        end
-      end
-      
-      def self.included(base)
-        base.send :include, InstanceMethods
-        base.send :include, AsyncSender::Object
-      end
-      
-      module InstanceMethods
-        def async_send(meth, *args)
-          RecordJob.enqueue(self.class.name, id, meth, args)
-        end
-      end
-    end
-    
+    autoload :Object,         'quebert/async_sender/object'
+    autoload :Instance,       'quebert/async_sender/instance'
+    autoload :Class,          'quebert/async_sender/class'
+    autoload :ActiveRecord,   'quebert/async_sender/active_record'
   end
 end

data/lib/quebert/async_sender/active_record.rb

@@ -0,0 +1,59 @@
+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
+        end
+      end
+      
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.send(:extend, ClassMethods)
+      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)
+        end
+      end
+    end
+  end
+end

data/lib/quebert/async_sender/class.rb

@@ -0,0 +1,11 @@
+module Quebert
+  module AsyncSender
+    # Extend a class with both the object and instance async_send
+    module Class
+      def self.included(base)
+        base.send(:include, AsyncSender::Object)
+        base.send(:include, AsyncSender::Instance)
+      end
+    end
+  end
+end

data/lib/quebert/async_sender/instance.rb

@@ -0,0 +1,51 @@
+module Quebert
+  module AsyncSender
+    # Perform jobs on instances of classes
+    module Instance
+      class InstanceJob < Job
+        def perform(klass, init_args, meth, args)
+          Support.constantize(klass).new(init_args).send(meth, *args)
+        end
+      end
+      
+      def self.included(base)
+        # Its not as simple as including initialize in a class, we
+        # have to do some tricks to make it work so we can put the include
+        # before the initialize method as opposed to after. Ah, and thanks PivotalLabs for this.
+        base.extend ClassMethods
+        base.overwrite_initialize
+        base.instance_eval do
+          def method_added(name)
+            return if name != :initialize
+            overwrite_initialize
+          end
+        end
+      end
+      
+      def initialize_with_async_sender(*args)
+        initialize_without_async_sender(*(@_init_args = args))
+      end
+      
+      module ClassMethods
+        def overwrite_initialize
+          class_eval do
+            unless method_defined?(:initialize_with_async_sender)
+              define_method(:initialize_with_async_sender) do
+                initialize_without_async_sender
+              end
+            end
+            
+            if instance_method(:initialize) != instance_method(:initialize_with_async_sender)
+              alias_method :initialize_without_async_sender, :initialize
+              alias_method :initialize, :initialize_with_async_sender
+            end
+          end
+        end
+      end
+      
+      def async_send(meth, *args)
+        InstanceJob.enqueue(self.class.name, @_init_args, meth, args)
+      end
+    end
+  end
+end

data/lib/quebert/async_sender/object.rb

@@ -0,0 +1,22 @@
+module Quebert
+  module AsyncSender
+    # Perform jobs on Object methods (not instances)
+    module Object
+      class ObjectJob < Job
+        def perform(const, meth, args)
+          Support.constantize(const).send(meth, *args)
+        end
+      end
+      
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+      
+      module ClassMethods
+        def async_send(meth, *args)
+          ObjectJob.enqueue(self.name, meth, args)
+        end
+      end
+    end
+  end
+end

data/quebert.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{quebert}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brad Gessler"]
@@ -29,6 +29,10 @@ Gem::Specification.new do |s|
      "bin/quebert",
      "lib/quebert.rb",
      "lib/quebert/async_sender.rb",
+     "lib/quebert/async_sender/active_record.rb",
+     "lib/quebert/async_sender/class.rb",
+     "lib/quebert/async_sender/instance.rb",
+     "lib/quebert/async_sender/object.rb",
      "lib/quebert/backend.rb",
      "lib/quebert/backend/beanstalk.rb",
      "lib/quebert/backend/in_process.rb",

data/spec/async_sender_spec.rb

@@ -59,27 +59,44 @@ describe AsyncSender::ActiveRecord do
       "#{first_name} #{last_name}"
     end
     
-    def self.email(address)
+    def self.emailizer(address)
       address
     end
   end
   
   before(:all) do
     @q = Backend::InProcess.new
-    Quebert::AsyncSender::ActiveRecord::RecordJob.backend = @q
+    Quebert::AsyncSender::ActiveRecord::PersistedRecordJob.backend = @q
+    Quebert::AsyncSender::ActiveRecord::UnpersistedRecordJob.backend = @q
     Quebert::AsyncSender::Object::ObjectJob.backend = @q
+  end
+  
+  context "persisted" do
+    before(:each) do
+      @user = User.create!(:first_name => 'Brad', :last_name => 'Gessler', :email => 'brad@bradgessler.com')
+    end
     
-    @user = User.create!(:first_name => 'Brad', :last_name => 'Gessler', :email => 'brad@bradgessler.com')
+    it "should async_send instance method" do
+      User.first.async_send(:name)
+      @q.reserve.perform.should eql(User.first.name)
+    end
   end
   
-  it "should async_send instance method" do
-    User.first.async_send(:name)
-    @q.reserve.perform.should eql(User.first.name)
+  context "unpersisted" do
+    it "should async_send instance method" do
+      user = User.new do |u|
+        u.email = 'barf@jones.com'
+        u.first_name = "Barf"
+        u.send(:write_attribute, :last_name, "Jones")
+      end
+      user.async_send(:name)
+      @q.reserve.perform.should eql("Barf Jones")
+    end
   end
   
   it "should async_send class method" do
     email = "brad@bradgessler.com"
-    User.async_send(:email, email)
+    User.async_send(:emailizer, email)
     @q.reserve.perform.should eql(email)
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: quebert
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Brad Gessler
@@ -82,6 +82,10 @@ files:
 - bin/quebert
 - lib/quebert.rb
 - lib/quebert/async_sender.rb
+- lib/quebert/async_sender/active_record.rb
+- lib/quebert/async_sender/class.rb
+- lib/quebert/async_sender/instance.rb
+- lib/quebert/async_sender/object.rb
 - lib/quebert/backend.rb
 - lib/quebert/backend/beanstalk.rb
 - lib/quebert/backend/in_process.rb