thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/active_record/attribute/type.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Attribute::Type
+  UPDATEABLE_TYPES = [:integer, :timestamp, :boolean, :float]
+
+  def initialize(attribute, model)
+    @attribute, @model = attribute, model
+  end
+
+  def multi?
+    @multi ||= attribute.options[:multi] || multi_from_associations
+  end
+
+  def timestamp?
+    type == :timestamp
+  end
+
+  def type
+    @type ||= attribute.options[:type] || type_from_database
+  end
+
+  def type=(value)
+    @type = attribute.options[:type] = value
+  end
+
+  def updateable?
+    UPDATEABLE_TYPES.include?(type) && single_column_reference?
+  end
+
+  private
+
+  attr_reader :attribute, :model
+
+  def associations
+    @associations ||= begin
+      klass = model
+      attribute.columns.first.__stack.collect { |name|
+        association = klass.reflect_on_association(name)
+        klass       = association.klass
+        association
+      }
+    end
+  end
+
+  def big_integer?
+    type_symbol == :integer && database_column.sql_type[/bigint/i]
+  end
+
+  def column_name
+    attribute.columns.first.__name.to_s
+  end
+
+  def database_column
+    @database_column ||= klass.columns.detect { |db_column|
+      db_column.name == column_name
+    }
+  end
+
+  def klass
+    @klass ||= associations.any? ? associations.last.klass : model
+  end
+
+  def multi_from_associations
+    associations.any? { |association|
+      [:has_many, :has_and_belongs_to_many].include?(association.macro)
+    }
+  end
+
+  def single_column_reference?
+    attribute.columns.length == 1               &&
+    attribute.columns.first.__stack.length == 0 &&
+    !attribute.columns.first.string?
+  end
+
+  def type_from_database
+    raise ThinkingSphinx::MissingColumnError,
+      "Cannot determine the database type of column #{column_name}, as it does not exist" if database_column.nil?
+
+    return :bigint if big_integer?
+
+    case type_symbol
+    when :datetime, :date
+      :timestamp
+    when :text
+      :string
+    when :decimal
+      :float
+    when :integer, :boolean, :timestamp, :float, :string, :bigint, :json
+      type_symbol
+    else
+      raise ThinkingSphinx::UnknownAttributeType,
+        <<-ERROR
+Unable to determine an equivalent Sphinx attribute type from #{database_column.type.class.name} for attribute #{attribute.name}. You may want to manually set the type.
+
+e.g.
+  has my_column, :type => :integer
+        ERROR
+    end
+  end
+
+  def type_symbol
+    return database_column.type if database_column.type.is_a?(Symbol)
+
+    database_column.type.class.name.demodulize.downcase.to_sym
+  end
+end

data/lib/thinking_sphinx/active_record/attribute/values.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Attribute::Values
+  def initialize(attribute)
+    @attribute = attribute
+  end
+
+  def value_for(instance)
+    object = column.__stack.inject(instance) { |object, name|
+      object.nil? ? nil : object.send(name)
+    }
+    object.nil? ? nil : object.send(column.__name)
+  end
+
+  private
+
+  def column
+    @attribute.columns.first
+  end
+end

data/lib/thinking_sphinx/active_record/attribute.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Attribute <
+  ThinkingSphinx::ActiveRecord::Property
+
+  delegate :type, :type=, :multi?, :updateable?, :to => :typist
+  delegate :value_for,                           :to => :values
+
+  private
+
+  def typist
+    @typist ||= ThinkingSphinx::ActiveRecord::Attribute::Type.new self, @model
+  end
+
+  def values
+    @values ||= ThinkingSphinx::ActiveRecord::Attribute::Values.new self
+  end
+end
+
+require 'thinking_sphinx/active_record/attribute/sphinx_presenter'
+require 'thinking_sphinx/active_record/attribute/type'
+require 'thinking_sphinx/active_record/attribute/values'

