resque-scheduler 2.0.0.e → 2.0.0.g

data/.gitignore

@@ -2,3 +2,4 @@
 doc/
 pkg
 nbproject
+Gemfile.lock

data/Gemfile

@@ -1,2 +1,9 @@
 source :rubygems
 gemspec
+
+group :test do
+  gem "rake"
+  gem "rack-test"
+  gem "yajl-ruby", "~>0.8.2", :platforms => :mri
+  gem "mocha"
+end

data/HISTORY.md

@@ -1,6 +1,14 @@
-## 2.0.0 (???)
+## 2.0.0.g (2012-01-24)
+
+* Fixed "already initialized constant" warning (skddc)
+
+## 2.0.0.f (2011-11-03)
 
 * TODO: address race condition with delayed jobs (using redis transactions)
+* Support ENV['BACKGROUND'] flag for daemonizing (bernerdschaefer)
+* Added support for before_schedule and after_schedule hooks (yaauie)
+* Added remove_delayed_job_from_timestamp to remove delayed jobs from
+  a given timestamp.
 
 ## 2.0.0.e (2011-09-16)
 

data/README.markdown

@@ -55,6 +55,14 @@ to know.
       
         # you probably already have this somewhere
         Resque.redis = 'localhost:6379'
+
+        # If you want to be able to dynamically change the schedule,
+        # uncomment this line.  A dynamic schedule can be updated via the
+        # Resque::Scheduler.set_schedule (and remove_schedule) methods.
+        # When dynamic is set to true, the scheduler process looks for 
+        # schedule changes and applies them on the fly.
+        # Note: This feature is only available in >=2.0.0.
+        #Resque::Scheduler.dynamic = true
         
         # The schedule doesn't need to be stored in a YAML, it just needs to
         # be a hash.  YAML is usually the easiest.
@@ -65,15 +73,7 @@ to know.
         # less code that resque-scheduler needs to know about. But in a small
         # project, it's usually easier to just include you job classes here.
         # So, someting like this:
-        require 'jobs'
-        
-        # If you want to be able to dynamically change the schedule,
-        # uncomment this line.  A dynamic schedule can be updated via the
-        # Resque::Scheduler.set_schedule (and remove_schedule) methods.
-        # When dynamic is set to true, the scheduler process looks for 
-        # schedule changes and applies them on the fly.
-        # Note: This feature is only available in >=2.0.0.
-        #Resque::Scheduler.dynamic = true
+        require 'jobs'        
       end
     end
 
@@ -91,7 +91,7 @@ supersedes `VERBOSE`.
 
 NOTE: You DO NOT want to run >1 instance of the scheduler.  Doing so will
 result in the same job being queued more than once.  You only need one
