thinking-sphinx 3.0.3 → 3.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e4abfc7a0ce650e92e51a842336ec1028f12e9ea
+  data.tar.gz: 2c51520fcd002486f51e127f981f5e7c60000706
+SHA512:
+  metadata.gz: 384ba739298c2dc12431cf9c74e79a3f15191098d84b41afab0e94383ac9403384e9290e38c834ef17a1675eedf5835477f63c12aeeb440144421dab97e82959
+  data.tar.gz: 787f2a640087f91d7ffd7d39d1b092fb027551e6df58d2ab19062a78bfebe3b7bbbfe8ad4c65858d84fc590403eb0515296c6a5192fc3aaf6937e2f595b1ec3a

data/.gitignore

@@ -5,4 +5,5 @@ Gemfile.lock
 *.sublime-*
 pkg/*
 spec/internal/config/test.sphinx.conf
-spec/internal/db/sphinx
+spec/internal/db/sphinx
+_site

data/HISTORY

@@ -1,3 +1,28 @@
+2013-07-09: 3.0.4
+* [CHANGE] Updating Riddle dependency to be >= 1.5.7.
+* [FEATURE] ts:regenerate rake task for rebuilding Sphinx when realtime indices are involved.
+* [FEATURE] ts:clear task removes all Sphinx index and binlog files.
+* [CHANGE] Glaze now responds to respond_to? (@groe).
+* [FEATURE] Facet search calls now respect the limit option (which otherwise defaults to max_matches) (Demian Ferreiro).
+* [FEATURE] Excerpts words can be overwritten with the words option (@groe).
+* [FIX] Empty queries with the star option set to true are handled gracefully.
+* [CHANGE] Deleted ActiveRecord objects are deleted in realtime indices as well.
+* [CHANGE] Realtime callbacks are no longer automatically added, but they're now more flexible (for association situations).
+* [CHANGE] Cleaning and refactoring so Code Climate ranks this as A-level code (Philip Arndt, Shevaun Coker, Garrett Heinlen).
+* [FIX] Excerpts are now wildcard-friendly.
+* [FIX] Facet searches now use max_matches value (with a default of 1000) to ensure as many results as possible are returned.
+* [CHANGE] Exceptions raised when communicating with Sphinx are now mentioned in the logs when queries are retried (instead of STDOUT).
+* [CHANGE] Excerpts now use just the query and standard conditions, instead of parsing Sphinx's keyword metadata (which had model names in it).
+* [FIX] The settings cache is now cleared when the configuration singleton is reset (Pedro Cunha).
+* [FEATURE] The :facets option can be used in facet searches to limit which facets are queried.
+* [FIX] Escaped @'s in queries are considered part of each word, instead of word separators.
+* [FIX] Internal class name conditions are ignored with auto-starred queries.
+* [FEATURE] A separate role can be set for Sphinx actions with Capistrano (Andrey Chernih).
+* [FIX] RDoc doesn't like constant hierarchies split over multiple lines.
+* [CHANGE] Get database connection details from ActiveRecord::Base, not each model, as this is where changes are reflected.
+* [CHANGE] Default Sphinx scopes are applied to new facet searches.
+* [FEATURE] Facet searches can now be called from Sphinx scopes.
+
 2013-05-07: 3.0.3
 * [CHANGE] Updating Riddle dependency to be >= 1.5.6
 * [FEATURE] INDEX_ONLY environment flag is passed through when invoked through Capistrano (Demian Ferreiro).

data/lib/thinking_sphinx.rb

@@ -42,6 +42,7 @@ require 'thinking_sphinx/callbacks'
 require 'thinking_sphinx/core'
 require 'thinking_sphinx/configuration'
 require 'thinking_sphinx/connection'
+require 'thinking_sphinx/deletion'
 require 'thinking_sphinx/errors'
 require 'thinking_sphinx/excerpter'
 require 'thinking_sphinx/facet'

data/lib/thinking_sphinx/active_record/association_proxy.rb

@@ -2,73 +2,31 @@ module ThinkingSphinx::ActiveRecord::AssociationProxy
   extend ActiveSupport::Concern
 
   def search(query = nil, options = {})
-    query, options = nil, query if query.is_a?(Hash)
-    options[:ignore_scopes] = true
-
-    ThinkingSphinx::Search::Merger.new(super).merge! nil,
-      :with => association_filter
+    perform_search super(*normalise_search_arguments(query, options))
   end
 
   def search_for_ids(query = nil, options = {})
+    perform_search super(*normalise_search_arguments(query, options))
+  end
+
+  private
+  def normalise_search_arguments(query, options)
     query, options = nil, query if query.is_a?(Hash)
     options[:ignore_scopes] = true
 
-    ThinkingSphinx::Search::Merger.new(super).merge! nil,
-      :with => association_filter
+    [query, options]
   end
 
-  private
+  def perform_search(searcher)
+    ThinkingSphinx::Search::Merger.new(searcher).merge! nil,
+      :with => association_filter
+  end
 
   def association_filter
     attribute = AttributeFinder.new(proxy_association).attribute
 
     {attribute.name.to_sym => proxy_association.owner.id}
   end
-
-  class AttributeFinder
-    def initialize(association)
-      @association = association
-    end
-
-    def attribute
-      attributes.detect { |attribute|
-        # Don't bother with attributes built from multiple columns
-        next unless attribute.columns.length == 1
-
-        attribute.columns.first.__name == foreign_key.to_sym ||
-        attribute.name == foreign_key.to_s
-      } or raise "Missing Attribute for Foreign Key #{foreign_key}"
-    end
-
-    private
-
-    def attributes
-      sources.collect(&:attributes).flatten
-    end
-
-    def configuration
-      ThinkingSphinx::Configuration.instance
-    end
-
-    def foreign_key
-      @foreign_key ||= if @association.reflection.through_reflection
-        @association.reflection.through_reflection.foreign_key
-      else
-        @association.reflection.foreign_key
-      end
-    end
-
-    def indices
-      @indices ||= begin
-        configuration.preload_indices
-        configuration.indices_for_references(
-          *@association.klass.name.underscore.to_sym
-        )
-      end
-    end
-
-    def sources
-      indices.collect(&:sources).flatten
-    end
-  end
 end
+
+require 'thinking_sphinx/active_record/association_proxy/attribute_finder'

data/lib/thinking_sphinx/active_record/association_proxy/attribute_finder.rb

@@ -0,0 +1,47 @@
+class ThinkingSphinx::ActiveRecord::AssociationProxy::AttributeFinder
+  def initialize(association)
+    @association = association
+  end
+
+  def attribute
+    attributes.detect { |attribute|
+      # Don't bother with attributes built from multiple columns
+      next if attribute.columns.many?
+
+      attribute.columns.first.__name == foreign_key.to_sym ||
+      attribute.name == foreign_key.to_s
+    } or raise "Missing Attribute for Foreign Key #{foreign_key}"
+  end
+
+  private
+  def attributes
+    sources.collect(&:attributes).flatten
+  end
+
+  def configuration
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def foreign_key
+    @foreign_key ||= reflection_target.foreign_key
+  end
+
+  def indices
+    @indices ||= begin
+      configuration.preload_indices
+      configuration.indices_for_references(
+        *@association.klass.name.underscore.to_sym
+      )
+    end
+  end
+
+  def reflection_target
+    target = @association.reflection
+    target = target.through_reflection if target.through_reflection
+    target
+  end
+
+  def sources
+    indices.collect(&:sources).flatten
+  end
+end

data/lib/thinking_sphinx/active_record/base.rb

@@ -7,30 +7,17 @@ module ThinkingSphinx::ActiveRecord::Base
     after_update  ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks
     after_commit  ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
 
-    after_save    ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks
-
     ::ActiveRecord::Associations::CollectionProxy.send :include,
       ThinkingSphinx::ActiveRecord::AssociationProxy
   end
 
   module ClassMethods
     def facets(query = nil, options = {})
-      search = ThinkingSphinx.facets query, options
-      ThinkingSphinx::Search::Merger.new(search).merge! nil, :classes => [self]
+      merge_search ThinkingSphinx.facets, query, options
     end
 
     def search(query = nil, options = {})
-      merger = ThinkingSphinx::Search::Merger.new ThinkingSphinx.search
-
-      merger.merge! *default_sphinx_scope_response if default_sphinx_scope?
-      merger.merge! query, options
-
-      if current_scope && !merger.search.options[:ignore_scopes]
-        raise ThinkingSphinx::MixedScopesError,
-          'You cannot search with Sphinx through ActiveRecord scopes'
-      end
-
-      merger.merge! nil, :classes => [self]
+      merge_search ThinkingSphinx.search, query, options
     end
 
     def search_count(query = nil, options = {})
@@ -51,5 +38,19 @@ module ThinkingSphinx::ActiveRecord::Base
     def default_sphinx_scope_response
       [sphinx_scopes[default_sphinx_scope].call].flatten
     end
+
+    def merge_search(search, query, options)
+      merger = ThinkingSphinx::Search::Merger.new search
+
+      merger.merge! *default_sphinx_scope_response if default_sphinx_scope?
+      merger.merge! query, options
+
+      if current_scope && !merger.search.options[:ignore_scopes]
+        raise ThinkingSphinx::MixedScopesError,
+          'You cannot search with Sphinx through ActiveRecord scopes'
+      end
+
+      merger.merge! nil, :classes => [self]
+    end
   end
 end

data/lib/thinking_sphinx/active_record/callbacks/delete_callbacks.rb

@@ -4,14 +4,7 @@ class ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks <
   callbacks :after_destroy
 
   def after_destroy
-    indices.each do |index|
-      connection.execute Riddle::Query.update(
-        index.name, index.document_id_for_key(instance.id),
-        :sphinx_deleted => true
-      )
-    end
-  rescue Mysql2::Error => error
-    # This isn't vital, so don't raise the error.
+    indices.each { |index| ThinkingSphinx::Deletion.perform index, instance }
   end
 
   private
@@ -20,10 +13,6 @@ class ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks <
     ThinkingSphinx::Configuration.instance
   end
 
-  def connection
-    @connection ||= ThinkingSphinx::Connection.new
-  end
-
   def indices
     config.preload_indices
     config.indices_for_references instance.class.name.underscore.to_sym

data/lib/thinking_sphinx/active_record/database_adapters.rb

@@ -1,55 +1,54 @@
 module ThinkingSphinx::ActiveRecord::DatabaseAdapters
-  def self.adapter_for(model)
-    return default.new(model) unless default.nil?
-
-    adapter = adapter_type_for(model)
-    klass   = case adapter
-    when :mysql
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter
-    when :postgresql
-      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter
-    else
-      raise "Invalid Database Adapter '#{adapter}': Thinking Sphinx only supports MySQL and PostgreSQL."
-    end
+  class << self
+    attr_accessor :default
 
-    klass.new model
-  end
+    def adapter_for(model)
+      return default.new(model) if default
+
+      adapter = adapter_type_for(model)
+      klass   = case adapter
+      when :mysql
+        MySQLAdapter
+      when :postgresql
+        PostgreSQLAdapter
+      else
+        raise "Invalid Database Adapter '#{adapter}': Thinking Sphinx only supports MySQL and PostgreSQL."
+      end
+
+      klass.new model
+    end
 
-  def self.adapter_type_for(model)
-    case model.connection.class.name
-    when "ActiveRecord::ConnectionAdapters::MysqlAdapter",
-         "ActiveRecord::ConnectionAdapters::Mysql2Adapter"
-      :mysql
-    when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-      :postgresql
-    when "ActiveRecord::ConnectionAdapters::JdbcAdapter"
-      case model.connection.config[:adapter]
-      when "jdbcmysql"
+    def adapter_type_for(model)
+      class_name = model.connection.class.name
+      case class_name.split('::').last
+      when 'MysqlAdapter', 'Mysql2Adapter'
         :mysql
-      when "jdbcpostgresql"
+      when 'PostgreSQLAdapter'
         :postgresql
-      when "jdbc"
-        match = /^jdbc:(?<adapter>mysql|postgresql):\/\//.match(model.connection.config[:url])
-        if match
-          match[:adapter].to_sym
-        else
-          model.connection.config[:adapter]
-        end
+      when 'JdbcAdapter'
+        adapter_type_for_jdbc(model)
       else
-        model.connection.config[:adapter]
+        class_name
       end
-    else
-      model.connection.class.name
     end
-  end
 
-  @default = nil
-  def self.default
-    @default
-  end
+    def adapter_type_for_jdbc(model)
+      case adapter = model.connection.config[:adapter]
+      when 'jdbcmysql'
+        :mysql
+      when 'jdbcpostgresql'
+        :postgresql
+      when 'jdbc'
+        adapter_type_for_jdbc_plain(adapter, model.connection.config[:url])
+      else adapter
+      end
+    end
+
+    def adapter_type_for_jdbc_plain(adapter, url)
+      return adapter unless match = /^jdbc:(?<adapter>mysql|postgresql):\/\//.match(url)
 
-  def self.default=(default)
-    @default = default
+      match[:adapter].to_sym
+    end
   end
 end
 

data/lib/thinking_sphinx/active_record/polymorpher.rb

@@ -14,11 +14,16 @@ class ThinkingSphinx::ActiveRecord::Polymorpher
 
   def append_reflections
     mappings.each do |class_name, name|
-      klass.reflections[name] ||= ThinkingSphinx::ActiveRecord::
-        FilteredReflection.clone_with_filter(reflection, name, class_name)
+      klass.reflections[name] ||= clone_with name, class_name
     end
   end
 
+  def clone_with(name, class_name)
+    ThinkingSphinx::ActiveRecord::FilteredReflection.clone_with_filter(
+      reflection, name, class_name
+    )
+  end
+
   def mappings
     @mappings ||= class_names.inject({}) do |hash, class_name|
       hash[class_name] = "#{column.__name}_#{class_name.downcase}".to_sym

data/lib/thinking_sphinx/active_record/property_query.rb

@@ -5,6 +5,13 @@ class ThinkingSphinx::ActiveRecord::PropertyQuery
 
   def to_s
     identifier = [type, property.name].compact.join(' ')
+
+    "#{identifier} from #{source_type}; #{queries.join('; ')}"
+  end
+
+  private
+
+  def queries
     queries    = []
     if column.string?
       queries << column.__name.strip.gsub(/\n/, "\\\n")
@@ -12,18 +19,20 @@ class ThinkingSphinx::ActiveRecord::PropertyQuery
       queries << to_sql
       queries << range_sql if ranged?
     end
-
-    "#{identifier} from #{source_type}; #{queries.join('; ')}"
+    queries
   end
 
-  private
-
   attr_reader :property, :source, :type
 
   def base_association
     reflections.first
   end
 
+  def base_association_class
+    base_association.klass
+  end
+  delegate :relation, :to => :base_association_class, :prefix => true
+
   def column
     @column ||= property.columns.first
   end
@@ -40,7 +49,7 @@ class ThinkingSphinx::ActiveRecord::PropertyQuery
 
       column.__stack.collect { |key|
         reflection = base.reflections[key]
-        base       = reflection.klass
+        base = reflection.klass
 
         extend_reflection reflection
       }.flatten
@@ -64,12 +73,11 @@ class ThinkingSphinx::ActiveRecord::PropertyQuery
   end
 
   def quoted_foreign_key
-    quote_with_table base_association.klass.table_name,
-      base_association.foreign_key
+    quote_with_table(base_association_class.table_name, base_association.foreign_key)
   end
 
   def quoted_primary_key
-    quote_with_table reflections.last.klass.table_name, column.__name
+    quote_with_table(reflections.last.klass.table_name, column.__name)
   end
 
   def quote_with_table(table, column)
@@ -85,8 +93,9 @@ class ThinkingSphinx::ActiveRecord::PropertyQuery
   end
 
   def range_sql
-    base_association.klass.unscoped.
-      select("MIN(#{quoted_foreign_key}), MAX(#{quoted_foreign_key})").to_sql
+    base_association_class_relation.select(
+      "MIN(#{quoted_foreign_key}), MAX(#{quoted_foreign_key})"
+    ).to_sql
   end
 
   def source_type
@@ -96,15 +105,10 @@ class ThinkingSphinx::ActiveRecord::PropertyQuery
   def to_sql
     raise "Could not determine SQL for MVA" if reflections.empty?
 
-    relation = base_association.klass.unscoped
-    relation = relation.joins joins unless joins.blank?
-    relation = relation.select "#{quoted_foreign_key} #{offset} AS #{quote_column('id')}, #{quoted_primary_key} AS #{quote_column(property.name)}"
-
-    if ranged?
-      relation = relation.where("#{quoted_foreign_key} >= $start")
-      relation = relation.where("#{quoted_foreign_key} <= $end")
-    end
-
+    relation = base_association_class_relation.select("#{quoted_foreign_key} #{offset} AS #{quote_column('id')}, #{quoted_primary_key} AS #{quote_column(property.name)}"
+    )
+    relation = relation.joins(joins) if joins.present?
+    relation = relation.where("#{quoted_foreign_key} BETWEEN $start AND $end") if ranged?
     relation = relation.order("#{quoted_foreign_key} ASC") if type.nil?
 
     relation.to_sql