thinking-sphinx 1.5.0 → 2.0.0.rc1

data/lib/thinking_sphinx/field.rb

@@ -19,8 +19,6 @@ module ThinkingSphinx
     # - :sortable => true
     # - :infixes  => true
     # - :prefixes => true
-    # - :file     => true
-    # - :with     => :attribute # or :wordcount
     #
     # Alias is only required in three circumstances: when there's
     # another attribute or field with the same name, when the column name is
@@ -60,8 +58,6 @@ module ThinkingSphinx
       @sortable = options[:sortable] || false
       @infixes  = options[:infixes]  || false
       @prefixes = options[:prefixes] || false
-      @file     = options[:file]     || false
-      @with     = options[:with]
       
       source.fields << self
     end
@@ -73,8 +69,6 @@ module ThinkingSphinx
     # multiple data values (has_many or has_and_belongs_to_many associations).
     # 
     def to_select_sql
-      return nil unless available?
-      
       clause = columns_with_prefixes.join(', ')
       
       clause = adapter.concatenate(clause)       if concat_ws?
@@ -82,17 +76,5 @@ module ThinkingSphinx
       
       "#{clause} AS #{quote_column(unique_name)}"
     end
-    
-    def file?
-      @file
-    end
-    
-    def with_attribute?
-      @with == :attribute
-    end
-    
-    def with_wordcount?
-      @with == :wordcount
-    end
   end
 end

data/lib/thinking_sphinx/index.rb

@@ -3,8 +3,8 @@ require 'thinking_sphinx/index/faux_column'
 
 module ThinkingSphinx
   class Index
-    attr_accessor :name, :model, :sources, :delta_object, :additional_indices
-
+    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.
@@ -13,9 +13,9 @@ module ThinkingSphinx
     #
     #   Index.new(User) do
     #     indexes login, email
-    #
+    #     
     #     has created_at
-    #
+    #     
     #     set_property :delta => true
     #   end
     #
@@ -25,48 +25,47 @@ module ThinkingSphinx
       @sources      = []
       @options      = {}
       @delta_object = nil
-      @additional_indices = []
     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|
@@ -75,83 +74,82 @@ module ThinkingSphinx
       }.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_indices << core_name
-      index.local_indices += additional_indices
-      index.local_indices.unshift delta_name if delta?
+      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

data/lib/thinking_sphinx/index/builder.rb

@@ -11,7 +11,7 @@ module ThinkingSphinx
     # your indexes. #where provides a method to add manual SQL conditions, and
     # set_property allows you to set some settings on a per-index basis. Check
     # out each method's documentation for better ideas of usage.
-    #
+    # 
     class Builder
       instance_methods.grep(/^[^_]/).each { |method|
         next if method.to_s == "instance_eval"
@@ -19,28 +19,28 @@ module ThinkingSphinx
           caller.grep(/irb.completion/).empty? ? method_missing(method) : super
         }
       }
-
+      
       def self.generate(model, name = nil, &block)
         index  = ThinkingSphinx::Index.new(model)
         index.name = name unless name.nil?
-
+        
         Builder.new(index, &block) if block_given?
-
+        
         index.delta_object = ThinkingSphinx::Deltas.parse index
         index
       end
-
+      
       def initialize(index, &block)
         @index  = index
         @explicit_source = false
-
+        
         self.instance_eval &block
-
+        
         if no_fields?
           raise "At least one field is necessary for an index"
         end
       end
-
+      
       def define_source(&block)
         if @explicit_source
           @source = ThinkingSphinx::Source.new(@index)
@@ -48,15 +48,10 @@ module ThinkingSphinx
         else
           @explicit_source = true
         end
-
+        
         self.instance_eval &block
       end
-
-      def use_local_indices(*indexes)
-        @index.additional_indices += indexes.map {|index_name| "#{index_name.to_s}_core"}
-      end
-      alias_method :use_local_index, :use_local_indices
-
+      
       # This is how you add fields - the strings Sphinx looks at - to your
       # index. Technically, to use this method, you need to pass in some
       # columns and options - but there's some neat method_missing stuff
