sunspot 2.2.0 → 2.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a3b915b7cc088b4c26ba0eb4ae3e541666da526
+  data.tar.gz: a3021876e0d940137daf4527c0d3ac354f93119c
+SHA512:
+  metadata.gz: 62193e81b7834636ad0b2a03110e0054778700fe93a7cd6d6f5a52366708703bf3ce3a0ef24cf83d78a3d3532e79c274d893019aab1e26c289932e5b501bf005
+  data.tar.gz: 3a69aa3883a08bdab4c31ece01218cc3ac2a5bde250704448b9ca5e8dda070a1c7aaf401f7658621e2616f15596a84acc34319173dab91cb71a25b56a199db09

data/lib/sunspot/dsl/field_query.rb

@@ -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
 
       #

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,108 @@
+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
+
+      # 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/search.rb

@@ -19,7 +19,7 @@ module Sunspot
       # ==== Example
       #
       #   Sunspot.search Post do
-      #     data_acccessor_for(Post).includes = [:blog, :comments]
+      #     data_accessor_for(Post).include = [:blog, :comments]
       #   end
       #
       def data_accessor_for(clazz)

data/lib/sunspot/dsl.rb

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

data/lib/sunspot/field_factory.rb

@@ -22,6 +22,23 @@ module Sunspot
             DataExtractor::AttributeExtractor.new(options.delete(:using) || name)
           end
       end
+
+      #
+      # Extract the encapsulated field's data from the given model and add it
+      # into the Solr document for indexing. (noop here for joins)
+      #
+      def populate_document(document, model, options = {}) #:nodoc:
+      end
+
+      protected
+
+      def extract_value(model, options = {})
+        if options.has_key?(:value)
+          options.delete(:value)
+        else
+          @data_extractor.value_for(model)
+        end
+      end
     end
 
     # 
@@ -54,15 +71,16 @@ module Sunspot
       # Extract the encapsulated field's data from the given model and add it
       # into the Solr document for indexing.
       #
-      def populate_document(document, model) #:nodoc:
-        unless (value = @data_extractor.value_for(model)).nil?
+      def populate_document(document, model, options = {}) #:nodoc:
+        value = extract_value(model, options)
+        unless value.nil?
           Util.Array(@field.to_indexed(value)).each do |scalar_value|
-            options = {}
-            options[:boost] = @field.boost if @field.boost
+            field_options = {}
+            field_options[:boost] = @field.boost if @field.boost
             document.add_field(
               @field.indexed_name.to_sym,
               scalar_value,
-              options
+              field_options.merge(options)
             )
           end
         end
@@ -92,14 +110,7 @@ module Sunspot
         @field
       end
 
-      # 
-      # Extract the encapsulated field's data from the given model and add it
-      # into the Solr document for indexing. (noop here for joins)
       #
-      def populate_document(document, model) #:nodoc:
-      end
-
-      # 
       # A unique signature identifying this field by name and type.
       #
       def signature
@@ -135,14 +146,16 @@ module Sunspot
       # Generate dynamic fields based on hash returned by data accessor and
       # add the field data to the document.
       #
-      def populate_document(document, model)
-        if values = @data_extractor.value_for(model)
+      def populate_document(document, model, options = {})
+        values = extract_value(model, options)
+        if values
           values.each_pair do |dynamic_name, value|
             field_instance = build(dynamic_name)
             Util.Array(field_instance.to_indexed(value)).each do |scalar_value|
               document.add_field(
                 field_instance.indexed_name.to_sym,
-                scalar_value
+                scalar_value,
+                options
               )
             end
           end

data/lib/sunspot/indexer.rb

@@ -22,12 +22,23 @@ module Sunspot
     # model<Object>:: the model to index
     #
     def add(model)
-      documents = Util.Array(model).map { |m| prepare(m) }
-      if batcher.batching?
-        batcher.concat(documents)
-      else
-        add_documents(documents)
-      end
+      documents = Util.Array(model).map { |m| prepare_full_update(m) }
+      add_batch_documents(documents)
+    end
+
+    #
+    # Construct a representation of the given class instances for atomic properties update
+    # and send it to the connection for indexing
+    #
+    # ==== Parameters
+    #
+    # clazz<Class>:: the class of the models to be updated
+    # updates<Hash>:: hash of updates where keys are model ids
+    #                 and values are hash with property name/values to be updated
+    #
+    def add_atomic_update(clazz, updates={})
+      documents = updates.map { |id, m| prepare_atomic_update(clazz, id, m) }
+      add_batch_documents(documents)
     end
 
     # 
@@ -49,7 +60,7 @@ module Sunspot
       )
     end
 
-    # 
+    #
     # Delete all documents of the class indexed by this indexer from Solr.
     #
     def remove_all(clazz = nil)
