thinking-sphinx 2.1.0 → 3.0.0.pre

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler'
+require 'appraisal'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+namespace :spec do
+  desc 'Run unit specs only'
+  RSpec::Core::RakeTask.new(:unit) do |task|
+    task.pattern    = 'spec'
+    task.rspec_opts = '--tag "~live"'
+  end
+
+  desc 'Run acceptance specs only'
+  RSpec::Core::RakeTask.new(:acceptance) do |task|
+    task.pattern    = 'spec'
+    task.rspec_opts = '--tag "live"'
+  end
+end
+
+task :default => :spec

data/gemfiles/.gitignore

@@ -0,0 +1 @@
+*.gemfile.lock

data/gemfiles/rails_3_1.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source :rubygems
+
+gem "riddle", "1.5.3"
+gem "combustion", :git=>"git://github.com/pat/combustion.git", :ref=>"45f50e64c3"
+gem "pg", "~> 0.11.0", :platform=>:ruby
+gem "activerecord-jdbcpostgresql-adapter", "~> 1.1.3", :platform=>:jruby
+gem "rails", "~> 3.1.0"
+
+gemspec :path=>"../"

data/gemfiles/rails_3_2.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source :rubygems
+
+gem "riddle", "1.5.3"
+gem "combustion", :git=>"git://github.com/pat/combustion.git", :ref=>"45f50e64c3"
+gem "pg", "~> 0.11.0", :platform=>:ruby
+gem "activerecord-jdbcpostgresql-adapter", "~> 1.1.3", :platform=>:jruby
+gem "rails", "~> 3.2.0"
+
+gemspec :path=>"../"

data/lib/thinking-sphinx.rb

@@ -1 +1 @@
-require 'thinking_sphinx'
+require 'thinking_sphinx'

data/lib/thinking_sphinx.rb

@@ -1,304 +1,46 @@
-require 'thread'
-require 'active_record'
-require 'innertube'
-require 'yaml'
 require 'riddle'
-
-require 'thinking_sphinx/auto_version'
-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/connection'
-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/search'
-require 'thinking_sphinx/search_methods'
-require 'thinking_sphinx/deltas'
-
-require 'thinking_sphinx/adapters/abstract_adapter'
-require 'thinking_sphinx/adapters/mysql_adapter'
-require 'thinking_sphinx/adapters/postgresql_adapter'
-
-require 'thinking_sphinx/railtie' if defined?(Rails)
+require 'middleware'
+require 'active_record'
 
 module ThinkingSphinx
