freelancing-god-thinking-sphinx 0.9.6 → 0.9.7

data/lib/thinking_sphinx/index.rb

@@ -37,6 +37,57 @@ module ThinkingSphinx
       initialize_from_builder(&block) if block_given?
     end
     
+    def to_config(index, database_conf, charset_type)
+      # Set up associations and joins
+      link!
+      
+      attr_sources = attributes.collect { |attrib|
+        attrib.to_sphinx_clause
+      }.join("\n  ")
+      
+      db_adapter = case adapter
+      when :postgres
+        "pgsql"
+      when :mysql
+        "mysql"
+      else
+        raise "Unsupported Database Adapter: Sphinx only supports MySQL and PosgreSQL"
+      end
+      
+      config = <<-SOURCE
+
+source #{model.name.downcase}_#{index}_core
+{
+type     = #{db_adapter}
+sql_host = #{database_conf[:host] || "localhost"}
+sql_user = #{database_conf[:username]}
+sql_pass = #{database_conf[:password]}
+sql_db   = #{database_conf[:database]}
+
+sql_query_pre    = #{charset_type == "utf-8" && adapter == :mysql ? "SET NAMES utf8" : ""}
+sql_query_pre    = #{to_sql_query_pre}
+sql_query        = #{to_sql.gsub(/\n/, ' ')}
+sql_query_range  = #{to_sql_query_range}
+sql_query_info   = #{to_sql_query_info}
+#{attr_sources}
+}
+      SOURCE
+      
+      if delta?
+        config += <<-SOURCE
+
+source #{model.name.downcase}_#{index}_delta : #{model.name.downcase}_#{index}_core
+{
+sql_query_pre    = 
+sql_query        = #{to_sql(:delta => true).gsub(/\n/, ' ')}
+sql_query_range  = #{to_sql_query_range :delta => true}
+}
+        SOURCE
+      end
+      
+      config
+    end
+    
     # Link all the fields and associations to their corresponding
     # associations and joins. This _must_ be called before interrogating
     # the index's fields and associations for anything that may reference
@@ -86,7 +137,7 @@ module ThinkingSphinx
         where_clause << " AND " << @conditions.join(" AND ")
       end
       
-      <<-SQL
+      sql = <<-SQL
 SELECT #{ (
   ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)}"] + 
   @fields.collect { |field| field.to_select_sql } +
@@ -102,8 +153,13 @@ GROUP BY #{ (
   @fields.collect { |field| field.to_group_sql }.compact +
   @attributes.collect { |attribute| attribute.to_group_sql }.compact
 ).join(", ") }
-ORDER BY NULL
       SQL
+      
+      if @model.connection.class.name == "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        sql += " ORDER BY NULL"
+      end
+      
+      sql
     end
     
     # Simple helper method for the query info SQL - which is a statement that
@@ -152,6 +208,14 @@ ORDER BY NULL
       end
     end
     
+    def prefix_fields
+      @fields.select { |field| field.prefixes }
+    end
+    
+    def infix_fields
+      @fields.select { |field| field.infixes }
+    end
+    
     private
     
     def quote_column(column)
@@ -182,6 +246,11 @@ ORDER BY NULL
         :type => :integer,
         :as   => :class_crc
       )
+      @attributes << Attribute.new(
+        FauxColumn.new("0"),
+        :type => :integer,
+        :as   => :sphinx_deleted
+      )
     end
     
     # Returns all associations used amongst all the fields and attributes.

data/lib/thinking_sphinx/index/builder.rb

@@ -48,14 +48,14 @@ module ThinkingSphinx
         # get access down the associations tree.
         # 
         #   indexes :id, :as => :my_id
+        #   indexes :name, :sortable => true
         #   indexes first_name, last_name, :sortable => true
-        #   indexes 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 -
-        # clash with your column names, you need to use the symbol version (see
-        # the first and last examples above).
+        # 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
@@ -194,4 +194,4 @@ module ThinkingSphinx
       end
     end
   end
-end
+end

data/lib/thinking_sphinx/search.rb

@@ -15,9 +15,12 @@ module ThinkingSphinx
       def search_for_ids(*args)
         results, client = search_results(*args.clone)
         
+        options = args.extract_options!
+        page    = options[:page] ? options[:page].to_i : 1
+        
         begin
           pager = WillPaginate::Collection.new(page,
-            client.limit, results[:total])
+            client.limit, results[:total] || 0)
           pager.replace results[:matches].collect { |match| match[:doc] }
         rescue
           results[:matches].collect { |match| match[:doc] }
@@ -268,6 +271,9 @@ module ThinkingSphinx
         
         client.anchor = anchor_conditions(klass, options) || {} if client.anchor.empty?
         
