sunspot 1.3.3 → 2.0.0.pre.111215

data/History.txt

@@ -1,13 +1,10 @@
-== 1.3.3 2012-06-11
-
-* Adds missing `more_like_this` method to `StubSessionProxy` (Patrick Van Stee)
-
-== 1.3.2
-
-* Set initialization order for Railtie (Mauro)
-* Removes deprecated `InstanceMethods` module (Anders Bengtsson)
-* Adds `Retry5xxSessionProxy` to retry requests when an internal server error
-  occurs (Nick Zadrozny)
+== 2.0.0
+* Adds support for field grouping (Andy Lindeman)
+* Adds support for native geospatial searches and ordering (Eric Tang, Bruno Miranda, Andy Lindeman)
+* Bundled Solr installation (`sunspot_solr`) is version 3.5.0 (Chris Parker)
+* Adds #query_time method to retrieve the Solr query time in
+  milliseconds (Jason Weathered)
+* Fixes syntax of highlighting when used with nested dismax queries (Marco Crepaldi)
 
 == 1.3.0 2011-11-26
 * Requests to Solr use HTTP POST verb by default to avoid issues when the query string grows too large for GET (Johan Van Ryseghem)

data/lib/sunspot/configuration.rb

@@ -8,6 +8,8 @@ module Sunspot
   # Sunspot.config.pagination.default_per_page::
   #   Solr always paginates its results. This sets Sunspot's default result
   #   count per page if it is not explicitly specified in the query.
+  # Sunspot.config.indexing.default_batch_size::
+  #   This sets the batch size for indexing, default is 50
   #
   module Configuration
     class <<self
@@ -28,6 +30,9 @@ module Sunspot
           pagination do
             default_per_page 30
           end
+          indexing do
+            default_batch_size 50
+          end
         end
       end
       

data/lib/sunspot/dsl/field_group.rb

@@ -0,0 +1,37 @@
+module Sunspot
+  module DSL
+    class FieldGroup
+      def initialize(query, setup, group)
+        @query, @setup, @group = query, setup, group
+      end
+
+      #
+      # Sets the number of results (documents) to return for each group.
+      # Defaults to 1.
+      #
+      def limit(num)
+        @group.limit = num
+      end
+
+      # Specify the order that results should be returned in. This method can
+      # be called multiple times; precedence will be in the order given.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: the field to use for ordering
+      # direction<Symbol>:: :asc or :desc (default :asc)
+      #
+      def order_by(field_name, direction = nil)
+        sort =
+          if special = Sunspot::Query::Sort.special(field_name)
+            special.new(direction)
+          else
+            Sunspot::Query::Sort::FieldSort.new(
+              @setup.field(field_name), direction
+            )
+          end
+        @group.add_sort(sort)
+      end
+    end
+  end
+end

data/lib/sunspot/dsl/field_query.rb

@@ -31,6 +31,27 @@ module Sunspot
         @query.add_sort(sort)
       end
 
+      #
+      # Specify that the results should be ordered based on their
+      # distance from a given point.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>::
+      #   the field that stores the location (declared as `latlon`)
+      # lat<Numeric>::
+      #   the reference latitude
+      # lon<Numeric>::
+      #   the reference longitude
+      # direction<Symbol>::
+      #   :asc or :desc (default :asc)
+      # 
+      def order_by_geodist(field_name, lat, lon, direction = nil)
+        @query.add_sort(
+          Sunspot::Query::Sort::GeodistSort.new(@setup.field(field_name), lat, lon, direction)
+        )
+      end
+
       # 
       # DEPRECATED Use <code>order_by(:random)</code>
       #
@@ -38,6 +59,33 @@ module Sunspot
         order_by(:random)
       end
 
+      # Specify a field for result grouping. Grouping groups documents
+      # with a common field value, return only the top document per
+      # group.
+      #
+      # More information in the Solr documentation:
+      # <http://wiki.apache.org/solr/FieldCollapsing>
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: the field to use for grouping
+      def group(*field_names, &block)
+        options = Sunspot::Util.extract_options_from(field_names)
+
+        field_names.each do |field_name|
+          field = @setup.field(field_name)
+          group = @query.add_group(Sunspot::Query::FieldGroup.new(field))
+          @search.add_field_group(field)
+
+          if block
+            Sunspot::Util.instance_eval_or_call(
+              FieldGroup.new(@query, @setup, group),
+              &block
+            )
+          end
+        end
+      end
+
       #
       # Request a facet on the search query. A facet is a feature of Solr that
       # determines the number of documents that match the existing search *and*

data/lib/sunspot/dsl/restriction_with_near.rb

@@ -116,6 +116,23 @@ module Sunspot
       def near(lat, lng, options = {})
         @query.fulltext.add_location(@field, lat, lng, options)
       end
