thinking-sphinx 3.0.6 → 3.1.0

data/lib/thinking_sphinx/controller.rb

@@ -0,0 +1,20 @@
+class ThinkingSphinx::Controller < Riddle::Controller
+  def index(*indices)
+    options = indices.extract_options!
+    indices << '--all' if indices.empty?
+
+    indices = indices.reject { |index| File.exists? guard_file(index) }
+    return if indices.empty?
+
+    indices.each { |index| FileUtils.touch guard_file(index) }
+    super(*(indices + [options]))
+    indices.each { |index| FileUtils.rm guard_file(index) }
+  end
+
+  def guard_file(index)
+    File.join(
+      ThinkingSphinx::Configuration.instance.indices_location,
+      "ts-#{index}.tmp"
+    )
+  end
+end

data/lib/thinking_sphinx/core/index.rb

@@ -22,6 +22,10 @@ module ThinkingSphinx::Core::Index
     false
   end
 
+  def distributed?
+    false
+  end
+
   def document_id_for_key(key)
      key * config.indices.count + offset
   end

data/lib/thinking_sphinx/deletion.rb

@@ -1,25 +1,27 @@
 class ThinkingSphinx::Deletion
   delegate :name, :to => :index
 
-  def self.perform(index, instance)
+  def self.perform(index, ids)
+    return if index.distributed?
+
     {
       'plain' => PlainDeletion,
       'rt'    => RealtimeDeletion
-    }[index.type].new(index, instance).perform
+    }[index.type].new(index, ids).perform
   rescue ThinkingSphinx::ConnectionError => error
     # This isn't vital, so don't raise the error.
   end
 
-  def initialize(index, instance)
-    @index, @instance = index, instance
+  def initialize(index, ids)
+    @index, @ids = index, Array(ids)
   end
 
   private
 
-  attr_reader :index, :instance
+  attr_reader :index, :ids
 
-  def document_id_for_key
-    index.document_id_for_key instance.id
+  def document_ids_for_keys
+    ids.collect { |id| index.document_id_for_key id }
   end
 
   def execute(statement)
@@ -30,15 +32,17 @@ class ThinkingSphinx::Deletion
 
   class RealtimeDeletion < ThinkingSphinx::Deletion
     def perform
-      execute Riddle::Query::Delete.new(name, document_id_for_key).to_sql
+      execute Riddle::Query::Delete.new(name, document_ids_for_keys).to_sql
     end
   end
 
   class PlainDeletion < ThinkingSphinx::Deletion
     def perform
-      execute Riddle::Query.update(
-        name, document_id_for_key, :sphinx_deleted => true
-      )
+      execute <<-SQL
+UPDATE #{name}
+SET sphinx_deleted = 1
+WHERE id IN (#{document_ids_for_keys.join(', ')})
+      SQL
     end
   end
 end

data/lib/thinking_sphinx/deltas.rb

@@ -30,6 +30,15 @@ module ThinkingSphinx::Deltas
     end
   end
 
+  def self.suspend_and_update(reference, &block)
+    suspend reference, &block
+
+    ids = reference.to_s.camelize.constantize.where(delta: true).pluck(:id)
+    config.indices_for_references(reference).each do |index|
+      ThinkingSphinx::Deletion.perform index, ids unless index.delta?
+    end
+  end
+
   def self.suspend!
     @suspended = true
   end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -6,6 +6,8 @@ class ThinkingSphinx::Deltas::DefaultDelta
   end
 
   def clause(delta_source = false)
+    return nil unless delta_source
+
     "#{adapter.quoted_table_name}.#{quoted_column} = #{adapter.boolean_value delta_source}"
   end
 

data/lib/thinking_sphinx/distributed.rb

@@ -0,0 +1,5 @@
+module ThinkingSphinx::Distributed
+  #
+end
+
+require 'thinking_sphinx/distributed/index'

data/lib/thinking_sphinx/distributed/index.rb

@@ -0,0 +1,24 @@
+class ThinkingSphinx::Distributed::Index <
+  Riddle::Configuration::DistributedIndex
+
+  attr_reader :reference, :options
+
+  def initialize(reference)
+    @reference = reference
+    @options   = {}
+
+    super reference.to_s.gsub('/', '_')
+  end
+
+  def delta?
+    false
+  end
+
+  def distributed?
+    true
+  end
+
+  def model
+    @model ||= reference.to_s.camelize.constantize
+  end
+end

data/lib/thinking_sphinx/excerpter.rb

@@ -15,11 +15,10 @@ class ThinkingSphinx::Excerpter
 
   def excerpt!(text)
     result = ThinkingSphinx::Connection.take do |connection|
-      connection.query(statement_for(text)).first['snippet']
+      connection.execute(statement_for(text)).first['snippet']
     end
 
-    ThinkingSphinx::Configuration.instance.settings['utf8'] ? result :
-      ThinkingSphinx::UTF8.encode(result)
+    encoded? ? result : ThinkingSphinx::UTF8.encode(result)
   end
 
   private
@@ -27,4 +26,9 @@ class ThinkingSphinx::Excerpter
   def statement_for(text)
     Riddle::Query.snippets(text, index, words, options)
   end
+
+  def encoded?
+    ThinkingSphinx::Configuration.instance.settings['utf8'].nil? ||
+    ThinkingSphinx::Configuration.instance.settings['utf8']
+  end
 end

data/lib/thinking_sphinx/facet_search.rb

@@ -105,7 +105,7 @@ class ThinkingSphinx::FacetSearch
         ", #{ThinkingSphinx::SphinxQL.group_by}, #{ThinkingSphinx::SphinxQL.count}",
       :group_by    => facet.name,
       :indices     => index_names_for(facet),
-      :max_matches => limit,
+      :max_matches => max_matches,
       :limit       => limit
     )
   end

