resque-retry 0.2.2 → 1.0.0.a

data/HISTORY.md

@@ -1,13 +1,21 @@
-## HEAD
+## HEAD - will become v1.0.0
 
-## 0.2.1 (2011-12-08)
+**INCLUDES NON-BACKWARDS COMPATIBLE CHANGES**
+
+* Fixed issues related to infinate job retries and v1.20.0 of resque.
+* Minimum gem dependency versions changed: resque >= 1.10.0, resque-scheduler >= 1.9.9
+* Feature: Setting `@retry_job_delegate` allows you to seperate the orignal job from a the retry job. (@tanob/@jniesen)
+* Web interface will work without needing to `require` your job code. (n.b. less details avaialble via web).
+* IMPORTANT: `#identifier` method has been namedspaced to `#retry_identifier`.
+* Bugfix: `Remove` button on retry web interface was not working.
+
+## 0.2.2 (2011-12-08)
 
 * Feature: Ability to set `retry_delay` per exception type. (Dave Benvenuti)
 
 ## 0.2.1 (2011-11-23)
 
-* Bugfix: Fixed error when we tried to parse a number/string as JSON on the
-  reque-retry web interface.
+* Bugfix: Fixed error when we tried to parse a number/string as JSON on the reque-retry web interface.
 
 ## 0.2.0 (2011-11-22)
 
@@ -17,10 +25,9 @@
     PREVIOUSLY: 0 == infinite retries.
            NOW: -1 == infinite retries; 0 == means never retry.
 
-* Bugfix: `#redis_retry_key` incorrectly built key when custom identifier
-  was used. (Bogdan Gusiev)
+* Bugfix: `#redis_retry_key` incorrectly built key when custom identifier was used. (Bogdan Gusiev)
 * Feature: Ability to sleep worker after re-queuing a job, may be used to bias
-  against the same worker from picking up the job again. (Michael Keirnan)
+           against the same worker from picking up the job again. (Michael Keirnan)
 * Feature: Ability to remove retry jobs using resque-web. (Thiago Morello)
 * Added example demo application.
 * Added Bundler `Gemfile`.
@@ -50,10 +57,8 @@
 ## 0.0.2 (2010-05-06)
 
 * Bugfix: Were calling non-existent method to delete redis key.
-* Delay no-longer falls back to `sleep`. resque-scheduler is a required
-  dependancy.
-* Redis key doesn't include ending colon `:` if no args were passed
-  to the job.
+* Delay no-longer falls back to `sleep`. resque-scheduler is a required dependancy.
+* Redis key doesn't include ending colon `:` if no args were passed to the job.
 
 ## 0.0.1 (2010-04-27)
 

data/README.md

@@ -1,7 +1,7 @@
 resque-retry
 ============
 
-A [Resque][rq] plugin. Requires Resque >= 1.8.0 & [resque-scheduler][rqs].
+A [Resque][rq] plugin. Requires Resque >= 1.10.0 & [resque-scheduler][rqs] >= 1.9.9.
 
 resque-retry provides retry, delay and exponential backoff support for
 resque jobs.
@@ -12,6 +12,8 @@ resque jobs.
   * Multiple failure backend with retry suppression & resque-web tab.
   * Small & Extendable - plenty of places to override retry logic/settings.
 