-instnace of the scheduler running per resque instance (regardless of number
+instance of the scheduler running per resque instance (regardless of number
 of machines).
 
 If the scheduler process goes down for whatever reason, the delayed items
@@ -128,12 +128,18 @@ down when a particular job is supposed to be queue, they will simply "catch up"
 once they are started again.  Jobs are guaranteed to run (provided they make it
 into the delayed queue) after their given queue_at time has passed.
 
+Similar to `before_enqueue` and `after_enqueue` hooks provided in Resque 
+(>= 1.19.1), your jobs can specify one or more `before_schedule` and
+`after_schedule` hooks, to be run before or after scheduling. If *any* of your
+`before_schedule` hooks returns `false`, the job will *not* be scheduled and
+your `after_schedule` hooks will *not* be run.
+
 One other thing to note is that insertion into the delayed queue is O(log(n))
 since the jobs are stored in a redis sorted set (zset).  I can't imagine this
 being an issue for someone since redis is stupidly fast even at log(n), but full
 disclosure is always best.
 
-##### Removing Delayed jobs
+#### Removing Delayed jobs
 
 If you have the need to cancel a delayed job, you can do like so:
 
@@ -183,7 +189,25 @@ A big shout out to [rufus-scheduler](http://github.com/jmettraux/rufus-scheduler
 for handling the heavy lifting of the actual scheduling engine.
 
 
-##### Support for resque-status (and other custom jobs)
+#### Time zones
+
+Note that if you use the cron syntax, this will be interpreted as in the server time zone
+rather than the `config.time_zone` specified in Rails.
+
+You can explicitly specify the time zone that rufus-scheduler will use:
+
+    cron: "30 6 * * 1 Europe/Stockholm"
+
+Also note that `config.time_zone` in Rails allows for a shorthand (e.g. "Stockholm")
+that rufus-scheduler does not accept. If you write code to set the scheduler time zone
+from the `config.time_zone` value, make sure it's the right format, e.g. with:
+
+    ActiveSupport::TimeZone.find_tzinfo(Rails.configuration.time_zone).name
+
+A future version of resque-scheduler may do this for you.
+
+
+#### Support for resque-status (and other custom jobs)
 
 Some Resque extensions like
 [resque-status](http://github.com/quirkey/resque-status) use custom job
@@ -194,11 +218,11 @@ support scheduled job.
 
 Let's pretend we have a JobWithStatus class called FakeLeaderboard
 
-		class FakeLeaderboard < Resque::JobWithStatus
-			def perform
-				# do something and keep track of the status
-			end
-		end
+    class FakeLeaderboard < Resque::JobWithStatus
+      def perform
+        # do something and keep track of the status
+      end
+    end
 
 And then a schedule:
 
@@ -265,6 +289,16 @@ Now make sure you're passing that file to resque-web like so:
 
 That should make the scheduler tabs show up in `resque-web`.
 
+### Running in the background
+
+(Only supported with ruby >= 1.9). There are scenarios where it's helpful for
+the resque worker to run itself in the background (usually in combination with
+PIDFILE).  Use the BACKGROUND option so that rake will return as soon as the
+worker is started.
+
+    $ PIDFILE=./resque-scheduler.pid BACKGROUND=yes \
+        rake resque:scheduler
+
 ### Plagiarism alert
 
 This was intended to be an extension to resque and so resulted in a lot of the
@@ -278,6 +312,3 @@ work on resque-scheduler.
 For bugs or suggestions, please just open an issue in github.
 
 Patches are always welcome.
-
-
-

data/Rakefile

@@ -1,11 +1,12 @@
 require 'bundler'
-require 'rake/rdoctask'
+
 Bundler::GemHelper.install_tasks
 
 $LOAD_PATH.unshift 'lib'
 
 task :default => :test
 
+# Tests
 desc "Run tests"
 task :test do
   Dir['test/*_test.rb'].each do |f|
@@ -13,9 +14,15 @@ task :test do
   end
 end
 
-Rake::RDocTask.new do |rd|
-  rd.main = "README.markdown"
-  rd.rdoc_files.include("README.markdown", "lib/**/*.rb")
-  rd.rdoc_dir = 'doc'
+# Documentation Tasks
+begin
+  require 'rdoc/task'
+
+  Rake::RDocTask.new do |rd|
+    rd.main = "README.markdown"
+    rd.rdoc_files.include("README.markdown", "lib/**/*.rb")
+    rd.rdoc_dir = 'doc'
+  end
+rescue LoadError
 end
 

data/lib/resque/scheduler.rb

@@ -116,13 +116,9 @@ module Resque
           interval_types = %w{cron every}
           interval_types.each do |interval_type|
             if !config[interval_type].nil? && config[interval_type].length > 0
-              begin
-                @@scheduled_jobs[name] = rufus_scheduler.send(interval_type, config[interval_type]) do
-                  log! "queueing #{config['class']} (#{name})"
-                  enqueue_from_config(config)
-                end
-              rescue Exception => e
-                log! "#{e.class.name}: #{e.message}"
+              @@scheduled_jobs[name] = rufus_scheduler.send(interval_type, config[interval_type]) do
+                log! "queueing #{config['class']} (#{name})"
+                handle_errors { enqueue_from_config(config) }
               end
               interval_defined = true
               break
@@ -160,7 +156,7 @@ module Resque
           handle_shutdown do
             if item = Resque.next_item_for_timestamp(timestamp)
               log "queuing #{item['class']} [delayed]"
-              enqueue_from_config(item)
+              handle_errors { enqueue_from_config(item) }
             end
           end
         # continue processing until there are no more ready items in this timestamp
@@ -172,6 +168,14 @@ module Resque
         yield
         exit if @shutdown
       end
+      
+      def handle_errors
+        begin
+          yield
+        rescue Exception => e
+          log! "#{e.class.name}: #{e.message}"
+        end
+      end
 
       # Enqueues a job based on a config hash
       def enqueue_from_config(job_config)
@@ -200,11 +204,11 @@ module Resque
           if Class === klass
             Resque.enqueue(klass, *params)
           else
+            # This will not run the before_hooks in rescue, but will at least
+            # queue the job.
             Resque::Job.create(queue, klass, *params)
           end
         end
-      rescue
-        log! "Failed to enqueue #{klass_name}:\n #{$!}"
       end
 
       def rufus_scheduler
@@ -275,7 +279,7 @@ module Resque
 
       def procline(string)
         log! string
-        $0 = "resque-scheduler-#{ResqueScheduler::Version}: #{string}"
+        $0 = "resque-scheduler-#{ResqueScheduler::VERSION}: #{string}"
       end
 
     end

data/lib/resque_scheduler.rb

@@ -102,14 +102,23 @@ module ResqueScheduler
   # sit in the schedule list.
   def enqueue_at(timestamp, klass, *args)
     validate_job!(klass)
-    delayed_push(timestamp, job_to_hash(klass, args))
+    enqueue_at_with_queue( queue_from_class(klass), timestamp, klass, *args)
   end
 
   # Identical to +enqueue_at+, except you can also specify
   # a queue in which the job will be placed after the 
   # timestamp has passed.
   def enqueue_at_with_queue(queue, timestamp, klass, *args)
+    before_hooks = before_schedule_hooks(klass).collect do |hook|
+      klass.send(hook,*args)
+    end
+    return false if before_hooks.any? { |result| result == false }
+    
     delayed_push(timestamp, job_to_hash_with_queue(queue, klass, args))
+    
+    after_schedule_hooks(klass).collect do |hook|
+      klass.send(hook,*args)
+    end
   end
 
   # Identical to enqueue_at but takes number_of_seconds_from_now
@@ -194,7 +203,10 @@ module ResqueScheduler
     redis.del :delayed_queue_schedule
   end
 
-  # given an encoded item, remove it from the delayed_queue
+  # Given an encoded item, remove it from the delayed_queue
+  # 
+  # This method is potentially very expensive since it needs to scan
+  # through the delayed queue for every timestamp.
   def remove_delayed(klass, *args)
     destroyed = 0
     search = encode(job_to_hash(klass, args))
@@ -203,9 +215,21 @@ module ResqueScheduler
     end
     destroyed
   end
+  
+  # Given a timestamp and job (klass + args) it removes all instances and
+  # returns the count of jobs removed.
+  #
+  # O(N) where N is the number of jobs scheduled to fire at the given
+  # timestamp
+  def remove_delayed_job_from_timestamp(timestamp, klass, *args)
+    key = "delayed:#{timestamp.to_i}"
+    count = redis.lrem key, 0, encode(job_to_hash(klass, args))
+    clean_up_timestamp(key, timestamp)
+    count
+  end
 
   def count_all_scheduled_jobs
-    total_jobs = 0 
+    total_jobs = 0
     Array(redis.zrange(:delayed_queue_schedule, 0, -1)).each do |timestamp|
       total_jobs += redis.llen("delayed:#{timestamp}").to_i
     end 
@@ -240,6 +264,14 @@ module ResqueScheduler
       end
     end
 
+    def before_schedule_hooks(klass)
+      klass.methods.grep(/^before_schedule/).sort
+    end
+
+    def after_schedule_hooks(klass)
+      klass.methods.grep(/^after_schedule/).sort
+    end
+
 end
 
 Resque.extend ResqueScheduler

data/lib/resque_scheduler/tasks.rb

@@ -9,6 +9,13 @@ namespace :resque do
     require 'resque'
     require 'resque_scheduler'
 
+    if ENV['BACKGROUND']
+      unless Process.respond_to?('daemon')
+        abort "env var BACKGROUND is set, which requires ruby >= 1.9"
+      end
+      Process.daemon(true)
+    end
+
     File.open(ENV['PIDFILE'], 'w') { |f| f << Process.pid.to_s } if ENV['PIDFILE']
 
     Resque::Scheduler.dynamic = true if ENV['DYNAMIC_SCHEDULE']

data/lib/resque_scheduler/version.rb

@@ -1,3 +1,3 @@
 module ResqueScheduler
-  Version = '2.0.0.e'
+  VERSION = '2.0.0.g'
 end

data/resque-scheduler.gemspec

@@ -1,9 +1,10 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path("../lib/resque_scheduler/version", __FILE__)
+$:.unshift File.expand_path("../lib", __FILE__)
+require "resque_scheduler/version"
 
 Gem::Specification.new do |s|
   s.name        = "resque-scheduler"
-  s.version     = ResqueScheduler::Version
+  s.version     = ResqueScheduler::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Ben VandenBos']
   s.email       = ['bvandenbos@gmail.com']
@@ -21,8 +22,6 @@ Gem::Specification.new do |s|
   s.require_path = 'lib'
 
   s.add_runtime_dependency(%q<redis>, [">= 2.0.1"])
-  s.add_runtime_dependency(%q<resque>, [">= 1.15.0"])
+  s.add_runtime_dependency(%q<resque>, [">= 1.19.0"])
   s.add_runtime_dependency(%q<rufus-scheduler>, [">= 0"])
-  s.add_development_dependency(%q<mocha>, [">= 0"])
-  s.add_development_dependency(%q<rack-test>, [">= 0"])
 end

data/test/delayed_queue_test.rb

@@ -1,14 +1,13 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class Resque::DelayedQueueTest < Test::Unit::TestCase
+context "DelayedQueue" do
 
-  def setup
+  setup do
     Resque::Scheduler.mute = true
     Resque.redis.flushall
   end
 
-  def test_enqueue_at_adds_correct_list_and_zset
-
+  test "enqueue_at adds correct list and zset" do
     timestamp = Time.now - 1 # 1 second ago (in the past, should come out right away)
 
     assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
@@ -34,8 +33,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(0, Resque.redis.zcard(:delayed_queue_schedule), "delayed queue should be empty")
   end
 
-  def test_enqueue_at_with_queue_adds_correct_list_and_zset_and_queue
-
+  test "enqueue_at with queue adds correct list and zset and queue" do
     timestamp = Time.now - 1 # 1 second ago (in the past, should come out right away)
 
     assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
@@ -62,7 +60,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(0, Resque.redis.zcard(:delayed_queue_schedule), "delayed queue should be empty")
   end
 
-  def test_something_in_the_future_doesnt_come_out
+  test "a job in the future doesn't come out" do
     timestamp = Time.now + 600 # 10 minutes from now (in the future, shouldn't come out)
 
     assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
@@ -78,7 +76,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_nil(read_timestamp, "No timestamps should be ready for queueing")
   end
 
-  def test_something_in_the_future_comes_out_if_you_want_it_to
+  test "a job in the future comes out if you want it to" do
     timestamp = Time.now + 600 # 10 minutes from now
 
     Resque.enqueue_at(timestamp, SomeIvarJob, "path")
@@ -88,7 +86,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(timestamp.to_i, read_timestamp, "The timestamp we pull out of redis should match the one we put in")
   end
 
-  def test_enqueue_at_and_enqueue_in_are_equivelent
+  test "enqueue_at and enqueue_in are equivelent" do
     timestamp = Time.now + 60
 
     Resque.enqueue_at(timestamp, SomeIvarJob, "path")
@@ -98,11 +96,11 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(2, Resque.redis.llen("delayed:#{timestamp.to_i}"), "should have 2 items in the timestamp queue")
   end
 
-  def test_empty_delayed_queue_peek
+  test "empty delayed_queue_peek returns empty array" do
     assert_equal([], Resque.delayed_queue_peek(0,20))
   end
 
-  def test_delayed_queue_peek
+  test "delqyed_queue_peek returns stuff" do
     t = Time.now
     expected_timestamps = (1..5).to_a.map do |i|
       (t + 60 + i).to_i
@@ -117,38 +115,56 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(expected_timestamps[2,3], timestamps)
   end
 
-  def test_delayed_queue_schedule_size
+  test "delayed_queue_schedule_size returns correct size" do
     assert_equal(0, Resque.delayed_queue_schedule_size)
     Resque.enqueue_at(Time.now+60, SomeIvarJob)
     assert_equal(1, Resque.delayed_queue_schedule_size)
   end
 
-  def test_delayed_timestamp_size
+  test "delayed_timestamp_size returns 0 when nothing is queue" do
+    t = Time.now + 60
+    assert_equal(0, Resque.delayed_timestamp_size(t))    
+  end
+  
+  test "delayed_timestamp_size returns 1 when one thing is queued" do
     t = Time.now + 60
-    assert_equal(0, Resque.delayed_timestamp_size(t))
     Resque.enqueue_at(t, SomeIvarJob)
-    assert_equal(1, Resque.delayed_timestamp_size(t))
-    assert_equal(0, Resque.delayed_timestamp_size(t.to_i+1))
+    assert_equal(1, Resque.delayed_timestamp_size(t))    
   end
 
-  def test_delayed_timestamp_peek
+  test "delayed_timestamp_peek returns empty array when nothings in it" do
     t = Time.now + 60
     assert_equal([], Resque.delayed_timestamp_peek(t, 0, 1), "make sure it's an empty array, not nil")
+  end
+  
+  test "delayed_timestamp_peek returns an array containing one job when one thing is queued" do
+    t = Time.now + 60
     Resque.enqueue_at(t, SomeIvarJob)
-    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 1).length)
+    assert_equal [{'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}], Resque.delayed_timestamp_peek(t, 0, 1)
+  end
+  
+  test "delayed_timestamp_peek returns an array of multiple jobs when more than one job is queued" do
+    t = Time.now + 60
     Resque.enqueue_at(t, SomeIvarJob)
-    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 1).length)
-    assert_equal(2, Resque.delayed_timestamp_peek(t, 0, 3).length)
-
-    assert_equal({'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}, Resque.delayed_timestamp_peek(t, 0, 1).first)
+    Resque.enqueue_at(t, SomeIvarJob)
+    job = {'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}
+    assert_equal([job, job], Resque.delayed_timestamp_peek(t, 0, 2))
+  end
+  
+  test "delayed_timestamp_peek only returns an array of one job if only asked for 1" do
+    t = Time.now + 60
+    Resque.enqueue_at(t, SomeIvarJob)
+    Resque.enqueue_at(t, SomeIvarJob)
+    job = {'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}
+    assert_equal([job], Resque.delayed_timestamp_peek(t, 0, 1))
   end
 
-  def test_handle_delayed_items_with_no_items
+  test "handle_delayed_items with no items" do
     Resque::Scheduler.expects(:enqueue).never
     Resque::Scheduler.handle_delayed_items
   end
 
-  def test_handle_delayed_items_with_items
+  test "handle_delayed_item with items" do
     t = Time.now - 60 # in the past
     Resque.enqueue_at(t, SomeIvarJob)
     Resque.enqueue_at(t, SomeIvarJob)
@@ -158,7 +174,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     Resque::Scheduler.handle_delayed_items
   end
 
-  def test_handle_delayed_items_with_items_in_the_future
+  test "handle_delayed_items with items in the future" do
     t = Time.now + 60 # in the future
     Resque.enqueue_at(t, SomeIvarJob)
     Resque.enqueue_at(t, SomeIvarJob)
@@ -168,7 +184,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     Resque::Scheduler.handle_delayed_items(t)
   end
 
-  def test_enqueue_delayed_items_for_timestamp
+  test "enqueue_delayed_items_for_timestamp creates jobs and empties the delayed queue" do
     t = Time.now + 60
 
     Resque.enqueue_at(t, SomeIvarJob)
@@ -183,7 +199,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(0, Resque.delayed_timestamp_peek(t, 0, 3).length)
   end
 
-  def test_works_with_out_specifying_queue__upgrade_case
+  test "handle_delayed_items works with out specifying queue (upgrade case)" do
     t = Time.now - 60
     Resque.delayed_push(t, :class => 'SomeIvarJob')
 
@@ -195,7 +211,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     Resque::Scheduler.handle_delayed_items
   end
 
-  def test_clearing_delayed_queue
+  test "reset_delayed_queue clears the queue" do
     t = Time.now + 120
     4.times { Resque.enqueue_at(t, SomeIvarJob) }
     4.times { Resque.enqueue_at(Time.now + rand(100), SomeIvarJob) }
@@ -204,14 +220,14 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(0, Resque.delayed_queue_schedule_size)
   end
 
-  def test_remove_specific_item
+  test "remove_delayed removes job and returns the count" do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob)
 
     assert_equal(1, Resque.remove_delayed(SomeIvarJob))
   end
 
-  def test_remove_bogus_item_leaves_the_rest_alone
+  test "remove_delayed doesn't remove things it shouldn't" do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob, "foo")
     Resque.enqueue_at(t, SomeIvarJob, "bar")
@@ -221,7 +237,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(0, Resque.remove_delayed(SomeIvarJob))
   end
 
-  def test_remove_specific_item_in_group_of_other_items_at_same_timestamp
+  test "remove_delayed respected param" do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob, "foo")
     Resque.enqueue_at(t, SomeIvarJob, "bar")
@@ -232,7 +248,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(1, Resque.delayed_queue_schedule_size)
   end
 
-  def test_remove_specific_item_in_group_of_other_items_at_different_timestamps
+  test "remove_delayed removes items in different timestamps" do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob, "foo")
     Resque.enqueue_at(t + 1, SomeIvarJob, "bar")
@@ -242,8 +258,52 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(2, Resque.remove_delayed(SomeIvarJob, "bar"))
     assert_equal(2, Resque.count_all_scheduled_jobs)
   end
+  
+  test "remove_delayed_job_from_timestamp removes instances of jobs at a given timestamp" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
+    assert_equal 0, Resque.delayed_timestamp_size(t)
+  end
+  
+  test "remove_delayed_job_from_timestamp doesn't remove items from other timestamps" do
+    t1 = Time.now + 120
+    t2 = t1 + 1
+    Resque.enqueue_at(t1, SomeIvarJob, "foo")
+    Resque.enqueue_at(t2, SomeIvarJob, "foo")
+    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t2, SomeIvarJob, "foo")
+    assert_equal 1, Resque.delayed_timestamp_size(t1)
+    assert_equal 0, Resque.delayed_timestamp_size(t2)
+  end
+  
+  test "remove_delayed_job_from_timestamp removes nothing if there are no matches" do
+    t = Time.now + 120
+    assert_equal 0, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
+  end
+  
+  test "remove_delayed_job_from_timestamp only removes items that match args" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t, SomeIvarJob, "bar")
+    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
+    assert_equal 1, Resque.delayed_timestamp_size(t)    
+  end
+  
+  test "remove_delayed_job_from_timestamp returns the number of items removed" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
+  end
+  
+  test "remove_delayed_job_from_timestamp should cleanup the delayed timestamp list if not jobs are left" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")    
+    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
+    assert !Resque.redis.exists("delayed:#{t.to_i}")
+    assert Resque.delayed_queue_peek(0, 100).empty?
+  end
 
