dpickett-thinking-sphinx 1.1.4

data/lib/thinking_sphinx/tasks.rb

@@ -0,0 +1,128 @@
+require 'fileutils'
+
+namespace :thinking_sphinx do
+  task :app_env do
+    Rake::Task[:environment].invoke if defined?(RAILS_ROOT)
+    Rake::Task[:merb_env].invoke    if defined?(Merb)
+  end
+  
+  desc "Stop if running, then start a Sphinx searchd daemon using Thinking Sphinx's settings"
+  task :running_start => :app_env do
+   Rake::Task["thinking_sphinx:stop"].invoke if sphinx_running?
+   Rake::Task["thinking_sphinx:start"].invoke
+  end
+  
+  desc "Start a Sphinx searchd daemon using Thinking Sphinx's settings"
+  task :start => :app_env do
+    config = ThinkingSphinx::Configuration.instance
+    
+    FileUtils.mkdir_p config.searchd_file_path
+    raise RuntimeError, "searchd is already running." if sphinx_running?
+    
+    Dir["#{config.searchd_file_path}/*.spl"].each { |file| File.delete(file) }
+
+    cmd = "#{config.bin_path}searchd --pidfile --config #{config.config_file}"
+    puts cmd
+    system cmd
+    
+    sleep(2)
+    
+    if sphinx_running?
+      puts "Started successfully (pid #{sphinx_pid})."
+    else
+      puts "Failed to start searchd daemon. Check #{config.searchd_log_file}."
+    end
+  end
+  
+  desc "Stop Sphinx using Thinking Sphinx's settings"
+  task :stop => :app_env do
+    raise RuntimeError, "searchd is not running." unless sphinx_running?
+    config = ThinkingSphinx::Configuration.instance
+    pid    = sphinx_pid
+    system "searchd --stop --config #{config.config_file}"
+    puts "Stopped search daemon (pid #{pid})."
+  end
+  
+  desc "Restart Sphinx"
+  task :restart => [:app_env, :stop, :start]
+  
+  desc "Generate the Sphinx configuration file using Thinking Sphinx's settings"
+  task :configure => :app_env do
+    config = ThinkingSphinx::Configuration.instance
+    puts "Generating Configuration to #{config.config_file}"
+    config.build
+  end
+  
+  desc "Index data for Sphinx using Thinking Sphinx's settings"
+  task :index => :app_env do
+    ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
+    
+    config = ThinkingSphinx::Configuration.instance
+    unless ENV["INDEX_ONLY"] == "true"
+      puts "Generating Configuration to #{config.config_file}"
+      config.build
+    end
+        
+    FileUtils.mkdir_p config.searchd_file_path
+    cmd = "#{config.bin_path}indexer --config #{config.config_file} --all"
+    cmd << " --rotate" if sphinx_running?
+    puts cmd
+    system cmd
+  end
+  
+  namespace :index do
+    task :delta => :app_env do
+      ThinkingSphinx.indexed_models.select { |model|
+        model.constantize.sphinx_indexes.any? { |index| index.delta? }
+      }.each do |model|
+        model.constantize.sphinx_indexes.select { |index|
+          index.delta? && index.delta_object.respond_to?(:delayed_index)
+        }.each { |index|
+          index.delta_object.delayed_index(index.model)
+        }
+      end
+    end
+  end
+  
+  desc "Process stored delta index requests"
+  task :delayed_delta => :app_env do
+    require 'delayed/worker'
+    
+    Delayed::Worker.new(
+      :min_priority => ENV['MIN_PRIORITY'],
+      :max_priority => ENV['MAX_PRIORITY']
+    ).start
+  end
+end
+
+namespace :ts do
+  desc "Stop if running, then start a Sphinx searchd daemon using Thinking Sphinx's settings"
+  task :run     => "thinking_sphinx:running_start"
+  desc "Start a Sphinx searchd daemon using Thinking Sphinx's settings"
+  task :start   => "thinking_sphinx:start"
+  desc "Stop Sphinx using Thinking Sphinx's settings"
+  task :stop    => "thinking_sphinx:stop"
+  desc "Index data for Sphinx using Thinking Sphinx's settings"
+  task :in      => "thinking_sphinx:index"
+  namespace :in do
+    desc "Index Thinking Sphinx datetime delta indexes"
+    task :delta => "thinking_sphinx:index:delta"
+  end
+  task :index   => "thinking_sphinx:index"
+  desc "Restart Sphinx"
+  task :restart => "thinking_sphinx:restart"
+  desc "Generate the Sphinx configuration file using Thinking Sphinx's settings"
+  task :conf    => "thinking_sphinx:configure"
+  desc "Generate the Sphinx configuration file using Thinking Sphinx's settings"
+  task :config  => "thinking_sphinx:configure"
+  desc "Process stored delta index requests"
+  task :dd      => "thinking_sphinx:delayed_delta"
+end
+
+def sphinx_pid
+  ThinkingSphinx.sphinx_pid
+end
+
+def sphinx_running?
+  ThinkingSphinx.sphinx_running?
+end