+[![Build Status](https://secure.travis-ci.org/lantins/resque-retry.png?branch=master)](http://travis-ci.org/lantins/resque-retry)
+
 Install & Quick Start
 ---------------------
 
@@ -19,6 +21,9 @@ To install:
 
     $ gem install resque-retry
 
+If your using [Bundler][bundler] to manage your dependencies, you should add `gem
+'resque-retry'` to your projects `Gemfile`.
+
 Add this to your `Rakefile`:
 
     require 'resque/tasks'
@@ -299,17 +304,17 @@ job arguments, to modify the arguments for the next retry attempt.
       end
     end
 
-### Job Identifier/Key
+### Job Retry Identifier/Key
 
 The retry attempt is incremented and stored in a Redis key. The key is
-built using the `identifier`. If you have a lot of arguments or really long
-ones, you should consider overriding `identifier` to define a more precise
-or loose custom identifier.
+built using the `retry_identifier`. If you have a lot of arguments or really long
+ones, you should consider overriding `retry_identifier` to define a more precise
+or loose custom retry identifier.
 
-The default identifier is just your job arguments joined with a dash `-`.
+The default retry identifier is just your job arguments joined with a dash `-`.
 
 By default the key uses this format: 
-`resque-retry:<job class name>:<identifier>`.
+`resque-retry:<job class name>:<retry_identifier>`.
 
 Or you can define the entire key by overriding `redis_retry_key`.
 
@@ -317,7 +322,7 @@ Or you can define the entire key by overriding `redis_retry_key`.
       extend Resque::Plugins::Retry
       @queue = :mt_messages
 
-      def self.identifier(mt_id, mobile_number, message)
+      def self.retry_identifier(mt_id, mobile_number, message)
         "#{mobile_number}:#{mt_id}"
       end
 
@@ -340,3 +345,5 @@ Contributing/Pull Requests
 [god]: http://github.com/mojombo/god
 [rq]: http://github.com/defunkt/resque
 [rqs]: http://github.com/bvandenbos/resque-scheduler
+[bundler]: http://gembundler.com/
+

data/lib/resque-retry/server.rb

@@ -9,10 +9,14 @@ module ResqueRetry
         helpers do
           # builds a retry key for the specified job.
           def retry_key_for_job(job)
-            klass = Resque.constantize(job['class'])
-            if klass.respond_to?(:redis_retry_key)
-              klass.redis_retry_key(job['args'])
-            else
+            begin
+              klass = Resque.constantize(job['class'])
+              if klass.respond_to?(:redis_retry_key)
+                klass.redis_retry_key(job['args'])
+              else
+                nil
+              end
+            rescue NameError
               nil
             end
           end
@@ -21,7 +25,7 @@ module ResqueRetry
           def retry_attempts_for_job(job)
             Resque.redis.get(retry_key_for_job(job))
           end
-          
+
           # gets the failure details hash for a job.
           def retry_failure_details(retry_key)
             Resque.decode(Resque.redis.get("failure_#{retry_key}"))
@@ -33,8 +37,7 @@ module ResqueRetry
             File.read(File.join(File.dirname(__FILE__), "server/views/#{path}"))
           end
 
-          # Cancels job retry
-          #
+          # cancels job retry
           def cancel_retry(job)
             klass = Resque.constantize(job['class'])
             retry_key = retry_key_for_job(job)

data/lib/resque-retry/server/views/retry.erb

@@ -23,26 +23,24 @@
   <% timestamps.each do |timestamp| %>
     <% job = resque.delayed_timestamp_peek(timestamp, 0, 1).first %>
     <% next unless job %>
-    <% retry_key = retry_key_for_job(job) %>
     <tr>
       <td>
-        <form action="<%= url "retry/#{timestamp}/remove" %>" method="post">
-          <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
+        <form action="<%= u "retry/#{timestamp}/remove" %>" method="post">
           <input type="submit" value="Remove">
         </form>
-        <form action="<%= url "/delayed/queue_now" %>" method="post">
+        <form action="<%= u "/delayed/queue_now" %>" method="post">
           <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
           <input type="submit" value="Queue now">
         </form>
       </td>
-      <td><a href="<%= url "retry/#{timestamp}" %>"><%= format_time(Time.at(timestamp)) %></a></td>
+      <td><a href="<%= u "retry/#{timestamp}" %>"><%= format_time(Time.at(timestamp)) %></a></td>
       <td><%= delayed_timestamp_size = resque.delayed_timestamp_size(timestamp) %></td>
       <% if job && delayed_timestamp_size == 1 %>
         <td><%= h job['class'] %></td>
         <td><%= h job['args'].inspect %></td>
         <td><%= retry_attempts_for_job(job) || '<i>n/a</i>' %></td>
       <% else %>
-        <td><a href="<%= url "retry/#{timestamp}" %>">see details</a></td>
+        <td><a href="<%= u "retry/#{timestamp}" %>">see details</a></td>
         <td></td>
         <td></td>
       <% end %>

data/lib/resque-retry/server/views/retry_timestamp.erb

@@ -51,7 +51,7 @@
         <% end %>
       <% end %>
       <td>
-        <form action="<%= url "retry/#{timestamp}/jobs/#{CGI.escape(Resque.encode(job))}/remove" %>" method="post">
+        <form action="<%= u "retry/#{timestamp}/jobs/#{CGI.escape(Resque.encode(job))}/remove" %>" method="post">
           <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
           <input type="submit" value="Remove">
         </form>

data/lib/resque/failure/multiple_with_retry_suppression.rb

@@ -25,7 +25,7 @@ module Resque
       # Store the lastest failure information in redis, used by the web
       # interface.
       def save
-        if ! (retryable? && retrying?)
+        if !(retryable? && retrying?)
           cleanup_retry_failure_log!
           super
         elsif retry_delay > 0
@@ -39,13 +39,13 @@ module Resque
             :queue     => queue
           }
 
-          redis.setex(failure_key, 2*retry_delay, Resque.encode(data))
+          redis.setex(failure_key, 2*retry_delay, encode(data))
         end
       end
 
       # Expose this for the hook's use.
       def self.failure_key(retry_key)
-        'failure_' + retry_key
+        'failure-' + retry_key
       end
 
       protected

data/lib/resque/plugins/exponential_backoff.rb

@@ -25,7 +25,7 @@ module Resque
     #     @backoff_strategy = [0, 60]
     #
     #     # used to build redis key, for counting job attempts.
-    #     def self.identifier(mt_id, mobile_number, message)
+    #     def self.retry_identifier(mt_id, mobile_number, message)
     #       "#{mobile_number}:#{mt_id}"
     #     end
     #

data/lib/resque/plugins/retry.rb

@@ -23,7 +23,7 @@ module Resque
     #     @retry_delay = 60 # default: 0
     #
     #     # used to build redis key, for counting job attempts.
-    #     def self.identifier(url, hook_id, hmac_key)
+    #     def self.retry_identifier(url, hook_id, hmac_key)
     #       "#{url}-#{hook_id}"
     #     end
     #
@@ -40,16 +40,16 @@ module Resque
         subclass.instance_variable_set("@retry_criteria_checks", retry_criteria_checks.dup)
       end
 
-      # @abstract You may override to implement a custom identifier,
+      # @abstract You may override to implement a custom retry identifier,
       #           you should consider doing this if your job arguments
-      #           are many/long or may not cleanly cleanly to strings.
+      #           are many/long or may not cleanly convert to strings.
       #
-      # Builds an identifier using the job arguments. This identifier
+      # Builds a retry identifier using the job arguments. This identifier
       # is used as part of the redis key.
       #
       # @param [Array] args job arguments
       # @return [String] job identifier
-      def identifier(*args)
+      def retry_identifier(*args)
         args_string = args.join('-')
         args_string.empty? ? nil : args_string
       end
@@ -59,7 +59,7 @@ module Resque
       #
       # @return [String] redis key
       def redis_retry_key(*args)
-        ['resque-retry', name, identifier(*args)].compact.join(":").gsub(/\s/, '')
+        ['resque-retry', name, retry_identifier(*args)].compact.join(":").gsub(/\s/, '')
       end
 
       # Maximum number of retrys we can attempt to successfully perform the job.
@@ -103,7 +103,11 @@ module Resque
       def sleep_after_requeue
         @sleep_after_requeue ||= 0
       end
-      
+
+      def retry_job_delegate
+        @retry_job_delegate ||= nil
+      end
+
       # @abstract
       # Modify the arguments used to retry the job. Use this to do something
       # other than try the exact same job again.
@@ -149,7 +153,7 @@ module Resque
 
         # call user retry criteria check blocks.
         retry_criteria_checks.each do |criteria_check|
-          should_retry ||= !!criteria_check.call(exception, *args)
+          should_retry ||= !!instance_exec(exception, *args, &criteria_check)
         end
 
         should_retry
@@ -206,12 +210,18 @@ module Resque
         # we'll just check here to see whether it takes the additional exception class argument or not
         temp_retry_delay = ([-1, 1].include?(method(:retry_delay).arity) ? retry_delay(exception.class) : retry_delay)
 
+        retry_in_queue = retry_job_delegate ? retry_job_delegate : self
         if temp_retry_delay <= 0
           # If the delay is 0, no point passing it through the scheduler
-          Resque.enqueue(self, *args_for_retry(*args))
+          Resque.enqueue(retry_in_queue, *args_for_retry(*args))
         else
-          Resque.enqueue_in(temp_retry_delay, self, *args_for_retry(*args))
+          Resque.enqueue_in(temp_retry_delay, retry_in_queue, *args_for_retry(*args))
         end
+
+        # remove retry key from redis if we handed retry off to another queue.
+        clean_retry_key(*args) if retry_job_delegate
+
+        # sleep after requeue if enabled.
         sleep(sleep_after_requeue) if sleep_after_requeue > 0
       end
 
@@ -219,6 +229,9 @@ module Resque
       #
       # Increments and sets the `@retry_attempt` count.
       def before_perform_retry(*args)
+        @on_failure_retry_hook_already_called = false
+
+        # store number of retry attempts.
         retry_key = redis_retry_key(*args)
         Resque.redis.setnx(retry_key, -1)             # default to -1 if not set.
         @retry_attempt = Resque.redis.incr(retry_key) # increment by 1.
@@ -228,19 +241,42 @@ module Resque
       #
       # Deletes retry attempt count from Redis.
       def after_perform_retry(*args)
-        Resque.redis.del(redis_retry_key(*args))
+        clean_retry_key(*args)
       end
 
       # Resque on_failure hook.
       #
       # Checks if our retry criteria is valid, if it is we try again.
       # Otherwise the retry attempt count is deleted from Redis.
+      #
+      # NOTE: This hook will only allow execution once per job perform attempt.
+      #       This was added because Resque v1.20.0 calls the hook twice.
+      #       IMO; this isn't something resque-retry should have to worry about!
       def on_failure_retry(exception, *args)
+        return if @on_failure_retry_hook_already_called
+
         if retry_criteria_valid?(exception, *args)
           try_again(exception, *args)
         else
-          Resque.redis.del(redis_retry_key(*args))
+          clean_retry_key(*args)
+        end
+
+        @on_failure_retry_hook_already_called = true
+      end
+
+      def instance_exec(*args, &block)
+        mname = "__instance_exec_#{Thread.current.object_id.abs}"
+        class << self; self end.class_eval{ define_method(mname, &block) }
+        begin
+          ret = send(mname, *args)
+        ensure
+          class << self; self end.class_eval{ undef_method(mname) } rescue nil
         end
+        ret
+      end
+
+      def clean_retry_key(*args)
+        Resque.redis.del(redis_retry_key(*args))
       end
 
     end

data/test/multiple_failure_test.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class MultipleFailureTest < MiniTest::Unit::TestCase
+
   def setup
     Resque.redis.flushall
     @worker = Resque::Worker.new(:testing)
@@ -8,13 +9,26 @@ class MultipleFailureTest < MiniTest::Unit::TestCase
 
     @old_failure_backend = Resque::Failure.backend
     MockFailureBackend.errors = []
-    Resque::Failure::MultipleWithRetrySuppression.classes = [MockFailureBackend]
+    Resque::Failure::MultipleWithRetrySuppression.classes = [ MockFailureBackend ]
     Resque::Failure.backend = Resque::Failure::MultipleWithRetrySuppression
   end
 
   def failure_key_for(klass)
     args = []
-    key = "failure_" + klass.redis_retry_key(args)
+    key = 'failure-' + klass.redis_retry_key(args)
+  end
+
+  def test_failure_is_passed_on_when_job_class_not_found
+    skip 'commit 7113b0df to `resque` gem means the failure backend is never called'
+    new_job_class = Class.new(LimitThreeJob).tap { |klass| klass.send(:instance_variable_set, :@queue, LimitThreeJob.instance_variable_get(:@queue)) }
+    Object.send(:const_set, 'LimitThreeJobTemp', new_job_class)
+    Resque.enqueue(LimitThreeJobTemp)
+
+    Object.send(:remove_const, 'LimitThreeJobTemp')
+    perform_next_job(@worker)
+
+    assert_equal 1, MockFailureBackend.errors.count, 'should have one error'
+    assert_match /uninitialized constant LimitThreeJobTemp/, MockFailureBackend.errors.first
   end
 
   def test_last_failure_is_saved_in_redis_if_delay
@@ -26,6 +40,29 @@ class MultipleFailureTest < MiniTest::Unit::TestCase
     assert Resque.redis.exists(key)
   end
 
+  def test_retry_key_splatting_args
+    # were expecting this to be called twice:
+    # - once before the job is executed.
+    # - once by the failure backend.
+    RetryDefaultsJob.expects(:redis_retry_key).with({'a' => 1, 'b' => 2}).times(2)
+
+    Resque.enqueue(RetryDefaultsJob, {'a' => 1, 'b' => 2})
+    perform_next_job(@worker)
+  end
+
+  def test_last_failure_removed_from_redis_after_error_limit
+    3.times do
+      Resque.enqueue(LimitThreeJobDelay1Hour)
+      perform_next_job(@worker)
+    end
+
+    key = failure_key_for(LimitThreeJobDelay1Hour)
+    assert Resque.redis.exists(key), 'key should still exist'
+
+    Resque.enqueue(LimitThreeJobDelay1Hour)
+    perform_next_job(@worker)
+    assert !Resque.redis.exists(key), 'key should have been removed.'
+  end
 
   def test_last_failure_has_double_delay_redis_expiry_if_delay
     Resque.enqueue(LimitThreeJobDelay1Hour)
@@ -45,7 +82,6 @@ class MultipleFailureTest < MiniTest::Unit::TestCase
     assert !Resque.redis.exists(key)
   end
 
-
   def test_errors_are_suppressed_up_to_retry_limit
     Resque.enqueue(LimitThreeJob)
     3.times do
@@ -73,8 +109,8 @@ class MultipleFailureTest < MiniTest::Unit::TestCase
     assert_equal 5, MockFailureBackend.errors.size
   end
 
-  def test_custom_identifier_job
-    Resque.enqueue(CustomIdentifierFailingJob, 'qq', 2)
+  def test_custom_retry_identifier_job
+    Resque.enqueue(CustomRetryIdentifierFailingJob, 'qq', 2)
     4.times do
       perform_next_job(@worker)
     end

data/test/retry_inheriting_checks_test.rb

@@ -30,4 +30,16 @@ class RetryInheritingChecksTest < MiniTest::Unit::TestCase
     assert_equal 1, klass.retry_criteria_checks.size
     assert_equal 'test', klass.test_value
   end
+
+  def test_retry_criteria_check_should_be_evaluated_under_child_context
+    Resque.enqueue(InheritedJob, 'arg')
+
+    10.times do
+      perform_next_job(@worker)
+    end
+
+    assert_equal 0, BaseJob.retry_attempt, "BaseJob retry attempts"
+    assert_equal 0, InheritedJob.retry_attempt, "InheritedJob retry attempts"
+    assert_equal 5, InheritedRetryJob.retry_attempt, "InheritedRetryJob retry attempts"
+  end
 end

data/test/retry_test.rb

@@ -142,6 +142,31 @@ class RetryTest < MiniTest::Unit::TestCase
     assert_equal 0, Resque.info[:pending], 'pending jobs'
   end
 
+  def test_retry_failed_jobs_in_separate_queue
+    Resque.enqueue(JobWithRetryQueue, 'arg1')
+
+    perform_next_job(@worker)
+
+    assert job_from_retry_queue = Resque.pop(:testing_retry)
+    assert_equal ['arg1'], job_from_retry_queue['args']
+    assert_equal nil, Resque.redis.get(JobWithRetryQueue.redis_retry_key('arg1'))
+  end
+
+  def test_clean_retry_key_should_splat_args
+    JobWithRetryQueue.expects(:clean_retry_key).once.with({"a" => 1, "b" => 2})
+
+    Resque.enqueue(JobWithRetryQueue, {"a" => 1, "b" => 2})
+
+    perform_next_job(@worker)
+  end
+
+  def test_retry_delayed_failed_jobs_in_separate_queue
+    Resque.enqueue(DelayedJobWithRetryQueue, 'arg1')
+    Resque.expects(:enqueue_in).with(1, JobRetryQueue, 'arg1')
+
+    perform_next_job(@worker)
+  end
+
   def test_delete_redis_key_when_job_is_successful
     Resque.enqueue(GoodJob, 'arg1')
 

data/test/test_helper.rb

@@ -2,20 +2,22 @@ dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + '/../lib'
 $TESTING = true
 
-gem 'minitest'
+require 'rubygems'
 require 'minitest/unit'
 require 'minitest/pride'
 require 'rack/test'
-require 'simplecov'
+require 'mocha'
 
-SimpleCov.start do
-  add_filter "/test/"
+if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '1.9'
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/test/'
+  end
 end
 
 require 'resque-retry'
 require dir + '/test_jobs'
 
-
 # make sure we can run redis
 if !system("which redis-server")
   puts '', "** can't find `redis-server` in your path"
@@ -29,16 +31,12 @@ end
 at_exit do
   next if $!
 
-  if defined?(MiniTest)
-    exit_code = MiniTest::Unit.new.run(ARGV)
-  else
-    exit_code = Test::Unit::AutoRunner.run
-  end
+  exit_code = MiniTest::Unit.new.run(ARGV)
 
   pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
   puts "Killing test redis server..."
   `rm -f #{dir}/dump.rdb`
-  Process.kill("KILL", pid.to_i)
+  `kill -9 #{pid}`
   exit exit_code
 end
 

data/test/test_jobs.rb

@@ -44,6 +44,35 @@ class SleepDelay1SecondJob < RetryDefaultsJob
   end
 end
 
+class JobRetryQueue
+  extend Resque::Plugins::Retry
+  @queue = :testing_retry
+
+  def self.perform(*args)
+  end
+end
+
+class JobWithRetryQueue
+  extend Resque::Plugins::Retry
+  @queue = :testing
+  @retry_job_delegate = JobRetryQueue
+
+  def self.perform(*args)
+    raise
+  end
+end
+
+class DelayedJobWithRetryQueue
+  extend Resque::Plugins::Retry
+  @queue = :testing
+  @retry_delay = 1
+  @retry_job_delegate = JobRetryQueue
+
+  def self.perform(*args)
+    raise
+  end
+end
+
 class InheritTestJob < RetryDefaultsJob
 end
 
@@ -147,6 +176,58 @@ module RetryModuleDefaultsJob
   end
 end
 
+class AsyncJob
+  extend Resque::Plugins::Retry
+
+  class << self
+    def perform(*opts)
+      process
+    end
+
+    def process
+      raise "Shouldn't be called"
+    end
+  end
+end
+
+class BaseJob < AsyncJob
+  @retry_limit = -1
+  @auto_retry_limit = 5
+  @retry_exceptions = []
+
+  retry_criteria_check do |exception, *args|
+    keep_trying?
+  end
+
+  class << self
+    def keep_trying?
+      retry_attempt < @auto_retry_limit
+    end
+
+    def inherited(subclass)
+      super
+      %w(@retry_exceptions @retry_delay @retry_limit @auto_retry_limit).each do |variable|
+        value = BaseJob.instance_variable_get(variable)
+        value = value.dup rescue value
+        subclass.instance_variable_set(variable, value)
+      end
+    end
+
+    def process
+      raise "Got called #{Time.now}"
+    end
+  end
+end
+
+class InheritedRetryJob < BaseJob
+  @queue = :testing
+end
+
+class InheritedJob < BaseJob
+  @queue = :testing
+  @retry_job_delegate = InheritedRetryJob
+end
+
 module RetryModuleCustomRetryCriteriaCheck
   extend Resque::Plugins::Retry
   @queue = :testing
@@ -254,14 +335,14 @@ end
 class InheritOrderingJobExtendFirstSubclass < InheritOrderingJobExtendFirst; end
 class InheritOrderingJobExtendLastSubclass < InheritOrderingJobExtendLast; end
 
-class CustomIdentifierFailingJob
+class CustomRetryIdentifierFailingJob
   extend Resque::Plugins::Retry
 
   @queue = :testing
   @retry_limit = 2
   @retry_delay = 0
 
-  def self.identifier(*args)
+  def self.retry_identifier(*args)
     args.first.to_s
   end
 

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: resque-retry
 version: !ruby/object:Gem::Version
-  version: 0.2.2
-  prerelease: 
+  version: 1.0.0.a
+  prerelease: 6
 platform: ruby
 authors:
 - Luke Antins
@@ -10,44 +10,44 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-08 00:00:00.000000000Z
+date: 2012-03-11 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &2153685420 !ruby/object:Gem::Requirement
+  name: resque
+  requirement: &2158569780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.10.0
   type: :runtime
   prerelease: false
-  version_requirements: *2153685420
+  version_requirements: *2158569780
 - !ruby/object:Gem::Dependency
-  name: resque
-  requirement: &2153679300 !ruby/object:Gem::Requirement
+  name: resque-scheduler
+  requirement: &2158568800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.9.9
   type: :runtime
   prerelease: false
-  version_requirements: *2153679300
+  version_requirements: *2158568800
 - !ruby/object:Gem::Dependency
-  name: resque-scheduler
-  requirement: &2153678300 !ruby/object:Gem::Requirement
+  name: rake
+  requirement: &2158568180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.8.0
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
-  version_requirements: *2153678300
+  version_requirements: *2158568180
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &2153677800 !ruby/object:Gem::Requirement
+  requirement: &2158567580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +55,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153677800
+  version_requirements: *2158567580
 - !ruby/object:Gem::Dependency
   name: rack-test
-  requirement: &2153660820 !ruby/object:Gem::Requirement
+  requirement: &2158567120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,10 +66,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153660820
+  version_requirements: *2158567120
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2153659700 !ruby/object:Gem::Requirement
+  requirement: &2158566580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,10 +77,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153659700
+  version_requirements: *2158566580
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &2153659000 !ruby/object:Gem::Requirement
+  requirement: &2158566080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,10 +88,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153659000
+  version_requirements: *2158566080
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &2153658420 !ruby/object:Gem::Requirement
+  requirement: &2158565300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,7 +99,18 @@ dependencies:
         version: 0.3.0
   type: :development
   prerelease: false
-  version_requirements: *2153658420
+  version_requirements: *2158565300
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &2158564740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2158564740
 description: ! "  resque-retry provides retry, delay and exponential backoff support
   for\n  resque jobs.\n\n  Features:\n\n  * Redis backed retry count/limit.\n  * Retry
   on all or specific exceptions.\n  * Exponential backoff (varying the delay between
@@ -147,9 +158,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10