warp-thinking-sphinx 1.2.12 → 1.3.10

data/lib/thinking_sphinx/context.rb

@@ -0,0 +1,74 @@
+class ThinkingSphinx::Context
+  attr_reader :indexed_models
+  
+  def initialize
+    @indexed_models = []
+  end
+  
+  def prepare
+    load_models
+    add_indexed_models if cached?
+  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 cached?
+    defined?(Rails)                   &&
+    Rails::VERSION::STRING.to_f > 2.1 &&
+    Rails.configuration.cache_classes
+  end
+  
+  def add_indexed_models
+    Object.subclasses_of(ActiveRecord::Base).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(:subclasses).detect { |model|
+          model.name == model_name
+        }
+      
+        begin
+          model_name.camelize.constantize
+        rescue LoadError
+          model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
+        rescue NameError
+          next
+        rescue StandardError
+          STDERR.puts "Warning: Error loading #{file}"
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas.rb

@@ -1,6 +1,4 @@
 require 'thinking_sphinx/deltas/default_delta'
-require 'thinking_sphinx/deltas/delayed_delta'
-require 'thinking_sphinx/deltas/datetime_delta'
 
 module ThinkingSphinx
   module Deltas

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -13,18 +13,8 @@ module ThinkingSphinx
           ThinkingSphinx.deltas_enabled?
         return true if instance && !toggled(instance)
         
-        config = ThinkingSphinx::Configuration.instance
-        client = Riddle::Client.new config.address, config.port
-        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
-        
-        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} #{delta_index_name model}`
-        puts(output) unless ThinkingSphinx.suppress_delta_output?
-        
-        client.update(
-          core_index_name(model),
-          ['sphinx_deleted'],
-          {instance.sphinx_document_id => [1]}
-        ) if instance && ThinkingSphinx.sphinx_running? && instance.in_both_indexes?
+        update_delta_indexes model
+        delete_from_core     model, instance if instance
         
         true
       end
@@ -48,17 +38,21 @@ module ThinkingSphinx
         " = #{adapter.boolean(toggled)}"
       end
       
-      protected
+      private
       
-      def core_index_name(model)
-        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
+      def update_delta_indexes(model)
+        config = ThinkingSphinx::Configuration.instance
+        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
+        
+        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} #{model.delta_index_names.join(' ')}`
+        puts(output) unless ThinkingSphinx.suppress_delta_output?
       end
       
-      def delta_index_name(model)
-        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_delta"
-      end  
-      
-      private
+      def delete_from_core(model, instance)
+        model.core_index_names.each do |index_name|
+          model.delete_in_index index_name, instance.sphinx_document_id
+        end
+      end
       
       def adapter
         @adapter = @index.model.sphinx_database_adapter

data/lib/thinking_sphinx/deploy/capistrano.rb

@@ -93,7 +93,7 @@ DESC
       rails_env = fetch(:rails_env, "production")
       rake = fetch(:rake, "rake")
       tasks.each do |t|
-        run "cd #{current_path}; #{rake} RAILS_ENV=#{rails_env} #{t}"
+        run "if [ -d #{release_path} ]; then cd #{release_path}; else cd #{current_path}; fi; #{rake} RAILS_ENV=#{rails_env} #{t}"
       end
     end
   end

data/lib/thinking_sphinx/facet_search.rb

@@ -3,6 +3,8 @@ module ThinkingSphinx
     attr_accessor :args, :options
     
     def initialize(*args)
+      ThinkingSphinx.context.define_indexes
+      
       @options      = args.extract_options!
       @args         = args
       
