thinking-sphinx 3.1.4 → 6.0.0

data/lib/thinking_sphinx/frameworks/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Frameworks::Rails
   def environment
     Rails.env

data/lib/thinking_sphinx/frameworks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx::Frameworks
   def self.current
     defined?(::Rails) ? ThinkingSphinx::Frameworks::Rails.new :

data/lib/thinking_sphinx/guard/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Guard::File
   attr_reader :name
 
@@ -10,7 +12,7 @@ class ThinkingSphinx::Guard::File
   end
 
   def locked?
-    File.exists? path
+    File.exist? path
   end
 
   def path

data/lib/thinking_sphinx/guard/files.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Guard::Files
   def self.call(names, &block)
     new(names).call(&block)

data/lib/thinking_sphinx/guard/none.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Guard::None
+  def self.call(names, &block)
+    block.call names
+  end
+end

data/lib/thinking_sphinx/guard.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx::Guard
   #
 end
 
 require 'thinking_sphinx/guard/file'
 require 'thinking_sphinx/guard/files'
+require 'thinking_sphinx/guard/none'

data/lib/thinking_sphinx/hooks/guard_presence.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Hooks::GuardPresence
+  def self.call(configuration = nil, stream = STDERR)
+    new(configuration, stream).call
+  end
+
+  def initialize(configuration = nil, stream = STDERR)
+    @configuration = configuration || ThinkingSphinx::Configuration.instance
+    @stream        = stream
+  end
+
+  def call
+    return if files.empty?
+
+    stream.puts "WARNING: The following indexing guard files exist:"
+    files.each do |file|
+      stream.puts " * #{file}"
+    end
+    stream.puts <<-TXT
+These files indicate indexing is already happening. If that is not the case,
+these files should be deleted to ensure all indices can be processed.
+
+    TXT
+  end
+
+  private
+
+  attr_reader :configuration, :stream
+
+  def files
+    @files ||= Dir["#{configuration.indices_location}/ts-*.tmp"]
+  end
+end

data/lib/thinking_sphinx/index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Index
   attr_reader :reference, :options, :block
 

data/lib/thinking_sphinx/index_set.rb

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::IndexSet
   include Enumerable
 
+  def self.reference_name(klass)
+    @cached_results ||= {}
+    @cached_results[klass.name] ||= klass.name.underscore.to_sym
+  end
+
   delegate :each, :empty?, :to => :indices
 
   def initialize(options = {}, configuration = nil)
@@ -27,15 +34,15 @@ class ThinkingSphinx::IndexSet
   end
 
   def classes
-    options[:classes] || []
+    options[:classes] || instances.collect(&:class)
   end
 
   def classes_specified?
-    classes.any? || references_specified?
+    instances.any? || classes.any? || references_specified?
   end
 
   def classes_and_ancestors
