thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/index_set.rb

@@ -0,0 +1,96 @@
+# 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)
+    @options       = options
+    @index_names   = options[:indices] || []
+    @configuration = configuration || ThinkingSphinx::Configuration.instance
+  end
+
+  def ancestors
+    classes_and_ancestors - classes
+  end
+
+  def to_a
+    indices
+  end
+
+  private
+
+  attr_reader :configuration, :options
+
+  def all_indices
+    configuration.preload_indices
+    configuration.indices
+  end
+
+  def classes
+    options[:classes] || instances.collect(&:class)
+  end
+
+  def classes_specified?
+    instances.any? || classes.any? || references_specified?
+  end
+
+  def classes_and_ancestors
+    @classes_and_ancestors ||= mti_classes + sti_classes.collect { |model|
+      model.ancestors.take_while { |klass|
+        klass != ActiveRecord::Base
+      }.select { |klass|
+        klass.class == Class
+      }
+    }.flatten
+  end
+
+  def index_names
+    options[:indices] || []
+  end
+
+  def indices
+    return all_indices.select { |index|
+      index_names.include?(index.name)
+    } if index_names.any?
+
+    everything = classes_specified? ? indices_for_references : all_indices
+    everything.reject &:distributed?
+  end
+
+  def indices_for_references
+    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|
+      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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Logger
+  def self.log(notification, message, &block)
+    ActiveSupport::Notifications.instrument(
+      "#{notification}.thinking_sphinx", notification => message, &block
+    )
+  end
+end

data/lib/thinking_sphinx/masks/group_enumerators_mask.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Masks::GroupEnumeratorsMask
+  def initialize(search)
+    @search = search
+  end
+
+  def can_handle?(method)
+    public_methods(false).include?(method)
+  end
+
+  def each_with_count(&block)
+    @search.raw.each_with_index do |row, index|
+      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["sphinx_internal_group"]
+    end
+  end
+
+  def each_with_group_and_count(&block)
+    @search.raw.each_with_index do |row, index|
+      yield @search[index], row["sphinx_internal_group"],
+        row["sphinx_internal_count"]
+    end
+  end
+end

data/lib/thinking_sphinx/masks/pagination_mask.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Masks::PaginationMask
+  def initialize(search)
+    @search = search
+  end
+
+  def can_handle?(method)
+    public_methods(false).include?(method)
+  end
+
+  def first_page?
+    search.current_page == 1
+  end
+
+  def last_page?
+    next_page.nil?
+  end
+
+  def next_page
+    search.current_page >= total_pages ? nil : search.current_page + 1
+  end
+
+  def next_page?
+    !next_page.nil?
+  end
+
+  def page(number)
+    search.options[:page] = number
+    search
+  end
+
+  def per(limit)
+    search.options[:limit] = limit
+    search
+  end
+
+  def previous_page
+    search.current_page == 1 ? nil : search.current_page - 1
+  end
+
+  alias_method :prev_page, :previous_page
+
+  def total_entries
+    search.meta['total_found'].to_i
+  end
+
+  alias_method :total_count, :total_entries
+  alias_method :count,       :total_entries
+
+  def total_pages
+    return 0 if search.meta['total'].nil?
+
+    @total_pages ||= (search.meta['total'].to_i / search.per_page.to_f).ceil
+  end
+
+  alias_method :page_count, :total_pages
+  alias_method :num_pages,  :total_pages
+
+  private
+
+  attr_reader :search
+end

data/lib/thinking_sphinx/masks/scopes_mask.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Masks::ScopesMask
+  def initialize(search)
+    @search = search
+  end
+
+  def can_handle?(method)
+    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
+  end
+
+  def search_for_ids(query = nil, options = {})
+    query, options = nil, query if query.is_a?(Hash)
+    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)
+    query, options = sphinx_scopes[scope].call(*args)
+    search query, options
+  end
+
+  def can_apply_scope?(scope)
+    @search.options[:classes].present?    &&
+    @search.options[:classes].length == 1 &&
+    @search.options[:classes].first.respond_to?(:sphinx_scopes) &&
+    sphinx_scopes[scope].present?
+  end
+
+  def method_missing(method, *args, &block)
+    apply_scope method, *args
+  end
+
+  def sphinx_scopes
+    @search.options[:classes].first.sphinx_scopes
+  end
+end