data/lib/thinking_sphinx/active_record/base.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::ActiveRecord::Base
+  extend ActiveSupport::Concern
+
+  included do
+    # Avoid method collisions for public Thinking Sphinx methods added to all
+    # ActiveRecord models. The `sphinx_`-prefixed versions will always exist,
+    # and the non-prefixed versions will be added if a method of that name
+    # doesn't already exist.
+    #
+    # If a method is overwritten later by something else, that's also fine - the
+    # prefixed versions will still be there.
+    class_module = ThinkingSphinx::ActiveRecord::Base::ClassMethods
+    class_module.public_instance_methods.each do |method_name|
+      short_method = method_name.to_s.delete_prefix("sphinx_").to_sym
+      next if methods.include?(short_method)
+
+      define_singleton_method(short_method, method(method_name))
+    end
+
+    if ActiveRecord::VERSION::STRING.to_i >= 5
+      [
+        ::ActiveRecord::Reflection::HasManyReflection,
+        ::ActiveRecord::Reflection::HasAndBelongsToManyReflection
+      ].each do |reflection_class|
+        reflection_class.include DefaultReflectionAssociations
+      end
+    else
+      ::ActiveRecord::Associations::CollectionProxy.include(
+        ThinkingSphinx::ActiveRecord::AssociationProxy
+      )
+    end
+  end
+
+  module DefaultReflectionAssociations
+    def extensions
+      super + [ThinkingSphinx::ActiveRecord::AssociationProxy]
+    end
+  end
+
+  module ClassMethods
+    def sphinx_facets(query = nil, options = {})
+      merge_search ThinkingSphinx.facets, query, options
+    end
+
+    def sphinx_search(query = nil, options = {})
+      merge_search ThinkingSphinx.search, query, options
+    end
+
+    def sphinx_search_count(query = nil, options = {})
+      search_for_ids(query, options).total_entries
+    end
+
+    def sphinx_search_for_ids(query = nil, options = {})
+      ThinkingSphinx::Search::Merger.new(
+        search(query, options)
+      ).merge! nil, :ids_only => true
+    end
+
+    def sphinx_search_none
+      merge_search ThinkingSphinx.search, nil, none: true
+    end
+
+    private
+
+    def default_sphinx_scope?
+      respond_to?(:default_sphinx_scope) && default_sphinx_scope
+    end
+
+    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
+
+      result = merger.merge! nil, :classes => [self]
+      result.populate if result.options[:populate]
+      result
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Callbacks::AssociationDeltaCallbacks
+  def initialize(path)
+    @path = path
+  end
+
+  def after_commit(instance)
+    Array(objects_for(instance)).each do |object|
+      object.update :delta => true unless object.frozen?
+    end
+  end
+
+  private
+
+  attr_reader :path
+
+  def objects_for(instance)
+    path.inject(instance) { |object, method| object.send method }
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks <
+  ThinkingSphinx::Callbacks
+
+  callbacks :after_commit, :after_destroy, :after_rollback
+
+  def after_commit
+    delete_from_sphinx
+  end
+
+  def after_destroy
+    delete_from_sphinx
+  end
+
+  def after_rollback
+    delete_from_sphinx
+  end
+
+  private
+
+  def delete_from_sphinx
+    return if ThinkingSphinx::Callbacks.suspended?
+
+    ThinkingSphinx::Processor.new(instance: instance).delete
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks <
+  ThinkingSphinx::Callbacks
+
+  callbacks :after_commit, :before_save
+
+  def after_commit
+    return unless !suspended? && delta_indices? && toggled?
+
+    delta_indices.each do |index|
+      index.delta_processor.index index
+    end
+
+    core_indices.each do |index|
+      index.delta_processor.delete index, instance
+    end
+  end
+
+  def before_save
+    return unless !ThinkingSphinx::Callbacks.suspended? && delta_indices? &&
+      new_or_changed?
+
+    processors.each { |processor| processor.toggle instance }
+  end
+
+  private
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def core_indices
+    @core_indices ||= indices.select(&:delta_processor).reject(&:delta?)
+  end
+
+  def delta_indices
+    @delta_indices ||= indices.select &:delta?
+  end
+
+  def delta_indices?
+    delta_indices.any?
+  end
+
+  def indices
+    @indices ||= config.index_set_class.new(
+      :instances => [instance], :classes => [instance.class]
+    ).select { |index| index.type == "plain" }
+  end
+
+  def new_or_changed?
+    instance.new_record? || instance.changed?
+  end
+
+  def processors
+    delta_indices.collect &:delta_processor
+  end
+
+  def suspended?
+    ThinkingSphinx::Callbacks.suspended? || ThinkingSphinx::Deltas.suspended?
+  end
+
+  def toggled?
+    processors.any? { |processor| processor.toggled?(instance) }
+  end
+end

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

@@ -0,0 +1,78 @@
+# 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 !ThinkingSphinx::Callbacks.suspended? && updates_enabled?
+
+    indices.each do |index|
+      update index unless index.distributed?
+    end
+  end
+
+  private
+
+  def attributes_hash_for(index)
+    updateable_attributes_for(index).inject({}) do |hash, attribute|
+      if changed_attributes.include?(attribute.columns.first.__name.to_s)
+        hash[attribute.name] = attribute.value_for(instance)
+      end
+
+      hash
+    end
+  end
+
+  def changed_attributes
+    @changed_attributes ||= CHANGED_ATTRIBUTES.call instance
+  end
+
+  def configuration
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def indices
+    @indices ||= begin
+      all = configuration.indices_for_references(reference)
+      all.reject { |index| index.type == 'rt' }
+    end
+  end
+
+  def reference
+    configuration.index_set_class.reference_name(instance.class)
+  end
+
+  def update(index)
+    attributes = attributes_hash_for(index)
+    return if attributes.empty?
+
+    sphinxql = Riddle::Query.update(
+      index.name,
+      index.document_id_for_key(instance.public_send(index.primary_key)),
+      attributes
+    )
+    ThinkingSphinx::Connection.take do |connection|
+      connection.execute(sphinxql)
+    end
+  rescue ThinkingSphinx::ConnectionError => error
+    # This isn't vital, so don't raise the error.
+  end
+
+  def updateable_attributes_for(index)
+    index.sources.collect(&:attributes).flatten.select { |attribute|
+      attribute.updateable?
+    }
+  end
+
+  def updates_enabled?
+    configuration.settings['attribute_updates']
+  end
+end

