acts_as_indexed 0.6.2

data/lib/will_paginate_search.rb

@@ -0,0 +1,29 @@
+# WillPaginateSearch
+# Copyright (c) 2007 - 2010 Douglas F Shearer.
+# http://douglasfshearer.com
+
+module WillPaginate
+
+  module Finder
+
+    module ClassMethods
+
+      # DEPRECATED. Use chained pagination instead.
+      def paginate_search(query, options)
+        warn "[DEPRECATION] `paginate_search` is deprecated and will be removed in a later release. Use `with_query(query).paginate()` instead."
+        page, per_page, total_entries = wp_parse_options(options)
+        
+        total_entries ||= find_with_index(query,{},{:ids_only => true}).size
+
+        returning WillPaginate::Collection.new(page, per_page, total_entries) do |pager|
+          options.update :offset => pager.offset, :limit => pager.per_page
+
+          options = options.delete_if {|key, value| [:page, :per_page].include?(key) }
+
+          pager.replace find_with_index(query, options)
+        end
+      end
+
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require 'acts_as_indexed'
+require 'will_paginate_search'

data/test/abstract_unit.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'fileutils'
+require 'rubygems'
+require 'active_record'
+require 'active_record/fixtures'
+require 'mocha'
+
+# Mock out the required environment variables.
+# Do this before requiring AAI.
+class Rails
+  def self.root
+    Dir.pwd
+  end
+  def self.env
+    'test'
+  end
+end
+
+require File.dirname(__FILE__) + '/../lib/acts_as_indexed'
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/test.log')
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'sqlite3')
+
+# Load Schema
+load(File.dirname(__FILE__) + '/schema.rb')
+
+# Load model.
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/fixtures/')
+
+class ActiveSupport::TestCase #:nodoc:
+  include ActiveRecord::TestFixtures
+  self.fixture_path = File.dirname(__FILE__) + '/fixtures/'
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+  
+  def destroy_index
+    `rm -rdf #{index_loc}`
+  end
+  
+  def build_index
+    # Makes a query to invoke the index build.
+    assert_equal [], Post.find_with_index('badger')
+    assert File.exists?(index_loc)
+    true
+  end
+  
+  def index_loc
+    File.join(Rails.root,'index')
+  end
+  
+end

