sherpa99-thinking-sphinx 1.1.4

data/features/support/db/migrations/create_posts.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Base.connection.create_table :posts, :force => true do |t|
+  t.column :subject, :string,  :null => false
+  t.column :content, :text
+end
+
+Post.create :subject => "Hello World", :content => "Um Text"

data/features/support/db/migrations/create_thetas.rb

@@ -0,0 +1,16 @@
+ActiveRecord::Base.connection.create_table :thetas, :force => true do |t|
+  t.column :name,       :string,    :null => false
+  t.column :created_at, :datetime,  :null => false
+  t.column :updated_at, :datetime,  :null => false
+end
+
+Theta.create :name => "one"
+Theta.create :name => "two"
+Theta.create :name => "three"
+Theta.create :name => "four"
+Theta.create :name => "five"
+Theta.create :name => "six"
+Theta.create :name => "seven"
+Theta.create :name => "eight"
+Theta.create :name => "nine"
+Theta.create :name => "ten"

data/features/support/db/mysql.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require 'active_record/connection_adapters/mysql_adapter'
+
+Database = 'mysql'

data/features/support/db/postgresql.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+Database = 'postgresql'

data/features/support/env.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'cucumber'
+require 'spec'
+require 'fileutils'
+require 'ginger'
+require 'will_paginate'

data/features/support/models/alpha.rb

@@ -0,0 +1,9 @@
+class Alpha < ActiveRecord::Base
+  define_index do
+    indexes :name, :sortable => true
+    
+    has value, cost, created_at, created_on
+    
+    set_property :field_weights => {"name" => 10}
+  end
+end

data/features/support/models/animal.rb

@@ -0,0 +1,5 @@
+class Animal < ActiveRecord::Base
+  define_index do
+    indexes name, :sortable => true
+  end
+end

data/features/support/models/beta.rb

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

data/features/support/models/box.rb

@@ -0,0 +1,8 @@
+class Box < ActiveRecord::Base
+  define_index do
+    indexes width, :as => :width_field
+    
+    has width, length, depth
+    has [width, length, depth], :as => :dimensions
+  end
+end

data/features/support/models/cat.rb

@@ -0,0 +1,3 @@
+class Cat < Animal
+  #
+end

data/features/support/models/comment.rb

@@ -0,0 +1,3 @@
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end

data/features/support/models/delayed_beta.rb

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

data/features/support/models/developer.rb

@@ -0,0 +1,8 @@
+class Developer < ActiveRecord::Base
+  define_index do
+    indexes country,  :facet => true
+    indexes state,    :facet => true
+    has age,          :facet => true
+    facet city
+  end
+end

data/features/support/models/gamma.rb

@@ -0,0 +1,5 @@
+class Gamma < ActiveRecord::Base
+  define_index do
+    indexes :name, :sortable => true
+  end
+end

data/features/support/models/person.rb

@@ -0,0 +1,8 @@
+class Person < ActiveRecord::Base
+  define_index do
+    indexes first_name, last_name, :sortable => true
+    
+    has [first_name, middle_initial, last_name], :as => :name_sort
+    has birthday
+  end
+end

data/features/support/models/post.rb

@@ -0,0 +1,8 @@
+class Post < ActiveRecord::Base
+  has_many :comments
+  
+  define_index do
+    indexes subject
+    indexes content
+  end
+end

data/features/support/models/theta.rb

@@ -0,0 +1,7 @@
+class Theta < ActiveRecord::Base
+  define_index do
+    indexes :name, :sortable => true
+    
+    set_property :delta => :datetime, :threshold => 1.hour
+  end
+end

data/features/support/post_database.rb

@@ -0,0 +1,37 @@
+$:.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'lib/thinking_sphinx'
+
+%w( tmp/config tmp/log tmp/db/sphinx/development ).each do |path|
+  FileUtils.mkdir_p "#{Dir.pwd}/#{path}"
+end
+
+Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/tmp" unless defined?(RAILS_ROOT)
+
+at_exit do
+  ThinkingSphinx::Configuration.instance.controller.stop
+  sleep(1) # Ensure Sphinx has shut down completely
+  FileUtils.rm_r "#{Dir.pwd}/tmp"
+end
+
+# Add log file
+ActiveRecord::Base.logger = Logger.new open("tmp/active_record.log", "a")
+
+ThinkingSphinx.deltas_enabled = false
+
+# Load Models
+Dir["features/support/models/*.rb"].sort.each do |file|
+  require file.gsub(/\.rb$/, '')
+end
+
+# Set up database tables and records
+Dir["features/support/db/migrations/*.rb"].each do |file|
+  require file.gsub(/\.rb$/, '')
+end
+
+ThinkingSphinx.deltas_enabled = true
+ThinkingSphinx.suppress_delta_output = true
+
+ThinkingSphinx::Configuration.instance.build
+ThinkingSphinx::Configuration.instance.controller.index
+ThinkingSphinx::Configuration.instance.controller.start

data/features/support/z.rb