-  def test_invalid_job_class
+  test "invalid job class" do
     assert_raise Resque::NoClassError do
       Resque.enqueue_in(10, nil)
     end

data/test/scheduler_args_test.rb

@@ -1,7 +1,70 @@
 require File.dirname(__FILE__) + '/test_helper'
 
 context "scheduling jobs with arguments" do
-  setup { Resque::Scheduler.clear_schedule! }
+
+  setup do
+    Resque::Scheduler.clear_schedule!
+    Resque::Scheduler.dynamic = false
+    Resque::Scheduler.mute = true
+  end
+
+  test "enqueue_from_config puts stuff in resque without class loaded" do
+    Resque::Job.stubs(:create).once.returns(true).with('joes_queue', 'UndefinedJob', '/tmp')
+    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'UndefinedJob', 'args' => "/tmp", 'queue' => 'joes_queue')
+  end
+
+  test "enqueue_from_config with_every_syntax" do
+    Resque::Job.stubs(:create).once.returns(true).with('james_queue', 'JamesJob', '/tmp')
+    Resque::Scheduler.enqueue_from_config('every' => '1m', 'class' => 'JamesJob', 'args' => '/tmp', 'queue' => 'james_queue')
+  end
+
+  test "enqueue_from_config puts jobs in the resque queue" do
+    Resque::Job.stubs(:create).once.returns(true).with(:ivar, SomeIvarJob, '/tmp')
+    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp")
+  end
+
+  test "enqueue_from_config with custom_class_job in resque" do
+    FakeCustomJobClass.stubs(:scheduled).once.returns(true).with(:ivar, 'SomeIvarJob', '/tmp')
+    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'custom_job_class' => 'FakeCustomJobClass', 'args' => "/tmp")
+  end
+
+  test "enqueue_from_config puts stuff in resquewhen rails_env matches" do
+    # The job should be loaded : its rails_env config matches the RAILS_ENV variable:
+    ENV['RAILS_ENV'] = 'production'
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+
+    # we allow multiple rails_env definition, it should work also:
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging, production'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(2, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+  end
+
+  test "enqueue_from_config  doesnt put stuff in resque when rails_env doesnt match" do
+    # RAILS_ENV is not set:
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+
+    # SET RAILS_ENV to a common value:
+    ENV['RAILS_ENV'] = 'production'
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+  end
+
+  test "enqueue_from_config when rails env arg is not set" do
+    # The job should be loaded, since a missing rails_env means ALL envs.
+    ENV['RAILS_ENV'] = 'production'
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+  end
 
   test "calls the worker without arguments when 'args' is missing from the config" do
     Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))

