sunspot 2.0.0 → 2.5.0

data/lib/sunspot/query/field_json_facet.rb

@@ -0,0 +1,19 @@
+module Sunspot
+  module Query
+    class FieldJsonFacet < AbstractJsonFieldFacet
+
+      def initialize(field, options, setup)
+        super
+      end
+
+      def field_name_with_local_params
+        {
+          @field.name => {
+            type: 'terms',
+            field: @field.indexed_name,
+          }.merge!(init_params)
+        }
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_list.rb

@@ -0,0 +1,15 @@
+module Sunspot
+  module Query #:nodoc:
+
+    # This DSL represents only fields that would come out of the results of the search type.
+    class FieldList
+      def initialize(list)
+        @list = list
+      end
+
+      def to_params
+        { :fl => @list }
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_stats.rb

@@ -0,0 +1,61 @@
+module Sunspot
+  module Query
+    class FieldStats
+      def initialize(field, options)
+        @field, @options = field, options
+        @facets = []
+      end
+
+      def add_facet field
+        @facets << field
+      end
+
+      def add_json_facet(json_facet)
+        @json_facet = json_facet
+      end
+
+      def to_params
+        params = {}
+        if !@json_facet.nil?
+          params['json.facet'] = recursive_add_stats(@json_facet.get_params).to_json
+        else
+          params.merge!(:stats => true, :"stats.field" => [@field.indexed_name])
+          params[facet_key] = @facets.map(&:indexed_name) unless @facets.empty?
+        end
+        params
+      end
+
+      STATS_FUNCTIONS = [:min, :max, :sum, :avg, :sumsq]
+
+      def recursive_add_stats(query)
+        query.keys.each do |k|
+          if !query[k][:facet].nil?
+            query[k][:facet] = recursive_add_stats(query[k][:facet])
+          end
+          query[k][:facet] ||= {}
+          query[k][:sort] = { @options[:sort] => @options[:sort_type]||'desc' } unless @options[:sort].nil?
+          query[k][:facet].merge!(json_stats_params)
+        end
+        query
+      end
+
+      def json_stats_params
+        params = {}
+        STATS_FUNCTIONS.each { |s| params[s] = "#{s.to_s}(#{@field.indexed_name})" }
+        unless @options[:stats].nil?
+          to_remove = STATS_FUNCTIONS - @options[:stats]
+          to_remove.map { |s| params.delete(s)}
+        end
+        params
+      end
+
+      def facet_key
+        qualified_param 'facet'
+      end
+
+      def qualified_param name
+        :"f.#{@field.indexed_name}.stats.#{name}"
+      end
+    end
+  end
+end

data/lib/sunspot/query/function_query.rb

@@ -4,7 +4,6 @@ module Sunspot
     # Abstract class for function queries.
     #
     class FunctionQuery 
-      include RSolr::Char
 
       def ^(y)
         @boost_amount = y
@@ -34,7 +33,7 @@ module Sunspot
       end
 
       def to_s
-        "#{escape(@field.indexed_name)}" << (@boost_amount ? "^#{@boost_amount}" : "")
+        "#{Util.escape(@field.indexed_name)}" << (@boost_amount ? "^#{@boost_amount}" : "")
       end
     end
 

data/lib/sunspot/query/geo.rb

@@ -21,7 +21,7 @@ module Sunspot
       end
 
       def to_subquery
-        "(#{to_boolean_query})"
+        { :q => "(#{to_boolean_query})" }
       end
 
       private

data/lib/sunspot/query/geofilt.rb

@@ -1,15 +1,20 @@
 module Sunspot
   module Query
     class Geofilt
+      include Filter
+      attr_reader :field
+
       def initialize(field, lat, lon, radius, options = {})
         @field, @lat, @lon, @radius, @options = field, lat, lon, radius, options
       end
 
-      def to_params
+      def to_boolean_phrase
         func = @options[:bbox] ? "bbox" : "geofilt"
+        "{!#{func} sfield=#{@field.indexed_name} pt=#{@lat},#{@lon} d=#{@radius}}"
+      end
 
-        filter = "{!#{func} sfield=#{@field.indexed_name} pt=#{@lat},#{@lon} d=#{@radius}}"
-        {:fq => filter}
+      def to_params
+        {:fq => to_filter_query}
       end
     end
   end

data/lib/sunspot/query/group.rb

