thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/thinking_sphinx/configuration/consistent_ids.rb

@@ -0,0 +1,31 @@
+class ThinkingSphinx::Configuration::ConsistentIds
+  def initialize(indices)
+    @indices = indices
+  end
+
+  def reconcile
+    return unless sphinx_internal_ids.any? { |attribute|
+      attribute.type == :bigint
+    }
+
+    sphinx_internal_ids.each do |attribute|
+      attribute.type = :bigint
+    end
+  end
+
+  private
+
+  def attributes
+    @attributes = sources.collect(&:attributes).flatten
+  end
+
+  def sphinx_internal_ids
+    @sphinx_internal_ids ||= attributes.select { |attribute|
+      attribute.name == 'sphinx_internal_id'
+    }
+  end
+
+  def sources
+    @sources ||= @indices.collect(&:sources).flatten
+  end
+end

data/lib/thinking_sphinx/configuration/defaults.rb

@@ -0,0 +1,5 @@
+module ThinkingSphinx::Configuration::Defaults
+  ADDRESS = '127.0.0.1'
+  PORT    = 9306
+  PANES   = []
+end

data/lib/thinking_sphinx/core.rb

@@ -0,0 +1,6 @@
+module ThinkingSphinx::Core
+  #
+end
+
+require 'thinking_sphinx/core/index'
+require 'thinking_sphinx/core/interpreter'

data/lib/thinking_sphinx/core/index.rb

@@ -0,0 +1,68 @@
+module ThinkingSphinx::Core::Index
+  extend ActiveSupport::Concern
+
+  included do
+    attr_reader :reference, :offset
+    attr_writer :definition_block
+  end
+
+  def initialize(reference, options = {})
+    @reference  = reference
+    @docinfo    = :extern
+    @options    = options
+    @offset     = config.next_offset(reference)
+
+    super "#{options[:name] || reference}_#{name_suffix}"
+  end
+
+  def delta?
+    false
+  end
+
+  def document_id_for_key(key)
+     key * config.indices.count + offset
+  end
+
+  def interpret_definition!
+    return if @interpreted_definition || @definition_block.nil?
+
+    @interpreted_definition = true
+    interpreter.translate! self, @definition_block
+  end
+
+  def model
+    @model ||= reference.to_s.camelize.constantize
+  end
+
+  def render
+    pre_render
+
+    @path ||= config.indices_location.join(name)
+
+    super
+  end
+
+  def sources
+    interpret_definition!
+    super
+  end
+
+  private
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def name_suffix
+    'core'
+  end
+
+  def pre_render
+    self.class.settings.each do |setting|
+      value = config.settings[setting.to_s]
+      send("#{setting}=", value) unless value.nil?
+    end
+
+    interpret_definition!
+  end
+end

data/lib/thinking_sphinx/core/interpreter.rb

@@ -0,0 +1,19 @@
+class ThinkingSphinx::Core::Interpreter < BasicObject
+  def self.translate!(index, block)
+    new(index, block).translate!
+  end
+
+  def initialize(index, block)
+    @index = index
+
+    mod = ::Module.new
+    mod.send :define_method, :translate!, block
+    mod.send :extend_object, self
+  end
+
+  private
+
+  def method_missing(method, *args)
+    ::ThinkingSphinx::ActiveRecord::Column.new method, *args
+  end
+end

data/lib/thinking_sphinx/deltas.rb

@@ -1,30 +1,39 @@
-require 'thinking_sphinx/deltas/default_delta'
-require 'thinking_sphinx/deltas/delete_job'
-require 'thinking_sphinx/deltas/index_job'
+module ThinkingSphinx::Deltas
+  def self.config
+    ThinkingSphinx::Configuration.instance
+  end
+  def self.processor_for(delta)
+    case delta
+    when TrueClass
+      ThinkingSphinx::Deltas::DefaultDelta
+    when Class
+      delta
+    else
+      nil
+    end
+  end
+
+  def self.resume!
+    @suspended = false
+  end
+
+  def self.suspend(reference, &block)
+    suspend!
+    yield
+    resume!
 
-module ThinkingSphinx
-  module Deltas
-    def self.parse(index)
-      delta_option = index.local_options.delete(:delta)
-      case delta_option
-      when TrueClass, :default
-        DefaultDelta.new index, index.local_options
-      when :delayed
-        DelayedDelta.new index, index.local_options
-      when :datetime
-        DatetimeDelta.new index, index.local_options
-      when FalseClass, nil
-        nil
-      else
-        if delta_option.is_a?(String)
-          delta_option = Kernel.const_get(delta_option)
-        end
-        if delta_option.ancestors.include?(ThinkingSphinx::Deltas::DefaultDelta)
-          delta_option.new index, index.local_options
-        else
-          raise "Unknown delta type"
-        end
-      end
+    config.indices_for_references(reference).each do |index|
+      index.delta_processor.index index
     end
   end
+
+  def self.suspend!
+    @suspended = true
+  end
+
+  def self.suspended?
+    @suspended
+  end
 end
+
+require 'thinking_sphinx/deltas/default_delta'

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -1,58 +1,58 @@
-module ThinkingSphinx
-  module Deltas
-    class DefaultDelta
-      attr_accessor :column
-
-      def initialize(index, options)
-        @index  = index
-        @column = options.delete(:delta_column) || :delta
-      end
-
-      def index(model, instance = nil)
-        return true unless ThinkingSphinx.updates_enabled? &&
-          ThinkingSphinx.deltas_enabled?
-        return true if instance && !toggled(instance)
-
-        update_delta_indexes model
-        delete_from_core     model, instance if instance
-
-        true
-      end
-
-      def toggle(instance)
-        instance.send "#{@column}=", true
-      end
-
-      def toggled(instance)
-        instance.send "#{@column}"
-      end
-
-      def reset_query(model)
-        "UPDATE #{model.quoted_table_name} SET " +
-        "#{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(false)} " +
-        "WHERE #{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(true)}"
-      end
-
-      def clause(model, toggled)
-        "#{model.quoted_table_name}.#{model.connection.quote_column_name(@column.to_s)}" +
-        " = #{adapter.boolean(toggled)}"
-      end
-
-      private
-
-      def update_delta_indexes(model)
-        ThinkingSphinx::Deltas::IndexJob.new(model.delta_index_names).perform
-      end
-
-      def delete_from_core(model, instance)
-        ThinkingSphinx::Deltas::DeleteJob.new(
-          model.core_index_names, instance.sphinx_document_id
-        ).perform
-      end
-
-      def adapter
-        @adapter = @index.model.sphinx_database_adapter
-      end
-    end
+class ThinkingSphinx::Deltas::DefaultDelta
+  attr_reader :adapter, :options
+
+  def initialize(adapter, options = {})
+    @adapter, @options = adapter, options
+  end
+
+  def clause(delta_source = false)
+    "#{adapter.quoted_table_name}.#{quoted_column} = #{adapter.boolean_value delta_source}"
+  end
+
+  def delete(index, instance)
+    config.connection.query Riddle::Query.update(
+      index.name, index.document_id_for_key(instance.id),
+      :sphinx_deleted => true
+    )
+  rescue Mysql2::Error => error
+    # This isn't vital, so don't raise the error.
+  end
+
+  def index(index)
+    controller.index index.name, :verbose => !config.settings['quiet_deltas']
+  end
+
+  def reset_query
+    (<<-SQL).strip.gsub(/\n\s*/, ' ')
+UPDATE #{adapter.quoted_table_name}
+SET #{quoted_column} = #{adapter.boolean_value false}
+WHERE #{quoted_column} = #{adapter.boolean_value true}
+    SQL
+  end
+
+  def toggle(instance)
+    instance.send "#{column}=", true
+  end
+
+  def toggled?(instance)
+    instance.send "#{column}?"
+  end
+
+  private
+
+  def column
+    options[:column] || :delta
+  end
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def controller
+    config.controller
+  end
+
+  def quoted_column
+    adapter.quote column
   end
 end

data/lib/thinking_sphinx/excerpter.rb

