thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/thinking_sphinx/middlewares/middleware.rb

@@ -0,0 +1,9 @@
+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,149 @@
+class ThinkingSphinx::Middlewares::SphinxQL <
+  ThinkingSphinx::Middlewares::Middleware
+
+  SELECT_OPTIONS = [:field_weights, :ranker]
+
+  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
+
+      if group_attribute.present?
+        context.search.masks << ThinkingSphinx::Masks::GroupEnumeratorsMask
+      end
+    end
+
+    private
+
+    attr_reader :context
+
+    def classes
+      options[:classes] || []
+    end
+
+    def classes_and_descendants
+      classes + descendants
+    end
+
+    def class_condition
+      '(' + classes_and_descendants.collect(&:name).join('|') + ')'
+    end
+
+    def descendants
+      @descendants ||= options[:skip_sti] ? [] : descendants_from_tables
+    end
+
+    def descendants_from_tables
+      classes.select { |klass|
+        klass.column_names.include?(klass.inheritance_column)
+      }.collect { |klass|
+        klass.connection.select_values(<<-SQL).compact.each(&:constantize)
+  SELECT DISTINCT #{klass.inheritance_column}
+  FROM #{klass.table_name}
+        SQL
+        klass.descendants
+      }.flatten
+    end
+
+    def exclusive_filters
+      @exclusive_filters ||= (options[:without] || {}).tap do |without|
+        if options[:without_ids].present? && options[:without_ids].any?
+          without[:sphinx_internal_id] = options[:without_ids]
+        end
+      end
+    end
+
+    def extended_query
+      conditions = options[:conditions] || {}
+      conditions[:sphinx_internal_class] = class_condition if classes.any?
+      @extended_query ||= begin
+        ThinkingSphinx::Search::Query.new(context.search.query, conditions,
+          options[:star]).to_s
+      end
+    end
+
+    def group_attribute
+      options[:group_by] ? options[:group_by].to_s : nil
+    end
+
+    def group_order_clause
+      case options[:order_group_by]
+      when Symbol
+        "#{options[:order_group_by]} ASC"
+      else
+        options[:order_group_by]
+      end
+    end
+
+    def inclusive_filters
+      @inclusive_filters ||= (options[:with] || {}).tap do |with|
+        with[:sphinx_deleted] = false
+      end
+    end
+
+    def index_names
+      indices.collect(&:name)
+    end
+
+    def indices
+      @indices ||= ThinkingSphinx::IndexSet.new classes, options[:indices]
+    end
+
+    def options
+      context.search.options
+    end
+
+    def order_clause
+      case options[:order]
+      when Symbol
+        "#{options[:order]} ASC"
+      else
+        options[:order]
+      end
+    end
+
+    def select_options
+      @select_options ||= options.keys.inject({}) do |hash, key|
+        hash[key] = options[key] if SELECT_OPTIONS.include?(key)
+        hash
+      end
+    end
+
+    def statement
+      Riddle::Query::Select.new.tap do |select|
+        select.from *index_names.collect { |index| "`#{index}`" }
+        select.values values                if values.present?
+        select.matching extended_query      if extended_query.present?
+        select.where inclusive_filters      if inclusive_filters.any?
+        select.where_all options[:with_all] if options[:with_all]
+        select.where_not exclusive_filters  if exclusive_filters.any?
+        select.where_not_all options[:without_all] if options[:without_all]
+        select.order_by order_clause        if order_clause.present?
+        select.group_by group_attribute     if group_attribute.present?
+        select.order_within_group_by group_order_clause if group_order_clause.present?
+        select.offset context.search.offset
+        select.limit  context.search.per_page
+        select.with_options select_options  if select_options.keys.any?
+      end
+    end
+
+    def values
+      options[:select] ||= '*, @groupby, @count' if group_attribute.present?
+      options[:select]
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares/stale_id_checker.rb