@@ -0,0 +1,46 @@
+module Sunspot
+  module Query
+    #
+    # A Group groups by the unique values of a given field, or by given queries.
+    #
+    class Group
+      attr_accessor :limit, :truncate, :ngroups
+      attr_reader :fields, :queries
+
+      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
+        @fields << field
+      end
+
+      def add_query(query)
+        @queries << query
+      end
+
+      def add_sort(sort)
+        @sort << sort
+      end
+
+      def to_params
+        params = {
+          :group            => 'true',
+          :"group.ngroups"  => @ngroups.nil? ? 'true' : @ngroups.to_s
+        }
+
+        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
+        params
+      end
+    end
+  end
+end

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/join.rb

@@ -0,0 +1,88 @@
+module Sunspot
+  module Query
+
+    #
+    # Solr full-text queries use Solr's JoinRequestHandler.
+    #
+    class Join < AbstractFulltext
+      attr_writer :minimum_match, :phrase_slop, :query_phrase_slop, :tie
+
+      def initialize(keywords, target, from, to)
+        @keywords = keywords
+        @target = target
+        @from = from
+        @to = to
+
+        @fulltext_fields = {}
+
+        @minimum_match = nil
+      end
+
+      #
+      # The query as Solr parameters
+      #
+      def to_params
+        params = { :q => @keywords }
+        params[:fl] = '* score'
+        params[:qf] = @fulltext_fields.values.map { |field| field.to_boosted_field }.join(' ')
+        params[:defType] = 'join'
+        params[:mm] = @minimum_match if @minimum_match
+
+        params
+      end
+
+      #
+      # Serialize the query as a Solr nested subquery.
+      #
+      def to_subquery
+        params = self.to_params
+        params.delete :defType
+        params.delete :fl
+
+        keywords = escape_quotes(params.delete(:q))
+        options = params.map { |key, value| escape_param(key, value) }.join(' ')
+        q_name = "q#{@target.name}#{self.object_id}"
+
+        {
+          :q     => "_query_:\"{!join from=#{@from} to=#{@to} v=$#{q_name}}\"",
+          q_name => "_query_:\"{!field f=type}#{@target.name}\"+_query_:\"{!edismax #{options}}#{keywords}\""
+        }
+      end
+
+      #
+      # Assign a new boost query and return it.
+      #
+      def create_boost_query(factor)
+      end
+
+      #
+      # Add a boost function
+      #
+      def add_boost_function(function_query)
+      end
+
+      #
+      # Add a fulltext field to be searched, with optional boost.
+      #
+      def add_fulltext_field(field, boost = nil)
+        super if field.is_a?(Sunspot::JoinField) &&
+          field.target == @target && field.from == @from && field.to == @to
+      end
+
+      #
+      # Add a phrase field for extra boost.
+      #
+      def add_phrase_field(field, boost = nil)
+      end
+
+      #
+      # Set highlighting options for the query. If fields is empty, the
+      # Highlighting object won't pass field names at all, which means
+      # the dismax's :qf parameter will be used by Solr.
+      #
+      def add_highlight(fields=[], options={})
+      end
+
+    end
+  end
+end

data/lib/sunspot/query/more_like_this.rb

@@ -50,7 +50,7 @@ module Sunspot
         params[:"mlt.fl"] = @fields.keys.join(",")
         boosted_fields = @fields.values.select { |field| field.boost }
         unless boosted_fields.empty?
-          params[:qf] = boosted_fields.map do |field|
+          params[:"mlt.qf"] = boosted_fields.map do |field|
             field.to_boosted_field
           end.join(' ')
         end

data/lib/sunspot/query/pagination.rb

@@ -6,14 +6,18 @@ module Sunspot
     # reference to it and updates it if pagination is changed.
     #
     class Pagination #:nodoc:
-      attr_reader :page, :per_page, :offset
+      attr_reader :page, :per_page, :offset, :cursor
 
-      def initialize(page = nil, per_page = nil, offset = nil)
-        self.offset, self.page, self.per_page = offset, page, per_page
+      def initialize(page = nil, per_page = nil, offset = nil, cursor = nil)
+        self.offset, self.page, self.per_page, self.cursor = offset, page, per_page, cursor
       end
 
       def to_params
-        { :start => start, :rows => rows }
+        if @cursor
+          { :cursorMark => @cursor, :rows => rows }
+        else
+          { :start => start, :rows => rows }
+        end
       end
 
       def page=(page)
