thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/active_record/database_adapters.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::ActiveRecord::DatabaseAdapters
+  class << self
+    attr_accessor :default
+
+    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 ThinkingSphinx::InvalidDatabaseAdapter, "Invalid adapter '#{adapter}': Thinking Sphinx only supports MySQL and PostgreSQL."
+      end
+
+      klass.new model
+    end
+
+    def adapter_type_for(model)
+      class_name = model.connection.class.name
+      case class_name.split('::').last
+      when 'MysqlAdapter', 'Mysql2Adapter'
+        :mysql
+      when 'PostgreSQLAdapter'
+        :postgresql
+      when 'JdbcAdapter'
+        adapter_type_for_jdbc(model)
+      else
+        class_name
+      end
+    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)
+
+      match[:adapter].to_sym
+    end
+  end
+end
+
+require 'thinking_sphinx/active_record/database_adapters/abstract_adapter'
+require 'thinking_sphinx/active_record/database_adapters/mysql_adapter'
+require 'thinking_sphinx/active_record/database_adapters/postgresql_adapter'

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Field <
+  ThinkingSphinx::ActiveRecord::Property
+  include ThinkingSphinx::Core::Field
+
+  def file?
+    options[:file]
+  end
+
+  def with_attribute?
+    options[:sortable] || options[:facet]
+  end
+
+  def wordcount?
+    options[:wordcount]
+  end
+end

data/lib/thinking_sphinx/active_record/filter_reflection.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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 self.call(reflection, name, class_name)
+    ReflectionGenerator.new(reflection, name, class_name).call
+  end
+end

data/lib/thinking_sphinx/active_record/index.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Index < Riddle::Configuration::Index
+  include ThinkingSphinx::Core::Index
+
+  attr_reader :reference
+  attr_writer :definition_block
+
+  def append_source
+    ThinkingSphinx::ActiveRecord::SQLSource.new(
+      model, source_options.merge(:position => sources.length)
+    ).tap do |source|
+      sources << source
+    end
+  end
+
+  def attributes
+    sources.collect(&:attributes).flatten
+  end
+
+  def delta?
+    @options[:delta?]
+  end
+
+  def delta_processor
+    @options[:delta_processor].try(:new, adapter, @options[:delta_options] || {})
+  end
+
+  def facets
+    @facets ||= sources.collect(&:facets).flatten
+  end
+
+  def fields
+    sources.collect(&:fields).flatten
+  end
+
+  def sources
+    interpret_definition!
+    super
+  end
+
+  def unique_attribute_names
+    attributes.collect(&:name)
+  end
+
+  private
+
+  def adapter
+    @adapter ||= ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+      adapter_for(model)
+  end
+
+  def interpreter
+    ThinkingSphinx::ActiveRecord::Interpreter
+  end
+
+  def name_suffix
+    @options[:delta?] ? 'delta' : 'core'
+  end
+
+  def source_options
+    {
+      :name            => name,
+      :offset          => offset,
+      :delta?          => @options[:delta?],
+      :delta_processor => @options[:delta_processor],
+      :delta_options   => @options[:delta_options],
+      :primary_key     => primary_key
+    }
+  end
+end