+        client.filters << Riddle::Client::Filter.new(
+          "sphinx_deleted", [0]
+        )
         # class filters
         client.filters << Riddle::Client::Filter.new(
           "class_crc", options[:classes].collect { |klass| klass.to_crc32 }

data/spec/unit/thinking_sphinx/active_record/delta_spec.rb

@@ -17,6 +17,10 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
         :after_commit, [:toggle_delta]
       )
     end
+    
+    it "should have an after_commit method by default" do
+      Person.instance_methods.should include("after_commit")
+    end
   end
   
   describe "save_with_after_commit_callback method" do

data/spec/unit/thinking_sphinx/active_record/search_spec.rb

@@ -0,0 +1,63 @@
+require 'spec/spec_helper'
+
+describe "ThinkingSphinx::ActiveRecord::Search" do
+  it "should add search_for_ids to ActiveRecord::Base" do
+    ActiveRecord::Base.methods.should include("search_for_ids")
+  end
+  
+  it "should add search_for_ids to ActiveRecord::Base" do
+    ActiveRecord::Base.methods.should include("search")
+  end
+  
+  describe "search_for_ids method" do
+    before :each do
+      ThinkingSphinx::Search.stub_method(:search_for_ids => true)
+    end
+    
+    after :each do
+      ThinkingSphinx::Search.unstub_method(:search_for_ids)
+    end
+    
+    it "should call ThinkingSphinx::Search#search_for_ids with the class option set" do
+      Person.search_for_ids("search")
+      
+      ThinkingSphinx::Search.should have_received(:search_for_ids).with(
+        "search", :class => Person
+      )
+    end
+    
+    it "should override the class option" do
+      Person.search_for_ids("search", :class => Friendship)
+      
+      ThinkingSphinx::Search.should have_received(:search_for_ids).with(
+        "search", :class => Person
+      )
+    end
+  end
+  
+  describe "search method" do
+    before :each do
+      ThinkingSphinx::Search.stub_method(:search => true)
+    end
+    
+    after :each do
+      ThinkingSphinx::Search.unstub_method(:search)
+    end
+    
+    it "should call ThinkingSphinx::Search#search with the class option set" do
+      Person.search("search")
+      
+      ThinkingSphinx::Search.should have_received(:search).with(
+        "search", :class => Person
+      )
+    end
+    
+    it "should override the class option" do
+      Person.search("search", :class => Friendship)
+      
+      ThinkingSphinx::Search.should have_received(:search).with(
+        "search", :class => Person
+      )
+    end
+  end
+end

data/spec/unit/thinking_sphinx/active_record_spec.rb

@@ -8,8 +8,9 @@ describe "ThinkingSphinx::ActiveRecord" do
       end
       
       TestModule::TestModel.stub_methods(
-        :before_save  => true,
-        :after_commit => true
+        :before_save    => true,
+        :after_commit   => true,
+        :after_destroy  => true
       )
       
       @index = ThinkingSphinx::Index.stub_instance(:delta? => false)
@@ -19,6 +20,8 @@ describe "ThinkingSphinx::ActiveRecord" do
     after :each do
       # Remove the class so we can redefine it
       TestModule.send(:remove_const, :TestModel)
+      
+      ThinkingSphinx::Index.unstub_method(:new)
     end
     
     it "should return nil and do nothing if indexes are disabled" do
@@ -72,6 +75,20 @@ describe "ThinkingSphinx::ActiveRecord" do
       TestModule::TestModel.should_not have_received(:after_commit)
     end
     
+    it "should add an after_destroy hook with delta indexing enabled" do
+      @index.stub_method(:delta? => true)
+      
+      TestModule::TestModel.define_index do; end
+      
+      TestModule::TestModel.should have_received(:after_destroy).with(:toggle_deleted)
+    end
+    
+    it "should add an after_destroy hook with delta indexing disabled" do
+      TestModule::TestModel.define_index do; end
+      
+      TestModule::TestModel.should have_received(:after_destroy).with(:toggle_deleted)
+    end
+    
     it "should return the new index" do
       TestModule::TestModel.define_index.should == @index
     end
@@ -82,4 +99,59 @@ describe "ThinkingSphinx::ActiveRecord" do
       Person.to_crc32.should be_a_kind_of(Integer)
     end
   end
