erichummel-sunspot 1.2.1 → 2.0.0.pre.111215

data/lib/sunspot/search/field_group.rb

@@ -0,0 +1,32 @@
+module Sunspot
+  module Search
+    class FieldGroup
+      def initialize(field, search, options) #:nodoc:
+        @field, @search, @options = field, search, options
+      end
+
+      def groups
+        @groups ||=
+          begin
+            if solr_response
+              solr_response['groups'].map do |group|
+                Group.new(group['groupValue'], group['doclist'], @search)
+              end
+            end
+          end
+      end
+
+      def matches
+        if solr_response
+          solr_response['matches'].to_i
+        end
+      end
+
+      private
+
+      def solr_response
+        @search.group_response[@field.indexed_name.to_s]
+      end
+    end
+  end
+end

data/lib/sunspot/search/group.rb

@@ -0,0 +1,50 @@
+require 'sunspot/search/hit_enumerable'
+
+module Sunspot
+  module Search
+    class Group
+      attr_reader :value
+
+      include HitEnumerable
+
+      def initialize(value, doclist, search)
+        @value, @doclist, @search = value, doclist, search
+      end
+
+      def hits(options = {})
+        if options[:verify]
+          super
+        else
+          @hits ||= super
+        end
+      end
+
+      def verified_hits
+        @verified_hits ||= super
+      end
+
+      def results
+        @results ||= verified_hits.map { |hit| hit.instance }
+      end
+
+      def highlights_for(doc)
+        @search.highlights_for(doc)
+      end
+
+      def solr_docs
+        @doclist['docs']
+      end
+      
+      #
+      # The total number of documents matching the query for this group
+      #
+      # ==== Returns
+      #
+      # Integer:: Total matching documents
+      # 
+      def total
+        @doclist['numFound']
+      end      
+    end
+  end
+end

data/lib/sunspot/search/hit.rb

@@ -96,6 +96,20 @@ module Sunspot
         "#<Sunspot::Search::Hit:#{@class_name} #{@primary_key}>"
       end
 
+      #
+      # Returns the instance primary key when the Hit is used to generate urls
+      # For example, using a search that stores the :name attribute:
+      #
+      #   hits = Sunspot.search(Object) do ...
+      #
+      #   hits.each do |hit|
+      #     link_to hit.stored(:name), edit_object_path(hit)
+      #   end
+      #
+      def to_param
+        self.primary_key
+      end
+
       private
 
       def setup
@@ -120,15 +134,15 @@ module Sunspot
 
       def stored_value(field_name, dynamic_field_name)
         setup.stored_fields(field_name, dynamic_field_name).each do |field|
-          if value = @stored_values[field.indexed_name]
-            case value
-            when Array
-              return value.map { |item| field.cast(item) }
-            else
-              return field.cast(value)
-            end
+          value = @stored_values[field.indexed_name]
+
+          if Array === value
+            return value.map { |item| field.cast(item) }
+          elsif !value.nil?
+            return field.cast(value)
           end
         end
+
         nil
       end
     end

data/lib/sunspot/search/hit_enumerable.rb

