thinking-sphinx 1.4.5 → 1.4.6

data/README.textile

@@ -191,3 +191,4 @@ Since I first released this library, there's been quite a few people who have su
 * Clemens Kofler
 * Ryan Mohr
 * Alex Chee
+* Bruno Santschi

data/VERSION

@@ -1 +1 @@
-1.4.5
+1.4.6

data/features/searching_by_model.feature

@@ -66,6 +66,12 @@ Feature: Searching on a single model
     When I filter by 2001-01-01 on comments_created_at
     Then I should get 1 result
   
+  Scenario: Filtering on a wordcount attribute
+    Given Sphinx is running
+    And I am searching on developers
+    When I filter between 0 and 1 on state_wordcount
+    Then I should get 5 results
+  
   Scenario: Searching by NULL/0 values in MVAs
     Given Sphinx is running
     And I am searching on boxes
@@ -166,3 +172,10 @@ Feature: Searching on a single model
     And I am searching on posts
     When I search for "Shakespeare"
     Then I should get 1 result
+  
+  Scenario: Searching on content from file field
+    Given Sphinx is running
+    And I am searching on posts
+    When I search for "foo bar baz"
+    Then I should get 1 result
+  

data/features/thinking_sphinx/db/fixtures/posts.rb

@@ -1,5 +1,9 @@
 post = Post.create(
-  :subject => "Hello World", :content => "Um Text", :id => 1, :category_id => 1
+  :subject => "Hello World",
+  :content => "Um Text",
+  :id => 1,
+  :category_id => 1,
+  :keywords_file => (File.dirname(__FILE__) + '/post_keywords.txt')
 )
 
 post.authors << Author.find(:first)

data/features/thinking_sphinx/db/migrations/create_posts.rb

@@ -2,4 +2,5 @@ ActiveRecord::Base.connection.create_table :posts, :force => true do |t|
   t.column :subject, :string,  :null => false
   t.column :content, :text
   t.column :category_id, :integer, :null => false
+  t.column :keywords_file, :string
 end

data/features/thinking_sphinx/models/developer.rb

@@ -12,6 +12,7 @@ class Developer < ActiveRecord::Base
     
     has age,                              :facet => true
     has tags(:id),      :as => :tag_ids,  :facet => true
+    has state,          :as => :state_wordcount, :type => :wordcount
     
     facet "LOWER(city)", :as => :city, :type => :string, :value => :city
     

data/features/thinking_sphinx/models/music.rb

@@ -2,7 +2,9 @@ class Music < Medium
   set_table_name 'music'
   
   define_index do
-    indexes artist, track, album
+    indexes artist, :with => :attribute
+    indexes track
+    indexes album, :with => :wordcount
     indexes genre(:name), :as => :genre
   end
 end

data/features/thinking_sphinx/models/post.rb

@@ -11,6 +11,7 @@ class Post < ActiveRecord::Base
     indexes tags.text, :as => :tags
     indexes comments.content, :as => :comments
     indexes authors.name, :as => :authors
+    indexes keywords_file, :as => :keywords, :file => true
     
     has comments(:id), :as => :comment_ids, :source => :ranged_query,
       :facet => true

data/lib/thinking_sphinx.rb

@@ -108,8 +108,8 @@ module ThinkingSphinx
     end
   end
 
-  def self.unique_id_expression(offset = nil)
-    "* #{context.indexed_models.size} + #{offset || 0}"
+  def self.unique_id_expression(adapter, offset = nil)
+    "* #{adapter.cast_to_int context.indexed_models.size} + #{offset || 0}"
   end
 
   # Check if index definition is disabled.

data/lib/thinking_sphinx/active_record.rb

@@ -285,6 +285,33 @@ module ThinkingSphinx
           index eldest_indexed_ancestor
       end
       