@@ -64,7 +66,7 @@ module ThinkingSphinx
     
     def facet_classes
       (
-        options[:classes] || ThinkingSphinx.indexed_models.collect { |model|
+        options[:classes] || ThinkingSphinx.context.indexed_models.collect { |model|
           model.constantize
         }
       ).select { |klass| klass.sphinx_facets.any? }

data/lib/thinking_sphinx/index.rb

@@ -2,14 +2,8 @@ require 'thinking_sphinx/index/builder'
 require 'thinking_sphinx/index/faux_column'
 
 module ThinkingSphinx
-  # The Index class is a ruby representation of a Sphinx source (not a Sphinx
-  # index - yes, I know it's a little confusing. You'll manage). This is
-  # another 'internal' Thinking Sphinx class - if you're using it directly,
-  # you either know what you're doing, or messing with things beyond your ken.
-  # Enjoy.
-  # 
   class Index
-    attr_accessor :model, :sources, :delta_object
+    attr_accessor :name, :model, :sources, :delta_object
     
     # Create a new index instance by passing in the model it is tied to, and
     # a block to build it with (optional but recommended). For documentation
@@ -26,6 +20,7 @@ module ThinkingSphinx
     #   end
     #
     def initialize(model, &block)
+      @name         = self.class.name_for model
       @model        = model
       @sources      = []
       @options      = {}
@@ -40,8 +35,19 @@ module ThinkingSphinx
       @sources.collect { |source| source.attributes }.flatten
     end
     
-    def name
-      self.class.name_for @model
+    def core_name
+      "#{name}_core"
+    end
+    
+    def delta_name
+      "#{name}_delta"
+    end
+    
+    def all_names
+      names  = [core_name]
+      names << delta_name if delta?
+      
+      names
     end
     
     def self.name_for(model)
@@ -61,7 +67,7 @@ module ThinkingSphinx
     end
     
     def options
-      all_index_options = ThinkingSphinx::Configuration.instance.index_options.clone
+      all_index_options = config.index_options.clone
       @options.keys.select { |key|
         ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) ||
         ThinkingSphinx::Configuration::CustomOptions.include?(key.to_s)
@@ -73,6 +79,12 @@ module ThinkingSphinx
       !@delta_object.nil?
     end
     
+    def to_riddle(offset)
+      indexes = [to_riddle_for_core(offset)]
+      indexes << to_riddle_for_delta(offset) if delta?
+      indexes << to_riddle_for_distributed
+    end
+    
     private
     
     def adapter
@@ -83,17 +95,63 @@ module ThinkingSphinx
       options[:charset_type] == "utf-8"
     end
     
-    # Does all the magic with the block provided to the base #initialize.
-    # Creates a new class subclassed from Builder, and evaluates the block
-    # on it, then pulls all relevant settings - fields, attributes, conditions,
-    # properties - into the new index.
-    # 
-    def initialize_from_builder(&block)
-      #
-    end
-    
     def sql_query_pre_for_delta
       [""]
     end
+    
+    def config
+      @config ||= ThinkingSphinx::Configuration.instance
+    end
+    
+    def to_riddle_for_core(offset)
+      index = Riddle::Configuration::Index.new core_name
+      index.path = File.join config.searchd_file_path, index.name
+      
+      set_configuration_options_for_indexes index
+      set_field_settings_for_indexes        index
+      
+      sources.each_with_index do |source, i|
+        index.sources << source.to_riddle_for_core(offset, i)
+      end
+      
+      index
+    end
+    
+    def to_riddle_for_delta(offset)
+      index = Riddle::Configuration::Index.new delta_name
+      index.parent = core_name
+      index.path = File.join config.searchd_file_path, index.name
+      
+      sources.each_with_index do |source, i|
+        index.sources << source.to_riddle_for_delta(offset, i)
+      end
+      
+      index
+    end
+    
+    def to_riddle_for_distributed
+      index = Riddle::Configuration::DistributedIndex.new name
+      index.local_indexes << core_name
+      index.local_indexes.unshift delta_name if delta?
+      index
+    end
+    
+    def set_configuration_options_for_indexes(index)
+      config.index_options.each do |key, value|
+        method = "#{key}=".to_sym
+        index.send(method, value) if index.respond_to?(method)
+      end
+      
+      options.each do |key, value|
+        index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
+      end
+    end
+    
+    def set_field_settings_for_indexes(index)
+      field_names = lambda { |field| field.unique_name.to_s }
+      
+      index.prefix_field_names += prefix_fields.collect(&field_names)
+      index.infix_field_names  += infix_fields.collect(&field_names)
+    end
   end
 end

data/lib/thinking_sphinx/index/builder.rb

@@ -20,9 +20,9 @@ module ThinkingSphinx
         }
       }
       
-      def self.generate(model, &block)
+      def self.generate(model, name = nil, &block)
         index  = ThinkingSphinx::Index.new(model)
-        model.sphinx_facets ||= []
+        index.name = name unless name.nil?
         
         Builder.new(index, &block) if block_given?
         

data/lib/thinking_sphinx/search.rb