@@ -0,0 +1,19 @@
+# This file exists because Cucumber likes to auto-load all ruby files
+puts <<-MESSAGE
+Cucumber 0.1.13 defaults to loading all ruby files within the features folder,
+with something approaching reverse-alphabetical order, and preferring the
+features/support folder over everything else. This is annoying, because some
+files need to be loaded before others (and others perhaps not at all, given
+missing dependencies). Hence this place-holder imaginatively named 'z.rb', to
+force this message.
+
+A work-around is to use cucumber profiles. You will find the default profile in
+cucumber.yml should serve your needs fine, unless you add new step definitions.
+When you do that, you can regenerate the YAML file by running:
+rake cucumber_defaults
+
+And then run specific features as follows is slightly more verbose, but it
+works, whereas this doesn't.
+cucumber -p default features/something.feature
+MESSAGE
+exit 0

data/ginger_scenarios.rb

@@ -0,0 +1,24 @@
+require 'ginger'
+
+Ginger.configure do |config|
+  config.aliases["active_record"] = "activerecord"
+  config.aliases["active_support"] = "activesupport"
+  
+  ar_1_2_6 = Ginger::Scenario.new
+  ar_1_2_6[/^active_?support$/] = "1.4.4"
+  ar_1_2_6[/^active_?record$/] = "1.15.6"
+  
+  ar_2_0_4 = Ginger::Scenario.new
+  ar_2_0_4[/^active_?support$/] = "2.0.4"
+  ar_2_0_4[/^active_?record$/] = "2.0.4"
+  
+  ar_2_1_2 = Ginger::Scenario.new
+  ar_2_1_2[/^active_?support$/] = "2.1.2"
+  ar_2_1_2[/^active_?record$/] = "2.1.2"
+  
+  ar_2_2_0 = Ginger::Scenario.new
+  ar_2_2_0[/^active_?support$/] = "2.2.0"
+  ar_2_2_0[/^active_?record$/] = "2.2.0"
+  
+  config.scenarios << ar_1_2_6 << ar_2_0_4 << ar_2_1_2 << ar_2_2_0
+end

data/init.rb

@@ -0,0 +1,12 @@
+require 'thinking_sphinx'
+
+if Rails::VERSION::STRING.to_f < 2.1
+  ThinkingSphinx::Configuration.instance.load_models
+end
+
+if Rails::VERSION::STRING.to_f > 1.2
+  require 'action_controller/dispatcher'
+  ActionController::Dispatcher.to_prepare :thinking_sphinx do
+    ThinkingSphinx::Configuration.instance.load_models
+  end
+end

data/lib/thinking_sphinx.rb

@@ -0,0 +1,144 @@
+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/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  = 3
+    
+    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/lib/thinking_sphinx/active_record.rb