+      # Temporarily disable delta indexing inside a block, then perform a
+      # single rebuild of index at the end.
+      #
+      # Useful when performing updates to batches of models to prevent
+      # the delta index being rebuilt after each individual update.
+      #
+      # In the following example, the delta index will only be rebuilt
+      # once, not 10 times.
+      #
+      #   SomeModel.suspended_delta do
+      #     10.times do
+      #       SomeModel.create( ... )
+      #     end
+      #   end
+      #
+      def suspended_delta(reindex_after = true, &block)
+        define_indexes
+        original_setting = ThinkingSphinx.deltas_suspended?
+        ThinkingSphinx.deltas_suspended = true
+        begin
+          yield
+        ensure
+          ThinkingSphinx.deltas_suspended = original_setting
+          self.index_delta if reindex_after
+        end
+      end
+      
       private
             
       def local_sphinx_indexes

data/lib/thinking_sphinx/active_record/delta.rb

@@ -22,33 +22,6 @@ module ThinkingSphinx
             def delta_objects
               self.sphinx_indexes.collect(&:delta_object).compact
             end
-            
-            # Temporarily disable delta indexing inside a block, then perform a
-            # single rebuild of index at the end.
-            #
-            # Useful when performing updates to batches of models to prevent
-            # the delta index being rebuilt after each individual update.
-            #
-            # In the following example, the delta index will only be rebuilt
-            # once, not 10 times.
-            #
-            #   SomeModel.suspended_delta do
-            #     10.times do
-            #       SomeModel.create( ... )
-            #     end
-            #   end
-            #
-            def suspended_delta(reindex_after = true, &block)
-              define_indexes
-              original_setting = ThinkingSphinx.deltas_suspended?
-              ThinkingSphinx.deltas_suspended = true
-              begin
-                yield
-              ensure
-                ThinkingSphinx.deltas_suspended = original_setting
-                self.index_delta if reindex_after
-              end
-            end
           end
           
           def toggled_delta?

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -28,6 +28,10 @@ module ThinkingSphinx
       "CAST(#{clause} AS UNSIGNED)"
     end
     
+    def cast_to_int(clause)
+      "CAST(#{clause} AS SIGNED)"
+    end
+    
     def convert_nulls(clause, default = '')
       default = "'#{default}'" if default.is_a?(String)
       

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -35,6 +35,10 @@ module ThinkingSphinx
       clause
     end
     
+    def cast_to_int(clause)
+      "#{clause}::INT8"
+    end
+    
     def convert_nulls(clause, default = '')
       default = case default
       when String

data/lib/thinking_sphinx/association.rb

@@ -71,9 +71,7 @@ module ThinkingSphinx
     # join conditions avoid column name collisions.
     # 
     def to_sql
-      @join.association_join.gsub(/::ts_join_alias::/,
-        "#{@reflection.klass.connection.quote_table_name(@join.parent.aliased_table_name)}"
-      )
+      rewrite_conditions
     end
     
     # Returns true if the association - or a parent - is a has_many or
@@ -160,5 +158,27 @@ module ThinkingSphinx
       
       options
     end
+    
+    def rewrite_conditions
+      rewrite_condition @join.association_join
+    end
+    
+    def rewrite_condition(condition)
+      return condition unless condition.is_a?(String)
+      
+      if defined?(ActsAsTaggableOn) &&
+        @reflection.klass == ActsAsTaggableOn::Tagging &&
+        @reflection.name.to_s[/_taggings$/]
+        condition = condition.gsub /taggings\./, "#{quoted_alias @join}."
+      end
+      
+      condition.gsub /::ts_join_alias::/, quoted_alias(@join.parent)
+    end
+    
+    def quoted_alias(join)
+      @reflection.klass.connection.quote_table_name(
+        join.aliased_table_name
+      )
+    end
   end
 end

data/lib/thinking_sphinx/attribute.rb

@@ -11,6 +11,21 @@ module ThinkingSphinx
   class Attribute < ThinkingSphinx::Property
     attr_accessor :query_source
     
