Allow use without activerecord

lib/resque_delay/message_sending.rb

@@ -4,7 +4,7 @@ class DelayProxy < ActiveSupport::BasicObject
     def initialize(target, options)
       @target = target
       @options = options
-      if @options[:in].not_nil? && !@options[:in].kind_of?(::Fixnum)
+      if @options[:in].present? && !@options[:in].kind_of?(::Fixnum)
         raise ::ArgumentError.new("Delayed settings must be a Fixnum! not a #{@options[:in].class.name}") 
       end
     end
@@ -19,24 +19,29 @@ def method_missing(method, *args)
       end
     end
 
-    # Called asynchrously by Resque
+    # Called asynchronously by Resque
     def self.perform(args)
-      PerformableMethod.new(*args).perform
+      if args.respond_to?(:[])
+        PerformableMethod.new(args["object"], args["method"], args["args"]).perform
+      else
+        PerformableMethod.new(*args).perform
+      end
     end
 
     private
-      def delay?
-        delay.to_i > 0
-      end
 
-      def delay
-        @delay ||= @options[:in]
-      end
+    def delay?
+      delay.to_i > 0
+    end
+
+    def delay
+      @delay ||= @options[:in]
+    end
   end
 
   module MessageSending
     def delay(options = {})
       DelayProxy.new(self, options)
     end
   end
-end
+end

lib/resque_delay/performable_method.rb

@@ -2,9 +2,10 @@ module ResqueDelay
   class PerformableMethod < Struct.new(:object, :method, :args)
     CLASS_STRING_FORMAT = /^CLASS\:([A-Z][\w\:]+)$/
     AR_STRING_FORMAT    = /^AR\:([A-Z][\w\:]+)\:(\d+)$/
+    DM_STRING_FORMAT    = /^DM\:((?:[A-Z][a-zA-z]+)(?:\:\:[A-Z][a-zA-z]+)*)\:([\d\:]+)$/
 
     def self.create(object, method, args)
-      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method)
+      raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method, true)
       self.new(object, method, args)
     end
 
@@ -18,15 +19,19 @@ def display_name
       case self.object
       when CLASS_STRING_FORMAT then "#{$1}.#{method}"
       when AR_STRING_FORMAT    then "#{$1}##{method}"
+      when DM_STRING_FORMAT    then "#{$1}##{method}"
       else "Unknown##{method}"
       end
     end
 
     def perform
-      load(object).send(method, *args.map{|a| load(a)})
-    rescue ActiveRecord::RecordNotFound
-      # We cannot do anything about objects which were deleted in the meantime
-      true
+      load(object).send(method, *args.map { |a| load(a) })
+    rescue => e
+      if defined?(ActiveRecord) && e.kind_of?(ActiveRecord::RecordNotFound)
+        true
+      else
+        raise
+      end
     end
 
     private
@@ -35,24 +40,33 @@ def load(arg)
       case arg
       when CLASS_STRING_FORMAT then $1.constantize
       when AR_STRING_FORMAT    then $1.constantize.find($2)
+      when DM_STRING_FORMAT    then $1.constantize.get!(*$2.split(':'))
       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
+      if arg.kind_of?(Class) || arg.kind_of?(Module)
+        class_to_string(arg)
+      elsif defined?(ActiveRecord) && arg.kind_of?(ActiveRecord::Base)
+        ar_to_string(arg)
+      elsif defined?(DataMapper) && arg.kind_of?(DataMapper::Resource)
+        dm_to_string(arg)
+      else
+        arg
       end
     end
 
     def ar_to_string(obj)
       "AR:#{obj.class}:#{obj.id}"
     end
 
+    def dm_to_string(obj)
+      "DM:#{obj.class}:#{obj.key.join(':')}"
+    end
+
     def class_to_string(obj)
       "CLASS:#{obj.name}"
     end
   end
-end
+end

resque-delay.gemspec

@@ -14,9 +14,8 @@ Gem::Specification.new do |s|
   s.files            += Dir.glob("spec/**/*")
 
   s.add_dependency    "resque", ">= 1.9"
-  s.add_dependency    "activerecord", ">= 2.3"
 
   s.description = <<DESCRIPTION
 Enable send_later support for Resque
 DESCRIPTION
-end
+end