sunspot 2.0.0 → 2.5.0

data/lib/sunspot/dsl/field_query.rb

@@ -1,6 +1,6 @@
 module Sunspot
   module DSL
-    # 
+    #
     # Provides an API for areas of the query DSL that operate on specific
     # fields. This functionality is provided by the query DSL and the dynamic
     # query DSL.
@@ -45,14 +45,14 @@ module Sunspot
       #   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>
       #
       def order_by_random
@@ -68,20 +68,22 @@ module Sunspot
       #
       # ==== Parameters
       #
-      # field_name<Symbol>:: the field to use for grouping
+      # field_names...<Symbol>:: the fields to use for grouping
       def group(*field_names, &block)
+        group = Sunspot::Query::Group.new()
+
         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)
+          group.add_field(field)
+        end
 
-          if block
-            Sunspot::Util.instance_eval_or_call(
-              FieldGroup.new(@setup, group),
-              &block
-            )
-          end
+        if block
+          dsl = Group.new(@setup, group)
+          Sunspot::Util.instance_eval_or_call(dsl, &block)
         end
+
+        @query.add_group(group)
+        @search.add_group(group)
       end
 
       #
@@ -109,7 +111,7 @@ module Sunspot
       #     with(:blog_id, 1)
       #     facet(:category_id)
       #   end
-      #   
+      #
       # The facet specified above will have a row for each category_id that is
       # present in a document which also has a blog_id of 1.
       #
@@ -125,12 +127,12 @@ module Sunspot
       #     category_filter = with(:category_id, 2)
       #     facet(:category_id, :exclude => category_filter)
       #   end
-      # 
+      #
       # Although the results of the above search will be restricted to those
       # with a category_id of 2, the category_id facet will operate as if a
       # category had not been selected, allowing the user to select additional
       # categories (which will presumably be ORed together).
-      # 
+      #
       # It possible to exclude multiple filters by passing an array:
       #
       #   Sunspot.search(Post) do
@@ -141,7 +143,7 @@ module Sunspot
       #           :exclude => [category_filter, author_filter].compact)
       #   end
       #
-      # You should consider using +.compact+ to ensure that the array does not 
+      # You should consider using +.compact+ to ensure that the array does not
       # contain any nil values.
       #
       # <strong>As far as I can tell, Solr only supports multi-select with
@@ -331,6 +333,33 @@ module Sunspot
         end
       end
 
+      def json_facet(*field_names)
+        options = Sunspot::Util.extract_options_from(field_names)
+
+        field_names.each do |field_name|
+          field = @setup.field(field_name)
+          facet = Sunspot::Util.parse_json_facet(field_name, options, @setup)
+          @search.add_json_facet(field, options)
+          @query.add_query_facet(facet)
+        end
+      end
+
+      def stats(*field_names, &block)
+        options = Sunspot::Util.extract_options_from(field_names)
+
+        field_names.each do |field_name|
+          field = @setup.field(field_name)
+          query_stats = @query.add_stats(
+            Sunspot::Query::FieldStats.new(field, options)
+          )
+          search_stats = @search.add_field_stats(field)
+
+          Sunspot::Util.instance_eval_or_call(
+            FieldStats.new(query_stats, @setup, search_stats),
+            &block) if block
+        end
+      end
+
       def dynamic(base_name, &block)
         dynamic_field_factory = @setup.dynamic_field_factory(base_name)
         Sunspot::Util.instance_eval_or_call(
@@ -338,6 +367,30 @@ module Sunspot
           &block
         )
       end
+      #
+      # Specify that results should be ordered based on a
+      # FunctionQuery - http://wiki.apache.org/solr/FunctionQuery
+      # Solr 3.1 and up
+      #
+      #  For example, to order by field1 + (field2*field3):
+      #
+      #    order_by_function :sum, :field1, [:product, :field2, :field3], :desc
+      #
+      # ==== Parameters
+      # function_name<Symbol>::
+      #   the function to run
+      # arguments::
+      #   the arguments for this function.
+      #   - Symbol for a field or function name
+      #   - Array for a nested function
+      #   - String for a literal constant
+      # direction<Symbol>::
+      #   :asc or :desc
+      def order_by_function(*args)
+        @query.add_sort(
+          Sunspot::Query::Sort::FunctionSort.new(@setup,args)
+        )
+      end
     end
   end
 end

data/lib/sunspot/dsl/field_stats.rb

@@ -0,0 +1,25 @@
+module Sunspot
+  module DSL
+    class FieldStats #:nodoc:
+      def initialize(query_stats, setup, search_stats) #:nodoc:
+        @query_stats, @setup, @search_stats = query_stats, setup, search_stats
+      end
+
+      def facet *field_names
+        field_names.each do |field_name|
+          field = @setup.field(field_name)
+
+          @query_stats.add_facet(field)
+          @search_stats.add_facet(field)
+        end
+      end
+
+      def json_facet(field_name, options = {})
+        field = @setup.field(field_name)
+        facet = Sunspot::Util.parse_json_facet(field_name, options, @setup)
+        @query_stats.add_json_facet(facet)
+      end
+
+    end
+  end
+end

