namxam-ts-delayed-delta 1.0.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Pat Allan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,54 @@
+h1. Delayed Deltas for Thinking Sphinx
+
+h2. Installation
+
+You'll need Thinking Sphinx 1.3.0 or later, and Delayed Job as well. The latter is flagged as a dependency.
+
+<pre><code>gem install ts-delayed-delta --source http://gemcutter.org</code></pre>
+
+In your @environment.rb@ file, with the rest of your gem dependencies:
+
+<pre><code>config.gem 'ts-delayed-delta',
+  :lib     => 'thinking_sphinx/deltas/delayed_delta'
+  :version => '>= 1.0.0',
+  :source  => 'http://gemcutter.org'</code></pre>
+
+And add the following line to the bottom of your @Rakefile@:
+
+<pre><code>require 'thinking_sphinx/deltas/delayed_delta/tasks'</code></pre>
+
+If this is your first time running Delayed Job, then you're going to need the jobs table migration as well:
+
+<pre><code>script/generate delayed_job</code></pre>
+
+For the indexes you want to use this delta approach, make sure you set that up in their @define_index@ blocks.
+
+<pre><code>define_index do
+  # ...
+  
+  set_property :delta => :delayed
+end</code></pre>
+
+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.
+
+<pre><code>def self.up
+  add_column :articles, :delta, :boolean, :default => true, :null => false
+end</code></pre>
+
+h2. Usage
+
+Once you've got it all set up, all you need to do is make sure that the delayed job process is running - either by Delayed Job's built-in approach, or Thinking Sphinx's custom rake task:
+
+<pre><code>rake thinking_sphinx:delayed_delta</code></pre>
+
+There's also a short name for the same task, to save your fingers some effort:
+
+<pre><code>rake ts:dd</code></pre>
+
+h2. Contributors
+
+* "Ryan Schlesinger":http://github.com/ryansch
+
+h2. Copyright
+
+Copyright (c) 2009 Pat Allan, and released under an MIT Licence.

data/features/delayed_deltas.feature

@@ -0,0 +1,37 @@
+Feature: Delayed Delta Indexing
+  In order to have delta indexing on frequently-updated sites
+  Developers
+  Should be able to use delayed_job to handle delta indexes to lower system load
+  
+  Scenario: Delta Index should not fire automatically
+    Given Sphinx is running
+    And I am searching on delayed betas
+    When I search for one
+    Then I should get 1 result
+  
+    When I change the name of delayed beta one to eleven
+    And I wait for Sphinx to catch up
+    And I search for one
+    Then I should get 1 result
+    
+    When I search for eleven
+    Then I should get 0 results
+  
+  Scenario: Delta Index should fire when jobs are run
+    Given Sphinx is running
+    And I am searching on delayed betas
+    When I search for one
+    Then I should get 1 result
+  
+    When I change the name of delayed beta two to twelve
+    And I wait for Sphinx to catch up
+    And I search for twelve
+    Then I should get 0 results
+    
+    When I run the delayed jobs
+    And I wait for Sphinx to catch up
+    And I search for twelve
+    Then I should get 1 result
+    
+    When I search for two
+    Then I should get 0 results

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,48 @@
+Before do
+  $queries_executed = []
+  ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
+  
+  @model      = nil
+  @method     = :search
+  @query      = ""
+  @conditions = {}
+  @with       = {}
+  @without    = {}
+  @with_all   = {}
+  @options    = {}
+  @results    = nil
+end
+
+Given "Sphinx is running" do
+  ThinkingSphinx::Configuration.instance.controller.should be_running
+end
+
+Given /^I am searching on (.+)$/ do |model|
+  @model = model.gsub(/\s/, '_').singularize.camelize.constantize
+end
+
+When "I wait for Sphinx to catch up" do
+  sleep(0.25)
+end
+
+When /^I search for (\w+)$/ do |query|
+  @results = nil
+  @query = query
+end
+
+Then /^I should get (\d+) results?$/ do |count|
+  results.length.should == count.to_i
+end
+
+def results
+  @results ||= (@model || ThinkingSphinx).send(
+    @method,
+    @query,
+    @options.merge(
+      :conditions => @conditions,
+      :with       => @with,
+      :without    => @without,
+      :with_all   => @with_all
+    )
+  )
+end