+
+      #
+      # Performs a query that is filtered by a radius around a given
+      # latitude and longitude.
+      #
+      # ==== Parameters
+      #
+      # :lat<Numeric>::
+      #   Latitude (in degrees)
+      # :lon<Numeric>::
+      #   Longitude (in degrees)
+      # :radius<Numeric>::
+      #   Radius (in kilometers)
+      #
+      def in_radius(lat, lon, radius)
+        @query.add_geo(Sunspot::Query::Geofilt.new(@field, lat, lon, radius))
+      end
     end
   end
 end

data/lib/sunspot/dsl.rb

@@ -1,5 +1,5 @@
 %w(fields scope paginatable adjustable field_query standard_query query_facet
    functional fulltext restriction restriction_with_near search
-   more_like_this_query function).each do |file|
+   more_like_this_query function field_group).each do |file|
   require File.join(File.dirname(__FILE__), 'dsl', file)
 end

data/lib/sunspot/query/common_query.rb

@@ -20,6 +20,11 @@ module Sunspot
         @sort << sort
       end
 
+      def add_group(group)
+        @components << group
+        group
+      end
+
       def add_field_facet(facet)
         @components << facet
         facet
@@ -35,6 +40,11 @@ module Sunspot
         function
       end
 
+      def add_geo(geo)
+        @components << geo
+        geo
+      end
+
       def paginate(page, per_page, offset = nil)
         if @pagination
           @pagination.offset = offset

data/lib/sunspot/query/dismax.rb

@@ -64,7 +64,7 @@ module Sunspot
         params.delete :defType
         params.delete :fl
         keywords = params.delete(:q)
-        options = params.map { |key, value| "#{key}='#{escape_quotes(value)}'"}.join(' ')
+        options = params.map { |key, value| escape_param(key, value) }.join(' ')
         "_query_:\"{!dismax #{options}}#{escape_quotes(keywords)}\""
       end
 
@@ -117,6 +117,10 @@ module Sunspot
 
 
       private
+      
+      def escape_param(key, value)
+        "#{key}='#{escape_quotes(Array(value).join(" "))}'"
+      end
 
       def escape_quotes(value)
         return value unless value.is_a? String

data/lib/sunspot/query/field_group.rb

@@ -0,0 +1,35 @@
+module Sunspot
+  module Query
+    #
+    # A FieldGroup groups by the unique values of a given field.
+    #
+    class FieldGroup
+      attr_accessor :limit
+
+      def initialize(field)
+        if field.multiple?
+          raise(ArgumentError, "#{field.name} cannot be used for grouping because it is a multiple-value field")
+        end
+        @field = field
+
+        @sort = SortComposite.new
+      end
+
+      def add_sort(sort)
+        @sort << sort
+      end
+
+      def to_params
+        params = {
+          :group         => "true",
+          :"group.field" => @field.indexed_name,
+        }
+
+        params.merge!(@sort.to_params("group."))
+        params[:"group.limit"] = @limit if @limit
+
+        params
+      end
+    end
+  end
+end

data/lib/sunspot/query/geofilt.rb

@@ -0,0 +1,15 @@
+module Sunspot
+  module Query
+    class Geofilt
+      def initialize(field, lat, lon, radius)
+        @field, @lat, @lon, @radius = field, lat, lon, radius
+      end
+
+      def to_params
+        filter = "{!geofilt sfield=#{@field.indexed_name} pt=#{@lat},#{@lon} d=#{@radius}}"
+
+        {:fq => filter}
+      end
+    end
+  end
+end

data/lib/sunspot/query/sort.rb

@@ -90,6 +90,20 @@ module Sunspot
           "score #{direction_for_solr}"
         end
       end
+
+      #
+      # A GeodistSort sorts by distance from a given point.
+      #
+      class GeodistSort < FieldSort
+        def initialize(field, lat, lon, direction)
+          @lat, @lon = lat, lon
+          super(field, direction)
+        end
+
+        def to_param
+          "geodist(#{@field.indexed_name.to_sym},#{@lat},#{@lon}) #{direction_for_solr}"
+        end
+      end
     end
   end
 end

data/lib/sunspot/query/sort_composite.rb

@@ -21,9 +21,10 @@ module Sunspot
       # 
       # Combine the sorts into a single param by joining them
       #
-      def to_params
+      def to_params(prefix = "")
         unless @sorts.empty?
-          { :sort => @sorts.map { |sort| sort.to_param } * ', ' }
+          key = "#{prefix}sort".to_sym
+          { key => @sorts.map { |sort| sort.to_param } * ', ' }
         else
           {}
         end

data/lib/sunspot/query.rb

@@ -1,8 +1,8 @@
 %w(filter abstract_field_facet connective boost_query date_field_facet dismax
    field_facet highlighting pagination restriction common_query
-   standard_query more_like_this more_like_this_query geo query_facet scope
+   standard_query more_like_this more_like_this_query geo geofilt query_facet scope
    sort sort_composite text_field_boost function_query
-   composite_fulltext).each do |file|
+   composite_fulltext field_group).each do |file|
   require(File.join(File.dirname(__FILE__), 'query', file))
 end
 module Sunspot

