thinking-sphinx 2.0.5 → 2.0.6

data/lib/thinking_sphinx/auto_version.rb

@@ -1,38 +0,0 @@
-module ThinkingSphinx
-  class AutoVersion
-    def self.detect
-      version = ThinkingSphinx::Configuration.instance.version
-      case version
-      when '0.9.8', '0.9.9'
-        require "riddle/#{version}"
-      when /1.10/
-        require 'riddle/1.10'
-      when /2.0.\d/
-        require 'riddle/2.0.1'
-      else
-        documentation_link = %Q{
-For more information, read the documentation:
-http://freelancing-god.github.com/ts/en/advanced_config.html          
-}
-
-        if version.nil? || version.empty?
-          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}
-}
-        end
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/bundled_search.rb

@@ -1,44 +0,0 @@
-module ThinkingSphinx
-  class BundledSearch
-    attr_reader :client
-    
-    def initialize
-      @searches = []
-    end
-    
-    def search(*args)
-      @searches << ThinkingSphinx.search(*args)
-      @searches.last.append_to client
-    end
-    
-    def search_for_ids(*args)
-      @searches << ThinkingSphinx.search_for_ids(*args)
-      @searches.last.append_to client
-    end
-    
-    def searches
-      populate
-      @searches
-    end
-    
-    private
-    
-    def client
-      @client ||= ThinkingSphinx::Configuration.instance.client
-    end
-    
-    def populated?
-      @populated
-    end
-    
-    def populate
-      return if populated?
-      
-      @populated = true
-      
-      client.run.each_with_index do |results, index|
-        searches[index].populate_from_queue results
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/class_facet.rb

@@ -1,20 +0,0 @@
-module ThinkingSphinx
-  class ClassFacet < ThinkingSphinx::Facet
-    def name
-      :class
-    end
-    
-    def attribute_name
-      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
-    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
-    end
-  end
-end

data/lib/thinking_sphinx/configuration.rb