data/test/acts_as_indexed_test.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class ActsAsIndexedTest < ActiveSupport::TestCase
+  fixtures :posts
+
+  def teardown
+    destroy_index
+  end
+
+  def test_adds_to_index
+    original_post_count = Post.count
+    assert_equal [], Post.find_with_index('badger')
+    p = Post.new(:title => 'badger', :body => 'Thousands of them!')
+    assert p.save
+    assert_equal original_post_count+1, Post.count
+    assert_equal [p.id], Post.find_with_index('badger',{},{:ids_only => true})
+  end
+
+  def test_removes_from_index
+    original_post_count = Post.count
+    assert_equal [posts(:wikipedia_article_4).id], Post.find_with_index('album',{},{:ids_only => true})
+    assert Post.find(posts(:wikipedia_article_4).id).destroy
+    assert_equal [], Post.find_with_index('album',{},{:ids_only => true})
+    assert_equal original_post_count-1, Post.count
+  end
+
+  def test_search_returns_posts
+    Post.find_with_index('album').each do |p|
+      assert_equal Post, p.class
+    end
+  end
+
+  def test_scoped_search_returns_posts
+    Post.with_query('album').each do |p|
+      assert_equal Post, p.class
+    end
+  end
+
+  def test_search_returns_post_ids
+    Post.find_with_index('album',{},{:ids_only => true}).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 Post.find_with_index('title',{},{:ids_only => true}).include?(p.id)
+    p.update_attributes(:title => 'No longer special')
+    assert !Post.find_with_index('title',{},{:ids_only => true}).include?(p.id)
+  end
+
+  def test_simple_queries
+    assert_equal [],  Post.find_with_index(nil)
+    assert_equal [],  Post.find_with_index('')
+    assert_equal [5, 6],  Post.find_with_index('ship',{},{:ids_only => true}).sort
+    assert_equal [6],  Post.find_with_index('foo',{},{:ids_only => true})
+    assert_equal [6],  Post.find_with_index('foo ship',{},{:ids_only => true})
+    assert_equal [6],  Post.find_with_index('ship foo',{},{:ids_only => true})
+  end
+
+  def test_scoped_simple_queries
+    assert_equal [],  Post.find_with_index(nil)
+    assert_equal [],  Post.with_query('')
+    assert_equal [5, 6],  Post.with_query('ship').map(&:id).sort
+    assert_equal [6],  Post.with_query('foo').map(&:id)
+    assert_equal [6],  Post.with_query('foo ship').map(&:id)
+    assert_equal [6],  Post.with_query('ship foo').map(&:id)
+  end
+
+  def test_negative_queries
+    assert_equal [5, 6],  Post.find_with_index('crane',{},{:ids_only => true}).sort
+    assert_equal [5],  Post.find_with_index('crane -foo',{},{:ids_only => true})
+    assert_equal [5],  Post.find_with_index('-foo crane',{},{:ids_only => true})
+    assert_equal [],  Post.find_with_index('-foo') #Edgecase
+  end
+
+  def test_scoped_negative_queries
+    assert_equal [5, 6],  Post.with_query('crane').map(&:id).sort
+    assert_equal [5],  Post.with_query('crane -foo').map(&:id)
+    assert_equal [5],  Post.with_query('-foo crane').map(&:id)
+    assert_equal [],  Post.with_query('-foo') #Edgecase
+  end
+
+  def test_quoted_queries
+    assert_equal [5],  Post.find_with_index('"crane ship"',{},{:ids_only => true})
+    assert_equal [6],  Post.find_with_index('"crane big"',{},{:ids_only => true})
+    assert_equal [],  Post.find_with_index('foo "crane ship"')
+    assert_equal [],  Post.find_with_index('"crane badger"')
+  end
+
+  def test_scoped_quoted_queries
+    assert_equal [5],  Post.with_query('"crane ship"').map(&:id)
+    assert_equal [6],  Post.with_query('"crane big"').map(&:id)
+    assert_equal [],  Post.with_query('foo "crane ship"')
+    assert_equal [],  Post.with_query('"crane badger"')
+  end
+
+  def test_negative_quoted_queries
+    assert_equal [6],  Post.find_with_index('crane -"crane ship"',{},{:ids_only => true})
+    assert_equal [],  Post.find_with_index('-"crane big"',{},{:ids_only => true}) # Edgecase
+  end
+
+  def test_scoped_negative_quoted_queries
+    assert_equal [6],  Post.with_query('crane -"crane ship"').map(&:id)
+    assert_equal [],  Post.with_query('-"crane big"') # Edgecase
+  end
+
+  def test_find_options
+    all_results = Post.find_with_index('crane',{},{:ids_only => true})
+    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
+
+  # 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
+    assert_equal 2, Post.find_with_index('crane',{},{:ids_only => true}).size
+    p = Post.find(6)
+    assert p.update_attributes(:body => p.body + ' crane')
+    assert_equal 2, Post.find_with_index('crane',{},{:ids_only => true}).size
+    assert_equal 2, Post.find_with_index('ship',{},{:ids_only => true}).size
+  end
+  
+end

data/test/configuration_test.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+include ActsAsIndexed
+
+class ConfigurationTest < ActiveSupport::TestCase  
+  
+  def test_default_index_file_should_be_set
+    assert_equal [Rails.root, 'index'], config.index_file
+  end
+  
+  def test_default_index_file_depth_should_be_set
+    assert_equal 3, config.index_file_depth
+  end
+
+  def test_default_min_word_size_should_be_set
+    assert_equal 3, config.min_word_size
+  end
+  
+  def test_index_file_should_be_writeable
+    config.index_file = [Rails.root, 'my_index']
+    assert_equal [Rails.root, 'my_index'], config.index_file
+  end
+  
+  def test_index_file_depth_should_be_writeable
+    config.index_file_depth = 5
+    assert_equal 5, config.index_file_depth
+  end
+  
+  def test_index_file_depth_should_raise_on_lower_than_1_value
+    assert_nothing_raised(ArgumentError) {  config.index_file_depth = 1  }
+    
+    e = assert_raise(ArgumentError) { config.index_file_depth = 0 }
+    assert_equal 'index_file_depth cannot be less than one (1)', e.message
+    
+    assert_raise(ArgumentError) { config.index_file_depth = -12 }
+  end
+  
+  def test_min_word_size_should_be_writeable
+    config.min_word_size = 7
+    assert_equal 7, config.min_word_size
+  end
+
+  def test_min_word_size_should_raise_on_lower_than_1_value
+    assert_nothing_raised(ArgumentError) {  config.min_word_size = 1  }
+
+    e = assert_raise(ArgumentError) { config.min_word_size = 0 }
+    assert_equal 'min_word_size cannot be less than one (1)', e.message
+
+    assert_raise(ArgumentError) { config.min_word_size = -12 }
+  end
+  
+  private
+  
+  def config
+    @config ||=ActsAsIndexed::Configuration.new
+  end
+  
+end

