outoftime-sunspot 0.0.1

data/solr/solr/conf/stopwords.txt

@@ -0,0 +1,57 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+# a couple of test stopwords to test that the words are really being
+# configured from this file:
+stopworda
+stopwordb
+
+#Standard english stop words taken from Lucene's StopAnalyzer
+an
+and
+are
+as
+at
+be
+but
+by
+for
+if
+in
+into
+is
+it
+no
+not
+of
+on
+or
+s
+such
+t
+that
+the
+their
+then
+there
+these
+they
+this
+to
+was
+will
+with
+

data/solr/solr/conf/synonyms.txt

@@ -0,0 +1,31 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+#some test synonym mappings unlikely to appear in real input text
+aaa => aaaa
+bbb => bbbb1 bbbb2
+ccc => cccc1,cccc2
+a\=>a => b\=>b
+a\,a => b\,b
+fooaaa,baraaa,bazaaa
+
+# Some synonym groups specific to this example
+GB,gib,gigabyte,gigabytes
+MB,mib,megabyte,megabytes
+Television, Televisions, TV, TVs
+#notice we use "gib" instead of "GiB" so any WordDelimiterFilter coming
+#after us won't split it into two words.
+
+# Synonym mappings can be used for spelling correction too
+pixima => pixma
+

data/tasks/deployment.rake

@@ -0,0 +1,34 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end

data/tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/tasks/rcov.rake

@@ -0,0 +1,6 @@
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |t|
+  t.test_files = FileList['test/**/test_*.rb']
+  t.rcov_opts << "--sort coverage"
+  t.rcov_opts << "--only-uncovered"
+end

data/tasks/solr.rake

@@ -0,0 +1,12 @@
+namespace :solr do
+  namespace :test do
+    desc 'Start Solr server'
+    task :start do
+      FileUtils.cd File.join(File.dirname(__FILE__), '..', 'solr') do
+        Kernel.fork do
+          Kernel.exec("java -jar start.jar 2> #{File.join('..', 'log', 'test_solr.log')}")
+        end
+      end
+    end
+  end
+end

data/tasks/website.rake

@@ -0,0 +1,17 @@
+desc 'Generate website files'
+task :website_generate => :ruby_env do
+  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
+    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PATH}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]

data/test/api/test_build_search.rb