+  
+  describe "toggle_deleted method" do
+    before :each do
+      @configuration = ThinkingSphinx::Configuration.stub_instance(
+        :address  => "an address",
+        :port     => 123
+      )
+      @client = Riddle::Client.stub_instance(:update => true)
+      @person = Person.new
+      
+      ThinkingSphinx::Configuration.stub_method(:new => @configuration)
+      Riddle::Client.stub_method(:new => @client)
+      Person.indexes.each { |index| index.stub_method(:delta? => false) }
+    end
+    
+    after :each do
+      ThinkingSphinx::Configuration.unstub_method(:new)
+      Riddle::Client.unstub_method(:new)
+      Person.indexes.each { |index| index.unstub_method(:delta?) }
+    end
+    
+    it "should create a client using the Configuration's address and port" do
+      @person.toggle_deleted
+      
+      Riddle::Client.should have_received(:new).with(
+        @configuration.address, @configuration.port
+      )
+    end
+    
+    it "should update the core index's deleted flag" do
+      @person.toggle_deleted
+      
+      @client.should have_received(:update).with(
+        "person_core", ["sphinx_deleted"], {@person.id => 1}
+      )
+    end
+    
+    it "should update the delta index's deleted flag if delta indexing is enabled" do
+      Person.indexes.each { |index| index.stub_method(:delta? => true) }
+      
+      @person.toggle_deleted
+      
+      @client.should have_received(:update).with(
+        "person_delta", ["sphinx_deleted"], {@person.id => 1}
+      )
+    end
+    
+    it "shouldn't update the delta index if delta indexing is disabled" do
+      @person.toggle_deleted
+      
+      @client.should_not have_received(:update).with(
+        "person_delta", ["sphinx_deleted"], {@person.id => 1}
+      )
+    end
+  end
 end

data/spec/unit/thinking_sphinx/association_spec.rb

