delayed-method 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Phuong Nguyen
+
+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,56 @@
+delayed-method
+---------------
+
+Requires the resque gem.
+
+Allows you to move a long run method to background to be processed later by resque
+
+I have to come up with this because all other resque based delayed execution gem out there that I have tried is complex, buggy and doesn't work.
+
+This delayed-method is designed to be deadly simple, doesn't hack deep into resque itself (so it is more likely to continue to work, even with further internal change of resque)
+
+Infact, it just rely on Resque.enqueue at the deepest level. It doesn't deal with serialization, so it won't have any problem with serialization
+
+Installation
+============
+
+    $ gem install delayed-method
+
+
+Usage
+============
+
+  Given you have this long call inside your web request:
+
+Executor.long_call(arg1, arg2)
+
+  then you can easily move it to the delayed queue in background with this:
+
+DelayedMethod.enqueue(Executor, :long_call, arg1, arg2)
+
+  Or if you use active record model:
+
+model.long_call(arg1, arg2)
+
+  then you can easily move it to the delayed queue in background with this:
+
+DelayedMethod.enqueue(model, :long_call, arg1, arg2)
+
+
+That's it. This is the only 2 cases that DelayedMethod will work.
+
+
+Warning
+===========
+
+Please notice that Class method call and ActiveRecord instance call are the only 2 cases supported.
+Even in that case, only simple arguments (string, number) are supported.
+Using object, structure, or symbol as argument will yield unexpected result. (Symbol will be converted to String).
+
+delayed-method is only that simple and will always be that simple.
+I don't want to promise a bundle of complex serialization or shit that will eventually turn into something sophisticated, easily fall apart when either resque or rails updated.
+
+Author
+=====
+
+Phuong Nguyen:: phuongnd08@gmail.com

data/Rakefile

@@ -0,0 +1,7 @@
+task :default => :spec
+task :test    => :spec
+
+desc "Run specs"
+task :spec do
+  exec "rspec spec/"
+end

data/lib/delayed-method.rb

@@ -0,0 +1,29 @@
+require 'resque'
+require 'active_support'
+
+class DelayedMethod
+  @queue = :delayed
+
+  class << self
+    include ActiveSupport::Inflector
+
+    def perform(klass_name, instance_id, method, *args)
+      if instance_id
+        constantize(klass_name).find(instance_id).send(method, *args)
+      else
+        constantize(klass_name).send(method, *args)
+      end
+    end
+
+    def enqueue(object, method, *args)
+      raise ArgumentError.new("object does not respond to #{method}") unless object.respond_to?(method)
+      if object.is_a? Class
+        Resque.enqueue(DelayedMethod, object.name, nil, method, *args)
+      elsif object.is_a? ActiveRecord::Base
+        Resque.enqueue(DelayedMethod, object.class.name, object.id, method, *args)
+      else
+        raise ArgumentError.new("Only class and ActiveRecord resource are supported")
+      end
+    end
+  end
+end

data/spec/delayed_method_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'active_record'
+
+describe DelayedMethod do
+  describe "enqueue and perform" do
+    context "object does not respond method" do
+      it "raises exception" do
+        expect {
+          DelayedMethod.enqueue(Object, :non_existent_method)
+        }.to raise_error
+      end
+    end
+
+    context "object responds to method" do
+      class TestClass
+        def self.execute(name, value)
+
+        end
+      end
+
+      context "for class object" do
+        it "queues a job to cause execution to happen" do
+          TestClass.should_receive(:execute).with("sample", "another_sample")
+          DelayedMethod.enqueue(TestClass, :execute, "sample", "another_sample")
+          klass, args = Resque.reserve(:delayed)
+          klass.perform(*args)
+        end
+      end
+
+      def mock_armodel
+        mock(ActiveRecord::Base, { :id => 1, :execute => true }).tap do |armodel|
+          armodel.should_receive(:is_a?).with(Class).and_return(false)
+          armodel.should_receive(:is_a?).with(ActiveRecord::Base).and_return(true)
+          armodel.should_receive(:class).and_return ActiveRecord::Base
+          ActiveRecord::Base.stub(:find).with(1).and_return armodel
+        end
+      end
+      context "for active record instance" do
+        it "queues a job to cause execution to happen" do
+          armodel = mock_armodel
+          armodel.should_receive(:execute).with("sample", "another_sample")
+          DelayedMethod.enqueue(armodel, :execute, "sample", "another_sample")
+          klass, args = Resque.reserve(:delayed)
+          klass.perform(*args)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'bundler'
+require 'rspec'
+require 'delayed-method'
+require 'debugger'

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: delayed-method
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Phuong Nguyen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-14 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: 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: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  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: activerecord
+  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: Allow you to quickly move a long call to background which then executed
+  by resque
+email: phuongnd08@gmail
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- LICENSE
+- lib/delayed-method.rb
+- spec/delayed_method_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/phuongnd08/delayed-method
+licenses: []
+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: Allow you to quickly move a long call to background which then executed by
+  resque
+test_files: []