outoftime-sunspot 0.0.2 → 0.7.0

data/spec/api/search_retrieval_spec.rb

@@ -27,15 +27,79 @@ describe 'retrieving search' do
     end
   end
 
+  it 'should return raw results without loading instances' do
+    post_1, post_2 = Array.new(2) { Post.new }
+    stub_results(post_1, post_2)
+    %w(load load_all).each { |message| MockAdapter::DataAccessor.should_not_receive(message) }
+    session.search(Post, :page => 1).raw_results.map do |raw_result|
+      [raw_result.class_name, raw_result.primary_key]
+    end.should == [['Post', post_1.id.to_s], ['Post', post_2.id.to_s]]
+  end
+
   it 'should return total' do
     stub_results(Post.new, Post.new, 4)
     session.search(Post, :page => 1).total.should == 4
   end
 
+  it 'should return field name for facet' do
+    stub_facet(:title_s, {})
+    result = session.search Post do
+      facet :title
+    end
+    result.facet(:title).field_name.should == :title
+  end
+
+  it 'should return string facet' do
+    stub_facet(:title_s, 'Author 1' => 2, 'Author 2' => 1)
+    result = session.search Post do
+      facet :title
+    end
+    facet_values(result, :title).should == ['Author 1', 'Author 2']
+  end
+
+  it 'should return counts for facet' do
+    stub_facet(:title_s, 'Author 1' => 2, 'Author 2' => 1)
+    result = session.search Post do
+      facet :title
+    end
+    facet_counts(result, :title).should == [2, 1]
+  end
+
+  it 'should return integer facet' do
+    stub_facet(:blog_id_i, '3' => 2, '1' => 1)
+    result = session.search Post do
+      facet :blog_id
+    end
+    facet_values(result, :blog_id).should == [3, 1]
+  end
+
+  it 'should return float facet' do
+    stub_facet(:average_rating_f, '9.3' => 2, '1.1' => 1)
+    result = session.search Post do
+      facet :average_rating
+    end
+    facet_values(result, :average_rating).should == [9.3, 1.1]
+  end
+
+  it 'should return time facet' do
+    stub_facet(:published_at_d, '2009-04-07T20:25:23Z' => 3, '2009-04-07T20:26:19Z' => 1)
+    result = session.search Post do
+      facet :published_at
+    end
+    facet_values(result, :published_at).should == [Time.gm(2009, 04, 07, 20, 25, 23),
+                                                   Time.gm(2009, 04, 07, 20, 26, 19)]
+  end
+
+  it 'should return boolean facet' do
+    stub_facet(:featured_b, 'true' => 3, 'false' => 1)
+    result = session.search(Post) { facet(:featured) }
+    facet_values(result, :featured).should == [true, false]
+  end
+
   private
 
   def stub_results(*results)
-    total_hits = if results.last.is_a?(Integer) then results.pop 
+    total_hits = if results.last.is_a?(Integer) then results.pop
                  else results.length
                  end
     response = mock('response')
@@ -44,9 +108,28 @@ describe 'retrieving search' do
     connection.stub!(:query).and_return(response)
   end
 
+  def stub_facet(name, values)
+    response = mock('response')
+    facets = values.map do |data, count|
+      value = Solr::Response::Standard::FacetValue.new
+      value.name = data
+      value.value = count
+      value
+    end.sort_by { |value| -value.value }
+    response.stub!(:field_facets).with(name.to_s).and_return(facets)
+    connection.stub!(:query).and_return(response)
+  end
+
+  def facet_values(result, field_name)
+    result.facet(field_name).rows.map { |row| row.value }
+  end
+
+  def facet_counts(result, field_name)
+    result.facet(field_name).rows.map { |row| row.count }
+  end
+
   def config
     @config ||= Sunspot::Configuration.build
-
   end
 
   def connection

data/spec/api/session_spec.rb

@@ -4,41 +4,49 @@ describe 'Session' do
   context 'using singleton session' do
     before :each do
       Sunspot.reset!
-      connection.should_receive(:add)
+      connection.should_receive(:add).twice
+      connection.should_receive(:commit).twice
       connection.should_receive(:query)
     end
 
     it 'should open connection with defaults if nothing specified' do
-      Solr::Connection.stub!(:new).with('http://localhost:8983/solr', :autocommit => :on).and_return(connection)
+      Solr::Connection.stub!(:new).with('http://localhost:8983/solr').and_return(connection)
       Sunspot.index(Post.new)
