sucker_punch-backgroundable 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGYyZWEyZWM0ZWJhMTFlNmI5MTFmZjRjOWQxYzk5NmY5ZDc2NTMwYQ==
+  data.tar.gz: !binary |-
+    YjgyMzgyYTZlNzAzMWQwZTgzZjgwNTc4ZjRlMGJkNzcyODFjZTkwZA==
+SHA512:
+  metadata.gz: !binary |-
+    NTAyYzMxZDQxYmFkMzk2NzMwODFiYmI5NmMxYWZlYmU0OWVlNDZmOTQ5Njcz
+    MDkxZmFjOThjNjNjMDMwNmUyOWU1N2Y5YTY2Mzk0ZTMyZGY3YWI4ODJmMjM2
+    ZDVmNDk1NzBlMzliNzkxZGRkOTQwMmY1YThiOWI5ODBjMjZiYzU=
+  data.tar.gz: !binary |-
+    ZTY0M2Q3MGMxMTJkZTY4ODQ3ZDc4N2M2NjE0YzNkZGQ4YTcyYzZlNjU3NTRm
+    MjdiOTBhMGE5ZDNlMDhkY2M4ZjYwMWEzYTliYzU5ZGMwYmNjODEwNzdkY2Uy
+    NmFiNzAyMGE2ZDRiNmNiNTE3NWZiNjZlOWUxZjQ2MDg3MzIzOWY=

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/.travis

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.0.1 (19/5/2014)
+
+* First Release

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "sucker_punch", ">= 1.0.0"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+  gem "simplecov", ">= 0"
+  gem "activerecord"
+  gem "sqlite3"
+end

data/Gemfile.lock

@@ -0,0 +1,101 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (4.1.0)
+      activesupport (= 4.1.0)
+      builder (~> 3.1)
+    activerecord (4.1.0)
+      activemodel (= 4.1.0)
+      activesupport (= 4.1.0)
+      arel (~> 5.0.0)
+    activesupport (4.1.0)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    addressable (2.3.6)
+    arel (5.0.1.20140414130214)
+    builder (3.2.2)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.1.3)
+    docile (1.1.3)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    git (1.2.6)
+    github_api (0.11.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.1)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 1.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.0)
+      oauth2
+    hashie (2.1.1)
+    highline (1.6.21)
+    i18n (0.6.9)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (0.1.13)
+      multi_json (>= 1.5)
+    mini_portile (0.6.0)
+    minitest (5.3.4)
+    multi_json (1.10.0)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.2.1)
+      mini_portile (= 0.6.0)
+    oauth2 (0.9.3)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 0.1.8)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.3.2)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    sqlite3 (1.3.9)
+    sucker_punch (1.0.5)
+      celluloid (~> 0.15.2)
+    thread_safe (0.3.3)
+    timers (1.1.0)
+    tzinfo (1.1.0)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  bundler (~> 1.0)
+  jeweler (~> 2.0.1)
+  rdoc (~> 3.12)
+  rspec (~> 2.8.0)
+  simplecov
+  sqlite3
+  sucker_punch (>= 1.0.0)

data/LICENSE.txt

