thinking-sphinx 2.0.6 → 2.0.7

data/lib/thinking_sphinx/index/faux_column.rb

@@ -0,0 +1,118 @@
+module ThinkingSphinx
+  class Index
+    # Instances of this class represent database columns and the stack of
+    # associations that lead from the base model to them.
+    # 
+    # The name and stack are accessible through methods starting with __ to
+    # avoid conflicting with the method_missing calls that build the stack.
+    # 
+    class FauxColumn
+      # Create a new column with a pre-defined stack. The top element in the
+      # stack will get shifted to be the name value.
+      # 
+      def initialize(*stack)
+        @name  = stack.pop
+        @stack = stack
+      end
+      
+      def self.coerce(columns)
+        case columns
+        when Symbol, String
+          FauxColumn.new(columns)
+        when Array
+          columns.collect { |col| FauxColumn.coerce(col) }
+        when FauxColumn
+          columns
+        else
+          nil
+        end
+      end
+      
+      # Can't use normal method name, as that could be an association or
+      # column name.
+      # 
+      def __name
+        @name
+      end
+      
+      # Can't use normal method name, as that could be an association or
+      # column name.
+      # 
+      def __stack
+        @stack
+      end
+      
+      def __path
+        @stack + [@name]
+      end
+      
+      # Returns true if the stack is empty *and* if the name is a string -
+      # which is an indication that of raw SQL, as opposed to a value from a
+      # table's column.
+      # 
+      def is_string?
+        @name.is_a?(String) && @stack.empty?
+      end
+      
+      def to_ary
+        [self]
+      end
+      
+      # This handles any 'invalid' method calls and sets them as the name,
+      # and pushing the previous name into the stack. The object returns
+      # itself.
+      # 
+      # If there's a single argument, it becomes the name, and the method
+      # symbol goes into the stack as well. Multiple arguments means new
+      # columns with the original stack and new names (from each argument) gets
+      # returned.
+      # 
+      # Easier to explain with examples:
+      # 
+      #   col = FauxColumn.new :a, :b, :c
+      #   col.__name  #=> :c
+      #   col.__stack #=> [:a, :b]
+      # 
+      #   col.whatever #=> col
+      #   col.__name  #=> :whatever
+      #   col.__stack #=> [:a, :b, :c]
+      #
+      #   col.something(:id) #=> col
+      #   col.__name  #=> :id
+      #   col.__stack #=> [:a, :b, :c, :whatever, :something]
+      #
+      #   cols = col.short(:x, :y, :z)
+      #   cols[0].__name  #=> :x
+      #   cols[0].__stack #=> [:a, :b, :c, :whatever, :something, :short]
+      #   cols[1].__name  #=> :y
+      #   cols[1].__stack #=> [:a, :b, :c, :whatever, :something, :short]
+      #   cols[2].__name  #=> :z
+      #   cols[2].__stack #=> [:a, :b, :c, :whatever, :something, :short]
+      #   
+      # Also, this allows method chaining to build up a relevant stack:
+      # 
+      #   col = FauxColumn.new :a, :b
+      #   col.__name  #=> :b
+      #   col.__stack #=> [:a]
+      # 
+      #   col.one.two.three #=> col
+      #   col.__name  #=> :three
+      #   col.__stack #=> [:a, :b, :one, :two]
+      #
+      def method_missing(method, *args)
+        @stack << @name
+        @name   = method
+        
+        if (args.empty?)
+          self
+        elsif (args.length == 1)
+          method_missing(args.first)
+        else
+          args.collect { |arg|
+            FauxColumn.new(@stack + [@name, arg])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/index.rb

@@ -0,0 +1,157 @@
+require 'thinking_sphinx/index/builder'
+require 'thinking_sphinx/index/faux_column'
+
+module ThinkingSphinx
+  class Index
+    attr_accessor :name, :model, :sources, :delta_object
+    
+    # Create a new index instance by passing in the model it is tied to, and
+    # a block to build it with (optional but recommended). For documentation
+    # on the syntax for inside the block, the Builder class is what you want.
+    #
+    # Quick Example:
+    #
+    #   Index.new(User) do
+    #     indexes login, email
+    #     
+    #     has created_at
+    #     
+    #     set_property :delta => true
+    #   end
+    #
+    def initialize(model, &block)
+      @name         = self.class.name_for model
+      @model        = model
+      @sources      = []
+      @options      = {}
+      @delta_object = nil
+    end
+    
+    def fields
+      @sources.collect { |source| source.fields }.flatten
+    end
+    
+    def attributes
+      @sources.collect { |source| source.attributes }.flatten
+    end
+    
+    def core_name
+      "#{name}_core"
+    end
+    
+    def delta_name
+      "#{name}_delta"
+    end
+    
+    def all_names
+      names  = [core_name]
+      names << delta_name if delta?
+      
+      names
+    end
+    
+    def self.name_for(model)
+      model.name.underscore.tr(':/\\', '_')
+    end
+    
+    def prefix_fields
+      fields.select { |field| field.prefixes }
+    end
+    
+    def infix_fields
+      fields.select { |field| field.infixes }
+    end
+    
+    def local_options
+      @options
+    end
+    
+    def options
+      all_index_options = config.index_options.clone
+      @options.keys.select { |key|
+        ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) ||
+        ThinkingSphinx::Configuration::CustomOptions.include?(key.to_s)
+      }.each { |key| all_index_options[key.to_sym] = @options[key] }
+      all_index_options
+    end
+    
+    def delta?
+      !@delta_object.nil?
+    end
+    
+    def to_riddle(offset)
+      indexes = [to_riddle_for_core(offset)]
+      indexes << to_riddle_for_delta(offset) if delta?
+      indexes << to_riddle_for_distributed
+    end
+    
+    private
+    
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
+    end
+    
+    def utf8?
+      options[:charset_type] == "utf-8"
+    end
+    
+    def sql_query_pre_for_delta
+      [""]
+    end
+    
+    def config
+      @config ||= ThinkingSphinx::Configuration.instance
+    end
+    
+    def to_riddle_for_core(offset)
+      index = Riddle::Configuration::Index.new core_name
+      index.path = File.join config.searchd_file_path, index.name
+      
+      set_configuration_options_for_indexes index
+      set_field_settings_for_indexes        index
+      
+      sources.each_with_index do |source, i|
+        index.sources << source.to_riddle_for_core(offset, i)
+      end
+      
+      index
+    end
+    
+    def to_riddle_for_delta(offset)
+      index = Riddle::Configuration::Index.new delta_name
+      index.parent = core_name
+      index.path = File.join config.searchd_file_path, index.name
+      
+      sources.each_with_index do |source, i|
+        index.sources << source.to_riddle_for_delta(offset, i)
+      end
+      
+      index
+    end
+    
+    def to_riddle_for_distributed
+      index = Riddle::Configuration::DistributedIndex.new name
+      index.local_indexes << core_name
+      index.local_indexes.unshift delta_name if delta?
+      index
+    end
+    
+    def set_configuration_options_for_indexes(index)
+      config.index_options.each do |key, value|
+        method = "#{key}=".to_sym
+        index.send(method, value) if index.respond_to?(method)
+      end
+      
+      options.each do |key, value|
+        index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
+      end
+    end
+    
+    def set_field_settings_for_indexes(index)
+      field_names = lambda { |field| field.unique_name.to_s }
+      
+      index.prefix_field_names += prefix_fields.collect(&field_names)
+      index.infix_field_names  += infix_fields.collect(&field_names)
+    end
+  end
+end

data/lib/thinking_sphinx/join.rb

@@ -0,0 +1,37 @@
+module ThinkingSphinx
+  class Join
+    attr_accessor :source, :column, :associations
+    
+    def initialize(source, column)
+      @source = source
+      @column = column
+      
+      @associations = association_stack(column.__path.clone).each { |assoc|
+        assoc.join_to(source.base)
+      }
+      
+      source.joins << self
+    end
+    
+    private
+    
+    # Gets a stack of associations for a specific path.
+    # 
+    def association_stack(path, parent = nil)
+      assocs = []
+      
+      if parent.nil?
+        assocs = @source.association(path.shift)
+      else
+        assocs = parent.children(path.shift)
+      end
+      
+      until path.empty?
+        point  = path.shift
+        assocs = assocs.collect { |assoc| assoc.children(point) }.flatten
+      end
+      
+      assocs
+    end
+  end
+end

data/lib/thinking_sphinx/property.rb

@@ -0,0 +1,185 @@
+module ThinkingSphinx
+  class Property
+    attr_accessor :alias, :columns, :associations, :model, :faceted, :admin
+    
+    def initialize(source, columns, options = {})
+      @source       = source
+      @model        = source.model
+      @columns      = Array(columns)
+      @associations = {}
+
+      raise "Cannot define a field or attribute in #{source.model.name} 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]
+      @faceted      = options[:facet]
+      @admin        = options[:admin]
+      @sortable     = options[:sortable] || false
+      @value_source = options[:value]
+      
+      @alias    = @alias.to_sym unless @alias.blank?
+      
+      @columns.each { |col|
+        @associations[col] = association_stack(col.__stack.clone).each { |assoc|
+          assoc.join_to(source.base)
+        }
+      }
+    end
+    
+    # Returns the unique name of the attribute - which is either the alias of
+    # the attribute, 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, @value_source)
+    end
+    
+    # Get the part of the GROUP BY clause related to this attribute - if one is
+    # needed. If not, all you'll get back is nil. The latter will happen if
+    # there isn't actually a real column to get data from, or 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?, is_string?, ThinkingSphinx.use_group_by_shortcut?
+        nil
+      else
+        @columns.collect { |column|
+          column_with_prefix(column)
+        }
+      end
+    end
+    
+    def changed?(instance)
+      return true if is_string? || @columns.any? { |col| !col.__stack.empty? }
+      
+      @columns.any? { |col|
+        instance.send("#{col.__name.to_s}_changed?")
+      }
+    end
+    
+    def admin?
+      admin
+    end
+    
+    def public?
+      !admin
+    end
+    
+    def available?
+      columns.any? { |column| column_available?(column) }
+    end
+    
+    private
+    
+    # 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
+    
+    # Returns true if any of the columns are string values, instead of database
+    # column references.
+    def is_string?
+      columns.all? { |col| col.is_string? }
+    end
+    
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
+    end
+    
+    def quote_with_table(table, column)
+      "#{quote_table_name(table)}.#{quote_column(column)}"
+    end
+    
+    def quote_column(column)
+      @model.connection.quote_column_name(column)
+    end
+    
+    def quote_table_name(table_name)
+      @model.connection.quote_table_name(table_name)
+    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?
+      multiple_associations? || @columns.length > 1
+    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)
+      return nil unless column_available?(column)
+      
+      if column.is_string?
+        column.__name
+      elsif column.__stack.empty?
+        "#{@model.quoted_table_name}.#{quote_column(column.__name)}"
+      else
+        associations[column].collect { |assoc|
+          assoc.has_column?(column.__name) ?
+          "#{quote_with_table(assoc.join.aliased_table_name, column.__name)}" :
+          nil
+        }.compact
+      end
+    end
+    
+    def columns_with_prefixes
+      @columns.collect { |column|
+        column_with_prefix column
+      }.flatten.compact
+    end
+    
+    def column_available?(column)
+      if column.is_string?
+        true
+      elsif column.__stack.empty?
+        @model.column_names.include?(column.__name.to_s)
+      else
+        associations[column].any? { |assoc| assoc.has_column?(column.__name) }
+      end
+    end
+    
+    # Gets a stack of associations for a specific path.
+    # 
+    def association_stack(path, parent = nil)
+      assocs = []
+      
+      if parent.nil?
+        assocs = @source.association(path.shift)
+      else
+        assocs = parent.children(path.shift)
+      end
+      
+      until path.empty?
+        point  = path.shift
+        assocs = assocs.collect { |assoc| assoc.children(point) }.flatten
+      end
+      
+      assocs
+    end
+  end
+end

data/lib/thinking_sphinx/railtie.rb

@@ -0,0 +1,46 @@
+require 'thinking_sphinx'
+require 'rails'
+
+module ThinkingSphinx
+  class Railtie < Rails::Railtie
+    
+    initializer 'thinking_sphinx.sphinx' do
+      ThinkingSphinx::AutoVersion.detect
+    end
+
+    initializer "thinking_sphinx.active_record" do
+      ActiveSupport.on_load :active_record do
+        include ThinkingSphinx::ActiveRecord
+      end
+    end
+
+    initializer "thinking_sphinx.action_controller" do
+      ActiveSupport.on_load :action_controller do
+        require 'thinking_sphinx/action_controller'
+        include ThinkingSphinx::ActionController
+      end
+    end
+
+    initializer "thinking_sphinx.set_app_root" do |app|
+      ThinkingSphinx::Configuration.instance.reset # Rails has setup app now
+    end
+
+    config.to_prepare do
+      I18n.backend.reload!
+      I18n.backend.available_locales
+      
+      # ActiveRecord::Base.to_crc32s is dependant on the subclasses being loaded
+      # consistently. When the environment is reset, subclasses/descendants will
+      # be lost but our context will not reload them for us.
+      #
+      # We reset the context which causes the subclasses/descendants to be
+      # reloaded next time the context is called.
+      # 
+      ThinkingSphinx.reset_context!
+    end
+
+    rake_tasks do
+      load File.expand_path('../tasks.rb', __FILE__)
+    end
+  end
+end