+      Sunspot.index!(Post.new)
+      Sunspot.commit
       Sunspot.search(Post)
     end
 
     it 'should open a connection with custom host' do
-      Solr::Connection.stub!(:new).with('http://127.0.0.1:8981/solr', :autocommit => :on).and_return(connection)
+      Solr::Connection.stub!(:new).with('http://127.0.0.1:8981/solr').and_return(connection)
       Sunspot.config.solr.url = 'http://127.0.0.1:8981/solr'
       Sunspot.index(Post.new)
+      Sunspot.index!(Post.new)
+      Sunspot.commit
       Sunspot.search(Post)
     end
   end
 
   context 'using custom session' do
     before :each do
-      connection.should_receive(:add)
+      connection.should_receive(:add).twice
+      connection.should_receive(:commit).twice
       connection.should_receive(:query)
     end
 
     it 'should open a connection with custom host' do
-      Solr::Connection.stub!(:new).with('http://127.0.0.1:8982/solr', :autocommit => :on).and_return(connection)
+      Solr::Connection.stub!(:new).with('http://127.0.0.1:8982/solr').and_return(connection)
       session = Sunspot::Session.new do |config|
         config.solr.url = 'http://127.0.0.1:8982/solr'
       end
       session.index(Post.new)
+      session.index!(Post.new)
+      session.commit
       session.search(Post)
     end
   end
 
   def connection
-    @connection ||= stub_everything('Connection')
+    @connection ||= mock('Connection').as_null_object
   end
 end

data/spec/integration/faceting_spec.rb

@@ -0,0 +1,39 @@
+describe 'search faceting' do
+  def self.test_field_type(name, attribute, field, value1, value2)
+    context "with field of type #{name}" do
+      before :all do
+        Sunspot.remove_all
+        2.times do
+          Sunspot.index(Post.new(attribute => value1))
+        end
+        Sunspot.index(Post.new(attribute => value2))
+        Sunspot.commit
+      end
+
+      before :each do
+        @search = Sunspot.search(Post) do
+          facet(field)
+        end
+      end
+
+      it "should return value #{value1.inspect} with count 2" do
+        row = @search.facet(field).rows[0]
+        row.value.should == value1
+        row.count.should == 2
+      end
+
+      it "should return value #{value2.inspect} with count 1" do
+        row = @search.facet(field).rows[1]
+        row.value.should == value2
+        row.count.should == 1
+      end
+    end
+  end
+
+  test_field_type('String', :title, :title, 'Title 1', 'Title 2')
+  test_field_type('Integer', :blog_id, :blog_id, 3, 4)
+  test_field_type('Float', :ratings_average, :average_rating, 2.2, 1.1)
+  test_field_type('Time', :published_at, :published_at, Time.mktime(2008, 02, 17, 17, 45, 04),
+                                                        Time.mktime(2008, 07, 02, 03, 56, 22))
+  test_field_type('Boolean', :featured, :featured, true, false)
+end

data/spec/integration/keyword_search_spec.rb

@@ -10,7 +10,7 @@ describe 'keyword search' do
                        :body => 'The interpreted strain scans the buffer around the upper temper')
     @posts << Post.new(:title => 'The toast abbreviates the recovering spirit',
                        :body => 'Does the wind interpret the buffer?')
-    Sunspot.index(*@posts)
+    Sunspot.index!(*@posts)
   end
 
   it 'matches a single keyword out of a single field' do

data/spec/integration/scoped_search_spec.rb