data/features/step_definitions/delayed_delta_steps.rb

@@ -0,0 +1,7 @@
+When /^I run the delayed jobs$/ do
+  Delayed::Job.work_off.inspect
+end
+
+When /^I change the name of delayed beta (\w+) to (\w+)$/ do |current, replacement|
+  DelayedBeta.find_by_name(current).update_attributes(:name => replacement)
+end

data/features/support/database.example.yml

@@ -0,0 +1,3 @@
+username: root
+host: localhost
+password: 

data/features/support/db/fixtures/delayed_betas.rb

@@ -0,0 +1,10 @@
+DelayedBeta.create :name => "one"
+DelayedBeta.create :name => "two"
+DelayedBeta.create :name => "three"
+DelayedBeta.create :name => "four"
+DelayedBeta.create :name => "five"
+DelayedBeta.create :name => "six"
+DelayedBeta.create :name => "seven"
+DelayedBeta.create :name => "eight"
+DelayedBeta.create :name => "nine"
+DelayedBeta.create :name => "ten"

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

@@ -0,0 +1,17 @@
+ActiveRecord::Base.connection.create_table :delayed_betas, :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/features/support/env.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'cucumber'
+require 'spec/expectations'
+require 'fileutils'
+require 'active_record'
+
+$:.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'cucumber/thinking_sphinx/internal_world'
+
+world = Cucumber::ThinkingSphinx::InternalWorld.new
+world.configure_database
+
+require "thinking_sphinx"
+require 'thinking_sphinx/deltas/delayed_delta'
+
+world.setup

data/features/support/models/delayed_beta.rb

@@ -0,0 +1,7 @@
+class DelayedBeta < ActiveRecord::Base
+  define_index do
+    indexes :name, :sortable => true
+    
+    set_property :delta => :delayed
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta.rb

@@ -0,0 +1,64 @@
+require 'delayed_job'
+require 'thinking_sphinx'
+require 'thinking_sphinx/deltas/delayed_delta/delta_job'
+require 'thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job'
+require 'thinking_sphinx/deltas/delayed_delta/job'
+
+# Delayed Deltas for Thinking Sphinx, using Delayed Job.
+# 
+# This documentation is aimed at those reading the code. If you're looking for
+# a guide to Thinking Sphinx and/or deltas, I recommend you start with the
+# Thinking Sphinx site instead - or the README for this library at the very
+# least.
+# 
+# @author Patrick Allan
+# @see http://ts.freelancing-gods.com Thinking Sphinx
+#
+class ThinkingSphinx::Deltas::DelayedDelta < ThinkingSphinx::Deltas::DefaultDelta
+  
+  # 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.
+  # 
+  # Neither job will be queued if updates or deltas are disabled, or if the 
+  # instance (when given) is not toggled to be in the delta index. The first two
+  # options are controlled via ThinkingSphinx.updates_enabled? and
+  # ThinkingSphinx.deltas_enabled?.
+  # 
+  # @param [Class] model the ActiveRecord model to index.
+  # @param [ActiveRecord::Base] instance the instance of the given model that
+  #   has changed. Optional.
+  # @return [Boolean] true
+  # 
+  def index(model, instance = nil)
+    return true if skip? instance
+    
+    ThinkingSphinx::Deltas::Job.enqueue(
+      ThinkingSphinx::Deltas::DeltaJob.new(model.delta_index_names),
+      ThinkingSphinx::Configuration.instance.delayed_job_priority
+    )
+    
+    Delayed::Job.enqueue(
+      ThinkingSphinx::Deltas::FlagAsDeletedJob.new(
+        model.core_index_names, instance.sphinx_document_id
+      ),
+      ThinkingSphinx::Configuration.instance.delayed_job_priority
+    ) if instance
+    
+    true
+  end
+  
+  private
+  
+  # Checks whether jobs should be enqueued. Only true if updates and deltas are
+  # enabled, and the instance (if there is one) is toggled.
+  # 
+  # @param [ActiveRecord::Base, NilClass] instance
+  # @return [Boolean]
+  # 
+  def skip?(instance)
+    !ThinkingSphinx.updates_enabled? ||
+    !ThinkingSphinx.deltas_enabled?  ||
+    (instance && !toggled(instance))
+  end
+end

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

