pixeltrix-thinking-sphinx 1.1.5

data/lib/thinking_sphinx/core/string.rb

@@ -0,0 +1,22 @@
+module ThinkingSphinx
+  module Core
+    module String
+      
+      def to_crc32
+        result = 0xFFFFFFFF
+        self.each_byte do |byte|
+          result ^= byte
+          8.times do
+            result = (result >> 1) ^ (0xEDB88320 * (result & 1))
+          end
+        end
+        result ^ 0xFFFFFFFF
+      end
+      
+    end
+  end
+end
+
+class String
+  include ThinkingSphinx::Core::String
+end

data/lib/thinking_sphinx/deltas.rb

@@ -0,0 +1,22 @@
+require 'thinking_sphinx/deltas/default_delta'
+require 'thinking_sphinx/deltas/delayed_delta'
+require 'thinking_sphinx/deltas/datetime_delta'
+
+module ThinkingSphinx
+  module Deltas
+    def self.parse(index, options)
+      case options.delete(:delta)
+      when TrueClass, :default
+        DefaultDelta.new index, options
+      when :delayed
+        DelayedDelta.new index, options
+      when :datetime
+        DatetimeDelta.new index, options
+      when FalseClass, nil
+        nil
+      else
+        raise "Unknown delta type"
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/datetime_delta.rb

@@ -0,0 +1,50 @@
+module ThinkingSphinx
+  module Deltas
+    class DatetimeDelta < ThinkingSphinx::Deltas::DefaultDelta
+      attr_accessor :column, :threshold
+      
+      def initialize(index, options)
+        @index      = index
+        @column     = options.delete(:delta_column) || :updated_at
+        @threshold  = options.delete(:threshold)    || 1.day
+      end
+      
+      def index(model, instance = nil)
+        # do nothing
+        true
+      end
+      
+      def delayed_index(model)
+        config = ThinkingSphinx::Configuration.instance
+        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
+        
+        output = `#{config.bin_path}indexer --config #{config.config_file} #{rotate} #{delta_index_name model}`
+        output += `#{config.bin_path}indexer --config #{config.config_file} #{rotate} --merge #{core_index_name model} #{delta_index_name model} --merge-dst-range sphinx_deleted 0 0`
+        puts output unless ThinkingSphinx.suppress_delta_output?
+        
+        true
+      end
+            
+      def toggle(instance)
+        # do nothing
+      end
+      
+      def toggled(instance)
+        instance.send(@column) > @threshold.ago
+      end
+      
+      def reset_query(model)
+        nil
+      end
+      
+      def clause(model, toggled)
+        if toggled
+          "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
+          " > #{adapter.time_difference(@threshold)}"
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -0,0 +1,65 @@
+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?
+        
+        config = ThinkingSphinx::Configuration.instance
+        client = Riddle::Client.new config.address, config.port
+        
+        client.update(
+          core_index_name(model),
+          ['sphinx_deleted'],
+          {instance.sphinx_document_id => [1]}
+        ) if instance && ThinkingSphinx.sphinx_running? && instance.in_core_index?
+        
+        output = `#{config.bin_path}indexer --config #{config.config_file} --rotate #{delta_index_name model}`
+        puts output unless ThinkingSphinx.suppress_delta_output?
+        
+        true
+      end
+      
+      def toggle(instance)
+        instance.delta = true
+      end
+      
+      def toggled(instance)
+        instance.delta
+      end
+      
+      def reset_query(model)
+        "UPDATE #{model.quoted_table_name} SET " +
+        "#{@index.quote_column(@column.to_s)} = #{adapter.boolean(false)}"
+      end
+      
+      def clause(model, toggled)
+        "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
+        " = #{adapter.boolean(toggled)}"
+      end
+      
+      protected
+      
+      def core_index_name(model)
+        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
+      end
+      
+      def delta_index_name(model)
+        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_delta"
+      end  
+      
+      private
+      
+      def adapter
+        @adapter = @index.model.sphinx_database_adapter
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta.rb

@@ -0,0 +1,25 @@
+require 'delayed/job'
+
+require 'thinking_sphinx/deltas/delayed_delta/delta_job'
+require 'thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job'
+require 'thinking_sphinx/deltas/delayed_delta/job'
+
+module ThinkingSphinx
+  module Deltas
+    class DelayedDelta < ThinkingSphinx::Deltas::DefaultDelta
+      def index(model, instance = nil)
+        ThinkingSphinx::Deltas::Job.enqueue(
+          ThinkingSphinx::Deltas::DeltaJob.new(delta_index_name(model))
+        )
+        
+        Delayed::Job.enqueue(
+          ThinkingSphinx::Deltas::FlagAsDeletedJob.new(
+            core_index_name(model), instance.sphinx_document_id
+          )
+        ) if instance
+        
+        true
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/delta_job.rb

@@ -0,0 +1,24 @@
+module ThinkingSphinx
+  module Deltas
+    class DeltaJob
+      attr_accessor :index
+      
+      def initialize(index)
+        @index = index
+      end
+      
+      def perform
+        return true unless ThinkingSphinx.updates_enabled? &&
+          ThinkingSphinx.deltas_enabled?
+        
+        config = ThinkingSphinx::Configuration.instance
+        client = Riddle::Client.new config.address, config.port
+        
+        output = `#{config.bin_path}indexer --config #{config.config_file} --rotate #{index}`
+        puts output unless ThinkingSphinx.suppress_delta_output?
+        
+        true
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job.rb

@@ -0,0 +1,27 @@
+module ThinkingSphinx
+  module Deltas
+    class FlagAsDeletedJob
+      attr_accessor :index, :document_id
+      
+      def initialize(index, document_id)
+        @index, @document_id = index, document_id
+      end
+      
+      def perform
+        return true unless ThinkingSphinx.updates_enabled?
+        
+        config = ThinkingSphinx::Configuration.instance
+        client = Riddle::Client.new config.address, config.port
+        
+        client.update(
+          @index,
+          ['sphinx_deleted'],
+          {@document_id => [1]}
+        ) if ThinkingSphinx.sphinx_running? &&
+          ThinkingSphinx::Search.search_for_id(@document_id, @index)
+        
+        true
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/job.rb

@@ -0,0 +1,26 @@
+module ThinkingSphinx
+  module Deltas
+    class Job < Delayed::Job
+      def self.enqueue(object, priority = 0)
+        super unless duplicates_exist(object)
+      end
+      
+      def self.cancel_thinking_sphinx_jobs
+        if connection.tables.include?("delayed_jobs")
+          delete_all("handler LIKE '--- !ruby/object:ThinkingSphinx::Deltas::%'")
+        end
+      end
+
+      private
+
+      def self.duplicates_exist(object)
+        count(
+          :conditions => {
+            :handler    => object.to_yaml,
+            :locked_at  => nil
+          }
+        ) > 0
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/facet.rb

@@ -0,0 +1,58 @@
+module ThinkingSphinx
+  class Facet
+    attr_reader :reference
+    
+    def initialize(reference)
+      @reference = reference
+      
+      if reference.columns.length != 1
+        raise "Can't translate Facets on multiple-column field or attribute"
+      end
+    end
+    
+    def name
+      reference.unique_name
+    end
+    
+    def attribute_name
+      @attribute_name ||= case @reference
+      when Attribute
+        @reference.unique_name.to_s
+      when Field
+        @reference.unique_name.to_s + "_sort"
+      end
+    end
+    
+    def value(object, attribute_value)
+      return translate(object, attribute_value) if @reference.is_a?(Field)
+      
+      case @reference.type
+      when :string, :multi
+        translate(object, attribute_value)
+      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)
+      column.__stack.each { |method|
+        object = object.send(method)
+      }
+      object.send(column.__name)
+    end
+    
+    def column
+      @reference.columns.first
+    end
+  end
+end

data/lib/thinking_sphinx/facet_collection.rb

@@ -0,0 +1,44 @@
+module ThinkingSphinx
+  class FacetCollection < Hash
+    attr_accessor :arguments
+    
+    def initialize(arguments)
+      @arguments        = arguments.clone
+      @attribute_values = {}
+      @facets           = []
+    end
+    
+    def add_from_results(facet, results)
+      self[facet.name]              = {}
+      @attribute_values[facet.name] = {}
+      @facets << facet
+      
+      results.each_with_groupby_and_count { |result, group, count|
+        facet_value = facet.value(result, group)
+        
+        self[facet.name][facet_value]               = count
+        @attribute_values[facet.name][facet_value]  = group
+      }
+    end
+    
+    def for(hash = {})
+      arguments        = @arguments.clone
+      options          = arguments.extract_options!
+      options[:with] ||= {}
+      
+      hash.each do |key, value|
+        attrib = facet_for_key(key).attribute_name
+        options[:with][attrib] = @attribute_values[key][value]
+      end
+      
+      arguments << options
+      ThinkingSphinx::Search.search *arguments
+    end
+    
+    private
+    
+    def facet_for_key(key)
+      @facets.detect { |facet| facet.name == key }
+    end
+  end
+end

data/lib/thinking_sphinx/field.rb

@@ -0,0 +1,172 @@
+module ThinkingSphinx
+  # Fields - holding the string data which Sphinx indexes for your searches.
+  # This class isn't really useful to you unless you're hacking around with the
+  # internals of Thinking Sphinx - but hey, don't let that stop you.
+  #
+  # One key thing to remember - if you're using the field manually to
+  # generate SQL statements, you'll need to set the base model, and all the
+  # associations. Which can get messy. Use Index.link!, it really helps.
+  # 
+  class Field
+    attr_accessor :alias, :columns, :sortable, :associations, :model, :infixes,
+      :prefixes, :faceted
+    
+    # To create a new field, you'll need to pass in either a single Column
+    # or an array of them, and some (optional) options. The columns are
+    # references to the data that will make up the field.
+    #
+    # Valid options are:
+    # - :as       => :alias_name 
+    # - :sortable => true
+    # - :infixes  => true
+    # - :prefixes => true
+    #
+    # Alias is only required in three circumstances: when there's
+    # another attribute or field with the same name, when the column name is
+    # 'id', or when there's more than one column.
+    # 
+    # Sortable defaults to false - but is quite useful when set to true, as
+    # it creates an attribute with the same string value (which Sphinx converts
+    # to an integer value), which can be sorted by. Thinking Sphinx is smart
+    # enough to realise that when you specify fields in sort statements, you
+    # mean their respective attributes.
+    # 
+    # If you have partial matching enabled (ie: enable_star), then you can
+    # specify certain fields to have their prefixes and infixes indexed. Keep
+    # in mind, though, that Sphinx's default is _all_ fields - so once you
+    # highlight a particular field, no other fields in the index will have
+    # these partial indexes.
+    #
+    # Here's some examples:
+    #
+    #   Field.new(
+    #     Column.new(:name)
+    #   )
+    #
+    #   Field.new(
+    #     [Column.new(:first_name), Column.new(:last_name)],
+    #     :as => :name, :sortable => true
+    #   )
+    # 
+    #   Field.new(
+    #     [Column.new(:posts, :subject), Column.new(:posts, :content)],
+    #     :as => :posts, :prefixes => true
+    #   )
+    # 
+    def initialize(columns, options = {})
+      @columns      = Array(columns)
+      @associations = {}
+
+      raise "Cannot define a field with no columns. Maybe you are trying to index a field with a reserved name (id, name). You can fix this error by using a symbol rather than a bare name (:id instead of id)." if @columns.empty? || @columns.any? { |column| !column.respond_to?(:__stack) }
+      
+      @alias    = options[:as]
+      @sortable = options[:sortable] || false
+      @infixes  = options[:infixes]  || false
+      @prefixes = options[:prefixes] || false
+      @faceted  = options[:facet]    || false
+    end
+    
+    # Get the part of the SELECT clause related to this field. Don't forget
+    # to set your model and associations first though.
+    #
+    # This will concatenate strings if there's more than one data source or
+    # multiple data values (has_many or has_and_belongs_to_many associations).
+    # 
+    def to_select_sql
+      clause = @columns.collect { |column|
+        column_with_prefix(column)
+      }.join(', ')
+      
+      clause = adapter.concatenate(clause) if concat_ws?
+      clause = adapter.group_concatenate(clause) if is_many?
+      
+      "#{adapter.cast_to_string clause } AS #{quote_column(unique_name)}"
+    end
+    
+    # Get the part of the GROUP BY clause related to this field - if one is
+    # needed. If not, all you'll get back is nil. The latter will happen if
+    # there's multiple data values (read: a has_many or has_and_belongs_to_many
+    # association).
+    #
+    def to_group_sql
+      case
+      when is_many?, ThinkingSphinx.use_group_by_shortcut?
+        nil
+      else
+        @columns.collect { |column|
+          column_with_prefix(column)
+        }
+      end
+    end
+    
+    # Returns the unique name of the field - which is either the alias of
+    # the field, or the name of the only column - if there is only one. If
+    # there isn't, there should be an alias. Else things probably won't work.
+    # Consider yourself warned.
+    #
+    def unique_name
+      if @columns.length == 1
+        @alias || @columns.first.__name
+      else
+        @alias
+      end
+    end
+    
+    def to_facet
+      return nil unless @faceted
+      
+      ThinkingSphinx::Facet.new(self)
+    end
+    
+    private
+    
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
+    end
+    
+    def quote_column(column)
+      @model.connection.quote_column_name(column)
+    end
+    
+    # Indication of whether the columns should be concatenated with a space
+    # between each value. True if there's either multiple sources or multiple
+    # associations.
+    # 
+    def concat_ws?
+      @columns.length > 1 || multiple_associations?
+    end
+        
+    # Checks whether any column requires multiple associations (which only
+    # happens for polymorphic situations).
+    # 
+    def multiple_associations?
+      associations.any? { |col,assocs| assocs.length > 1 }
+    end
+    
+    # Builds a column reference tied to the appropriate associations. This
+    # dives into the associations hash and their corresponding joins to
+    # figure out how to correctly reference a column in SQL.
+    #
+    def column_with_prefix(column)
+      if column.is_string?
+        column.__name
+      elsif associations[column].empty?
+        "#{@model.quoted_table_name}.#{quote_column(column.__name)}"
+      else
+        associations[column].collect { |assoc|
+          assoc.has_column?(column.__name) ?
+          "#{@model.connection.quote_table_name(assoc.join.aliased_table_name)}" + 
+          ".#{quote_column(column.__name)}" :
+          nil
+        }.compact.join(', ')
+      end
+    end
+    
+    # Could there be more than one value related to the parent record? If so,
+    # then this will return true. If not, false. It's that simple.
+    #
+    def is_many?
+      associations.values.flatten.any? { |assoc| assoc.is_many? }
+    end
+  end
+end