@@ -1,339 +0,0 @@
-require 'erb'
-require 'singleton'
-
-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:
-  #
-  # config file::           config/#{environment}.sphinx.conf
-  # searchd log file::      log/searchd.log
-  # query log file::        log/searchd.query.log
-  # pid file::              log/searchd.#{environment}.pid
-  # searchd files::         db/sphinx/#{environment}/
-  # address::               127.0.0.1
-  # port::                  9312
-  # allow star::            false
-  # min prefix length::     1
-  # min infix length::      1
-  # mem limit::             64M
-  # max matches::           1000
-  # morphology::            nil
-  # charset type::          utf-8
-  # charset table::         nil
-  # ignore chars::          nil
-  # html strip::            false
-  # html remove elements::  ''
-  # searchd_binary_name::   searchd
-  # indexer_binary_name::   indexer
-  #
-  # If you want to change these settings, create a YAML file at
-  # config/sphinx.yml with settings for each environment, in a similar
-  # fashion to database.yml - using the following keys: config_file,
-  # searchd_log_file, query_log_file, pid_file, searchd_file_path, port,
-  # allow_star, enable_star, min_prefix_len, min_infix_len, mem_limit,
-  # max_matches, morphology, charset_type, charset_table, ignore_chars,
-  # html_strip, html_remove_elements, delayed_job_priority,
-  # searchd_binary_name, indexer_binary_name.
-  #
-  # I think you've got the idea.
-  #
-  # Each setting in the YAML file is optional - so only put in the ones you
-  # want to change.
-  #
-  # Keep in mind, if for some particular reason you're using a version of
-  # Sphinx older than 0.9.8 r871 (that's prior to the proper 0.9.8 release),
-  # don't set allow_star to true.
-  #
-  class Configuration
-    include Singleton
-
-    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( blend_chars charset_table charset_type charset_dictpath
-      docinfo enable_star exceptions expand_keywords hitless_words
-      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_accessor :version
-
-    attr_reader :environment, :configuration, :controller
-    
-    @@environment = nil
-    
-    # Load in the configuration settings - this will look for config/sphinx.yml
-    # and parse it according to the current environment.
-    #
-    def initialize(app_root = Dir.pwd)
-      self.reset
-    end
-
-    def self.configure(&block)
-      yield instance
-      instance.reset(instance.app_root)
-    end
-
-    def reset(custom_app_root=nil)
-      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)
-        self.app_root ||= app_root
-      end
-
-      @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.model_directories    = ["#{app_root}/app/models/"] +
-        Dir.glob("#{app_root}/vendor/plugins/*/app/models/")
-      self.delayed_job_priority = 0
-      self.indexed_models       = []
-      
-      self.source_options  = {}
-      self.index_options   = {
-        :charset_type => "utf-8"
-      }
-
-      self.version = nil
-      parse_config
-      self.version ||= @controller.sphinx_version
-
-      self
-    end
-
-    def self.environment
-      if @@environment.nil?
-        ThinkingSphinx.mutex.synchronize do
-          @@environment ||= if defined?(Merb)
-            Merb.environment
-          elsif defined?(Rails)
-            Rails.env
-          elsif defined?(Sinatra)
-            Sinatra::Application.environment.to_s
-          else
-            ENV['RAILS_ENV'] || 'development'
-          end
-        end
-      end
-      
-      @@environment
-    end
-    
-    def self.reset_environment
-      ThinkingSphinx.mutex.synchronize do
-        @@environment = nil
-      end
-    end
-
-    def environment
-      self.class.environment
-    end
-    
-    def generate
-      @configuration.indexes.clear
-
-      ThinkingSphinx.context.indexed_models.each do |model|
-        model = model.constantize
-        model.define_indexes
-        @configuration.indexes.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.
-    #
-    def build(file_path=nil)
-      file_path ||= "#{self.config_file}"
-      
-      generate
-      
-      open(file_path, "w") do |file|
-        file.write @configuration.render
-      end
-    end
-
-    def address
-      @address
-    end
-
-    def address=(address)
-      @address = address
-      @configuration.searchd.address = address
-    end
-
-    def port
-      @port
-    end
-
-    def port=(port)
-      @port = port
-      @configuration.searchd.port = port
-    end
-
-    def pid_file
-      @configuration.searchd.pid_file
-    end
-
-    def pid_file=(pid_file)
-      @configuration.searchd.pid_file = pid_file
-    end
-
-    def searchd_log_file
-      @configuration.searchd.log
-    end
-
-    def searchd_log_file=(file)
-      @configuration.searchd.log = file
-    end
-
-    def query_log_file
-      @configuration.searchd.query_log
-    end
-
-    def query_log_file=(file)
-      @configuration.searchd.query_log = file
-    end
-
-    def config_file
-      @controller.path
-    end
-
-    def config_file=(file)
-      @controller.path = file
-    end
-
-    def bin_path
-      @controller.bin_path
-    end
-
-    def bin_path=(path)
-      @controller.bin_path = path
-    end
-
-    def searchd_binary_name
-      @controller.searchd_binary_name
-    end
-
-    def searchd_binary_name=(name)
-      @controller.searchd_binary_name = name
-    end
-
-    def indexer_binary_name
-      @controller.indexer_binary_name
-    end
-
-    def indexer_binary_name=(name)
-      @controller.indexer_binary_name = name
-    end
-    
-    attr_accessor :timeout
-    
-    def client
-      client = Riddle::Client.new address, port,
-        configuration.searchd.client_key
-      client.max_matches = configuration.searchd.max_matches || 1000
-      client.timeout = timeout || 0
-      client
-    end
-
-    def models_by_crc
-      @models_by_crc ||= begin
-        ThinkingSphinx.context.indexed_models.inject({}) do |hash, model|
-          hash[model.constantize.to_crc32] = model
-          model.constantize.descendants.each { |subclass|
-            hash[subclass.to_crc32] = subclass.name
-          }
-          hash
-        end
-      end
-    end
-
-    private
-
-    # Parse the config/sphinx.yml file - if it exists - then use the attribute
-    # accessors to set the appropriate values. Nothing too clever.
-    #
-    def parse_config
-      path = "#{app_root}/config/sphinx.yml"
-      return unless File.exists?(path)
-
-      conf = YAML::load(ERB.new(IO.read(path)).result)[environment]
-
-      conf.each do |key,value|
-        self.send("#{key}=", value) if self.respond_to?("#{key}=")
-
-        set_sphinx_setting self.source_options, key, value, SourceOptions
-        set_sphinx_setting self.index_options,  key, value, IndexOptions
-        set_sphinx_setting self.index_options,  key, value, CustomOptions
-        set_sphinx_setting @configuration.searchd, key, value
-        set_sphinx_setting @configuration.indexer, key, value
-      end unless conf.nil?
-
-      self.bin_path += '/' unless self.bin_path.blank?
-
-      if self.allow_star
-        self.index_options[:enable_star]    = true
-        self.index_options[:min_prefix_len] = 1
-      end
-    end
-
-    def set_sphinx_setting(object, key, value, allowed = {})
-      if object.is_a?(Hash)
-        object[key.to_sym] = value if allowed.include?(key.to_s)
-      else
-        object.send("#{key}=", value) if object.respond_to?("#{key}")
-        send("#{key}=", value) if self.respond_to?("#{key}")
-      end
-    end
-    
-    def enforce_common_attribute_types
-      sql_indexes = configuration.indexes.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,76 +0,0 @@
-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
-    ActiveRecord::Base.descendants.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).
-  #
-  def load_models
-    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?
-        next if ::ActiveRecord::Base.send(:descendants).detect { |model|
-          model.name == model_name.camelize
-        }
-        
-        begin
-          model_name.camelize.constantize
-        rescue LoadError
-          model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
-        rescue NameError
-          next
-        rescue StandardError => err
-          STDERR.puts "Warning: Error loading #{file}:"
-          STDERR.puts err.message
-          STDERR.puts err.backtrace.join("\n"), ''
-        end
-      end
-    end
-  end
-end