-  mattr_accessor :database_adapter
-
-  # 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
-
-  # A SphinxError occurs when Sphinx responds with an error due to problematic
-  # queries or indexes.
-  class SphinxError < RuntimeError
-    attr_accessor :results
-    def initialize(message = nil, results = nil)
-      super(message)
-      self.results = results
-    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.
-  @@sphinx_mutex          = Mutex.new
-  @@context               = nil
-  @@define_indexes        = true
-  @@deltas_enabled        = nil
-  @@updates_enabled       = nil
-  @@suppress_delta_output = false
-  @@remote_sphinx         = false
-  @@use_group_by_shortcut = nil
-
-  def self.mutex
-    @@sphinx_mutex
-  end
-
-  def self.context
-    if @@context.nil?
-      mutex.synchronize do
-        if @@context.nil?
-          @@context = ThinkingSphinx::Context.new
-          @@context.prepare
-        end
-      end
-    end
-
-    @@context
-  end
-
-  def self.reset_context!(context = nil)
-    mutex.synchronize do
-      @@context = context
-    end
-  end
-
-  def self.unique_id_expression(adapter, offset = nil)
-    "* #{adapter.cast_to_int context.indexed_models.size} + #{offset || 0}"
-  end
-
-  # Check if index definition is disabled.
-  #
-  def self.define_indexes?
-    @@define_indexes
-  end
-
-  # Enable/disable indexes - you may want to do this while migrating data.
-  #
-  #   ThinkingSphinx.define_indexes = false
-  #
-  def self.define_indexes=(value)
-    mutex.synchronize do
-      @@define_indexes = value
-    end
-  end
-
-  # Check if delta indexing is enabled/disabled.
-  #
-  def self.deltas_enabled?
-    if @@deltas_enabled.nil?
-      mutex.synchronize do
-        if @@deltas_enabled.nil?
-          @@deltas_enabled = (
-            ThinkingSphinx::Configuration.environment != "test"
-          )
-        end
-      end
-    end
-
-    @@deltas_enabled && !deltas_suspended?
-  end
-
-  # Enable/disable delta indexing.
-  #
-  #   ThinkingSphinx.deltas_enabled = false
-  #
-  def self.deltas_enabled=(value)
-    mutex.synchronize do
-      @@deltas_enabled = value
-    end
-  end
-
-  # Check if delta indexing is suspended.
-  #
-  def self.deltas_suspended?
-    if Thread.current[:thinking_sphinx_deltas_suspended].nil?
-      Thread.current[:thinking_sphinx_deltas_suspended] = false
-    end
-
-    Thread.current[:thinking_sphinx_deltas_suspended]
-  end
-
-  # Suspend/resume delta indexing.
-  #
-  #   ThinkingSphinx.deltas_suspended = false
-  #
-  def self.deltas_suspended=(value)
-    Thread.current[:thinking_sphinx_deltas_suspended] = value
-  end
-
-  # Check if updates are enabled. True by default, unless within the test
-  # environment.
-  #
-  def self.updates_enabled?
-    if @@updates_enabled.nil?
-      mutex.synchronize do
-        if @@updates_enabled.nil?
-          @@updates_enabled = (
-            ThinkingSphinx::Configuration.environment != "test"
-          )
-        end
-      end
-    end
-
-    @@updates_enabled
-  end
-
-  # Enable/disable updates to Sphinx
-  #
-  #   ThinkingSphinx.updates_enabled = false
-  #
-  def self.updates_enabled=(value)
-    mutex.synchronize do
-      @@updates_enabled = value
-    end
-  end
-
-  def self.suppress_delta_output?
-    @@suppress_delta_output
-  end
-
-  def self.suppress_delta_output=(value)
-    mutex.synchronize do
-      @@suppress_delta_output = value
-    end
-  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?
-    if @@use_group_by_shortcut.nil?
-      mutex.synchronize do
-        if @@use_group_by_shortcut.nil?
-          @@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
-      end
-    end
-
-    @@use_group_by_shortcut
-  end
-
-  def self.reset_use_group_by_shortcut
-    mutex.synchronize do
-      @@use_group_by_shortcut = nil
-    end
-  end
-
-  # An indication of whether Sphinx is running on a remote machine instead of
-  # the same machine.
-  #
-  def self.remote_sphinx?
-    @@remote_sphinx
-  end
-
-  # Tells Thinking Sphinx that Sphinx is running on a different machine, and
-  # thus it can't reliably guess whether it is running or not (ie: the
-  # #sphinx_running? method), and so just assumes it is.
-  #
-  # Useful for multi-machine deployments. Set it in your production.rb file.
-  #
-  #   ThinkingSphinx.remote_sphinx = true
-  #
-  def self.remote_sphinx=(value)
-    mutex.synchronize do
-      @@remote_sphinx = value
-    end
-  end
-
-  # Check if Sphinx is running. If remote_sphinx is set to true (indicating
-  # Sphinx is on a different machine), this will always return true, and you
-  # will have to handle any connection errors yourself.
-  #
-  def self.sphinx_running?
-    remote_sphinx? || sphinx_running_by_pid?
+  def self.count(query = '', options = {})
+    search(query, options).total_entries
   end
 
-  # Check if Sphinx is actually running, provided the pid is on the same
-  # machine as this code.
-  #
-  def self.sphinx_running_by_pid?
-    !!sphinx_pid && pid_active?(sphinx_pid)
+  def self.facets(query = '', options = {})
+    ThinkingSphinx::FacetSearch.new query, options
   end
 
-  def self.sphinx_pid
-    if File.exists?(ThinkingSphinx::Configuration.instance.pid_file)
-      File.read(ThinkingSphinx::Configuration.instance.pid_file)[/\d+/]
-    else
-      nil
-    end
+  def self.search(query = '', options = {})
+    ThinkingSphinx::Search.new query, options
   end
 