@@ -0,0 +1,175 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'scoped_search' do
+  def self.test_field_type(name, attribute, field, *values)
+    raise(ArgumentError, 'Please supply five values') unless values.length == 5
+
+    context "with field of type #{name}" do
+      before :all do
+        Sunspot.remove_all
+        @posts = values.map do |value|
+          post = Post.new(attribute => value)
+          Sunspot.index(post)
+          post
+        end
+        Sunspot.commit
+      end
+
+      it 'should filter by exact match' do
+        Sunspot.search(Post) { with(field, values[2]) }.results.should == [@posts[2]]
+      end
+
+      it 'should reject by inexact match' do
+        results = Sunspot.search(Post) { without(field, values[2]) }.results
+        [0, 1, 3, 4].each { |i| results.should include(@posts[i]) }
+        results.should_not include(@posts[2])
+      end
+
+      it 'should filter by less than' do
+        results = Sunspot.search(Post) { with(field).less_than values[2] }.results
+        (0..2).each { |i| results.should include(@posts[i]) }
+        (3..4).each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by less than' do
+        results = Sunspot.search(Post) { without(field).less_than values[2] }.results
+        (0..2).each { |i| results.should_not include(@posts[i]) }
+        (3..4).each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should filter by greater than' do
+        results = Sunspot.search(Post) { with(field).greater_than values[2] }.results
+        (2..4).each { |i| results.should include(@posts[i]) }
+        (0..1).each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by greater than' do
+        results = Sunspot.search(Post) { without(field).greater_than values[2] }.results
+        (2..4).each { |i| results.should_not include(@posts[i]) }
+        (0..1).each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should filter by between' do
+        results = Sunspot.search(Post) { with(field).between(values[1]..values[3]) }.results
+        (1..3).each { |i| results.should include(@posts[i]) }
+        [0, 4].each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by between' do
+        results = Sunspot.search(Post) { without(field).between(values[1]..values[3]) }.results
+        (1..3).each { |i| results.should_not include(@posts[i]) }
+        [0, 4].each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should filter by any of' do
+        results = Sunspot.search(Post) { with(field).any_of(values.values_at(1, 3)) }.results
+        [1, 3].each { |i| results.should include(@posts[i]) }
+        [0, 2, 4].each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by any of' do
+        results = Sunspot.search(Post) { without(field).any_of(values.values_at(1, 3)) }.results
+        [1, 3].each { |i| results.should_not include(@posts[i]) }
+        [0, 2, 4].each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should order by field ascending' do
+        results = Sunspot.search(Post) { order_by field, :asc }.results
+        results.should == @posts
+      end
+
+      it 'should order by field descending' do
+        results = Sunspot.search(Post) { order_by field, :desc }.results
+        results.should == @posts.reverse
+      end
+    end
+  end
+
+  test_field_type 'String', :title, :title, 'apple', 'banana', 'cherry', 'date', 'eggplant'
+  test_field_type 'Integer', :blog_id, :blog_id, -2, 0, 3, 12, 20
+  test_field_type 'Float', :ratings_average, :average_rating, -2.5, 0.0, 3.2, 3.5, 16.0
+  test_field_type 'Time', :published_at, :published_at, *(['1970-01-01 00:00:00 UTC', '1983-07-08 04:00:00 UTC', '1983-07-08 02:00:00 -0500',
+                                                           '2005-11-05 10:00:00 UTC', Time.now.to_s].map { |t| Time.parse(t) })
+
+  describe 'Boolean field type' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [Post.new(:featured => true), Post.new(:featured => false), Post.new]
+      Sunspot.index!(@posts)
+    end
+
+    it 'should filter by exact match for true' do
+      Sunspot.search(Post) { with(:featured, true) }.results.should == [@posts[0]]
+    end
+
+    it 'should filter for exact match for false' do
+      Sunspot.search(Post) { with(:featured, false) }.results.should == [@posts[1]]
+    end
+  end
+
+  describe 'passing nil value to equal' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [Post.new(:title => 'apple'), Post.new]
+      Sunspot.index!(@posts)
+    end
+
+    it 'should filter results without value for field' do
+      Sunspot.search(Post) { with(:title, nil) }.results.should == [@posts[1]]
+    end
+
+    it 'should exclude results without value for field' do
+      Sunspot.search(Post) { without(:title, nil) }.results.should == [@posts[0]]
+    end
+  end
+
+  describe 'exclusion by identity' do
+    before do
+      @posts = (1..5).map do |i|
+        post = Post.new
+        Sunspot.index(post)
+        post
+      end
+      Sunspot.commit
+    end
+
+    it 'should not return excluded object' do
+      excluded_post = @posts.shift
+      Sunspot.search(Post) { without(excluded_post) }.results.should_not include(excluded_post)
+    end
+
+    it 'should return objects not excluded' do
+      excluded_post = @posts.shift
+      for included_post in @posts
+        Sunspot.search(Post) { without(excluded_post) }.results.should include(included_post)
+      end
+    end
+
+    it 'should not return excluded objects' do
+      excluded_posts = [@posts.shift, @posts.shift]
+      for excluded_post in excluded_posts
+        Sunspot.search(Post) { without(excluded_posts) }.results.should_not include(excluded_post)
+      end
+    end
+  end
+
+  describe 'multiple column ordering' do
+    before do
+      Sunspot.remove_all
+      @posts = [
+        Post.new(:ratings_average => 2, :title => 'banana'),
+        Post.new(:ratings_average => 2, :title => 'eggplant'),
+        Post.new(:ratings_average => 1, :title => 'apple')
+      ].each { |post| Sunspot.index(post) }
+      Sunspot.commit
+    end
+
+    it 'should order with precedence given' do
+      search = Sunspot.search(Post) do
+        order_by :average_rating, :desc
+        order_by :sort_title, :asc
+      end
+      search.results.should == @posts
+    end
+  end
+end

