acts_as_indexed 0.7.1 → 0.7.2

data/CHANGELOG

@@ -1,3 +1,10 @@
+===0.7.2 [31st March 2011]
+  - Fixed bug with ranking of records [Christopher Souvey - bug report]
+  - Fixed a bug with the slicing of records before AR order is applied. [Christopher Souvey - bug report]
+  - Fixed bug with slicing of id-only results.
+  - Error now raised when combining ids_only with find options other than limit and offset.
+  - Can now disable auto-indexing. Useful for large test suites.
+
 ===0.7.1 [22nd February 2011]
  - Removed file locking on Microsoft Windows as it is unsupported.
 

data/VERSION

@@ -1 +1 @@
-0.7.1
+0.7.2

data/acts_as_indexed.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{acts_as_indexed}
-  s.version = "0.7.1"
+  s.version = "0.7.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Douglas F Shearer"]
-  s.date = %q{2011-02-22}
+  s.date = %q{2011-03-31}
   s.description = %q{Acts As Indexed is a plugin which provides a pain-free way to add fulltext search to your Ruby on Rails app}
   s.email = %q{dougal.s@gmail.com}
   s.extra_rdoc_files = [

data/lib/acts_as_indexed/class_methods.rb

@@ -58,6 +58,8 @@ module ActsAsIndexed
     # Adds the passed +record+ to the index. Index is built if it does not already exist. Clears the query cache.
 
     def index_add(record)
+      return if self.aai_config.disable_auto_indexing
+
       build_index unless aai_config.index_file.directory?
       index = new_index
       index.add_record(record)
@@ -67,6 +69,8 @@ module ActsAsIndexed
     # Removes the passed +record+ from the index. Clears the query cache.
 
     def index_remove(record)
+      return if self.aai_config.disable_auto_indexing
+
       index = new_index
       index.remove_record(record)
       @query_cache = {}
@@ -77,6 +81,8 @@ module ActsAsIndexed
     # 2. Adds the new version to the index.
 
     def index_update(record)
+      return if self.aai_config.disable_auto_indexing
+
       build_index unless aai_config.index_file.directory?
       index = new_index
       index.update_record(record,find(record.id))
@@ -99,27 +105,40 @@ module ActsAsIndexed
     # no_query_cache:: Turns off the query cache when set to true. Useful for testing.
 
     def search_index(query, find_options={}, options={})
+
       # Clear the query cache off  if the key is set.
-      @query_cache = {}  if (options.has_key?('no_query_cache') || options[:no_query_cache])
+      @query_cache = {}  if options[:no_query_cache]
+
+      # Run the query if not already in cache.
       if !@query_cache || !@query_cache[query]
-        logger.debug('Query not in cache, running search.')
         build_index unless aai_config.index_file.directory?
-        index = new_index
-        (@query_cache ||= {})[query] = index.search(query)
-      else
-        logger.debug('Query held in cache.')
+        (@query_cache ||= {})[query] = new_index.search(query)
       end
-      return @query_cache[query].sort.reverse.map{|r| r.first} if options[:ids_only] || @query_cache[query].empty?
 
-      # slice up the results by offset and limit
-      offset = find_options[:offset] || 0
-      limit = find_options.include?(:limit) ? find_options[:limit] : @query_cache[query].size
-      part_query = @query_cache[query].sort.reverse.slice(offset,limit).map{|r| r.first}
+      if options[:ids_only]
+        find_option_keys = find_options.keys.map{ |k| k.to_sym }
+        find_option_keys -= [:limit, :offset]
+        if find_option_keys.any?
+          raise ArgumentError, 'ids_only can not be combined with find option keys other than :offset or :limit'
+        end
+      end
+
+      if find_options.include?(:order)
+        part_query = @query_cache[query].map{ |r| r.first }
+
+      else
+        # slice up the results by offset and limit
+        offset = find_options[:offset] || 0
+        limit = find_options.include?(:limit) ? find_options[:limit] : @query_cache[query].size
+        part_query = @query_cache[query].sort_by{ |r| r.last }.slice(offset,limit).map{ |r| r.first }
+
+        # Set these to nil as we are dealing with the pagination by setting
+        # exactly what records we want.
+        find_options[:offset] = nil
+        find_options[:limit] = nil
+      end
 
-      # Set these to nil as we are dealing with the pagination by setting
-      # exactly what records we want.
-      find_options[:offset] = nil
-      find_options[:limit] = nil
+      return part_query if options[:ids_only]
 
       with_scope :find => find_options do
         # Doing the find like this eliminates the possibility of errors occuring
@@ -128,6 +147,7 @@ module ActsAsIndexed
 
         if find_options.include?(:order)
          records # Just return the records without ranking them.
+
        else
          # Results come back in random order from SQL, so order again.
          ranked_records = {}
@@ -135,7 +155,7 @@ module ActsAsIndexed
            ranked_records[r] = @query_cache[query][r.id]
          end
 
-         ranked_records.to_a.sort_by{|a| a.last }.reverse.map{|r| r.first}
+         ranked_records.to_a.sort_by{ |a| a.last }.map{ |r| r.first}
        end
       end
 

data/lib/acts_as_indexed/configuration.rb

@@ -30,6 +30,11 @@ module ActsAsIndexed
     # Set to true to enable.
     # Default is false.
     attr_accessor :case_sensitive
+    
+    # Disable indexing, useful for large test suites.
+    # Set to false to disable.
+    # Default is false.
+    attr_accessor :disable_auto_indexing
 
     def initialize
       @index_file       = nil
@@ -37,6 +42,7 @@ module ActsAsIndexed
       @min_word_size    = 3
       @if_proc          = if_proc
       @case_sensitive   = false
+      @disable_auto_indexing = false
     end
 
     # Since we cannot expect Rails to be available on load, it is best to put

data/test/acts_as_indexed_test.rb

@@ -15,135 +15,194 @@ class ActsAsIndexedTest < ActiveSupport::TestCase
     post = Post.new(:title => 'badger', :body => 'Thousands of them!')
     assert post.save
     assert_equal original_post_count + 1, Post.count
-    assert_equal [post.id], result_ids('badger')
+    assert_equal [post.id], find_with_index_ids('badger')
   end
-  
+
   def test_removes_from_index
     original_post_count = Post.count
-    assert_equal [posts(:wikipedia_article_4).id], result_ids('album')
+    assert_equal [posts(:wikipedia_article_4).id], find_with_index_ids('album')
     assert Post.find(posts(:wikipedia_article_4).id).destroy
-    assert_equal [], result_ids('album')
+    assert_equal [], find_with_index_ids('album')
     assert_equal original_post_count - 1, Post.count
   end
-  
+
   def test_search_returns_posts
     Post.with_query('album').each do |p|
       assert_equal Post, p.class
     end
   end
-  
+
   def test_search_returns_post_ids
-    result_ids('album').each do |pid|
+    find_with_index_ids('album').each do |pid|
       assert p = Post.find(pid)
       assert_equal Post, p.class
     end
   end
-  
+
   # After a portion of a record has been removed
   # the portion removes should no longer be in the index.
   def test_updates_index
     p = Post.create(:title => 'A special title', :body => 'foo bar bla bla bla')
-    assert result_ids('title').include?(p.id)
+    assert find_with_index_ids('title').include?(p.id)
     p.update_attributes(:title => 'No longer special')
-    assert !result_ids('title').include?(p.id)
+    assert !find_with_index_ids('title').include?(p.id)
   end
-  
+
   def test_simple_queries
-    assert_equal_array_contents [],     result_ids(nil)
-    assert_equal_array_contents [],     result_ids('')
-    assert_equal_array_contents [5, 6], result_ids('ship')
-    assert_equal_array_contents [6],    result_ids('foo')
-    assert_equal_array_contents [6],    result_ids('foo ship')
-    assert_equal_array_contents [6],    result_ids('ship foo')
-  end
-  
+    queries = {
+      nil        => [],
+      ''         => [],
+      'ship'     => [5,6],
+      'crane'    => [6,5],
+      'foo'      => [6],
+      'foo ship' => [6],
+      'ship foo' => [6]
+    }
+
+    run_queries(queries)
+  end
+
   def test_negative_queries
-    assert_equal_array_contents [5, 6], result_ids('crane')
-    assert_equal_array_contents [5],    result_ids('crane -foo')
-    assert_equal_array_contents [5],    result_ids('-foo crane')
-    assert_equal_array_contents [],     result_ids('-foo') #Edgecase
+    queries = {
+      'crane -foo' => [5],
+      '-foo crane' => [5],
+      '-foo'       => [] # edgecase
+    }
+
+    run_queries(queries)
   end
-  
+
   def test_quoted_queries
-    assert_equal_array_contents [5], result_ids('"crane ship"')
-    assert_equal_array_contents [6], result_ids('"crane big"')
-    assert_equal_array_contents [],  result_ids('foo "crane ship"')
-    assert_equal_array_contents [],  result_ids('"crane badger"')
+    queries = {
+      '"crane ship"'     => [5],
+      '"crane big"'      => [6],
+      'foo "crane ship"' => [],
+      '"crane badger"'   => []
+    }
+
+    run_queries(queries)
   end
-  
+
   def test_negative_quoted_queries
-    assert_equal_array_contents [6], result_ids('crane -"crane ship"')
-    assert_equal_array_contents [],  result_ids('-"crane big"') # Edgecase
+    queries = {
+      'crane -"crane ship"' => [6],
+      '-"crane big"'        => [] # edgecase
+    }
+
+    run_queries(queries)
   end
-  
+
   def test_scoped_negative_quoted_queries
-    assert_equal_array_contents [6], result_ids('crane -"crane ship"')
-    assert_equal_array_contents [],  result_ids('-"crane big"') # Edgecase
+    queries = {
+      'crane -"crane ship"' => [6],
+      '-"crane big"'        => []
+    }
+
+    run_queries(queries)
   end
-  
+
   def test_start_queries
-    assert_equal_array_contents [6,5],         result_ids('ship ^crane')
-    assert_equal_array_contents [6,5],         result_ids('^crane ship')
-    assert_equal_array_contents [6,5],         result_ids('^ship ^crane')
-    assert_equal_array_contents [6,5],         result_ids('^crane ^ship')
-    assert_equal_array_contents [6,5],         result_ids('^ship crane')
-    assert_equal_array_contents [6,5],         result_ids('crane ^ship')
-    assert_equal_array_contents [6,5],         result_ids('^crane')
-    assert_equal_array_contents [6,5],         result_ids('^cran')
-    assert_equal_array_contents [6,5],         result_ids('^cra')
-    assert_equal_array_contents [6,5,4],       result_ids('^cr')
-    assert_equal_array_contents [6,5,4,3,2,1], result_ids('^c')
-    assert_equal_array_contents [],            result_ids('^notthere')
-  end
-  
+    queries = {
+      'ship ^crane'  => [5,6],
+      '^crane ship'  => [5,6],
+      '^ship ^crane' => [5,6],
+      '^crane ^ship' => [5,6],
+      '^ship crane'  => [5,6],
+      'crane ^ship'  => [5,6],
+      '^crane'       => [6,5] ,
+      '^cran'        => [6,5],
+      '^cra'         => [6,5],
+      '^cr'          => [6,5,4],
+      '^c'           => [5,2,1,6,3,4],
+      '^notthere'    => []
+    }
+
+    run_queries(queries)
+  end
+
   def test_start_quoted_queries
-    assert_equal_array_contents [6,5],         result_ids('^"crane" ship')
-    assert_equal_array_contents [6,5],         result_ids('ship ^"crane"')
-    assert_equal_array_contents [5],           result_ids('^"crane ship"')
-    assert_equal_array_contents [5],           result_ids('^"crane shi"')
-    assert_equal_array_contents [5],           result_ids('^"crane sh"')
-    assert_equal_array_contents [5],           result_ids('^"crane s"')
-    assert_equal_array_contents [6,5],         result_ids('^"crane "')
-    assert_equal_array_contents [6,5],         result_ids('^"crane"')
-    assert_equal_array_contents [6,5],         result_ids('^"cran"')
-    assert_equal_array_contents [6,5],         result_ids('^"cra"')
-    assert_equal_array_contents [6,5,4],       result_ids('^"cr"')
-    assert_equal_array_contents [6,5,4,3,2,1], result_ids('^"c"')
-  end
-  
+    queries = {
+      '^"crane" ship' => [5,6],
+      'ship ^"crane"' => [5,6],
+      '^"crane ship"' => [5],
+      '^"crane shi"'  => [5],
+      '^"crane sh"'   => [5],
+      '^"crane s"'    => [5],
+      '^"crane "'     => [6,5],
+      '^"crane"'      => [6,5],
+      '^"cran"'       => [6,5],
+      '^"cra"'        => [6,5],
+      '^"cr"'         => [6,5,4],
+      '^"c"'          => [5,2,1,6,3,4],
+    }
+
+    run_queries(queries)
+  end
+
   def test_find_options
-    all_results = Post.find_with_index('crane',{},{:ids_only => true})
-    assert_equal 2, all_results.size
+    # limit.
+    assert_equal [6], Post.find_with_index('^cr', { :limit => 1 }, :ids_only => true)
+    assert_equal [6], Post.find_with_index('^cr', { :limit => 1 }).map{ |r| r.id }
+
+    # offset
+    assert_equal [5,4], Post.find_with_index('^cr', { :offset => 1 }, :ids_only => true)
+    assert_equal [5,4], Post.find_with_index('^cr', { :offset => 1 }).map{ |r| r.id }
+
+    # limit and offset
+    assert_equal [5], Post.find_with_index('^cr', { :limit => 1, :offset => 1 }, :ids_only => true)
+    assert_equal [5], Post.find_with_index('^cr', { :limit => 1, :offset => 1 }).map{ |r| r.id }
+
+    # order
+    assert_equal [6,5,4,3,2,1], Post.find_with_index('^c', { :order => 'id desc' }).map{ |r| r.id }
+    assert_equal [1,2,3,4,5,6], Post.find_with_index('^c', { :order => 'id' }).map{ |r| r.id }
+
+    # order and limit
+    assert_equal [6,5,4], Post.find_with_index('^c', { :order => 'id desc' , :limit => 3}).map{ |r| r.id }
+    assert_equal [1,2,3,4], Post.find_with_index('^c', { :order => 'id', :limit => 4 }).map{ |r| r.id }
+
+    # order and offset
+    assert_equal [5,4,3,2,1], Post.find_with_index('^c', { :order => 'id desc' , :offset => 1}).map{ |r| r.id }
+    assert_equal [3,4,5,6], Post.find_with_index('^c', { :order => 'id', :offset => 2 }).map{ |r| r.id }
+
+    # order, limit and offset
+    assert_equal [5,4,3], Post.find_with_index('^c', { :order => 'id desc' , :limit => 3, :offset => 1}).map{ |r| r.id }
+    assert_equal [3,4], Post.find_with_index('^c', { :order => 'id', :limit => 2, :offset => 2 }).map{ |r| r.id }
+  end
+
+  def test_should_error_when_ids_only_combined_with_finder_options
+    expected_message = "ids_only can not be combined with find option keys other than :offset or :limit"
     
-    first_result = Post.find_with_index('crane',{:limit => 1})
-    assert_equal 1, first_result.size
-    assert_equal all_results.first, first_result.first.id
-  
-    second_result = Post.find_with_index('crane',{:limit => 1, :offset => 1})
-    assert_equal 1, second_result.size
-    assert_equal all_results[1], second_result.first.id
-  end
-  
+    error = assert_raise(ArgumentError) do
+      Post.find_with_index('foo', { :order => 'id' }, :ids_only => true)
+    end
+    assert_equal(expected_message, error.message)
+
+    error = assert_raise(ArgumentError) do
+      Post.find_with_index('bar', { 'order' => 'id' }, :ids_only => true)
+    end
+    assert_equal(expected_message, error.message)
+  end
+
   # When a atom already in a record is duplicated, it removes
   # all records with that same atom from the index.
   def test_update_record_bug
     p = Post.find(6)
     assert p.update_attributes(:body => p.body + ' crane')
-    assert_equal 2, result_ids('crane').size
-    assert_equal 2, result_ids('ship').size
+    assert_equal 2, find_with_index_ids('crane').size
+    assert_equal 2, find_with_index_ids('ship').size
   end
-  
+
   # If an if proc is supplied, the index should only be created if the proc evaluated true
   def test_create_if
     Post.acts_as_indexed :fields => [:title, :body], :if => Proc.new { |post| post.visible }
-  
+
     original_post_count = Post.count
     assert_equal [], Post.find_with_index('badger', {}, { :no_query_cache => true, :ids_only => true})
     p = Post.new(:title => 'badger', :body => 'thousands of them!', :visible => true)
     assert p.save
     assert_equal original_post_count + 1, Post.count
     assert_equal [p.id], Post.find_with_index('badger', {}, { :no_query_cache => true, :ids_only => true})
-  
+
     original_post_count = Post.count
     assert_equal [], Post.find_with_index('unicorns')
     p = Post.new(:title => 'unicorns', :body => 'there are none', :visible => false)
@@ -151,45 +210,45 @@ class ActsAsIndexedTest < ActiveSupport::TestCase
     assert_equal original_post_count + 1, Post.count
     assert_equal [], Post.find_with_index('unicorns', {}, { :no_query_cache => true, :ids_only => true})
   end
-  
+
   # If an index already exists, and an if proc is supplied, and the proc is true, it should still appear in the index
   def test_update_if_update
     Post.acts_as_indexed :fields => [:title, :body], :if => Proc.new { |post| post.visible }
     destroy_index
-  
+
     assert_equal 1, Post.find_with_index('crane', {}, { :no_query_cache => true, :ids_only => true}).size
     p = Post.find(6)
     assert p.update_attributes(:visible => true)
     assert_equal 1, Post.find_with_index('crane', {}, { :no_query_cache => true, :ids_only => true}).size
   end
-  
+
   # If an index already exists, and an if proc is supplied, and the proc is false, it should no longer appear in the index
   def test_update_if_remove
     Post.acts_as_indexed :fields => [:title, :body], :if => Proc.new { |post| post.visible }
     destroy_index
-  
+
     assert_equal 1, Post.find_with_index('crane', {}, { :no_query_cache => true, :ids_only => true}).size
     p = Post.find(6)
     assert p.update_attributes(:visible => false)
     assert_equal 0, Post.find_with_index('crane',{},{ :no_query_cache => true, :ids_only => true}).size
   end
-  
+
   # If an index doesn't exist, and an if proc is supplied, and the proc is true, it should appear in the index
   def test_update_if_add
     Post.acts_as_indexed :fields => [:title, :body], :if => Proc.new { |post| post.visible }
     destroy_index
-  
+
     assert_equal 1, Post.find_with_index('crane', {}, { :no_query_cache => true, :ids_only => true}).size
     p = Post.find(5)
     assert p.update_attributes(:visible => true)
     assert_equal 2, Post.find_with_index('crane',{},{ :no_query_cache => true, :ids_only => true}).size
   end
-  
+
   # If an index doesn't exist, and an if proc is supplied, and the proc is false, then nothing happens
   def test_update_if_not_in
     Post.acts_as_indexed :fields => [:title, :body], :if => Proc.new { |post| post.visible }
     destroy_index
-  
+
     assert_equal 1, Post.find_with_index('crane', {}, { :no_query_cache => true, :ids_only => true}).size
     p = Post.find(5)
     assert p.update_attributes(:visible => false)
@@ -199,22 +258,43 @@ class ActsAsIndexedTest < ActiveSupport::TestCase
   def test_case_insensitive
     Post.acts_as_indexed :fields => [:title, :body], :case_sensitive => true
     destroy_index
-    
+
     assert_equal 1, Post.find_with_index('Ellis', {}, { :no_query_cache => true, :ids_only => true}).size
     assert_equal 0, Post.find_with_index('ellis', {}, { :no_query_cache => true, :ids_only => true}).size
-    
+
     assert_equal 3, Post.find_with_index('The', {}, { :no_query_cache => true, :ids_only => true}).size
     assert_equal 5, Post.find_with_index('the', {}, { :no_query_cache => true, :ids_only => true}).size
   end
 
   private
-  
-  def result_ids(query)
-    Post.with_query(query).map { |r| r.id }
+
+  def run_queries(queries)
+    queries.each do |query, expected_results|
+
+      actual_results = find_with_index_ids(query)
+      message = "#{expected_results.inspect} expected for find_with_index(#{query.inspect}) but was\n#{actual_results.inspect}"
+      assert expected_results == actual_results, message
+
+      actual_results = find_with_index_ids_only(query)
+      message = "#{expected_results.inspect} expected for find_with_index(#{query.inspect}, {}, :ids_only => true) but was\n#{actual_results.inspect}"
+      assert expected_results == actual_results, message
+
+      actual_results = find_with_query(query)
+      message = "#{expected_results.inspect} expected for with_query(#{query.inspect}) but was\n#{actual_results.inspect}"
+      assert expected_results.sort == actual_results.sort, message
+    end
+  end
+
+  def find_with_index_ids(query)
+    Post.find_with_index(query).map { |r| r.id }
   end
 
-  def assert_equal_array_contents(a, b)
-    a.sort == b.sort
+  def find_with_index_ids_only(query)
+    Post.find_with_index(query, {}, :ids_only => true)
+  end
+
+  def find_with_query(query)
+    Post.with_query(query).map { |r| r.id }
   end
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_indexed
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 7
   prerelease: 
   segments: 
   - 0
   - 7
-  - 1
-  version: 0.7.1
+  - 2
+  version: 0.7.2
 platform: ruby
 authors: 
 - Douglas F Shearer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-22 00:00:00 +00:00
+date: 2011-03-31 00:00:00 +01:00
 default_executable: 
 dependencies: []