-  def self.pid_active?(pid)
-    !!Process.kill(0, pid.to_i)
-  rescue Errno::EPERM => e
-    true
-  rescue Exception => e
-    false
-  end
-
-  def self.microsoft?
-    RUBY_PLATFORM =~ /mswin/
-  end
-
-  def self.jruby?
-    defined?(JRUBY_VERSION)
-  end
-
-  def self.mysql?
-    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlAdapter" ||
-    ::ActiveRecord::Base.connection.class.name.demodulize == "Mysql2Adapter" ||
-    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlplusAdapter" || (
-      jruby? && ::ActiveRecord::Base.connection.config[:adapter] == "jdbcmysql"
-    )
-  end
-
-  def self.rails_3_1?
-    !!defined?(::ActiveRecord::Associations::CollectionProxy)
-  end
-
-  def self.before_index_hooks
-    @before_index_hooks
+  def self.search_for_ids(query = '', options = {})
+    search = ThinkingSphinx::Search.new query, options
+    ThinkingSphinx::Search::Merger.new(search).merge! nil, :ids_only => true
   end
+end
 
-  @before_index_hooks = []
+# Core
+require 'thinking_sphinx/batched_search'
+require 'thinking_sphinx/callbacks'
+require 'thinking_sphinx/core'
+require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/excerpter'
+require 'thinking_sphinx/facet'
+require 'thinking_sphinx/facet_search'
+require 'thinking_sphinx/index'
+require 'thinking_sphinx/index_set'
+require 'thinking_sphinx/masks'
+require 'thinking_sphinx/middlewares'
+require 'thinking_sphinx/panes'
+require 'thinking_sphinx/rake_interface'
+require 'thinking_sphinx/scopes'
+require 'thinking_sphinx/search'
+require 'thinking_sphinx/test'
+# Extended
+require 'thinking_sphinx/active_record'
+require 'thinking_sphinx/deltas'
+require 'thinking_sphinx/real_time'
 
-  extend ThinkingSphinx::SearchMethods::ClassMethods
-end
+require 'thinking_sphinx/railtie' if defined?(Rails)

data/lib/thinking_sphinx/active_record.rb