@@ -68,26 +63,26 @@ module ThinkingSphinx
       # field.
       #
       # Adding Single-Column Fields:
-      #
+      # 
       # You can use symbols or methods - and can chain methods together to
       # get access down the associations tree.
-      #
+      # 
       #   indexes :id, :as => :my_id
       #   indexes :name, :sortable => true
       #   indexes first_name, last_name, :sortable => true
       #   indexes users.posts.content, :as => :post_content
       #   indexes users(:id), :as => :user_ids
       #
-      # Keep in mind that if any keywords for Ruby methods - such as id or
+      # Keep in mind that if any keywords for Ruby methods - such as id or 
       # name - clash with your column names, you need to use the symbol
       # version (see the first, second and last examples above).
       #
       # If you specify multiple columns (example #2), a field will be created
       # for each. Don't use the :as option in this case. If you want to merge
       # those columns together, continue reading.
-      #
+      # 
       # Adding Multi-Column Fields:
-      #
+      # 
       #   indexes [first_name, last_name], :as => :name
       #   indexes [location, parent.location], :as => :location
       #
@@ -95,7 +90,7 @@ module ThinkingSphinx
       # them in an Array, as shown by the above examples. There's no
       # limitations on whether they're symbols or methods or what level of
       # associations they come from.
-      #
+      # 
       # Adding SQL Fragment Fields
       #
       # You can also define a field using an SQL fragment, useful for when
@@ -107,37 +102,37 @@ module ThinkingSphinx
         options = args.extract_options!
         args.each do |columns|
           field = Field.new(source, FauxColumn.coerce(columns), options)
-
+          
           add_sort_attribute  field, options   if field.sortable
           add_facet_attribute field, options   if field.faceted
         end
       end
-
+      
       # This is the method to add attributes to your index (hence why it is
       # aliased as 'attribute'). The syntax is the same as #indexes, so use
       # that as starting point, but keep in mind the following points.
-      #
+      # 
       # An attribute can have an alias (the :as option), but it is always
       # sortable - so you don't need to explicitly request that. You _can_
       # specify the data type of the attribute (the :type option), but the
       # code's pretty good at figuring that out itself from peering into the
       # database.
-      #
+      # 
       # Attributes are limited to the following types: integers, floats,
       # datetimes (converted to timestamps), booleans, strings and MVAs
       # (:multi). Don't forget that Sphinx converts string attributes to
       # integers, which are useful for sorting, but that's about it.
-      #
+      # 
       # Collection of integers are known as multi-value attributes (MVAs).
       # Generally these would be through a has_many relationship, like in this
       # example:
-      #
+      # 
       #   has posts(:id), :as => :post_ids
-      #
+      # 
       # This allows you to filter on any of the values tied to a specific
       # record. Might be best to read through the Sphinx documentation to get
       # a better idea of that though.
-      #
+      # 
       # Adding SQL Fragment Attributes
       #
       # You can also define an attribute using an SQL fragment, useful for
@@ -145,68 +140,68 @@ module ThinkingSphinx
       # the type of the attribute though:
       #
       #   has "age < 18", :as => :minor, :type => :boolean
-      #
+      # 
       # If you're creating attributes for latitude and longitude, don't
       # forget that Sphinx expects these values to be in radians.
-      #
+      # 
       def has(*args)
         options = args.extract_options!
         args.each do |columns|
           attribute = Attribute.new(source, FauxColumn.coerce(columns), options)
-
+          
           add_facet_attribute attribute, options if attribute.faceted
         end
       end
-
+      
       def facet(*args)
         options = args.extract_options!
         options[:facet] = true
-
+        
         args.each do |columns|
           attribute = Attribute.new(source, FauxColumn.coerce(columns), options)
-
+          
           add_facet_attribute attribute, options
         end
       end
-
+      
       def join(*args)
         args.each do |association|
           Join.new(source, association)
         end
       end
-
+      
       # Use this method to add some manual SQL conditions for your index
       # request. You can pass in as many strings as you like, they'll get
       # joined together with ANDs later on.