data/test/scheduler_hooks_test.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "scheduling jobs with hooks" do
+  class JobThatCannotBeScheduledWithoutArguments < Resque::Job
+    @queue = :job_that_cannot_be_scheduled_without_arguments
+    def self.perform(*x);end
+    def self.before_schedule_return_nil_if_arguments_not_supplied(*args)
+      counters[:before_schedule] += 1
+      return false if args.empty?
+    end
+
+    def self.after_schedule_do_something(*args)
+      counters[:after_schedule] += 1
+    end
+
+    class << self
+      def counters
+        @counters ||= Hash.new{|h,k| h[k]=0}
+      end
+      def clean
+        counters.clear
+        self
+      end
+    end
+  end
+  
+  setup do
+    Resque::Scheduler.dynamic = false
+    Resque.redis.del(:schedules)
+    Resque.redis.del(:schedules_changed)
+    Resque::Scheduler.mute = true
+    Resque::Scheduler.clear_schedule!
+    Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
+  end
+
+  test "before_schedule hook that does not return false should not block" do
+    enqueue_time = Time.now + 12
+    Resque.enqueue_at(enqueue_time, JobThatCannotBeScheduledWithoutArguments.clean, :foo)
+    assert_equal(1, Resque.delayed_timestamp_size(enqueue_time.to_i), "delayed queue should have one entry now")
+    assert_equal(1, JobThatCannotBeScheduledWithoutArguments.counters[:before_schedule], 'before_schedule was not run')
+    assert_equal(1, JobThatCannotBeScheduledWithoutArguments.counters[:after_schedule], 'after_schedule was not run')
+  end
+
+  test "before_schedule hook that returns false should block" do
+    enqueue_time = Time.now + 60
+    assert_equal(0, JobThatCannotBeScheduledWithoutArguments.clean.counters[:before_schedule], 'before_schedule should be zero')
+    Resque.enqueue_at(enqueue_time, JobThatCannotBeScheduledWithoutArguments.clean)
+    assert_equal(0, Resque.delayed_timestamp_size(enqueue_time.to_i), "job should not have been put in queue")
+    assert_equal(1, JobThatCannotBeScheduledWithoutArguments.counters[:before_schedule], 'before_schedule was not run')
+    assert_equal(0, JobThatCannotBeScheduledWithoutArguments.counters[:after_schedule], 'after_schedule was run')
+  end
+end