+    SphinxTypeMappings = {
+      :multi     => :sql_attr_multi,
+      :datetime  => :sql_attr_timestamp,
+      :string    => :sql_attr_str2ordinal,
+      :float     => :sql_attr_float,
+      :boolean   => :sql_attr_bool,
+      :integer   => :sql_attr_uint,
+      :bigint    => :sql_attr_bigint,
+      :wordcount => :sql_attr_str2wordcount
+    }
+    
+    if Riddle.loaded_version.to_i > 1
+      SphinxTypeMappings[:string] = :sql_attr_string
+    end
+    
     # To create a new attribute, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options.
     #
@@ -117,15 +132,7 @@ module ThinkingSphinx
     end
     
     def type_to_config
-      {
-        :multi    => :sql_attr_multi,
-        :datetime => :sql_attr_timestamp,
-        :string   => :sql_attr_str2ordinal,
-        :float    => :sql_attr_float,
-        :boolean  => :sql_attr_bool,
-        :integer  => :sql_attr_uint,
-        :bigint   => :sql_attr_bigint
-      }[type]
+      SphinxTypeMappings[type]
     end
     
     def include_as_association?
@@ -226,7 +233,7 @@ module ThinkingSphinx
       
       <<-SQL
 SELECT #{foreign_key_for_mva base_assoc}
-  #{ThinkingSphinx.unique_id_expression(offset)} AS #{quote_column('id')},
+  #{ThinkingSphinx.unique_id_expression(adapter, offset)} AS #{quote_column('id')},
   #{primary_key_for_mva(end_assoc)} AS #{quote_column(unique_name)}
 FROM #{quote_table_name base_assoc.table} #{association_joins}
       SQL

data/lib/thinking_sphinx/auto_version.rb

@@ -7,7 +7,7 @@ module ThinkingSphinx
         require "riddle/#{version}"
       when /1.10/
         require 'riddle/1.10'
-      when /2.0.1/
+      when /2.0.\d/
         require 'riddle/2.0.1'
       else
         documentation_link = %Q{

data/lib/thinking_sphinx/class_facet.rb

@@ -5,12 +5,16 @@ module ThinkingSphinx
     end
     
     def attribute_name
-      "class_crc"
+      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
     end
     
     def value(object, attribute_hash)
-      crc = attribute_hash['class_crc']
-      ThinkingSphinx::Configuration.instance.models_by_crc[crc]
+      if Riddle.loaded_version.to_i < 2
+        crc = attribute_hash['class_crc']
+        ThinkingSphinx::Configuration.instance.models_by_crc[crc]
+      else
+        attribute_hash['sphinx_internal_class']
+      end
     end
   end
 end

data/lib/thinking_sphinx/configuration.rb

@@ -91,10 +91,10 @@ module ThinkingSphinx
       if custom_app_root
         self.app_root = custom_app_root
       else
-        self.app_root          = RAILS_ROOT                 if defined?(RAILS_ROOT)
-        self.app_root          = Merb.root                  if defined?(Merb)
-        self.app_root          = Sinatra::Application.root  if defined?(Sinatra)
-        self.app_root        ||= app_root
+        self.app_root   = Merb.root                  if defined?(Merb)
+        self.app_root   = Sinatra::Application.root  if defined?(Sinatra)
+        self.app_root   = RAILS_ROOT                 if defined?(RAILS_ROOT)
+        self.app_root ||= app_root
       end
       
       @configuration = Riddle::Configuration.new
@@ -132,10 +132,10 @@ module ThinkingSphinx
         ThinkingSphinx.mutex.synchronize do
           @@environment ||= if defined?(Merb)
             Merb.environment
-          elsif defined?(Sinatra)
-            Sinatra::Application.environment.to_s
           elsif defined?(RAILS_ENV)
             RAILS_ENV
+          elsif defined?(Sinatra)
+            Sinatra::Application.environment.to_s
           else
             ENV['RAILS_ENV'] || 'development'
           end

data/lib/thinking_sphinx/facet.rb

@@ -16,6 +16,7 @@ module ThinkingSphinx
       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

data/lib/thinking_sphinx/facet_search.rb

@@ -29,7 +29,7 @@ module ThinkingSphinx
         names = options[:all_facets] ?
           facet_names_for_all_classes : facet_names_common_to_all_classes
         
-        names.delete "class_crc" unless options[:class_facet]
+        names.delete class_facet unless options[:class_facet]
         names
       end
     end
@@ -162,5 +162,9 @@ module ThinkingSphinx
         facet.name == name
       }
     end