data/lib/sunspot/dsl/fields.rb

@@ -33,13 +33,10 @@ module Sunspot
       #   DSL::Fulltext#boost_fields method.
       #
       def text(*names, &block)
-        options = names.pop if names.last.is_a?(Hash)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+
         names.each do |name|
-          @setup.add_text_field_factory(
-            name,
-            options || {},
-            &block
-          )
+          @setup.add_text_field_factory(name, options, &block)
         end
       end
 
@@ -58,6 +55,22 @@ module Sunspot
         @setup.add_document_boost(attr_name, &block)
       end
 
+      #
+      # If you use the compositeId router for shards, you can send documents
+      # with a prefix in the document ID which will be used to calculate the
+      # hash Solr uses to determine the shard a document is sent to for indexing.
+      # The prefix can be anything you’d like it to be (it doesn’t have to be
+      # the shard name, for example), but it must be consistent so Solr
+      # behaves consistently.
+      #
+      # ==== Parameters
+      #
+      # attr_name<Symbol,String>:: Attribute name to call or a string constant
+      #
+      def id_prefix(attr_name = nil, &block)
+        @setup.add_id_prefix(attr_name, &block)
+      end
+
       # method_missing is used to provide access to typed fields, because
       # developers should be able to add new Sunspot::Type implementations
       # dynamically and have them recognized inside the Fields DSL. Like #text,
@@ -74,26 +87,33 @@ module Sunspot
       #
       def method_missing(method, *args, &block)
         options = Util.extract_options_from(args)
-        type_const_name = "#{Util.camel_case(method.to_s.sub(/^dynamic_/, ''))}Type"
+        join = method.to_s == 'join'
+        type_string = join ? options.delete(:type).to_s : method.to_s
+        type_const_name = "#{Util.camel_case(type_string.sub(/^dynamic_/, ''))}Type"
         trie = options.delete(:trie)
         type_const_name = "Trie#{type_const_name}" if trie
+
         begin
           type_class = Type.const_get(type_const_name)
-        rescue(NameError)
+        rescue NameError
           if trie
             raise ArgumentError, "Trie fields are only valid for numeric and time types"
           else
             super(method, *args, &block)
           end
         end
+
         type = type_class.instance
         name = args.shift
+
         if method.to_s =~ /^dynamic_/
           if type.accepts_dynamic?
             @setup.add_dynamic_field_factory(name, type, options, &block)
           else
             super(method, *args, &block)
           end
+        elsif join
+          @setup.add_join_field_factory(name, type, options.merge(:clazz => @setup.clazz), &block)
         else
           @setup.add_field_factory(name, type, options, &block)
         end

data/lib/sunspot/dsl/fulltext.rb

@@ -168,8 +168,12 @@ module Sunspot
       # will be boosted by (average_rating + popularity * 10).
       #
       def boost(factor_or_function, &block)
+        additive_boost(factor_or_function, &block)
+      end
+
+      def additive_boost(factor_or_function, &block)
         if factor_or_function.is_a?(Sunspot::Query::FunctionQuery)
