thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/middlewares/glazier.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Middlewares::Glazier <
+  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
+      @indices = {}
+    end
+
+    def call
+      return if context[:panes].empty?
+
+      context[:results] = context[:results].collect { |result|
+        ThinkingSphinx::Search::Glaze.new context, result, row_for(result),
+          context[:panes]
+      }
+    end
+
+    private
+
+    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 &&
+        ids.include?(row['sphinx_internal_id'])
+      }
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/ids_only.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Middlewares::IdsOnly <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    contexts.each do |context|
+      context[:results] = context[:results].collect { |row|
+        row['sphinx_internal_id']
+      }
+    end
+
+    app.call contexts
+  end
+end

data/lib/thinking_sphinx/middlewares/inquirer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Middlewares::Inquirer <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    @contexts = contexts
+    @batch    = nil
+
+    ThinkingSphinx::Logger.log :query, combined_queries do
+      batch.results
+    end
+
+    index = 0
+    contexts.each do |context|
+      Inner.new(context).call batch.results[index], batch.results[index + 1]
+
+      index += 2
+    end
+
+    app.call contexts
+  end
+
+  private
+
+  def batch
+    @batch ||= begin
+      batch = ThinkingSphinx::Search::BatchInquirer.new
+
+      @contexts.each do |context|
+        batch.append_query context[:sphinxql].to_sql
+        batch.append_query Riddle::Query.meta
+      end
+
+      batch
+    end
+  end
+
+  def combined_queries
+    @contexts.collect { |context| context[:sphinxql].to_sql }.join('; ')
+  end
+
+  class Inner
+    def initialize(context)
+      @context = context
+    end
+
+    def call(raw_results, meta_results)
+      context[:results] = raw_results.to_a
+      context[:raw]     = context[:results].dup
+      context[:meta]    = meta_results.inject({}) { |hash, row|
+        hash[row['Variable_name']] = row['Value']
+        hash
+      }
+
+      total = context[:meta]['total_found']
+      ThinkingSphinx::Logger.log :message, "Found #{total} result#{'s' unless total == 1}"
+    end
+
+    private
+
+    attr_reader :context
+  end
+end

data/lib/thinking_sphinx/middlewares/middleware.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Middlewares::Middleware
+  def initialize(app)
+    @app = app
+  end
+
+  private
+
+  attr_reader :app, :context
+end

data/lib/thinking_sphinx/middlewares/sphinxql.rb