+    
+    def class_facet
+      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
+    end
   end
 end

data/lib/thinking_sphinx/field.rb

@@ -19,6 +19,8 @@ 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
@@ -58,6 +60,8 @@ 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
@@ -78,5 +82,17 @@ 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/search.rb

@@ -22,7 +22,7 @@ module ThinkingSphinx
       undef_method method
     }
     
-    HashOptions   = [:conditions, :with, :without, :with_all]
+    HashOptions   = [:conditions, :with, :without, :with_all, :without_any]
     ArrayOptions  = [:classes, :without_ids]
     
     attr_reader :args, :options
@@ -474,9 +474,12 @@ module ThinkingSphinx
     
     def match_hash(object)
       @results[:matches].detect { |match|
+        class_crc = object.class.name
+        class_crc = object.class.to_crc32 if Riddle.loaded_version.to_i < 2
+        
         match[:attributes]['sphinx_internal_id'] == object.
           primary_key_for_sphinx &&
-        match[:attributes]['class_crc'] == object.class.to_crc32
+        match[:attributes][crc_attribute] == class_crc
       }
     end
     
@@ -714,6 +717,11 @@ module ThinkingSphinx
         Array(values).collect { |value|
           Riddle::Client::Filter.new attrib.to_s, filter_value(value)
         }
+      }.flatten +
+      (options[:without_any] || {}).collect { |attrib, values|
+        Array(values).collect { |value|
+          Riddle::Client::Filter.new attrib.to_s, filter_value(value), true
+        }
       }.flatten
     end
     
@@ -869,7 +877,7 @@ module ThinkingSphinx
       return single_class_results if one_class
       
       groups = results[:matches].group_by { |match|
-        match[:attributes]["class_crc"]
+        match[:attributes][crc_attribute]
       }
       groups.each do |crc, group|
         group.replace(
@@ -879,7 +887,7 @@ module ThinkingSphinx
       
       results[:matches].collect do |match|
         groups.detect { |crc, group|
-          crc == match[:attributes]["class_crc"]
+          crc == match[:attributes][crc_attribute]
         }[1].compact.detect { |obj|
           obj.primary_key_for_sphinx == match[:attributes]["sphinx_internal_id"]
         }
@@ -891,7 +899,11 @@ module ThinkingSphinx
     end
     
     def class_from_crc(crc)
-      config.models_by_crc[crc].constantize
+      if Riddle.loaded_version.to_i < 2
+        config.models_by_crc[crc].constantize
+      else
+        crc.constantize
+      end
     end
     
     def each_with_attribute(attribute, &block)
@@ -944,5 +956,9 @@ module ThinkingSphinx
       
       results_count
     end
+    
+    def crc_attribute
+      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
+    end
   end
 end

data/lib/thinking_sphinx/source.rb

@@ -45,6 +45,7 @@ module ThinkingSphinx
       )
       
       set_source_database_settings  source
+      set_source_fields             source
       set_source_attributes         source, offset
       set_source_settings           source
       set_source_sql                source, offset
@@ -59,6 +60,7 @@ module ThinkingSphinx
       source.parent = "#{index.core_name}_#{position}"
       
       set_source_database_settings  source
+      set_source_fields             source
       set_source_attributes         source, offset, true
       set_source_settings           source
       set_source_sql                source, offset, true