@@ -0,0 +1,72 @@
+module Sunspot
+  module Search
+    module HitEnumerable #:nodoc:
+      def hits(options = {})
+        if options[:verify]
+          verified_hits
+        elsif solr_docs
+          solr_docs.map { |d| Hit.new(d, highlights_for(d), self) }
+        else
+          []
+        end
+      end
+
+      def verified_hits
+        hits.select { |h| h.result }
+      end
+
+      # 
+      # Populate the Hit objects with their instances. This is invoked the first
+      # time any hit has its instance requested, and all hits are loaded as a
+      # batch.
+      #
+      def populate_hits #:nodoc:
+        id_hit_hash = Hash.new { |h, k| h[k] = {} }
+        hits.each do |hit|
+          id_hit_hash[hit.class_name][hit.primary_key] = hit
+        end
+        id_hit_hash.each_pair do |class_name, hits|
+          ids = hits.map { |id, hit| hit.primary_key }
+          data_accessor = data_accessor_for(Util.full_const_get(class_name))
+          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
+          end
+          hits_for_class.values.each { |hit| hit.result = nil }
+        end
+      end
+
+      #
+      # Convenience method to iterate over hit and result objects. Block is
+      # yielded a Sunspot::Server::Hit instance and a Sunspot::Server::Result
+      # instance.
+      #
+      # Note that this method iterates over verified hits (see #hits method
+      # for more information).
+      #
+      def each_hit_with_result
+        verified_hits.each do |hit|
+          yield(hit, hit.result)
+        end
+      end
+
+      # 
+      # Get the data accessor that will be used to load a particular class out of
+      # persistent storage. Data accessors can implement any methods that may be
+      # useful for refining how data is loaded out of storage. When building a
+      # search manually (e.g., using the Sunspot#new_search method), this should
+      # be used before calling #execute(). Use the
+      # Sunspot::DSL::Search#data_accessor_for method when building searches using
+      # the block DSL.
+      #
+      def data_accessor_for(clazz) #:nodoc:
+        # FIXME: This method does not belong here, but I was getting bogged
+        # down trying to figure out where it should go. Punted for now.
+        # - AL 27 Nov 2011
+        (@data_accessors ||= {})[clazz.name.to_sym] ||=
+          Adapters::DataAccessor.create(clazz)
+      end
+    end
+  end
+end

data/lib/sunspot/search/paginated_collection.rb

@@ -4,8 +4,10 @@ module Sunspot
     class PaginatedCollection
       instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval|object_id/ }
 
-      attr_reader :total_count, :current_page, :per_page
+      attr_reader :current_page, :per_page
+      attr_accessor :total_count
       alias :total_entries :total_count
+      alias :total_entries= :total_count=
       alias :limit_value :per_page
 
       def initialize(collection, page, per_page, total)
@@ -34,12 +36,12 @@ module Sunspot
 
       def next_page
         current_page < total_pages ? (current_page + 1) : nil
-      end  
+      end
 
       def out_of_bounds?
         current_page > total_pages
       end
-      
+
       def offset
         (current_page - 1) * per_page
       end

data/lib/sunspot/session.rb

@@ -239,7 +239,9 @@ module Sunspot
     #
     def connection
       @connection ||=
-        self.class.connection_class.connect(:url => config.solr.url)
+        self.class.connection_class.connect(:url          => config.solr.url,
+                                            :read_timeout => config.solr.read_timeout,
+                                            :open_timeout => config.solr.open_timeout)
     end
 
     def indexer

data/lib/sunspot/type.rb

@@ -354,6 +354,27 @@ module Sunspot
       end
     end
 
+    # 
+    # The Latlon type encodes geographical coordinates in the native
+    # Solr LatLonType.
+    #
+    # The data for this type must respond to the `lat` and `lng` methods; you
+    # can use Sunspot::Util::Coordinates as a wrapper if your source data does
+    # not follow this API.
+    #
+    # Location fields can be used with the geospatial DSL. See the
+    # Geospatial section of the README for examples.
+    #
+    class LatlonType < AbstractType
+      def indexed_name(name)
+        "#{name}_ll"
+      end
+
+      def to_indexed(value)
+        "#{value.lat.to_f},#{value.lng.to_f}"
+      end
+    end
+
     class ClassType < AbstractType
       def indexed_name(name) #:nodoc:
         'class_name'

data/lib/sunspot/util.rb

@@ -227,7 +227,16 @@ module Sunspot
         @__calling_context__.__send__(:id)
       end
 
+      # Special case due to `Kernel#sub`'s existence
+      def sub(*args, &block)
+        __proxy_method__(:sub, *args, &block)
+      end
+
       def method_missing(method, *args, &block)
+        __proxy_method__(method, *args, &block)
+      end
+
+      def __proxy_method__(method, *args, &block)
         begin
           @__receiver__.__send__(method.to_sym, *args, &block)
         rescue ::NoMethodError => e

data/lib/sunspot/version.rb

@@ -1,3 +1,3 @@
 module Sunspot
