delayed_resque 1.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjE0NjkzODhkNGI2NDNlMTgwYzAzYzBiZWI5MDlhYzkwMGNkYTM2OA==
+  data.tar.gz: !binary |-
+    NTI0MDE4ZDA4ZjZiMTM3ZjNhYzJkYjllNDRlNGM4YjYzZjRmYjNlOA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YjliYTNkNjBjMzAzNDNmZTcwN2IwMzg4MzE0ODRkMjBiNmU0MDJmZDVjNjY4
+    NzhkMDdmY2NmMjEzM2Y1NzUyZjg0MDhhNGJhMWRhMmFiM2Q1Y2E5YjBiNjgx
+    ZDZhNDgxOTY1NGI3NmJiOWUyYzU2NTFhZDQxMjZmMzdjNDBhMmQ=
+  data.tar.gz: !binary |-
+    MTY0MTFjOGQ1NjIyYmYxMzMwZjY2ZDM2ZWEzZjVmZGM4NjEzNjJjNWM5YjRl
+    NmNiY2FjNmY2OTkwYjM3ZTlkNTBlNTlmMjQ4MzAwYTEwNjBhODc1NmM5Yzg2
+    ODY4MzRkYjAxOTVjZDVkMzMwYmE0M2FjYTZhN2EwY2U5NTFmODU=

data/README.md

@@ -0,0 +1,23 @@
+delayed_resque
+==============
+
+Provides delayed_job syntax to resque.
+
+Call `.delay.method(params)` on any object and it will be processed in the background.
+
+    # with delayed_job
+    @user.delay.activate!(@device)
+
+Parameters can be scalar values, active record instances, or classes (but not instances of non-AR objects).
+
+The queue to use for the method can be specified on the delay method:
+
+    @user.delay(:queue => :device_activation).activate!(@device)
+
+Credits
+-------
+
+Based on the work of https://github.com/defunkt/resque and 
+https://github.com/collectiveidea/delayed_job.
+
+Special Thanks to https://github.com/k1w1 for the spec and the extracting most of the code out of delayed_job

data/lib/delayed_resque/message_sending.rb

@@ -0,0 +1,61 @@
+require 'active_support/core_ext/module/aliasing'
+module DelayedResque
+  class DelayProxy 
+    def initialize(payload_class, target, options)
+      @payload_class = payload_class
+      @target = target
+      @options = {:queue => "default"}.update(options)
+    end
+
+    def method_missing(method, *args)
+
+      queue = @options[:queue] || @payload_class.queue
+      performable = @payload_class.new(@target, method.to_sym, @options, args)
+      if @options[:unique]
+        if @options[:run_at] or @options[:in]
+          ::Resque.remove_delayed(@payload_class, performable.store)
+        else
+          ::Resque.dequeue(@payload_class, performable.store)
+        end
+      end
+  
+
+      if @options[:run_at]
+        ::Resque.enqueue_at(@options[:run_at], @payload_class, performable.store) 
+      elsif @options[:in]
+        ::Resque.enqueue_in(@options[:in], @payload_class, performable.store)
+      else
+        ::Resque.enqueue_to(queue, @payload_class, performable.store)
+      end
+    end
+  end
+  
+  
+  module MessageSending
+    def delay(options = {})
+      DelayProxy.new(PerformableMethod, self, options)
+    end
+    alias __delay__ delay
+    
+    module ClassMethods
+      def handle_asynchronously(method, opts = {})
+        aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+        with_method, without_method = "#{aliased_method}_with_delay#{punctuation}", "#{aliased_method}_without_delay#{punctuation}"
+        define_method(with_method) do |*args|
+          curr_opts = opts.clone
+          curr_opts.each_key do |key|
+            if (val = curr_opts[key]).is_a?(Proc)
+              curr_opts[key] = if val.arity == 1
+                val.call(self)
+              else
+                val.call
+              end
+            end
+          end
+          delay(curr_opts).__send__(without_method, *args)
+        end
+        alias_method_chain method, :delay
+      end
+    end
+  end
+end

data/lib/delayed_resque/performable_mailer.rb

@@ -0,0 +1,21 @@
+require 'mail'
+
+module DelayedResque
+  class PerformableMailer < PerformableMethod
+    def self.perform(options)
+      PerformableMethod.perform(options).deliver
+    end
+  end
+
+  module DelayMail
+    def delay(options = {})
+      DelayProxy.new(PerformableMailer, self, options)
+    end
+  end
+end
+
+Mail::Message.class_eval do
+  def delay(*args)
+    raise RuntimeError, "Use MyMailer.delay.mailer_action(args) to delay sending of emails."
+  end
+end

data/lib/delayed_resque/performable_method.rb

