activeasync 0.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rspec
+log/*.log
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+tmp/

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## 0.0.1 (2012-01-26)
+
+* async method: interface for sending methods with arguments to Resque
+* :async => true option for running active model callbacks in the background
+* ActiveRecord module to enable async option for after_save, after_update, and after_create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in activeasync.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Ross Kaffenberger
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc "Run the specs"
+task :default => ["spec"]

data/activeasync.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_async/version"
+
+Gem::Specification.new do |s|
+  s.name        = "activeasync"
+  s.version     = ActiveAsync::VERSION
+  s.authors     = ["Ross Kaffenberger"]
+  s.email       = ["rosskaff@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Add async support to ruby objects}
+  s.description = %q{Provides async methods ruby objects for queuing background jobs. Currently supports Resque. Bonus: callback hooks for ActiveRecord objects}
+
+  s.rubyforge_project = "activeasync"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_runtime_dependency "rest-client"
+  s.add_dependency "resque", "~> 1.10"
+  s.add_dependency "activesupport", "~> 3.0"
+
+  s.add_development_dependency "rails", "~> 3.0"
+  s.add_development_dependency "rspec", "~> 2.8.0"
+  s.add_development_dependency "database_cleaner", "~> 0.7.0"
+  s.add_development_dependency "ruby-debug"
+  s.add_development_dependency "sqlite3"
+end

data/lib/active_async.rb

@@ -0,0 +1,23 @@
+require "resque"
+require "active_support/concern"
+require "active_async/version"
+require "active_async/async"
+require "active_async/callbacks"
+require "active_async/active_record"
+
+module ActiveAsync
+  extend self
+
+  def background
+    @background ||= ::Resque
+  end
+
+  def background=(background)
+    @background = background
+  end
+
+  def reset!
+    @background = nil
+  end
+
+end

data/lib/active_async/active_record.rb

@@ -0,0 +1,13 @@
+module ActiveAsync
+  module ActiveRecord
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveAsync::Async
+      include ActiveAsync::Callbacks
+
+      define_async_callbacks :after_save, :after_update, :after_create
+    end
+
+  end
+end

data/lib/active_async/async.rb

@@ -0,0 +1,38 @@
+module ActiveAsync
+  module Async
+    extend ActiveSupport::Concern
+
+    CLASS_IDENTIFIER = "__class__".freeze
+
+    included do
+      class_attribute :queue
+      self.queue = :general
+    end
+
+    module ClassMethods
+
+      # This will be called by a worker when a job needs to be processed
+      def perform(id, method, *args)
+        async_class_or_instance(id).send(method, *args)
+      end
+
+      def async(method, *args)
+        ActiveAsync.background.enqueue(self, CLASS_IDENTIFIER, method, *args)
+      end
+
+      private
+
+      def async_class_or_instance(id)
+        id == CLASS_IDENTIFIER ? self : self.find(id)
+      end
+
+    end
+
+    # We can pass this any Repository instance method that we want to
+    # run later.
+    def async(method, *args)
+      ActiveAsync.background.enqueue(self.class, id, method, *args)
+    end
+
+  end
+end

data/lib/active_async/callbacks.rb

@@ -0,0 +1,45 @@
+module ActiveAsync
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def define_async_callbacks(*callback_names)
+        callback_names.each do |callback_name|
+          class_eval <<-RUBY
+            define_callbacks :async_#{callback_name}
+
+            def self.#{callback_name}_with_async(*methods)
+              #{callback_name}_without_async(*extract_async_methods(methods))
+            end
+
+            class << self
+              alias_method_chain :#{callback_name}, :async
+            end
+          RUBY
+        end
+      end
+
+      private
+
+      def extract_async_methods(methods)
+        options = methods.extract_options!
+        methods = options[:async] ? define_async_methods(methods) : methods
+        methods.push(options.except(:async))
+      end
+
+      def define_async_methods(methods)
+        methods.map do |method_name|
+          async_name = "async_#{method_name}"
+          unless instance_methods.include?(async_name)
+            define_method(async_name) do
+              async(method_name)
+            end
+          end
+          async_name
+        end
+      end
+
+    end
+  end
+end

data/lib/active_async/fake_resque.rb

@@ -0,0 +1,9 @@
+module ActiveAsync
+  module FakeResque
+    extend self
+
+    def self.enqueue(klass, *args)
+      klass.send(:perform, *args)
+    end
+  end
+end

data/lib/active_async/version.rb

@@ -0,0 +1,3 @@
+module ActiveAsync
+  VERSION = "0.0.1"
+end

data/spec/active_async/active_record_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ActiveAsync::ActiveRecord do
+
+  let(:blog) { Blog.new }
+
+  before(:each) do
+    Blog.stub!(:find).and_return(blog)
+  end
+
+  describe "included", :stub_resque do
+    it "should define async callback for save" do
+      blog.should_receive(:expensive_save_method)
+      blog.save
+    end
+
+    it "should define async callback for update" do
+      blog.save
+      blog.should_receive(:expensive_update_method)
+      blog.update_attributes(:title => "foo")
+    end
+
+    it "should define async callback for create" do
+      blog.should_receive(:expensive_create_method)
+      Blog.create
+    end
+  end
+end

data/spec/active_async/async_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe ActiveAsync::Async do
+
+  context "activerecord, resque", :stub_resque do
+    let(:post) { Post.create(:title => "A new post") }
+
+    describe "queue" do
+      it "should provide default queue" do
+        Post.queue.should == :general
+      end
+
+      it "allows override per class" do
+        Blog.queue = :blog
+        Blog.queue.should == :blog
+        Post.queue.should == :general
+      end
+    end
+
+    describe "perform" do
+      it "should send method for given instance id" do
+        Post.any_instance.should_receive(:expensive_method)
+        Post.perform(post.id, :expensive_method)
+      end
+    end
+
+    describe "async" do
+      it "should send method for given instance id" do
+        Post.should_receive(:expensive_method)
+        Post.async(:expensive_method)
+      end
+    end
+
+    describe "#async" do
+      it "should call the given method" do
+        Post.any_instance.should_receive(:expensive_method)
+        post.async(:expensive_method)
+      end
+
+      it "should call the given method" do
+        Post.any_instance.should_receive(:expensive_method).with(1, 2, 3)
+        post.async(:expensive_method, 1, 2, 3)
+      end
+
+      it "should call 'perform' class method as expected by Resque" do
+        Post.should_receive(:perform).with(post.id, :expensive_method)
+        post.async(:expensive_method)
+      end
+
+      it "should find the existing record" do
+        Post.should_receive(:find).with(post.id).and_return(post)
+        post.async(:expensive_method)
+      end
+
+      it "should raise error if record not found" do
+        post = Post.new
+        lambda { post.async(:expensive_method) }.should raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+
+end

data/spec/active_async/callbacks_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe ActiveAsync::Callbacks do
+
+  describe "active model example", :stub_resque do
+    class DummyBase
+      extend ActiveModel::Callbacks
+
+      define_model_callbacks :save, :update, :create
+
+      def id; object_id; end
+      def find(id); end
+
+      def save;   run_callbacks :save; end
+      def update; run_callbacks :update; end
+      def create; run_callbacks :create; end
+
+      include ActiveAsync::Async
+      include ActiveAsync::Callbacks
+
+      define_async_callbacks :after_save, :after_update, :after_create
+    end
+
+    class DummyUser < DummyBase
+      after_save    :save_expensive_method,   :async => true
+      after_update  :update_expensive_method, :async => true
+      after_create  :create_expensive_method, :async => true, :more_options => true
+
+      def save_expensive_method;    self.class.run_expensive_method; end
+      def create_expensive_method;  self.class.run_expensive_method; end
+      def update_expensive_method;  self.class.run_expensive_method; end
+
+      def self.run_expensive_method
+        # please run with async!
+      end
+    end
+
+    let(:model) { DummyUser.new }
+
+    before(:each) do
+      DummyUser.stub!(:find).and_return(model)
+    end
+
+    describe "callbacks with async" do
+
+      describe "on create" do
+        it "should run create method" do
+          model.should_receive(:create_expensive_method).once
+          model.create
+        end
+
+        it "should run methods asynchronously on create" do
+          model.should_receive(:async).with(:create_expensive_method)
+          model.create
+        end
+
+      end
+
+      describe "on save" do
+        it "should run save method" do
+          model.should_receive(:save_expensive_method).once
+          model.save
+        end
+
+        it "should run methods asynchronously on create" do
+          model.should_receive(:async).with(:save_expensive_method)
+          model.save
+        end
+      end
+
+      describe "on update" do
+        it "should run update method" do
+          model.should_receive(:update_expensive_method).once
+          model.update
+        end
+
+        it "should run methods asynchronously on update" do
+          model.should_receive(:async).with(:update_expensive_method)
+          model.update
+        end
+      end
+
+      it "should run expensive method for each callback" do
+        DummyUser.should_receive(:run_expensive_method).exactly(1).times
+        model.create
+
+        DummyUser.should_receive(:run_expensive_method).exactly(1).times
+        model.save
+
+        DummyUser.should_receive(:run_expensive_method).exactly(1).times
+        model.update
+      end
+
+      describe ".extract_async_methods" do
+        it "should forward unmodified arguments if not asyncing" do
+          extracted_args = DummyUser.send(:extract_async_methods, [:method_name, {:more_options => true}])
+          extracted_args.should == [:method_name, {:more_options => true}]
+        end
+
+        it "should pass along all options to after_create macro execpt :async" do
+          extracted_args = DummyUser.send(:extract_async_methods, [:method_name, {:more_options => true, :async => true}])
+          extracted_args.should include(:more_options => true)
+          extracted_args.should_not include(:async => true)
+        end
+
+        it "should update method name and define async method when async is true" do
+          extracted_args = DummyUser.send(:extract_async_methods, [:method_name, {:async => true}])
+          extracted_args.should == ["async_method_name", {}]
+          DummyUser.instance_methods.should include("async_method_name")
+        end
+      end
+
+
+    end
+  end
+
+end