@@ -97,6 +99,14 @@ module ThinkingSphinx
       source.sql_sock = config[:socket]
     end
     
+    def set_source_fields(source)
+      fields.each do |field|
+        source.sql_file_field   << field.unique_name if field.file?
+        source.sql_field_string << field.unique_name if field.with_attribute?
+        source.sql_field_str2wordcount << field.unique_name if field.with_wordcount?
+      end
+    end
+    
     def set_source_attributes(source, offset, delta = false)
       available_attributes.each do |attrib|
         source.send(attrib.type_to_config) << attrib.config_value(offset, delta)

data/lib/thinking_sphinx/source/internal_properties.rb

@@ -4,10 +4,15 @@ module ThinkingSphinx
       def add_internal_attributes_and_facets
         add_internal_attribute :sphinx_internal_id, nil,
           @model.primary_key_for_sphinx.to_sym
-        add_internal_attribute :class_crc,          :integer, crc_column, true
         add_internal_attribute :sphinx_deleted,     :integer, "0"
-
-        add_internal_facet :class_crc
+        add_internal_attribute :class_crc,          :integer, crc_column, true
+        
+        unless Riddle.loaded_version.to_i < 2
+          add_internal_attribute :sphinx_internal_class, :string, internal_class_column, true
+          add_internal_facet :sphinx_internal_class
+        else
+          add_internal_facet :class_crc
+        end
       end
 
       def add_internal_attribute(name, type, contents, facet = false)

data/lib/thinking_sphinx/source/sql.rb

@@ -59,7 +59,7 @@ GROUP BY #{ sql_group_clause }
       end
 
       def sql_select_clause(offset)
-        unique_id_expr = ThinkingSphinx.unique_id_expression(offset)
+        unique_id_expr = ThinkingSphinx.unique_id_expression(adapter, offset)
 
         (
           ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key_for_sphinx)} #{unique_id_expr} AS #{quote_column(@model.primary_key_for_sphinx)} "] + 
@@ -128,6 +128,15 @@ GROUP BY #{ sql_group_clause }
         end
       end
       
+      def internal_class_column
+        if @model.table_exists? &&
+          @model.column_names.include?(@model.inheritance_column)
+          adapter.quote_with_table(@model.inheritance_column)
+        else
+          "'#{@model.name}'"
+        end
+      end
+      
       def type_values
         @model.connection.select_values <<-SQL
 SELECT DISTINCT #{@model.inheritance_column}

data/spec/thinking_sphinx/attribute_spec.rb

@@ -298,184 +298,176 @@ describe ThinkingSphinx::Attribute do
   end
   
   describe "MVA with source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = @attribute.config_value.split('; ')
+      declaration, query = attribute.config_value.split('; ')
       declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
     end
   end
   
   describe "MVA with source query for a delta source" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = @attribute.config_value(nil, true).split('; ')
+      declaration, query = attribute.config_value(nil, true).split('; ')
       declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
     end
   end
   
   describe "MVA via a HABTM association with a source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-        :as => :link_ids, :source => :query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+      :as => :link_ids, :source => :query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = @attribute.config_value.split('; ')
+      declaration, query = attribute.config_value.split('; ')
       declaration.should == "uint link_ids from query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
     end
   end
   
   describe "MVA with ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA with ranged source query for a delta source" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
+      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
       declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA via a has-many :through with a ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
-        :as => :football_team_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
+      :as => :football_team_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint football_team_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`football_team_id` AS `football_team_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`football_team_id` AS `football_team_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA via a has-many :through using a foreign key with a ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
-        :as => :friend_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
+      :as => :friend_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint friend_ids from ranged-query"
-      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `friendships`.`friend_id` AS `friend_ids` FROM `friendships` WHERE `friendships`.`person_id` >= $start AND `friendships`.`person_id` <= $end"
+      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `friendships`.`friend_id` AS `friend_ids` FROM `friendships` WHERE `friendships`.`person_id` >= $start AND `friendships`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`friendships`.`person_id`), MAX(`friendships`.`person_id`) FROM `friendships`"
     end
   end
   
   describe "MVA via a HABTM with a ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-        :as => :link_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+      :as => :link_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint link_ids from ranged-query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`links_people`.`person_id`), MAX(`links_people`.`person_id`) FROM `links_people`"
     end
   end
   
   describe "MVA via two has-many associations with a ranged source query" do
