thinking-sphinx 1.5.0 → 2.0.0.rc1

data/lib/thinking_sphinx/auto_version.rb

@@ -5,35 +5,17 @@ module ThinkingSphinx
       case version
       when '0.9.8', '0.9.9'
         require "riddle/#{version}"
-      when /1.10/
-        require 'riddle/1.10'
-      when /2.0.[12]/
-        require 'riddle/2.0.1'
-      when /2.0.[^12]/, /2.1.\d/
-        require 'riddle/2.1.0'
       else
-        documentation_link = %Q{
-For more information, read the documentation:
-http://pat.github.io/thinking-sphinx/advanced_config.html
-}
-
-        if version.nil? || version.empty?
-          STDERR.puts %Q{
+        STDERR.puts %Q{
 Sphinx cannot be found on your system. You may need to configure the following
 settings in your config/sphinx.yml file:
   * bin_path
   * searchd_binary_name
   * indexer_binary_name
 
-#{documentation_link}
-}
-        else
-          STDERR.puts %Q{
-Unsupported version: #{version}
-
-#{documentation_link}
+For more information, read the documentation:
+http://freelancing-god.github.com/ts/en/advanced_config.html
 }
-        end
       end
     end
   end

data/lib/thinking_sphinx/class_facet.rb

@@ -5,16 +5,11 @@ module ThinkingSphinx
     end
     
     def attribute_name
-      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
+      "class_crc"
     end
     
-    def value(object, attribute_hash)
-      if Riddle.loaded_version.to_i < 2
-        crc = attribute_hash['class_crc']
-        ThinkingSphinx::Configuration.instance.models_by_crc[crc]
-      else
-        attribute_hash['sphinx_internal_class']
-      end
+    def value(object, attribute_value)
+      object.class.name
     end
   end
 end

data/lib/thinking_sphinx/configuration.rb

@@ -5,7 +5,7 @@ module ThinkingSphinx
   # This class both keeps track of the configuration settings for Sphinx and
   # also generates the resulting file for Sphinx to use.
   #
-  # Here are the default settings, relative to RAILS_ROOT where relevant:
+  # Here are the default settings, relative to Rails.root where relevant:
   #
   # config file::           config/#{environment}.sphinx.conf
   # searchd log file::      log/searchd.log
@@ -15,7 +15,6 @@ module ThinkingSphinx
   # address::               127.0.0.1
   # port::                  9312
   # allow star::            false
-  # stop timeout::          5
   # min prefix length::     1
   # min infix length::      1
   # mem limit::             64M
@@ -28,7 +27,6 @@ module ThinkingSphinx
   # html remove elements::  ''
   # searchd_binary_name::   searchd
   # indexer_binary_name::   indexer
-  # hard_retry_count::      0
   #
   # If you want to change these settings, create a YAML file at
   # config/sphinx.yml with settings for each environment, in a similar
@@ -51,28 +49,28 @@ module ThinkingSphinx
   class Configuration
     include Singleton
 
-    SourceOptions = Riddle::Configuration::SQLSource.settings.map { |setting|
-      setting.to_s
-    } - %w( type sql_query sql_joined_field sql_file_field
-      sql_query_range sql_attr_uint sql_attr_bool sql_attr_bigint sql_query_info
-      sql_attr_timestamp sql_attr_str2ordinal sql_attr_float sql_attr_multi
-      sql_attr_string sql_attr_str2wordcount sql_column_buffers sql_field_string
-      sql_field_str2wordcount )
-    IndexOptions  = Riddle::Configuration::Index.settings.map     { |setting|
-      setting.to_s
-    } - %w( source prefix_fields infix_fields )
-    CustomOptions = %w( disable_range use_64_bit )
-
-    attr_accessor :searchd_file_path, :allow_star, :app_root,
-      :model_directories, :delayed_job_priority, :indexed_models, :use_64_bit,
-      :touched_reindex_file, :stop_timeout, :version, :shuffle,
-      :hard_retry_count
+    SourceOptions = %w( mysql_connect_flags mysql_ssl_cert mysql_ssl_key
+      mysql_ssl_ca sql_range_step sql_query_pre sql_query_post
+      sql_query_killlist sql_ranged_throttle sql_query_post_index unpack_zlib
+      unpack_mysqlcompress unpack_mysqlcompress_maxsize )
 
+    IndexOptions  = %w( charset_table charset_type charset_dictpath docinfo
+      enable_star exceptions html_index_attrs html_remove_elements html_strip
+      index_exact_words ignore_chars inplace_docinfo_gap inplace_enable
+      inplace_hit_gap inplace_reloc_factor inplace_write_factor min_infix_len
+      min_prefix_len min_stemming_len min_word_len mlock morphology ngram_chars
+      ngram_len ondisk_dict overshort_step phrase_boundary phrase_boundary_step
+      preopen stopwords stopwords_step wordforms )
+
+    CustomOptions = %w( disable_range )
+
+    attr_accessor :searchd_file_path, :allow_star, :database_yml_file,
+      :app_root, :model_directories, :delayed_job_priority, :indexed_models
+    
     attr_accessor :source_options, :index_options
-    attr_reader :configuration
-    attr_writer :controller
+    attr_accessor :version
 
-    @@environment = nil
+    attr_reader :environment, :configuration, :controller
 
     # Load in the configuration settings - this will look for config/sphinx.yml
     # and parse it according to the current environment.
@@ -90,30 +88,29 @@ module ThinkingSphinx
       if custom_app_root
         self.app_root = custom_app_root
       else
-        self.app_root   = Merb.root                  if defined?(Merb)
-        self.app_root   = Sinatra::Application.root  if defined?(Sinatra)
-        self.app_root   = RAILS_ROOT                 if defined?(RAILS_ROOT)
-        self.app_root ||= app_root
+        self.app_root = Rails.root if defined?(Rails)
+        self.app_root = Merb.root if defined?(Merb)
+        self.app_root ||= Dir.pwd
       end
 
-      @controller    = nil
       @configuration = Riddle::Configuration.new
       @configuration.searchd.pid_file   = "#{self.app_root}/log/searchd.#{environment}.pid"
       @configuration.searchd.log        = "#{self.app_root}/log/searchd.log"
       @configuration.searchd.query_log  = "#{self.app_root}/log/searchd.query.log"
 
+      @controller = Riddle::Controller.new @configuration,
+        "#{self.app_root}/config/#{environment}.sphinx.conf"
+
       self.address              = "127.0.0.1"
       self.port                 = 9312
+      self.database_yml_file    = "#{self.app_root}/config/database.yml"
       self.searchd_file_path    = "#{self.app_root}/db/sphinx/#{environment}"
       self.allow_star           = false
-      self.stop_timeout         = 5
       self.model_directories    = ["#{app_root}/app/models/"] +
         Dir.glob("#{app_root}/vendor/plugins/*/app/models/")
       self.delayed_job_priority = 0
       self.indexed_models       = []
-      self.shuffle              = false
-      self.hard_retry_count     = 0
-
+      
       self.source_options  = {}
       self.index_options   = {
         :charset_type => "utf-8"
@@ -121,32 +118,20 @@ module ThinkingSphinx
 
       self.version = nil
       parse_config
-      if controller.respond_to?(:sphinx_version)
-        self.version ||= controller.sphinx_version
-      end
-
-      ThinkingSphinx::Attribute::SphinxTypeMappings.merge!(
-        :string => :sql_attr_string
-      ) if Riddle.loaded_version.to_i > 1
+      self.version ||= @controller.sphinx_version
 
       self
     end
 
     def self.environment
-      @@environment ||= if defined?(Merb)
-        Merb.environment
-      elsif defined?(RAILS_ENV)
-        RAILS_ENV
-      elsif defined?(Sinatra)
-        Sinatra::Application.environment.to_s
-      else
-        ENV['RAILS_ENV'] || 'development'
-      end
-    end
-
-    def self.reset_environment
-      ThinkingSphinx.mutex.synchronize do
-        @@environment = nil
+      Thread.current[:thinking_sphinx_environment] ||= begin
+        if defined?(Merb)
+          Merb.environment
+        elsif defined?(Rails)
+          Rails.env
+        else
+          ENV['RAILS_ENV'] || 'development'
+        end
       end
     end
 
@@ -154,23 +139,6 @@ module ThinkingSphinx
       self.class.environment
     end
 
-    def controller
-      @controller ||= Riddle::Controller.new @configuration,
-        "#{self.app_root}/config/#{environment}.sphinx.conf"
-    end
-
-    def generate
-      @configuration.indices.clear
-
-      ThinkingSphinx.context.indexed_models.each do |model|
-        model = model.constantize
-        model.define_indexes
-        @configuration.indices.concat model.to_riddle
-
-        enforce_common_attribute_types
-      end
-    end
-
     # Generate the config file for Sphinx by using all the settings defined and
     # looping through all the models with indexes to build the relevant
     # indexer and searchd configuration, and sources and indexes details.
@@ -178,7 +146,13 @@ module ThinkingSphinx
     def build(file_path=nil)
       file_path ||= "#{self.config_file}"
 
-      generate
+      @configuration.indexes.clear
+
+      ThinkingSphinx.context.indexed_models.each do |model|
+        model = model.constantize
+        model.define_indexes
+        @configuration.indexes.concat model.to_riddle
+      end
 
       open(file_path, "w") do |file|
         file.write @configuration.render
@@ -203,14 +177,6 @@ module ThinkingSphinx
       @configuration.searchd.port = port
     end
 
-    def use_socket=(use_socket)
-      if use_socket
-        socket = "#{app_root}/tmp/sockets/searchd.#{self.environment}.sock"
-        @configuration.searchd.listen = socket
-        self.address = socket
-      end
-    end
-
     def pid_file
       @configuration.searchd.pid_file
     end
@@ -236,44 +202,48 @@ module ThinkingSphinx
     end
 
     def config_file
-      controller.path
+      @controller.path
     end
 
     def config_file=(file)
-      controller.path = file
+      @controller.path = file
     end
 
     def bin_path
-      controller.bin_path
+      @controller.bin_path
     end
 
     def bin_path=(path)
-      controller.bin_path = path
+      @controller.bin_path = path
     end
 
     def searchd_binary_name
-      controller.searchd_binary_name
+      @controller.searchd_binary_name
     end
 
     def searchd_binary_name=(name)
-      controller.searchd_binary_name = name
+      @controller.searchd_binary_name = name
     end
 
     def indexer_binary_name
-      controller.indexer_binary_name
+      @controller.indexer_binary_name
     end
 
     def indexer_binary_name=(name)
-      controller.indexer_binary_name = name
+      @controller.indexer_binary_name = name
     end
 
-    attr_accessor :timeout
+    def client
+      client = Riddle::Client.new address, port
+      client.max_matches = configuration.searchd.max_matches || 1000
+      client
+    end
 
     def models_by_crc
       @models_by_crc ||= begin
         ThinkingSphinx.context.indexed_models.inject({}) do |hash, model|
           hash[model.constantize.to_crc32] = model
-          Object.subclasses_of(model.constantize).each { |subclass|
+          model.constantize.subclasses.each { |subclass|
             hash[subclass.to_crc32] = subclass.name
           }
           hash
@@ -281,11 +251,6 @@ module ThinkingSphinx
       end
     end
 
-    def touch_reindex_file(output)
-      return FileUtils.touch(@touched_reindex_file) if @touched_reindex_file and output =~ /succesfully sent SIGHUP to searchd/
-      false
-    end
-
     private
 
     # Parse the config/sphinx.yml file - if it exists - then use the attribute
@@ -323,26 +288,5 @@ module ThinkingSphinx
         send("#{key}=", value) if self.respond_to?("#{key}")
       end
     end
-
-    def enforce_common_attribute_types
-      sql_indexes = configuration.indices.reject { |index|
-        index.is_a? Riddle::Configuration::DistributedIndex
-      }
-
-      return unless sql_indexes.any? { |index|
-        index.sources.any? { |source|
-          source.sql_attr_bigint.include? :sphinx_internal_id
-        }
-      }
-
-      sql_indexes.each { |index|
-        index.sources.each { |source|
-          next if source.sql_attr_bigint.include? :sphinx_internal_id
-
-          source.sql_attr_bigint << :sphinx_internal_id
-          source.sql_attr_uint.delete :sphinx_internal_id
-        }
-      }
-    end
   end
 end

data/lib/thinking_sphinx/context.rb

@@ -1,50 +1,50 @@
 class ThinkingSphinx::Context
   attr_reader :indexed_models
-
+  
   def initialize(*models)
     @indexed_models = []
   end
-
+  
   def prepare
     ThinkingSphinx::Configuration.instance.indexed_models.each do |model|
       add_indexed_model model
     end
-
+    
     return unless indexed_models.empty?
-
+    
     load_models
     add_indexed_models
   end
-
+  
   def define_indexes
     indexed_models.each { |model|
       model.constantize.define_indexes
     }
   end
-
+  
   def add_indexed_model(model)
     model = model.name if model.is_a?(Class)
-
+    
     indexed_models << model
     indexed_models.uniq!
     indexed_models.sort!
   end
-
+  
   def superclass_indexed_models
     klasses = indexed_models.collect { |name| name.constantize }
     klasses.reject { |klass|
       klass.superclass.ancestors.any? { |ancestor| klasses.include?(ancestor) }
     }.collect { |klass| klass.name }
   end
-
+  
   private
-
+  
   def add_indexed_models
-    Object.subclasses_of(ActiveRecord::Base).each do |klass|
+    ActiveRecord::Base.subclasses.each do |klass|
       add_indexed_model klass if klass.has_sphinx_indexes?
     end
   end
-
+  
   # Make sure all models are loaded - without reloading any that
   # ActiveRecord::Base is already aware of (otherwise we start to hit some
   # messy dependencies issues).
@@ -53,22 +53,20 @@ class ThinkingSphinx::Context
     ThinkingSphinx::Configuration.instance.model_directories.each do |base|
       Dir["#{base}**/*.rb"].each do |file|
         model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
-
+        
         next if model_name.nil?
-        camelized_model = model_name.camelize
         next if ::ActiveRecord::Base.send(:subclasses).detect { |model|
-          model.name == camelized_model
+          model.name == model_name.camelize
         }
-
+        
         begin
-          camelized_model.constantize
+          model_name.camelize.constantize
         rescue LoadError
-          # Make sure that STI subclasses in subfolders are loaded.
           model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
-        rescue Exception => err
-          STDERR.puts "Warning: Error loading #{file}:"
-          STDERR.puts err.message
-          STDERR.puts err.backtrace.join("\n"), ''
+        rescue NameError
+          next
+        rescue StandardError
+          STDERR.puts "Warning: Error loading #{file}"
         end
       end
     end