-    @classes_and_ancestors ||= classes.collect { |model|
+    @classes_and_ancestors ||= mti_classes + sti_classes.collect { |model|
       model.ancestors.take_while { |klass|
         klass != ActiveRecord::Base
       }.select { |klass|
@@ -61,13 +68,29 @@ class ThinkingSphinx::IndexSet
     all_indices.select { |index| references.include? index.reference }
   end
 
+  def instances
+    options[:instances] || []
+  end
+
+  def mti_classes
+    classes.reject { |klass|
+      klass.column_names.include?(klass.inheritance_column)
+    }
+  end
+
   def references
     options[:references] || classes_and_ancestors.collect { |klass|
-      klass.name.underscore.to_sym
+      self.class.reference_name(klass)
     }
   end
 
   def references_specified?
     options[:references] && options[:references].any?
   end
+
+  def sti_classes
+    classes.select { |klass|
+      klass.column_names.include?(klass.inheritance_column)
+    }
+  end
 end

data/lib/thinking_sphinx/indexing_strategies/all_at_once.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::IndexingStrategies::AllAtOnce
+  def self.call(indices = [], &block)
+    indices << '--all' if indices.empty?
+
+    block.call indices
+  end
+end

data/lib/thinking_sphinx/indexing_strategies/one_at_a_time.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::IndexingStrategies::OneAtATime
+  def self.call(indices = [], &block)
+    if indices.empty?
+      configuration = ThinkingSphinx::Configuration.instance
+      configuration.preload_indices
+
+      indices = configuration.indices.select { |index|
+        !(index.distributed? || index.type == 'rt')
+      }.collect &:name
+    end
+
+    indices.each { |name| block.call [name] }
+  end
+end

data/lib/thinking_sphinx/interfaces/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Interfaces::Base
+  include ThinkingSphinx::WithOutput
+
+  private
+
+  def command(command, extra_options = {})
+    ThinkingSphinx::Commander.call(
+      command, configuration, options.merge(extra_options), stream
+    )
+  end
+end

data/lib/thinking_sphinx/interfaces/daemon.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Interfaces::Daemon < ThinkingSphinx::Interfaces::Base
+  def start
+    if command :running
+      raise ThinkingSphinx::SphinxAlreadyRunning, 'searchd is already running'
+    end
+
+    command(options[:nodetach] ? :start_attached : :start_detached)
+  end
+
+  def status
+    if command :running
+      stream.puts "The Sphinx daemon searchd is currently running."
+    else
+      stream.puts "The Sphinx daemon searchd is not currently running."
+    end
+  end
+
+  def stop
+    command :stop
+  end
+
+  private
+
+  delegate :controller, :to => :configuration
+end

data/lib/thinking_sphinx/interfaces/real_time.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Interfaces::RealTime < ThinkingSphinx::Interfaces::Base
+  def initialize(configuration, options, stream = STDOUT)
+    super
+
+    configuration.preload_indices
+
+    command :prepare
+  end
+
+  def clear
+    command :clear_real_time, :indices => indices
+  end
+
+  def index
+    return if indices.empty?
+    if !command :running
+      stream.puts <<-TXT
+The Sphinx daemon is not currently running. Real-time indices can only be
+populated by sending commands to a running daemon.
+      TXT
+      return
+    end
+
+    command :index_real_time, :indices => indices
+  end
+
+  private
+
+  def index_names
+    @index_names ||= options[:index_names] || []
+  end
+
+  def indices
+    @indices ||= begin
+      indices = configuration.indices.select { |index| index.type == 'rt' }
+
+      if index_names.any?
+        indices.select! { |index| index_names.include? index.name }
+      end
+
+      indices
+    end
+  end
+end

data/lib/thinking_sphinx/interfaces/sql.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Interfaces::SQL < ThinkingSphinx::Interfaces::Base
+  def initialize(configuration, options, stream = STDOUT)
+    super
+
+    configuration.preload_indices
+
+    command :prepare
+  end
+
+  def clear
+    command :clear_sql, :indices => (filtered? ? filtered_indices : indices)
+  end
+
+  def index(reconfigure = true, verbose = nil)
+    stream.puts <<-TXT unless verbose.nil?
+The verbose argument to the index method is now deprecated, and can instead be
+managed by the :verbose option passed in when initialising RakeInterface. That
+option is set automatically when invoked by rake, via rake's --silent and/or
+--quiet arguments.
+    TXT
+    return if indices.empty?
+
+    command :configure if reconfigure
+    command :index_sql,
+      :indices => (filtered? ? filtered_indices.collect(&:name) : nil)
+  end
+
+  def merge
+    command :merge_and_update
+  end
+
+  private
+
+  def filtered?
+    index_names.any?
+  end
+
+  def filtered_indices
+    indices.select { |index| index_names.include? index.name }
+  end
+
+  def index_names
+    @index_names ||= options[:index_names] || []
+  end
+
+  def indices
+    @indices ||= configuration.indices.select do |index|
+      index.type == 'plain' || index.type.blank?
+    end
+  end
+end

data/lib/thinking_sphinx/interfaces.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Interfaces
+  #
+end
+
+require 'thinking_sphinx/interfaces/base'
+require 'thinking_sphinx/interfaces/daemon'
+require 'thinking_sphinx/interfaces/real_time'
+require 'thinking_sphinx/interfaces/sql'

data/lib/thinking_sphinx/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Logger
   def self.log(notification, message, &block)
     ActiveSupport::Notifications.instrument(

data/lib/thinking_sphinx/masks/group_enumerators_mask.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Masks::GroupEnumeratorsMask
   def initialize(search)
     @search = search
@@ -9,20 +11,20 @@ class ThinkingSphinx::Masks::GroupEnumeratorsMask
 
   def each_with_count(&block)
     @search.raw.each_with_index do |row, index|
-      yield @search[index], row[ThinkingSphinx::SphinxQL.count[:column]]
+      yield @search[index], row["sphinx_internal_count"]
     end
   end
 
   def each_with_group(&block)
     @search.raw.each_with_index do |row, index|
-      yield @search[index], row[ThinkingSphinx::SphinxQL.group_by[:column]]
+      yield @search[index], row["sphinx_internal_group"]
     end
   end
 
   def each_with_group_and_count(&block)
     @search.raw.each_with_index do |row, index|
-      yield @search[index], row[ThinkingSphinx::SphinxQL.group_by[:column]],
-        row[ThinkingSphinx::SphinxQL.count[:column]]
+      yield @search[index], row["sphinx_internal_group"],
+        row["sphinx_internal_count"]
     end
   end
 end

data/lib/thinking_sphinx/masks/pagination_mask.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Masks::PaginationMask
   def initialize(search)
     @search = search

data/lib/thinking_sphinx/masks/scopes_mask.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Masks::ScopesMask
   def initialize(search)
     @search = search
@@ -24,6 +26,12 @@ class ThinkingSphinx::Masks::ScopesMask
     search query, options.merge(:ids_only => true)
   end
 
+  def none
+    ThinkingSphinx::Search::Merger.new(@search).merge! nil, :none => true
+  end
+
+  alias_method :search_none, :none
+
   private
 
   def apply_scope(scope, *args)

data/lib/thinking_sphinx/masks/weight_enumerator_mask.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Masks::WeightEnumeratorMask
   def initialize(search)
     @search = search
@@ -9,7 +11,7 @@ class ThinkingSphinx::Masks::WeightEnumeratorMask
 
   def each_with_weight(&block)
     @search.raw.each_with_index do |row, index|
-      yield @search[index], row[ThinkingSphinx::SphinxQL.weight[:column]]
+      yield @search[index], row["weight()"]
     end
   end
 end

data/lib/thinking_sphinx/masks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx::Masks
   #
 end

data/lib/thinking_sphinx/middlewares/active_record_translator.rb

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
   ThinkingSphinx::Middlewares::Middleware
 
+  NO_MODEL = Struct.new(:primary_key).new(:id).freeze
+  NO_INDEX = Struct.new(:primary_key).new(:id).freeze
+
   def call(contexts)
     contexts.each do |context|
       Inner.new(context).call
@@ -36,12 +41,25 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
       }.compact
     end
 
+    def index_for(model)
+      return NO_INDEX unless context[:indices]
+
+      context[:indices].detect { |index| index.model == model } || NO_INDEX
+    end
+
     def model_names
       @model_names ||= context[:results].collect { |row|
         row['sphinx_internal_class']
       }.uniq
     end
 
+    def primary_key_for(model)
+      model = NO_MODEL unless model.respond_to?(:primary_key)
+
+      @primary_keys        ||= {}
+      @primary_keys[model] ||= index_for(model).primary_key
+    end
+
     def reset_memos
       @model_names        = nil
       @results_for_models = nil
@@ -49,27 +67,32 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
 
     def result_for(row)
       results_for_models[row['sphinx_internal_class']].detect { |record|
-        record.id == row['sphinx_internal_id']
+        record.public_send(
+          primary_key_for(record.class)
+        ) == row['sphinx_internal_id']
       }
     end
 
     def results_for_models
       @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)
+
+        model_sql_options = sql_options[name] || sql_options
+
+        hash[name] = model_relation_with_sql_options(model.unscoped, model_sql_options).where(
+          primary_key_for(model) => 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 = relation.group  sql_options[:group]  if sql_options[:group]
+    def model_relation_with_sql_options(relation, model_sql_options)
+      relation = relation.includes model_sql_options[:include] if model_sql_options[:include]
+      relation = relation.joins  model_sql_options[:joins]  if model_sql_options[:joins]
+      relation = relation.order  model_sql_options[:order]  if model_sql_options[:order]
+      relation = relation.select model_sql_options[:select] if model_sql_options[:select]
+      relation = relation.group  model_sql_options[:group]  if model_sql_options[:group]
       relation
     end
 

data/lib/thinking_sphinx/middlewares/geographer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/module/delegation'
 
 class ThinkingSphinx::Middlewares::Geographer <

data/lib/thinking_sphinx/middlewares/glazier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Middlewares::Glazier <
   ThinkingSphinx::Middlewares::Middleware
 
@@ -14,6 +16,7 @@ class ThinkingSphinx::Middlewares::Glazier <
   class Inner
     def initialize(context)
       @context = context
+      @indices = {}
     end
 
     def call
@@ -29,10 +32,20 @@ class ThinkingSphinx::Middlewares::Glazier <
 
     attr_reader :context
 
+    def indices_for(model)
+      @indices[model] ||= context[:indices].select do |index|
+        index.model == model
+      end
+    end
+
     def row_for(result)
+      ids = indices_for(result.class).collect do |index|
+        result.send index.primary_key
+      end
+
       context[:raw].detect { |row|
         row['sphinx_internal_class'] == result.class.name &&
-        row['sphinx_internal_id']    == result.id
+        ids.include?(row['sphinx_internal_id'])
       }
     end
   end

data/lib/thinking_sphinx/middlewares/ids_only.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Middlewares::IdsOnly <
   ThinkingSphinx::Middlewares::Middleware
 

data/lib/thinking_sphinx/middlewares/inquirer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Middlewares::Inquirer <
   ThinkingSphinx::Middlewares::Middleware
 
@@ -45,7 +47,7 @@ class ThinkingSphinx::Middlewares::Inquirer <
 
     def call(raw_results, meta_results)
       context[:results] = raw_results.to_a
-      context[:raw]     = raw_results
+      context[:raw]     = context[:results].dup
       context[:meta]    = meta_results.inject({}) { |hash, row|
         hash[row['Variable_name']] = row['Value']
         hash

data/lib/thinking_sphinx/middlewares/middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Middlewares::Middleware
   def initialize(app)
     @app = app

data/lib/thinking_sphinx/middlewares/sphinxql.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Middlewares::SphinxQL <
   ThinkingSphinx::Middlewares::Middleware
 
   SELECT_OPTIONS = [:agent_query_timeout, :boolean_simplify, :comment, :cutoff,
     :field_weights, :global_idf, :idf, :index_weights, :max_matches,
     :max_query_time, :max_predicted_time, :ranker, :retry_count, :retry_delay,
-    :reverse_scan, :sort_method]
+    :reverse_scan, :sort_method, :rand_seed]
 
   def call(contexts)
     contexts.each do |context|
@@ -80,19 +82,6 @@ class ThinkingSphinx::Middlewares::SphinxQL <
       end.flatten
     end
 
-    def indices_match_classes?
-      indices.collect(&:reference).uniq.sort == classes.collect { |klass|
-        klass.name.underscore.to_sym
-      }.sort
-    end
-
-    def inheritance_column_select(klass)
-      <<-SQL
-SELECT DISTINCT #{klass.inheritance_column}
-FROM #{klass.table_name}
-SQL
-    end
-
     def exclusive_filters
       @exclusive_filters ||= (options[:without] || {}).tap do |without|
         without[:sphinx_internal_id] = options[:without_ids] if options[:without_ids].present?
@@ -142,6 +131,19 @@ SQL
       end
     end
 
+    def indices_match_classes?
+      indices.collect(&:reference).uniq.sort == classes.collect { |klass|
+        configuration.index_set_class.reference_name(klass)
+      }.sort
+    end
+
+    def inheritance_column_select(klass)
+      <<-SQL
+SELECT DISTINCT #{klass.inheritance_column}
+FROM #{klass.table_name}
+SQL
+    end
+
     def order_clause
       order_by = options[:order]
       order_by = "#{order_by} ASC" if order_by.is_a? Symbol
@@ -159,8 +161,8 @@ SQL
 
     def values
       options[:select] ||= ['*',
-        "#{ThinkingSphinx::SphinxQL.group_by[:select]}",
-        "#{ThinkingSphinx::SphinxQL.count[:select]}"
+        "groupby() AS sphinx_internal_group",
+        "id AS sphinx_document_id, count(DISTINCT sphinx_document_id) AS sphinx_internal_count"
       ].join(', ') if group_attribute.present?
       options[:select]
     end

data/lib/thinking_sphinx/middlewares/stale_id_checker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::Middlewares::StaleIdChecker <
   ThinkingSphinx::Middlewares::Middleware
 
@@ -33,7 +35,7 @@ class ThinkingSphinx::Middlewares::StaleIdChecker <
     end
 
     def raise_exception
-      raise ThinkingSphinx::Search::StaleIdsException, stale_ids
+      raise ThinkingSphinx::Search::StaleIdsException.new(stale_ids, context)
     end
 
     def stale_ids