data/test/database.yml

@@ -0,0 +1,10 @@
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: root
+  :password:
+  :database: rails_plugin_test
+
+sqlite3:
+  :adapter: sqlite3
+  :database: ':memory:'

data/test/fixtures/post.rb

@@ -0,0 +1,5 @@
+class Post < ActiveRecord::Base
+  acts_as_indexed :fields => [:title, :body]
+  
+  validates_presence_of :title, :body
+end

data/test/fixtures/posts.yml

@@ -0,0 +1,31 @@
+# Content generated using the random article feature on Wikipedia, http://en.wikipedia.org/wiki/Special:Random
+# Wikipedia content may be redistributed under the GNU Free Documentation License; http://en.wikipedia.org/wiki/Wikipedia:Text_of_the_GNU_Free_Documentation_License
+wikipedia_article_1:
+  id: 1
+  title: Body Count (video game)
+  body: Body Count is a 1994 First-person shooter for the Sega Mega Drive. It is one of the few games that make use of the Menacer light gun and the Mega Mouse. \n In the U.S. the game was released on the Sega Channel.
+  
+wikipedia_article_2:
+  id: 2
+  title: Julien Ellis
+  body: Julien Ellis is a ice hockey goalie, born in Sorel, Quebec on January 27, 1986. He is currently 6'0" and weighs approximately 177 pounds. He wears number 34 and catches left. \n Julien played his entire junior hockey career in the QMJHL with the Shawinigan Cataractes. He was there from 2002 through the 2006 season, and played a total of 173 regular season games for them. During his time there, he recorded eight shutouts, as well as a career high .921 save percentage and 2.41 goals against average. \n Julien was chosen in round six of the 2004 NHL Entry Draft by the Vancouver Canucks, making him 189th overall pick and the 5th pick for Vancouver. \n His 2006-07 season was spent with the Victoria Salmon Kings of the ECHL, where he played 37 games and made 1,212 saves. Julien was called up the the Manitoba Moose of the AHL several times, where he played eight games.
+  
+wikipedia_article_3:
+  id: 3
+  title: Tuen Mun River
+  body: The Tuen Mun River is a river in Tuen Mun, New Territories, Hong Kong. It has many tributaries, with major ones coming from Lam Tei, Kau Keng Shan, Hung Shui Hang and Nai Wai. It flows south, splitting Tuen Mun into a west side and an east side. It eventually feeds into the Tuen Mun Typhoon Shelter, which is part of Castle Peak Bay.
+  
+wikipedia_article_4:
+  id: 4
+  title: So Happily Unsatisfied
+  body: So Happily Unsatisfied is an album that was recorded by the band Nine Days. It was intended to be the follow-up to their successful major-label debut, The Madding Crowd from 2000. The release date of the album was repeatedly delayed by Sony until the band was ultimately dropped. In the interim, the album had leaked onto the internet. The band has also put the whole album on their official website for the public to download.
+  
+wikipedia_article_5:
+  id: 5
+  title: SS Cornhusker State (T-ACS-6)
+  body: SS Cornhusker State (T-ACS-6) is a crane ship in ready reserve for the United States Navy. She is stationed at Cheatham Annex in Williamsburg, Virginia and is in ready reserve under the Military Sealift Command. The ship was named for the state of Nebraska, which is also known as the Cornhusker State. \n The ship was built by the Bath Iron Works. Her keel was laid on 27 November 1967, launched on 2 November 1968, and delivered 20 June 1969 as CV Stag Hound (MA 207). \n Stag Hound was acquired by the US Navy from the Maritime Administration in 1986 and was converted throughout 1987. She re-entered service as Cornhusker State on 12 March 1988, and has been in ready reserve since 1993.
+  
+article_similar_to_5:
+  id: 6
+  title: An article I made up by myself!
+  body: crane crane big ship foo

data/test/schema.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table :posts, :force => true do |t|
+    t.column :title, :string
+    t.column :body, :text
+  end
+end