data/spec/mocks/mock_adapter.rb

@@ -1,25 +1,22 @@
 require File.join(File.dirname(__FILE__), 'post')
 
 module MockAdapter
-  class InstanceAdapter
-    include Sunspot::Adapters::InstanceAdapter
-    
+  class InstanceAdapter < Sunspot::Adapters::InstanceAdapter
     def id
-      instance.id
+      @instance.id
     end
   end
 
-  class ClassAdapter
-    include Sunspot::Adapters::ClassAdapter
-
+  class DataAccessor < Sunspot::Adapters::DataAccessor
     def load(id)
-      clazz.get(id.to_i)
+      @clazz.get(id.to_i)
     end
 
     def load_all(ids)
-      clazz.get_all(ids.map { |id| id.to_i })
+      @clazz.get_all(ids.map { |id| id.to_i })
     end
   end
 end
 
-Sunspot::Adapters.register(MockAdapter, BaseClass)
+Sunspot::Adapters::DataAccessor.register(MockAdapter::DataAccessor, BaseClass)
+Sunspot::Adapters::InstanceAdapter.register(MockAdapter::InstanceAdapter, BaseClass)

data/spec/mocks/post.rb

@@ -3,7 +3,8 @@ class Post < BaseClass
   @@posts = [nil]
 
   attr_reader :id
-  attr_accessor :title, :body, :blog_id, :published_at, :average_rating, :author_name
+  attr_accessor :title, :body, :blog_id, :published_at, :ratings_average, :author_name, :featured
+  alias_method :featured?, :featured
 
 
   def initialize(attrs = {})
@@ -33,9 +34,13 @@ Sunspot.setup(Post) do
   string :title
   integer :blog_id
   integer :category_ids, :multiple => true
-  float :average_rating
+  float :average_rating, :using => :ratings_average
   time :published_at
+  boolean :featured, :using => :featured?
   string :sort_title do
     title.downcase.sub(/^(a|an|the)\W+/, '') if title
   end
+  integer :primary_category_id do |post|
+    post.category_ids.first
+  end
 end

data/tasks/rdoc.rake

@@ -0,0 +1,7 @@
+require 'rake/rdoctask'
+
+Rake::RDocTask.new(:doc) do |rdoc|
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc', 'lib/sunspot.rb', 'lib/sunspot/**/*.rb')
+  rdoc.rdoc_dir = 'doc'
+end

data/tasks/spec.rake

@@ -6,16 +6,19 @@ require 'spec/rake/spectask'
 desc 'run specs'
 Spec::Rake::SpecTask.new('spec') do |t|
   t.spec_files = FileList[File.join(File.dirname(__FILE__), '..', 'spec', '**', '*_spec.rb')]
+  t.spec_opts = ['--color']
 end
 
 namespace :spec do
   desc 'run api specs (mock out Solr dependency)'
   Spec::Rake::SpecTask.new('api') do |t|
     t.spec_files = FileList[File.join(File.dirname(__FILE__), '..', 'spec', 'api', '*_spec.rb')]
+    t.spec_opts = ['--color']
   end
 
   desc 'run integration specs (be sure to run `bin/sunspot-solr start`)'
   Spec::Rake::SpecTask.new('integration') do |t|
     t.spec_files = FileList[File.join(File.dirname(__FILE__), '..', 'spec', 'integration', '*_spec.rb')]
+    t.spec_opts = ['--color']
   end
 end

data/tasks/todo.rake

