thinking-sphinx 1.2.13 → 1.4.0

data/lib/thinking_sphinx/tasks.rb

@@ -1,10 +1,16 @@
 require 'fileutils'
+require 'timeout'
 
 namespace :thinking_sphinx do
   task :app_env do
     if defined?(RAILS_ROOT)
       Rake::Task[:environment].invoke
-      Rails.configuration.cache_classes = false
+      
+      if defined?(Rails.configuration)
+        Rails.configuration.cache_classes = false
+      else
+        Rails::Initializer.run { |config| config.cache_classes = false }
+      end
     end
     
     Rake::Task[:merb_env].invoke    if defined?(Merb)
@@ -29,10 +35,8 @@ namespace :thinking_sphinx do
     raise RuntimeError, "searchd is already running." if sphinx_running?
     
     Dir["#{config.searchd_file_path}/*.spl"].each { |file| File.delete(file) }
-
-    system! "#{config.bin_path}#{config.searchd_binary_name} --pidfile --config \"#{config.config_file}\""
     
-    sleep(2)
+    config.controller.start
     
     if sphinx_running?
       puts "Started successfully (pid #{sphinx_pid})."
@@ -48,7 +52,13 @@ namespace :thinking_sphinx do
     else
       config = ThinkingSphinx::Configuration.instance
       pid    = sphinx_pid
-      system! "#{config.bin_path}#{config.searchd_binary_name} --stop --config \"#{config.config_file}\""
+      config.controller.stop
+      
+      # Ensure searchd is stopped, but don't try too hard
+      Timeout.timeout(5) do
+        sleep(1) until config.controller.stop
+      end
+      
       puts "Stopped search daemon (pid #{pid})."
     end
   end
@@ -65,19 +75,21 @@ namespace :thinking_sphinx do
   
   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}#{config.indexer_binary_name} --config \"#{config.config_file}\" --all"
-    cmd << " --rotate" if sphinx_running?
     
-    system! cmd
+    FileUtils.mkdir_p config.searchd_file_path
+    config.controller.index :verbose => true
+  end
+  
+  desc "Reindex Sphinx without regenerating the configuration file"
+  task :reindex => :app_env do
+    config = ThinkingSphinx::Configuration.instance
+    FileUtils.mkdir_p config.searchd_file_path
+    puts config.controller.index
   end
   
   desc "Stop Sphinx (if it's running), rebuild the indexes, and start Sphinx"
@@ -86,30 +98,6 @@ namespace :thinking_sphinx do
     Rake::Task["thinking_sphinx:index"].invoke
     Rake::Task["thinking_sphinx:start"].invoke
   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
@@ -123,11 +111,9 @@ namespace :ts do
   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 "Reindex Sphinx without regenerating the configuration file"
+  task :reindex => "thinking_sphinx:reindex"
   desc "Restart Sphinx"
   task :restart => "thinking_sphinx:restart"
   desc "Generate the Sphinx configuration file using Thinking Sphinx's settings"
@@ -136,8 +122,6 @@ namespace :ts do
   task :config  => "thinking_sphinx:configure"
   desc "Stop Sphinx (if it's running), rebuild the indexes, and start Sphinx"
   task :rebuild => "thinking_sphinx:rebuild"
-  desc "Process stored delta index requests"
-  task :dd      => "thinking_sphinx:delayed_delta"
 end
 
 def sphinx_pid
@@ -147,19 +131,3 @@ end
 def sphinx_running?
   ThinkingSphinx.sphinx_running?
 end
-
-# a fail-fast, hopefully helpful version of system
-def system!(cmd)
-  unless system(cmd)
-    raise <<-SYSTEM_CALL_FAILED
-The following command failed:
-  #{cmd}
-
-This could be caused by a PATH issue in the environment of cron/passenger/etc. Your current PATH:
-  #{ENV['PATH']}
-You can set the path to your indexer and searchd binaries using the bin_path property in config/sphinx.yml:
-  production:
-    bin_path: '/usr/local/bin'
-SYSTEM_CALL_FAILED
-  end
-end

data/lib/thinking_sphinx/test.rb

@@ -0,0 +1,55 @@
+class ThinkingSphinx::Test
+  def self.init(suppress_delta_output = true)
+    set_flags suppress_delta_output
+    create_indexes_folder
+  end
+  
+  def self.start
+    config.build
+    config.controller.index
+    config.controller.start
+  end
+  
+  def self.start_with_autostop
+    autostop
+    start
+  end
+  
+  def self.stop
+    config.controller.stop
+    sleep(0.5) # Ensure Sphinx has shut down completely
+  end
+  
+  def self.autostop
+    Kernel.at_exit do
+      ThinkingSphinx::Test.stop
+    end
+  end
+  
+  def self.run(&block)
+    begin
+      start
+      yield
+    ensure
+      stop
+    end
+  end
+  
+  def self.config
+    @config ||= ::ThinkingSphinx::Configuration.instance
+  end
+  
+  def self.index(*indexes)
+    config.controller.index *indexes
+  end
+  
+  def self.set_flags(suppress_delta_output)
+    ::ThinkingSphinx.deltas_enabled        = true
+    ::ThinkingSphinx.updates_enabled       = true
+    ::ThinkingSphinx.suppress_delta_output = suppress_delta_output
+  end
+  
+  def self.create_indexes_folder
+    FileUtils.mkdir_p config.searchd_file_path
+  end
+end

data/lib/thinking_sphinx.rb

@@ -1,26 +1,25 @@
-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 'yaml'
-require 'cgi'
+require 'riddle'
 
+require 'thinking_sphinx/auto_version'
 require 'thinking_sphinx/core/array'
 require 'thinking_sphinx/core/string'
 require 'thinking_sphinx/property'
 require 'thinking_sphinx/active_record'
 require 'thinking_sphinx/association'
 require 'thinking_sphinx/attribute'
+require 'thinking_sphinx/bundled_search'
 require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/context'
 require 'thinking_sphinx/excerpter'
 require 'thinking_sphinx/facet'
 require 'thinking_sphinx/class_facet'
 require 'thinking_sphinx/facet_search'
 require 'thinking_sphinx/field'
 require 'thinking_sphinx/index'
+require 'thinking_sphinx/join'
 require 'thinking_sphinx/source'
 require 'thinking_sphinx/rails_additions'
 require 'thinking_sphinx/search'
@@ -38,6 +37,8 @@ Merb::Plugins.add_rakefiles(
 ) if defined?(Merb)
 
 module ThinkingSphinx
+  mattr_accessor :database_adapter
+  
   # A ConnectionError will get thrown when a connection to Sphinx can't be
   # made.
   class ConnectionError < StandardError
@@ -57,26 +58,48 @@ module ThinkingSphinx
   # @return [String] The version number as a string
   # 
   def self.version
-    hash = YAML.load_file File.join(File.dirname(__FILE__), '../VERSION.yml')
-    [hash[:major], hash[:minor], hash[:patch]].join('.')
+    open(File.join(File.dirname(__FILE__), '../VERSION')) { |f|
+      f.read.strip
+    }
   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 ||= []
+  @@sphinx_mutex = Mutex.new
+  @@context      = nil
+  
+  def self.context
+    if @@context.nil?
+      @@sphinx_mutex.synchronize do
+        if @@context.nil?
+          @@context = ThinkingSphinx::Context.new
+          @@context.prepare
+        end
+      end
+    end
+    
+    @@context
+  end
+  
+  def self.reset_context!
+    @@sphinx_mutex.synchronize do
+      @@context = nil
+    end
   end
 
   def self.unique_id_expression(offset = nil)
-    "* #{ThinkingSphinx.indexed_models.size} + #{offset || 0}"
+    "* #{context.indexed_models.size} + #{offset || 0}"
   end
 
   # Check if index definition is disabled.
   #
   def self.define_indexes?
-    @@define_indexes =  true unless defined?(@@define_indexes)
-    @@define_indexes == true
+    if Thread.current[:thinking_sphinx_define_indexes].nil?
+      Thread.current[:thinking_sphinx_define_indexes] = true
+    end
+    
+    Thread.current[:thinking_sphinx_define_indexes]
   end
 
   # Enable/disable indexes - you may want to do this while migrating data.
@@ -84,16 +107,19 @@ module ThinkingSphinx
   #   ThinkingSphinx.define_indexes = false
   #
   def self.define_indexes=(value)
-    @@define_indexes = value
+    Thread.current[:thinking_sphinx_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
+    if Thread.current[:thinking_sphinx_deltas_enabled].nil?
+      Thread.current[:thinking_sphinx_deltas_enabled] = (
+        ThinkingSphinx::Configuration.environment != "test"
+      )
+    end
+    
+    Thread.current[:thinking_sphinx_deltas_enabled]
   end
 
   # Enable/disable all delta indexing.
@@ -101,17 +127,20 @@ module ThinkingSphinx
   #   ThinkingSphinx.deltas_enabled = false
   #
   def self.deltas_enabled=(value)
-    @@deltas_enabled = value
+    Thread.current[:thinking_sphinx_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
+    if Thread.current[:thinking_sphinx_updates_enabled].nil?
+      Thread.current[:thinking_sphinx_updates_enabled] = (
+        ThinkingSphinx::Configuration.environment != "test"
+      )
+    end
+    
+    Thread.current[:thinking_sphinx_updates_enabled]
   end
 
   # Enable/disable updates to Sphinx
@@ -119,38 +148,37 @@ module ThinkingSphinx
   #   ThinkingSphinx.updates_enabled = false
   #
   def self.updates_enabled=(value)
-    @@updates_enabled = value
+    Thread.current[:thinking_sphinx_updates_enabled] = value
   end
 
-  @@suppress_delta_output = false
-
   def self.suppress_delta_output?
-    @@suppress_delta_output
+    Thread.current[:thinking_sphinx_suppress_delta_output] ||= false
   end
 
   def self.suppress_delta_output=(value)
-    @@suppress_delta_output = value
+    Thread.current[:thinking_sphinx_suppress_delta_output] = value
   end
   
-  @@use_group_by_shortcut = nil
   # 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?
-    @@use_group_by_shortcut ||= !!(
-      mysql? && ::ActiveRecord::Base.connection.select_all(
-        "SELECT @@global.sql_mode, @@session.sql_mode;"
-      ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
-    )
+    if Thread.current[:thinking_sphinx_use_group_by_shortcut].nil?
+      Thread.current[:thinking_sphinx_use_group_by_shortcut] = !!(
+        mysql? && ::ActiveRecord::Base.connection.select_all(
+          "SELECT @@global.sql_mode, @@session.sql_mode;"
+        ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
+      )
+    end
+    
+    Thread.current[:thinking_sphinx_use_group_by_shortcut]
   end
 
-  @@remote_sphinx = false
-
   # An indication of whether Sphinx is running on a remote machine instead of
   # the same machine.
   #
   def self.remote_sphinx?
-    @@remote_sphinx
+    Thread.current[:thinking_sphinx_remote_sphinx] ||= false
   end
 
   # Tells Thinking Sphinx that Sphinx is running on a different machine, and
@@ -162,7 +190,7 @@ module ThinkingSphinx
   #   ThinkingSphinx.remote_sphinx = true
   #
   def self.remote_sphinx=(value)
-    @@remote_sphinx = value
+    Thread.current[:thinking_sphinx_remote_sphinx] = value
   end
 
   # Check if Sphinx is running. If remote_sphinx is set to true (indicating
@@ -190,6 +218,8 @@ module ThinkingSphinx
 
   def self.pid_active?(pid)
     !!Process.kill(0, pid.to_i)
+  rescue Errno::EPERM => e
+    true
   rescue Exception => e
     false
   end
@@ -211,3 +241,5 @@ module ThinkingSphinx
   
   extend ThinkingSphinx::SearchMethods::ClassMethods
 end
+
+ThinkingSphinx::AutoVersion.detect

data/rails/init.rb

@@ -1,3 +1,7 @@
+Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
+  $LOAD_PATH.unshift path
+end
+
 require 'thinking_sphinx'
 require 'action_controller/dispatcher'
 
@@ -9,6 +13,4 @@ ActionController::Dispatcher.to_prepare :thinking_sphinx do
   elsif Rails::VERSION::STRING.to_f > 2.1
     I18n.backend.load_translations(*I18n.load_path)
   end
-  
-  ThinkingSphinx::Configuration.instance.load_models
 end

data/spec/{lib/thinking_sphinx → thinking_sphinx}/active_record/delta_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe "ThinkingSphinx::ActiveRecord::Delta" do
   it "should call the toggle_delta method after a save" do
@@ -73,14 +73,12 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       Person.delta_object.stub!(:` => "", :toggled => true)
       
       @person = Person.new
-      @person.stub!(
-        :in_both_indexes?     => false,
-        :sphinx_document_id => 1
-      )
+      Person.stub!(:search_for_id => false)
+      @person.stub!(:sphinx_document_id => 1)
       
       @client = Riddle::Client.new
       @client.stub!(:update => true)
-      Riddle::Client.stub!(:new => @client)
+      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
     end
     
     it "shouldn't index if delta indexing is disabled" do
@@ -108,7 +106,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
     
     it "should call indexer for the delta index" do
       Person.sphinx_indexes.first.delta_object.should_receive(:`).with(
-        "#{ThinkingSphinx::Configuration.instance.bin_path}indexer --config #{ThinkingSphinx::Configuration.instance.config_file} --rotate person_delta"
+        "#{ThinkingSphinx::Configuration.instance.bin_path}indexer --config \"#{ThinkingSphinx::Configuration.instance.config_file}\" --rotate person_delta"
       )
       
       @person.send(:index_delta)
@@ -121,7 +119,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
     end
     
     it "should update the deleted attribute if in the core index" do
-      @person.stub!(:in_both_indexes? => true)
+      Person.stub!(:search_for_id => true)
       @client.should_receive(:update)
       
       @person.send(:index_delta)

data/spec/{lib/thinking_sphinx → thinking_sphinx}/active_record/has_many_association_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
   describe "search method" do
@@ -21,7 +21,13 @@ describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
       end
       
       @person.friendships.search "test"
-    end    
+    end
+    
+    it "should define indexes for the reflection class" do
+      Friendship.should_receive(:define_indexes)
+      
+      @person.friendships.search 'test'
+    end
   end
   
   describe "search method for has_many :through" do
@@ -46,4 +52,21 @@ describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
       @person.friends.search "test"
     end
   end
-end
+  
+  describe 'filtering sphinx scopes' do
+    before :each do
+      Friendship.stub!(:search => Friendship)
+      
+      @person = Person.find(:first)
+    end
+    
+    it "should add a filter for the attribute in a sphinx scope call" do
+      Friendship.should_receive(:search).with do |options|
+        options[:with][:person_id].should == @person.id
+        Friendship
+      end
+      
+      @person.friendships.reverse
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/scopes_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Scopes do
+  after :each do
+    Alpha.remove_sphinx_scopes
+  end
+  
+  it "should be included into models with indexes" do
+    Alpha.included_modules.should include(ThinkingSphinx::ActiveRecord::Scopes)
+  end
+  
+  it "should not be included into models without indexes" do
+    Gamma.included_modules.should_not include(
+      ThinkingSphinx::ActiveRecord::Scopes
+    )
+  end
+  
+  describe '.sphinx_scope' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+    end
+    
+    it "should define a method on the model" do
+      Alpha.should respond_to(:by_name)
+    end
+  end
+  
+  describe '.sphinx_scopes' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+    end
+    
+    it "should return an array of defined scope names as symbols" do
+      Alpha.sphinx_scopes.should == [:by_name]
+    end
+  end
+
+  describe '.default_sphinx_scope' do
+    before :each do
+      Alpha.sphinx_scope(:scope_used_as_default_scope) { {:conditions => {:name => 'name'}} }
+      Alpha.default_sphinx_scope :scope_used_as_default_scope
+    end
+    
+    it "should return an array of defined scope names as symbols" do
+      Alpha.sphinx_scopes.should == [:scope_used_as_default_scope]
+    end
+    
+    it "should have a default_sphinx_scope" do
+      Alpha.has_default_sphinx_scope?.should be_true
+    end
+  end
+
+  describe '.remove_sphinx_scopes' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.remove_sphinx_scopes
+    end
+    
+    it "should remove sphinx scope methods" do
+      Alpha.should_not respond_to(:by_name)
+    end
+    
+    it "should empty the list of sphinx scopes" do
+      Alpha.sphinx_scopes.should be_empty
+    end
+  end
+
+  describe '.example_default_scope' do
+    before :each do
+      Alpha.sphinx_scope(:foo_scope){ {:conditions => {:name => 'foo'}} }
+      Alpha.default_sphinx_scope :foo_scope
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.sphinx_scope(:by_foo)  { |foo|  {:conditions => {:foo  => foo}}  }
+    end
+
+    it "should return a ThinkingSphinx::Search object" do
+      Alpha.search.should be_a(ThinkingSphinx::Search)
+    end
+
+    it "should apply the default scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.search.options[:conditions].should == {:name => 'foo'}
+    end
+
+    it "should apply the default scope options and scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_foo('foo').search.options[:conditions].should == {:foo => 'foo', :name => 'foo'}
+    end
+
+    it "should apply the default scope options before other scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('bar').search.options[:conditions].should == {:name => 'bar'}
+    end
+  end
+
+  describe '.example_scope' do
+    before :each do
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.sphinx_scope(:by_foo)  { |foo|  {:conditions => {:foo  => foo}}  }
+      Alpha.sphinx_scope(:with_betas) { {:classes => [Beta]} }
+    end
+    
+    it "should return a ThinkingSphinx::Search object" do
+      Alpha.by_name('foo').should be_a(ThinkingSphinx::Search)
+    end
+    
+    it "should set the classes option" do
+      Alpha.by_name('foo').options[:classes].should == [Alpha]
+    end
+    
+    it "should be able to be called on a ThinkingSphinx::Search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      lambda {
+        search.by_name('foo')
+      }.should_not raise_error
+    end
+    
+    it "should return the search object it gets called upon" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('foo').should == search
+    end
+    
+    it "should apply the scope options to the underlying search object" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('foo').options[:conditions].should == {:name => 'foo'}
+    end
+    
+    it "should combine hash option scopes such as :conditions" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.by_name('foo').by_foo('bar').options[:conditions].
+        should == {:name => 'foo', :foo => 'bar'}
+    end
+    
+    it "should combine array option scopes such as :classes" do
+      search = ThinkingSphinx::Search.new(:classes => [Alpha])
+      search.with_betas.options[:classes].should == [Alpha, Beta]
+    end
+  end
+  
+  describe '.search_count_with_scope' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @client = Riddle::Client.new
+
+      @config.stub!(:client => @client)
+      @client.stub!(:query => {:matches => [], :total_found => 43})
+      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
+      Alpha.sphinx_scope(:ids_only) { {:ids_only => true} }
+    end
+    
+    it "should return the total number of results" do
+      Alpha.by_name('foo').search_count.should == 43
+    end
+    
+    it "should not make any calls to the database" do
+      Alpha.should_not_receive(:find)
+      
+      Alpha.by_name('foo').search_count
+    end
+    
+    it "should not leave the :ids_only option set and the results populated if it was not set before" do
+      stored_scope = Alpha.by_name('foo')
+      stored_scope.search_count
+      stored_scope.options[:ids_only].should be_false
+      stored_scope.populated?.should be_false
+    end
+    
+    it "should leave the :ids_only option set and the results populated if it was set before" do
+      stored_scope = Alpha.by_name('foo').ids_only
+      stored_scope.search_count
+      stored_scope.options[:ids_only].should be_true
+      stored_scope.populated?.should be_true
+    end
+  end
+  
+end