@@ -0,0 +1,245 @@
+require 'thinking_sphinx/active_record/delta'
+require 'thinking_sphinx/active_record/search'
+require 'thinking_sphinx/active_record/has_many_association'
+
+module ThinkingSphinx
+  # Core additions to ActiveRecord models - define_index for creating indexes
+  # for models. If you want to interrogate the index objects created for the
+  # model, you can use the class-level accessor :sphinx_indexes.
+  #
+  module ActiveRecord
+    def self.included(base)
+      base.class_eval do
+        class_inheritable_array :sphinx_indexes, :sphinx_facets
+        class << self
+          # Allows creation of indexes for Sphinx. If you don't do this, there
+          # isn't much point trying to search (or using this plugin at all,
+          # really).
+          #
+          # An example or two:
+          #
+          #   define_index
+          #     indexes :id, :as => :model_id
+          #     indexes name
+          #   end
+          #
+          # You can also grab fields from associations - multiple levels deep
+          # if necessary.
+          #
+          #   define_index do
+          #     indexes tags.name, :as => :tag
+          #     indexes articles.content
+          #     indexes orders.line_items.product.name, :as => :product
+          #   end
+          #
+          # And it will automatically concatenate multiple fields:
+          #
+          #   define_index do
+          #     indexes [author.first_name, author.last_name], :as => :author
+          #   end
+          #
+          # The #indexes method is for fields - if you want attributes, use
+          # #has instead. All the same rules apply - but keep in mind that
+          # attributes are for sorting, grouping and filtering, not searching.
+          #
+          #   define_index do
+          #     # fields ...
+          #     
+          #     has created_at, updated_at
+          #   end
+          #
+          # One last feature is the delta index. This requires the model to
+          # have a boolean field named 'delta', and is enabled as follows:
+          #
+          #   define_index do
+          #     # fields ...
+          #     # attributes ...
+          #     
+          #     set_property :delta => true
+          #   end
+          #
+          # Check out the more detailed documentation for each of these methods
+          # at ThinkingSphinx::Index::Builder.
+          # 
+          def define_index(&block)
+            return unless ThinkingSphinx.define_indexes?
+            
+            self.sphinx_indexes ||= []
+            index = Index.new(self, &block)
+            
+            self.sphinx_indexes << index
+            unless ThinkingSphinx.indexed_models.include?(self.name)
+              ThinkingSphinx.indexed_models << self.name
+            end
+            
+            if index.delta?
+              before_save   :toggle_delta
+              after_commit  :index_delta
+            end
+            
+            after_destroy :toggle_deleted
+            
+            index
+          end
+          alias_method :sphinx_index, :define_index
+          
+          def sphinx_index_options
+            sphinx_indexes.last.options
+          end
+          
+          # Generate a unique CRC value for the model's name, to use to
+          # determine which Sphinx documents belong to which AR records.
+          # 
+          # Really only written for internal use - but hey, if it's useful to
+          # you in some other way, awesome.
+          # 
+          def to_crc32
+            self.name.to_crc32
+          end
+          
+          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
+          
+          def to_riddle(offset)
+            sphinx_database_adapter.setup
+            
+            indexes = [to_riddle_for_core(offset)]
+            indexes << to_riddle_for_delta(offset) if sphinx_delta?
+            indexes << to_riddle_for_distributed
+          end
+          
+          def sphinx_database_adapter
+            @sphinx_database_adapter ||=
+              ThinkingSphinx::AbstractAdapter.detect(self)
+          end
+          
+          private
+          
+          def sphinx_name
+            self.name.underscore.tr(':/\\', '_')
+          end
+          
+          def sphinx_delta?
+            self.sphinx_indexes.any? { |index| index.delta? }
+          end
+          
+          def to_riddle_for_core(offset)
+            index = Riddle::Configuration::Index.new("#{sphinx_name}_core")
+            index.path = File.join(
+              ThinkingSphinx::Configuration.instance.searchd_file_path, index.name
+            )
+            
+            set_configuration_options_for_indexes index
+            set_field_settings_for_indexes        index
+            
+            self.sphinx_indexes.select { |ts_index|
+              ts_index.model == self
+            }.each_with_index do |ts_index, i|
+              index.sources << ts_index.to_riddle_for_core(offset, i)
+            end
+            
+            index
+          end
+          
+          def to_riddle_for_delta(offset)
+            index = Riddle::Configuration::Index.new("#{sphinx_name}_delta")
+            index.parent = "#{sphinx_name}_core"
+            index.path = File.join(ThinkingSphinx::Configuration.instance.searchd_file_path, index.name)
+            
+            self.sphinx_indexes.each_with_index do |ts_index, i|
+              index.sources << ts_index.to_riddle_for_delta(offset, i) if ts_index.delta?
+            end
+            
+            index
+          end
+          
+          def to_riddle_for_distributed
+            index = Riddle::Configuration::DistributedIndex.new(sphinx_name)
+            index.local_indexes << "#{sphinx_name}_core"
+            index.local_indexes.unshift "#{sphinx_name}_delta" if sphinx_delta?
+            index
+          end
+          
+          def set_configuration_options_for_indexes(index)
+            ThinkingSphinx::Configuration.instance.index_options.each do |key, value|
+              index.send("#{key}=".to_sym, value)
+            end
+            
+            self.sphinx_indexes.each do |ts_index|
+              ts_index.options.each do |key, value|
+                index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
+              end
+            end
+          end
+          
+          def set_field_settings_for_indexes(index)
+            field_names = lambda { |field| field.unique_name.to_s }
+            
+            self.sphinx_indexes.each do |ts_index|
+              index.prefix_field_names += ts_index.prefix_fields.collect(&field_names)
+              index.infix_field_names  += ts_index.infix_fields.collect(&field_names)
+            end
+          end
+        end
+      end
+      
+      base.send(:include, ThinkingSphinx::ActiveRecord::Delta)
+      base.send(:include, ThinkingSphinx::ActiveRecord::Search)
+      
+      ::ActiveRecord::Associations::HasManyAssociation.send(
+        :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
+      )
+      ::ActiveRecord::Associations::HasManyThroughAssociation.send(
+        :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
+      )
+    end
+    
+    def in_core_index?
+      self.class.search_for_id(
+        self.sphinx_document_id,
+        "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
+      )
+    end
+    
+    def toggle_deleted
+      return unless ThinkingSphinx.updates_enabled? && ThinkingSphinx.sphinx_running?
+      
+      config = ThinkingSphinx::Configuration.instance
+      client = Riddle::Client.new config.address, config.port
+      
+      client.update(
+        "#{self.class.sphinx_indexes.first.name}_core",
+        ['sphinx_deleted'],
+        {self.sphinx_document_id => 1}
+      ) if self.in_core_index?
+      
+      client.update(
+        "#{self.class.sphinx_indexes.first.name}_delta",
+        ['sphinx_deleted'],
+        {self.sphinx_document_id => 1}
+      ) if ThinkingSphinx.deltas_enabled? &&
+        self.class.sphinx_indexes.any? { |index| index.delta? } &&
+        self.delta
+    rescue ::ThinkingSphinx::ConnectionError
+      # nothing
+    end
+    
+    def sphinx_document_id
+      (self.id * ThinkingSphinx.indexed_models.size) +
+        ThinkingSphinx.indexed_models.index(self.class.source_of_sphinx_index.name)
+    end
+  end
+end