flying-sphinx 0.8.5 → 1.0.0

data/lib/flying_sphinx/delayed_delta.rb

@@ -1,89 +0,0 @@
-class FlyingSphinx::DelayedDelta < ThinkingSphinx::Deltas::DefaultDelta
-  # 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, 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)
-    return if duplicates_exist? object
-
-    enqueue_without_duplicates_check object, priority
-  end
-
-  def self.enqueue_without_duplicates_check(object, priority = 0)
-    if defined?(Rails) && Rails.version.to_i <= 2
-      ::Delayed::Job.enqueue(object, priority)
-    else
-      ::Delayed::Job.enqueue(object, :priority => priority)
-    end
-  end
-
-  # 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)
-    ::Delayed::Job.count(
-      :conditions => {
-        :handler    => object.to_yaml,
-        :locked_at  => nil
-      }
-    ) > 0
-  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.
-  #
-  # 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
-
-    self.class.enqueue(
-      FlyingSphinx::IndexRequest.new(model.delta_index_names, true),
-      delayed_job_priority
-    )
-
-    self.class.enqueue_without_duplicates_check(
-      FlyingSphinx::FlagAsDeletedJob.new(
-        model.core_index_names, instance.sphinx_document_id
-      ),
-      delayed_job_priority
-    ) if instance
-
-    true
-  end
-
-  private
-
-  def delayed_job_priority
-    ThinkingSphinx::Configuration.instance.delayed_job_priority
-  end
-
-  # 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/flying_sphinx/flag_as_deleted_job.rb

@@ -1,41 +0,0 @@
-# A simple job for flagging a specified Sphinx document in a given index as
-# 'deleted'.
-#
-class FlyingSphinx::FlagAsDeletedJob
-  attr_accessor :indices, :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(indices, document_id)
-    @indices, @document_id = indices, 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
-    indices.each do |index|
-      client.update index, ['sphinx_deleted'], {@document_id => [1]}
-    end
-  rescue Riddle::ConnectionError
-    # If it fails here, so be it.
-  ensure
-    true
-  end
-
-  private
-
-  def client
-    @client ||= ThinkingSphinx::Configuration.instance.client
-  end
-end

data/lib/flying_sphinx/heroku_shared_adapter.rb

@@ -1,5 +0,0 @@
-class FlyingSphinx::HerokuSharedAdapter < ThinkingSphinx::PostgreSQLAdapter
-  def setup
-    create_array_accum_function
-  end
-end

data/lib/flying_sphinx/index_request.rb

@@ -1,110 +0,0 @@
-class FlyingSphinx::IndexRequest
-  attr_reader :index_id, :indices, :async
-
-  INDEX_COMPLETE_CHECKING_INTERVAL = 3
-
-  # Remove all Delta jobs from the queue. If the
-  # delayed_jobs table does not exist, this method will do nothing.
-  #
-  def self.cancel_jobs
-    return unless defined?(::Delayed) && ::Delayed::Job.table_exists?
-
-    ::Delayed::Job.delete_all "handler LIKE '--- !ruby/object:FlyingSphinx::%'"
-  end
-
-  def self.output_last_index
-    index = FlyingSphinx::Configuration.new.api.get('indices/last').body
-    puts "Index Job Status: #{index.status}"
-    puts "Index Log:\n#{index.log}"
-  end
-
-  def initialize(indices = [], async = false)
-    @indices, @async = indices, async
-  end
-
-  # Shows index name in Delayed::Job#name.
-  #
-  def display_name
-    "#{self.class.name} for #{indices.join(', ')}"
-  end
-
-  def index
-    begin_request
-    return if async
-
-    while !request_complete?
-      sleep 3
-    end
-  end
-
-  def status_message
-    raise "Index Request failed to start. Something's not right!" if @index_id.nil?
-
-    status = request_status
-    case status
-    when 'FINISHED'
-      "Index Request has completed:\n#{request_log}"
-    when 'FAILED'
-      'Index Request failed.'
-    when 'PENDING'
-      'Index Request is still pending - something has gone wrong.'
-    else
-      "Unknown index response: '#{status}'."
-    end
-  end
-
-  # Runs Sphinx's indexer tool to process the index. Currently assumes Sphinx is
-  # running.
-  #
-  # @return [Boolean] true
-  #
-  def perform
-    index
-    true
-  end
-
-  private
-
-  def configuration
-    @configuration ||= FlyingSphinx::Configuration.new
-  end
-
-  def begin_request
-    path = 'indices'
-    path << '/unique' if async
-    response = api.post path, :indices => indices.join(',')
-
-    @index_id = response.body.id
-    @request_begun = true
-
-    raise RuntimeError, 'Your account does not support delta indexing. Upgrading plans is probably the best way around this.' if response.body.status == 'BLOCKED'
-  end
-
-  def request_begun?
-    @request_begun
-  end
-
-  def request_complete?
-    case request_status
-    when 'FINISHED', 'FAILED'
-      true
-    when 'PENDING'
-      false
-    else
-      raise "Unknown index response: '#{response.body}'"
-    end
-  end
-
-  def request_log
-    @request.log
-  end
-
-  def request_status
-    @request = api.get("indices/#{index_id}").body
-    @request.status
-  end
-
-  def api
-    configuration.api
-  end
-end