@@ -0,0 +1,71 @@
+require 'active_record'
+
+module DelayedResque
+  class PerformableMethod < Struct.new(:object, :method, :args)
+    CLASS_STRING_FORMAT = /^CLASS\:([A-Z][\w\:]+)$/
+    AR_STRING_FORMAT = /^AR\:([A-Z][\w\:]+)\:(\d+)$/
+
+    def initialize(object, method, options, args)
+      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method,true)
+
+      @object = dump(object)
+      @method = method.to_sym
+      @options = options
+      @args = args.map { |a| dump(a) }
+    end
+
+    def display_name
+      case self.object
+      when CLASS_STRING_FORMAT then "#{$1}.#{method}"
+      when AR_STRING_FORMAT then "#{$1}##{method}"
+      else "Unknown##{method}"
+      end
+    end
+
+    def self.queue
+      "default"
+    end
+    
+    def self.perform(options)
+      object = options["obj"]
+      method = options["method"] 
+      args = options["args"] 
+      self.load(object).send(method, *args.map{|a| self.load(a)})
+    rescue ActiveRecord::RecordNotFound
+      Rails.logger.warn("PerformableMethod: failed to find record for #{object.inspect}")
+      # We cannot do anything about objects which were deleted in the meantime
+      true
+    end
+
+    def store
+      {"obj" => @object, "method" => @method, "args" => @args}.merge(@options[:params] || {})
+    end
+
+    private
+
+    def self.load(arg)
+      case arg
+      when CLASS_STRING_FORMAT then $1.constantize
+      when AR_STRING_FORMAT then $1.constantize.find($2)
+      when Hash then ::HashWithIndifferentAccess.new(arg)
+      else arg
+      end
+    end
+
+    def dump(arg)
+      case arg
+      when Class, Module then class_to_string(arg)
+      when ActiveRecord::Base then ar_to_string(arg)
+      else arg
+      end
+    end
+
+    def ar_to_string(obj)
+      "AR:#{obj.class}:#{obj.id}"
+    end
+
+    def class_to_string(obj)
+      "CLASS:#{obj.name}"
+    end
+  end
+end

data/lib/delayed_resque/railtie.rb

@@ -0,0 +1,17 @@
+require 'resque'
+require 'rails'
+
+module Delayed     
+  class Railtie < Rails::Railtie
+    initializer :after_initialize do
+      ActiveSupport.on_load(:action_mailer) do
+        ActionMailer::Base.send(:extend, DelayedResque::DelayMail)
+      end
+    end
+
+    rake_tasks do
+      load "resque/tasks.rb"
+      load "resque_scheduler/tasks.rb"
+    end
+  end
+end

data/lib/delayed_resque/version.rb

@@ -0,0 +1,3 @@
+module DelayedResque
+  VERSION = "1.0.1"
+end

data/lib/delayed_resque.rb

@@ -0,0 +1,16 @@
+require 'resque'
+require 'resque_scheduler'
+require 'active_support'
+require 'delayed_resque/message_sending'
+require 'delayed_resque/performable_method'
+if defined?(ActionMailer)
+  require 'action_mailer/version'
+  require 'delayed_resque/performable_mailer' if 3 == ActionMailer::VERSION::MAJOR
+end
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'delayed_resque/railtie' if defined?(Rails::Railtie)
+
+# Support delaying class methods.
+Object.send(:include, DelayedResque::MessageSending)
+Module.send(:include, DelayedResque::MessageSending::ClassMethods)  