@@ -0,0 +1,256 @@
+# 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, :rand_seed]
+
+  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
+      context[:indices]  = indices
+      context[:sphinxql] = statement
+    end
+
+    private
+
+    attr_reader :context
+
+    delegate :search, :configuration, :to => :context
+    delegate :options,                :to => :search
+    delegate :settings,               :to => :configuration
+
+    def classes
+      options[:classes] || []
+    end
+
+    def classes_and_descendants
+      classes + descendants
+    end
+
+    def classes_and_descendants_names
+      classes_and_descendants.collect do |klass|
+        name = klass.name
+        name = %Q{"#{name}"} if name[/:/]
+        name
+      end
+    end
+
+    def classes_with_inheritance_column
+      classes.select { |klass|
+        klass.column_names.include?(klass.inheritance_column)
+      }
+    end
+
+    def class_condition
+      "(#{classes_and_descendants_names.join('|')})"
+    end
+
+    def class_condition_required?
+      classes.any? && !indices_match_classes?
+    end
+
+    def constantize_inheritance_column(klass)
+      values = klass.connection.select_values inheritance_column_select(klass)
+      values.reject(&:blank?).each(&:constantize)
+    end
+
+    def descendants
+      @descendants ||= options[:skip_sti] ? [] : descendants_from_tables
+    end
+
+    def descendants_from_tables
+      classes_with_inheritance_column.collect do |klass|
+        constantize_inheritance_column(klass)
+        klass.descendants
+      end.flatten
+    end
+
+    def exclusive_filters
+      @exclusive_filters ||= (options[:without] || {}).tap do |without|
+        without[:sphinx_internal_id] = options[:without_ids] if options[:without_ids].present?
+      end
+    end
+
+    def extended_query
+      conditions = options[:conditions] || {}
+      if class_condition_required?
+        conditions[:sphinx_internal_class_name] = class_condition
+      end
+
+      @extended_query ||= ThinkingSphinx::Search::Query.new(
+        context.search.query, conditions, options[:star]
+      ).to_s
+    end
+
+    def group_attribute
+      options[:group_by].to_s if options[:group_by]
+    end
+
+    def group_order_clause
+      group_by = options[:order_group_by]
+      group_by = "#{group_by} ASC" if group_by.is_a? Symbol
+      group_by
+    end
+
+    def inclusive_filters
+      (options[:with] || {}).merge({:sphinx_deleted => false})
+    end
+
+    def index_names
+      indices.collect(&:name)
+    end
+
+    def index_options
+      indices.first.options
+    end
+
+    def indices
+      @indices ||= begin
+        set = configuration.index_set_class.new(
+          options.slice(:classes, :indices)
+        )
+        raise ThinkingSphinx::NoIndicesError if set.empty?
+        set
+      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
+      order_by
+    end
+
+    def select_options
+      @select_options ||= SELECT_OPTIONS.inject({}) do |hash, key|
+        hash[key] = settings[key.to_s] if settings.key? key.to_s
+        hash[key] = index_options[key] if index_options.key? key
+        hash[key] = options[key]       if options.key? key
+        hash
+      end
+    end
+
+    def values
+      options[: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
+
+    def statement
+      Statement.new(self).to_riddle_query_select
+    end
+
+    class Statement
+      def initialize(report)
+        self.report = report
+        self.query = Riddle::Query::Select.new
+      end
+
+      def to_riddle_query_select
+        filter_by_scopes
+
+        query
+      end
+
+      protected
+      attr_accessor :report, :query
+      def filter_by_scopes
+        scope_by_from
+        scope_by_values
+        scope_by_extended_query
+        scope_by_inclusive_filters
+        scope_by_with_all
+        scope_by_exclusive_filters
+        scope_by_without_all
+
+        scope_by_order
+        scope_by_group
+        scope_by_pagination
+        scope_by_options
+      end
+
+      def scope_by_from
+        query.from *(index_names.collect { |index| "`#{index}`" })
+      end
+
+      def scope_by_values
+        query.values(values.present? ? values : '*')
+      end
+
+      def scope_by_extended_query
+        query.matching extended_query if extended_query.present?
+      end
+
+      def scope_by_inclusive_filters
+        query.where inclusive_filters if inclusive_filters.any?
+      end
+
+      def scope_by_with_all
+        query.where_all options[:with_all] if options[:with_all]
+      end
+
+      def scope_by_exclusive_filters
+        query.where_not exclusive_filters  if exclusive_filters.any?
+      end
+
+      def scope_by_without_all
+        query.where_not_all options[:without_all] if options[:without_all]
+      end
+
+      def scope_by_order
+        query.order_by order_clause if order_clause.present?
+      end
+
+      def scope_by_group
+        query.group_by group_attribute        if group_attribute.present?
+        query.group_best options[:group_best] if options[:group_best]
+        query.order_within_group_by group_order_clause if group_order_clause.present?
+        query.having options[:having]         if options[:having]
+      end
+
+      def scope_by_pagination
+        query.offset context.search.offset
+        query.limit  context.search.per_page
+      end
+
+      def scope_by_options
+        query.with_options select_options if select_options.keys.any?
+      end
+
+      def method_missing(*args, &block)
+        report.send *args, &block
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/stale_id_checker.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Middlewares::StaleIdChecker <
+  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
+      raise_exception if context[:results].any?(&:nil?)
+    end
+
+    private
+
+    attr_reader :context
+
+    def actual_ids
+      context[:results].compact.collect(&:id)
+    end
+
+    def expected_ids
+      context[:raw].collect { |row| row['sphinx_internal_id'].to_i }
+    end
+
+    def raise_exception
+      raise ThinkingSphinx::Search::StaleIdsException.new(stale_ids, context)
+    end
+
+    def stale_ids
+      # Currently only works with single-model queries. Has at no point done
+      # otherwise, but such an improvement would be nice.
+      expected_ids - actual_ids
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/stale_id_filter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Middlewares::StaleIdFilter <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    @context   = contexts.first
+    @stale_ids = []
+    @retries   = stale_retries
+
+    begin
+      app.call contexts
+    rescue ThinkingSphinx::Search::StaleIdsException => error
+      raise error if @retries <= 0
+
+      append_stale_ids error.ids, error.context
+      ThinkingSphinx::Logger.log :message, log_message
+
+      @retries -= 1 and retry
+    end
+  end
+
+  private
+
+  def append_stale_ids(ids, context)
+    @stale_ids |= ids
+
+    context.search.options[:without_ids] ||= []
+    context.search.options[:without_ids] |= ids
+  end
+
+  def log_message
+    'Stale Ids (%s %s left): %s' % [
+      @retries, (@retries == 1 ? 'try' : 'tries'), @stale_ids.join(', ')
+    ]
+  end
+
+  def stale_retries
+    case context.search.options[:retry_stale]
+    when nil, TrueClass
+      2
+    when FalseClass
+      0
+    else
+      context.search.options[:retry_stale].to_i
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/valid_options.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Middlewares::ValidOptions <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    contexts.each { |context| check_options context.search.options }
+
+    app.call contexts
+  end
+
+  private
+
+  def check_options(options)
+    unknown = invalid_keys options.keys
+    return if unknown.empty?
+
+    ThinkingSphinx::Logger.log :caution,
+      "Unexpected search options: #{unknown.inspect}"
+  end
+
+  def invalid_keys(keys)
+    keys - ThinkingSphinx::Search.valid_options
+  end
+end

data/lib/thinking_sphinx/middlewares.rb

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

data/lib/thinking_sphinx/panes/attributes_pane.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Panes::AttributesPane
+  def initialize(context, object, raw)
+    @raw = raw
+  end
+
+  def sphinx_attributes
+    @raw
+  end
+end

data/lib/thinking_sphinx/panes/distance_pane.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Panes::DistancePane
+  def initialize(context, object, raw)
+    @raw = raw
+  end
+
+  def distance
+    @raw['geodist'].to_f
+  end
+
+  def geodist
+    @raw['geodist'].to_f
+  end
+end

data/lib/thinking_sphinx/panes/excerpts_pane.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Panes::ExcerptsPane
+  def initialize(context, object, raw)
+    @context, @object = context, object
+  end
+
+  def excerpts
+    @excerpt_glazing ||= Excerpts.new @object, excerpter
+  end
+
+  private
+
+  def excerpter
+    @excerpter ||= ThinkingSphinx::Excerpter.new(
+      @context[:indices].first.name,
+      excerpt_words,
+      @context.search.options[:excerpts] || {}
+    )
+  end
+
+  def excerpt_words
+    @excerpt_words ||= begin
+      conditions = @context.search.options[:conditions] || {}
+      ThinkingSphinx::Search::Query.new(
+        ([@context.search.query] + conditions.values).compact.join(' '),
+        {}, @context.search.options[:star]
+      ).to_s
+    end
+  end
+
+  class Excerpts
+    def initialize(object, excerpter)
+      @object, @excerpter = object, excerpter
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      @excerpter.excerpt! @object.send(method, *args, &block).to_s
+    end
+  end
+end

data/lib/thinking_sphinx/panes/weight_pane.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Panes::WeightPane
+  def initialize(context, object, raw)
+    @raw = raw
+  end
+
+  def weight
+    @raw["weight()"]
+  end
+end

data/lib/thinking_sphinx/panes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Panes
+  #
+end
+
+require 'thinking_sphinx/panes/attributes_pane'
+require 'thinking_sphinx/panes/distance_pane'
+require 'thinking_sphinx/panes/excerpts_pane'
+require 'thinking_sphinx/panes/weight_pane'