data/lib/sunspot/search/abstract_search.rb

@@ -1,4 +1,5 @@
 require 'sunspot/search/paginated_collection'
+require 'sunspot/search/hit_enumerable'
 
 module Sunspot
   module Search #:nodoc:
@@ -14,15 +15,21 @@ module Sunspot
       # Retrieve all facet objects defined for this search, in order they were
       # defined. To retrieve an individual facet by name, use #facet()
       #
-      attr_reader :facets
+      attr_reader :facets, :groups
       attr_reader :query #:nodoc:
       attr_accessor :request_handler
+
+      include HitEnumerable
   
       def initialize(connection, setup, query, configuration) #:nodoc:
         @connection, @setup, @query = connection, setup, query
         @query.paginate(1, configuration.pagination.default_per_page)
+
         @facets = []
         @facets_by_name = {}
+
+        @groups_by_name = {}
+        @groups = []
       end
   
       #
@@ -78,44 +85,33 @@ module Sunspot
       #
       def hits(options = {})
         if options[:verify]
-          verified_hits
+          super
         else
-          @hits ||=
-            begin
-              hits = if solr_response && solr_response['docs']
-                solr_response['docs'].map do |doc|
-                  Hit.new(doc, highlights_for(doc), self)
-                end
-              end
-              paginate_collection(hits || [])
-            end
+          @hits ||= paginate_collection(super)
         end
       end
       alias_method :raw_results, :hits
-  
+
+      # 
+      # The total number of documents matching the query parameters
       #
-      # Convenience method to iterate over hit and result objects. Block is
-      # yielded a Sunspot::Server::Hit instance and a Sunspot::Server::Result
-      # instance.
+      # ==== Returns
       #
-      # Note that this method iterates over verified hits (see #hits method
-      # for more information).
+      # Integer:: Total matching documents
       #
-      def each_hit_with_result
-        verified_hits.each do |hit|
-          yield(hit, hit.result)
-        end
+      def total
+        @total ||= solr_response['numFound'] || 0
       end
   
       # 
-      # The total number of documents matching the query parameters
+      # The time elapsed to generate the Solr response
       #
       # ==== Returns
       #
-      # Integer:: Total matching documents
+      # Integer:: Query runtime in milliseconds
       #
-      def total
-        @total ||= solr_response['numFound'] || 0
+      def query_time
+        @query_time ||= solr_response_header['QTime']
       end
   
       # 
@@ -167,6 +163,12 @@ module Sunspot
           end
         end
       end
+
+      def group(name)
+        if name
+          @groups_by_name[name.to_sym]
+        end
+      end
   
       # 
       # Deprecated in favor of optional second argument to #facet
@@ -178,19 +180,9 @@ module Sunspot
       def facet_response #:nodoc:
         @solr_result['facet_counts']
       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:
-        (@data_accessors ||= {})[clazz.name.to_sym] ||=
-          Adapters::DataAccessor.create(clazz)
+
+      def group_response #:nodoc:
+        @solr_result['grouped']
       end
   
       # 
@@ -211,31 +203,14 @@ module Sunspot
         self
       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
   
       def inspect #:nodoc:
         "<Sunspot::Search:#{query.to_params.inspect}>"
       end
+
+      def add_field_group(field, options = {}) #:nodoc:
+        add_group(field.name, FieldGroup.new(field, self, options))
+      end
   
       def add_field_facet(field, options = {}) #:nodoc:
         name = (options[:name] || field.name)
@@ -250,6 +225,12 @@ module Sunspot
         name = (options[:name] || field.name)
         add_facet(name, DateFacet.new(field, self, options))
       end
+
+      def highlights_for(doc) #:nodoc:
+        if @solr_result['highlighting']
+          @solr_result['highlighting'][doc['id']]
+        end
+      end
   
       private
   
@@ -265,14 +246,16 @@ module Sunspot
         @solr_response ||= @solr_result['response'] || {}
       end
   
-      def highlights_for(doc)
-        if @solr_result['highlighting']
-          @solr_result['highlighting'][doc['id']]
-        end
+      def solr_response_header
+        @solr_response_header ||= @solr_result['responseHeader'] || {}
+      end
+
+      def solr_docs
+        solr_response['docs']
       end
   
       def verified_hits
-        @verified_hits ||= paginate_collection(hits.select { |hit| hit.instance })
+        @verified_hits ||= paginate_collection(super)
       end
   
       def paginate_collection(collection)
@@ -283,6 +266,11 @@ module Sunspot
         @facets << facet
         @facets_by_name[name.to_sym] = facet
       end
+
+      def add_group(name, group)
+        @groups << group
+        @groups_by_name[name.to_sym] = group
+      end
       
       # Clear out all the cached ivars so the search can be called again.
       def reset

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,35 @@
+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 highlights_for(doc)
+        @search.highlights_for(doc)
+      end
+
+      def solr_docs
+        @doclist['docs']
+      end
+    end
+  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