thinking-sphinx 3.0.3 → 3.0.4

data/lib/thinking_sphinx/connection.rb

@@ -35,7 +35,7 @@ module ThinkingSphinx::Connection
       pool.take do |connection|
         begin
           yield connection
-        rescue Mysql2::Error => error
+        rescue ThinkingSphinx::QueryExecutionError, Mysql2::Error => error
           original = ThinkingSphinx::SphinxError.new_from_mysql error
           raise original if original.is_a?(ThinkingSphinx::QueryError)
           raise Innertube::Pool::BadResource
@@ -43,8 +43,12 @@ module ThinkingSphinx::Connection
       end
     rescue Innertube::Pool::BadResource
       retries += 1
-      retry if retries < 3
-      raise original
+      raise original unless retries < 3
+
+      ActiveSupport::Notifications.instrument(
+        "message.thinking_sphinx", :message => "Retrying query \"#{original.statement}\" after error: #{original.message}"
+      )
+      retry
     end
   end
 
@@ -65,9 +69,10 @@ module ThinkingSphinx::Connection
 
     def execute(statement)
       client.query statement
-    rescue
-      puts "Error with statement: #{statement}"
-      raise
+    rescue => error
+      wrapper           = ThinkingSphinx::QueryExecutionError.new error.message
+      wrapper.statement = statement
+      raise wrapper
     end
 
     def query(statement)
@@ -78,6 +83,10 @@ module ThinkingSphinx::Connection
       results  = [client.query(statements.join('; '))]
       results << client.store_result while client.next_result
       results
+    rescue => error
+      wrapper           = ThinkingSphinx::QueryExecutionError.new error.message
+      wrapper.statement = statements.join('; ')
+      raise wrapper
     end
   end
 

data/lib/thinking_sphinx/core.rb

@@ -2,6 +2,7 @@ module ThinkingSphinx::Core
   #
 end
 
+require 'thinking_sphinx/core/settings'
 require 'thinking_sphinx/core/field'
 require 'thinking_sphinx/core/index'
 require 'thinking_sphinx/core/interpreter'

data/lib/thinking_sphinx/core/index.rb

@@ -1,5 +1,6 @@
 module ThinkingSphinx::Core::Index
   extend ActiveSupport::Concern
+  include ThinkingSphinx::Core::Settings
 
   included do
     attr_reader :reference, :offset, :options
@@ -12,6 +13,7 @@ module ThinkingSphinx::Core::Index
     @charset_type = 'utf-8'
     @options      = options
     @offset       = config.next_offset(reference)
+    @type         = 'plain'
 
     super "#{options[:name] || reference.to_s.gsub('/', '_')}_#{name_suffix}"
   end
@@ -27,10 +29,7 @@ module ThinkingSphinx::Core::Index
   def interpret_definition!
     return if @interpreted_definition
 
-    self.class.settings.each do |setting|
-      value = config.settings[setting.to_s]
-      send("#{setting}=", value) unless value.nil?
-    end
+    apply_defaults!
 
     @interpreted_definition = true
     interpreter.translate! self, @definition_block if @definition_block
@@ -42,19 +41,24 @@ module ThinkingSphinx::Core::Index
 
   def render
     pre_render
+    set_path
 
-    @path ||= File.join config.indices_location, name
-
-    if respond_to?(:infix_fields)
-      self.infix_fields  = fields.select(&:infixing?).collect(&:name)
-      self.prefix_fields = fields.select(&:prefixing?).collect(&:name)
-    end
+    assign_infix_fields
+    assign_prefix_fields
 
     super
   end
 
   private
 
+  def assign_infix_fields
+    self.infix_fields  = fields.select(&:infixing?).collect(&:name)
+  end
+
+  def assign_prefix_fields
+    self.prefix_fields = fields.select(&:prefixing?).collect(&:name)
+  end
+
   def config
     ThinkingSphinx::Configuration.instance
   end