data/lib/flying_sphinx/sphinx_configuration.rb

@@ -1,30 +0,0 @@
-class FlyingSphinx::SphinxConfiguration
-  def initialize(thinking_sphinx = ThinkingSphinx::Configuration.instance)
-    @thinking_sphinx = thinking_sphinx
-  end
-
-  def upload_to(api)
-    api.put '/',
-      :configuration  => content,
-      :sphinx_version => thinking_sphinx.version
-  end
-
-  def upload_file_to(api, path)
-    api.put '/',
-      :configuration  => File.read(path),
-      :sphinx_version => '2.0.4'
-  end
-
-  private
-
-  attr_reader :thinking_sphinx
-
-  def content
-    @content ||= begin
-      thinking_sphinx.generate
-      thinking_sphinx.configuration.searchd.client_key =
-        FlyingSphinx::Configuration.new.client_key
-      thinking_sphinx.configuration.render
-    end
-  end
-end

data/spec/specs/delayed_delta_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-describe FlyingSphinx::DelayedDelta do
-  describe '.enqueue' do
-    before :each do
-      Delayed::Job.stub!(:count => 0)
-    end
-
-    it "should enqueue if there's no existing jobs for the same index" do
-      Delayed::Job.should_receive(:enqueue)
-
-      FlyingSphinx::DelayedDelta.enqueue(stub('object'))
-    end
-
-    it "should not enqueue the job if there's an existing job already" do
-      Delayed::Job.stub!(:count => 1)
-      Delayed::Job.should_not_receive(:enqueue)
-
-      FlyingSphinx::DelayedDelta.enqueue(stub('object'))
-    end
-  end
-
-  describe '#index' do
-    let(:config)        { ThinkingSphinx::Configuration.instance }
-    let(:delayed_delta) { FlyingSphinx::DelayedDelta.new stub('instance'), {} }
-    let(:model)         {
-      stub 'foo',
-        :name              => 'foo',
-        :core_index_names  => ['foo_core'],
-        :delta_index_names => ['foo_delta']
-    }
-    let(:instance) { stub('instance', :sphinx_document_id => 42) }
-
-    before :each do
-      ThinkingSphinx.updates_enabled = true
-      ThinkingSphinx.deltas_enabled  = true
-
-      config.delayed_job_priority = 2
-
-      FlyingSphinx::DelayedDelta.stub!(:enqueue => true)
-      Delayed::Job.stub!(:enqueue => true, :inspect => 'Delayed::Job')
-
-      delayed_delta.stub!(:toggled => true)
-    end
-
-    context 'updates disabled' do
-      before :each do
-        ThinkingSphinx.updates_enabled = false
-      end
-
-      it "should not enqueue a delta job" do
-        FlyingSphinx::DelayedDelta.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
-        FlyingSphinx::DelayedDelta.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
-        FlyingSphinx::DelayedDelta.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
-      FlyingSphinx::DelayedDelta.should_receive(:enqueue) do |job, priority|
-        job.indices.should == ['foo_delta']
-        job.async.should be_true
-      end
-
-      delayed_delta.index model
-    end
-
-    it "should use the defined priority for the delta job" do
-      FlyingSphinx::DelayedDelta.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, options|
-        job.indices.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, options|
-        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, options|
-        options[: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

data/spec/specs/flag_as_deleted_job_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe FlyingSphinx::FlagAsDeletedJob do
-  describe '#perform' do
-    let(:config) { ThinkingSphinx::Configuration.instance }
-    let(:client) { stub('client', :update => true) }
-    let(:job)    { FlyingSphinx::FlagAsDeletedJob.new(['foo_core'], 12) }
-
-    before :each do
-      config.stub!(:client => client)
-    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.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
-  end
-end