data/lib/thinking_sphinx.rb

@@ -0,0 +1,145 @@
+Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
+  $LOAD_PATH.unshift path
+end
+
+require 'active_record'
+require 'riddle'
+require 'after_commit'
+
+require 'thinking_sphinx/core/string'
+require 'thinking_sphinx/active_record'
+require 'thinking_sphinx/association'
+require 'thinking_sphinx/attribute'
+require 'thinking_sphinx/collection'
+require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/facet'
+require 'thinking_sphinx/class_facet'
+require 'thinking_sphinx/facet_collection'
+require 'thinking_sphinx/field'
+require 'thinking_sphinx/index'
+require 'thinking_sphinx/rails_additions'
+require 'thinking_sphinx/search'
+require 'thinking_sphinx/deltas'
+
+require 'thinking_sphinx/adapters/abstract_adapter'
+require 'thinking_sphinx/adapters/mysql_adapter'
+require 'thinking_sphinx/adapters/postgresql_adapter'
+
+ActiveRecord::Base.send(:include, ThinkingSphinx::ActiveRecord)
+
+Merb::Plugins.add_rakefiles(
+  File.join(File.dirname(__FILE__), "thinking_sphinx", "tasks")
+) if defined?(Merb)
+
+module ThinkingSphinx
+  module Version #:nodoc:
+    Major = 1
+    Minor = 1
+    Tiny  = 4
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+  
+  # A ConnectionError will get thrown when a connection to Sphinx can't be
+  # made.
+  class ConnectionError < StandardError
+  end
+  
+  # A StaleIdsException is thrown by Collection.instances_from_matches if there
+  # are records in Sphinx but not in the database, so the search can be retried.
+  class StaleIdsException < StandardError
+    attr_accessor :ids
+    def initialize(ids)
+      self.ids = ids
+    end
+  end
+  
+  # The collection of indexed models. Keep in mind that Rails lazily loads
+  # its classes, so this may not actually be populated with _all_ the models
+  # that have Sphinx indexes.
+  def self.indexed_models
+    @@indexed_models ||= []
+  end
+  
+  # Check if index definition is disabled.
+  # 
+  def self.define_indexes?
+    @@define_indexes =  true unless defined?(@@define_indexes)
+    @@define_indexes == true
+  end
+  
+  # Enable/disable indexes - you may want to do this while migrating data.
+  # 
+  #   ThinkingSphinx.define_indexes = false
+  # 
+  def self.define_indexes=(value)
+    @@define_indexes = value
+  end
+  
+  @@deltas_enabled = nil
+
+  # Check if delta indexing is enabled.
+  # 
+  def self.deltas_enabled?
+    @@deltas_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@deltas_enabled.nil?
+    @@deltas_enabled
+  end
+  
+  # Enable/disable all delta indexing.
+  #
+  #   ThinkingSphinx.deltas_enabled = false
+  #
+  def self.deltas_enabled=(value)
+    @@deltas_enabled = value
+  end
+  
+  @@updates_enabled = nil
+  
+  # Check if updates are enabled. True by default, unless within the test
+  # environment.
+  # 
+  def self.updates_enabled?
+    @@updates_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@updates_enabled.nil?
+    @@updates_enabled
+  end
+  
+  # Enable/disable updates to Sphinx
+  # 
+  #   ThinkingSphinx.updates_enabled = false
+  #
+  def self.updates_enabled=(value)
+    @@updates_enabled = value
+  end
+  
+  @@suppress_delta_output = false
+  
+  def self.suppress_delta_output?
+    @@suppress_delta_output
+  end
+  
+  def self.suppress_delta_output=(value)
+    @@suppress_delta_output = value
+  end
+  
+  # Checks to see if MySQL will allow simplistic GROUP BY statements. If not,
+  # or if not using MySQL, this will return false.
+  # 
+  def self.use_group_by_shortcut?
+    ::ActiveRecord::ConnectionAdapters.constants.include?("MysqlAdapter") &&
+    ::ActiveRecord::Base.connection.is_a?(
+      ::ActiveRecord::ConnectionAdapters::MysqlAdapter
+    ) &&
+    ::ActiveRecord::Base.connection.select_all(
+      "SELECT @@global.sql_mode, @@session.sql_mode;"
+    ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
+  end
+  
+  def self.sphinx_running?
+    !!sphinx_pid
+  end
+  
+  def self.sphinx_pid
+    pid_file = ThinkingSphinx::Configuration.instance.pid_file    
+    `cat #{pid_file}`[/\d+/] if File.exists?(pid_file)
+  end
+end

data/spec/unit/thinking_sphinx/active_record/delta_spec.rb

@@ -0,0 +1,136 @@
+require 'spec/spec_helper'
+
+describe "ThinkingSphinx::ActiveRecord::Delta" do
+  it "should call the toggle_delta method after a save" do
+    @beta = Beta.new(:name => 'beta')
+    @beta.stub_method(:toggle_delta => true)
+    
+    @beta.save
+    
+    @beta.should have_received(:toggle_delta)
+  end
+  
+  it "should call the toggle_delta method after a save!" do
+    @beta = Beta.new(:name => 'beta')
+    @beta.stub_method(:toggle_delta => true)
+    
+    @beta.save!
+    
+    @beta.should have_received(:toggle_delta)
+  end
+
+  describe "suspended_delta method" do
+    before :each do
+      ThinkingSphinx.stub_method(:deltas_enabled? => true)
+      Person.sphinx_indexes.first.delta_object.stub_method(:` => "")
+    end
+
+    it "should execute the argument block with deltas disabled" do
+      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(false)
+      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(true)
+      lambda { Person.suspended_delta { raise 'i was called' } }.should(
+        raise_error(Exception)
+      )
+    end
+
+    it "should restore deltas_enabled to its original setting" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => false)
+      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
+      Person.suspended_delta { 'no-op' }
+    end
+
+    it "should restore deltas_enabled to its original setting even if there was an exception" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => false)
+      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
+      lambda { Person.suspended_delta { raise 'bad error' } }.should(
+        raise_error(Exception)
+      )
+    end
+
+    it "should reindex by default after the code block is run" do
+      Person.should_receive(:index_delta)
+      Person.suspended_delta { 'no-op' }
+    end
+    
+    it "should not reindex after the code block if false is passed in" do
+      Person.should_not_receive(:index_delta)
+      Person.suspended_delta(false) { 'no-op' }
+    end
+  end
+  
+  describe "toggle_delta method" do
+    it "should set the delta value to true" do
+      @person = Person.new
+      
+      @person.delta.should be_false
+      @person.send(:toggle_delta)
+      @person.delta.should be_true
+    end
+  end
+  
+  describe "index_delta method" do
+    before :each do
+      ThinkingSphinx::Configuration.stub_method(:environment => "spec")
+      ThinkingSphinx.stub_method(:deltas_enabled? => true, :sphinx_running? => true)
+      Person.delta_object.stub_methods(:` => "", :toggled => true)
+      
+      @person = Person.new
+      @person.stub_method(
+        :in_core_index?     => false,
+        :sphinx_document_id => 1
+      )
+      
+      @client = Riddle::Client.stub_instance(:update => true)
+      Riddle::Client.stub_method(:new => @client)
+    end
+    
+    it "shouldn't index if delta indexing is disabled" do
+      ThinkingSphinx.stub_method(:deltas_enabled? => false)
+      
+      @person.send(:index_delta)
+      
+      Person.sphinx_indexes.first.delta_object.should_not have_received(:`)
+      @client.should_not have_received(:update)
+    end
+    
+    it "shouldn't index if index updating is disabled" do
+      ThinkingSphinx.stub_method(:updates_enabled? => false)
+      
+      @person.send(:index_delta)
+      
+      Person.sphinx_indexes.first.delta_object.should_not have_received(:`)
+    end
+    
+    it "shouldn't index if the environment is 'test'" do
+      ThinkingSphinx.unstub_method(:deltas_enabled?)
+      ThinkingSphinx.deltas_enabled = nil
+      ThinkingSphinx::Configuration.stub_method(:environment => "test")
+      
+      @person.send(:index_delta)
+      
+      Person.sphinx_indexes.first.delta_object.should_not have_received(:`)
+    end
+    
+    it "should call indexer for the delta index" do
+      @person.send(:index_delta)
+      
+      Person.sphinx_indexes.first.delta_object.should have_received(:`).with(
+        "#{ThinkingSphinx::Configuration.instance.bin_path}indexer --config #{ThinkingSphinx::Configuration.instance.config_file} --rotate person_delta"
+      )
+    end
+    
+    it "shouldn't update the deleted attribute if not in the index" do
+      @person.send(:index_delta)
+      
+      @client.should_not have_received(:update)
+    end
+    
+    it "should update the deleted attribute if in the core index" do
+      @person.stub_method(:in_core_index? => true)
+      
+      @person.send(:index_delta)
+      
+      @client.should have_received(:update)
+    end
+  end
+end

data/spec/unit/thinking_sphinx/active_record/has_many_association_spec.rb

@@ -0,0 +1,53 @@
+require 'spec/spec_helper'
+
+describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
+  describe "search method" do
+    before :each do
+      Friendship.stub_method(:search => true)
+      
+      @person = Person.find(:first)
+      @index  = Friendship.sphinx_indexes.first
+    end
+    
+    it "should raise an error if the required attribute doesn't exist" do
+      @index.stub_method(:attributes => [])
+      
+      lambda { @person.friendships.search "test" }.should raise_error(RuntimeError)
+      
+      @index.unstub_method(:attributes)
+    end
+    
+    it "should add a filter for the attribute into a normal search call" do
+      @person.friendships.search "test"
+      
+      Friendship.should have_received(:search).with(
+        "test", :with => {:person_id => @person.id}
+      )
+    end    
+  end
+  
+  describe "search method for has_many :through" do
+    before :each do
+      Person.stub_method(:search => true)
+      
+      @person = Person.find(:first)
+      @index  = Person.sphinx_indexes.first
+    end
+    
+    it "should raise an error if the required attribute doesn't exist" do
+      @index.stub_method(:attributes => [])
+      
+      lambda { @person.friends.search "test" }.should raise_error(RuntimeError)
+      
+      @index.unstub_method(:attributes)
+    end
+    
+    it "should add a filter for the attribute into a normal search call" do
+      @person.friends.search "test"
+      
+      Person.should have_received(:search).with(
+        "test", :with => {:friendly_ids => @person.id}
+      )
+    end
+  end
+end

data/spec/unit/thinking_sphinx/active_record/search_spec.rb

@@ -0,0 +1,107 @@
+require 'spec/spec_helper'
+
+describe "ThinkingSphinx::ActiveRecord::Search" do
+  it "should add search_for_ids to ActiveRecord::Base" do
+    ActiveRecord::Base.methods.should include("search_for_ids")
+  end
+  
+  it "should add search_for_ids to ActiveRecord::Base" do
+    ActiveRecord::Base.methods.should include("search")
+  end
+  
+  it "should add search_count to ActiveRecord::Base" do
+    ActiveRecord::Base.methods.should include("search_count")
+  end
+
+  it "should add search_for_id to ActiveRecord::Base" do
+    ActiveRecord::Base.methods.should include("search_for_id")
+  end
+  
+  describe "search_for_ids method" do
+    before :each do
+      ThinkingSphinx::Search.stub_method(:search_for_ids => true)
+    end
+    
+    it "should call ThinkingSphinx::Search#search_for_ids with the class option set" do
+      Person.search_for_ids("search")
+      
+      ThinkingSphinx::Search.should have_received(:search_for_ids).with(
+        "search", :class => Person
+      )
+    end
+    
+    it "should override the class option" do
+      Person.search_for_ids("search", :class => Friendship)
+      
+      ThinkingSphinx::Search.should have_received(:search_for_ids).with(
+        "search", :class => Person
+      )
+    end
+  end
+  
+  describe "search method" do
+    before :each do
+      ThinkingSphinx::Search.stub_method(:search => true)
+    end
+    
+    it "should call ThinkingSphinx::Search#search with the class option set" do
+      Person.search("search")
+      
+      ThinkingSphinx::Search.should have_received(:search).with(
+        "search", :class => Person
+      )
+    end
+    
+    it "should override the class option" do
+      Person.search("search", :class => Friendship)
+      
+      ThinkingSphinx::Search.should have_received(:search).with(
+        "search", :class => Person
+      )
+    end
+  end
+  
+  describe "search_for_id method" do
+    before :each do
+      ThinkingSphinx::Search.stub_method(:search_for_id => true)
+    end
+    
+    it "should call ThinkingSphinx::Search#search with the class option set" do
+      Person.search_for_id(10)
+      
+      ThinkingSphinx::Search.should have_received(:search_for_id).with(
+        10, :class => Person
+      )
+    end
+    
+    it "should override the class option" do
+      Person.search_for_id(10, :class => Friendship)
+      
+      ThinkingSphinx::Search.should have_received(:search_for_id).with(
+        10, :class => Person
+      )
+    end
+  end
+
+  describe "search_count method" do
+    before :each do
+      ThinkingSphinx::Search.stub_method(:count => true)
+    end
+
+    it "should call ThinkingSphinx::Search#search with the class option set" do
+      Person.search_count("search")
+
+      ThinkingSphinx::Search.should have_received(:count).with(
+        "search", :class => Person
+      )
+    end
+
+    it "should override the class option" do
+      Person.search_count("search", :class => Friendship)
+
+      ThinkingSphinx::Search.should have_received(:count).with(
+        "search", :class => Person
+      )
+    end
+  end
+end