-    before :each do
-      @index  = ThinkingSphinx::Index.new(Alpha)
-      @source = ThinkingSphinx::Source.new(@index)
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-        :as => :gamma_values, :source => :ranged_query
-      )
-    end
+    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
+    let(:source)    { ThinkingSphinx::Source.new(index) }
+    let(:attribute) { ThinkingSphinx::Attribute.new(source,
+      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+      :as => :gamma_values, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
       range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
     end
   end
   
   describe "MVA via two has-many associations with a ranged source query for a delta source" do
-    before :each do
-      @index  = ThinkingSphinx::Index.new(Alpha)
-      @source = ThinkingSphinx::Source.new(@index)
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-        :as => :gamma_values, :source => :ranged_query
-      )
+    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
+    let(:source)    { ThinkingSphinx::Source.new(index) }
+    let(:attribute) { ThinkingSphinx::Attribute.new(source,
+      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+      :as => :gamma_values, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
       
-      @index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new @index, @index.local_options
+    before :each do
+      index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new index, index.local_options
     end
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
+      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
       declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
       range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
     end
   end

data/spec/thinking_sphinx/auto_version_spec.rb

@@ -46,6 +46,14 @@ describe ThinkingSphinx::AutoVersion do
       ThinkingSphinx::AutoVersion.detect
     end
     
+    it "should require 2.0.1 if using Sphinx 2.0.2 dev" do
+      ThinkingSphinx::AutoVersion.should_receive(:require).
+        with('riddle/2.0.1')
+      
+      @config.stub!(:version => '2.0.2-dev')
+      ThinkingSphinx::AutoVersion.detect
+    end
+    
     it "should output a warning if the detected version is unsupported" do
       STDERR.should_receive(:puts).with(/unsupported/i)
       

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -16,16 +16,22 @@ describe ThinkingSphinx::FacetSearch do
         
     it "should request all shared facets in a multi-model request by default" do
       ThinkingSphinx.stub!(:search => search)
-      ThinkingSphinx::FacetSearch.new.facet_names.should == ['class_crc']
+      if Riddle.loaded_version.to_i < 2
+        ThinkingSphinx::FacetSearch.new.facet_names.should == ['class_crc']
+      else
+        ThinkingSphinx::FacetSearch.new.facet_names.should == ['sphinx_internal_class']
+      end
     end
     
     it "should request all facets in a multi-model request if specified" do
       ThinkingSphinx.stub!(:search => search)
-      ThinkingSphinx::FacetSearch.new(
-        :all_facets => true
-      ).facet_names.should == [
-        'class_crc', 'city_facet', 'state_facet', 'birthday'
-      ]
+      names = ThinkingSphinx::FacetSearch.new(:all_facets => true).facet_names
+      
+      if Riddle.loaded_version.to_i < 2
+        names.should == ['class_crc', 'city_facet', 'state_facet', 'birthday']
+      else
+        names.should == ['sphinx_internal_class', 'city_facet', 'state_facet', 'birthday']
+      end
     end
     
     it "should use the system-set max_matches for limit on facet calls" do

data/spec/thinking_sphinx/index/builder_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::Index::Builder do
+  let(:internal_attribute_count) {
+    Riddle.loaded_version.to_i < 2 ? 3 : 4
+  }
   describe ".generate without source scope" do
     before :each do
       @index = ThinkingSphinx::Index::Builder.generate(Person) do
@@ -31,10 +34,10 @@ describe ThinkingSphinx::Index::Builder do
       @source.fields[1].unique_name.should == :last_name
     end
     
-    it "should have two attributes alongside the three internal ones" do
-      @source.attributes.length.should == 5
-      @source.attributes[3].unique_name.should == :birthday
-      @source.attributes[4].unique_name.should == :internal_id
+    it "should have two attributes alongside the internal ones" do
+      @source.attributes.length.should == 2 + internal_attribute_count
+      @source.attributes[internal_attribute_count].unique_name.should == :birthday
+      @source.attributes[1 + internal_attribute_count].unique_name.should == :internal_id
     end
     
     it "should have one condition" do
@@ -95,8 +98,8 @@ describe ThinkingSphinx::Index::Builder do
       @source.fields.length.should == 1
     end
     
-    it "should have one attribute alongside the three internal ones" do
-      @source.attributes.length.should == 4
+    it "should have one attribute alongside the internal ones" do
+      @source.attributes.length.should == 1 + internal_attribute_count
     end
     
     it "should set the attribute name to have the _sort suffix" do
@@ -142,8 +145,8 @@ describe ThinkingSphinx::Index::Builder do
       @source.fields.length.should == 1
     end
     
-    it "should have one attribute alongside the three internal ones" do
-      @source.attributes.length.should == 4
+    it "should have one attribute alongside the internal ones" do
+      @source.attributes.length.should == 1 + internal_attribute_count
     end
     
     it "should set the attribute name to have the _facet suffix" do
@@ -174,8 +177,8 @@ describe ThinkingSphinx::Index::Builder do
       Alpha.sphinx_facets.delete_at(-1)
     end
     
-    it "should have just one attribute alongside the three internal ones" do
-      @source.attributes.length.should == 4
+    it "should have just one attribute alongside the internal ones" do
+      @source.attributes.length.should == 1 + internal_attribute_count
     end
   end
   
@@ -193,8 +196,8 @@ describe ThinkingSphinx::Index::Builder do
       Person.sphinx_facets.delete_at(-1)
     end
     
-    it "should have just one attribute alongside the three internal ones" do
-      @source.attributes.length.should == 4
+    it "should have just one attribute alongside the internal ones" do
+      @source.attributes.length.should == 1 + internal_attribute_count
     end
   end
   
@@ -212,8 +215,8 @@ describe ThinkingSphinx::Index::Builder do
       Beta.sphinx_facets.delete_at(-1)
     end
     
-    it "should have just one attribute alongside the three internal ones" do
-      @source.attributes.length.should == 4
+    it "should have just one attribute alongside the internal ones" do
+      @source.attributes.length.should == 1 + internal_attribute_count
     end
   end
   
@@ -231,8 +234,8 @@ describe ThinkingSphinx::Index::Builder do
       Alpha.sphinx_facets.delete_at(-1)
     end
     
-    it "should have just one attribute alongside the three internal ones" do
-      @source.attributes.length.should == 4
+    it "should have just one attribute alongside the internal ones" do
+      @source.attributes.length.should == 1 + internal_attribute_count
     end
   end
   
@@ -250,8 +253,8 @@ describe ThinkingSphinx::Index::Builder do
       Person.sphinx_facets.delete_at(-1)
     end
     
-    it "should have two attributes alongside the three internal ones" do
-      @source.attributes.length.should == 5
+    it "should have two attributes alongside the internal ones" do
+      @source.attributes.length.should == 2 + internal_attribute_count
     end
     
     it "should set the facet attribute name to have the _facet suffix" do
@@ -282,8 +285,8 @@ describe ThinkingSphinx::Index::Builder do
       Person.sphinx_facets.delete_at(-1)
     end
     
-    it "should have two attributes alongside the three internal ones" do
-      @source.attributes.length.should == 5
+    it "should have two attributes alongside the internal ones" do
+      @source.attributes.length.should == 2 + internal_attribute_count
     end
     
     it "should set the facet attribute name to have the _facet suffix" do
@@ -321,8 +324,8 @@ describe ThinkingSphinx::Index::Builder do
       @source.fields.length.should == 1
     end
     
-    it "should have one attribute alongside the three internal ones" do
-      @source.attributes.length.should == 4
+    it "should have one attribute alongside the internal ones" do
+      @source.attributes.length.should == 1 + internal_attribute_count
     end
     
     it "should set the attribute name to have the _facet suffix" do
@@ -381,10 +384,10 @@ describe ThinkingSphinx::Index::Builder do
       @source.fields[1].unique_name.should == :last_name
     end
     
-    it "should have two attributes alongside the three internal ones" do
-      @source.attributes.length.should == 5
-      @source.attributes[3].unique_name.should == :birthday
-      @source.attributes[4].unique_name.should == :internal_id
+    it "should have two attributes alongside the internal ones" do
+      @source.attributes.length.should == 2 + internal_attribute_count
+      @source.attributes[internal_attribute_count].unique_name.should == :birthday
+      @source.attributes[1 + internal_attribute_count].unique_name.should == :internal_id
     end
   end
   
@@ -418,12 +421,12 @@ describe ThinkingSphinx::Index::Builder do
     end
     
     it "should have two attributes alongside the six internal ones" do
-      @index.attributes.length.should == 8
+      @index.attributes.length.should == 2 + (internal_attribute_count * 2)
     end
     
-    it "should have one attribute in each source alongside the three internal ones" do
+    it "should have one attribute in each source alongside the internal ones" do
       @index.sources.each do |source|
-        source.attributes.length.should == 4
+        source.attributes.length.should == 1 + internal_attribute_count
       end
     end
   end

data/spec/thinking_sphinx/search_spec.rb

@@ -1135,10 +1135,11 @@ describe ThinkingSphinx::Search do
       @client.stub! :query => {
         :matches => [{
           :attributes => {
-            'sphinx_internal_id' => @alpha.id,
-            'class_crc'          => Alpha.to_crc32,
-            '@groupby'           => 101,
-            '@count'             => 5
+            'sphinx_internal_id'    => @alpha.id,
+            'sphinx_internal_class' => 'Alpha',
+            'class_crc'             => Alpha.to_crc32,
+            '@groupby'              => 101,
+            '@count'                => 5
           }
         }]
       }
@@ -1172,8 +1173,9 @@ describe ThinkingSphinx::Search do
       @client.stub! :query => {
         :matches => [{
           :attributes => {
-            'sphinx_internal_id' => @alpha.id,
-            'class_crc'          => Alpha.to_crc32
+            'sphinx_internal_id'    => @alpha.id,
+            'sphinx_internal_class' => 'Alpha',
+            'class_crc'             => Alpha.to_crc32
           }, :weight => 12
         }]
       }
@@ -1197,11 +1199,12 @@ describe ThinkingSphinx::Search do
       @client.stub! :query => {
         :matches => [{
           :attributes => {
-            'sphinx_internal_id' => @alpha.id,
-            'class_crc'          => Alpha.to_crc32,
-            '@geodist'           => 101,
-            '@groupby'           => 102,
-            '@count'             => 103
+            'sphinx_internal_id'    => @alpha.id,
+            'sphinx_internal_class' => 'Alpha',
+            'class_crc'             => Alpha.to_crc32,
+            '@geodist'              => 101,
+            '@groupby'              => 102,
+            '@count'                => 103
           }, :weight => 12
         }]
       }

metadata

@@ -2,7 +2,7 @@
 name: thinking-sphinx
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.4.5
+  version: 1.4.6
 platform: ruby
 authors: 
 - Pat Allan
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-12 00:00:00 +10:00
+date: 2011-05-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,7 +34,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.3.2
+        version: 1.3.3
   type: :runtime
   prerelease: false
   version_requirements: *id002
@@ -382,7 +382,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1314985061244983665
+      hash: -3557249456082129398
       segments: 
       - 0
       version: "0"