-  VERSION = '1.2.1'
+  VERSION = '2.0.0.pre.111215'
 end

data/spec/api/batcher_spec.rb

@@ -0,0 +1,112 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe Sunspot::Batcher do
+  it "includes Enumerable" do
+    described_class.should include Enumerable
+  end
+
+  describe "#each" do
+    let(:current) { [:foo, :bar] }
+    before { subject.stub(:current).and_return current }
+
+    it "iterates over current" do
+      yielded_values = []
+
+      subject.each do |value|
+        yielded_values << value
+      end
+
+      yielded_values.should eq current
+    end
+  end
+
+  describe "adding to current batch" do
+    it "#push pushes to current" do
+      subject.push :foo
+      subject.current.should include :foo
+    end
+
+    it "#<< pushes to current" do
+      subject.push :foo
+      subject.current.should include :foo
+    end
+
+    it "#concat concatinates on current batch" do
+      subject << :foo
+      subject.concat [:bar, :mix]
+      should include :foo, :bar, :mix
+    end
+  end
+
+
+  describe "#current" do
+    context "no current" do
+      it "starts a new" do
+        expect { subject.current }.to change(subject, :depth).by 1
+      end
+
+      it "is empty by default" do
+        subject.current.should be_empty
+      end
+    end
+
+    context "with a current" do
+      before { subject.start_new }
+
+      it "does not start a new" do
+        expect { subject.current }.to_not change(subject, :depth)
+      end
+
+      it "returns the same as last time" do
+        subject.current.should eq subject.current
+      end
+    end
+  end
+
+  describe "#start_new" do
+    it "creates a new batches" do
+      expect { 2.times { subject.start_new } }.to change(subject, :depth).by 2
+    end
+
+    it "changes current" do
+      subject << :foo
+      subject.start_new
+      should_not include :foo
+    end
+  end
+
+  describe "#end_current" do
+    context "no current batch" do
+      it "fails" do
+        expect { subject.end_current }.to raise_error Sunspot::Batcher::NoCurrentBatchError
+      end
+    end
+
+    context "with current batch" do
+      before { subject.start_new }
+
+      it "changes current" do
+        subject << :foo
+        subject.end_current
+        should_not include :foo
+      end
+
+      it "returns current" do
+        subject << :foo
+        subject.end_current.should 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
+    end
+
+    it "is true when depth is more than 0" do
+      subject.should_receive(:depth).and_return 1
+      should be_batching
+    end
+  end
+end

data/spec/api/class_set_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Sunspot::ClassSet do
+  it "is enumerable" do
+    class1, class2 = stub(:name => "Class1"), stub(:name => "Class2")
+
+    set = described_class.new
+    set << class1 << class2
+
+    set.to_a.should =~ [class1, class2]
+  end
+
+  it "replaces classes with the same name" do
+    set = described_class.new
+
+    class1 = stub(:name => "Class1")
+    set << class1
+    set.to_a.should == [class1]
+
+    class1_dup = stub(:name => "Class1")
+    set << class1_dup
+    set.to_a.should == [class1_dup]
+  end
+end

data/spec/api/hit_enumerable_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sunspot::Search::HitEnumerable do
+  subject do
+    Class.new do
+      include Sunspot::Search::HitEnumerable
+    end.new
+  end
+
+  describe "#hits" do
+    before do
+      subject.stub(:solr_docs).and_return([{"id" => "Post 1", "score" => 3.14}])
+      subject.stub(:highlights_for)
+    end
+
+    it "retrieves the raw Solr response from #solr_docs and constructs Hit objects" do
+      Sunspot::Search::Hit.should_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})
+
+      subject.hits
+    end
+
+    it "returns only verified hits if :verify => true is passed" do
+      Sunspot::Search::Hit.any_instance.stub(:result).and_return(nil)
+
+      subject.hits(:verify => true).should be_empty
+    end
+
+    it "returns an empty array if no results are available from Solr" do
+      subject.stub(:solr_docs).and_return(nil)
+
+      subject.hits.should == []
+    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=)
+
+      subject.populate_hits
+    end
+  end
+end