@@ -66,4 +70,8 @@ module ThinkingSphinx::Core::Index
   def pre_render
     interpret_definition!
   end
+
+  def set_path
+    @path ||= File.join config.indices_location, name
+  end
 end

data/lib/thinking_sphinx/core/settings.rb

@@ -0,0 +1,9 @@
+module ThinkingSphinx::Core::Settings
+  private
+  def apply_defaults!(defaults = self.class.settings)
+    defaults.each do |setting|
+      value = config.settings[setting.to_s]
+      send("#{setting}=", value) unless value.nil?
+    end
+  end
+end

data/lib/thinking_sphinx/deletion.rb

@@ -0,0 +1,48 @@
+class ThinkingSphinx::Deletion
+  delegate :name, :to => :index
+
+  def self.perform(index, instance)
+    {
+      'plain' => PlainDeletion,
+      'rt'    => RealtimeDeletion
+    }[index.type].new(index, instance).perform
+  rescue Mysql2::Error => error
+    # This isn't vital, so don't raise the error.
+  end
+
+  def initialize(index, instance)
+    @index, @instance = index, instance
+  end
+
+  private
+
+  attr_reader :index, :instance
+
+  def connection
+    @connection ||= ThinkingSphinx::Connection.new
+  end
+
+  def document_id_for_key
+    index.document_id_for_key instance.id
+  end
+
+  def execute(statement)
+    ThinkingSphinx::Connection.pool.take do |connection|
+      connection.execute statement
+    end
+  end
+
+  class RealtimeDeletion < ThinkingSphinx::Deletion
+    def perform
+      execute Riddle::Query::Delete.new(name, document_id_for_key).to_sql
+    end
+  end
+
+  class PlainDeletion < ThinkingSphinx::Deletion
+    def perform
+      execute Riddle::Query.update(
+        name, document_id_for_key, :sphinx_deleted => true
+      )
+    end
+  end
+end

data/lib/thinking_sphinx/errors.rb

@@ -1,4 +1,6 @@
 class ThinkingSphinx::SphinxError < StandardError
+  attr_accessor :statement
+
   def self.new_from_mysql(error)
     case error.message
     when /parse error/
@@ -12,6 +14,7 @@ class ThinkingSphinx::SphinxError < StandardError
     end
 
     replacement.set_backtrace error.backtrace
+    replacement.statement = error.statement if error.respond_to?(:statement)
     replacement
   end
 end
@@ -25,5 +28,9 @@ end
 class ThinkingSphinx::ParseError < ThinkingSphinx::QueryError
 end
 
+class ThinkingSphinx::QueryExecutionError < StandardError
+  attr_accessor :statement
+end
+
 class ThinkingSphinx::MixedScopesError < StandardError
 end

data/lib/thinking_sphinx/excerpter.rb

@@ -10,6 +10,7 @@ class ThinkingSphinx::Excerpter
   def initialize(index, words, options = {})
     @index, @words = index, words
     @options = DefaultOptions.merge(options)
+    @words = @options.delete(:words) if @options[:words]
   end
 
   def excerpt!(text)

data/lib/thinking_sphinx/facet_search.rb

@@ -1,7 +1,8 @@
 class ThinkingSphinx::FacetSearch
   include Enumerable
 
-  attr_reader :query, :options
+  attr_reader   :options
+  attr_accessor :query
 
   def initialize(query = nil, options = {})
     query, options   = nil, query if query.is_a?(Hash)
@@ -36,12 +37,7 @@ class ThinkingSphinx::FacetSearch
 
     batch = ThinkingSphinx::BatchedSearch.new
     facets.each do |facet|
-      search = ThinkingSphinx::Search.new query, options.merge(
-        :select   => '*, @groupby, @count',
-        :group_by => facet.name,
-        :indices  => index_names_for(facet)
-      )
-      batch.searches << search
+      batch.searches << ThinkingSphinx::Search.new(query, options_for(facet))
     end
 
     batch.populate ThinkingSphinx::Middlewares::RAW_ONLY