@@ -90,9 +101,9 @@ module Sunspot
     # 
     # Convert documents into hash of indexed properties
     #
-    def prepare(model)
-      document = document_for(model)
-      setup = setup_for(model)
+    def prepare_full_update(model)
+      document = document_for(model.class, model.id)
+      setup = setup_for_object(model)
       if boost = setup.document_boost_for(model)
         document.attrs[:boost] = boost
       end
@@ -102,20 +113,40 @@ module Sunspot
       document
     end
 
+    def prepare_atomic_update(clazz, id, updates = {})
+      document = document_for(clazz, id)
+      setup_for_class(clazz).all_field_factories.each do |field_factory|
+        if updates.has_key?(field_factory.name)
+          field_factory.populate_document(document, nil, value: updates[field_factory.name], update: :set)
+        end
+      end
+      document
+    end
+
     def add_documents(documents)
       @connection.add(documents)
     end
 
+    def add_batch_documents(documents)
+      if batcher.batching?
+        batcher.concat(documents)
+      else
+        add_documents(documents)
+      end
+    end
+
     # 
     # All indexed documents index and store the +id+ and +type+ fields.
     # This method constructs the document hash containing those key-value
     # pairs.
     #
-    def document_for(model)
-      RSolr::Xml::Document.new(
-        :id => Adapters::InstanceAdapter.adapt(model).index_id,
-        :type => Util.superclasses_for(model.class).map { |clazz| clazz.name }
-      )
+    def document_for(clazz, id)
+      if Adapters::InstanceAdapter.for(clazz)
+        RSolr::Xml::Document.new(
+            id: Adapters::InstanceAdapter.index_id_for(clazz.name, id),
+            type: Util.superclasses_for(clazz).map(&:name)
+        )
+      end
     end
 
     # 
@@ -129,8 +160,23 @@ module Sunspot
     #
     # Sunspot::Setup:: The setup for the object's class
     #
-    def setup_for(object)
-      Setup.for(object.class) || raise(NoSetupError, "Sunspot is not configured for #{object.class.inspect}")
+    def setup_for_object(object)
+      setup_for_class(object.class)
+    end
+
+    #
+    # Get the Setup object for the given class.
+    #
+    # ==== Parameters
+    #
+    # clazz<Class>:: The class whose setup is to be retrieved
+    #
+    # ==== Returns
+    #
+    # Sunspot::Setup:: The setup for the class
+    #
+    def setup_for_class(clazz)
+      Setup.for(clazz) || raise(NoSetupError, "Sunspot is not configured for #{clazz.inspect}")
     end
   end
 end

data/lib/sunspot/query/abstract_fulltext.rb

@@ -18,8 +18,15 @@ module Sunspot
       #
       # Add a boost function
       #
-      def add_boost_function(function_query)
-        @boost_functions << function_query
+      def add_additive_boost_function(function_query)
+        @additive_boost_functions << function_query
+      end
+
+      #
+      # Add a multiplicative boost function
+      #
+      def add_multiplicative_boost_function(function_query)
+        @multiplicative_boost_functions << function_query
       end
 
       #

data/lib/sunspot/query/dismax.rb

@@ -13,7 +13,8 @@ module Sunspot
         @keywords = keywords
         @fulltext_fields = {}
         @boost_queries = []
-        @boost_functions = []
+        @additive_boost_functions = []
+        @multiplicative_boost_functions = []
         @highlights = []
 
         @minimum_match = nil
@@ -46,9 +47,15 @@ module Sunspot
           end
         end
 
-        unless @boost_functions.empty?
-          params[:bf] = @boost_functions.map do |boost_function|
-            boost_function.to_s
+        unless @additive_boost_functions.empty?
+          params[:bf] = @additive_boost_functions.map do |additive_boost_function|
+            additive_boost_function.to_s
+          end
+        end
+
+        unless @multiplicative_boost_functions.empty?
+          params[:boost] = @multiplicative_boost_functions.map do |multiplicative_boost_function|
+            multiplicative_boost_function.to_s
           end
         end
 

data/lib/sunspot/query/{field_group.rb → group.rb}

@@ -1,18 +1,27 @@
 module Sunspot
   module Query
     #
-    # A FieldGroup groups by the unique values of a given field.
+    # A Group groups by the unique values of a given field, or by given queries.
     #
-    class FieldGroup
+    class Group
       attr_accessor :limit, :truncate
+      attr_reader :fields, :queries
 
-      def initialize(field)
+      def initialize
+        @sort = SortComposite.new
+        @fields = []
+        @queries = []
+      end
+
+      def add_field(field)
         if field.multiple?
           raise(ArgumentError, "#{field.name} cannot be used for grouping because it is a multiple-value field")
         end
-        @field = field
+        @fields << field
+      end
 