-          @query.add_boost_function(factor_or_function)
+          @query.add_additive_boost_function(factor_or_function)
         else
           Sunspot::Util.instance_eval_or_call(
             Scope.new(@query.create_boost_query(factor_or_function), @setup),
@@ -178,6 +182,10 @@ module Sunspot
         end
       end
 
+      def multiplicative_boost(factor_or_function)
+        @query.add_multiplicative_boost_function(factor_or_function)
+      end
+
       #
       # Add boost to certain fields, without restricting which fields are
       # searched.

data/lib/sunspot/dsl/group.rb

@@ -0,0 +1,118 @@
+module Sunspot
+  module DSL
+    class Group
+      def initialize(setup, group)
+        @setup, @group = setup, group
+      end
+
+      # Specify one or more fields for result grouping.
+      #
+      # ==== Parameters
+      #
+      # field_names...<Symbol>:: the fields to use for grouping
+      #
+      def field(*field_names, &block)
+        field_names.each do |field_name|
+          field = @setup.field(field_name)
+          @group.add_field(field)
+        end
+      end
+
+      # Specify a query to group results by.
+      #
+      # ==== Parameters
+      #
+      # label<Object>:: a label for this group; when #value is called on this
+      #   group's results, this label will be returned.
+      #
+      def query(label, &block)
+        group_query = Sunspot::Query::GroupQuery.new(label)
+        Sunspot::Util.instance_eval_or_call(Scope.new(group_query, @setup), &block)
+        @group.add_query(group_query)
+      end
+
+      #
+      # Sets the number of results (documents) to return for each group.
+      # Defaults to 1.
+      #
+      def limit(num)
+        @group.limit = num
+      end
+
+      #
+      # If set, facet counts are based on the most relevant document of
+      # each group matching the query.
+      #
+      # Supported in Solr 3.4 and above.
+      #
+      # ==== Example
+      #
+      #     Sunspot.search(Post) do
+      #       group :title do
+      #         truncate
+      #       end
+      #
+      #       facet :title, :extra => :any
+      #     end
+      #
+      def truncate
+        @group.truncate = true
+      end
+
+      #
+      # The group.ngroups option true return the total number of groups
+      # this is expensive and sometimes you don't need it!
+      # If ngroups is false paginated_collection last_page? and total_pages wont't work.
+      # Defaults to true.
+      #
+      def ngroups(enabled)
+        @group.ngroups = enabled
+      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
+
+      #
+      # Specify that results should be ordered based on a
+      # FunctionQuery - http://wiki.apache.org/solr/FunctionQuery
+      # Solr 3.1 and up
+      #
+      #  For example, to order by field1 + (field2*field3):
+      #
+      #    order_by_function :sum, :field1, [:product, :field2, :field3], :desc
+      #
+      # ==== Parameters
+      # function_name<Symbol>::
+      #   the function to run
+      # arguments::
+      #   the arguments for this function.
+      #   - Symbol for a field or function name
+      #   - Array for a nested function
+      #   - String for a literal constant
+      # direction<Symbol>::
+      #   :asc or :desc
+      def order_by_function(*args)
+        @group.add_sort(
+          Sunspot::Query::Sort::FunctionSort.new(@setup,args)
+        )
+      end
+    end
+  end
+end

data/lib/sunspot/dsl/paginatable.rb

@@ -20,12 +20,15 @@ module Sunspot
       # :offset<Integer,String>::
       #   Applies a shift to paginated records. The default is 0.
       #
+      # :cursor<String>:: Cursor value for cursor-based pagination. The default is nil.
+      #
       def paginate(options = {})
         page = options.delete(:page)
         per_page = options.delete(:per_page)
         offset = options.delete(:offset)
+        cursor = options.delete(:cursor)
         raise ArgumentError, "unknown argument #{options.keys.first.inspect} passed to paginate" unless options.empty?
-        @query.paginate(page, per_page, offset)
+        @query.paginate(page, per_page, offset, cursor)
       end
     end
   end

data/lib/sunspot/dsl/scope.rb

@@ -1,6 +1,6 @@
 module Sunspot
   module DSL #:nodoc:
-    # 
+    #
     # This DSL presents methods for constructing restrictions and other query
     # elements that are specific to fields. As well as being a superclass of
     # Sunspot::DSL::StandardQuery, which presents the main query block, this
@@ -12,7 +12,17 @@ module Sunspot
         @scope, @setup = scope, setup
       end
 
-      # 
+      # Build a restriction to return only fields of the type in the results.
+      def field_list(*args)
+        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
+
+      #
       # Build a positive restriction. This method can take three forms: equality
       # restriction, restriction by another restriction, or identity
       # restriction.
@@ -62,7 +72,7 @@ module Sunspot
       #   Sunspot.search do
       #     with(:category_ids, [1, 5, 9])
       #   end
-      # 
+      #
       # Other restriction types:
       #
       #   Sunspot.search(Post) do
@@ -87,7 +97,7 @@ module Sunspot
         add_restriction(true, *args)
       end
 
-      # 
+      #
       # Create a disjunction, scoping the results to documents that match any
       # of the enclosed restrictions.
       #
@@ -109,7 +119,7 @@ module Sunspot
         disjunction
       end
 
-      # 
+      #
       # Create a conjunction, scoping the results to documents that match all of
       # the enclosed restrictions. When called from the top level of a search
       # block, this has no effect, but can be useful for grouping a conjunction
@@ -138,9 +148,9 @@ module Sunspot
       # The block API is implemented by Sunspot::DSL::FieldQuery, which is a
       # superclass of the Query DSL (thus providing a subset of the API, in
       # particular only methods that refer to particular fields).
-      # 
+      #
       # ==== Parameters
-      # 
+      #
       # base_name<Symbol>:: The base name for the dynamic field definition
       #
       # ==== Example
@@ -160,14 +170,14 @@ module Sunspot
         )
       end
 
-      # 
+      #
       # Apply scope-type restrictions on fulltext fields. In certain situations,
       # it may be desirable to place logical restrictions on text fields.
       # Remember that text fields are tokenized; your mileage may very.
       #
       # The block works exactly like a normal scope, except that the field names
       # refer to text fields instead of attribute fields.
-      # 
+      #
       # === Example
       #
       #   Sunspot.search(Post) do
@@ -208,7 +218,6 @@ module Sunspot
           )
         end
       end
-
     end
   end
 end