thinking-sphinx 3.1.4 → 6.0.0

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

@@ -1,10 +1,18 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks <
   ThinkingSphinx::Callbacks
 
+  if ActiveRecord::Base.instance_methods.grep(/saved_changes/).any?
+    CHANGED_ATTRIBUTES = lambda { |instance| instance.saved_changes.keys }
+  else
+    CHANGED_ATTRIBUTES = lambda { |instance| instance.changed }
+  end
+
   callbacks :after_update
 
   def after_update
-    return unless updates_enabled?
+    return unless !ThinkingSphinx::Callbacks.suspended? && updates_enabled?
 
     indices.each do |index|
       update index unless index.distributed?
@@ -15,7 +23,7 @@ class ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks <
 
   def attributes_hash_for(index)
     updateable_attributes_for(index).inject({}) do |hash, attribute|
-      if instance.changed.include?(attribute.columns.first.__name.to_s)
+      if changed_attributes.include?(attribute.columns.first.__name.to_s)
         hash[attribute.name] = attribute.value_for(instance)
       end
 
@@ -23,6 +31,10 @@ class ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks <
     end
   end
 
+  def changed_attributes
+    @changed_attributes ||= CHANGED_ATTRIBUTES.call instance
+  end
+
   def configuration
     ThinkingSphinx::Configuration.instance
   end
@@ -35,7 +47,7 @@ class ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks <
   end
 
   def reference
-    instance.class.name.underscore.to_sym
+    configuration.index_set_class.reference_name(instance.class)
   end
 
   def update(index)
@@ -43,7 +55,9 @@ class ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks <
     return if attributes.empty?
 
     sphinxql = Riddle::Query.update(
-      index.name, index.document_id_for_key(instance.id), attributes
+      index.name,
+      index.document_id_for_key(instance.public_send(index.primary_key)),
+      attributes
     )
     ThinkingSphinx::Connection.take do |connection|
       connection.execute(sphinxql)

data/lib/thinking_sphinx/active_record/column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::Column
   def initialize(*stack)
     @stack = stack

data/lib/thinking_sphinx/active_record/column_sql_presenter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::ColumnSQLPresenter
   def initialize(model, column, adapter, associations)
     @model, @column, @adapter, @associations = model, column, adapter, associations
@@ -13,7 +15,7 @@ class ThinkingSphinx::ActiveRecord::ColumnSQLPresenter
     return __name if string?
     return nil unless exists?
 
-    quoted_table = escape_table? ? adapter.quote(table) : table
+    quoted_table = escape_table? ? escape_table(table) : table
 
     "#{quoted_table}.#{adapter.quote __name}"
   end
@@ -24,6 +26,10 @@ class ThinkingSphinx::ActiveRecord::ColumnSQLPresenter
 
   delegate :__stack, :__name, :string?, :to => :column
 
