resque-async-method-enhanced 1.3.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3-p286@resque-async-method --create

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog  VERSION = '1.3.1'
+
+* Change name due to the reluctance of owner of gem, Nick Ragaz to integrate this improved version of his *beautiful* code, bullshit...
+
+# Changelog  VERSION = '1.3'
+
+* Switch to plugin resque-lock-timeout instead of sef implementation
+* Add timeout feature
+
+# Changelog  VERSION = '1.2'
+
+* Add lock flag
+
+# Changelog  VERSION = '1.1.1'
+
+* Switch testunit to rspec

data/COMMANDS

@@ -0,0 +1,9 @@
+bundle && bundle exec rake spec
+gem build resque-async-method-enhanced.gemspec
+git tag -a v1.3.1 -m 'version 1.3.1'
+git push --tags
+gem push resque-async-method-enhanced-1.3.1.gem
+git push origin master
+
+extra:
+bundle exec rspec spec/resque-async-method-enhanced/method_spec.rb -e 'Resque::Plugins::Async::Method for valid record with loner'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in resque-async-method-enhanced.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    resque-async-method-enhanced (1.3.1)
+      activesupport
+      resque
+      resque-lock-timeout
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.9)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.1)
+    multi_json (1.3.7)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rake (0.9.2.2)
+    redis (3.0.2)
+    redis-namespace (1.2.1)
+      redis (~> 3.0.0)
+    resque (1.23.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.0)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    resque-lock-timeout (0.4.1)
+      resque (>= 1.8.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    sinatra (1.3.3)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    tilt (1.3.3)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  resque-async-method-enhanced!
+  rspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Nick Ragaz
+
+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/README.md

@@ -0,0 +1,86 @@
+Resque::Plugins::Async::Method
+==============================
+
+Make Active Record instance methods asynchronous using [resque](http://www.github.com/defunkt/resque).
+
+Works with Ruby ~> 1.9, Rails ~> 3 and Resque ~> 1.17. (Probably works with earlier versions too -- but why?)
+
+Usage
+-----
+
+    class User < ActiveRecord::Base
+      # Not needed! This is done using a hook on ActiveRecord::Base.
+      # include Resque::Plugins::Async::Method
+
+      def process_avatar
+        # do stuff
+      end
+      async_method :process_avatar
+
+    end
+
+    u = User.find(1)
+
+    u.process_avatar # => queued in 'users' queue
+    
+	# You can call previous method in sync mode by :
+    u.sync_process_avatar # => happens right away!
+
+Note that in the test environment, none of this magic happens. You can test the expected output immediately.
+
+Method return values will change. `Resque.enqueue` will return `[]` from an async'ed method.
+
+## In Module extension
+
+Sometimes it's nice to async a method that you're including from a module:
+
+    module MyExtension
+      extend ActiveSupport::Concern
+
+      include Resque::Plugins::Async::Method
+
+      included do
+        async_method :generate_matrix, queue: 'matrices'
+      end
+
+      def generate_matrix
+        # do stuff
+      end
+    end
+
+# Concurrently protection
+
+You can protect for concurrently processing in background
+
+For this, you must indicate which classes should not make any treatment concurrently :
+
+    class User < ActiveRecord::Base
+		...
+
+       def process_avatar
+        # do stuff
+      end
+      async_method :process_avatar, loner: true
+
+    end
+
+You can also set a timeout in seconds, when you pass key :lock_timeout the key :loner is useless but you can set it anyway.
+
+    class User < ActiveRecord::Base
+		...
+
+       def process_avatar
+        # do stuff
+      end
+      async_method :process_avatar, lock_timeout: 3600
+
+    end
+
+
+Changelog
+---------
+* 1.3: Technical enhancement, switch to plugin resque-lock-timeout
+* 1.2: Add flaging system
+* 1.1.1: Switch to Rspec test suite.
+* 1.0.1: Update for latest Resque API (true returned from successful queue)
+* 1.0.0: Initial release

data/Rakefile

@@ -0,0 +1,27 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Resque::Plugins::Async::Method'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = ['--color --format nested --fail-fast']
+end
+
+task :default => :spec

data/lib/resque-async-method-enhanced.rb

@@ -0,0 +1,16 @@
+require 'resque-async-method-enhanced/version'
+require 'active_support/concern'
+require 'active_support/dependencies/autoload'
+
+module Resque
+  module Plugins
+    module Async
+      autoload :Method, 'resque/plugins/async/method'
+      autoload :Worker, 'resque/plugins/async/worker'
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include Resque::Plugins::Async::Method
+end

data/lib/resque-async-method-enhanced/version.rb

@@ -0,0 +1,3 @@
+module ResqueAsyncMethodEnhanced
+  VERSION = '1.3.1'
+end

data/lib/resque/plugins/async/method.rb

@@ -0,0 +1,36 @@
+require 'resque/plugins/async/worker'
+
+module Resque::Plugins::Async::Method
+  extend ActiveSupport::Concern
+
+  class NotPersistedError < StandardError; end
+
+  module ClassMethods
+    
+    def async_method method_name, options = {}
+      
+      puts "options => #{options}"
+      alias_method :"sync_#{method_name}", method_name # Allow tests to call sync_ methods ...
+
+      return if Rails.env.test? # ... but don't actually make them asynchronous
+
+      define_method method_name do |*args|
+        raise NotPersistedError, "Methods can only be async'ed on persisted records (currently: #{inspect})" unless self.persisted?
+
+        my_klass              = Resque::Plugins::Async::Worker
+        my_klass.queue        = options[:queue] || __send__(:class).name.underscore.pluralize.to_sym
+        my_klass.loner        = options[:loner] || false
+        my_klass.lock_timeout = options[:lock_timeout] || 0
+        my_klass.loner = true if my_klass.lock_timeout > 0 # Magick config
+
+        Resque.enqueue(
+          my_klass,
+          __send__(:class).name,
+          __send__(:id),
+          "sync_#{method_name}".to_sym,
+          *args
+        )
+      end
+    end
+  end
+end

data/lib/resque/plugins/async/worker.rb

@@ -0,0 +1,20 @@
+require 'resque-lock-timeout'
+
+class Resque::Plugins::Async::Worker
+  extend Resque::Plugins::LockTimeout
+
+  @queue        = :async_methods
+  @loner        = false
+  @lock_timeout = 0
+    
+  class << self
+        
+    attr_accessor :queue
+    attr_accessor :loner
+    attr_accessor :lock_timeout
+  
+    def perform klass, *args
+      klass.constantize.find(args.shift).send(args.shift, *args)
+    end
+  end
+end

data/resque-async-method-enhanced.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/resque-async-method-enhanced/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Joel AZEMAR', 'Nick Ragaz']
+  gem.email         = ['joel.azemar@gmail.com', 'nick.ragaz@gmail.com']
+  gem.description   = %q{Make Active Support instance methods asynchronous using resque.}
+  gem.summary       = %q{Make Active Support instance methods asynchronous using resque.}
+  gem.homepage      = 'http://github.com/joel/resque-async-method-enhanced'
+  gem.licenses      = [ 'MIT' ]
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.name          = 'resque-async-method-enhanced'
+  gem.require_paths = ['lib']
+  gem.version       = ResqueAsyncMethodEnhanced::VERSION
+
+  gem.add_runtime_dependency      'resque'
+  gem.add_runtime_dependency      'resque-lock-timeout'
+  gem.add_runtime_dependency      'activesupport'
+  gem.add_development_dependency  'rspec'
+  gem.add_development_dependency  'rake'
+end

data/spec/resque-async-method-enhanced/method_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Resque::Plugins::Async::Method do
+
+  context 'for valid record' do
+    
+    subject { MyKlass.new }
+    
+    before { Rails.env.stub test?: false }
+    
+    context 'with simple class' do
+      
+      class MyKlass
+        include Resque::Plugins::Async::Method
+    
+        def foo
+          'bar'
+        end
+        async_method :foo
+        
+        def persisted?
+          true
+        end
+        
+        def id
+          42
+        end
+      end
+
+      it { MyKlass.respond_to?(:async_method).should be_true }
+
+      context 'have defalut value' do
+        it { Resque::Plugins::Async::Worker.queue.should eql(:async_methods) }
+        it { Resque::Plugins::Async::Worker.loner.should be_false }
+        it { Resque::Plugins::Async::Worker.lock_timeout.should eql(0) }
+      end
+      
+      context 'alsways can be call method on sync mode' do
+        it { subject.respond_to?(:sync_foo).should be_true }
+        it { subject.sync_foo.should eql('bar') }
+      end
+  
+      context 'and on async mode' do
+    
+        before do
+          Resque.should_receive(:enqueue).with(Resque::Plugins::Async::Worker, 'MyKlass', 42, :sync_foo).and_return('it works')
+        end
+    
+        its(:foo) { should eql 'it works' }
+        
+      end
+      
+    end  
+
+  end
+end

data/spec/resque-async-method-enhanced/method_with_options_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Resque::Plugins::Async::Method do
+
+  context 'for valid record' do
+    
+    subject { MyAwesomeKlass.new }
+    
+    before { Rails.env.stub test?: false }
+    
+    context 'with options' do
+      
+      before { Resque.stub enqueue: nil }
+      
+      class MyAwesomeKlass
+        include Resque::Plugins::Async::Method
+    
+        def foo
+          'bar'
+        end
+        async_method :foo, queue: :my_queue,  loner: true, lock_timeout: 60
+        
+        def persisted?
+          true
+        end
+        
+        def id
+          42
+        end
+      end
+
+      context 'should have options values' do
+        
+        before { subject.foo }
+        
+        it { Resque::Plugins::Async::Worker.queue.should eql(:my_queue) }
+        it { Resque::Plugins::Async::Worker.loner.should be_true }
+        it { Resque::Plugins::Async::Worker.lock_timeout.should eql(60) }
+      end
+      
+    end
+  end
+end

data/spec/resque-async-method-enhanced/worker_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Resque::Plugins::Async::Worker do
+  
+  subject { Resque::Plugins::Async::Worker }
+  
+  context 'queue' do
+    context 'should be change of value' do
+      before { subject.queue = :foo }
+      describe 'when set :foo' do
+        its(:queue) { should eql :foo }
+      end
+    end
+  end
+  
+  class MyClass; end
+  
+  context '#perform' do
+    let(:my_class_instance) { MyClass.new }
+    
+    before do
+      MyClass.should_receive(:find).with(42).and_return(my_class_instance)
+      my_class_instance.should_receive(:foo).with('bar')
+    end
+    
+    it('should be call corretly Resque#perform') { subject.perform('MyClass', 42, 'foo', 'bar') }
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('..', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+require 'resque'
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/dependencies/autoload'
+require 'resque-lock-timeout'
+require 'resque-async-method-enhanced'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end
+
+RSpec.configuration.after(:all) do
+  Resque.inline = true
+end
+
+# Avoid call Rails.env.test? => false
+class Env; def test?; false; end; end
+class Logger; def info(s); puts(s); end; end
+
+class Rails
+  def self.env; Env.new; end
+  def self.logger; Logger.new; end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: resque-async-method-enhanced
+version: !ruby/object:Gem::Version
+  version: 1.3.1
+  prerelease: 
+platform: ruby
+authors:
+- Joel AZEMAR
+- Nick Ragaz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque-lock-timeout
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Make Active Support instance methods asynchronous using resque.
+email:
+- joel.azemar@gmail.com
+- nick.ragaz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- CHANGELOG.md
+- COMMANDS
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/resque-async-method-enhanced.rb
+- lib/resque-async-method-enhanced/version.rb
+- lib/resque/plugins/async/method.rb
+- lib/resque/plugins/async/worker.rb
+- resque-async-method-enhanced.gemspec
+- spec/resque-async-method-enhanced/method_spec.rb
+- spec/resque-async-method-enhanced/method_with_options_spec.rb
+- spec/resque-async-method-enhanced/worker_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/joel/resque-async-method-enhanced
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Make Active Support instance methods asynchronous using resque.
+test_files:
+- spec/resque-async-method-enhanced/method_spec.rb
+- spec/resque-async-method-enhanced/method_with_options_spec.rb
+- spec/resque-async-method-enhanced/worker_spec.rb
+- spec/spec_helper.rb