@@ -14,7 +14,7 @@ module ThinkingSphinx
       kind_of? member? method methods nil? object_id respond_to? send should
       type )
     SafeMethods = %w( partition private_methods protected_methods
-      public_methods send )
+      public_methods send class )
     
     instance_methods.select { |method|
       method.to_s[/^__/].nil? && !CoreMethods.include?(method.to_s)
@@ -58,6 +58,8 @@ module ThinkingSphinx
     end
     
     def initialize(*args)
+      ThinkingSphinx.context.define_indexes
+      
       @array    = []
       @options  = args.extract_options!
       @args     = args
@@ -90,6 +92,8 @@ module ThinkingSphinx
       if is_scope?(method)
         add_scope(method, *args, &block)
         return self
+      elsif method == :search_count
+        return scoped_count
       elsif method.to_s[/^each_with_.*/].nil? && !@array.respond_to?(method)
         super
       elsif !SafeMethods.include?(method.to_s)
@@ -146,7 +150,9 @@ module ThinkingSphinx
     # @return [Integer]
     # 
     def per_page
-      @options[:limit] || @options[:per_page] || 20
+      @options[:limit] ||= @options[:per_page]
+      @options[:limit] ||= 20
+      @options[:limit].to_i
     end
     
     # The total number of pages available if the results are paginated.
@@ -155,6 +161,8 @@ module ThinkingSphinx
     # 
     def total_pages
       populate
+      return 0 if @results[:total].nil?
+      
       @total_pages ||= (@results[:total] / per_page.to_f).ceil
     end
     # Compatibility with older versions of will_paginate
@@ -166,15 +174,18 @@ module ThinkingSphinx
     # 
     def total_entries
       populate
+      return 0 if @results[:total_found].nil?
+      
       @total_entries ||= @results[:total_found]
     end
     
     # The current page's offset, based on the number of records per page.
+    # Or explicit :offset if given. 
     # 
     # @return [Integer]
     # 
     def offset
-      (current_page - 1) * per_page
+      @options[:offset] || ((current_page - 1) * per_page)
     end
     
     def indexes
@@ -215,6 +226,7 @@ module ThinkingSphinx
     end
     
     def search(*args)
+      add_default_scope
       merge_search ThinkingSphinx::Search.new(*args)
       self
     end
@@ -231,8 +243,12 @@ module ThinkingSphinx
       
       retry_on_stale_index do
         begin
-          log "Querying Sphinx: #{query}"
-          @results = client.query query, indexes, comment
+          log "Querying: '#{query}'"
+          runtime = Benchmark.realtime {
+            @results = client.query query, indexes, comment
+          }
+          log "Found #{@results[:total_found]} results", :debug,
+            "Sphinx (#{sprintf("%f", runtime)}s)"
         rescue Errno::ECONNREFUSED => err
           raise ThinkingSphinx::ConnectionError,
             'Connection to Sphinx Daemon (searchd) failed.'
@@ -280,13 +296,16 @@ module ThinkingSphinx
       end
     end
     
-    def self.log(message, method = :debug)
+    def self.log(message, method = :debug, identifier = 'Sphinx')
       return if ::ActiveRecord::Base.logger.nil?
-      ::ActiveRecord::Base.logger.send method, message
+      identifier_color, message_color = "4;32;1", "0" # 0;1 = Bold
+      info = "  \e[#{identifier_color}m#{identifier}\e[0m   "
+      info << "\e[#{message_color}m#{message}\e[0m"
+      ::ActiveRecord::Base.logger.send method, info
     end
     
-    def log(message, method = :debug)
-      self.class.log(message, method)
+    def log(*args)
+      self.class.log(*args)
     end
     
     def client
@@ -305,6 +324,9 @@ module ThinkingSphinx
         # puts "value: #{value.inspect}"
         client.send("#{key}=", value) if value
       end
+
+      # treated non-standard as :select is already used for AR queries
+      client.select = options[:sphinx_select] || '*'
       
       client.limit      = per_page
       client.offset     = offset
@@ -684,6 +706,11 @@ MSG
       one_class && one_class.sphinx_scopes.include?(method)
     end
     
+    # Adds the default_sphinx_scope if set.
+    def add_default_scope
+      add_scope(one_class.get_default_sphinx_scope) if one_class && one_class.has_default_sphinx_scope?
+    end
+    
     def add_scope(method, *args, &block)
       merge_search one_class.send(method, *args, &block)
     end
@@ -704,5 +731,16 @@ MSG
         end
       end
     end
+    
+    def scoped_count
+      return self.total_entries if @options[:ids_only]
+      
+      @options[:ids_only] = true
+      results_count = self.total_entries
+      @options[:ids_only] = false
+      @populated = false
+      
+      results_count
+    end
   end
 end