-        @sort = SortComposite.new
+      def add_query(query)
+        @queries << query
       end
 
       def add_sort(sort)
@@ -23,10 +32,11 @@ module Sunspot
         params = {
           :group            => "true",
           :"group.ngroups"  => "true",
-          :"group.field"    => @field.indexed_name
         }
 
         params.merge!(@sort.to_params("group."))
+        params[:"group.field"] = @fields.map(&:indexed_name) if @fields.any?
+        params[:"group.query"] = @queries.map(&:to_boolean_phrase) if @queries.any?
         params[:"group.limit"] = @limit if @limit
         params[:"group.truncate"] = @truncate if @truncate
 

data/lib/sunspot/query/group_query.rb

@@ -0,0 +1,17 @@
+module Sunspot
+  module Query
+    #
+    # Representation of a GroupQuery, which allows the searcher to specify a
+    # query to group matching documents. This is essentially a conjunction,
+    # with an extra instance variable containing the label for the group.
+    #
+    class GroupQuery < Connective::Conjunction #:nodoc:
+      attr_reader :label
+
+      def initialize(label, negated = false)
+        super(negated)
+        @label = label
+      end
+    end
+  end
+end

data/lib/sunspot/query/restriction.rb

@@ -11,7 +11,7 @@ module Sunspot
         # Array:: Collection of restriction class names
         #
         def names
-          constants - %w(Base) #XXX this seems ugly
+          constants - abstract_constants
         end
 
         # 
@@ -22,6 +22,17 @@ module Sunspot
           @types ||= {}
           @types[restriction_name.to_sym] ||= const_get(Sunspot::Util.camel_case(restriction_name.to_s))
         end
+
+        private
+
+        #
+        # Return the names of all abstract restriction classes that should not
+        # be made available to the DSL. Considers abstract classes are any class
+        # ending with '::Base' or containing a namespace prefixed with 'Abstract'
+        #
+        def abstract_constants
+          constants.grep(/(^|::)(Base$|Abstract)/)
+        end
       end
 
       # 
@@ -330,6 +341,39 @@ module Sunspot
           "#{solr_value(@value)}*"
         end
       end
+
+      class AbstractRange < Between
+        private
+
+        def operation
+          @operation || self.class.name.split('::').last
+        end
+
+        def solr_value(value = @value)
+          @field.to_indexed(value)
+        end
+
+        def to_positive_boolean_phrase
+          "_query_:\"{!field f=#{@field.indexed_name} op=#{operation}}#{solr_value}\""
+        end
+      end
+
+      class Containing < AbstractRange
+        def initialize(negated, field, value)
+          @operation = 'Contains'
+          super
+        end
+      end
+
+      class Intersecting < AbstractRange
+        def initialize(negated, field, value)
+          @operation = 'Intersects'
+          super
+        end
+      end
+
+      class Within < AbstractRange
+      end
     end
   end
 end

data/lib/sunspot/query.rb

@@ -2,7 +2,7 @@
    field_facet highlighting pagination restriction common_query spellcheck
    standard_query more_like_this more_like_this_query geo geofilt bbox query_facet
    scope sort sort_composite text_field_boost function_query field_stats
-   composite_fulltext field_group).each do |file|
+   composite_fulltext group group_query).each do |file|
   require(File.join(File.dirname(__FILE__), 'query', file))
 end
 module Sunspot

data/lib/sunspot/schema.rb

@@ -23,7 +23,8 @@ module Sunspot
       FieldType.new('slong', 'SortableLong', 'l'),
       FieldType.new('tint', 'TrieInteger', 'it'),
       FieldType.new('tfloat', 'TrieFloat', 'ft'),
-      FieldType.new('tdate', 'TrieInt', 'dt')
+      FieldType.new('tdate', 'TrieInt', 'dt'),
+      FieldType.new('daterange', 'DateRange', 'dr')
 
     ]
 

data/lib/sunspot/search/abstract_search.rb

@@ -222,8 +222,12 @@ module Sunspot
         "<Sunspot::Search:#{query.to_params.inspect}>"
       end
 
-      def add_field_group(field) #:nodoc:
-        add_group(field.name, FieldGroup.new(field, self))
+      def add_group(group) #:nodoc:
+        group.fields.each do |field|
+          add_subgroup(field.name, FieldGroup.new(field, self))
+        end
+
+        add_subgroup(:queries, QueryGroup.new(group.queries, self)) if group.queries.any?
       end
 
       def add_field_facet(field, options = {}) #:nodoc:
@@ -303,7 +307,7 @@ module Sunspot
         @stats_by_name[name.to_sym] = stats
       end
 
-      def add_group(name, group)
+      def add_subgroup(name, group)
         @groups << group
         @groups_by_name[name.to_sym] = group
       end