ts-resque-delta 0.0.6 → 1.0.0

data/README.markdown

@@ -1,57 +1,82 @@
 Delayed Deltas for Thinking Sphinx (with Resque)
 ================================================
-
-**This code is HEAVILY borrowed from [ts-delayed-delta](http://github.com/freelancing-god/ts-delayed-delta).**
+**This code is HEAVILY borrowed from
+[ts-delayed-delta](https://github.com/freelancing-god/ts-delayed-delta).**
 
 Installation
 ------------
-
-You'll need Thinking Sphinx 1.3.0 or later, and Resque as well. The latter is flagged as a dependency.
+This gem depends on the following gems: _thinking-sphinx_, _resque_, and
+_resque-lock-timeout_.
 
     gem install ts-resque-delta
 
-In your `Gemfile` file, with the rest of your gem dependencies:
+Add _ts-resque-delta_ to your **Gemfile** file, with the rest of your gem
+dependencies:
 
-    gem 'ts-resque-delta', 'x.x.x', :require => 'thinking_sphinx/deltas/resque_delta'
+    gem 'ts-resque-delta', '1.0.0',
+      :require => 'thinking_sphinx/deltas/resque_delta'
 
-And add the following line to the bottom of your `Rakefile`:
+And add the following line to your **Rakefile**:
 
     require 'thinking_sphinx/deltas/resque_delta/tasks'
 
-For the indexes you want to use this delta approach, make sure you set that up in their `define_index` blocks.
+Add the delta property to each `define_index` block:
 
     define_index do
       # ...
       set_property :delta => ThinkingSphinx::Deltas::ResqueDelta
     end
 
-If you've never used delta indexes before, you'll want to add the boolean column named delta to each model that is using the approach.
+If you've never used delta indexes before, you'll want to add the boolean
+column named `:delta` to each model's table (note, you must set the `:default`
+value to `true`):
 
     def self.up
-      add_column :articles, :delta, :boolean, :default => true, :null => false
+      add_column :foos, :delta, :boolean, :default => true, :null => false
+    end
+
+Also, I highly recommend adding a MySQL index to the table of any model using
+delta indexes. The Sphinx indexer uses `WHERE table.delta = 1` whenever the
+delta indexer runs and `... = 0` whenever the normal indexer runs. Having the
+MySQL index on the delta column will generally be a win:
+
+    def self.up
+      # ...
+      add_index :foos, :delta
     end
 
 Usage
 -----
+Once you've got it all set up, all you need to do is make sure that the Resque
+worker is running. You can do this by specifying the `:ts_delta` queue when
+running Resque:
 
-Once you've got it all set up, all you need to do is make sure that the Resque worker is running. You can do this either by running Resque's workers and specifying the `:ts_delta` queue, or Thinking Sphinx's custom rake task:
+    QUEUE=ts_delta,other_queues rake resque:work
 
-    rake thinking_sphinx:resque_delta
+Additionally, ts-resque-delta will wrap thinking-sphinx's
+`thinking_sphinx:index` and `thinking_sphinx:reindex` tasks with
+`thinking_sphinx:lock_deltas` and `thinking_sphinx:unlock_deltas`. This will
+prevent the delta indexer from running at the same time as the main indexer.
 
-There's also a short name for the same task, to save your fingers some effort:
+Finally, ts-resque-delta also provides a rake task called
+`thinking_sphinx:smart_index` (or `ts:si` for short). This task, instead of
+locking all the delta indexes at once while the main indexer runs, will lock
+each delta index independently and sequentially. Thay way, your delta indexer
+can run while the main indexer is processing large core indexes.
 
-    rake ts:rd
+Contributors (for ts-delayed-delta)
+-----------------------------------
+* [Aaron Gibralter](https://github.com/agibralter)
+* [Ryan Schlesinger](https://github.com/ryansch) (Locking/`smart_index`)
 
 Original Contributors (for ts-delayed-delta)
 --------------------------------------------
-
-* [Pat Allan](http://github.com/freelancing-god)
-* [Ryan Schlesinger](http://github.com/ryansch) (Allowing installs as a plugin)
-* [Maximilian Schulz](http://max.jungeelite.de) (Ensuring compatibility with Bundler)
-* [Edgars Beigarts](http://github.com/ebeigarts) (Adding intelligent description for tasks)
-* [Alexander Simonov](http://simonov.me/) (Explicit table definition)
+* [Pat Allan](https://github.com/freelancing-god)
+* [Ryan Schlesinger](https://github.com/ryansch) (Allowing installs as a plugin)
+* [Maximilian Schulz](https://max.jungeelite.de) (Ensuring compatibility with Bundler)
+* [Edgars Beigarts](https://github.com/ebeigarts) (Adding intelligent description for tasks)
+* [Alexander Simonov](https://simonov.me/) (Explicit table definition)
 
 Copyright
 ---------
-
-Copyright (c) 2010 Aaron Gibralter, and released under an MIT Licence.
+Copyright (c) 2011 Aaron Gibralter, and released under an MIT Licence.

data/features/support/env.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'cucumber'
 require 'spec/expectations'
 require 'fileutils'
@@ -11,8 +10,6 @@ $:.unshift(File.dirname(__FILE__))
 
 require 'cucumber/thinking_sphinx/internal_world'
 
-Time.zone_default = Time.__send__(:get_zone, 'Melbourne')
-ActiveRecord::Base.time_zone_aware_attributes = true
 ActiveRecord::Base.default_timezone = :utc
 
 world = Cucumber::ThinkingSphinx::InternalWorld.new

data/features/thinking_sphinx/db/migrations/create_delayed_betas.rb

@@ -1,17 +1,4 @@
-ActiveRecord::Base.connection.create_table :delayed_betas, :force => true do |t|
+ActiveRecord::Base.connection.create_table :delayed_beta, :force => true do |t|
   t.column  :name, :string,  :null => false
   t.column :delta, :boolean, :null => false, :default => false
 end
-
-ActiveRecord::Base.connection.create_table :delayed_jobs, :force => true do |t|
-  t.column :priority, :integer, :default => 0
-  t.column :attempts, :integer, :default => 0
-  t.column :handler, :text
-  t.column :last_error, :string
-  t.column :run_at, :datetime
-  t.column :locked_at, :datetime
-  t.column :failed_at, :datetime
-  t.column :locked_by, :string
-  t.column :created_at, :datetime
-  t.column :updated_at, :datetime
-end

data/lib/thinking_sphinx/deltas/resque_delta.rb

@@ -25,6 +25,18 @@ class ThinkingSphinx::Deltas::ResqueDelta < ThinkingSphinx::Deltas::DefaultDelta
     end
   end
 
+  def self.lock(index_name)
+    Resque.redis.set("ts-delta:index:#{index_name}:locked", 'true')
+  end
+
+  def self.unlock(index_name)
+    Resque.redis.del("ts-delta:index:#{index_name}:locked")
+  end
+
+  def self.locked?(index_name)
+    Resque.redis.get("ts-delta:index:#{index_name}:locked") == 'true'
+  end
+
   # Adds a job to the queue for processing the given model's delta index. A job
   # for hiding the instance in the core index is also created, if an instance is
   # provided.
@@ -41,10 +53,13 @@ class ThinkingSphinx::Deltas::ResqueDelta < ThinkingSphinx::Deltas::DefaultDelta
   #
   def index(model, instance = nil)
     return true if skip?(instance)
-    Resque.enqueue(
-      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob,
-      model.delta_index_names
-    )
+    model.delta_index_names.each do |delta|
+      next if self.class.locked?(delta)
+      Resque.enqueue(
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob,
+        [delta]
+      )
+    end
     if instance
       Resque.enqueue(
         ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob,

data/lib/thinking_sphinx/deltas/resque_delta/delta_job.rb

@@ -14,6 +14,8 @@ class ThinkingSphinx::Deltas::ResqueDelta::DeltaJob
   # @param [String] index the name of the Sphinx index
   #
   def self.perform(indexes)
+    return if skip?(indexes)
+
     config = ThinkingSphinx::Configuration.instance
     output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} --rotate #{indexes.join(' ')}`
     puts output unless ThinkingSphinx.suppress_delta_output?
@@ -51,4 +53,12 @@ class ThinkingSphinx::Deltas::ResqueDelta::DeltaJob
     Resque.redis.lrem("queue:#{@queue}", 0, redis_job_value)
     yield
   end
+
+  protected
+
+  def self.skip?(indexes)
+    indexes.any? do |index|
+      ThinkingSphinx::Deltas::ResqueDelta.locked?(index)
+    end
+  end
 end

data/lib/thinking_sphinx/deltas/resque_delta/tasks.rb

@@ -1,22 +1,80 @@
+require 'thinking_sphinx/deltas/resque_delta'
+
 namespace :thinking_sphinx do
-  task :index do
-    ThinkingSphinx::Deltas::ResqueDelta.cancel_thinking_sphinx_jobs
+
+  # Return a list of index prefixes (i.e. without "_core"/"_delta").
+  def sphinx_indexes
+    unless @sphinx_indexes
+      @ts_config ||= ThinkingSphinx::Configuration.instance
+      @ts_config.generate
+      @sphinx_indexes = @ts_config.configuration.indexes.collect { |i| i.name }
+      # The collected indexes look like:
+      # ["foo_core", "foo_delta", "foo", "bar_core", "bar_delta", "bar"]
+      @sphinx_indexes.reject! { |i| i =~ /_(core|delta)$/}
+      # Now we have:
+      # ["foo", "bar"]
+    end
+    @sphinx_indexes
+  end
+
+  def lock_delta(index_name)
+    ThinkingSphinx::Deltas::ResqueDelta.lock("#{index_name}_delta")
+  end
+
+  def unlock_delta(index_name)
+    ThinkingSphinx::Deltas::ResqueDelta.unlock("#{index_name}_delta")
+  end
+
+  desc 'Lock all delta indexes (Resque will not run indexer or place new jobs on the :ts_delta queue).'
+  task :lock_deltas do
+    sphinx_indexes.each { |index_name| lock_delta(index_name) }
+  end
+
+  desc 'Unlock all delta indexes.'
+  task :unlock_deltas do
+    sphinx_indexes.each { |index_name| unlock_delta(index_name) }
   end
 
-  desc "Process stored delta index requests"
-  task :resque_delta => :app_env do
-    raise "TODO... for now, please just run the workers on your own and make sure to work the :ts_delta queue."
-  #   require 'delayed/worker'
-  #   require 'thinking_sphinx/deltas/resque_delta'
-  #   
-  #   Delayed::Worker.new(
-  #     :min_priority => ENV['MIN_PRIORITY'],
-  #     :max_priority => ENV['MAX_PRIORITY']
-  #   ).start
+  desc 'Like `rake thinking_sphinx:index`, but locks one index at a time.'
+  task :smart_index => :app_env do
+    # Load config like ts:in.
+    @ts_config = ThinkingSphinx::Configuration.instance
+    unless ENV['INDEX_ONLY'] == 'true'
+      puts "Generating Configuration to #{@ts_config.config_file}"
+      @ts_config.build
+    end
+    FileUtils.mkdir_p(@ts_config.searchd_file_path)
+
+    # Index each core, one at a time. Wrap with delta locking logic.
+    sphinx_indexes.each do |index_name|
+      lock_delta(index_name)
+      @ts_config.controller.index("#{index_name}_core", :verbose => true)
+      ret = $?
+      unlock_delta(index_name)
+      exit(-1) if ret.to_i != 0
+      Resque.enqueue(
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob,
+        ["#{index_name}_delta"]
+      )
+    end
   end
 end
 
 namespace :ts do
-  desc "Process stored delta index requests"
-  task :rd => "thinking_sphinx:resque_delta"
+
+  desc 'Like `rake thinking_sphinx:index`, but locks one index at a time.'
+  task :si => 'thinking_sphinx:smart_index'
+end
+
+unless Rake::Task.task_defined?('thinking_sphinx:index')
+  require 'thinking_sphinx/tasks'
+end
+
+# Ensure that indexing does not conflict with ts-resque-delta delta jobs.
+Rake::Task['thinking_sphinx:index'].enhance ['thinking_sphinx:lock_deltas'] do
+  Rake::Task['thinking_sphinx:unlock_deltas'].invoke
+end
+
+Rake::Task['thinking_sphinx:reindex'].enhance ['thinking_sphinx:lock_deltas'] do
+  Rake::Task['thinking_sphinx:unlock_deltas'].invoke
 end

data/lib/thinking_sphinx/deltas/resque_delta/version.rb

@@ -1,7 +1,7 @@
 module ThinkingSphinx
   module Deltas
     class ResqueDeltaInfo
-      VERSION = "0.0.6"
+      VERSION = "1.0.0"
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 
-require 'rubygems'
 require 'spec'
 require 'spec/autorun'
 

data/spec/thinking_sphinx/deltas/resque_delta/delta_job_spec.rb

@@ -6,33 +6,64 @@ describe ThinkingSphinx::Deltas::ResqueDelta::DeltaJob do
       ThinkingSphinx.suppress_delta_output = false
       ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.stub(:` => true)
       ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.stub(:puts => nil)
+      ThinkingSphinx::Deltas::ResqueDelta.stub(:locked?).and_return(false)
     end
 
     it "should output the delta indexing by default" do
       ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_receive(:puts)
-      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(['foo_core'])
+      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(
+        ['foo_delta']
+      )
     end
 
     it "should not output the delta indexing if requested" do
       ThinkingSphinx.suppress_delta_output = true
       ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_not_receive(:puts)
-      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(['foo_core'])
+      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(
+        ['foo_delta']
+      )
     end
 
     it "should process just the requested indexes" do
-      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_receive(:`) do |command|
-        command.should match(/foo_core/)
-        command.should_not match(/--all/)
+      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_receive(:`) do |c|
+        c.should match(/foo_delta/)
+        c.should_not match(/--all/)
       end
-      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(['foo_core'])
+      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(
+        ['foo_delta']
+      )
     end
 
     context 'multiple indexes' do
       it "should process all requested indexes" do
-        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_receive(:`) do |command|
-          command.should match(/foo_core bar_core/)
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_receive(:`) do |c|
+          c.should match(/foo_delta bar_delta/)
         end
-        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(['foo_core', 'bar_core'])
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(
+          ['foo_delta', 'bar_delta']
+        )
+      end
+    end
+
+    context 'when an index is locked' do
+      before do
+        ThinkingSphinx::Deltas::ResqueDelta.stub(:locked?) do |index_name|
+          index_name == 'foo_delta' ? true : false
+        end
+      end
+
+      it "should not start the indexer" do
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_not_receive(:`)
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(
+          ['foo_delta']
+        )
+      end
+
+      it "should not start the indexer for multiple indexes" do
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_not_receive(:`)
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.perform(
+          ['bar_delta', 'foo_delta']
+        )
       end
     end
   end

data/spec/thinking_sphinx/deltas/resque_delta/flag_as_deleted_job_spec.rb

@@ -5,19 +5,19 @@ describe ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob do
     before :each do
       ThinkingSphinx.updates_enabled = true
       @client = stub('client', :update => true)
-      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
-      ThinkingSphinx.stub!(:search_for_id => true)
-      ThinkingSphinx.stub!(:sphinx_running? => true)
+      ThinkingSphinx::Configuration.instance.stub(:client => @client)
+      ThinkingSphinx.stub(:search_for_id => true)
+      ThinkingSphinx.stub(:sphinx_running? => true)
     end
 
     it "should not update if Sphinx isn't running" do
-      ThinkingSphinx.stub!(:sphinx_running? => false)
+      ThinkingSphinx.stub(:sphinx_running? => false)
       @client.should_not_receive(:update)
       ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob.perform(['foo_core'], 12)
     end
 
     it "should not update if the document isn't in the index" do
-      ThinkingSphinx.stub!(:search_for_id => false)
+      ThinkingSphinx.stub(:search_for_id => false)
       @client.should_not_receive(:update)
       ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob.perform(['foo_core'], 12)
     end

data/spec/thinking_sphinx/deltas/resque_delta_spec.rb

@@ -6,21 +6,25 @@ describe ThinkingSphinx::Deltas::ResqueDelta do
       ThinkingSphinx.updates_enabled = true
       ThinkingSphinx.deltas_enabled  = true
 
-      Resque.stub!(:enqueue => true)
+      Resque.stub(:enqueue => true)
 
       @delayed_delta = ThinkingSphinx::Deltas::ResqueDelta.new(
         stub('instance'), {}
       )
-      @delayed_delta.stub!(:toggled => true)
+      @delayed_delta.stub(:toggled).and_return(true)
+
+      ThinkingSphinx::Deltas::ResqueDelta.stub(:lock)
+      ThinkingSphinx::Deltas::ResqueDelta.stub(:unlock)
+      ThinkingSphinx::Deltas::ResqueDelta.stub(:locked?).and_return(false)
 
       @model = stub('foo')
-      @model.stub!(:name => 'foo')
-      @model.stub!(:source_of_sphinx_index => @model)
-      @model.stub!(:core_index_names  => ['foo_core'])
-      @model.stub!(:delta_index_names => ['foo_delta'])
+      @model.stub(:name => 'foo')
+      @model.stub(:source_of_sphinx_index => @model)
+      @model.stub(:core_index_names  => ['foo_core'])
+      @model.stub(:delta_index_names => ['foo_delta'])
 
       @instance = stub('instance')
-      @instance.stub!(:sphinx_document_id => 42)
+      @instance.stub(:sphinx_document_id => 42)
     end
 
     context 'updates disabled' do
@@ -57,7 +61,7 @@ describe ThinkingSphinx::Deltas::ResqueDelta do
 
     context "instance isn't toggled" do
       before :each do
-        @delayed_delta.stub!(:toggled => false)
+        @delayed_delta.stub(:toggled => false)
       end
 
       it "should not enqueue a delta job" do
@@ -71,23 +75,44 @@ describe ThinkingSphinx::Deltas::ResqueDelta do
       end
     end
 
-    it "should enqueue a delta job for the appropriate indexes" do
-      Resque.should_receive(:enqueue).with(ThinkingSphinx::Deltas::ResqueDelta::DeltaJob, ['foo_delta']).once
+    it "should enqueue a delta job" do
+      Resque.should_receive(:enqueue).at_least(:once).with(
+        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob,
+        ['foo_delta']
+      )
       @delayed_delta.index(@model)
     end
 
-    it "should enqueue a flag-as-deleted job for the appropriate indexes" do
-      # WTF RSpec: http://gist.github.com/447611
-      # Resque.should_receive(:enqueue).with(ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob, ['foo_core'], an_instance_of(Numeric))
-      Resque.should_receive(:enqueue).twice
+    it "should enqueue a flag-as-deleted job" do
+      Resque.should_receive(:enqueue).at_least(:once).with(
+        ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob,
+        ['foo_core'],
+        42
+      )
       @delayed_delta.index(@model, @instance)
     end
 
-    it "should enqueue a flag-as-deleted job for the appropriate id" do
-      # WTF RSpec: http://gist.github.com/447611
-      # Resque.should_receive(:enqueue).with(ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob, an_instance_of(Array), 42)
-      Resque.should_receive(:enqueue).twice
-      @delayed_delta.index(@model, @instance)
+    context "delta index is locked" do
+      before :each do
+        ThinkingSphinx::Deltas::ResqueDelta.stub(:locked?).and_return(true)
+      end
+
+      it "should not enqueue a delta job" do
+        Resque.should_not_receive(:enqueue).with(
+          ThinkingSphinx::Deltas::ResqueDelta::DeltaJob,
+          ['foo_delta']
+        )
+        @delayed_delta.index(@model, @instance)
+      end
+
+      it "should enqueue a flag-as-deleted job" do
+        Resque.should_receive(:enqueue).at_least(:once).with(
+          ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedJob,
+          ['foo_core'],
+          42
+        )
+        @delayed_delta.index(@model, @instance)
+      end
     end
   end
 end

data/ts-resque-delta.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Aaron Gibralter"]
   s.email       = ["aaron.gibralter@gmail.com"]
-  s.homepage    = "http://github.com/agibralter/ts-resque-delta"
+  s.homepage    = "https://github.com/agibralter/ts-resque-delta"
   s.summary     = %q{Thinking Sphinx - Resque Deltas}
   s.description = %q{Manage delta indexes via Resque for Thinking Sphinx}
 
@@ -26,4 +26,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec", "~> 1"
   s.add_development_dependency "cucumber", ">= 0"
   s.add_development_dependency "database_cleaner", ">= 0.5.2"
+  s.add_development_dependency "mysql"
+  s.add_development_dependency "SystemTimer"
+  s.add_development_dependency "rake", "0.8.7"
+  s.add_development_dependency "ruby-debug"
+  s.add_development_dependency "activerecord", "~> 2.3.11"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ts-resque-delta
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  version: 1.0.0
 platform: ruby
 authors: 
 - Aaron Gibralter
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-20 00:00:00 -04:00
-default_executable: 
+date: 2011-05-31 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: thinking-sphinx
@@ -109,6 +108,80 @@ dependencies:
         version: 0.5.2
   type: :development
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: SystemTimer
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 3
+        - 11
+        version: 2.3.11
+  type: :development
+  version_requirements: *id011
 description: Manage delta indexes via Resque for Thinking Sphinx
 email: 
 - aaron.gibralter@gmail.com
@@ -146,8 +219,7 @@ files:
 - tasks/rails.rake
 - tasks/testing.rb
 - ts-resque-delta.gemspec
-has_rdoc: true
-homepage: http://github.com/agibralter/ts-resque-delta
+homepage: https://github.com/agibralter/ts-resque-delta
 licenses: []
 
 post_install_message: 
@@ -176,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ts-resque-delta
-rubygems_version: 1.5.2
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: Thinking Sphinx - Resque Deltas
@@ -194,3 +266,4 @@ test_files:
 - spec/thinking_sphinx/deltas/resque_delta/delta_job_spec.rb
 - spec/thinking_sphinx/deltas/resque_delta/flag_as_deleted_job_spec.rb
 - spec/thinking_sphinx/deltas/resque_delta_spec.rb
+has_rdoc: