skalee-thinking-sphinx 1.3.14.1

data/lib/thinking_sphinx/index/faux_column.rb

@@ -0,0 +1,110 @@
+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
+      
+      # 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
+      
+      # 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/property.rb

@@ -0,0 +1,162 @@
+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]
+      
+      @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)
+    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.all? { |col|
+        instance.respond_to?("#{col.__name.to_s}_changed?") &&
+        !instance.send("#{col.__name.to_s}_changed?")
+      }
+    end
+    
+    def admin?
+      admin
+    end
+    
+    def public?
+      !admin
+    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)
+      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) ?
+          "#{quote_with_table(assoc.join.aliased_table_name, column.__name)}" :
+          nil
+        }.compact.join(', ')
+      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/rails_additions.rb

@@ -0,0 +1,150 @@
+module ThinkingSphinx
+  module HashExcept
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+  end
+end
+
+Hash.send(
+  :include, ThinkingSphinx::HashExcept
+) unless Hash.instance_methods.include?("except")
+
+module ThinkingSphinx
+  module ArrayExtractOptions
+    def extract_options!
+      last.is_a?(::Hash) ? pop : {}
+    end
+  end
+end
+
+Array.send(
+  :include, ThinkingSphinx::ArrayExtractOptions
+) unless Array.instance_methods.include?("extract_options!")
+
+module ThinkingSphinx
+  module AbstractQuotedTableName
+    def quote_table_name(name)
+      quote_column_name(name)
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(
+  :include, ThinkingSphinx::AbstractQuotedTableName
+) unless ActiveRecord::ConnectionAdapters::AbstractAdapter.instance_methods.include?("quote_table_name")
+
+module ThinkingSphinx
+  module MysqlQuotedTableName
+    def quote_table_name(name) #:nodoc:
+      quote_column_name(name).gsub('.', '`.`')
+    end
+  end
+end
+
+if ActiveRecord::ConnectionAdapters.constants.include?("MysqlAdapter") or ActiveRecord::Base.respond_to?(:jdbcmysql_connection)
+  adapter = ActiveRecord::ConnectionAdapters.const_get(
+    defined?(JRUBY_VERSION) ? :JdbcAdapter : :MysqlAdapter
+  )
+  unless adapter.instance_methods.include?("quote_table_name")
+    adapter.send(:include, ThinkingSphinx::MysqlQuotedTableName)
+  end
+end
+
+module ThinkingSphinx
+  module ActiveRecordQuotedName
+    def quoted_table_name
+      self.connection.quote_table_name(self.table_name)
+    end 
+  end
+end
+
+ActiveRecord::Base.extend(
+  ThinkingSphinx::ActiveRecordQuotedName
+) unless ActiveRecord::Base.respond_to?("quoted_table_name")
+
+module ThinkingSphinx
+  module ActiveRecordStoreFullSTIClass
+    def store_full_sti_class
+      false
+    end
+  end
+end
+
+ActiveRecord::Base.extend(
+  ThinkingSphinx::ActiveRecordStoreFullSTIClass
+) unless ActiveRecord::Base.respond_to?(:store_full_sti_class)
+
+module ThinkingSphinx
+  module ClassAttributeMethods
+    def cattr_reader(*syms)
+      syms.flatten.each do |sym|
+        next if sym.is_a?(Hash)
+        class_eval(<<-EOS, __FILE__, __LINE__)
+          unless defined? @@#{sym}
+            @@#{sym} = nil
+          end
+
+          def self.#{sym}
+            @@#{sym}
+          end
+
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+      end
+    end
+
+    def cattr_writer(*syms)
+      options = syms.extract_options!
+      syms.flatten.each do |sym|
+        class_eval(<<-EOS, __FILE__, __LINE__)
+          unless defined? @@#{sym}
+            @@#{sym} = nil
+          end
+
+          def self.#{sym}=(obj)
+            @@#{sym} = obj
+          end
+
+          #{"
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+          " unless options[:instance_writer] == false }
+        EOS
+      end
+    end
+
+    def cattr_accessor(*syms)
+      cattr_reader(*syms)
+      cattr_writer(*syms)
+    end
+  end
+end
+
+Class.extend(
+  ThinkingSphinx::ClassAttributeMethods
+) unless Class.respond_to?(:cattr_reader)
+
+module ThinkingSphinx
+  module MetaClass
+    def singleton_class
+      class << self
+        self
+      end
+    end
+  end
+end
+
+unless Object.new.respond_to?(:singleton_class)
+  Object.send(:include, ThinkingSphinx::MetaClass)
+end