@@ -64,26 +60,53 @@ class ThinkingSphinx::FacetSearch
   private
 
   def facets
-    @facets ||= begin
-      properties = indices.collect(&:facets).flatten
-      properties.group_by(&:name).collect { |name, matches|
-        ThinkingSphinx::Facet.new name, matches
+    @facets ||= properties.group_by(&:name).collect { |name, matches|
+      ThinkingSphinx::Facet.new name, matches
+    }
+  end
+
+  def properties
+    properties = indices.collect(&:facets).flatten
+    if options[:facets].present?
+      properties = properties.select { |property|
+        options[:facets].include? property.name.to_sym
       }
     end
+    properties
   end
 
   def index_names_for(*facets)
-    indices.select { |index|
-      facet_names = index.facets.collect(&:name)
-      facets.all? { |facet|
-        facet_names.include?(facet.name)
-      }
-    }.collect &:name
+    facet_names(
+      indices.select do |index|
+        facets.all? { |facet| facet_names(index.facets).include?(facet.name) }
+      end
+    )
+  end
+
+  def facet_names(facets)
+    facets.collect(&:name)
   end
 
   def indices
-    @indices ||= ThinkingSphinx::IndexSet.new options[:classes],
-      options[:indices]
+    @indices ||= ThinkingSphinx::IndexSet.new options[:classes], options[:indices]
+  end
+
+  def max_matches
+    ThinkingSphinx::Configuration.instance.settings['max_matches'] || 1000
+  end
+
+  def limit
+    limit = options[:limit] || options[:per_page] || max_matches
+  end
+
+  def options_for(facet)
+    options.merge(
+      :select      => '*, @groupby, @count',
+      :group_by    => facet.name,
+      :indices     => index_names_for(facet),
+      :max_matches => limit,
+      :limit       => limit
+    )
   end
 
   class Filter

data/lib/thinking_sphinx/masks/scopes_mask.rb

@@ -7,6 +7,13 @@ class ThinkingSphinx::Masks::ScopesMask
     public_methods(false).include?(method) || can_apply_scope?(method)
   end
 
+  def facets(query = nil, options = {})
+    search = ThinkingSphinx.facets query, options
+    ThinkingSphinx::Search::Merger.new(search).merge!(
+      @search.query, @search.options
+    )
+  end
+
   def search(query = nil, options = {})
     query, options = nil, query if query.is_a?(Hash)
     ThinkingSphinx::Search::Merger.new(@search).merge! query, options

data/lib/thinking_sphinx/middlewares.rb

@@ -1,39 +1,33 @@
-module ThinkingSphinx::Middlewares
-  #
+module ThinkingSphinx::Middlewares; end
+
+%w[middleware active_record_translator geographer glazier ids_only inquirer
+   sphinxql stale_id_checker stale_id_filter utf8].each do |middleware|
+  require "thinking_sphinx/middlewares/#{middleware}"
 end
 
-require 'thinking_sphinx/middlewares/middleware'
-require 'thinking_sphinx/middlewares/active_record_translator'
-require 'thinking_sphinx/middlewares/geographer'
-require 'thinking_sphinx/middlewares/glazier'
-require 'thinking_sphinx/middlewares/ids_only'
-require 'thinking_sphinx/middlewares/inquirer'
-require 'thinking_sphinx/middlewares/sphinxql'
-require 'thinking_sphinx/middlewares/stale_id_checker'
-require 'thinking_sphinx/middlewares/stale_id_filter'
-require 'thinking_sphinx/middlewares/utf8'
+module ThinkingSphinx::Middlewares
+  def self.use(builder, middlewares)
+    middlewares.each { |m| builder.use m }
+  end
+
+  BASE_MIDDLEWARES = [SphinxQL, Geographer, Inquirer]
 
-ThinkingSphinx::Middlewares::DEFAULT = ::Middleware::Builder.new do
-  use ThinkingSphinx::Middlewares::StaleIdFilter
-  use ThinkingSphinx::Middlewares::SphinxQL
-  use ThinkingSphinx::Middlewares::Geographer
-  use ThinkingSphinx::Middlewares::Inquirer
-  use ThinkingSphinx::Middlewares::UTF8
-  use ThinkingSphinx::Middlewares::ActiveRecordTranslator
-  use ThinkingSphinx::Middlewares::StaleIdChecker
-  use ThinkingSphinx::Middlewares::Glazier
-end
+  DEFAULT = ::Middleware::Builder.new do
+    use StaleIdFilter
+    ThinkingSphinx::Middlewares.use self, BASE_MIDDLEWARES
+    use UTF8
+    use ActiveRecordTranslator
+    use StaleIdChecker
+    use Glazier
+  end
 
-ThinkingSphinx::Middlewares::RAW_ONLY = ::Middleware::Builder.new do
-  use ThinkingSphinx::Middlewares::SphinxQL
-  use ThinkingSphinx::Middlewares::Geographer
-  use ThinkingSphinx::Middlewares::Inquirer
-  use ThinkingSphinx::Middlewares::UTF8
-end
+  RAW_ONLY = ::Middleware::Builder.new do
+    ThinkingSphinx::Middlewares.use self, BASE_MIDDLEWARES
+    use UTF8
+  end
 
-ThinkingSphinx::Middlewares::IDS_ONLY = ::Middleware::Builder.new do
-  use ThinkingSphinx::Middlewares::SphinxQL
-  use ThinkingSphinx::Middlewares::Geographer
-  use ThinkingSphinx::Middlewares::Inquirer
-  use ThinkingSphinx::Middlewares::IdsOnly
+  IDS_ONLY = ::Middleware::Builder.new do
+    ThinkingSphinx::Middlewares.use self, BASE_MIDDLEWARES
+    use IdsOnly
+  end
 end

data/lib/thinking_sphinx/middlewares/active_record_translator.rb

@@ -18,7 +18,7 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
 
     def call
       results_for_models # load now to avoid segfaults
-      context[:results] = context[:results].collect { |row| result_for row }
+      context[:results] = context[:results].collect { |row| result_for(row) }
     end
 
     private
@@ -26,11 +26,9 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
     attr_reader :context
 
     def ids_for_model(model_name)
-      context[:results].select { |row|
-        row['sphinx_internal_class'] == model_name
-      }.collect { |row|
-        row['sphinx_internal_id']
-      }
+      context[:results].collect { |row|
+        row['sphinx_internal_id'] if row['sphinx_internal_class'] == model_name
+      }.compact
     end
 
     def model_names
@@ -51,20 +49,22 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
     end
 
     def results_for_models
-      @results_for_models ||= model_names.inject({}) { |hash, name|
-        ids      = ids_for_model(name)
-        model    = name.constantize
-        relation = model.unscoped
-
-        relation = relation.includes sql_options[:include] if sql_options[:include]
-        relation = relation.joins  sql_options[:joins]  if sql_options[:joins]
-        relation = relation.order  sql_options[:order]  if sql_options[:order]
-        relation = relation.select sql_options[:select] if sql_options[:select]
-
-        hash[name] = relation.where(model.primary_key => ids)
+      @results_for_models ||= model_names.inject({}) do |hash, name|
+        model = name.constantize
+        hash[name] = model_relation_with_sql_options(model.unscoped).where(
+          model.primary_key => ids_for_model(name)
+        )
 
         hash
-      }
+      end
+    end
+
+    def model_relation_with_sql_options(relation)
+      relation = relation.includes sql_options[:include] if sql_options[:include]
+      relation = relation.joins  sql_options[:joins]  if sql_options[:joins]
+      relation = relation.order  sql_options[:order]  if sql_options[:order]
+      relation = relation.select sql_options[:select] if sql_options[:select]
+      relation
     end
 
     def sql_options