@@ -1,23 +1,25 @@
-module ThinkingSphinx
-  class Excerpter
-    CoreMethods = %w( kind_of? object_id respond_to? respond_to_missing? should
-      should_not stub! )
-    # Hide most methods, to allow them to be passed through to the instance.
-    instance_methods.select { |method|
-      method.to_s[/^__/].nil? && !CoreMethods.include?(method.to_s)
-    }.each { |method|
-      undef_method method
-    }
-    
-    def initialize(search, instance)
-      @search   = search
-      @instance = instance
-    end
-    
-    def method_missing(method, *args, &block)
-      string = @instance.send(method, *args, &block).to_s
-      
-      @search.excerpt_for(string, @instance.class)
-    end
+class ThinkingSphinx::Excerpter
+  DefaultOptions = {
+    :before_match    => '<span class="match">',
+    :after_match     => '</span>',
+    :chunk_separator => ' &#8230; ' # ellipsis
+  }
+
+  attr_accessor :index, :words, :options
+
+  def initialize(index, words, options = {})
+    @index, @words = index, words
+    @options = DefaultOptions.merge(options)
+  end
+
+  def excerpt!(text)
+    connection.query(Riddle::Query.snippets(text, index, words, options)).
+      first['snippet']
+  end
+
+  private
+
+  def connection
+    @connection ||= ThinkingSphinx::Configuration.instance.connection
   end
 end

data/lib/thinking_sphinx/facet.rb

@@ -1,135 +1,30 @@
-module ThinkingSphinx
-  class Facet
-    attr_reader :property, :value_source
+class ThinkingSphinx::Facet
+  attr_reader :name
 
-    def initialize(property, value_source = nil)
-      @property     = property
-      @value_source = value_source
-
-      if property.columns.length != 1
-        raise "Can't translate Facets on multiple-column field or attribute"
-      end
-    end
-
-    def self.name_for(facet)
-      case facet
-      when Facet
-        facet.name
-      when String, Symbol
-        return :class if facet.to_s == 'sphinx_internal_class'
-        facet.to_s.gsub(/(_facet|_crc)$/,'').to_sym
-      end
-    end
-
-    def self.attribute_name_for(name)
-      name.to_s == 'class' ? 'class_crc' : "#{name}_facet"
-    end
-
-    def self.attribute_name_from_value(name, value)
-      case value
-      when String
-        attribute_name_for(name)
-      when Array
-        if value.all? { |val| val.is_a?(Integer) }
-          name
-        else
-          attribute_name_for(name)
-        end
-      else
-        name
-      end
-    end
-
-    def self.translate?(property)
-      return true if property.is_a?(Field)
-
-      case property.type
-      when :string
-        true
-      when :integer, :boolean, :datetime, :float
-        false
-      when :multi
-        !property.all_ints?
-      end
-    end
-
-    def name
-      property.unique_name
-    end
-
-    def attribute_name
-      if translate?
-        Facet.attribute_name_for(@property.unique_name)
-      else
-        @property.unique_name.to_s
-      end
-    end
-
-    def translate?
-      Facet.translate?(@property)
-    end
-
-    def type
-      @property.is_a?(Field) ? :string : @property.type
-    end
-
-    def float?
-      @property.type == :float
-    end
-
-    def value(object, attribute_hash)
-      attribute_value = attribute_hash['@groupby']
-      return translate(object, attribute_value) if translate? || float?
-
-      case @property.type
-      when :datetime
-        Time.at(attribute_value)
-      when :boolean
-        attribute_value > 0
-      else
-        attribute_value
-      end
-    end
-
-    def to_s
-      name
-    end
-
-    private
-
-    def translate(object, attribute_value)
-      objects = source_objects(object)
-      return if objects.blank?
+  def initialize(name, properties)
+    @name, @properties = name, properties
+  end
 
-      method = value_source || column.__name
-      object = objects.one? ? objects.first : objects.detect { |item|
-        result = item.send(method)
-        case result
-        when String
-          result.to_crc32 == attribute_value
-        when NilClass
-          false
-        else
-          result == attribute_value
-        end
-      }
+  def filter_type
+    use_field? ? :conditions : :with
+  end
 
-      object.try(method)
-    end
+  def results_from(raw)
+    raw.inject({}) { |hash, row|
+      hash[row[group_column]] = row['@count']
+      hash
+    }
+  end
 
-    def source_objects(object)
-      column.__stack.each { |method|
-        object = Array(object).collect { |item|
-          item.send(method)
-        }.flatten.compact
+  private
 
-        return nil if object.empty?
-      }
-      Array(object)
-    end
+  def group_column
+    @properties.any?(&:multi?) ? '@groupby' : name
+  end
 
-    def column
-      @property.columns.first
-    end
+  def use_field?
+    @properties.any? { |property|
+      property.type.nil? || property.type == :string
+    }
   end
 end