thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/thinking_sphinx/index_set.rb

@@ -0,0 +1,51 @@
+class ThinkingSphinx::IndexSet
+  include Enumerable
+
+  def initialize(classes, index_names, configuration = nil)
+    @classes       = classes || []
+    @index_names   = index_names
+    @configuration = configuration || ThinkingSphinx::Configuration.instance
+  end
+
+  def ancestors
+    classes_and_ancestors - classes
+  end
+
+  def each(&block)
+    indices.each { |index| yield index }
+  end
+
+  def to_a
+    indices
+  end
+
+  private
+
+  def classes_and_ancestors
+    @classes_and_ancestors ||= @classes.collect { |model|
+      model.ancestors.take_while { |klass|
+        klass != ActiveRecord::Base
+      }.select { |klass|
+        klass.class == Class
+      }
+    }.flatten
+  end
+
+  def indices
+    @configuration.preload_indices
+
+    return @configuration.indices.select { |index|
+      @index_names.include?(index.name)
+    } if @index_names && @index_names.any?
+
+    return @configuration.indices if @classes.empty?
+
+    @configuration.indices_for_references(*references)
+  end
+
+  def references
+    classes_and_ancestors.collect { |klass|
+      klass.name.underscore.to_sym
+    }
+  end
+end

data/lib/thinking_sphinx/masks.rb

@@ -0,0 +1,8 @@
+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/masks/group_enumerators_mask.rb

@@ -0,0 +1,23 @@
+class ThinkingSphinx::Masks::GroupEnumeratorsMask
+  def initialize(search)
+    @search = search
+  end
+
+  def each_with_count(&block)
+    @search.raw.each_with_index do |row, index|
+      yield @search[index], row['@count']
+    end
+  end
+
+  def each_with_group(&block)
+    @search.raw.each_with_index do |row, index|
+      yield @search[index], row['@groupby']
+    end
+  end
+
+  def each_with_group_and_count(&block)
+    @search.raw.each_with_index do |row, index|
+      yield @search[index], row['@groupby'], row['@count']
+    end
+  end
+end

data/lib/thinking_sphinx/masks/pagination_mask.rb

@@ -0,0 +1,60 @@
+class ThinkingSphinx::Masks::PaginationMask
+  def initialize(search)
+    @search = search
+  end
+
+  def current_page
+    search.options[:page] = 1 if search.options[:page].blank?
+    search.options[:page].to_i
+  end
+
+  def first_page?
+    current_page == 1
+  end
+
+  def last_page?
+    next_page.nil?
+  end
+
+  def next_page
+    current_page >= total_pages ? nil : 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
+    current_page == 1 ? nil : current_page - 1
+  end
+
+  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,35 @@
+class ThinkingSphinx::Masks::ScopesMask
+  def initialize(search)
+    @search = search
+  end
+
+  def respond_to?(method, include_private = false)
+    super || can_apply_scope?(method)
+  end
+
+  def search(query = nil, options = {})
+    query, options = nil, query if query.is_a?(Hash)
+    ThinkingSphinx::Search::Merger.new(@search).merge! query, options
+  end
+
+  private
+
+  def apply_scope(scope, *args)
+    search *sphinx_scopes[scope].call(*args)
+  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,11 @@
+class ThinkingSphinx::Masks::WeightEnumeratorMask
+  def initialize(search)
+    @search = search
+  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/middlewares.rb

@@ -0,0 +1,36 @@
+module ThinkingSphinx::Middlewares
+  #
+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'
+
+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::ActiveRecordTranslator
+  use ThinkingSphinx::Middlewares::StaleIdChecker
+  use ThinkingSphinx::Middlewares::Glazier
+end
+
+ThinkingSphinx::Middlewares::RAW_ONLY = ::Middleware::Builder.new do
+  use ThinkingSphinx::Middlewares::SphinxQL
+  use ThinkingSphinx::Middlewares::Geographer
+  use ThinkingSphinx::Middlewares::Inquirer
+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
+end

data/lib/thinking_sphinx/middlewares/active_record_translator.rb

@@ -0,0 +1,73 @@
+class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
+  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
+      results_for_models # load now to avoid segfaults
+      context[:results] = context[:results].collect { |row| result_for row }
+    end
+
+    private
+
+    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']
+      }
+    end
+
+    def model_names
+      @model_names ||= context[:results].collect { |row|
+        row['sphinx_internal_class']
+      }.uniq
+    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.id == row['sphinx_internal_id']
+      }
+    end
+
+    def results_for_models
+      @results_for_models ||= model_names.inject({}) { |hash, name|
+        ids        = ids_for_model(name)
+        relation   = name.constantize.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(:id => ids)
+
+        hash
+      }
+    end
+
+    def sql_options
+      context.search.options[:sql] || {}
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/geographer.rb

@@ -0,0 +1,53 @@
+class ThinkingSphinx::Middlewares::Geographer <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    contexts.each do |context|
+      Inner.new(context).call
+    end
+
+    app.call contexts
+  end
+
+  class Inner
+    def initialize(context)
+      @context = context
+    end
+
+    def call
+      return unless geo
+
+      context[:sphinxql].values geodist_clause
+      context[:panes] << ThinkingSphinx::Panes::DistancePane
+    end
+
+    private
+
+    attr_reader :context
+
+    def attribute_names
+      @attribute_names ||= context[:indices].collect(&:unique_attribute_names).
+        flatten.uniq
+    end
+
+    def geo
+      context.search.options[:geo]
+    end
+
+    def geodist_clause
+      "GEODIST(#{geo.first}, #{geo.last}, #{latitude_attribute}, #{longitude_attribute}) AS geodist"
+    end
+
+    def latitude_attribute
+      context.search.options[:latitude_attr]                         ||
+      attribute_names.detect { |attribute| attribute == 'lat' }      ||
+      attribute_names.detect { |attribute| attribute == 'latitude' } || 'lat'
+    end
+
+    def longitude_attribute
+      context.search.options[:longitude_attr]                         ||
+      attribute_names.detect { |attribute| attribute == 'lng' }       ||
+      attribute_names.detect { |attribute| attribute == 'longitude' } || 'lng'
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/glazier.rb

@@ -0,0 +1,39 @@
+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
+    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 row_for(result)
+      context[:raw].detect { |row|
+        row['sphinx_internal_class'] == result.class.name &&
+        row['sphinx_internal_id']    == result.id
+      }
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/ids_only.rb

@@ -0,0 +1,13 @@
+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,62 @@
+class ThinkingSphinx::Middlewares::Inquirer <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    @contexts = contexts
+    @batch    = nil
+
+    contexts.first.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
+      context[:raw]     = raw_results
+      context[:meta]    = meta_results.inject({}) { |hash, row|
+        hash[row['Variable_name']] = row['Value']
+        hash
+      }
+
+      total = context[:meta]['total_found']
+      context.log :message, "Found #{total} result#{'s' unless total == 1}"
+    end
+
+    private
+
+    attr_reader :context
+  end
+end