thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/thinking_sphinx/active_record/association.rb

@@ -0,0 +1,9 @@
+class ThinkingSphinx::ActiveRecord::Association
+  def initialize(column)
+    @column = column
+  end
+
+  def stack
+    @column.__stack + [@column.__name]
+  end
+end

data/lib/thinking_sphinx/active_record/association_proxy.rb

@@ -0,0 +1,68 @@
+module ThinkingSphinx::ActiveRecord::AssociationProxy
+  extend ActiveSupport::Concern
+
+  def search(query = nil, options = {})
+    ThinkingSphinx::Search::Merger.new(super).merge! nil,
+      :with => association_filter
+  end
+
+  def search_for_ids(query = nil, options = {})
+    ThinkingSphinx::Search::Merger.new(super).merge! nil,
+      :with => association_filter
+  end
+
+  private
+
+  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

data/lib/thinking_sphinx/active_record/associations.rb

@@ -0,0 +1,68 @@
+class ThinkingSphinx::ActiveRecord::Associations
+  JoinDependency = ::ActiveRecord::Associations::JoinDependency
+
+  attr_reader :model
+
+  def initialize(model)
+    @model = model
+    @joins = ActiveSupport::OrderedHash.new
+  end
+
+  def add_join_to(stack)
+    join_for(stack)
+  end
+
+  def aggregate_for?(stack)
+    return false if stack.empty?
+
+    joins_for(stack).any? { |join|
+      [:has_many, :has_and_belongs_to_many].include?(
+        join.reflection.macro
+      )
+    }
+  end
+
+  def alias_for(stack)
+    return model.quoted_table_name if stack.empty?
+
+    join_for(stack).aliased_table_name
+  end
+
+  def join_values
+    @joins.values
+  end
+
+  private
+
+  def base
+    @base ||= JoinDependency.new model, [], []
+  end
+
+  def join_for(stack)
+    @joins[stack] ||= begin
+      JoinDependency::JoinAssociation.new(
+        reflection_for(stack), base, parent_join_for(stack)
+      ).tap { |join| join.join_type = Arel::OuterJoin }
+    end
+  end
+
+  def joins_for(stack)
+    if stack.length == 1
+      [join_for(stack)]
+    else
+      [joins_for(stack[0..-2]), join_for(stack)].flatten
+    end
+  end
+
+  def parent_for(stack)
+    stack.length == 1 ? base : join_for(stack[0..-2])
+  end
+
+  def parent_join_for(stack)
+    stack.length == 1 ? base.join_base : parent_for(stack)
+  end
+
+  def reflection_for(stack)
+    parent_for(stack).active_record.reflections[stack.last]
+  end
+end

data/lib/thinking_sphinx/active_record/attribute.rb

@@ -0,0 +1,20 @@
+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/attribute/sphinx_presenter.rb

@@ -0,0 +1,32 @@
+class ThinkingSphinx::ActiveRecord::Attribute::SphinxPresenter
+  SPHINX_TYPES = {
+    :integer   => :uint,
+    :boolean   => :bool,
+    :timestamp => :timestamp,
+    :float     => :float,
+    :string    => :string,
+    :bigint    => :bigint,
+    :ordinal   => :str2ordinal,
+    :wordcount => :str2wordcount
+  }
+
+  def initialize(attribute)
+    @attribute = attribute
+  end
+
+  def collection_type
+    @attribute.multi? ? :multi : sphinx_type
+  end
+
+  def declaration
+    if @attribute.multi?
+      "#{sphinx_type} #{@attribute.name} from field"
+    else
+      @attribute.name
+    end
+  end
+
+  def sphinx_type
+    SPHINX_TYPES[@attribute.type]
+  end
+end

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

@@ -0,0 +1,79 @@
+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 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
+    db_column = klass.columns.detect { |db_column|
+      db_column.name == attribute.columns.first.__name.to_s
+    }
+
+    if db_column.type == :integer && db_column.sql_type[/bigint/i]
+      return :bigint
+    end
+
+    case db_column.type
+    when :datetime, :date
+      :timestamp
+    when :text
+      :string
+    when :decimal
+      :float
+    else
+      db_column.type
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+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/base.rb

@@ -0,0 +1,36 @@
+module ThinkingSphinx::ActiveRecord::Base
+  extend ActiveSupport::Concern
+
+  included do
+    after_destroy ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks
+    before_save   ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+    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]
+    end
+
+    def search(query = nil, options = {})
+      search = ThinkingSphinx.search query, options
+      ThinkingSphinx::Search::Merger.new(search).merge! nil, :classes => [self]
+    end
+
+    def search_count(query = nil, options = {})
+      search(query, options).total_entries
+    end
+
+    def search_for_ids(query = nil, options = {})
+      search = search query, options
+      ThinkingSphinx::Search::Merger.new(search).merge! nil, :ids_only => true
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+class ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks <
+  ThinkingSphinx::Callbacks
+
+  callbacks :after_destroy
+
+  def after_destroy
+    indices.each do |index|
+      connection.query 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.
+  end
+
+  private
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def connection
+    @connection ||= config.connection
+  end
+
+  def indices
+    config.preload_indices
+    config.indices_for_references instance.class.name.underscore.to_sym
+  end
+end

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

@@ -0,0 +1,55 @@
+class ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks <
+  ThinkingSphinx::Callbacks
+
+  callbacks :after_commit, :before_save
+
+  def after_commit
+    return unless delta_indices? && processors.any? { |processor|
+      processor.toggled?(instance)
+    } && !ThinkingSphinx::Deltas.suspended?
+
+    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 delta_indices?
+
+    processors.each { |processor| processor.toggle instance }
+  end
+
+  private
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def core_indices
+    @core_indices ||= indices.reject { |index| index.delta? }
+  end
+
+  def delta_indices
+    @delta_indices ||= indices.select { |index| index.delta? }
+  end
+
+  def delta_indices?
+    delta_indices.any?
+  end
+
+  def indices
+    @indices ||= config.indices_for_references reference
+  end
+
+  def processors
+    delta_indices.collect &:delta_processor
+  end
+
+  def reference
+    instance.class.name.underscore.to_sym
+  end
+end

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

@@ -0,0 +1,59 @@
+class ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks <
+  ThinkingSphinx::Callbacks
+
+  callbacks :after_update
+
+  def after_update
+    return unless updates_enabled?
+
+    indices.each do |index|
+      update index
+    end
+  end
+
+  private
+
+  def attributes_hash_for(index)
+    updateable_attributes_for(index).inject({}) do |hash, attribute|
+      if instance.changed.include?(attribute.columns.first.__name.to_s)
+        hash[attribute.name] = attribute.value_for(instance)
+      end
+
+      hash
+    end
+  end
+
+  def configuration
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def indices
+    @indices ||= configuration.indices_for_references reference
+  end
+
+  def reference
+    instance.class.name.underscore.to_sym
+  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.id), attributes
+    )
+    configuration.connection.query(sphinxql)
+  rescue Mysql2::Error => 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