@@ -0,0 +1,4 @@
+desc 'Show all TODO and related tags'
+task :todo do
+  FileList['lib/**/*.rb'].egrep(/#.*(TODO|FIXME|XXX)/)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: outoftime-sunspot
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.7.0
 platform: ruby
 authors: 
 - Mat Brown
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-14 00:00:00 -08:00
+date: 2009-04-28 00:00:00 -07:00
 default_executable: sunspot-solr
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,18 +63,22 @@ extra_rdoc_files: []
 files: 
 - Rakefile
 - README.rdoc
+- TODO
 - History.txt
 - VERSION.yml
 - bin/sunspot-solr
 - lib/sunspot
 - lib/sunspot/session.rb
 - lib/sunspot/type.rb
+- lib/sunspot/facets.rb
+- lib/sunspot/facet.rb
 - lib/sunspot/adapters.rb
 - lib/sunspot/restriction.rb
+- lib/sunspot/facet_row.rb
 - lib/sunspot/configuration.rb
 - lib/sunspot/dsl.rb
 - lib/sunspot/search.rb
-- lib/sunspot/builder.rb
+- lib/sunspot/setup.rb
 - lib/sunspot/field.rb
 - lib/sunspot/indexer.rb
 - lib/sunspot/query.rb
@@ -86,11 +90,11 @@ files:
 - lib/sunspot.rb
 - lib/light_config.rb
 - spec/spec_helper.rb
-- spec/custom_expectation.rb
 - spec/integration
 - spec/integration/spec_helper.rb
+- spec/integration/faceting_spec.rb
+- spec/integration/scoped_search_spec.rb
 - spec/integration/keyword_search_spec.rb
-- spec/integration/field_types_spec.rb
 - spec/integration/test_pagination.rb
 - spec/mocks
 - spec/mocks/base_class.rb
@@ -102,10 +106,11 @@ files:
 - spec/api/spec_helper.rb
 - spec/api/session_spec.rb
 - spec/api/build_search_spec.rb
-- spec/api/standard_search_builder_spec.rb
 - spec/api/indexer_spec.rb
 - tasks/gemspec.rake
 - tasks/rcov.rake
+- tasks/todo.rake
+- tasks/rdoc.rake
 - tasks/spec.rake
 - solr/etc/webdefault.xml
 - solr/etc/jetty.xml
@@ -150,7 +155,7 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Library for expressive, powerful interaction with the Solr search engine
 test_files: []
 

data/lib/sunspot/builder.rb

@@ -1,78 +0,0 @@
-module Sunspot
-  module Builder
-    class AbstractBuilder
-      attr_reader :search, :types, :field_names
-
-      def initialize(query_dsl, types, field_names)
-        @search, @types, @field_names = query_dsl, types, field_names
-      end
-    end
-
-    class ParamsBuilder < AbstractBuilder
-      attr_reader :params
-
-      def initialize(query_dsl, types, field_names, params = {})
-        super(query_dsl, types, field_names)
-        @params = params
-        params.each_pair do |field_name, value|
-          self.send("#{field_name}=", value)
-        end
-      end
-    end
-
-    class StandardBuilder < ParamsBuilder
-      def initialize(query_dsl, types, field_names, params = {})
-        params = { :keywords => nil, :conditions => {}, :order => nil, :page => nil, :per_page => nil }.merge(params)
-        field_names.each { |field_name| params[:conditions][field_name.to_sym] = nil unless params[:conditions].has_key?(field_name.to_sym) }
-        super(query_dsl, types, field_names, params)
-      end
-
-      def keywords=(keywords)
-        search.keywords(keywords) if keywords
-      end
-
-      def conditions=(conditions)
-        conditions.each_pair do |field_name, value|
-          unless value.nil?
-            unless value.is_a?(Array)
-              search.with.send(field_name, value) if field_names.include?(field_name.to_s)
-            else
-              search.with.send(field_name).any_of(value)
-            end
-          end
-        end
-      end
-
-      def order=(order_string)
-        search.order_by(*order_string.split(' ')) if order_string
-      end
-
-      def page=(page)
-        search.paginate(:page => page, :per_page => params[:per_page]) if page
-      end
-
-      def per_page=(per_page) # ugly
-      end
-
-      def keywords
-        params[:keywords]
-      end
-
-      def conditions
-        ::Sunspot::Util::ClosedStruct.new(params[:conditions])
-      end
-      
-      def order
-        params[:order]
-      end
-
-      def page
-        params[:page]
-      end
-
-      def per_page
-        params[:per_page]
-      end
-    end
-  end
-end