data/lib/thinking_sphinx/masks/weight_enumerator_mask.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Masks::WeightEnumeratorMask
+  def initialize(search)
+    @search = search
+  end
+
+  def can_handle?(method)
+    public_methods(false).include?(method)
+  end
+
+  def each_with_weight(&block)
+    @search.raw.each_with_index do |row, index|
+      yield @search[index], row["weight()"]
+    end
+  end
+end

data/lib/thinking_sphinx/masks.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Masks
+  #
+end
+
+require 'thinking_sphinx/masks/group_enumerators_mask'
+require 'thinking_sphinx/masks/pagination_mask'
+require 'thinking_sphinx/masks/scopes_mask'
+require 'thinking_sphinx/masks/weight_enumerator_mask'

data/lib/thinking_sphinx/middlewares/active_record_translator.rb

@@ -0,0 +1,103 @@
+# 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
+    end
+
+    app.call contexts
+  end
+
+  private
+
+  class Inner
+    def initialize(context)
+      @context = context
+    end
+
+    def call
+      results_for_models # load now to avoid segfaults
+
+      context[:results] = if sql_options[:order]
+        results_for_models.values.first
+      else
+        context[:results].collect { |row| result_for(row) }
+      end
+    end
+
+    private
+
+    attr_reader :context
+
+    def ids_for_model(model_name)
+      context[:results].collect { |row|
+        row['sphinx_internal_id'] if row['sphinx_internal_class'] == model_name
+      }.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
+    end
+
+    def result_for(row)
+      results_for_models[row['sphinx_internal_class']].detect { |record|
+        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
+
+        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, 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
+
+    def sql_options
+      context.search.options[:sql] || {}
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/geographer.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+
+class ThinkingSphinx::Middlewares::Geographer <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    contexts.each do |context|
+      Inner.new(context).call
+    end
+
+    app.call contexts
+  end
+
+  private
+
+  class Inner
+    def initialize(context)
+      @context = context
+    end
+
+    def call
+      return unless geo
+
+      context[:sphinxql].prepend_values geodist_clause
+      context[:panes] << ThinkingSphinx::Panes::DistancePane
+    end
+
+    private
+
+    attr_reader :context
+
+    delegate :geo, :latitude, :longitude, :to => :geolocation_attributes
+
+    def fixed_format(float)
+      ThinkingSphinx::FloatFormatter.new(float).fixed
+    end
+
+    def geolocation_attributes
+      @geolocation_attributes ||= GeolocationAttributes.new(context)
+    end
+
+    def geodist_clause
+      "GEODIST(#{fixed_format geo.first}, #{fixed_format geo.last}, #{latitude}, #{longitude}) AS geodist"
+    end
+
+    class GeolocationAttributes
+      attr_accessor :latitude, :longitude
+
+      def initialize(context)
+        self.context   = context
+        self.latitude  = latitude_attr if latitude_attr
+        self.longitude = longitude_attr if longitude_attr
+      end
+
+      def geo
+        search_context_options[:geo]
+      end
+
+      def latitude
+        @latitude ||= names.detect { |name| %w[lat latitude].include?(name) } || 'lat'
+      end
+
+      def longitude
+        @longitude ||= names.detect { |name| %w[lng longitude].include?(name) } || 'lng'
+      end
+
+      private
+
+      attr_accessor :context
+
+      def latitude_attr
+        @latitude_attr ||= search_context_options[:latitude_attr]
+      end
+
+      def longitude_attr
+        @longitude_attr ||= search_context_options[:longitude_attr]
+      end
+
+      def indices
+        context[:indices]
+      end
+
+      def names
+        @names ||= indices.collect(&:unique_attribute_names).flatten.uniq
+      end
+
+      def search_context_options
+        @search_context_options ||= context.search.options
+      end
+    end
+  end
+end