data/lib/thinking_sphinx/active_record/interpreter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Interpreter <
+  ::ThinkingSphinx::Core::Interpreter
+
+  def define_source(&block)
+    @source = @index.append_source
+    instance_eval &block
+  end
+
+  def group_by(*columns)
+    __source.groupings += columns
+  end
+
+  def has(*columns)
+    build_properties(
+      ::ThinkingSphinx::ActiveRecord::Attribute, columns
+    ).each { |attribute| __source.add_attribute attribute }
+  end
+
+  def indexes(*columns)
+    build_properties(
+      ::ThinkingSphinx::ActiveRecord::Field, columns
+    ).each { |field| __source.add_field field }
+  end
+
+  def join(*columns)
+    __source.associations += columns.collect { |column|
+      ::ThinkingSphinx::ActiveRecord::Association.new column
+    }
+  end
+
+  def polymorphs(column, options)
+    __source.polymorphs << ::ThinkingSphinx::ActiveRecord::Polymorpher.new(
+      __source, column, options[:to]
+    )
+  end
+
+  def sanitize_sql(*arguments)
+    __source.model.send :sanitize_sql, *arguments
+  end
+
+  def set_database(hash_or_key)
+    configuration = hash_or_key.is_a?(::Hash) ? hash_or_key :
+      ::ActiveRecord::Base.configurations[hash_or_key.to_s]
+
+    __source.set_database_settings configuration.symbolize_keys
+  end
+
+  def set_property(properties)
+    properties.each do |key, value|
+      @index.send("#{key}=", value)   if @index.class.settings.include?(key)
+      __source.send("#{key}=", value) if __source.class.settings.include?(key)
+      __source.options[key] = value   if source_option?(key)
+      @index.options[key] = value     if search_option?(key)
+    end
+  end
+
+  def where(*conditions)
+    __source.conditions += conditions
+  end
+
+  private
+
+  def __source
+    @source ||= @index.append_source
+  end
+
+  def build_properties(klass, columns)
+    options = columns.extract_options!
+    columns.collect { |column| klass.new(__source.model, column, options) }
+  end
+
+  def source_option?(key)
+    ::ThinkingSphinx::ActiveRecord::SQLSource::OPTIONS.include?(key)
+  end
+end

data/lib/thinking_sphinx/active_record/join_association.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::JoinAssociation <
+  ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+
+  def build_constraint(klass, table, key, foreign_table, foreign_key)
+    constraint = super
+
+    constraint = constraint.and(
+      foreign_table[reflection.options[:foreign_type]].eq(
+        base_klass.base_class.name
+      )
+    ) if reflection.options[:sphinx_internal_filtered]
+
+    constraint
+  end
+end

data/lib/thinking_sphinx/active_record/log_subscriber.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::LogSubscriber < ActiveSupport::LogSubscriber
+  def guard(event)
+    identifier = colored_text "Sphinx"
+    warn "  #{identifier}  #{event.payload[:guard]}"
+  end
+
+  def message(event)
+    identifier = colored_text "Sphinx"
+    debug "  #{identifier}  #{event.payload[:message]}"
+  end
+
+  def query(event)
+    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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Polymorpher
+  def initialize(source, column, class_names)
+    @source, @column, @class_names = source, column, class_names
+  end
+
+  def morph!
+    append_reflections
+    morph_properties
+  end
+
+  private
+
+  attr_reader :source, :column, :class_names
+
+  def append_reflections
+    mappings.each do |class_name, name|
+      next if klass.reflect_on_association(name)
+
+      reflection = clone_with name, class_name
+      if ActiveRecord::Reflection.respond_to?(:add_reflection)
+        ActiveRecord::Reflection.add_reflection klass, name, reflection
+      else
+        klass.reflections[name] = reflection
+      end
+    end
+  end
+
+  def clone_with(name, class_name)
+    ThinkingSphinx::ActiveRecord::FilterReflection.call(
+      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
+      hash
+    end
+  end
+
+  def morphed_stacks
+    @morphed_stacks ||= mappings.values.collect { |key|
+      column.__stack + [key]
+    }
+  end
+
+  def morph_properties
+    (source.fields + source.attributes).each do |property|
+      property.rebase column.__path, :to => morphed_stacks
+    end
+  end
+
+  def reflection
+    @reflection ||= klass.reflect_on_association column.__name
+  end
+
+  def klass
+    @klass ||= column.__stack.inject(source.model) { |parent, key|
+      parent.reflect_on_association(key).klass
+    }
+  end
+end

data/lib/thinking_sphinx/active_record/property.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Property
+  include ThinkingSphinx::Core::Property
+
+  attr_reader :model, :columns, :options
+
+  def initialize(model, columns, options = {})
+    @model, @options = model, options
+
+    @columns = Array(columns).collect { |column|
+      column.respond_to?(:__name) ? column :
+        ThinkingSphinx::ActiveRecord::Column.new(column)
+    }
+  end
+
+  def rebase(associations, options)
+    @columns = columns.inject([]) do |array, column|
+      array + column.__replace(associations, options[:to])
+    end
+  end
+
+  def name
+    (options[:as] || columns.first.__name).to_s
+  end
+
+  def source_type
+    options[:source]
+  end
+end