@@ -0,0 +1,27 @@
+# A simple job class that processes a given index.
+# 
+class ThinkingSphinx::Deltas::DeltaJob
+  attr_accessor :indexes
+  
+  # Initialises the object with an index name.
+  # 
+  # @param [String] index the name of the Sphinx index
+  # 
+  def initialize(indexes)
+    @indexes = indexes
+  end
+  
+  # Runs Sphinx's indexer tool to process the index. Currently assumes Sphinx is
+  # running.
+  # 
+  # @return [Boolean] true
+  # 
+  def perform
+    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?
+    
+    true
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job.rb

@@ -0,0 +1,40 @@
+# A simple job for flagging a specified Sphinx document in a given index as
+# 'deleted'.
+#  
+class ThinkingSphinx::Deltas::FlagAsDeletedJob
+  attr_accessor :indexes, :document_id
+  
+  # Initialises the object with an index name and document id. Please note that
+  # the document id is Sphinx's unique identifier, and will almost certainly not
+  # be the model instance's primary key value.
+  # 
+  # @param [String] index The index name
+  # @param [Integer] document_id The document id
+  # 
+  def initialize(indexes, document_id)
+    @indexes, @document_id = indexes, document_id
+  end
+  
+  # Updates the sphinx_deleted attribute for the given document, setting the
+  # value to 1 (true). This is not a special attribute in Sphinx, but is used
+  # by Thinking Sphinx to ignore deleted values between full re-indexing. It's
+  # particularly useful in this situation to avoid old values in the core index
+  # and just use the new values in the delta index as a reference point.
+  # 
+  # @return [Boolean] true
+  # 
+  def perform
+    config = ThinkingSphinx::Configuration.instance
+    
+    indexes.each do |index|
+      config.client.update(
+        index,
+        ['sphinx_deleted'],
+        {@document_id => [1]}
+      ) if ThinkingSphinx.sphinx_running? &&
+        ThinkingSphinx.search_for_id(@document_id, index)
+    end
+    
+    true
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/job.rb

@@ -0,0 +1,54 @@
+# A custom job model, subclassed from Delayed::Job. The two things it does
+# differently is that it checks for duplicate tasks before enqueuing them, and
+# provides the option to remove all Delayed Delta jobs from the queue.
+# 
+# As such, this class should not be used for any other tasks.
+# 
+class ThinkingSphinx::Deltas::Job < Delayed::Job
+  # Adds a job to the queue, if it doesn't already exist. This is to ensure
+  # multiple indexing requests for the same delta index don't get added, as the
+  # index only needs to be processed once.
+  # 
+  # Because indexing jobs are all the same object, with a single instance
+  # variable (the index name), they all get serialised to the same YAML value.
+  # 
+  # @param [Object] object The job, which must respond to the #perform method.
+  # @param [Integer] priority (0)
+  # 
+  def self.enqueue(object, priority = 0)
+    ::Delayed::Job.enqueue(object, priority) unless duplicates_exist(object)
+  end
+  
+  # Remove all Thinking Sphinx/Delayed Delta jobs from the queue. If the
+  # delayed_jobs table does not exist, this method will do nothing.
+  # 
+  def self.cancel_thinking_sphinx_jobs
+    if connection.tables.include?("delayed_jobs")
+      delete_all("handler LIKE '--- !ruby/object:ThinkingSphinx::Deltas::%'")
+    end
+  end
+  
+  # This is to stop ActiveRecord complaining about a missing database when
+  # running specs (otherwise printing failure messages raises confusing stack
+  # traces).
+  # 
+  def self.inspect
+    "Job"
+  end
+  
+  private
+  
+  # Checks whether a given job already exists in the queue.
+  # 
+  # @param [Object] object The job
+  # @return [Boolean] True if a duplicate of the job already exists in the queue
+  # 
+  def self.duplicates_exist(object)
+    count(
+      :conditions => {
+        :handler    => object.to_yaml,
+        :locked_at  => nil
+      }
+    ) > 0
+  end
+end

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

