ts-delayed-delta 1.1.3 → 2.0.0

data/VERSION

@@ -1 +0,0 @@
-1.1.2

data/features/delayed_deltas.feature

@@ -1,37 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,11 +0,0 @@
-When /^I run the delayed jobs$/ do
-  if Delayed::Worker.respond_to? :backend
-    Delayed::Worker.new(:quiet => true).work_off
-  else
-    Delayed::Job.work_off
-  end
-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/env.rb

@@ -1,33 +0,0 @@
-require 'rubygems'
-require 'fileutils'
-require 'bundler'
-
-Bundler.require :default, :development
-
-require 'active_record'
-require 'thinking_sphinx'
-require 'delayed_job'
-
-ActiveRecord::Base.send(:include, ThinkingSphinx::ActiveRecord)
-Delayed::Worker.backend = :active_record
-
-ActiveSupport::Inflector.inflections do |inflect|
-  inflect.plural /^(.*)beta$/i, '\1betas'
-  inflect.singular /^(.*)betas$/i, '\1beta'
-end
-
-$:.unshift File.dirname(__FILE__) + '/../../lib'
-
-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
-world.configure_database
-
-require "thinking_sphinx"
-require 'thinking_sphinx/deltas/delayed_delta'
-
-world.setup

data/features/thinking_sphinx/database.example.yml

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

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

@@ -1,10 +0,0 @@
-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/thinking_sphinx/db/migrations/create_delayed_betas.rb

@@ -1,17 +0,0 @@
-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/thinking_sphinx/models/delayed_beta.rb

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

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

@@ -1,65 +0,0 @@
-module Delayed
-  module Backend
-    module ActiveRecord
-      class Job < ::ActiveRecord::Base
-        self.table_name = "delayed_jobs"
-      end
-    end
-  end
-end
-
-# 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::Backend::ActiveRecord::Job
-  self.table_name = "delayed_jobs"
-  # 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 => 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/railtie.rb

@@ -1,5 +0,0 @@
-class ThinkingSphinx::Deltas::DelayedDelta::Railtie < Rails::Railtie
-  rake_tasks do
-    load 'thinking_sphinx/deltas/delayed_delta/tasks.rb'
-  end
-end

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

@@ -1,23 +0,0 @@
-namespace :thinking_sphinx do
-  task :index do
-    require 'thinking_sphinx/deltas/delayed_delta'
-    ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
-  end
-
-  desc "Process stored delta index requests"
-  task :delayed_delta => :app_env do
-    require 'delayed_job'
-    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/lib/thinking_sphinx/deltas/delayed_delta/version.rb

@@ -1,5 +0,0 @@
-module ThinkingSphinx
-  module DelayedDelta
-    Version = '1.1.3'
-  end
-end

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

@@ -1,53 +0,0 @@
-require '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 indices" do
-      @delta_job.should_receive(:`) do |command|
-        command.should match(/foo_core/)
-        command.should_not match(/--all/)
-      end
-
-      @delta_job.perform
-    end
-
-    context 'multiple indices' do
-      it "should process all requested indices" do
-        @delta_job.indices = ['foo_core', 'bar_core']
-        @delta_job.should_receive(:`) do |command|
-          command.should match(/foo_core bar_core/)
-        end
-
-        @delta_job.perform
-      end
-    end
-  end
-
-  describe "#display_name" do
-    it "should display class name with all indices" do
-      @delta_job = ThinkingSphinx::Deltas::DeltaJob.new(['foo_core', 'bar_core'])
-      @delta_job.display_name.should == "ThinkingSphinx::Deltas::DeltaJob for foo_core, bar_core"
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require '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 indices" do
-      @job.indices = ['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

@@ -1,52 +0,0 @@
-require '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 => double('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