@@ -28,6 +32,10 @@ module Sunspot
         @offset = offset.to_i
       end
 
+      def cursor=(cursor)
+        @cursor = cursor if cursor
+      end
+
       private
 
       def start

data/lib/sunspot/query/range_json_facet.rb

@@ -0,0 +1,28 @@
+module Sunspot
+  module Query
+    class RangeJsonFacet < AbstractJsonFieldFacet
+
+      SECONDS_IN_DAY = 86400
+
+      def initialize(field, options, setup)
+        raise Exception.new("Need to specify a range") if options[:range].nil?
+        @start = options[:range].first
+        @end = options[:range].last
+        @gap = options[:gap] || SECONDS_IN_DAY
+        super
+      end
+
+      def field_name_with_local_params
+        {
+          @field.name => {
+            type: 'range',
+            field: @field.indexed_name,
+            start: @field.to_indexed(@start),
+            end: @field.to_indexed(@end),
+            gap: @gap
+          }.merge!(init_params)
+        }
+      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
 
       # 
@@ -38,7 +49,6 @@ module Sunspot
       #
       class Base #:nodoc:
         include Filter
-        include RSolr::Char
 
         RESERVED_WORDS = Set['AND', 'OR', 'NOT']
 
@@ -68,11 +78,14 @@ module Sunspot
         # on whether this restriction is negated.
         #
         def to_boolean_phrase
+          phrase = []
+          phrase << @field.local_params if @field.respond_to? :local_params
           unless negated?
-            to_positive_boolean_phrase
+            phrase << to_positive_boolean_phrase
           else
-            to_negated_boolean_phrase
+            phrase << to_negated_boolean_phrase
           end
+          phrase.join
         end
 
         # 
@@ -89,7 +102,7 @@ module Sunspot
         # String:: Boolean phrase for restriction in the positive
         #
         def to_positive_boolean_phrase
-          "#{escape(@field.indexed_name)}:#{to_solr_conditional}"
+          "#{Util.escape(@field.indexed_name)}:#{to_solr_conditional}"
         end
 
         # 
@@ -122,7 +135,7 @@ module Sunspot
 
         protected
 
-        # 
+        #
         # Return escaped Solr API representation of given value
         #
         # ==== Parameters
@@ -135,7 +148,7 @@ module Sunspot
         # String:: Solr API representation of given value
         #
         def solr_value(value = @value)
-          solr_value = escape(@field.to_indexed(value))
+          solr_value = Util.escape(@field.to_indexed(value))
           if RESERVED_WORDS.include?(solr_value)
             %Q("#{solr_value}")
           else
@@ -145,9 +158,13 @@ module Sunspot
       end
 
       class InRadius < Base
-        def initialize(negated, field, lat, lon, radius)
-          @lat, @lon, @radius = lat, lon, radius
-          super negated, field, [lat, lon, radius]
+        def initialize(negated, field, *value)
+          @lat, @lon, @radius = value
+          super negated, field, value
+        end
+
+        def negate
+          self.class.new(!@negated, @field, *@value)
         end
 
         private
@@ -156,6 +173,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.
@@ -165,7 +193,7 @@ module Sunspot
           unless @value.nil?
             super
           else
-            "#{escape(@field.indexed_name)}:[* TO *]"
+            "#{Util.escape(@field.indexed_name)}:[* TO *]"
           end
         end
 
@@ -273,10 +301,23 @@ module Sunspot
       # Results must have field with value included in given collection
       #
       class AnyOf < Base
+
+        def negated?
+          if @value.empty?
+            false
+          else
+            super
+          end
+        end
+
         private
 
         def to_solr_conditional
-          "(#{@value.map { |v| solr_value v } * ' OR '})"
+          if @value.empty?
+            "[* TO *]"
+          else
+            "(#{@value.map { |v| solr_value v } * ' OR '})"
+          end
         end
       end
 
@@ -285,10 +326,22 @@ module Sunspot
       # collection (only makes sense for fields with multiple values)
       #
       class AllOf < Base
+        def negated?
+          if @value.empty?
+            false
+          else
+            super
+          end
+        end
+        
         private
 
         def to_solr_conditional
-          "(#{@value.map { |v| solr_value v } * ' AND '})"
+          if @value.empty?
+            "[* TO *]"
+          else
+            "(#{@value.map { |v| solr_value v } * ' AND '})"
+          end
         end
       end
 
@@ -303,6 +356,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