+  def escape_table(table_name)
+    table_name.split('.').map { |t| adapter.quote(t) }.join('.')
+  end
+
   def escape_table?
     table[/[`"]/].nil?
   end

data/lib/thinking_sphinx/active_record/database_adapters/abstract_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
   def initialize(model)
     @model = model

data/lib/thinking_sphinx/active_record/database_adapters/mysql_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter <
   ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
 
@@ -38,6 +40,12 @@ class ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter <
   end
 
   def utf8_query_pre
-    ['SET NAMES utf8']
+    ["SET NAMES #{settings['mysql_encoding']}"]
+  end
+
+  private
+
+  def settings
+    ThinkingSphinx::Configuration.instance.settings
   end
 end

data/lib/thinking_sphinx/active_record/database_adapters/postgresql_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter <
   ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
 

data/lib/thinking_sphinx/active_record/database_adapters.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx::ActiveRecord::DatabaseAdapters
   class << self
     attr_accessor :default
@@ -12,7 +14,7 @@ module ThinkingSphinx::ActiveRecord::DatabaseAdapters
       when :postgresql
         PostgreSQLAdapter
       else
-        raise "Invalid Database Adapter '#{adapter}': Thinking Sphinx only supports MySQL and PostgreSQL."
+        raise ThinkingSphinx::InvalidDatabaseAdapter, "Invalid adapter '#{adapter}': Thinking Sphinx only supports MySQL and PostgreSQL."
       end
 
       klass.new model

data/lib/thinking_sphinx/active_record/depolymorph/association_reflection.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# This custom association approach is only available in Rails 4.1-5.1. This
+# behaviour is superseded by OverriddenReflection for Rails 5.2, and was
+# preceded by ScopedReflection for Rails 4.0.
+class ThinkingSphinx::ActiveRecord::Depolymorph::AssociationReflection <
+  ThinkingSphinx::ActiveRecord::Depolymorph::BaseReflection
+
+  # Since Rails 4.2, the macro argument has been removed. The underlying
+  # behaviour remains the same, though.
+  def call
+    if explicit_macro?
+      klass.new name, nil, options, reflection.active_record
+    else
+      klass.new reflection.macro, name, nil, options, reflection.active_record
+    end
+  end
+
+  private
+
+  def explicit_macro?
+    ActiveRecord::Reflection::MacroReflection.instance_method(:initialize).
+      arity == 4
+  end
+
+  def options
+    super
+
+    @options[:sphinx_internal_filtered] = true
+    @options
+  end
+end

data/lib/thinking_sphinx/active_record/depolymorph/base_reflection.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Depolymorph::BaseReflection
+  def initialize(reflection, name, class_name)
+    @reflection = reflection
+    @name       = name
+    @class_name = class_name
+
+    @options = reflection.options.clone
+  end
+
+  def call
+    # Should be implemented by subclasses.
+  end
+
+  private
+
+  attr_reader :reflection, :name, :class_name
+
+  def klass
+    reflection.class
+  end
+
+  def options
+    @options.delete :polymorphic
+    @options[:class_name]    = class_name
+    @options[:foreign_key] ||= "#{reflection.name}_id"
+    @options[:foreign_type]  = reflection.foreign_type
+
+    @options
+  end
+end

data/lib/thinking_sphinx/active_record/depolymorph/conditions_reflection.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# The conditions approach is only available in Rails 3. This behaviour is
+# superseded by ScopedReflection for Rails 4.0.
+class ThinkingSphinx::ActiveRecord::Depolymorph::ConditionsReflection <
+  ThinkingSphinx::ActiveRecord::Depolymorph::BaseReflection
+
+  def call
+    klass.new reflection.macro, name, options, active_record
+  end
+
+  private
+
+  delegate :foreign_type, :active_record, :to => :reflection
+
+  def condition
+    "::ts_join_alias::.#{quoted_foreign_type} = '#{class_name}'"
+  end
+
+  def options
+    super
+
+    case @options[:conditions]
+    when nil
+      @options[:conditions] = condition
+    when Array
+      @options[:conditions] << condition
+    when Hash
+      @options[:conditions].merge! foreign_type => @options[:class_name]
+    else
+      @options[:conditions] = "#{@options[:conditions]} AND #{condition}"
+    end
+
+    @options
+  end
+
+  def quoted_foreign_type
+    active_record.connection.quote_column_name foreign_type
+  end
+end

data/lib/thinking_sphinx/active_record/depolymorph/overridden_reflection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# This overriding approach is only available in Rails 5.2+. This behaviour
+# was preceded by AssociationReflection for Rails 4.1-5.1.
+class ThinkingSphinx::ActiveRecord::Depolymorph::OverriddenReflection <
+  ThinkingSphinx::ActiveRecord::Depolymorph::BaseReflection
+
+  module BuildJoinConstraint
+    def build_join_constraint(table, foreign_table)
+      super.and(
+        foreign_table[options[:foreign_type]].eq(
+          options[:class_name].constantize.base_class.name
+        )
+      )
+    end
+  end
+
+  module JoinScope
+    def join_scope(table, foreign_table, foreign_klass)
+      super.where(
+        foreign_table[options[:foreign_type]].eq(
+          options[:class_name].constantize.base_class.name
+        )
+      )
+    end
+  end
+
+  def self.overridden_classes
+    @overridden_classes ||= {}
+  end
+
+  def call
+    klass.new name, nil, options, reflection.active_record
+  end
+
+  private
+
+  def klass
+    self.class.overridden_classes[reflection.class] ||= begin
+      subclass = Class.new reflection.class
+      subclass.include extension(reflection)
+      subclass
+    end
+  end
+
+  def extension(reflection)
+    reflection.respond_to?(:build_join_constraint) ?
+      BuildJoinConstraint : JoinScope
+  end
+end

data/lib/thinking_sphinx/active_record/depolymorph/scoped_reflection.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This scoped approach is only available in Rails 4.0. This behaviour is
+# superseded by AssociationReflection for Rails 4.1, and was preceded by
+# ConditionsReflection for Rails 3.2.
+class ThinkingSphinx::ActiveRecord::Depolymorph::ScopedReflection <
+  ThinkingSphinx::ActiveRecord::Depolymorph::BaseReflection
+
+  def call
+    klass.new reflection.macro, name, scope, options,
+      reflection.active_record
+  end
+
+  private
+
+  def scope
+    lambda { |association|
+      reflection = association.reflection
+      klass      = reflection.class_name.constantize
+      where(
+        association.parent.aliased_table_name.to_sym =>
+        {reflection.foreign_type => klass.base_class.name}
+      )
+    }
+  end
+end

data/lib/thinking_sphinx/active_record/field.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::Field <
   ThinkingSphinx::ActiveRecord::Property
   include ThinkingSphinx::Core::Field

data/lib/thinking_sphinx/active_record/filter_reflection.rb

@@ -1,76 +1,18 @@
-class ThinkingSphinx::ActiveRecord::FilterReflection
-  attr_reader :reflection, :class_name
-
-  delegate :foreign_type, :active_record, :to => :reflection
-
-  def self.call(reflection, name, class_name)
-    filter = new(reflection, class_name)
-    klass  = reflection.class
-    arity  = klass.instance_method(:initialize).arity
-
-    if defined?(ActiveRecord::Reflection::MacroReflection) && arity == 4
-      klass.new name, filter.scope, filter.options, reflection.active_record
-    elsif reflection.respond_to?(:scope)
-      klass.new reflection.macro, name, filter.scope, filter.options,
-        reflection.active_record
-    else
-      klass.new reflection.macro, name, filter.options,
-        reflection.active_record
-    end
-  end
-
-  def initialize(reflection, class_name)
-    @reflection, @class_name = reflection, class_name
-    @options = reflection.options.clone
-  end
-
-  def options
-    @options.delete :polymorphic
-    @options[:class_name]    = class_name
-    @options[:foreign_key] ||= "#{reflection.name}_id"
-    @options[:foreign_type]  = reflection.foreign_type
-
-    if reflection.respond_to?(:scope)
-      @options[:sphinx_internal_filtered] = true
-      return @options
-    end
+# frozen_string_literal: true
 
-    case @options[:conditions]
-    when nil
-      @options[:conditions] = condition
-    when Array
-      @options[:conditions] << condition
-    when Hash
-      @options[:conditions].merge!(reflection.foreign_type => @options[:class_name])
-    else
-      @options[:conditions] << " AND #{condition}"
-    end
-
-    @options
-  end
-
-  def scope
-    if ::Joiner::Joins.instance_methods.include?(:join_association_class)
-      return nil
-    end
-
-    lambda { |association|
-      reflection = association.reflection
-      klass      = reflection.class_name.constantize
-      where(
-        association.parent.aliased_table_name.to_sym =>
-        {reflection.foreign_type => klass.base_class.name}
-      )
-    }
-  end
-
-  private
-
-  def condition
-    "::ts_join_alias::.#{quoted_foreign_type} = '#{class_name}'"
+class ThinkingSphinx::ActiveRecord::FilterReflection
+  ReflectionGenerator = case ActiveRecord::VERSION::STRING.to_f
+  when (5.2..)
+    ThinkingSphinx::ActiveRecord::Depolymorph::OverriddenReflection
+  when 4.1..5.1
+    ThinkingSphinx::ActiveRecord::Depolymorph::AssociationReflection
+  when 4.0
+    ThinkingSphinx::ActiveRecord::Depolymorph::ScopedReflection
+  when 3.2
+    ThinkingSphinx::ActiveRecord::Depolymorph::ConditionsReflection
   end
 
-  def quoted_foreign_type
-    active_record.connection.quote_column_name foreign_type
+  def self.call(reflection, name, class_name)
+    ReflectionGenerator.new(reflection, name, class_name).call
   end
 end

data/lib/thinking_sphinx/active_record/index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::Index < Riddle::Configuration::Index
   include ThinkingSphinx::Core::Index
 
@@ -28,6 +30,10 @@ class ThinkingSphinx::ActiveRecord::Index < Riddle::Configuration::Index
     @facets ||= sources.collect(&:facets).flatten
   end
 
+  def fields
+    sources.collect(&:fields).flatten
+  end
+
   def sources
     interpret_definition!
     super
@@ -44,10 +50,6 @@ class ThinkingSphinx::ActiveRecord::Index < Riddle::Configuration::Index
       adapter_for(model)
   end
 
-  def fields
-    sources.collect(&:fields).flatten
-  end
-
   def interpreter
     ThinkingSphinx::ActiveRecord::Interpreter
   end
@@ -63,7 +65,7 @@ class ThinkingSphinx::ActiveRecord::Index < Riddle::Configuration::Index
       :delta?          => @options[:delta?],
       :delta_processor => @options[:delta_processor],
       :delta_options   => @options[:delta_options],
-      :primary_key     => @options[:primary_key] || model.primary_key || :id
+      :primary_key     => primary_key
     }
   end
 end

data/lib/thinking_sphinx/active_record/interpreter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::Interpreter <
   ::ThinkingSphinx::Core::Interpreter
 
@@ -11,15 +13,15 @@ class ThinkingSphinx::ActiveRecord::Interpreter <
   end
 
   def has(*columns)
-    __source.attributes += build_properties(
+    build_properties(
       ::ThinkingSphinx::ActiveRecord::Attribute, columns
-    )
+    ).each { |attribute| __source.add_attribute attribute }
   end
 
   def indexes(*columns)
-    __source.fields += build_properties(
+    build_properties(
       ::ThinkingSphinx::ActiveRecord::Field, columns
-    )
+    ).each { |field| __source.add_field field }
   end
 
   def join(*columns)

data/lib/thinking_sphinx/active_record/join_association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::JoinAssociation <
   ::ActiveRecord::Associations::JoinDependency::JoinAssociation
 
@@ -5,7 +7,9 @@ class ThinkingSphinx::ActiveRecord::JoinAssociation <
     constraint = super
 
     constraint = constraint.and(
-      foreign_table[reflection.options[:foreign_type]].eq(base_klass.name)
+      foreign_table[reflection.options[:foreign_type]].eq(
+        base_klass.base_class.name
+      )
     ) if reflection.options[:sphinx_internal_filtered]
 
     constraint

data/lib/thinking_sphinx/active_record/log_subscriber.rb

@@ -1,18 +1,37 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::LogSubscriber < ActiveSupport::LogSubscriber
   def guard(event)
-    identifier = color 'Sphinx', GREEN, true
+    identifier = colored_text "Sphinx"
     warn "  #{identifier}  #{event.payload[:guard]}"
   end
 
   def message(event)
-    identifier = color 'Sphinx', GREEN, true
+    identifier = colored_text "Sphinx"
     debug "  #{identifier}  #{event.payload[:message]}"
   end
 
   def query(event)
-    identifier = color('Sphinx Query (%.1fms)' % event.duration, GREEN, true)
+    identifier = colored_text("Sphinx Query (%.1fms)" % event.duration)
     debug "  #{identifier}  #{event.payload[:query]}"
   end
+
+  def caution(event)
+    identifier = colored_text "Sphinx"
+    warn "  #{identifier}  #{event.payload[:caution]}"
+  end
+
+  private
+
+  if Rails.gem_version >= Gem::Version.new("7.1.0")
+    def colored_text(text)
+      color text, GREEN, bold: true
+    end
+  else
+    def colored_text(text)
+      color text, GREEN, true
+    end
+  end
 end
 
 ThinkingSphinx::ActiveRecord::LogSubscriber.attach_to :thinking_sphinx

data/lib/thinking_sphinx/active_record/polymorpher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::Polymorpher
   def initialize(source, column, class_names)
     @source, @column, @class_names = source, column, class_names

data/lib/thinking_sphinx/active_record/property.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::Property
   include ThinkingSphinx::Core::Property
 

data/lib/thinking_sphinx/active_record/property_query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::PropertyQuery
   def initialize(property, source, type = nil)
     @property, @source, @type = property, source, type
@@ -25,6 +27,7 @@ primary key.
   attr_reader :property, :source, :type
 
   delegate :unscoped, :to => :base_association_class, :prefix => true
+  delegate :sql,      :to => Arel
 
   def base_association
     reflections.first
@@ -133,7 +136,7 @@ primary key.
     relation = relation.joins(joins) if joins.present?
     relation = relation.where("#{quoted_foreign_key} BETWEEN $start AND $end") if ranged?
     relation = relation.where("#{quoted_foreign_key} IS NOT NULL")
-    relation = relation.order("#{quoted_foreign_key} ASC") if type.nil?
+    relation = relation.order(sql("#{quoted_foreign_key} ASC")) if type.nil?
 
     relation.to_sql
   end

data/lib/thinking_sphinx/active_record/property_sql_presenter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::PropertySQLPresenter
   attr_reader :property, :adapter, :associations
 

data/lib/thinking_sphinx/active_record/simple_many_query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ThinkingSphinx::ActiveRecord::SimpleManyQuery <
   ThinkingSphinx::ActiveRecord::PropertyQuery
 

data/lib/thinking_sphinx/active_record/source_joins.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::SourceJoins
+  def self.call(model, source)
+    new(model, source).call
+  end
+
+  def initialize(model, source)
+    @model, @source = model, source
+  end
+
+  def call
+    append_specified_associations
+    append_property_associations
+
+    joins
+  end
+
+  private
+
+  attr_reader :model, :source
+
+  def append_property_associations
+    source.properties.collect(&:columns).each do |columns|
+      columns.each { |column| append_column_associations column }
+    end
+  end
+
+  def append_column_associations(column)
+    return if column.__stack.empty? or column_included_in_queries?(column)
+
+    joins.add_join_to column.__stack if column_exists?(column)
+  end
+
+  def append_specified_associations
+    source.associations.reject(&:string?).each do |association|
+      joins.add_join_to association.stack
+    end
+  end
+
+  def column_exists?(column)
+    Joiner::Path.new(model, column.__stack).model
+    true
+  rescue Joiner::AssociationNotFound
+    false
+  end
+
+  def joins
+    @joins ||= begin
+      joins = Joiner::Joins.new model
+      if joins.respond_to?(:join_association_class)
+        joins.join_association_class = ThinkingSphinx::ActiveRecord::JoinAssociation
+      end
+      joins
+    end
+  end
+
+  def source_query_properties
+    source.properties.select { |field| field.source_type == :query }
+  end
+
+  # Use "first" here instead of a more intuitive flatten because flatten
+  # will also ask each column to become an Array and that will start
+  # to retrieve data.
+  def column_included_in_queries?(column)
+    source_query_properties.collect(&:columns).collect(&:first).include?(column)
+  end
+end

data/lib/thinking_sphinx/active_record/sql_builder/clause_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module ActiveRecord
     class SQLBuilder::ClauseBuilder