sunspot 2.2.7 → 2.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4bdef6ed9f0c2c63ec693c6db3fe71149987c50d
-  data.tar.gz: c7451cff132715d22bff11d90bed4ba62bf516e2
+  metadata.gz: 97232f93d9d1c5ce704e6249cd1afcec04f7f231
+  data.tar.gz: 9eb35de3e65284cdec3eb299d6085cc32e662590
 SHA512:
-  metadata.gz: 71b60a64a69d3397a7d81c01282f8ab80e8c7b662bdb4196e91c84b9c06787d8787a2f37ba80e163f653ac0635ecf6edf682b2fec27a0dbef8ecfb79e9fd62c0
-  data.tar.gz: bdb4c1d76331b386db7a487b3161afbf4f10c7f5c3a74f0d45e1d1876d348f84ba7fa7dfc750d45a2342f0d73d8cf51b72567dae3972ffd5ac08549cd8bf5ec6
+  metadata.gz: 5bd0d81960ded04f07fdfa72811ddf959c5c97b0339e58246761469d3f9b4d9a82bf71ec69e8ee222b05ff9c07b5ff406f2702ef1ab8caeacbb1d219415b0044
+  data.tar.gz: b8adf8fc509ea65e460139687084832f8353e81e6ad1fd50f976db0a721545934761894ca42281962b19ce64b179a69b607dd3bb05b735b5fc53603aff0685a5

data/.gitignore

@@ -11,3 +11,4 @@ pkg
 README.rdoc
 .bundle
 Gemfile.lock