-      #
+      # 
       #   where "user_id = 10"
       #   where "parent_type = 'Article'", "created_at < NOW()"
-      #
+      # 
       def where(*args)
         source.conditions += args
       end
-
+      
       # Use this method to add some manual SQL strings to the GROUP BY
       # clause. You can pass in as many strings as you'd like, they'll get
       # joined together with commas later on.
-      #
+      # 
       #   group_by "lat", "lng"
-      #
+      # 
       def group_by(*args)
         source.groupings += args
       end
-
+      
       # This is what to use to set properties on the index. Chief amongst
       # those is the delta property - to allow automatic updates to your
       # indexes as new models are added and edited - but also you can
       # define search-related properties which will be the defaults for all
       # searches on the model.
-      #
+      # 
       #   set_property :delta => true
       #   set_property :field_weights => {"name" => 100}
       #   set_property :order => "name ASC"
       #   set_property :select => 'name'
-      #
+      # 
       # Also, the following two properties are particularly relevant for
       # geo-location searching - latitude_attr and longitude_attr. If your
       # attributes for these two values are named something other than
@@ -215,59 +210,49 @@ module ThinkingSphinx
       # geo-related search.
       #
       #   set_property :latitude_attr => "lt", :longitude_attr => "lg"
-      #
+      # 
       # Please don't forget to add a boolean field named 'delta' to your
       # model's database table if enabling the delta index for it.
       # Valid options for the delta property are:
-      #
+      # 
       # true
       # false
       # :default
       # :delayed
       # :datetime
-      #
-      # You can also extend ThinkingSphinx::Deltas::DefaultDelta to implement
+      # 
+      # You can also extend ThinkingSphinx::Deltas::DefaultDelta to implement 
       # your own handling for delta indexing.
-      #
+      # 
       def set_property(*args)
         options = args.extract_options!
         options.each do |key, value|
           set_single_property key, value
         end
-
+        
         set_single_property args[0], args[1] if args.length == 2
       end
       alias_method :set_properties, :set_property
-
+      
       # Handles the generation of new columns for the field and attribute
       # definitions.
-      #
+      # 
       def method_missing(method, *args)
         FauxColumn.new(method, *args)
       end
-
+      
       # A method to allow adding fields from associations which have names
       # that clash with method names in the Builder class (ie: properties,
       # fields, attributes).
-      #
+      # 
       # Example: indexes assoc(:properties).column
-      #
+      # 
       def assoc(assoc, *args)
         FauxColumn.new(assoc, *args)
       end
-
-      # Use this method to generate SQL for your attributes, conditions, etc.
-      # You can pass in as whatever ActiveRecord::Base.sanitize_sql accepts.
-      #
-      #   where sanitize_sql(["active = ?", true])
-      #   #=> WHERE active = 1
-      #
-      def sanitize_sql(*args)
-        @index.model.send(:sanitize_sql, *args)
-      end
-
+      
       private
-
+      
       def source
         @source ||= begin
           source = ThinkingSphinx::Source.new(@index)
@@ -275,7 +260,7 @@ module ThinkingSphinx
           source
         end
       end
-
+      
       def set_single_property(key, value)
         source_options = ThinkingSphinx::Configuration::SourceOptions
         if source_options.include?(key.to_s)
@@ -284,19 +269,19 @@ module ThinkingSphinx
           @index.local_options.merge!  key => value
         end
       end
-
+      
       def add_sort_attribute(field, options)
         add_internal_attribute field, options, "_sort"
       end
-
+      
       def add_facet_attribute(property, options)
         add_internal_attribute property, options, "_facet", true
         @index.model.sphinx_facets << property.to_facet
       end
-
+      
       def add_internal_attribute(property, options, suffix, crc = false)
         return unless ThinkingSphinx::Facet.translate?(property)
-
+        
         Attribute.new(source,
           property.columns.collect { |col| col.clone },
           options.merge(
@@ -306,7 +291,7 @@ module ThinkingSphinx
           ).except(:facet)
         )
       end
-
+      
       def no_fields?
         @index.sources.empty? || @index.sources.any? { |source|
           source.fields.length == 0