@@ -0,0 +1,21 @@
+namespace :thinking_sphinx do
+  task :index do
+    ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
+  end
+  
+  desc "Process stored delta index requests"
+  task :delayed_delta => :app_env do
+    require 'delayed/worker'
+    require 'thinking_sphinx/deltas/delayed_delta'
+    
+    Delayed::Worker.new(
+      :min_priority => ENV['MIN_PRIORITY'],
+      :max_priority => ENV['MAX_PRIORITY']
+    ).start
+  end
+end
+
+namespace :ts do
+  desc "Process stored delta index requests"
+  task :dd => "thinking_sphinx:delayed_delta"
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+
+require 'thinking_sphinx'
+require 'thinking_sphinx/deltas/delayed_delta'
+
+Spec::Runner.configure do |config|
+  #
+end

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

@@ -0,0 +1,46 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Deltas::DeltaJob do
+  describe '#perform' do
+    before :each do
+      ThinkingSphinx.suppress_delta_output = false
+      
+      @delta_job = ThinkingSphinx::Deltas::DeltaJob.new(['foo_core'])
+      @delta_job.stub! :`    => true
+      @delta_job.stub! :puts => nil
+    end
+    
+    it "should output the delta indexing by default" do
+      @delta_job.should_receive(:puts)
+      
+      @delta_job.perform
+    end
+    
+    it "should not output the delta indexing if requested" do
+      ThinkingSphinx.suppress_delta_output = true
+      @delta_job.should_not_receive(:puts)
+      
+      @delta_job.perform
+    end
+    
+    it "should process just the requested indexes" do
+      @delta_job.should_receive(:`) do |command|
+        command.should match(/foo_core/)
+        command.should_not match(/--all/)
+      end
+      
+      @delta_job.perform
+    end
+    
+    context 'multiple indexes' do
+      it "should process all requested indexes" do
+        @delta_job.indexes = ['foo_core', 'bar_core']
+        @delta_job.should_receive(:`) do |command|
+          command.should match(/foo_core bar_core/)
+        end
+
+        @delta_job.perform
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Deltas::FlagAsDeletedJob do
+  describe '#perform' 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)
+      
+      @job = ThinkingSphinx::Deltas::FlagAsDeletedJob.new(['foo_core'], 12)
+    end
+    
+    it "should not update if Sphinx isn't running" do
+      ThinkingSphinx.stub!(:sphinx_running? => false)
+      @client.should_not_receive(:update)
+      
+      @job.perform
+    end
+    
+    it "should not update if the document isn't in the index" do
+      ThinkingSphinx.stub!(:search_for_id => false)
+      @client.should_not_receive(:update)
+      
+      @job.perform
+    end
+    
+    it "should update the specified index" do
+      @client.should_receive(:update) do |index, attributes, values|
+        index.should == 'foo_core'
+      end
+      
+      @job.perform
+    end
+    
+    it "should update all specified indexes" do
+      @job.indexes = ['foo_core', 'bar_core']
+      @client.should_receive(:update).with('foo_core', anything, anything)
+      @client.should_receive(:update).with('bar_core', anything, anything)
+      
+      @job.perform
+    end
+    
+    it "should update the sphinx_deleted attribute" do
+      @client.should_receive(:update) do |index, attributes, values|
+        attributes.should == ['sphinx_deleted']
+      end
+      
+      @job.perform
+    end
+    
+    it "should set sphinx_deleted for the given document to true" do
+      @client.should_receive(:update) do |index, attributes, values|
+        values[12].should == [1]
+      end
+      
+      @job.perform
+    end
+    
+    it "should check for the existence of the document in the specified index" do
+      ThinkingSphinx.should_receive(:search_for_id) do |id, index|
+        index.should == 'foo_core'
+      end
+      
+      @job.perform
+    end
+    
+    it "should check for the existence of the given document id" do
+      ThinkingSphinx.should_receive(:search_for_id) do |id, index|
+        id.should == 12
+      end
+      
+      @job.perform
+    end
+  end
+end

data/spec/thinking_sphinx/deltas/delayed_delta/job_spec.rb

@@ -0,0 +1,52 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Deltas::Job do
+  describe '.enqueue' do
+    before :each do
+      ThinkingSphinx::Deltas::Job.stub!(:count => 0)
+    end
+    
+    it "should enqueue if there's no existing jobs for the same index" do
+      Delayed::Job.should_receive(:enqueue)
+      
+      ThinkingSphinx::Deltas::Job.enqueue(stub('object'))
+    end
+    
+    it "should not enqueue the job if there's an existing job already" do
+      ThinkingSphinx::Deltas::Job.stub!(:count => 1)
+      Delayed::Job.should_not_receive(:enqueue)
+      
+      ThinkingSphinx::Deltas::Job.enqueue(stub('object'))
+    end
+  end
+  
+  describe '.cancel_thinking_sphinx_jobs' do
+    before :each do
+      ThinkingSphinx::Deltas::Job.stub!(:connection, stub('connection'))
+      ThinkingSphinx::Deltas::Job.stub!(:delete_all => true)
+    end
+    
+    it "should not delete any rows if the delayed_jobs table does not exist" do
+      ThinkingSphinx::Deltas::Job.connection.stub!(:tables => [])
+      ThinkingSphinx::Deltas::Job.should_not_receive(:delete_all)
+      
+      ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
+    end
+    
+    it "should delete rows if the delayed_jobs table does exist" do
+      ThinkingSphinx::Deltas::Job.connection.stub!(:tables => ['delayed_jobs'])
+      ThinkingSphinx::Deltas::Job.should_receive(:delete_all)
+      
+      ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
+    end
+    
+    it "should delete only Thinking Sphinx jobs" do
+      ThinkingSphinx::Deltas::Job.connection.stub!(:tables => ['delayed_jobs'])
+      ThinkingSphinx::Deltas::Job.should_receive(:delete_all) do |sql|
+        sql.should match(/handler LIKE '--- !ruby\/object:ThinkingSphinx::Deltas::\%'/)
+      end
+      
+      ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
+    end
+  end
+end

data/spec/thinking_sphinx/deltas/delayed_delta_spec.rb

@@ -0,0 +1,128 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Deltas::DelayedDelta do
+  describe '#index' do
+    before :each do
+      ThinkingSphinx.updates_enabled = true
+      ThinkingSphinx.deltas_enabled  = true
+      ThinkingSphinx::Configuration.instance.delayed_job_priority = 2
+      
+      ThinkingSphinx::Deltas::Job.stub!(:enqueue => true)
+      Delayed::Job.stub!(:enqueue => true, :inspect => "Delayed::Job")
+      
+      @delayed_delta = ThinkingSphinx::Deltas::DelayedDelta.new(
+        stub('instance'), {}
+      )
+      @delayed_delta.stub!(:toggled => true)
+      
+      @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'])
+      
+      @instance = stub('instance')
+      @instance.stub!(:sphinx_document_id => 42)
+    end
+    
+    context 'updates disabled' do
+      before :each do
+        ThinkingSphinx.updates_enabled = false
+      end
+      
+      it "should not enqueue a delta job" do
+        ThinkingSphinx::Deltas::Job.should_not_receive(:enqueue)
+        
+        @delayed_delta.index(@model)
+      end
+      
+      it "should not enqueue a flag as deleted job" do
+        Delayed::Job.should_not_receive(:enqueue)
+        
+        @delayed_delta.index(@model)
+      end
+    end
+    
+    context 'deltas disabled' do
+      before :each do
+        ThinkingSphinx.deltas_enabled = false
+      end
+      
+      it "should not enqueue a delta job" do
+        ThinkingSphinx::Deltas::Job.should_not_receive(:enqueue)
+        
+        @delayed_delta.index(@model)
+      end
+      
+      it "should not enqueue a flag as deleted job" do
+        Delayed::Job.should_not_receive(:enqueue)
+        
+        @delayed_delta.index(@model)
+      end
+    end
+    
+    context "instance isn't toggled" do
+      before :each do
+        @delayed_delta.stub!(:toggled => false)
+      end
+      
+      it "should not enqueue a delta job" do
+        ThinkingSphinx::Deltas::Job.should_not_receive(:enqueue)
+        
+        @delayed_delta.index(@model, @instance)
+      end
+      
+      it "should not enqueue a flag as deleted job" do
+        Delayed::Job.should_not_receive(:enqueue)
+        
+        @delayed_delta.index(@model, @instance)
+      end
+    end
+    
+    it "should enqueue a delta job for the appropriate indexes" do
+      ThinkingSphinx::Deltas::Job.should_receive(:enqueue) do |job, priority|
+        job.indexes.should == ['foo_delta']
+      end
+      
+      @delayed_delta.index(@model)
+    end
+    
+    it "should use the defined priority for the delta job" do
+      ThinkingSphinx::Deltas::Job.should_receive(:enqueue) do |job, priority|
+        priority.should == 2
+      end
+      
+      @delayed_delta.index(@model)
+    end
+    
+    it "should enqueue a flag-as-deleted job for the appropriate indexes" do
+      Delayed::Job.should_receive(:enqueue) do |job, priority|
+        job.indexes.should == ['foo_core']
+      end
+      
+      @delayed_delta.index(@model, @instance)
+    end
+    
+    it "should enqueue a flag-as-deleted job for the appropriate id" do
+      Delayed::Job.should_receive(:enqueue) do |job, priority|
+        job.document_id.should == 42
+      end
+      
+      @delayed_delta.index(@model, @instance)
+    end
+    
+    it "should use the defined priority for the flag-as-deleted job" do
+      Delayed::Job.should_receive(:enqueue) do |job, priority|
+        priority.should == 2
+      end
+      
+      @delayed_delta.index(@model, @instance)
+    end
+    
+    it "should not enqueue a flag-as-deleted job if no instance is provided" do
+      Delayed::Job.should_not_receive(:enqueue)
+      
+      @delayed_delta.index(@model)
+    end
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification 
+name: namxam-ts-delayed-delta
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 3
+  version: 1.0.3
+platform: ruby
+authors: 
+- Pat Allan
+- Maximilian Schulz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thinking-sphinx
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 6
+        version: 1.3.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: delayed_job
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 8
+        - 4
+        version: 1.8.4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Manage delta indexes via Delayed Job for Thinking Sphinx (including fix for bundler)
+email: max@jungeelite.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- LICENSE
+- README.textile
+- lib/thinking_sphinx/deltas/delayed_delta.rb
+- lib/thinking_sphinx/deltas/delayed_delta/delta_job.rb
+- lib/thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job.rb
+- lib/thinking_sphinx/deltas/delayed_delta/job.rb
+- lib/thinking_sphinx/deltas/delayed_delta/tasks.rb
+has_rdoc: true
+homepage: http://github.com/namxam/ts-delayed-delta
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Thinking Sphinx - Delayed Deltas
+test_files: 
+- features/delayed_deltas.feature
+- features/step_definitions/common_steps.rb
+- features/step_definitions/delayed_delta_steps.rb
+- features/support/database.example.yml
+- features/support/db/fixtures/delayed_betas.rb
+- features/support/db/migrations/create_delayed_betas.rb
+- features/support/env.rb
+- features/support/models/delayed_beta.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/thinking_sphinx/deltas/delayed_delta/delta_job_spec.rb
+- spec/thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job_spec.rb
+- spec/thinking_sphinx/deltas/delayed_delta/job_spec.rb
+- spec/thinking_sphinx/deltas/delayed_delta_spec.rb