data/test/scheduler_test.rb

@@ -1,12 +1,8 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class Resque::SchedulerTest < Test::Unit::TestCase
+context "Resque::Scheduler" do
 
-  class FakeJob
-    def self.scheduled(queue, klass, *args); end
-  end
-
-  def setup
+  setup do
     Resque::Scheduler.dynamic = false
     Resque.redis.del(:schedules)
     Resque.redis.del(:schedules_changed)
@@ -15,70 +11,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
   end
 
-  def test_enqueue_from_config_puts_stuff_in_the_resque_queue_without_class_loaded
-    Resque::Job.stubs(:create).once.returns(true).with('joes_queue', 'BigJoesJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'BigJoesJob', 'args' => "/tmp", 'queue' => 'joes_queue')
-  end
-
-  def test_enqueue_from_config_with_every_syntax
-    Resque::Job.stubs(:create).once.returns(true).with('james_queue', 'JamesJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config('every' => '1m', 'class' => 'JamesJob', 'args' => '/tmp', 'queue' => 'james_queue')
-  end
-
-  def test_enqueue_from_config_doesnt_crash_on_exception_when_enqueueing
-    Resque::Job.stubs(:create).raises(Resque::NoQueueError, 'test exception').with(:ivar, 'SomeIvarJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp")
-  end
-
-  def test_enqueue_from_config_puts_stuff_in_the_resque_queue
-    Resque::Job.stubs(:create).once.returns(true).with(:ivar, SomeIvarJob, '/tmp')
-    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp")
-  end
-
-  def test_enqueue_from_config_with_custom_class_job_in_the_resque_queue
-    FakeJob.stubs(:scheduled).once.returns(true).with(:ivar, 'SomeIvarJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'custom_job_class' => 'Resque::SchedulerTest::FakeJob', 'args' => "/tmp")
-  end
-
-  def test_enqueue_from_config_puts_stuff_in_the_resque_queue_when_env_match
-    # The job should be loaded : its rails_env config matches the RAILS_ENV variable:
-    ENV['RAILS_ENV'] = 'production'
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'}}
-    Resque::Scheduler.load_schedule!
-    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-
-    # we allow multiple rails_env definition, it should work also:
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging, production'}}
-    Resque::Scheduler.load_schedule!
-    assert_equal(2, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-  end
-
-  def test_enqueue_from_config_dont_puts_stuff_in_the_resque_queue_when_env_doesnt_match
-    # RAILS_ENV is not set:
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
-    Resque::Scheduler.load_schedule!
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-
-    # SET RAILS_ENV to a common value:
-    ENV['RAILS_ENV'] = 'production'
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
-    Resque::Scheduler.load_schedule!
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-  end
-
-  def test_enqueue_from_config_when_rails_env_arg_is_not_set
-    # The job should be loaded, since a missing rails_env means ALL envs.
-    ENV['RAILS_ENV'] = 'production'
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
-    Resque::Scheduler.load_schedule!
-    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-  end
-
-  def test_enqueue_constantizes
+  test "enqueue constantizes" do
     # The job should be loaded, since a missing rails_env means ALL envs.
     ENV['RAILS_ENV'] = 'production'
     config = {'cron' => "* * * * *", 'class' => 'SomeRealClass', 'args' => "/tmp"}
@@ -86,7 +19,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     Resque::Scheduler.enqueue_from_config(config)
   end
 
-  def test_enqueue_runs_hooks
+  test "enqueue runs hooks" do
     # The job should be loaded, since a missing rails_env means ALL envs.
     ENV['RAILS_ENV'] = 'production'
     config = {'cron' => "* * * * *", 'class' => 'SomeRealClass', 'args' => "/tmp"}
@@ -97,7 +30,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     Resque::Scheduler.enqueue_from_config(config)
   end
 
-  def test_config_makes_it_into_the_rufus_scheduler
+  test "config makes it into the rufus_scheduler" do
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
 
     Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
@@ -107,7 +40,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert Resque::Scheduler.scheduled_jobs.include?(:some_ivar_job)
   end
 
-  def test_can_reload_schedule
+  test "can reload schedule" do
     Resque::Scheduler.dynamic = true
     Resque.schedule = {"some_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
 
@@ -129,7 +62,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert Resque::Scheduler.scheduled_jobs.include?("some_ivar_job2")
   end
 
-  def test_load_schedule_job
+  test "load_schedule_job loads a schedule" do 
     Resque::Scheduler.load_schedule_job("some_ivar_job", {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"})
 
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -137,7 +70,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
   end
 
-  def test_load_schedule_job_with_no_cron
+  test "load_schedule_job without cron" do
     Resque::Scheduler.load_schedule_job("some_ivar_job", {'class' => 'SomeIvarJob', 'args' => "/tmp"})
 
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -145,7 +78,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert !Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
   end
 
-  def test_load_schedule_job_with_blank_cron
+  test "load_schedule_job with an empty cron" do
     Resque::Scheduler.load_schedule_job("some_ivar_job", {'cron' => '', 'class' => 'SomeIvarJob', 'args' => "/tmp"})
 
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -153,7 +86,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert !Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
   end
 
-  def test_update_schedule
+  test "update_schedule" do
     Resque::Scheduler.dynamic = true
     Resque.schedule = {
       "some_ivar_job"    => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"},
@@ -187,7 +120,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert_equal 0, Resque.redis.scard(:schedules_changed)
   end
 
-  def test_update_schedule_with_mocks
+  test "update_schedule with mocks" do
     Resque::Scheduler.dynamic = true
     Resque.schedule = {
       "some_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"},
@@ -223,7 +156,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert_equal 0, Resque.redis.scard(:schedules_changed)
   end
 
-  def test_set_schedules
+  test "schedule= sets the schedule" do
     Resque::Scheduler.dynamic = true
     Resque.schedule = {"my_ivar_job" => {
       'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/75"
@@ -232,7 +165,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
       Resque.decode(Resque.redis.hget(:schedules, "my_ivar_job")))
   end
 
-  def test_set_schedule
+  test "set_schedule can set an individual schedule" do
     Resque.set_schedule("some_ivar_job", {
       'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/22"
     })
@@ -241,7 +174,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert Resque.redis.sismember(:schedules_changed, "some_ivar_job")
   end
 
-  def test_get_schedule
+  test "get_schedule returns a schedule" do
     Resque.redis.hset(:schedules, "some_ivar_job2", Resque.encode(
       {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/33"}
     ))
@@ -249,7 +182,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
       Resque.get_schedule("some_ivar_job2"))
   end
 
-  def test_remove_schedule
+  test "remove_schedule removes a schedule" do
     Resque.redis.hset(:schedules, "some_ivar_job3", Resque.encode(
       {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/44"}
     ))
@@ -258,7 +191,7 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     assert Resque.redis.sismember(:schedules_changed, "some_ivar_job3")
   end
 
-  def test_adheres_to_lint
+  test "adheres to lint" do
     assert_nothing_raised do
       Resque::Plugin.lint(Resque::Scheduler)
       Resque::Plugin.lint(ResqueScheduler)

data/test/test_helper.rb

@@ -68,6 +68,10 @@ def context(*args, &block)
   klass.class_eval &block
 end
 
+class FakeCustomJobClass
+  def self.scheduled(queue, klass, *args); end
+end
+
 class SomeJob
   def self.perform(repo_id, path)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-scheduler
 version: !ruby/object:Gem::Version
-  version: 2.0.0.e
+  version: 2.0.0.g
   prerelease: 6
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-16 00:00:00.000000000Z
+date: 2012-01-24 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2163772500 !ruby/object:Gem::Requirement
+  requirement: &2160604100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2163772500
+  version_requirements: *2160604100
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &2163770620 !ruby/object:Gem::Requirement
+  requirement: &2160602220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,21 +32,21 @@ dependencies:
         version: 2.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *2163770620
+  version_requirements: *2160602220
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &2163770140 !ruby/object:Gem::Requirement
+  requirement: &2160601740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.15.0
+        version: 1.19.0
   type: :runtime
   prerelease: false
-  version_requirements: *2163770140
+  version_requirements: *2160601740
 - !ruby/object:Gem::Dependency
   name: rufus-scheduler
-  requirement: &2163769660 !ruby/object:Gem::Requirement
+  requirement: &2160601260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,29 +54,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2163769660
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: &2163769160 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2163769160
-- !ruby/object:Gem::Dependency
-  name: rack-test
-  requirement: &2163768680 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2163768680
+  version_requirements: *2160601260
 description: ! "Light weight job scheduling on top of Resque.\n    Adds methods enqueue_at/enqueue_in
   to schedule jobs in the future.\n    Also supports queueing jobs on a fixed, cron-like
   schedule."
@@ -88,7 +66,6 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
-- Gemfile.lock
 - HISTORY.md
 - LICENSE
 - README.markdown
@@ -107,6 +84,7 @@ files:
 - test/redis-test.conf
 - test/resque-web_test.rb
 - test/scheduler_args_test.rb
+- test/scheduler_hooks_test.rb
 - test/scheduler_test.rb
 - test/test_helper.rb
 homepage: http://github.com/bvandenbos/resque-scheduler
@@ -123,7 +101,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3350821914372278115
+      hash: -2970363216344829182
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/Gemfile.lock

@@ -1,44 +0,0 @@
-PATH
-  remote: .
-  specs:
-    resque-scheduler (2.0.0.e)
-      redis (>= 2.0.1)
-      resque (>= 1.15.0)
-      rufus-scheduler
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    json (1.4.6)
-    mocha (0.9.9)
-      rake
-    rack (1.2.1)
-    rack-test (0.5.6)
-      rack (>= 1.0)
-    rake (0.8.7)
-    redis (2.2.2)
-    redis-namespace (1.1.0)
-      redis (< 3.0.0)
-    resque (1.15.0)
-      json (~> 1.4.6)
-      redis-namespace (>= 0.10.0)
-      sinatra (>= 0.9.2)
-      vegas (~> 0.1.2)
-    rufus-scheduler (2.0.10)
-      tzinfo (>= 0.3.23)
-    sinatra (1.2.6)
-      rack (~> 1.1)
-      tilt (>= 1.2.2, < 2.0)
-    tilt (1.3.2)
-    tzinfo (0.3.29)
-    vegas (0.1.8)
-      rack (>= 1.0.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (>= 1.0.0)
-  mocha
-  rack-test
-  resque-scheduler!