@@ -0,0 +1,247 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Association do
+  describe "class-level children method" do
+    before :each do
+      @normal_reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :options => {:polymorphic => false}
+      )
+      @normal_association = ThinkingSphinx::Association.stub_instance
+      @poly_reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :options        => {:polymorphic => true},
+        :macro          => :has_many,
+        :name           => "polly",
+        :active_record  => "AR"
+      )
+      @non_poly_reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance
+      
+      Person.stub_method(:reflect_on_association => @normal_reflection)
+      ThinkingSphinx::Association.stub_methods(
+        :new                  => @normal_association,
+        :polymorphic_classes  => [Person, Person],
+        :casted_options       => {:casted => :options}
+      )
+      ::ActiveRecord::Reflection::AssociationReflection.stub_method(
+        :new => @non_poly_reflection
+      )
+    end
+    
+    it "should return an empty array if no association exists" do
+      Person.stub_method(:reflect_on_association => nil)
+      
+      ThinkingSphinx::Association.children(Person, :assoc).should == []
+    end
+    
+    it "should return a single association instance in an array if assocation isn't polymorphic" do
+      ThinkingSphinx::Association.children(Person, :assoc).should == [@normal_association]
+    end
+    
+    it "should return multiple association instances for polymorphic associations" do
+      Person.stub_method(:reflect_on_association => @poly_reflection)
+      
+      ThinkingSphinx::Association.children(Person, :assoc).should ==
+        [@normal_association, @normal_association]
+    end
+    
+    it "should generate non-polymorphic 'casted' associations for each polymorphic possibility" do
+      Person.stub_method(:reflect_on_association => @poly_reflection)
+      
+      ThinkingSphinx::Association.children(Person, :assoc)
+      
+      ThinkingSphinx::Association.should have_received(:casted_options).with(
+        Person, @poly_reflection
+      ).twice
+      
+      ::ActiveRecord::Reflection::AssociationReflection.should have_received(:new).with(
+        :has_many, :polly_Person, {:casted => :options}, "AR"
+      ).twice
+      
+      ThinkingSphinx::Association.should have_received(:new).with(
+        nil, @non_poly_reflection
+      ).twice
+    end
+  end
+  
+  describe "instance-level children method" do
+    it "should return the children associations for the given association" do
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :klass => :klass
+      )
+      @association = ThinkingSphinx::Association.new(nil, @reflection)
+      ThinkingSphinx::Association.stub_method(:children => :result)
+      
+      @association.children(:assoc).should == :result
+      ThinkingSphinx::Association.should have_received(:children).with(:klass, :assoc, @association)
+    end
+  end
+  
+  describe "join_to method" do
+    before :each do
+      @parent_join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
+      @join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
+      @parent = ThinkingSphinx::Association.stub_instance(:join_to => true, :join => nil)
+      @base_join = Object.stub_instance(:joins => [:a, :b, :c])
+      
+      ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_method(:new => @join)
+    end
+    
+    it "should call the parent's join_to if parent has no join" do
+      @assoc = ThinkingSphinx::Association.new(@parent, :ref)
+      
+      @assoc.join_to(@base_join)
+      
+      @parent.should have_received(:join_to).with(@base_join)
+    end
+    
+    it "should not call the parent's join_to if it already has a join" do
+      @assoc = ThinkingSphinx::Association.new(@parent, :ref)
+      @parent.stub_method(:join => @parent_join)
+      
+      @assoc.join_to(@base_join)
+      
+      @parent.should_not have_received(:join_to)
+    end
+    
+    it "should define the join association with a JoinAssociation instance" do
+      @assoc = ThinkingSphinx::Association.new(@parent, :ref)
+      
+      @assoc.join_to(@base_join).should == @join
+      @assoc.join.should == @join
+    end
+  end
+  
+  describe "to_sql method" do
+    before :each do
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :klass => Person
+      )
+      @association = ThinkingSphinx::Association.new(nil, @reflection)
+      @parent = Object.stub_instance(:aliased_table_name => "ALIAS TABLE NAME")
+      @join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance(
+        :association_join => "full association join SQL",
+        :parent           => @parent
+      )
+      @association.join = @join
+    end
+    
+    it "should return the join's association join value" do
+      @association.to_sql.should == "full association join SQL"
+    end
+    
+    it "should replace ::ts_join_alias:: with the aliased table name" do
+      @join.stub_method(:association_join => "text with ::ts_join_alias:: gone")
+      
+      @association.to_sql.should == "text with `ALIAS TABLE NAME` gone"
+    end
+  end
+  
+  describe "is_many? method" do
+    before :each do
+      @parent = ThinkingSphinx::Association.stub_instance(
+        :is_many? => :parent_is_many
+      )
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :macro => :has_many
+      )
+    end
+    
+    it "should return true if association is either a has_many or a habtm" do
+      association = ThinkingSphinx::Association.new(@parent, @reflection)
+      association.is_many?.should be_true
+      
+      @reflection.stub_method(:macro => :has_and_belongs_to_many)
+      association.is_many?.should be_true
+    end
+    
+    it "should return the parent value if not a has many or habtm and there is a parent" do
+      association = ThinkingSphinx::Association.new(@parent, @reflection)
+      @reflection.stub_method(:macro => :belongs_to)
+      association.is_many?.should == :parent_is_many
+    end
+    
+    it "should return false if no parent and not a has many or habtm" do
+      association = ThinkingSphinx::Association.new(nil, @reflection)
+      @reflection.stub_method(:macro => :belongs_to)
+      association.is_many?.should be_false
+    end
+  end
+  
+  describe "ancestors method" do
+    it "should return an array of associations - including all parents" do
+      parent = ThinkingSphinx::Association.stub_instance(:ancestors => [:all, :ancestors])
+      association = ThinkingSphinx::Association.new(parent, @reflection)
+      association.ancestors.should == [:all, :ancestors, association]
+    end
+  end
+  
+  describe "polymorphic_classes method" do
+    it "should return all the polymorphic result types as classes" do
+      Person.connection.stub_method(:select_all => [
+        {"person_type" => "Person"},
+        {"person_type" => "Friendship"}
+      ])
+      ref = Object.stub_instance(
+        :active_record  => Person,
+        :options        => {:foreign_type => "person_type"}
+      )
+      
+      ThinkingSphinx::Association.send(:polymorphic_classes, ref).should == [Person, Friendship]
+    end
+  end
+  
+  describe "casted_options method" do
+    before :each do
+      @options = {
+        :foreign_key  => "thing_id",
+        :foreign_type => "thing_type",
+        :polymorphic  => true
+      }
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :options => @options
+      )
+    end
+    
+    it "should return a new options set for a specific class" do
+      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
+        :polymorphic  => nil,
+        :class_name   => "Person",
+        :foreign_key  => "thing_id",
+        :foreign_type => "thing_type",
+        :conditions   => "::ts_join_alias::.`thing_type` = 'Person'"
+      }
+    end
+        
+    it "should append to existing Array of conditions" do
+      @options[:conditions] = ["first condition"]
+      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
+        :polymorphic  => nil,
+        :class_name   => "Person",
+        :foreign_key  => "thing_id",
+        :foreign_type => "thing_type",
+        :conditions   => ["first condition", "::ts_join_alias::.`thing_type` = 'Person'"]
+      }
+    end
+    
+    it "should merge to an existing Hash of conditions" do
+      @options[:conditions] = {"field" => "value"}
+      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
+        :polymorphic  => nil,
+        :class_name   => "Person",
+        :foreign_key  => "thing_id",
+        :foreign_type => "thing_type",
+        :conditions   => {"field" => "value", "thing_type" => "Person"}
+      }
+    end
+    
+    it "should append to an existing String of conditions" do
+      @options[:conditions] = "first condition"
+      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
+        :polymorphic  => nil,
+        :class_name   => "Person",
+        :foreign_key  => "thing_id",
+        :foreign_type => "thing_type",
+        :conditions   => "first condition AND ::ts_join_alias::.`thing_type` = 'Person'"
+      }
+    end
+  end
+end