@@ -0,0 +1,8 @@
+Copyright (c) 2014 Michaël Van Damme
+
+sucker_punch-backgroundable is an Open Source project licensed under the terms of
+the LGPLv3 license. Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for the license text.
+
+Parts of sucker_punch-backgroundable were taken from the TorqueBox project, which is 
+also licensed under LGPLv3 (see <http://torquebox.org/license/>).

data/README.md

@@ -0,0 +1,150 @@
+# sucker_punch-backgroundable
+[![Build Status](https://travis-ci.org/mvdamme/sucker_punch-backgroundable.png)](https://travis-ci.org/mvdamme/sucker_punch-backgroundable)
+
+This gem allows you to background any method call with [SuckerPunch](https://github.com/brandonhilkert/sucker_punch) without 
+having to write a special job class.
+It provides the same API as the Backgroundable module from [TorqueBox](http://torquebox.org/), and a large part of the code
+comes directly from the TorqueBox project.
+
+## Installation
+
+Add the following to your Gemfile:
+
+```ruby
+gem 'sucker_punch-backgroundable'
+```
+
+And then execute:
+
+```ruby
+bundle install
+```
+
+## Usage
+
+Include the `SuckerPunch::Backgroundable` module in your class. Then you can use `always_background :method1, :method2, ...` to
+cause the supplied methods to run asynchronously (in the background). Example:
+
+```ruby
+class MyClass
+  SuckerPunch::Backgroundable
+  
+  always_background :send_email
+  def send_email
+    # ...
+  end
+  
+  always_background :calculate_statistics
+  def self.calculate_statistics
+    # ...
+  end
+end
+```
+
+In this example, calls to instance method `send_email` and class method `calculate_statistics` will automatically run in the background:
+
+```ruby
+obj = MyClass.new
+obj.send_email  # returns immediately, method runs in the background
+
+Myclass.calculate_statistics  # returns immediately, method runs in the background
+```
+
+Methods that have not been marked with `always_background` can also be backgrounded when you call them: 
+
+```ruby
+class MyClass
+  SuckerPunch::Backgroundable
+  
+  def notify
+    # ...
+  end
+end
+
+obj = MyClass.new
+
+# This will run in the background (and return immediately)
+obj.background.notify
+
+# This will run the method normally (synchronously, returning after the method is finished)
+obj.background.notify
+```
+
+It is also possible to specify a delay in seconds:
+
+```ruby
+# This will return immediately and run the method in the background after a delay of 60 seconds
+obj.later(60).notify
+```
+
+Both `background` and `later` also work with class methods (e.g. `MyClass.background.my_class_method(argument)`).
+
+### Reloading
+
+When backgrounding an instance method, the method is called on the object, but in a different thread (using SuckerPunch).
+If you don't use the object anymore in the current thread, this is ok. If the object is still being used in the current thread,
+it may be better to reload it from the data store (assuming a data store backed object) in the background thread to avoid any 
+threading issues. The gem can do this automatically, although currently only ActiveRecord is supported:
+
+```ruby
+class MyModel < ActiveRecord::Base
+  SuckerPunch::Backgroundable
+  
+  always_background :send_email, :reload => true
+  def send_email
+    # ...
+  end
+end
+```
+
+Or, when using `background` or `later`:
+
+```ruby
+obj.background(:reload => true).my_instance_method
+obj.later(60, :reload => true).my_instance_method
+```
+
+It is also possible to specify the `reload` option globally by using an initializer:
+
+```ruby
+SuckerPunch::Backgroundable.configure do |config|
+  config.reload = true
+end
+```
+
+## Configuration
+
+Apart from the `reload` option described above, there is only one other configuration setting:
+
+```ruby
+SuckerPunch::Backgroundable.configure do |config|
+  config.reload = true
+  config.workers = 4   # default is 2
+end
+```
+
+The number of workers sets the number of background threads that SuckerPunch will use. The default (and minimum) is 2.
+
+## Usage with ActiveRecord
+
+When using this gem with ActiveRecord models, it is recommended to set the `reload` option to true (see above).
+If you want sucker_punch-backgroundable to be available in all models you can  use the following in an initializer:
+
+```ruby
+ActiveRecord::Base.send(:include, SuckerPunch::Backgroundable)
+```
+
+## Contributing to sucker_punch-backgroundable
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2014 Michaël Van Damme. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "sucker_punch-backgroundable"
+  gem.homepage = "http://github.com/mvdamme/sucker_punch-backgroundable"
+  gem.license = "LGPL-3"
+  gem.summary = %Q{Easily execute an object's methods in the background with sucker_punch}
+  gem.description = %Q{This gem allows you to background any method call without having to write a special job class. Heavily inspired by the Backgroundable module in TorqueBox.}
+  gem.email = "michael.vandamme@vub.ac.be"
+  gem.authors = ["Michaël Van Damme"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sucker_punch-backgroundable #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/sucker_punch/backgroundable/backgroundable.rb

@@ -0,0 +1,155 @@
+# The majority of this file (> 95%) was copied from the Backgroundable module in Torquebox
+# (see https://github.com/torquebox/torquebox/blob/master/gems/messaging/lib/torquebox/messaging/backgroundable.rb).
+# The code was slightly adapted so it works with Sucker Punch instead of Torquebox messaging.
+
+module SuckerPunch
+
+  # Backgroundable provides mechanism for executing an object's
+  # methods asynchronously.
+  module Backgroundable
+
+    def self.included(base)
+      base.extend(BackgroundableClassMethods)
+    end
+
+    # Allows you to background any method that has not been marked
+    # as a backgrounded method via {BackgroundableClassMethods#always_background}.
+    def background(options = { })
+      BackgroundProxy.new(self, options)
+    end
+
+    # Allows you to background any method that has not been marked
+    # as a backgrounded method via {BackgroundableClassMethods#always_background}.
+    # The method will not be executed immediately, but only after 'seconds' seconds.
+    def later(seconds, options = { })
+      BackgroundProxy.new(self, options, seconds)
+    end
+
+    module BackgroundableClassMethods
+
+      # Marks methods to always be backgrounded. Takes one or more
+      # method symbols, and an optional options hash as the final
+      # argument. 
+      def always_background(*methods)
+        options = methods.last.is_a?(Hash) ? methods.pop : {}
+        @__backgroundable_methods ||= {}
+
+        methods.each do |method|
+          method = method.to_s
+          if !@__backgroundable_methods[method]
+            @__backgroundable_methods[method] ||= { }
+            @__backgroundable_methods[method][:options] = options
+            if Util.singleton_methods_include?(self, method) ||
+                Util.instance_methods_include?(self, method)
+              __enable_backgrounding(method)
+            end
+          end
+        end
+      end
+
+      # Allows you to background any method that has not been marked
+      # as a backgrounded method via {BackgroundableClassMethods#always_background}.
+      def background(options = { })
+        BackgroundProxy.new(self, options)
+      end
+
+      # Allows you to background any method that has not been marked
+      # as a backgrounded method via {BackgroundableClassMethods#always_background}.
+      # The method will not be executed immediately, but only after 'seconds' seconds.
+      def later(seconds, options = { })
+        BackgroundProxy.new(self, options, seconds)
+      end
+
+      # @api private
+      def method_added(method)
+        super
+        __method_added(method)
+      end
+
+      # @api private
+      def singleton_method_added(method)
+        super
+        __method_added(method)
+      end
+
+      private
+      
+      def __method_added(method)
+        method = method.to_s
+        if @__backgroundable_methods &&
+            @__backgroundable_methods[method] &&
+            !@__backgroundable_methods[method][:backgrounding]
+          __enable_backgrounding(method)
+        end
+      end
+
+      def __enable_backgrounding(method)
+        singleton_method = Util.singleton_methods_include?(self, method)
+        singleton = (class << self; self; end)
+
+        if singleton_method
+
+          SuckerPunch.logger.
+            warn("always_background called for :#{method}, but :#{method} " +
+                 "exists as both a class and instance method. Only the " +
+                 "class method will be backgrounded.") if Util.instance_methods_include?(self, method)
+
+          privatize = Util.private_singleton_methods_include?(self, method)
+          protect = Util.protected_singleton_methods_include?(self, method) unless privatize
+        else
+          privatize = Util.private_instance_methods_include?(self, method)
+          protect = Util.protected_instance_methods_include?(self, method) unless privatize
+        end
+
+        async_method = "__async_#{method}"
+        sync_method = "__sync_#{method}"
+
+        @__backgroundable_methods[method][:backgrounding] = true
+        options = @__backgroundable_methods[method][:options]
+
+        (singleton_method ? singleton : self).class_eval do
+          define_method async_method do |*args|
+            # run sucker punch job asynchronously
+            Job.new.async.perform(self, sync_method, args, options)
+          end
+        end
+        
+        code = singleton_method ? "class << self" : ""
+        code << %Q{
+          alias_method :#{sync_method}, :#{method}
+          alias_method :#{method}, :#{async_method}
+        }
+        code << %Q{
+          #{privatize ? "private" : "protected"} :#{method}, :#{sync_method}, :#{async_method}
+        } if privatize || protect
+        code << "end" if singleton_method
+
+        class_eval code
+      ensure
+        @__backgroundable_methods[method][:backgrounding] = nil
+      end
+
+    end
+
+    # @api private
+    class BackgroundProxy
+      def initialize(receiver, options, seconds = 0)
+        @receiver = receiver
+        @options = options
+        @seconds = seconds
+      end
+
+      def method_missing(method, *args, &block)
+        @receiver.method_missing(method, *args, &block) unless @receiver.respond_to?(method)
+        raise ArgumentError.new("Backgrounding a method with a block argument is not supported.") if block_given?
+        if @seconds > 0
+          Job.new.async.later(@seconds, @receiver, method, args, @options)
+        else
+          Job.new.async.perform(@receiver, method, args, @options)
+        end
+      end
+    end
+    
+  end
+
+end

data/lib/sucker_punch/backgroundable/config.rb

@@ -0,0 +1,26 @@
+# configuration, see http://robots.thoughtbot.com/mygem-configure-block.
+module SuckerPunch
+  module Backgroundable
+    class << self
+      attr_accessor :configuration
+    end
+  
+    def self.configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+  
+    class Configuration
+      attr_accessor :workers
+      attr_accessor :reload
+  
+      def initialize
+        @workers = 2
+        @reload = false
+      end
+    end
+    
+  end
+end
+
+SuckerPunch::Backgroundable.configure {}

data/lib/sucker_punch/backgroundable/job.rb

@@ -0,0 +1,36 @@
+module SuckerPunch
+  module Backgroundable
+
+    class Job
+      include SuckerPunch::Job
+      workers SuckerPunch::Backgroundable.configuration.workers
+    
+      def perform(receiver, method, args, options)
+        receiver = load(receiver) if instantiate?(options)
+        if defined?(ActiveRecord)
+          ActiveRecord::Base.connection_pool.with_connection do
+            receiver.send(method, *args)
+          end
+        else
+          receiver.send(method, *args)
+        end
+      end
+    
+      def later(sec, *args)
+        after(sec) { perform(*args) }
+      end
+      
+      private
+      
+        def instantiate?(options)
+          return true if SuckerPunch::Backgroundable.configuration.reload && !(!options[:reload].nil? && options[:reload] == false)
+          options[:reload]
+        end
+        
+        def load(receiver)
+          receiver.respond_to?(:id) ? receiver.class.find(receiver.id) : receiver
+        end
+    end
+
+  end
+end

data/lib/sucker_punch/backgroundable/util.rb

@@ -0,0 +1,47 @@
+# This code was copied from the Backgroundable module in Torquebox
+# (see https://github.com/torquebox/torquebox/blob/master/gems/messaging/lib/torquebox/messaging/backgroundable.rb).
+
+module SuckerPunch
+
+  module Backgroundable
+
+    module Util
+
+      class << self
+        def singleton_methods_include?(klass, method)
+          methods_include?(klass.singleton_methods, method) ||
+            private_singleton_methods_include?(klass, method)
+        end
+
+        def private_singleton_methods_include?(klass, method)
+          methods_include?(klass.private_methods, method)
+        end
+
+        def protected_singleton_methods_include?(klass, method)
+          methods_include?(klass.protected_methods, method)
+        end
+
+        def instance_methods_include?(klass, method)
+          methods_include?(klass.instance_methods, method) ||
+            private_instance_methods_include?(klass, method)
+        end
+
+        def private_instance_methods_include?(klass, method)
+          methods_include?(klass.private_instance_methods, method)
+        end
+
+        def protected_instance_methods_include?(klass, method)
+          methods_include?(klass.protected_instance_methods, method)
+        end
+
+        def methods_include?(methods, method)
+          method = (RUBY_VERSION =~ /^1\.8\./ ? method.to_s : method.to_sym)
+          methods.include?(method)
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/sucker_punch-backgroundable.rb

@@ -0,0 +1,6 @@
+require 'sucker_punch'
+require 'sucker_punch/backgroundable/config'
+require 'sucker_punch/backgroundable/util'
+require 'sucker_punch/backgroundable/job'
+require 'sucker_punch/backgroundable/backgroundable'
+

data/spec/load_active_record.rb

@@ -0,0 +1,32 @@
+# Code taken from http://iain.nl/testing-activerecord-in-isolation
+
+require 'active_record'
+
+db_file = './spec/test.db'
+File.delete(db_file) if File.exist?(db_file)
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: db_file
+
+ActiveRecord::Migration.create_table :test_models do |t|
+  t.integer :value
+  t.timestamps
+end
+
+module ActiveModel::Validations
+  # Extension to enhance `should have` on AR Model instances.  Calls
+  # model.valid? in order to prepare the object's errors object.
+  #
+  # You can also use this to specify the content of the error messages.
+  #
+  # @example
+  #
+  #     model.should have(:no).errors_on(:attribute)
+  #     model.should have(1).error_on(:attribute)
+  #     model.should have(n).errors_on(:attribute)
+  #
+  #     model.errors_on(:attribute).should include("can't be blank")
+  def errors_on(attribute)
+    self.valid?
+    [self.errors[attribute]].flatten.compact
+  end
+  alias :error_on :errors_on
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_profile 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'sucker_punch-backgroundable'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

data/spec/sucker_punch-backgroundable_spec.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/test_class')
+
+describe "sucker_punch-backgroundable" do
+  before :each do
+    @obj = TestClass.new
+    TestClass.clear
+  end
+ 
+  context 'instance methods' do
+    it "backgrounds instance methods declared after :always_background" do
+      @obj.always1
+      check_queue(1)
+    end
+    
+    it "backgrounds instance methods declared before :always_background" do
+      @obj.always2(100)
+      check_queue(100)
+    end
+    
+    it "allows backgrounding of instance methods not declared as :always_background" do
+      @obj.background.normal(200)
+      check_queue(200)
+    end
+
+    it "allows running instance methods with a specified delay" do
+      @obj.later(2).normal(200) # run after 2 seconds
+      check_queue(200, 2.2)
+    end
+
+    it "allows running instance methods with a specified delay, even when they are declared as :always_bacground" do
+      @obj.later(2).always1 # run after 2 seconds
+      check_queue(1, 2.2)
+    end
+  end 
+  
+  context 'class methods' do
+    it "backgrounds class methods declared after :always_background" do
+      TestClass.class_always1
+      check_queue(1)
+    end
+    
+    it "backgrounds class methods declared before :always_background" do
+      TestClass.class_always2(100)
+      check_queue(100)
+    end
+    
+    it "allows backgrounding of class methods not declared as :always_background" do
+      TestClass.background.class_normal(200)
+      check_queue(200)
+    end
+
+    it "allows running class methods with a specified delay" do
+      TestClass.later(2).class_normal(200) # run after 2 seconds
+      check_queue(200, 2.2)
+    end
+
+    it "allows running class methods with a specified delay, even when they are declared as :always_bacground" do
+      TestClass.later(2).class_always1 # run after 2 seconds
+      check_queue(1, 2.2)
+    end
+  end 
+  
+  context 'singleton methods' do
+    before :each do 
+      def @obj.my_singleton(value)
+        add_to_queue(value + 1)
+      end
+    end
+    
+    it "allows backgrounding of singleton methods" do
+      @obj.background.my_singleton(200)
+      check_queue(201)
+    end
+
+    it "allows running singleton methods with a specified delay" do
+      @obj.later(2).my_singleton(200) # run after 2 seconds
+      check_queue(201, 2.2)
+    end
+  end
+  
+  def check_queue(value, wait_before = 0.2, wait_after = 0.3)
+    sleep( wait_before )
+    TestClass.queue.length.should eq(0)
+    sleep( wait_after )
+    TestClass.queue.length.should eq(1)
+    TestClass.queue.pop.should eq(value)
+  end
+
+  context 'reloading' do
+    before do
+      require File.expand_path(File.dirname(__FILE__) + '/load_active_record')
+      require File.expand_path(File.dirname(__FILE__) + '/test_model')
+    end
+    
+    before :each do
+      @model = TestModel.create(:value => 5)
+    end
+
+    after :each do
+      TestModel.delete_all
+    end
+
+    it "fully reloads objects when :reload option is true" do
+      @model.later(0.4, :reload => true).copy_value
+      @model.value += 1 # change object
+      sleep(0.5)
+      TestModel.queue.pop.should eq(5)
+    end
+
+    it "doesn't reload objects when :reload option is false" do
+      @model.later(0.4).copy_value # :reload defaults to false
+      @model.value += 1 # change object
+      sleep(0.5)
+      TestModel.queue.pop.should eq(6)
+    end
+
+    it "respects :reload => true as option to :always_background" do
+      @model.copy_value_in_background
+      @model.value += 1 # change object
+      sleep(0.5)
+      TestModel.queue.pop.should eq(5)
+    end
+
+    context 'global reload option' do
+      it "honors when global reload is set to true" do
+        SuckerPunch::Backgroundable.configure do |config|
+          config.reload = true
+        end
+        @model.later(0.4).copy_value
+        @model.value += 1 # change object
+        sleep(0.5)
+        TestModel.queue.pop.should eq(5)
+      end
+
+      it "honors :reload => false even when when global reload is set to true" do
+        SuckerPunch::Backgroundable.configure do |config|
+          config.reload = true
+        end
+        @model.later(0.4, :reload => false).copy_value
+        @model.value += 1 # change object
+        sleep(0.5)
+        TestModel.queue.pop.should eq(6)
+      end
+
+      it "ignores :reload for class methods" do
+        SuckerPunch::Backgroundable.configure do |config|
+          config.reload = true
+        end
+        TestModel.class_always
+        sleep(0.5)
+        TestModel.queue.pop.should eq(7)
+      end
+
+    end
+  end
+  
+end

data/spec/test_class.rb

@@ -0,0 +1,54 @@
+class TestClass
+  include SuckerPunch::Backgroundable
+  
+  @@queue = Queue.new
+  
+  def self.queue
+    @@queue
+  end
+  
+  def self.clear
+    @@queue.clear
+  end
+  
+  always_background :always1
+  def always1
+    add_to_queue
+  end
+  
+  def always2(value)
+    add_to_queue(value)
+  end
+  always_background :always2
+  
+  def normal(value)
+    add_to_queue(value)
+  end
+
+  always_background :class_always1
+  def self.class_always1
+    self.class_add_to_queue
+  end
+  
+  def self.class_always2(value)
+    self.class_add_to_queue(value)
+  end
+  always_background :class_always2
+  
+  def self.class_normal(value)
+    self.class_add_to_queue(value)
+  end
+
+  private
+  
+    def add_to_queue(value = 1)
+      sleep(0.4)
+      @@queue << value
+    end
+
+    def self.class_add_to_queue(value = 1)
+      sleep(0.4)
+      @@queue << value
+    end
+    
+end

data/spec/test_model.rb

@@ -0,0 +1,29 @@
+class TestModel < ActiveRecord::Base
+  include SuckerPunch::Backgroundable
+
+  @@queue = Queue.new
+  
+  def self.queue
+    @@queue
+  end
+  
+  def self.clear
+    @@queue.clear
+  end
+  
+  def copy_value
+    @@queue << value
+  end
+
+  always_background :class_always
+  def self.class_always
+    sleep(0.4)
+    @@queue << 7
+  end
+
+  always_background :copy_value_in_background, :reload => true
+  def copy_value_in_background
+    sleep(0.4)
+    @@queue << value
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: sucker_punch-backgroundable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michaël Van Damme
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sucker_punch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: activerecord
+  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: sqlite3
+  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'
+description: This gem allows you to background any method call without having to write
+  a special job class. Heavily inspired by the Backgroundable module in TorqueBox.
+email: michael.vandamme@vub.ac.be
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- .travis
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/sucker_punch-backgroundable.rb
+- lib/sucker_punch/backgroundable/backgroundable.rb
+- lib/sucker_punch/backgroundable/config.rb
+- lib/sucker_punch/backgroundable/job.rb
+- lib/sucker_punch/backgroundable/util.rb
+- spec/load_active_record.rb
+- spec/spec_helper.rb
+- spec/sucker_punch-backgroundable_spec.rb
+- spec/test_class.rb
+- spec/test_model.rb
+homepage: http://github.com/mvdamme/sucker_punch-backgroundable
+licenses:
+- LGPL-3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Easily execute an object's methods in the background with sucker_punch
+test_files: []