data/lib/thinking_sphinx/index.rb

@@ -11,16 +11,12 @@ class ThinkingSphinx::Index
     defaults = ThinkingSphinx::Configuration.instance.
       settings['index_options'] || {}
     defaults.symbolize_keys!
-    
+
     @reference, @options, @block = reference, defaults.merge(options), block
   end
 
   def indices
-    if options[:delta]
-      delta_indices
-    else
-      [single_index]
-    end
+    options[:delta] ? delta_indices : [single_index]
   end
 
   private

data/lib/thinking_sphinx/index_set.rb

@@ -19,8 +19,10 @@ class ThinkingSphinx::IndexSet
 
   private
 
+  attr_reader :classes, :configuration, :index_names
+
   def classes_and_ancestors
-    @classes_and_ancestors ||= @classes.collect { |model|
+    @classes_and_ancestors ||= classes.collect { |model|
       model.ancestors.take_while { |klass|
         klass != ActiveRecord::Base
       }.select { |klass|
@@ -30,15 +32,15 @@ class ThinkingSphinx::IndexSet
   end
 
   def indices
-    @configuration.preload_indices
-
-    return @configuration.indices.select { |index|
-      @index_names.include?(index.name)
-    } if @index_names && @index_names.any?
+    configuration.preload_indices
 
-    return @configuration.indices if @classes.empty?
+    return configuration.indices.select { |index|
+      index_names.include?(index.name)
+    } if index_names && index_names.any?
 
-    @configuration.indices_for_references(*references)
+    everything = classes.empty? ? configuration.indices :
+      configuration.indices_for_references(*references)
+    everything.reject &:distributed?
   end
 
   def references

data/lib/thinking_sphinx/middlewares.rb

@@ -15,7 +15,6 @@ module ThinkingSphinx::Middlewares
   DEFAULT = ::Middleware::Builder.new do
     use StaleIdFilter
     ThinkingSphinx::Middlewares.use self, BASE_MIDDLEWARES
-    use UTF8
     use ActiveRecordTranslator
     use StaleIdChecker
     use Glazier
@@ -23,7 +22,6 @@ module ThinkingSphinx::Middlewares
 
   RAW_ONLY = ::Middleware::Builder.new do
     ThinkingSphinx::Middlewares.use self, BASE_MIDDLEWARES
-    use UTF8
   end
 
   IDS_ONLY = ::Middleware::Builder.new do

data/lib/thinking_sphinx/middlewares/active_record_translator.rb

@@ -69,6 +69,7 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
       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]
       relation
     end
 

data/lib/thinking_sphinx/middlewares/geographer.rb

@@ -21,7 +21,7 @@ class ThinkingSphinx::Middlewares::Geographer <
     def call
       return unless geo
 
-      context[:sphinxql].values geodist_clause
+      context[:sphinxql].prepend_values geodist_clause
       context[:panes] << ThinkingSphinx::Panes::DistancePane
     end
 

data/lib/thinking_sphinx/middlewares/sphinxql.rb

@@ -1,10 +1,10 @@
 class ThinkingSphinx::Middlewares::SphinxQL <
   ThinkingSphinx::Middlewares::Middleware
 
-  SELECT_OPTIONS = [:ranker, :max_matches, :cutoff, :max_query_time,
-    :retry_count, :retry_delay, :field_weights, :index_weights, :reverse_scan,
-    :comment, :agent_query_timeout, :boolean_simplify, :global_idf, :idf,
-    :sort_method]
+  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]
 
   def call(contexts)
     contexts.each do |context|
@@ -197,7 +197,7 @@ SQL
       end
 
       def scope_by_values
-        query.values values if values.present?
+        query.values(values.present? ? values : '*')
       end
 
       def scope_by_extended_query
@@ -225,8 +225,10 @@ SQL
       end
 
       def scope_by_group
-        query.group_by group_attribute if group_attribute.present?
+        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

data/lib/thinking_sphinx/middlewares/utf8.rb

@@ -5,13 +5,18 @@ class ThinkingSphinx::Middlewares::UTF8 <
     contexts.each do |context|
       context[:results].each { |row| update_row row }
       update_row context[:meta]
-    end unless ThinkingSphinx::Configuration.instance.settings['utf8']
+    end unless encoded?
 
     app.call contexts
   end
 
   private
 
+  def encoded?
+    ThinkingSphinx::Configuration.instance.settings['utf8'].nil? ||
+    ThinkingSphinx::Configuration.instance.settings['utf8']
+  end
+
   def update_row(row)
     row.each do |key, value|
       next unless value.is_a?(String)

data/lib/thinking_sphinx/query.rb

@@ -0,0 +1,9 @@
+module ThinkingSphinx::Query
+  def self.escape(query)
+    Riddle::Query.escape query
+  end
+
+  def self.wildcard(query, pattern = true)
+    ThinkingSphinx::Wildcard.call query, pattern
+  end
+end

data/lib/thinking_sphinx/railtie.rb

@@ -7,16 +7,3 @@ class ThinkingSphinx::Railtie < Rails::Railtie
     load File.expand_path('../tasks.rb', __FILE__)
   end
 end
-
-# Add 'app/indices' path to Rails Engines
-module ThinkingSphinx::EnginePaths
-  extend ActiveSupport::Concern
-
-  included do
-    initializer :add_indices_path do
-      paths.add "app/indices"
-    end
-  end
-end
-
-Rails::Engine.send :include, ThinkingSphinx::EnginePaths

data/lib/thinking_sphinx/search/query.rb

@@ -1,8 +1,5 @@
 # encoding: utf-8
-
 class ThinkingSphinx::Search::Query
-  DEFAULT_TOKEN = /[\p{Word}\\][\p{Word}\\@]+/
-
   attr_reader :keywords, :conditions, :star
 
   def initialize(keywords = '', conditions = {}, star = false)
@@ -20,24 +17,9 @@ class ThinkingSphinx::Search::Query
   private
 
   def star_keyword(keyword, key = nil)
-    unless star && (key.nil? || key.to_s != 'sphinx_internal_class_name')
-      return keyword.to_s
-    end
+    return keyword.to_s unless star
+    return keyword.to_s if key.to_s == 'sphinx_internal_class_name'
 
-    token = star.is_a?(Regexp) ? star : DEFAULT_TOKEN
-    keyword.gsub(/("#{token}(.*?#{token})?"|(?![!-])#{token})/u) do
-      pre, proper, post = $`, $&, $'
-      # E.g. "@foo", "/2", "~3", but not as part of a token
-      is_operator = pre.match(%r{\A(\W|^)[@~/]\Z}) ||
-                    pre.match(%r{(\W|^)@\([^\)]*$})
-      # E.g. "foo bar", with quotes
-      is_quote    = proper[/^".*"$/]
-      has_star    = post[/\*$/] || pre[/^\*/]
-      if is_operator || is_quote || has_star
-        proper
-      else
-        "*#{proper}*"
-      end
-    end
+    ThinkingSphinx::Query.wildcard keyword, star
   end
 end

data/lib/thinking_sphinx/sphinxql.rb

@@ -13,5 +13,5 @@ module ThinkingSphinx::SphinxQL
     self.count    = '@count'
   end
 
-  self.variables!
+  self.functions!
 end

data/lib/thinking_sphinx/wildcard.rb

@@ -0,0 +1,34 @@
+class ThinkingSphinx::Wildcard
+  DEFAULT_TOKEN = /\p{Word}+/
+
+  def self.call(query, pattern = DEFAULT_TOKEN)
+    new(query, pattern).call
+  end
+
+  def initialize(query, pattern = DEFAULT_TOKEN)
+    @query   = query || ''
+    @pattern = pattern.is_a?(Regexp) ? pattern : DEFAULT_TOKEN
+  end
+
+  def call
+    query.gsub(/("#{pattern}(.*?#{pattern})?"|(?![!-])#{pattern})/u) do
+      pre, proper, post = $`, $&, $'
+      # E.g. "@foo", "/2", "~3", but not as part of a token pattern
+      is_operator = pre == '@' ||
+                    pre.match(%r{([^\\]+|\A)[~/]\Z}) ||
+                    pre.match(%r{(\W|^)@\([^\)]*$})
+      # E.g. "foo bar", with quotes
+      is_quote    = proper[/^".*"$/]
+      has_star    = post[/\*$/] || pre[/^\*/]
+      if is_operator || is_quote || has_star
+        proper
+      else
+        "*#{proper}*"
+      end
+    end
+  end
+
+  private
+
+  attr_reader :query, :pattern
+end

data/spec/acceptance/geosearching_spec.rb

@@ -36,4 +36,17 @@ describe 'Searching by latitude and longitude', :live => true do
       cities.first.geodist.should == 250326.906250
     end
   end
+
+  it "handles custom select clauses that refer to the distance" do
+    mel = City.create :name => 'Melbourne', :lat => -0.6599720, :lng => 2.530082
+    syd = City.create :name => 'Sydney',    :lat => -0.5909679, :lng => 2.639131
+    bri = City.create :name => 'Brisbane',  :lat => -0.4794031, :lng => 2.670838
+    index
+
+    City.search(
+      :geo  => [-0.616241, 2.602712],
+      :with => {:geodist => 0.0..470_000.0},
+      :select => "*, geodist as custom_weight"
+    ).to_a.should == [mel, syd]
+  end
 end