@@ -1,386 +1,25 @@
-require 'thinking_sphinx/active_record/attribute_updates'
-require 'thinking_sphinx/active_record/collection_proxy'
-require 'thinking_sphinx/active_record/collection_proxy_with_scopes'
-require 'thinking_sphinx/active_record/delta'
-require 'thinking_sphinx/active_record/has_many_association'
-require 'thinking_sphinx/active_record/log_subscriber'
-require 'thinking_sphinx/active_record/has_many_association_with_scopes'
-require 'thinking_sphinx/active_record/scopes'
-
-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
-        if defined?(class_attribute)
-          class_attribute :sphinx_indexes, :sphinx_facets
-        else
-          class_inheritable_array :sphinx_indexes, :sphinx_facets
-        end
-
-        extend ThinkingSphinx::ActiveRecord::ClassMethods
-
-        class << self
-          attr_accessor :sphinx_index_blocks, :sphinx_types
-
-          def set_sphinx_primary_key(attribute)
-            @sphinx_primary_key_attribute = attribute
-          end
-
-          def primary_key_for_sphinx
-            @primary_key_for_sphinx ||= begin
-              if custom_primary_key_for_sphinx?
-                @sphinx_primary_key_attribute ||
-                superclass.primary_key_for_sphinx
-              else
-                primary_key || 'id'
-              end
-            end
-          end
-
-          def custom_primary_key_for_sphinx?
-            (
-              superclass.respond_to?(:custom_primary_key_for_sphinx?) &&
-              superclass.custom_primary_key_for_sphinx?
-            ) || !@sphinx_primary_key_attribute.nil?
-          end
-
-          def clear_primary_key_for_sphinx
-            @primary_key_for_sphinx = nil
-          end
-
-          def sphinx_index_options
-            sphinx_indexes.last.options
-          end
-
-          def set_sphinx_types(types)
-            @sphinx_types = types
-          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
-            (descendants << self).collect { |klass| klass.to_crc32 }
-          end
-
-          def sphinx_database_adapter
-            ThinkingSphinx::AbstractAdapter.detect(self)
-          end
-
-          def sphinx_name
-            self.name.underscore.tr(':/\\', '_')
-          end
-
-          private
-
-          def defined_indexes?
-            @defined_indexes
-          end
-
-          def defined_indexes=(value)
-            @defined_indexes = value
-          end
-
-          def sphinx_delta?
-            self.sphinx_indexes.any? { |index| index.delta? }
-          end
-        end
-      end
-
-      if ThinkingSphinx.rails_3_1?
-        assoc_mixin = ThinkingSphinx::ActiveRecord::CollectionProxy
-        ::ActiveRecord::Associations::CollectionProxy.send(:include, assoc_mixin)
-      else
-        assoc_mixin = ThinkingSphinx::ActiveRecord::HasManyAssociation
-        ::ActiveRecord::Associations::HasManyAssociation.send(:include, assoc_mixin)
-        ::ActiveRecord::Associations::HasManyThroughAssociation.send(:include, assoc_mixin)
-      end
-    end
-
-    module ClassMethods
-      # 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(name = nil, &block)
-        self.sphinx_index_blocks ||= []
-        self.sphinx_indexes      ||= []
-        self.sphinx_facets       ||= []
-
-        ThinkingSphinx.context.add_indexed_model self
-
-        if sphinx_index_blocks.empty?
-          before_validation :define_indexes
-          before_destroy    :define_indexes
-        end
-
-        self.sphinx_index_blocks << lambda {
-          add_sphinx_index name, &block
-        }
-
-        include ThinkingSphinx::ActiveRecord::Scopes
-        include ThinkingSphinx::SearchMethods
-      end
-
-      def define_indexes
-        superclass.define_indexes unless superclass == ::ActiveRecord::Base
-
-        return if sphinx_index_blocks.nil? ||
-          defined_indexes?                 ||
-          !ThinkingSphinx.define_indexes?
-
-        sphinx_index_blocks.each do |block|
-          block.call
-        end
-
-        self.defined_indexes = true
-
-        # We want to make sure that if the database doesn't exist, then Thinking
-        # Sphinx doesn't mind when running non-TS tasks (like db:create, db:drop
-        # and db:migrate). It's a bit hacky, but I can't think of a better way.
-      rescue StandardError => err
-        case err.class.name
-        when "Mysql::Error", "Mysql2::Error", "Java::JavaSql::SQLException", "ActiveRecord::StatementInvalid"
-          return
-        else
-          raise err
-        end
-      end
-
-      def add_sphinx_index(name, &block)
-        index = ThinkingSphinx::Index::Builder.generate self, name, &block
-
-        unless sphinx_indexes.any? { |i| i.name == index.name }
-          add_sphinx_callbacks_and_extend(index.delta?)
-          insert_sphinx_index index
-        end
-      end
-
-      def insert_sphinx_index(index)
-        self.sphinx_indexes += [index]
-      end
+require 'active_record'
 
