dpickett-thinking-sphinx 1.1.4 → 1.1.12

data/lib/thinking_sphinx.rb

@@ -7,6 +7,7 @@ require 'riddle'
 require 'after_commit'
 
 require 'thinking_sphinx/core/string'
+require 'thinking_sphinx/property'
 require 'thinking_sphinx/active_record'
 require 'thinking_sphinx/association'
 require 'thinking_sphinx/attribute'
@@ -35,7 +36,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 1
     Minor = 1
-    Tiny  = 4
+    Tiny  = 12
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -61,6 +62,10 @@ module ThinkingSphinx
     @@indexed_models ||= []
   end
   
+  def self.unique_id_expression(offset = nil)
+    "* #{ThinkingSphinx.indexed_models.size} + #{offset || 0}"
+  end
+  
   # Check if index definition is disabled.
   # 
   def self.define_indexes?
@@ -125,21 +130,52 @@ module ThinkingSphinx
   # or if not using MySQL, this will return false.
   # 
   def self.use_group_by_shortcut?
-    ::ActiveRecord::ConnectionAdapters.constants.include?("MysqlAdapter") &&
-    ::ActiveRecord::Base.connection.is_a?(
-      ::ActiveRecord::ConnectionAdapters::MysqlAdapter
-    ) &&
-    ::ActiveRecord::Base.connection.select_all(
-      "SELECT @@global.sql_mode, @@session.sql_mode;"
-    ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
+    !!(
+      mysql? && ::ActiveRecord::Base.connection.select_all(
+        "SELECT @@global.sql_mode, @@session.sql_mode;"
+      ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
+    )
   end
   
   def self.sphinx_running?
-    !!sphinx_pid
+    !!sphinx_pid && pid_active?(sphinx_pid)
   end
   
   def self.sphinx_pid
-    pid_file = ThinkingSphinx::Configuration.instance.pid_file    
-    `cat #{pid_file}`[/\d+/] if File.exists?(pid_file)
+    pid_file    = ThinkingSphinx::Configuration.instance.pid_file
+    cat_command = 'cat'
+    return nil unless File.exists?(pid_file)
+    
+    if microsoft?
+      pid_file.gsub!('/', '\\')
+      cat_command = 'type'
+    end
+    
+    `#{cat_command} #{pid_file}`[/\d+/]
+  end
+  
+  def self.pid_active?(pid)
+    return true if microsoft?
+    
+    begin
+      # In JRuby this returns -1 if the process doesn't exist
+      Process.getpgid(pid.to_i) != -1
+    rescue Exception => e
+      false
+    end
+  end
+  
+  def self.microsoft?
+    RUBY_PLATFORM =~ /mswin/
+  end
+  
+  def self.jruby?
+    defined?(JRUBY_VERSION)
+  end
+  
+  def self.mysql?
+    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlAdapter" || (
+      jruby? && ::ActiveRecord::Base.connection.config[:adapter] == "jdbcmysql"
+    )
   end
 end

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

@@ -76,7 +76,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       
       @person = Person.new
       @person.stub_method(
-        :in_core_index?     => false,
+        :in_both_indexes?     => false,
         :sphinx_document_id => 1
       )
       
@@ -126,7 +126,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
     end
     
     it "should update the deleted attribute if in the core index" do
-      @person.stub_method(:in_core_index? => true)
+      @person.stub_method(:in_both_indexes? => true)
       
       @person.send(:index_delta)
       

data/spec/unit/thinking_sphinx/active_record_spec.rb

@@ -64,15 +64,15 @@ describe "ThinkingSphinx::ActiveRecord" do
       
       TestModule::TestModel.define_index do; end
       
-      TestModule::TestModel.should have_received(:before_save)
-      TestModule::TestModel.should have_received(:after_commit)
+      TestModule::TestModel.should have_received(:before_save).with(:toggle_delta)
+      TestModule::TestModel.should have_received(:after_commit).with(:index_delta)
     end
     
     it "should not add before_save and after_commit hooks to the model if delta indexing is disabled" do
       TestModule::TestModel.define_index do; end
       
-      TestModule::TestModel.should_not have_received(:before_save)
-      TestModule::TestModel.should_not have_received(:after_commit)
+      TestModule::TestModel.should_not have_received(:before_save).with(:toggle_delta)
+      TestModule::TestModel.should_not have_received(:after_commit).with(:index_delta)
     end
     
     it "should add an after_destroy hook with delta indexing enabled" do
@@ -93,6 +93,60 @@ describe "ThinkingSphinx::ActiveRecord" do
       TestModule::TestModel.define_index.should == @index
     end
   end
+
+  describe "index methods" do
+    before(:all) do
+      @person = Person.find(:first)
+    end
+
+    describe "in_both_indexes?" do
+      it "should return true if in core and delta indexes" do
+        @person.should_receive(:in_core_index?).and_return(true)
+        @person.should_receive(:in_delta_index?).and_return(true)
+        @person.in_both_indexes?.should be_true
+      end
+      
+      it "should return false if in one index and not the other" do
+        @person.should_receive(:in_core_index?).and_return(true)
+        @person.should_receive(:in_delta_index?).and_return(false)
+        @person.in_both_indexes?.should be_false
+      end
+    end
+
+    describe "in_core_index?" do
+      it "should call in_index? with core" do
+        @person.should_receive(:in_index?).with('core')
+        @person.in_core_index?
+      end
+    end
+
+    describe "in_delta_index?" do
+      it "should call in_index? with delta" do
+        @person.should_receive(:in_index?).with('delta')
+        @person.in_delta_index?
+      end
+    end
+
+    describe "in_index?" do
+      it "should return true if in the specified index" do
+        @person.should_receive(:sphinx_document_id).and_return(1)
+        @person.should_receive(:sphinx_index_name).and_return('person_core')
+        Person.should_receive(:search_for_id).with(1, 'person_core').and_return(true)
+      
+        @person.in_index?('core').should be_true
+      end
+    end
+  end
+
+  describe "source_of_sphinx_index method" do
+    it "should return self if model defines an index" do
+      Person.source_of_sphinx_index.should == Person
+    end
+
+    it "should return the parent if model inherits an index" do
+      Parent.source_of_sphinx_index.should == Person
+    end
+  end
   
   describe "to_crc32 method" do
     it "should return an integer" do
@@ -100,6 +154,12 @@ describe "ThinkingSphinx::ActiveRecord" do
     end
   end
     
+  describe "to_crc32s method" do
+    it "should return an array" do
+      Person.to_crc32s.should be_a_kind_of(Array)
+    end
+  end
+    
   describe "toggle_deleted method" do
     before :each do
       ThinkingSphinx.stub_method(:sphinx_running? => true)

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -157,7 +157,7 @@ describe ThinkingSphinx::Attribute do
     end
     
     it "should return :string if there's more than one association" do
-      @attribute.associations = {:a => :assoc, :b => :assoc}
+      @attribute.associations = {:a => [:assoc], :b => [:assoc]}
       @attribute.send(:type).should == :string
     end
     
@@ -209,4 +209,19 @@ describe ThinkingSphinx::Attribute do
       attribute.send(:all_ints?).should be_false
     end
   end
+  
+  describe "with custom queries" do
+    before :each do
+      index = CricketTeam.sphinx_indexes.first
+      @statement = index.to_riddle_for_core(0, 0).sql_attr_multi.first
+    end
+    
+    it "should track the query type accordingly" do
+      @statement.should match(/uint tags from query/)
+    end
+    
+    it "should include the SQL statement" do
+      @statement.should match(/SELECT cricket_team_id, id FROM tags/)
+    end
+  end
 end

data/spec/unit/thinking_sphinx/facet_collection_spec.rb

@@ -0,0 +1,64 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::FacetCollection do
+  before do
+    @facet_collection = ThinkingSphinx::FacetCollection.new([])
+  end
+
+  # TODO fix nasty hack when we have internet!
+  def mock_results
+    return @results if defined? @results
+    @result = Person.find(:first)
+    @results = [@result]
+    @results.stub!(:each_with_groupby_and_count).and_yield(@result, @result.city.to_crc32, 1)
+    @results
+  end
+
+  describe "#add_from_results" do
+    describe "with empty result set" do
+      before do
+        @facet_collection.add_from_results('attribute_facet', [])
+      end
+
+      it "should add key as attribute" do
+        @facet_collection.should have_key(:attribute)
+      end
+
+      it "should return an empty hash for the facet results" do
+        @facet_collection[:attribute].should be_empty
+      end
+    end
+
+    describe "with non-empty result set" do
+      before do
+        @facet_collection.add_from_results('city_facet', mock_results)
+      end
+
+      it "should return a hash" do
+        @facet_collection.should be_a_kind_of(Hash)
+      end
+
+      it "should add key as attribute" do
+        @facet_collection.keys.should include(:city)
+      end
+
+      it "should return a hash" do
+        @facet_collection[:city].should == {@result.city => 1}
+      end
+    end
+  end
+
+  describe "#for" do
+    before do
+      @facet_collection.add_from_results('city_facet', mock_results)
+    end
+
+    it "should return the search results for the attribute and key pair" do
+      ThinkingSphinx::Search.should_receive(:search) do |options|
+        options[:with].should have_key('city_facet')
+        options[:with]['city_facet'].should == @result.city.to_crc32
+      end
+      @facet_collection.for(:city => @result.city)
+    end
+  end
+end

data/spec/unit/thinking_sphinx/facet_spec.rb

@@ -0,0 +1,46 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Facet do
+  describe ".name_for" do
+    it "should remove '_facet' from provided string and return a symbol" do
+      ThinkingSphinx::Facet.name_for('attribute_facet').should == :attribute
+    end
+
+    it "should remove '_facet' from provided symbol" do
+      ThinkingSphinx::Facet.name_for(:attribute_facet).should == :attribute
+    end
+
+    it "should return the name of the facet if a Facet is passed" do
+      facet = ThinkingSphinx::Facet.new(
+        ThinkingSphinx::Attribute.stub_instance(:unique_name => :attribute, :columns => ['attribute'])
+      )
+      ThinkingSphinx::Facet.name_for(facet).should == :attribute
+    end
+
+    it "should return 'class' for special case name 'class_crc'" do
+      ThinkingSphinx::Facet.name_for(:class_crc).should == :class
+    end
+
+    it "should cycle" do
+      ThinkingSphinx::Facet.name_for(ThinkingSphinx::Facet.attribute_name_for(:attribute)).should == :attribute
+    end
+  end
+
+  describe ".attribute_name_for" do
+    it "should append '_facet' to provided string" do
+      ThinkingSphinx::Facet.attribute_name_for('attribute').should == 'attribute_facet'
+    end
+
+    it "should append '_facet' to provided symbol and return a string" do
+      ThinkingSphinx::Facet.attribute_name_for(:attribute).should == 'attribute_facet'
+    end
+
+    it "should return 'class_crc' for special case attribute 'class'" do
+      ThinkingSphinx::Facet.attribute_name_for(:class).should == 'class_crc'
+    end
+
+    it "should cycle" do
+      ThinkingSphinx::Facet.attribute_name_for(ThinkingSphinx::Facet.name_for('attribute_facet')).should == 'attribute_facet'
+    end
+  end
+end

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -51,4 +51,94 @@ describe ThinkingSphinx::Index do
       @index.infix_fields.should_not include(@field_b)
     end
   end
+  
+  describe "multi-value attribute as ranged-query with has-many association" do
+    before :each do 
+      @index = ThinkingSphinx::Index.new(Person) do
+        has tags(:id), :as => :tag_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
+    end
+    
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/tag_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`tags`.`id`/)
+    end
+    
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `tags`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
+      
+      declaration, query, range_query = attribute.send(: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"
+      range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
+    end
+  end
+  
+  describe "multi-value attribute as ranged-query with has-many-through association" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person) do
+        has football_teams(:id), :as => :football_teams_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
+    end
+    
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/football_teams_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`tags`.`football_team_id`/)
+    end
+    
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `tags`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
+      
+      declaration, query, range_query = attribute.send(:config_value).split('; ')
+      declaration.should == "uint football_teams_ids from ranged-query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`football_team_id` AS `football_teams_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 "multi-value attribute as ranged-query with has-many-through association and foreign_key" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person) do
+        has friends(:id), :as => :friend_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
+    end
+    
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/friend_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`friendships`.`friend_id`/)
+    end
+    
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `friendships`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
+      
+      declaration, query, range_query = attribute.send(: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"
+      range_query.should == "SELECT MIN(`friendships`.`person_id`), MAX(`friendships`.`person_id`) FROM `friendships`"
+    end
+  end
 end

data/spec/unit/thinking_sphinx/rails_additions_spec.rb

@@ -0,0 +1,183 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::HashExcept do
+  before(:each) do
+    @hash = { :number => 20, :letter => 'b', :shape => 'rectangle' }
+  end
+  
+  describe "except method" do
+    it "returns a hash without the specified keys" do
+      new_hash = @hash.except(:number)
+      new_hash.should_not have_key(:number)
+    end
+  end
+  
+  describe "except! method" do
+    it "modifies hash removing specified keys" do
+      @hash.except!(:number)
+      @hash.should_not have_key(:number)
+    end
+  end
+  
+  describe "extends Hash" do
+    it 'with except' do
+      Hash.instance_methods.include?('except').should be_true
+    end
+
+    it 'with except!' do
+      Hash.instance_methods.include?('except!').should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::ArrayExtractOptions do
+  describe 'extract_options! method' do
+    it 'returns a hash' do
+      array = []
+      array.extract_options!.should be_kind_of(Hash)
+    end
+
+    it 'returns the last option if it is a hash' do
+      array = ['a', 'b', {:c => 'd'}]
+      array.extract_options!.should == {:c => 'd'}
+    end
+  end
+  
+  describe "extends Array" do
+    it 'with extract_options!' do
+      Array.instance_methods.include?('extract_options!').should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::AbstractQuotedTableName do
+  describe 'quote_table_name method' do
+    it 'calls quote_column_name' do
+      adapter = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql')
+      adapter.should_receive(:quote_column_name).with('messages')
+      adapter.quote_table_name('messages')
+    end
+  end
+  
+  describe "extends ActiveRecord::ConnectionAdapters::AbstractAdapter" do
+    it 'with quote_table_name' do
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.instance_methods.include?('quote_table_name').should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::MysqlQuotedTableName do
+  describe "quote_table_name method" do
+    it 'correctly quotes' do
+      adapter = ActiveRecord::Base.connection
+      adapter.quote_table_name('thinking_sphinx.messages').should == "`thinking_sphinx`.`messages`"
+    end
+  end
+  
+  describe "extends ActiveRecord::ConnectionAdapters::MysqlAdapter" do
+    it 'with quote_table_name' do
+      adapter = defined?(JRUBY_VERSION) ? :JdbcAdapter : :MysqlAdapter
+      ActiveRecord::ConnectionAdapters.const_get(adapter).instance_methods.include?("quote_table_name").should be_true
+    end
+  end  
+end
+
+describe ThinkingSphinx::ActiveRecordQuotedName do
+  describe "quoted_table_name method" do
+    it 'returns table name wrappd in quotes' do
+      Person.quoted_table_name.should == '`people`'
+    end
+  end
+  
+  describe "extends ActiveRecord::Base" do
+    it 'with quoted_table_name' do
+      ActiveRecord::Base.respond_to?("quoted_table_name").should be_true
+    end
+  end
+end
+
+describe ThinkingSphinx::ActiveRecordStoreFullSTIClass do
+  describe "store_full_sti_class method" do
+    it 'returns false' do
+      Person.store_full_sti_class.should be_false
+    end
+  end
+  
+  describe "extends ActiveRecord::Base" do
+    it 'with store_full_sti_class' do
+      ActiveRecord::Base.respond_to?(:store_full_sti_class).should be_true
+    end
+  end
+end
+
+class TestModel
+  @@squares = 89
+  @@circles = 43
+  
+  def number_of_polygons
+    @@polygons
+  end
+end
+
+describe ThinkingSphinx::ClassAttributeMethods do
+  describe "cattr_reader method" do
+    it 'creates getters' do
+      TestModel.cattr_reader :herbivores
+      test_model = TestModel.new
+      test_model.respond_to?(:herbivores).should be_true
+    end
+
+    it 'sets the initial value to nil' do
+      TestModel.cattr_reader :carnivores
+      test_model = TestModel.new
+      test_model.carnivores.should be_nil
+    end
+
+    it 'does not override an existing definition' do
+      TestModel.cattr_reader :squares
+      test_model = TestModel.new
+      test_model.squares.should == 89      
+    end
+  end
+
+  describe "cattr_writer method" do
+    it 'creates setters' do
+      TestModel.cattr_writer :herbivores
+      test_model = TestModel.new
+      test_model.respond_to?(:herbivores=).should be_true
+    end
+    
+    it 'does not override an existing definition' do
+      TestModel.cattr_writer :polygons
+      test_model = TestModel.new
+      test_model.polygons = 100
+      test_model.number_of_polygons.should == 100
+    end
+  end
+
+  describe "cattr_accessor method" do
+    it 'calls cattr_reader' do
+      Class.should_receive(:cattr_reader).with('polygons')
+      Class.cattr_accessor('polygons')
+    end
+
+    it 'calls cattr_writer' do
+      Class.should_receive(:cattr_writer).with('polygons')
+      Class.cattr_accessor('polygons')
+    end
+  end
+
+  describe "extends Class" do
+    it 'with cattr_reader' do
+      Class.respond_to?('cattr_reader').should be_true
+    end
+
+    it 'with cattr_writer' do
+      Class.respond_to?('cattr_writer').should be_true
+    end
+
+    it 'with cattr_accessor' do
+      Class.respond_to?('cattr_accessor').should be_true
+    end
+  end
+end

data/spec/unit/thinking_sphinx/search_spec.rb

@@ -50,6 +50,50 @@ describe ThinkingSphinx::Search do
 
     end
   end
+  
+  describe "facets method" do
+    before :each do
+      @results = [Person.find(:first)]
+      @results.stub!(:each_with_groupby_and_count).
+        and_yield(@results.first, @results.first.city.to_crc32, 1)
+      ThinkingSphinx::Search.stub!(:search => @results)
+      
+      @config = ThinkingSphinx::Configuration.instance
+      @config.configuration.searchd.max_matches = 10_000
+    end
+    
+    it "should use the system-set max_matches for limit on facet calls" do
+      ThinkingSphinx::Search.should_receive(:search) do |options|
+        options[:max_matches].should  == 10_000
+        options[:limit].should        == 10_000
+      end
+      
+      ThinkingSphinx::Search.facets :all_attributes => true
+    end
+    
+    it "should use the default max-matches if there is no explicit setting" do
+      @config.configuration.searchd.max_matches = nil
+      ThinkingSphinx::Search.should_receive(:search) do |options|
+        options[:max_matches].should  == 1000
+        options[:limit].should        == 1000
+      end
+      
+      ThinkingSphinx::Search.facets :all_attributes => true
+    end
+    
+    it "should ignore user-provided max_matches and limit on facet calls" do
+      ThinkingSphinx::Search.should_receive(:search) do |options|
+        options[:max_matches].should  == 10_000
+        options[:limit].should        == 10_000
+      end
+      
+      ThinkingSphinx::Search.facets(
+        :all_attributes => true,
+        :max_matches    => 500,
+        :limit          => 200
+      )
+    end
+  end
 end
 
 describe ThinkingSphinx::Search, "playing nice with Search model" do