@@ -0,0 +1,216 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TestBuildSearch < Test::Unit::TestCase
+  CONFIG = Sunspot::Configuration.build
+
+  test 'should search by keywords' do
+    connection.expects(:query).with('(keyword search) AND (type:Post)', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    session.search Post, :keywords => 'keyword search'
+    session.search Post do
+      keywords 'keyword search'
+    end
+  end
+
+  test 'should scope by exact match with a string' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['title_s:My\ Pet\ Post'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    session.search Post, :conditions => { :title => 'My Pet Post' }
+    session.search Post do
+      with.title 'My Pet Post'
+    end
+  end
+
+  test 'should ignore nonexistant fields in hash scope' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page)
+    session.search Post, :conditions => { :bogus => 'Field' }
+  end
+
+  test 'should raise an ArgumentError for nonexistant fields in block scope' do
+    lambda do 
+      session.search Post do
+        with.bogus 'Field'
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  test 'should scope by exact match with time' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['published_at_d:1983\-07\-08T09\:00\:00Z'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    time = Time.parse('1983-07-08 05:00:00 -0400')
+    session.search Post, :conditions => { :published_at => time }
+    session.search Post do
+      with.published_at time
+    end
+  end
+
+  test 'should scope by less than match with float' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:[* TO 3\.0]'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+
+    session.search Post, :conditions => { :average_rating => 3.0 } do
+      conditions.interpret :average_rating, :less_than
+    end
+
+    session.search Post do
+      with.average_rating.less_than 3.0
+    end
+  end
+
+  test 'should scope by greater than match with float' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:[3\.0 TO *]'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    session.search Post, :conditions => { :average_rating => 3.0 } do 
+      conditions.interpret :average_rating, :greater_than
+    end
+    session.search Post do
+      with.average_rating.greater_than 3.0
+    end
+  end
+
+  test 'should scope by between match with float' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:[2\.0 TO 4\.0]'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    session.search Post, :conditions => { :average_rating => [2.0, 4.0] } do
+      conditions.interpret :average_rating, :between
+    end
+    session.search Post do
+      with.average_rating.between 2.0..4.0
+    end
+  end
+
+  test 'should scope by any match with integer' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['category_ids_im:(2 OR 7 OR 12)'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    session.search Post, :conditions => { :category_ids => [2, 7, 12] }
+    session.search Post do
+      with.category_ids.any_of [2, 7, 12]
+    end
+  end
+
+  test 'should scope by all match with integer' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['category_ids_im:(2 AND 7 AND 12)'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    session.search Post, :conditions => { :category_ids => [2, 7, 12] } do
+      conditions.interpret :category_ids, :all_of
+    end
+    session.search Post do
+      with.category_ids.all_of [2, 7, 12]
+    end
+  end
+
+  test 'should allow setting of default conditions' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:2\.0'], :start => 0, :rows => CONFIG.pagination.default_per_page)
+    session.search Post do
+      conditions.default :average_rating, 2.0
+    end
+  end
+
+  test 'should not use default condition value if condition provided' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:3\.0'], :start => 0, :rows => CONFIG.pagination.default_per_page)
+    session.search Post, :conditions => { :average_rating => 3.0 } do
+      conditions.default :average_rating, 2.0
+    end
+  end
+
+  test 'should paginate using default per_page' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => [], :rows => 30, :start => 30).times(2)
+    session.search Post, :page => 2
+    session.search Post do
+      paginate :page => 2
+    end
+  end
+
+  test 'should paginate using provided per_page' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => [], :rows => 15, :start => 45).times(2)
+    session.search Post, :page => 4, :per_page => 15
+    session.search Post do
+      paginate :page => 4, :per_page => 15
+    end
+  end
+
+  test 'should order' do
+    connection.expects(:query).with('(type:Post)', :filter_queries => [], :sort => [{ :average_rating_f => :descending }], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    session.search Post, :order => 'average_rating desc'
+    session.search Post do
+      order_by :average_rating, :desc
+    end
+  end
+
+  test 'should build search for multiple types' do
+    connection.expects(:query).with('(type:(Post OR Comment))', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page)
+    session.search(Post, Comment)
+  end
+
+  test 'should allow search on fields common to all types' do
+    connection.expects(:query).with('(type:(Post OR Comment))', :filter_queries => ['published_at_d:1983\-07\-08T09\:00\:00Z'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
+    time = Time.parse('1983-07-08 05:00:00 -0400')
+    session.search Post, Comment, :conditions => { :published_at => time }
+    session.search Post, Comment do
+      with.published_at time
+    end
+  end
+
+  test 'should raise exception if search scoped to field not common to all types' do
+    lambda do
+      session.search Post, Comment do
+        with.blog_id 1
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  test 'should raise exception if search scoped to field configured differently between types' do
+    lambda do
+      session.search Post, Comment do
+        with.average_rating 2.2 # this is a float in Post but an integer in Comment
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  test 'should ignore condition if field is not common to all types' do
+    connection.expects(:query).with('(type:(Post OR Comment))', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page)    
+    session.search Post, Comment, :conditions => { :blog_id => 1 }
+  end
+
+  test 'should raise ArgumentError if bogus field scoped' do
+    lambda do
+      session.search Post do
+        with.bogus.equal_to :field
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  test 'should raise NoMethodError if bogus operator referenced' do
+    lambda do
+      session.search Post do
+        with.category_ids.resembling :bogus_condition
+      end
+    end.should raise_error(NoMethodError)
+  end
+
+  test 'should raise ArgumentError if no :page argument given to paginate' do
+    lambda do
+      session.search Post do
+        paginate
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  test 'should raise ArgumentError if bogus argument given to paginate' do
+    lambda do
+      session.search Post do
+        paginate :page => 4, :ugly => :puppy
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  test 'should raise NoMethodError if more than one argument passed to scope method' do # or should it?
+    lambda do
+      session.search Post do
+        with.category_ids 4, 5
+      end
+    end.should raise_error(NoMethodError)
+  end
+
+  private
+
+  def connection
+    @connection ||= stub
+  end
+
+  def session
+    @session ||= Sunspot::Session.new(CONFIG, connection)
+  end
+end

data/test/api/test_helper.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+gem 'mocha', '~>0.9'
+require 'mocha'

data/test/api/test_indexer.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TestIndexer < Test::Unit::TestCase
+  CONFIG = Sunspot::Configuration.build
+
+  describe 'when indexing an object' do
+    test 'should index id and type' do
+      connection.expects(:add).with(has_entries(:id => "Post #{post.id}", :type => ['Post', 'BaseClass']))
+      session.index post
+    end
+
+    test 'should index text' do
+      post :title => 'A Title', :body => 'A Post'
+      connection.expects(:add).with(has_entries(:title_text => 'A Title', :body_text => 'A Post'))
+      session.index post
+    end
+
+    test 'should correctly index a string attribute field' do 
+      post :title => 'A Title'
+      connection.expects(:add).with(has_entries(:title_s => 'A Title'))
+      session.index post
+    end
+
+    test 'should correctly index an integer attribute field' do
+      post :blog_id => 4
+      connection.expects(:add).with(has_entries(:blog_id_i => '4'))
+      session.index post
+    end
+
+    test 'should correctly index a float attribute field' do
+      post :average_rating => 2.23
+      connection.expects(:add).with(has_entries(:average_rating_f => '2.23'))
+      session.index post
+    end
+
+    test 'should allow indexing by a multiple-value field' do
+      post :category_ids => [3, 14]
+      connection.expects(:add).with(has_entries(:category_ids_im => ['3', '14']))
+      session.index post
+    end
+
+    test 'should correctly index a time field' do
+      post :published_at => Time.parse('1983-07-08 05:00:00 -0400')
+      connection.expects(:add).with(has_entries(:published_at_d => '1983-07-08T09:00:00Z'))
+      session.index post
+    end
+
+    test 'should correctly index a virtual field' do
+      post :title => 'The Blog Post'
+      connection.expects(:add).with(has_entries(:sort_title_s => 'blog post'))
+      session.index post
+    end
+
+    test 'should correctly index a field that is defined on a superclass' do
+      Sunspot.setup(BaseClass) { string :author_name }
+      post :author_name => 'Mat Brown'
+      connection.expects(:add).with(has_entries(:author_name_s => 'Mat Brown'))
+      session.index post
+    end
+
+    test 'should remove an object from the index' do
+      connection.expects(:delete).with("Post #{post.id}")
+      session.remove(post)
+    end
+
+    test 'should be able to remove everything from the index' do
+      connection.expects(:delete_by_query).with("type:[* TO *]")
+      session.remove_all
+    end
+
+    test 'should be able to remove everything of a given class from the index' do
+      connection.expects(:delete_by_query).with("type:Post")
+      session.remove_all(Post)
+    end
+  end
+
+  test 'should throw a NoMethodError only if a nonexistent type is defined' do
+    lambda { Sunspot.setup(Post) { string :author_name }}.should_not raise_error
+    lambda { Sunspot.setup(Post) { bogus :journey }}.should raise_error(NoMethodError)
+  end
+
+  test 'should throw a NoMethodError if a nonexistent field argument is passed' do
+    lambda { Sunspot.setup(Post) { string :author_name, :bogus => :argument }}.should raise_error(ArgumentError)
+  end
+
+  test 'should throw an ArgumentError if an attempt is made to index an object that has no configuration' do
+    lambda { session.index(Time.now) }.should raise_error(ArgumentError)
+  end
+
+  test 'should throw an ArgumentError if single-value field tries to index multiple values' do
+    lambda do
+      Sunspot.setup(Post) { string :author_name }
+      session.index(post(:author_name => ['Mat Brown', 'Matthew Brown']))
+    end.should raise_error(ArgumentError)
+  end
+
+  private
+
+  def connection
+    @connection ||= stub
+  end
+
+  def session
+    @session ||= Sunspot::Session.new(CONFIG, connection)
+  end
+
+  def post(attrs = {})
+    @post ||= Post.new(attrs)
+  end
+end

data/test/api/test_retrieve_search.rb

@@ -0,0 +1,114 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TestRetrieveSearch < Test::Unit::TestCase
+  CONFIG = Sunspot::Configuration.build
+
+  test 'should load search result' do
+    post = Post.new
+    stub_results(post)
+
+    session.search(Post).results.should == [post]
+  end
+
+  test 'should load multiple search results in order' do
+    post_1, post_2 = Post.new, Post.new
+    stub_results(post_1, post_2)
+    session.search(Post).results.should == [post_1, post_2]
+    stub_results(post_2, post_1)
+    session.search(Post).results.should == [post_2, post_1]
+  end
+
+  test 'should return search total as attribute of results if pagination is provided' do
+    stub_results(Post.new, 4)
+    session.search(Post, :page => 1).results.total_entries.should == 4
+  end
+
+  test 'should return vanilla array if pagination is provided but WillPaginate is not available' do
+    stub_results(Post.new)
+    without_class(WillPaginate) do
+      session.search(Post, :page => 1).results.should_not respond_to(:total_entries)
+    end
+  end
+
+  test 'should return total' do
+    stub_results(Post.new, Post.new, 4)
+    session.search(Post, :page => 1).total.should == 4
+  end
+
+  test 'should give access to order through hash and object' do
+    stub_results
+    search = session.search(Post, :order => 'sort_title asc')
+    search.attributes[:order].should == 'sort_title asc'
+    search.order.should == 'sort_title asc'
+  end
+
+  test 'should give nil order if no order set' do
+    stub_results
+    search = session.search(Post)
+    search.attributes.should have_key(:order)
+    search.attributes[:order].should be_nil
+    search.order.should be_nil
+  end
+
+  test 'should give access to page and per-page through hash and object' do
+    stub_results
+    search = session.search(Post, :page => 2, :per_page => 15)
+    search.attributes[:page].should == 2
+    search.attributes[:per_page].should == 15
+    search.page.should == 2
+    search.per_page.should == 15
+  end
+
+  test 'should give access to keywords' do
+    stub_results
+    search = session.search(Post, :keywords => 'some keywords')
+    search.attributes[:keywords].should == 'some keywords'
+    search.keywords.should == 'some keywords'
+  end
+
+  test 'should have nil keywords if no keywords given' do
+    stub_results
+    search = session.search(Post)
+    search.attributes.should have_key(:keywords)
+    search.attributes[:keywords].should be_nil
+    search.keywords.should be_nil
+  end
+
+  test 'should give access to conditions' do
+    stub_results
+    search = session.search(Post, :conditions => { :blog_id => 1 })
+    search.attributes[:conditions][:blog_id].should == 1
+    search.conditions.blog_id.should == 1
+  end
+
+  test 'should have nil values for fields with unspecified conditions' do
+    stub_results
+    search = session.search(Post)
+    %w(title blog_id category_ids average_rating published_at sort_title).each do |field_name|
+      search.attributes[:conditions].should have_key(field_name.to_sym)
+      search.attributes[:conditions][field_name.to_sym].should == nil
+      search.conditions.should respond_to(field_name)
+      search.conditions.send(field_name).should == nil
+    end
+  end
+
+  private
+
+  def stub_results(*results)
+    total_hits = if results.last.is_a?(Integer) then results.pop 
+                 else results.length
+                 end
+    response = stub
+    response.stubs(:hits).returns(results.map { |result| { 'id' => "#{result.class.name} #{result.id}" }})
+    response.stubs(:total_hits).returns(total_hits)
+    connection.stubs(:query).returns(response)
+  end
+
+  def connection
+    @connection ||= Object.new
+  end
+
+  def session
+    @session ||= Sunspot::Session.new(CONFIG, connection)
+  end
+end

data/test/api/test_session.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TestSession < Test::Unit::TestCase
+  context 'using singleton session' do
+    before do
+      Sunspot.reset!
+      connection.expects(:add)
+      connection.expects(:query)
+    end
+
+    test 'should open connection with defaults if nothing specified' do
+      Solr::Connection.stubs(:new).with('http://localhost:8983/solr', :autocommit => :on).returns(connection)
+      Sunspot.index(Post.new)
+      Sunspot.search(Post)
+    end
+
+    test 'should open a connection with custom host' do
+      Solr::Connection.stubs(:new).with('http://127.0.0.1:8981/solr', :autocommit => :on).returns(connection)
+      Sunspot.config.solr.url = 'http://127.0.0.1:8981/solr'
+      Sunspot.index(Post.new)
+      Sunspot.search(Post)
+    end
+  end
+
+  context 'using custom session' do
+    before do
+      connection.expects(:add)
+      connection.expects(:query)
+    end
+
+    test 'should open a connection with custom host' do
+      Solr::Connection.stubs(:new).with('http://127.0.0.1:8982/solr', :autocommit => :on).returns(connection)
+      session = Sunspot::Session.new do |config|
+        config.solr.url = 'http://127.0.0.1:8982/solr'
+      end
+      session.index(Post.new)
+      session.search(Post)
+    end
+  end
+
+  private
+
+  def connection
+    @connection ||= stub_everything('Connection')
+  end
+end