+gemfiles/*.gemfile*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Appraisals

@@ -0,0 +1,7 @@
+appraise 'rsolr-1.1.x' do
+  gem 'rsolr', '~> 1.1.0'
+end
+
+appraise 'rsolr-2.1.x' do
+  gem 'rsolr', '~> 2.1.0'
+end

data/Gemfile

@@ -1,11 +1,3 @@
 source "http://rubygems.org"
 
-gem 'sunspot_solr', :path => File.expand_path('../../sunspot_solr', __FILE__)
-
 gemspec
-
-group :development do
-  gem 'rake'
-end
-
-gem 'rsolr', ENV['RSOLR'] if ENV['RSOLR']

data/lib/sunspot/dsl/scope.rb

@@ -14,7 +14,12 @@ module Sunspot
 
       # Build a restriction to return only fields of the type in the results.
       def field_list(*args)
-        @query.add_field_list(Sunspot::Query::FieldList.new(args.flatten))
+        list = args.flatten.map { |field| @setup.field(field.to_sym).indexed_name.to_sym }
+        @query.add_field_list(Sunspot::Query::FieldList.new([:id] + list)) unless list.empty?
+      end
+
+      def without_stored_fields
+        @query.add_field_list(Sunspot::Query::FieldList.new([:id]))
       end
 
       #

data/lib/sunspot/field.rb

@@ -93,6 +93,17 @@ module Sunspot
       !!@joined
     end
 
+    #
+    # Whether the field is stored or not.
+    #
+    # ==== Returns
+    #
+    # Boolean:: True if this field is a stored field
+    #
+    def stored?
+      !!@stored
+    end
+
     def hash
       indexed_name.hash
     end

data/lib/sunspot/field_factory.rb

@@ -72,11 +72,15 @@ module Sunspot
       # into the Solr document for indexing.
       #
       def populate_document(document, model, options = {}) #:nodoc:
+        atomic_operation = options[:update] == :set
         value = extract_value(model, options)
-        unless value.nil?
-          Util.Array(@field.to_indexed(value)).each do |scalar_value|
+        if value != nil || atomic_operation
+          indexed_values = Util.Array(@field.to_indexed(value))
+          indexed_values = [nil] if indexed_values.empty? && atomic_operation
+          indexed_values.each do |scalar_value|
             field_options = {}
             field_options[:boost] = @field.boost if @field.boost
+            field_options[:null] = true if scalar_value.nil? && atomic_operation
             document.add_field(
               @field.indexed_name.to_sym,
               scalar_value,

data/lib/sunspot/query/bbox.rb

@@ -5,8 +5,12 @@ module Sunspot
         @field, @first_corner, @second_corner = field, first_corner, second_corner
       end
 
+      def to_solr_conditional
+        "[#{@first_corner.join(",")} TO #{@second_corner.join(",")}]"
+      end
+
       def to_params
-        filter = "#{@field.indexed_name}:[#{@first_corner.join(",")} TO #{@second_corner.join(",")}]"
+        filter = "#{@field.indexed_name}:#{to_solr_conditional}"
 
         {:fq => filter}
       end

data/lib/sunspot/query/restriction.rb

@@ -169,6 +169,17 @@ module Sunspot
           end
       end
 
+      class InBoundingBox < Base
+        def initialize(negated, field, first_corner, second_corner)
+          @bbox = Sunspot::Query::Bbox.new(field, first_corner, second_corner)
+          super negated, field, [first_corner, second_corner]
+        end
+
+        def to_solr_conditional
+          @bbox.to_solr_conditional
+        end
+      end
+
       # 
       # Results must have field with value equal to given value. If the value
       # is nil, results must have no value for the given field.

data/lib/sunspot/search/hit_enumerable.rb

@@ -11,6 +11,9 @@ module Sunspot
         end
       end
 
+      #
+      # Returns all of the hits that have a result
+      #
       def verified_hits
         hits.select { |h| h.result }
       end
@@ -31,7 +34,7 @@ module Sunspot
           hits_for_class = id_hit_hash[class_name]
           data_accessor.load_all(ids).each do |result|
             hit = hits_for_class.delete(Adapters::InstanceAdapter.adapt(result).id.to_s)
-            hit.result = result
+            hit.result = result if hit
           end
           hits_for_class.values.each { |hit| hit.result = nil }
         end

data/lib/sunspot/search/standard_search.rb

@@ -49,12 +49,11 @@ module Sunspot
       # the index. Otherwise return Solr's suggested collation.
       #
       # Solr's suggested collation is more liberal, replacing even terms that
-      # are present in the index. This may not be useful if only one term is
-      # misspelled and preventing useful results.
+      # are present in the index.
       #
       # Mix and match in your views for a blend of strict and liberal collations.
       def spellcheck_collation(*terms)
-        if solr_spellcheck['suggestions'] && solr_spellcheck['suggestions'].length > 2
+        if solr_spellcheck['suggestions'] && solr_spellcheck['suggestions'].length > 0
           collation = terms.join(" ").dup if terms
 
           # If we are given a query string, tokenize it and strictly replace

data/lib/sunspot/version.rb

@@ -1,3 +1,3 @@
 module Sunspot
-  VERSION = '2.2.7'
+  VERSION = '2.2.8'
 end

data/spec/api/adapters_spec.rb

@@ -2,45 +2,45 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 
 describe Sunspot::Adapters::InstanceAdapter do
   it "finds adapter by superclass" do
-    Sunspot::Adapters::InstanceAdapter::for(Model).should be(AbstractModelInstanceAdapter)
+    expect(Sunspot::Adapters::InstanceAdapter::for(Model)).to be(AbstractModelInstanceAdapter)
   end
 
   it "finds adapter by mixin" do
-    Sunspot::Adapters::InstanceAdapter::for(MixModel).should be(MixInModelInstanceAdapter)
+    expect(Sunspot::Adapters::InstanceAdapter::for(MixModel)).to be(MixInModelInstanceAdapter)
   end
 
   it 'throws NoAdapterError if anonymous module passed in' do
-    lambda do
+    expect do
       Sunspot::Adapters::InstanceAdapter::for(Module.new)
-    end.should raise_error(Sunspot::NoAdapterError)
+    end.to raise_error(Sunspot::NoAdapterError)
   end
 
   it "registers adapters found by ancestor lookup with the descendant class" do
-    Sunspot::Adapters::InstanceAdapter::registered_adapter_for(UnseenModel).should be(nil)
+    expect(Sunspot::Adapters::InstanceAdapter::registered_adapter_for(UnseenModel)).to be(nil)
     Sunspot::Adapters::InstanceAdapter::for(UnseenModel)
-    Sunspot::Adapters::InstanceAdapter::registered_adapter_for(UnseenModel).should be(AbstractModelInstanceAdapter)
+    expect(Sunspot::Adapters::InstanceAdapter::registered_adapter_for(UnseenModel)).to be(AbstractModelInstanceAdapter)
   end
 end
 
 describe Sunspot::Adapters::DataAccessor do
   it "finds adapter by superclass" do
-    Sunspot::Adapters::DataAccessor::for(Model).should be(AbstractModelDataAccessor)
+    expect(Sunspot::Adapters::DataAccessor::for(Model)).to be(AbstractModelDataAccessor)
   end
 
   it "finds adapter by mixin" do
-    Sunspot::Adapters::DataAccessor::for(MixModel).should be(MixInModelDataAccessor)
+    expect(Sunspot::Adapters::DataAccessor::for(MixModel)).to be(MixInModelDataAccessor)
   end
 
   it 'throws NoAdapterError if anonymous module passed in' do
-    lambda do
+    expect do
       Sunspot::Adapters::DataAccessor::for(Module.new)
-    end.should raise_error(Sunspot::NoAdapterError)
+    end.to raise_error(Sunspot::NoAdapterError)
   end
 
   it "registers adapters found by ancestor lookup with the descendant class" do
-    Sunspot::Adapters::DataAccessor::registered_accessor_for(UnseenModel).should be(nil)
+    expect(Sunspot::Adapters::DataAccessor::registered_accessor_for(UnseenModel)).to be(nil)
     Sunspot::Adapters::DataAccessor::for(UnseenModel)
-    Sunspot::Adapters::DataAccessor::registered_accessor_for(UnseenModel).should be(AbstractModelDataAccessor)
+    expect(Sunspot::Adapters::DataAccessor::registered_accessor_for(UnseenModel)).to be(AbstractModelDataAccessor)
   end
 end
 
@@ -51,30 +51,30 @@ describe Sunspot::Adapters::Registry do
   let(:mixin_accessor){ Sunspot::Adapters::DataAccessor::for(MixModel) }
 
   it "registers and retrieves a data accessor for abstractclass" do
-      registry.retrieve(AbstractModel).should be_a(abstractclass_accessor)
+      expect(registry.retrieve(AbstractModel)).to be_a(abstractclass_accessor)
   end
 
   it "registers and retrieves a data accessor for superclass" do
-      registry.retrieve(Model).should be_a(superclass_accessor)
+      expect(registry.retrieve(Model)).to be_a(superclass_accessor)
   end
 
   it "registers and retrieves a data accessor for mixin" do
-      registry.retrieve(MixModel).should be_a(mixin_accessor)
+      expect(registry.retrieve(MixModel)).to be_a(mixin_accessor)
   end
 
   it "injects inherited attributes" do
-    AbstractModelDataAccessor.any_instance.stub(:inherited_attributes).and_return([:to_be_injected])
+    allow_any_instance_of(AbstractModelDataAccessor).to receive(:inherited_attributes).and_return([:to_be_injected])
     in_registry_data_accessor = registry.retrieve(AbstractModel)
     in_registry_data_accessor.to_be_injected = "value"
-    registry.retrieve(Model).to_be_injected.should == "value"
+    expect(registry.retrieve(Model).to_be_injected).to eq("value")
   end
 
   it "not overrides inherited attributes" do
-    AbstractModelDataAccessor.any_instance.stub(:inherited_attributes).and_return([:to_be_injected])
+    allow_any_instance_of(AbstractModelDataAccessor).to receive(:inherited_attributes).and_return([:to_be_injected])
     parent_data_accessor = registry.retrieve(AbstractModel)
     current_data_accessor = registry.retrieve(Model)
     parent_data_accessor.to_be_injected = "value"
     current_data_accessor.to_be_injected = "safe-value"
-    registry.retrieve(Model).to_be_injected.should == "safe-value"
+    expect(registry.retrieve(Model).to_be_injected).to eq("safe-value")
   end
 end

data/spec/api/batcher_spec.rb

@@ -2,12 +2,12 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 
 describe Sunspot::Batcher do
   it "includes Enumerable" do
-    described_class.should include Enumerable
+    expect(described_class).to include Enumerable
   end
 
   describe "#each" do
     let(:current) { [:foo, :bar] }
-    before { subject.stub(:current).and_return current }
+    before { allow(subject).to receive(:current).and_return current }
 
     it "iterates over current" do
       yielded_values = []
@@ -16,25 +16,25 @@ describe Sunspot::Batcher do
         yielded_values << value
       end
 
-      yielded_values.should eq current
+      expect(yielded_values).to eq current
     end
   end
 
   describe "adding to current batch" do
     it "#push pushes to current" do
       subject.push :foo
-      subject.current.should include :foo
+      expect(subject.current).to include :foo
     end
 
     it "#<< pushes to current" do
       subject.push :foo
-      subject.current.should include :foo
+      expect(subject.current).to include :foo
     end
 
     it "#concat concatinates on current batch" do
       subject << :foo
       subject.concat [:bar, :mix]
-      should include :foo, :bar, :mix
+      is_expected.to include :foo, :bar, :mix
     end
   end
 
@@ -46,7 +46,7 @@ describe Sunspot::Batcher do
       end
 
       it "is empty by default" do
-        subject.current.should be_empty
+        expect(subject.current).to be_empty
       end
     end
 
@@ -58,7 +58,7 @@ describe Sunspot::Batcher do
       end
 
       it "returns the same as last time" do
-        subject.current.should eq subject.current
+        expect(subject.current).to eq subject.current
       end
     end
   end
@@ -71,7 +71,7 @@ describe Sunspot::Batcher do
     it "changes current" do
       subject << :foo
       subject.start_new
-      should_not include :foo
+      is_expected.not_to include :foo
     end
   end
 
@@ -88,25 +88,25 @@ describe Sunspot::Batcher do
       it "changes current" do
         subject << :foo
         subject.end_current
-        should_not include :foo
+        is_expected.not_to include :foo
       end
 
       it "returns current" do
         subject << :foo
-        subject.end_current.should include :foo
+        expect(subject.end_current).to include :foo
       end
     end
   end
 
   describe "#batching?" do
     it "is false when depth is 0" do
-      subject.should_receive(:depth).and_return 0
-      should_not be_batching
+      expect(subject).to receive(:depth).and_return 0
+      is_expected.not_to be_batching
     end
 
     it "is true when depth is more than 0" do
-      subject.should_receive(:depth).and_return 1
-      should be_batching
+      expect(subject).to receive(:depth).and_return 1
+      is_expected.to be_batching
     end
   end
 end

data/spec/api/binding_spec.rb

@@ -6,7 +6,7 @@ describe "DSL bindings" do
     session.search(Post) do
       value = test_method
     end
-    value.should == 'value'
+    expect(value).to eq('value')
   end
 
   it 'should give access to calling context\'s id method in search DSL' do
@@ -14,7 +14,7 @@ describe "DSL bindings" do
     session.search(Post) do
       value = id
     end
-    value.should == 16
+    expect(value).to eq(16)
   end
 
   it 'should give access to calling context\'s methods in nested DSL block' do
@@ -24,7 +24,7 @@ describe "DSL bindings" do
         value = test_method
       end
     end
-    value.should == 'value'
+    expect(value).to eq('value')
   end
 
   it 'should give access to calling context\'s methods in double-nested DSL block' do

data/spec/api/class_set_spec.rb

@@ -7,7 +7,7 @@ describe Sunspot::ClassSet do
     set = described_class.new
     set << class1 << class2
 
-    set.to_a.should =~ [class1, class2]
+    expect(set.to_a).to match_array([class1, class2])
   end
 
   it "replaces classes with the same name" do
@@ -15,10 +15,10 @@ describe Sunspot::ClassSet do
 
     class1 = double(:name => "Class1")
     set << class1
-    set.to_a.should == [class1]
+    expect(set.to_a).to eq([class1])
 
     class1_dup = double(:name => "Class1")
     set << class1_dup
-    set.to_a.should == [class1_dup]
+    expect(set.to_a).to eq([class1_dup])
   end
 end

data/spec/api/hit_enumerable_spec.rb

@@ -9,37 +9,60 @@ describe Sunspot::Search::HitEnumerable do
 
   describe "#hits" do
     before do
-      subject.stub(:solr_docs).and_return([{"id" => "Post 1", "score" => 3.14}])
-      subject.stub(:highlights_for)
+      allow(subject).to receive(:solr_docs).and_return([{"id" => "Post 1", "score" => 3.14}])
+      allow(subject).to receive(:highlights_for)
     end
 
     it "retrieves the raw Solr response from #solr_docs and constructs Hit objects" do
-      Sunspot::Search::Hit.should_receive(:new).
+      expect(Sunspot::Search::Hit).to receive(:new).
                            with({"id" => "Post 1", "score" => 3.14}, anything, anything)
 
       subject.hits
     end
 
     it "constructs Hit objects with highlights" do
-      subject.should_receive(:highlights_for).with({"id" => "Post 1", "score" => 3.14})
+      expect(subject).to receive(:highlights_for).with({"id" => "Post 1", "score" => 3.14})
 
       subject.hits
     end
 
     it "returns only verified hits if :verify => true is passed" do
-      Sunspot::Search::Hit.any_instance.stub(:result).and_return(nil)
+      allow_any_instance_of(Sunspot::Search::Hit).to receive(:result).and_return(nil)
 
-      subject.hits(:verify => true).should be_empty
+      expect(subject.hits(:verify => true)).to be_empty
     end
 
     it "returns an empty array if no results are available from Solr" do
-      subject.stub(:solr_docs).and_return(nil)
+      allow(subject).to receive(:solr_docs).and_return(nil)
 
-      subject.hits.should == []
+      expect(subject.hits).to eq([])
     end
 
     it "provides #populate_hits so that querying for one hit result will eager load the rest" do
-      Sunspot::Search::Hit.any_instance.should_receive(:result=)
+      expect_any_instance_of(Sunspot::Search::Hit).to receive(:result=)
+
+      subject.populate_hits
+    end
+  end
+
+  describe "#populate_hits" do
+    let(:post_1) { Post.new(id: "1", title: "Title 1") }
+
+    before do
+      allow(subject).to receive(:solr_docs).and_return([{ "id" => "Post 1", "score" => 3.14 }])
+      allow(subject).to receive(:highlights_for)
+    end
+
+    it "populates the hit object with the result from the data accessor" do
+      allow_any_instance_of(MockAdapter::DataAccessor).to receive(:load_all).and_return([post_1])
+      expect_any_instance_of(Sunspot::Search::Hit).to receive(:result=).with(post_1)
+
+      subject.populate_hits
+    end
+
+    it "populates the hit object only once if there are duplicate entries in the database (ex: db missing unique constraints)" do
+      allow_any_instance_of(MockAdapter::DataAccessor).to receive(:load_all).and_return([post_1, post_1])
+      expect_any_instance_of(Sunspot::Search::Hit).to receive(:result=).with(post_1)
 
       subject.populate_hits
     end