-      def has_sphinx_indexes?
-        sphinx_indexes      &&
-        sphinx_index_blocks &&
-        (sphinx_indexes.length > 0 || sphinx_index_blocks.length > 0)
-      end
-
-      def indexed_by_sphinx?
-        sphinx_indexes && sphinx_indexes.length > 0
-      end
-
-      def delta_indexed_by_sphinx?
-        sphinx_indexes && sphinx_indexes.any? { |index| index.delta? }
-      end
-
-      def sphinx_index_names
-        define_indexes
-        sphinx_indexes.collect(&:all_names).flatten
-      end
-
-      def core_index_names
-        define_indexes
-        sphinx_indexes.collect(&:core_name)
-      end
-
-      def delta_index_names
-        define_indexes
-        sphinx_indexes.select(&:delta?).collect(&:delta_name)
-      end
-
-      def to_riddle
-        define_indexes
-        sphinx_database_adapter.setup
-
-        local_sphinx_indexes.collect { |index|
-          index.to_riddle(sphinx_offset)
-        }.flatten
-      end
-
-      def source_of_sphinx_index
-        define_indexes
-        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 delete_in_index(index, document_id)
-        return unless ThinkingSphinx.sphinx_running?
-
-        ThinkingSphinx::Connection.take do |client|
-          client.update index, ['sphinx_deleted'], {document_id => [1]}
-        end
-      rescue Riddle::ConnectionError, Riddle::ResponseError,
-        ThinkingSphinx::SphinxError, Errno::ETIMEDOUT, Timeout::Error
-        # Not the end of the world if Sphinx isn't running.
-      end
-
-      def sphinx_offset
-        ThinkingSphinx.context.superclass_indexed_models.
-          index eldest_indexed_ancestor
-      end
-
-      # Temporarily disable delta indexing inside a block, then perform a
-      # single rebuild of index at the end.
-      #
-      # Useful when performing updates to batches of models to prevent
-      # the delta index being rebuilt after each individual update.
-      #
-      # In the following example, the delta index will only be rebuilt
-      # once, not 10 times.
-      #
-      #   SomeModel.suspended_delta do
-      #     10.times do
-      #       SomeModel.create( ... )
-      #     end
-      #   end
-      #
-      def suspended_delta(reindex_after = true, &block)
-        define_indexes
-        original_setting = ThinkingSphinx.deltas_suspended?
-        ThinkingSphinx.deltas_suspended = true
-        begin
-          yield
-        ensure
-          ThinkingSphinx.deltas_suspended = original_setting
-          self.index_delta if reindex_after && !original_setting
-        end
-      end
-
-      private
-
-      def local_sphinx_indexes
-        (sphinx_indexes || []).select { |index|
-          index.model == self
-        }
-      end
-
-      def add_sphinx_callbacks_and_extend(delta = false)
-        unless indexed_by_sphinx?
-          after_destroy :toggle_deleted
-
-          include ThinkingSphinx::ActiveRecord::AttributeUpdates
-        end
-
-        if delta && !delta_indexed_by_sphinx?
-          include ThinkingSphinx::ActiveRecord::Delta
-
-          before_save  :toggle_delta
-          after_commit :index_delta
-        end
-      end
-
-      def eldest_indexed_ancestor
-        ancestors.reverse.detect { |ancestor|
-          ThinkingSphinx.context.indexed_models.include?(ancestor.name)
-        }.name
-      end
-    end
-
-    attr_accessor :excerpts
-    attr_accessor :sphinx_attributes
-    attr_accessor :matching_fields
-
-    def toggle_deleted
-      return unless ThinkingSphinx.updates_enabled?
-
-      self.class.core_index_names.each do |index_name|
-        self.class.delete_in_index index_name, self.sphinx_document_id
-      end
-      self.class.delta_index_names.each do |index_name|
-        self.class.delete_in_index index_name, self.sphinx_document_id
-      end if self.class.delta_indexed_by_sphinx? && toggled_delta?
-
-    rescue ::ThinkingSphinx::ConnectionError
-      # nothing
-    end
-
-    # Returns the unique integer id for the object. This method uses the
-    # attribute hash to get around ActiveRecord always mapping the #id method
-    # to whatever the real primary key is (which may be a unique string hash).
-    #
-    # @return [Integer] Unique record id for the purposes of Sphinx.
-    #
-    def primary_key_for_sphinx
-      read_attribute(self.class.primary_key_for_sphinx)
-    end
-
-    def sphinx_document_id
-      primary_key_for_sphinx * ThinkingSphinx.context.indexed_models.size +
-        self.class.sphinx_offset
-    end
-
-    private
+module ThinkingSphinx::ActiveRecord
+  module Callbacks; end
+end
 
-    def sphinx_index_name(suffix)
-      "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_#{suffix}"
-    end
+require 'thinking_sphinx/active_record/property'
+require 'thinking_sphinx/active_record/association'
+require 'thinking_sphinx/active_record/association_proxy'
+require 'thinking_sphinx/active_record/associations'
+require 'thinking_sphinx/active_record/attribute'
+require 'thinking_sphinx/active_record/base'
+require 'thinking_sphinx/active_record/column'
+require 'thinking_sphinx/active_record/database_adapters'
+require 'thinking_sphinx/active_record/field'
+require 'thinking_sphinx/active_record/index'
+require 'thinking_sphinx/active_record/interpreter'
+require 'thinking_sphinx/active_record/log_subscriber'
+require 'thinking_sphinx/active_record/property_sql_presenter'
+require 'thinking_sphinx/active_record/sql_builder'
+require 'thinking_sphinx/active_record/sql_source'
 
-    def define_indexes
-      self.class.define_indexes
-    end
-  end
-end
+require 'thinking_sphinx/active_record/callbacks/delete_callbacks'
+require 'thinking_sphinx/active_record/callbacks/delta_callbacks'
+require 'thinking_sphinx/active_record/callbacks/update_callbacks'