data/lib/thinking_sphinx/active_record/column.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Column
+  def initialize(*stack)
+    @stack = stack
+    @name  = stack.pop
+  end
+
+  def __name
+    @name
+  end
+
+  def __path
+    @stack + [@name]
+  end
+
+  def __replace(stack, replacements)
+    return [self] if string? || __stack[0..stack.length-1] != stack
+
+    replacements.collect { |replacement|
+      self.class.new *(replacement + __stack[stack.length..-1]), __name
+    }
+  end
+
+  def __stack
+    @stack
+  end
+
+  def string?
+    __name.is_a?(String)
+  end
+
+  def to_ary
+    [self]
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    @stack << @name
+    @name = method
+    self
+  end
+end

data/lib/thinking_sphinx/active_record/column_sql_presenter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::ColumnSQLPresenter
+  def initialize(model, column, adapter, associations)
+    @model, @column, @adapter, @associations = model, column, adapter, associations
+  end
+
+  def aggregate?
+    path.aggregate?
+  rescue Joiner::AssociationNotFound
+    false
+  end
+
+  def with_table
+    return __name if string?
+    return nil unless exists?
+
+    quoted_table = escape_table? ? escape_table(table) : table
+
+    "#{quoted_table}.#{adapter.quote __name}"
+  end
+
+  private
+
+  attr_reader :model, :column, :adapter, :associations
+
+  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
+
+  def exists?
+    path.model.column_names.include?(column.__name.to_s)
+  rescue Joiner::AssociationNotFound
+    false
+  end
+
+  def path
+    Joiner::Path.new model, column.__stack
+  end
+
+  def table
+    associations.alias_for __stack
+  end
+
+  def version
+    ActiveRecord::VERSION
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
+  def initialize(model)
+    @model = model
+  end
+
+  def quote(column)
+    @model.connection.quote_column_name(column)
+  end
+
+  def quoted_table_name
+    @model.quoted_table_name
+  end
+
+  def utf8_query_pre
+    []
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter <
+  ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
+
+  def boolean_value(value)
+    value ? 1 : 0
+  end
+
+  def cast_to_bigint(clause)
+    "CAST(#{clause} AS UNSIGNED INTEGER)"
+  end
+
+  def cast_to_string(clause)
+    "CAST(#{clause} AS char)"
+  end
+
+  def cast_to_timestamp(clause)
+    "UNIX_TIMESTAMP(#{clause})"
+  end
+
+  def concatenate(clause, separator = ' ')
+    "CONCAT_WS('#{separator}', #{clause})"
+  end
+
+  def convert_nulls(clause, default = '')
+    "IFNULL(#{clause}, #{default})"
+  end
+
+  def convert_blank(clause, default = '')
+    "COALESCE(NULLIF(#{clause}, ''), #{default})"
+  end
+
+  def group_concatenate(clause, separator = ' ')
+    "GROUP_CONCAT(DISTINCT #{clause} SEPARATOR '#{separator}')"
+  end
+
+  def time_zone_query_pre
+    ["SET TIME_ZONE = '+0:00'"]
+  end
+
+  def utf8_query_pre
+    ["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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter <
+  ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
+
+  def boolean_value(value)
+    value ? 'TRUE' : 'FALSE'
+  end
+
+  def cast_to_bigint(clause)
+    "#{clause}::bigint"
+  end
+
+  def cast_to_string(clause)
+    "#{clause}::varchar"
+  end
+
+  def cast_to_timestamp(clause)
+    if ThinkingSphinx::Configuration.instance.settings['64bit_timestamps']
+      "extract(epoch from #{clause})::bigint"
+    else
+      "extract(epoch from #{clause})::int"
+    end
+  end
+
+  def concatenate(clause, separator = ' ')
+    clause.split(', ').collect { |part|
+      convert_nulls(part, "''")
+    }.join(" || '#{separator}' || ")
+  end
+
+  def convert_nulls(clause, default = '')
+    "COALESCE(#{clause}, #{default})"
+  end
+
+  def convert_blank(clause, default = '')
+    "COALESCE(NULLIF(#{clause}, ''), #{default})"
+  end
+
+  def group_concatenate(clause, separator = ' ')
+    "array_to_string(array_agg(DISTINCT #{clause}), '#{separator}')"
+  end
+
+  def time_zone_query_pre
+    ['SET TIME ZONE UTC']
+  end
+end