data/spec/delayed_resque_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'resque_spec/scheduler'
+describe DelayedResque do
+  before do
+    ResqueSpec.reset!
+  end
+
+  class DummyObject      
+    include DelayedResque::MessageSending
+    @queue = "default"
+  
+    def self.first_method(param)
+    end
+  end
+  
+  describe "handle_asyncronously" do 
+    class Story
+      class << self ; def tell!(arg);end ; handle_asynchronously :tell! ;end 
+      def tell!(arg);end
+      handle_asynchronously :tell!
+    end
+
+    it "aliases original method for class methid" do 
+      expect(Story).to respond_to(:tell_without_delay!)
+      expect(Story).to respond_to(:tell_with_delay!)
+    end
+
+    it "aliases original method for instance method" do
+      expect(Story.new).to respond_to(:tell_without_delay!)
+      expect(Story.new).to respond_to(:tell_with_delay!)
+    end
+  end
+
+  context "class methods can be delayed" do
+    it "can delay method" do
+      DummyObject.delay.first_method(123)
+      DelayedResque::PerformableMethod.should have_queued({"obj"=>"CLASS:DummyObject", "method"=>:first_method, "args"=>[123]}).in(:default)
+    end
+    
+    it "delayed method is called" do
+      DummyObject.stub(:second_method).with(123, 456)
+      with_resque do
+        DummyObject.delay.second_method(123, 456)
+      end
+    end
+    
+    it "can't delay missing method" do
+      expect {
+        DummyObject.delay.non_existent_method
+      }.to raise_error(NoMethodError)
+    end
+    
+    it "can pass additional params" do
+      DummyObject.delay(:params => {"k" => "v"}).first_method(123)
+      DelayedResque::PerformableMethod.should have_queued({"obj"=>"CLASS:DummyObject", "method"=>:first_method, "args"=>[123], "k" => "v"}).in(:default)
+    end
+    
+  end
+  
+  context "active record methods can be delayed" do
+  
+    ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'dummy_models'")
+    ActiveRecord::Base.connection.create_table(:dummy_models) do |t|
+      t.integer :value
+    end
+
+    class DummyModel < ActiveRecord::Base
+      def update_value(new_value1, new_value2)
+        self.value = new_value1 + new_value2
+        save!
+      end
+      
+      def copy_value(record)
+        self.value = record.value
+        save!
+      end
+
+      def tell!(args)
+        p "SLEEEP"
+      end 
+      handle_asynchronously :tell!  
+    end
+    
+    it "can delay method" do
+      record = DummyModel.create(:value => 1)
+      with_resque do
+        record.delay.update_value(3, 7)
+      end
+      record.reload.value.should eq(10)
+    end
+    
+    it "AR model can be parameter to delay" do
+      record1 = DummyModel.create(:value => 1)
+      record2 = DummyModel.create(:value => 3)
+      with_resque do
+        record1.delay.copy_value(record2)
+      end
+      record1.reload.value.should eq(3)
+    end
+    
+    it "job are enqueue in redis" do 
+      record1 = DummyModel.create
+      record1.tell!(1)
+      expect(Resque.size("default")).to eq(1)
+    end  
+  end
+  
+  context "methods can be delayed for an interval" do
+    it "can delay method" do
+      DummyObject.delay(:in => 5.minutes).first_method(123)
+      DelayedResque::PerformableMethod.should have_scheduled({"obj"=>"CLASS:DummyObject", "method"=>:first_method, "args"=>[123]}).in(5 * 60)
+    end
+    
+    it "can run at specific time" do
+      at_time = Time.now.utc + 10.minutes
+      DummyObject.delay(:run_at  => at_time).first_method(123)
+      DelayedResque::PerformableMethod.should have_scheduled({"obj"=>"CLASS:DummyObject", "method"=>:first_method, "args"=>[123]}).at(at_time)
+      DelayedResque::PerformableMethod.should have_schedule_size_of(1)
+    end
+  end
+  
+  context "unique jobs" do
+    it "can remove preceeding jobs" do
+      DummyObject.delay.first_method(123)
+      DelayedResque::PerformableMethod.should have_queued({"obj"=>"CLASS:DummyObject", "method"=>:first_method, "args"=>[123]})
+      DelayedResque::PerformableMethod.should have_queue_size_of(1)
+      DummyObject.delay.first_method(124)
+      DelayedResque::PerformableMethod.should have_queue_size_of(2)
+      DummyObject.delay(:unique => true).first_method(123)
+      DelayedResque::PerformableMethod.should have_queue_size_of(2)
+    end
+    
+    it "can remove preceeding delayed jobs" do
+      at_time = Time.now.utc + 10.minutes
+      DummyObject.delay(:run_at => at_time).first_method(123)
+      DelayedResque::PerformableMethod.should have_scheduled({"obj"=>"CLASS:DummyObject", "method"=>:first_method, "args"=>[123]}).at(at_time)
+      DelayedResque::PerformableMethod.should have_schedule_size_of(1)
+      DummyObject.delay(:run_at => at_time + 1).first_method(123)
+      DelayedResque::PerformableMethod.should have_schedule_size_of(2)
+      DummyObject.delay(:run_at => at_time + 2, :unique => true).first_method(123)
+      DelayedResque::PerformableMethod.should have_schedule_size_of(1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec'
+require 'resque_scheduler'
+require 'resque_spec'
+require 'resque_spec/scheduler'
+require 'delayed_resque'
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+ActiveRecord::Base.establish_connection(
+	:adapter => "sqlite3",
+	:database => "#{root}/test.db"
+)
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: delayed_resque
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Viren Negi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.19.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.19.0
+- !ruby/object:Gem::Dependency
+  name: resque-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: resque_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Gem design to wrap Delayed Job nicety syntax under Resque
+email:
+- meetme2meat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/delayed_resque/message_sending.rb
+- lib/delayed_resque/performable_mailer.rb
+- lib/delayed_resque/performable_method.rb
+- lib/delayed_resque/railtie.rb
+- lib/delayed_resque/version.rb
+- lib/delayed_resque.rb
+- README.md
+- spec/delayed_resque_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/meetme2meat/delayed_resque
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- MIT-LICENSE
+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.0.5
+signing_key: 
+specification_version: 4
+summary: Delayed Job Syntax mapped over Resque
+test_files:
+- spec/delayed_resque_spec.rb
+- spec/spec_helper.rb
+has_rdoc: