freelancing-god-thinking-sphinx 0.9.10 → 0.9.11

data/README

@@ -16,15 +16,32 @@ To get the spec suite running, you will need to install the not-a-mock gem if yo
   cd not-a-mock
   rake gem
   gem install pkg/not_a_mock-1.1.0.gem
+  
+Then install the ginger gem. The steps are the same, except that you might need to sudo the gem install:
 
-Then set up your database
+  git clone git://github.com/freelancing-god/ginger.git
+  cd ginger
+  rake gem
+  sudo gem install pkg/ginger-1.1.0.gem
+
+Then set up your database:
 
   cp spec/fixtures/database.yml.default spec/fixtures/database.yml
   mysqladmin -u root create thinking_sphinx
+  
+Make sure you don't have another Sphinx daemon (searchd) running. If you do, quit it with "rake ts:stop"
+in the app root.
 
 You should now have a passing test suite from which to build your patch on.
 
   rake spec
+  
+If you get the message "Failed to start searchd daemon", run the spec with sudo:
+
+  sudo rake spec
+  
+If you quit the spec suite before it's completed, you may be left with data in the test
+database, causing the next run to have failures. Let that run complete and then try again.
 
 == Contributors
 
@@ -74,3 +91,4 @@ Since I first released this library, there's been quite a few people who have su
 - Mike Flester
 - Jim Remsik
 - Kennon Ballou
+- Henrik Nyh

data/lib/thinking_sphinx.rb

@@ -30,7 +30,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 0
     Minor = 9
-    Tiny  = 10
+    Tiny  = 11
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -109,4 +109,15 @@ module ThinkingSphinx
       "SELECT @@global.sql_mode, @@session.sql_mode;"
     ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
   end
+  
+  def self.sphinx_running?
+    pid_file = ThinkingSphinx::Configuration.instance.pid_file
+    
+    if File.exists?(pid_file)
+      pid = `cat #{pid_file}`[/\d+/]
+      `ps -p #{pid} | wc -l`.to_i > 1
+    else
+      false
+    end
+  end
 end

data/lib/thinking_sphinx/active_record.rb

@@ -103,6 +103,18 @@ module ThinkingSphinx
           def to_crc32s
             (subclasses << self).collect { |klass| klass.to_crc32 }
           end
+          
+          def source_of_sphinx_index
+            possible_models = self.sphinx_indexes.collect { |index| index.model }
+            return self if possible_models.include?(self)
+
+            parent = self.superclass
+            while !possible_models.include?(parent) && parent != ::ActiveRecord::Base
+              parent = parent.superclass
+            end
+
+            return parent
+          end
         end
       end
       
@@ -120,12 +132,12 @@ module ThinkingSphinx
     def in_core_index?
       self.class.search_for_id(
         self.sphinx_document_id,
-        "#{self.class.name.underscore.tr(':/\\', '_')}_core"
+        "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
       )
     end
     
     def toggle_deleted
-      return unless ThinkingSphinx.updates_enabled?
+      return unless ThinkingSphinx.updates_enabled? && ThinkingSphinx.sphinx_running?
       
       config = ThinkingSphinx::Configuration.instance
       client = Riddle::Client.new config.address, config.port
@@ -147,7 +159,7 @@ module ThinkingSphinx
     
     def sphinx_document_id
       (self.id * ThinkingSphinx.indexed_models.size) +
-        ThinkingSphinx.indexed_models.index(self.class.name)
+        ThinkingSphinx.indexed_models.index(self.class.source_of_sphinx_index.name)
     end
   end
 end

data/lib/thinking_sphinx/index/builder.rb

@@ -133,7 +133,7 @@ module ThinkingSphinx
         # when you would like to index a calculated value. Don't forget to set
         # the type of the attribute though:
         #
-        #   indexes "age < 18", :as => :minor, :type => :boolean
+        #   has "age < 18", :as => :minor, :type => :boolean
         # 
         # If you're creating attributes for latitude and longitude, don't
         # forget that Sphinx expects these values to be in radians.

data/lib/thinking_sphinx/search.rb

@@ -44,7 +44,7 @@ module ThinkingSphinx
       # 
       #   User.search "pat", :include => :posts
       #
-      # == Advanced Searching
+      # == Match Modes
       #
       # Sphinx supports 5 different matching modes. By default Thinking Sphinx
       # uses :all, which unsurprisingly requires all the supplied search terms
@@ -62,6 +62,20 @@ module ThinkingSphinx
       # for more complex query syntax, refer to the sphinx documentation for further
       # details.
       #
+      # == Weighting
+      #
+      # Sphinx has support for weighting, where matches in one field can be considered
+      # more important than in another. Weights are integers, with 1 as the default.
+      # They can be set per-search like this:
+      #
+      #   User.search "pat allan", :field_weights => { :alias => 4, :aka => 2 }
+      #
+      # If you're searching multiple models, you can set per-index weights:
+      #
+      #   ThinkingSphinx::Search.search "pat", :index_weights => { User => 10 }
+      #
+      # See http://sphinxsearch.com/doc.html#weighting for further details.
+      #
       # == Searching by Fields
       # 
       # If you want to step it up a level, you can limit your search terms to
@@ -275,6 +289,16 @@ module ThinkingSphinx
         klass  = options[:class]
         index_options = klass ? klass.sphinx_indexes.last.options : {}
         
+        # Turn :index_weights => { "foo" => 2, User => 1 }
+        # into :index_weights => { "foo" => 2, "user_core" => 1 }
+        if iw = options[:index_weights]
+          options[:index_weights] = iw.inject({}) do |hash, (index,weight)|
+            key = index.is_a?(Class) ? "#{ThinkingSphinx::Index.name(index)}_core" : index
+            hash[key] = weight
+            hash
+          end
+        end
+        
         [
           :max_matches, :match_mode, :sort_mode, :sort_by, :id_range,
           :group_by, :group_function, :group_clause, :group_distinct, :cut_off,

data/spec/unit/thinking_sphinx/active_record_spec.rb

@@ -121,6 +121,8 @@ describe "ThinkingSphinx::ActiveRecord" do
   
   describe "toggle_deleted method" do
     before :each do
+      ThinkingSphinx.stub_method(:sphinx_running? => true)
+      
       @configuration = ThinkingSphinx::Configuration.instance
       @configuration.stub_methods(
         :address  => "an address",
@@ -160,6 +162,15 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
     end
     
+    it "shouldn't attempt to update the deleted flag if sphinx isn't running" do
+      ThinkingSphinx.stub_method(:sphinx_running? => false)
+      
+      @person.toggle_deleted
+      
+      @person.should_not have_received(:in_core_index?)
+      @client.should_not have_received(:update)
+    end
+    
     it "should update the delta index's deleted flag if delta indexes are enabled and the instance's delta is true" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
@@ -270,6 +281,16 @@ describe "ThinkingSphinx::ActiveRecord" do
     Beta.search("three").should be_empty
   end
   
+  it "should remove subclass instances from the core index if they're in it" do
+    Cat.search("moggy").should_not be_empty
+    
+    cat = Cat.find(:first, :conditions => {:name => "moggy"})
+    cat.destroy
+    sleep(1)
+    
+    Cat.search("moggy").should be_empty
+  end
+  
   it "should remove destroyed new instances from the delta index if they're in it" do
     beta = Beta.create!(:name => "eleven")
     sleep(1) # wait for Sphinx to catch up

data/spec/unit/thinking_sphinx/configuration_spec.rb

@@ -508,5 +508,5 @@ describe ThinkingSphinx::Configuration do
       
       config.source_options[option.to_sym] = nil
     end
-  end
+  end  
 end

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -81,7 +81,7 @@ describe ThinkingSphinx::Index do
       conf = @index.to_config(Person, 0, @database, 0)
       conf.should_not match(/sql_port/)
     end
-    
+        
     it "should have a pre query 'SET NAMES utf8' if using mysql and utf8 charset" do
       @index.options[:charset_type] = "utf-8"
       @index.to_config(Person, 0, @database, 0).should match(

data/spec/unit/thinking_sphinx_spec.rb

@@ -126,4 +126,19 @@ describe ThinkingSphinx do
       end
     end
   end
+  
+  it "should detect if sphinx is running" do
+    ThinkingSphinx.sphinx_running?.should be_false
+    
+    @sphinx.setup_sphinx
+    @sphinx.start
+    sleep(1)
+    
+    ThinkingSphinx.sphinx_running?.should be_true
+    
+    @sphinx.stop
+    sleep(1)
+    
+    ThinkingSphinx.sphinx_running?.should be_false
+  end
 end

data/tasks/thinking_sphinx_tasks.rb

@@ -82,6 +82,8 @@ namespace :ts do
   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"
 end
 

data/vendor/after_commit/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Nick Muerdter
+
+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/vendor/after_commit/README

@@ -0,0 +1,16 @@
+after_commit
+===========
+
+A Ruby on Rails plugin to add after_commit callbacks. The callbacks that are provided can be used
+to trigger events that run only after the entire transaction is complete. This is beneficial
+in situations where you are doing asynchronous processing and need committed objects.
+
+The following callbacks are provided:
+  
+   * (1) after_commit
+   * (2) after_commit_on_create
+   * (3) after_commit_on_update
+   * (4) after_commit_on_destroy
+   
+The after_commit callback is run for any object that has just been committed. You can obtain finer
+callback control by using the additional <tt>after_commit_on_*</tt> callbacks.

data/vendor/after_commit/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the after_commit plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the after_commit plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AfterCommit'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/after_commit/init.rb

@@ -0,0 +1,5 @@
+ActiveRecord::Base.send(:include, AfterCommit::ActiveRecord)
+
+Object.subclasses_of(ActiveRecord::ConnectionAdapters::AbstractAdapter).each do |klass|
+  klass.send(:include, AfterCommit::ConnectionAdapters)
+end

data/vendor/after_commit/lib/after_commit.rb

@@ -0,0 +1,42 @@
+require 'after_commit/active_record'
+require 'after_commit/connection_adapters'
+
+module AfterCommit
+  def self.committed_records
+    @@committed_records ||= []
+  end
+
+  def self.committed_records=(committed_records)
+    @@committed_records = committed_records
+  end
+  
+  def self.committed_records_on_create
+    @@committed_records_on_create ||= []
+  end
+  
+  def self.committed_records_on_create=(committed_records)
+    @@committed_records_on_create = committed_records
+  end
+  
+  def self.committed_records_on_update
+    @@committed_records_on_update ||= []
+  end
+  
+  def self.committed_records_on_update=(committed_records)
+    @@committed_records_on_update = committed_records
+  end
+  
+  def self.committed_records_on_destroy
+    @@committed_records_on_destroy ||= []
+  end
+  
+  def self.committed_records_on_destroy=(committed_records)
+    @@committed_records_on_destroy = committed_records
+  end
+end
+
+ActiveRecord::Base.send(:include, AfterCommit::ActiveRecord)
+
+Object.subclasses_of(ActiveRecord::ConnectionAdapters::AbstractAdapter).each do |klass|
+  klass.send(:include, AfterCommit::ConnectionAdapters)
+end

data/vendor/after_commit/lib/after_commit/active_record.rb

@@ -0,0 +1,91 @@
+module AfterCommit
+  module ActiveRecord
+    # Based on the code found in Thinking Sphinx:
+    # http://ts.freelancing-gods.com/ which was based on code written by Eli
+    # Miller:
+    # http://elimiller.blogspot.com/2007/06/proper-cache-expiry-with-aftercommit.html
+    # with slight modification from Joost Hietbrink. And now me! Whew.
+    def self.included(base)
+      base.class_eval do
+        # The define_callbacks method was added post Rails 2.0.2 - if it
+        # doesn't exist, we define the callback manually
+        if respond_to?(:define_callbacks)
+          define_callbacks  :after_commit,
+                            :after_commit_on_create,
+                            :after_commit_on_update,
+                            :after_commit_on_destroy
+        else
+          class << self
+            # Handle after_commit callbacks - call all the registered callbacks.
+            def after_commit(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit, callbacks)
+            end
+            
+            def after_commit_on_create(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_create, callbacks)
+            end
+            
+            def after_commit_on_update(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_update, callbacks)
+            end
+            
+            def after_commit_on_destroy(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_destroy, callbacks)
+            end
+          end
+        end
+
+        after_save    :add_committed_record
+        after_create  :add_committed_record_on_create
+        after_update  :add_committed_record_on_update
+        after_destroy :add_committed_record_on_destroy
+
+        # We need to keep track of records that have been saved or destroyed
+        # within this transaction.
+        def add_committed_record
+          AfterCommit.committed_records << self
+        end
+        
+        def add_committed_record_on_create
+          AfterCommit.committed_records_on_create << self
+        end
+        
+        def add_committed_record_on_update
+          AfterCommit.committed_records_on_update << self
+        end
+        
+        def add_committed_record_on_destroy
+          AfterCommit.committed_records << self
+          AfterCommit.committed_records_on_destroy << self
+        end
+        
+        def after_commit
+          # Deliberately blank.
+        end
+
+        # Wraps a call to the private callback method so that the the
+        # after_commit callback can be made from the ConnectionAdapters when
+        # the commit for the transaction has finally succeeded. 
+        def after_commit_callback
+          callback(:after_commit)
+        end
+        
+        def after_commit_on_create_callback
+          callback(:after_commit_on_create)
+        end
+        
+        def after_commit_on_update_callback
+          callback(:after_commit_on_update)
+        end
+        
+        def after_commit_on_destroy_callback
+          callback(:after_commit_on_destroy)
+        end
+      end
+    end
+  end
+end