data/test/search_atom_test.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+include ActsAsIndexed
+
+class SearchAtomTest < ActiveSupport::TestCase  
+  
+  def test_should_create_a_new_instance
+    assert SearchAtom.new
+  end
+  
+  def test_include_record_should_return_false
+    assert ! SearchAtom.new.include_record?(123)
+  end
+  
+  def test_include_record_should_return_true
+    assert build_search_atom.include_record?(123)
+  end
+  
+  def test_add_record_should_add_record
+    search_atom = SearchAtom.new
+    search_atom.add_record(456)
+    
+    assert search_atom.include_record?(456)
+  end
+  
+  def test_add_record_should_leave_positions_untouched
+    search_atom = build_search_atom
+    original_records_count = search_atom.record_ids.size
+    
+    search_atom.add_record(123)
+    assert_equal original_records_count, search_atom.record_ids.size
+    assert_equal [2,23,78], search_atom.positions(123)
+  end
+  
+  def test_add_position_should_add_position
+    search_atom = build_search_atom
+    search_atom.expects(:add_record).with(123)
+    
+    search_atom.add_position(123,98)
+    assert search_atom.positions(123).include?(98)
+  end
+  
+  def test_record_ids_should_return_obvious
+    assert_equal [123], build_search_atom.record_ids
+  end
+  
+  def test_positions_should_return_positions
+    assert_equal [2,23,78], build_search_atom.positions(123)
+  end
+  
+  def test_positions_should_return_nil
+    assert_equal nil, build_search_atom.positions(456)
+  end
+  
+  def test_remove_record
+    search_atom = build_search_atom
+    search_atom.remove_record(123)
+    assert ! search_atom.include_record?(123)
+  end
+  
+  def test_preceded_by
+    former = build_search_atom({ 1 => [1], 2 => [1] })
+    latter = build_search_atom({ 1 => [2], 2 => [3] })
+    result = latter.preceded_by(former)
+    assert_equal [1], result.record_ids
+    assert_equal [2], result.positions(1)
+  end
+  
+  def test_weightings
+    # 5 documents.
+    weightings = build_search_atom({ 1 => [1, 8], 2 => [1] }).weightings(5)
+    assert_in_delta(1.832, weightings[1], 2 ** -10)
+    assert_in_delta(0.916, weightings[2], 2 ** -10)
+    
+    # Empty positions.
+    weightings = build_search_atom({ 1 => [1, 8], 2 => [] }).weightings(5)
+    assert_in_delta(1.832, weightings[1], 2 ** -10)
+    assert_in_delta(0.0, weightings[2], 2 ** -10)
+    
+    # 10 documents.
+    weightings = build_search_atom({ 1 => [1, 8], 2 => [1] }).weightings(10)
+    assert_in_delta(3.219, weightings[1], 2 ** -10)
+    assert_in_delta(1.609, weightings[2], 2 ** -10)
+  end
+  
+  private
+  
+  def build_search_atom(records = { 123 => [2,23,78] })
+    search_atom = SearchAtom.new
+    records.each do |record_id, positions|
+      search_atom.add_record(record_id)
+      positions.each do |position|
+        search_atom.add_position(record_id, position)
+      end
+    end
+    search_atom
+  end
+  
+end

data/test/search_index_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+include ActsAsIndexed
+
+class SearchIndexTest < ActiveSupport::TestCase
+
+  def teardown
+    destroy_index
+  end
+
+  def test_should_check_for_non_existing_index
+    SearchIndex.any_instance.expects(:exists?).returns(false)
+    File.expects(:open).never
+    assert build_search_index
+  end
+
+  def test_should_check_for_existing_index
+    SearchIndex.any_instance.expects(:exists?).returns(true)
+    SearchIndex.any_instance.expects(:load_record_size).returns(0)
+    assert build_search_index
+  end
+  
+  def test_add_record
+    search_index = build_search_index
+    mock_record = mock(:id => 123)
+    mock_condensed_record = ['mock','condensed','record']
+    
+    search_index.expects(:condense_record).with(mock_record).returns(mock_condensed_record)
+    search_index.expects(:load_atoms).with(mock_condensed_record)
+    search_index.expects(:add_occurences).with(mock_condensed_record,123)
+    
+    search_index.add_record(mock_record)
+  end
+  
+  def test_add_records
+    search_index = build_search_index
+    mock_records = ['record0', 'record1']
+    
+    search_index.expects(:add_record).with('record0')
+    search_index.expects(:add_record).with('record1')
+    
+    search_index.add_records(mock_records)
+  end
+  
+  private
+  
+  def build_search_index(root = index_loc, index_depth = 2, fields = [:title, :body], min_word_size = 3)
+    SearchIndex.new([root], index_depth, fields, min_word_size)
+  end
+  
+end