@@ -0,0 +1,45 @@
+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, stale_ids
+    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,46 @@
+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
+      @context.log :message, log_message
+
+      @retries -= 1 and retry
+    end
+  end
+
+  private
+
+  def append_stale_ids(ids)
+    @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/panes.rb

@@ -0,0 +1,8 @@
+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'

data/lib/thinking_sphinx/panes/attributes_pane.rb

@@ -0,0 +1,9 @@
+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,13 @@
+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,37 @@
+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 ||= @context[:meta].keys.select { |key|
+      key[/^keyword\[/]
+    }.sort.collect { |key| @context[:meta][key] }.join(' ')
+  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,9 @@
+class ThinkingSphinx::Panes::WeightPane
+  def initialize(context, object, raw)
+    @raw = raw
+  end
+
+  def weight
+    @raw['@weight']
+  end
+end

data/lib/thinking_sphinx/railtie.rb

@@ -1,43 +1,9 @@
-require 'thinking_sphinx'
-require 'rails'
-
-module ThinkingSphinx
-  class Railtie < Rails::Railtie
-
-    initializer 'thinking_sphinx.sphinx' do
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    initializer "thinking_sphinx.active_record" do
-      ActiveSupport.on_load :active_record do
-        include ThinkingSphinx::ActiveRecord
-      end
-    end
-
-    initializer "thinking_sphinx.action_controller" do
-      ActiveSupport.on_load :action_controller do
-        require 'thinking_sphinx/action_controller'
-        include ThinkingSphinx::ActionController
-      end
-    end
-
-    initializer "thinking_sphinx.set_app_root" do |app|
-      ThinkingSphinx::Configuration.instance.reset # Rails has setup app now
-    end
-
-    config.to_prepare do
-      # ActiveRecord::Base.to_crc32s is dependant on the subclasses being loaded
-      # consistently. When the environment is reset, subclasses/descendants will
-      # be lost but our context will not reload them for us.
-      #
-      # We reset the context which causes the subclasses/descendants to be
-      # reloaded next time the context is called.
-      #
-      ThinkingSphinx.reset_context!
-    end
+class ThinkingSphinx::Railtie < Rails::Railtie
+  ActiveSupport.on_load :active_record do
+    include ThinkingSphinx::ActiveRecord::Base
+  end
 
-    rake_tasks do
-      load File.expand_path('../tasks.rb', __FILE__)
-    end
+  rake_tasks do
+    load File.expand_path('../tasks.rb', __FILE__)
   end
 end

data/lib/thinking_sphinx/rake_interface.rb

@@ -0,0 +1,47 @@
+class ThinkingSphinx::RakeInterface
+  def configure
+    puts "Generating configuration to #{config.configuration_file}"
+    config.render_to_file
+  end
+
+  def index(reconfigure = true)
+    configure if reconfigure
+    FileUtils.mkdir_p config.indices_location
+    controller.index :verbose => true
+  end
+
+  def start
+    raise RuntimeError, 'searchd is already running' if controller.running?
+
+    controller.start
+
+    if controller.running?
+      puts "Started searchd successfully (pid: #{controller.pid})."
+    else
+      puts "Failed to start searchd. Check the log files for more information."
+    end
+  end
+
+  def stop
+    unless controller.running?
+      puts 'searchd is not currently running.' and return
+    end
+
+    pid = controller.pid
+    until controller.stop do
+      sleep(0.5)
+    end
+
+    puts "Stopped searchd daemon (pid: #{pid})."
+  end
+
+  private
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def controller
+    config.controller
+  end
+end

data/lib/thinking_sphinx/real_time.rb

@@ -0,0 +1,11 @@
+module ThinkingSphinx::RealTime
+  module Callbacks; end
+end
+
+require 'thinking_sphinx/real_time/property'
+require 'thinking_sphinx/real_time/attribute'
+require 'thinking_sphinx/real_time/field'
+require 'thinking_sphinx/real_time/index'
+require 'thinking_sphinx/real_time/interpreter'
+
+require 'thinking_sphinx/real_time/callbacks/real_time_callbacks'