sunspot 2.0.0 → 2.5.0

data/lib/sunspot/query/sort.rb

@@ -114,6 +114,47 @@ module Sunspot
           "geodist(#{@field.indexed_name.to_sym},#{@lat},#{@lon}) #{direction_for_solr}"
         end
       end
+
+      class SolrIdSort < Abstract
+        def to_param
+          "id #{direction_for_solr}"
+        end
+      end
+
+      #
+      # A FunctionSort sorts by solr function.
+      # FunctionComp recursively parses arguments for nesting
+      #
+      class FunctionSort < Abstract
+        attr_reader :comp
+        def initialize(setup,args)
+          @direction = args.pop
+          @comp = FunctionComp.new(setup,args)
+        end
+        def to_param
+          "#{comp.to_s} #{direction_for_solr}"
+        end
+      end
+      class FunctionComp
+        attr_accessor :function,:fields
+        def initialize(setup,args)
+          @function=args.shift
+          @fields = []
+          args.each do |argument|
+            case argument.class.name
+            when "Array"
+              @fields<< FunctionComp.new(setup,argument)
+            when "Symbol"
+              @fields<< setup.field(argument).indexed_name
+            else
+              @fields<< argument
+            end
+          end
+        end
+        def to_s
+          "#{function}(#{fields.map(&:to_s).join(",")})"
+        end
+      end
     end
   end
 end

data/lib/sunspot/query/sort_composite.rb

@@ -18,6 +18,13 @@ module Sunspot
         @sorts << sort
       end
 
+      #
+      # Check sort presence
+      #
+      def include?(sort)
+        @sorts.any? { |s| s.to_param.include?(sort) }
+      end
+
       # 
       # Combine the sorts into a single param by joining them
       #

data/lib/sunspot/query/spellcheck.rb

@@ -0,0 +1,19 @@
+module Sunspot
+  module Query
+    class Spellcheck < Connective::Conjunction
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def to_params
+        options = {}
+        @options.each do |key, val|
+          options["spellcheck." + Sunspot::Util.method_case(key.to_s)] = val
+        end
+        { :spellcheck => true }.merge(options)
+      end
+    end
+  end
+end

data/lib/sunspot/query/standard_query.rb

@@ -5,11 +5,33 @@ module Sunspot
 
       def initialize(types)
         super
-        @components << @fulltext = CompositeFulltext.new
+        @components << @fulltext = Conjunction.new
       end
 
       def add_fulltext(keywords)
-        @fulltext.add(keywords)
+        @fulltext.add_fulltext(keywords)
+      end
+
+      def add_join(keywords, target, from, to)
+        @fulltext.add_join(keywords, target, from, to)
+      end
+
+      def disjunction
+        parent_fulltext = @fulltext
+        @fulltext = @fulltext.add_disjunction
+
+        yield
+      ensure
+        @fulltext = parent_fulltext
+      end
+
+      def conjunction
+        parent_fulltext = @fulltext
+        @fulltext = @fulltext.add_conjunction
+
+        yield
+      ensure
+        @fulltext = parent_fulltext
       end
     end
   end

data/lib/sunspot/query/text_field_boost.rb

@@ -8,9 +8,7 @@ module Sunspot
       end
 
       def to_boosted_field
-        boosted_field = @field.indexed_name
-        boosted_field.concat("^#{@boost}") if @boost
-        boosted_field
+        @boost ? "#{@field.indexed_name}^#{@boost}" : @field.indexed_name
       end
     end
   end

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')
 
     ]
 
@@ -87,8 +88,16 @@ module Sunspot
     # Return an XML representation of this schema using the ERB template
     #
     def to_xml
-      template = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'schema.xml.erb')
-      ERB.new(File.read(template), nil, '-').result(binding)
+      template_path = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'schema.xml.erb')
+      template_text = File.read(template_path)
+
+      erb = if RUBY_VERSION >= '2.6'
+        ERB.new(template_text, trim_mode: '-')
+      else
+        ERB.new(template_text, nil, '-')
+      end
+
+      erb.result(binding)
     end
 
     private

data/lib/sunspot/search.rb

@@ -1,5 +1,7 @@
-%w(abstract_search standard_search more_like_this_search query_facet field_facet
-   date_facet range_facet facet_row hit highlight field_group group hit_enumerable).each do |file|
+%w(abstract_search standard_search more_like_this_search query_facet
+   field_facet field_json_facet date_facet range_facet json_facet_stats
+   facet_row json_facet_row hit highlight field_group group hit_enumerable
+   stats_row stats_json_row field_stats stats_facet query_group).each do |file|
   require File.join(File.dirname(__FILE__), 'search', file)
 end
 

data/lib/sunspot/search/abstract_search.rb

@@ -1,17 +1,18 @@
 require 'sunspot/search/paginated_collection'
+require 'sunspot/search/cursor_paginated_collection'
 require 'sunspot/search/hit_enumerable'
 
 module Sunspot
   module Search #:nodoc:
-    
-    # 
+
+    #
     # This class encapsulates the results of a Solr search. It provides access
     # to search results, total result count, facets, and pagination information.
     # Instances of Search are returned by the Sunspot.search and
     # Sunspot.new_search methods.
     #
     class AbstractSearch
-      # 
+      #
       # Retrieve all facet objects defined for this search, in order they were
       # defined. To retrieve an individual facet by name, use #facet()
       #
@@ -20,7 +21,7 @@ module Sunspot
       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)
@@ -30,8 +31,11 @@ module Sunspot
 
         @groups_by_name = {}
         @groups = []
+
+        @stats_by_name = {}
+        @stats = []
       end
-  
+
       #
       # Execute the search on the Solr instance and store the results. If you
       # use Sunspot#search() to construct your searches, there is no need to call
@@ -49,8 +53,8 @@ module Sunspot
       def execute! #:nodoc: deprecated
         execute
       end
-  
-      # 
+
+      #
       # Get the collection of results as instantiated objects. If WillPaginate is
       # available, the results will be a WillPaginate::Collection instance; if
       # not, it will be a vanilla Array.
@@ -65,8 +69,8 @@ module Sunspot
       def results
         @results ||= paginate_collection(verified_hits.map { |hit| hit.instance })
       end
-  
-      # 
+
+      #
       # Access raw Solr result information. Returns a collection of Hit objects
       # that contain the class name, primary key, keyword relevance score (if
       # applicable), and any stored fields.
@@ -92,7 +96,7 @@ module Sunspot
       end
       alias_method :raw_results, :hits
 
-      # 
+      #
       # The total number of documents matching the query parameters
       #
       # ==== Returns
@@ -102,8 +106,8 @@ module Sunspot
       def total
         @total ||= solr_response['numFound'] || 0
       end
-  
-      # 
+
+      #
       # The time elapsed to generate the Solr response
       #
       # ==== Returns
@@ -113,8 +117,8 @@ module Sunspot
       def query_time
         @query_time ||= solr_response_header['QTime']
       end
-  
-      # 
+
+      #
       # Get the facet object for the given name. `name` can either be the name
       # given to a query facet, or the field name of a field facet. Returns a
       # Sunspot::Facet object.
@@ -156,11 +160,19 @@ module Sunspot
       #
       def facet(name, dynamic_name = nil)
         if name
-          if dynamic_name
-            @facets_by_name[:"#{name}:#{dynamic_name}"]
-          else
-            @facets_by_name[name.to_sym]
-          end
+          facet_name = if dynamic_name
+                         separator = @setup.dynamic_field_factory(name).separator
+                         [name, dynamic_name].join(separator)
+                       else
+                         name
+                       end.to_sym
+          @facets_by_name[facet_name]
+        end
+      end
+
+      def stats(name)
+        if name
+          @stats_by_name[name.to_sym]
         end
       end
 
@@ -169,23 +181,35 @@ module Sunspot
           @groups_by_name[name.to_sym]
         end
       end
-  
-      # 
+
+      def json_facet_stats(name, options = {})
+        JsonFacetStats.new(name, self, options)
+      end
+
+      #
       # Deprecated in favor of optional second argument to #facet
       #
       def dynamic_facet(base_name, dynamic_name) #:nodoc:
         facet(base_name, dynamic_name)
       end
-  
+
       def facet_response #:nodoc:
         @solr_result['facet_counts']
       end
 
+      def json_facet_response #:nodoc:
+        @solr_result['facets']
+      end
+
+      def stats_response #:nodoc:
+        @solr_result['stats']['stats_fields']
+      end
+
       def group_response #:nodoc:
         @solr_result['grouped']
       end
-  
-      # 
+
+      #
       # Build this search using a DSL block. This method can be called more than
       # once on an unexecuted search (e.g., Sunspot.new_search) in order to build
       # a search incrementally.
@@ -202,25 +226,29 @@ module Sunspot
         Util.instance_eval_or_call(dsl, &block)
         self
       end
-  
-  
+
+
       def inspect #:nodoc:
         "<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:
         name = (options[:name] || field.name)
         add_facet(name, FieldFacet.new(field, self, options))
       end
-  
+
       def add_query_facet(name, options) #:nodoc:
         add_facet(name, QueryFacet.new(name, self, options))
       end
-  
+
       def add_date_facet(field, options) #:nodoc:
         name = (options[:name] || field.name)
         add_facet(name, DateFacet.new(field, self, options))
@@ -231,26 +259,35 @@ module Sunspot
         add_facet(name, RangeFacet.new(field, self, options))
       end
 
+      def add_field_stats(field) #:nodoc:
+        add_stats(field.name, FieldStats.new(field, self))
+      end
+
+      def add_json_facet(field, options = {})
+        name = (options[:name] || field.name)
+        add_facet(name, FieldJsonFacet.new(field, self, options))
+      end
+
       def highlights_for(doc) #:nodoc:
         if @solr_result['highlighting']
           @solr_result['highlighting'][doc['id']]
         end
       end
-  
+
       private
-  
+
       def dsl
-        raise NotImplementedError 
+        raise NotImplementedError
       end
-  
+
       def execute_request(params)
         raise NotImplementedError
       end
-  
+
       def solr_response
         @solr_response ||= @solr_result['response'] || {}
       end
-  
+
       def solr_response_header
         @solr_response_header ||= @solr_result['responseHeader'] || {}
       end
@@ -258,25 +295,38 @@ module Sunspot
       def solr_docs
         solr_response['docs']
       end
-  
+
+      def next_cursor
+        @solr_result['nextCursorMark'] if @query.cursor
+      end
+
       def verified_hits
         @verified_hits ||= paginate_collection(super)
       end
-  
+
       def paginate_collection(collection)
-        PaginatedCollection.new(collection, @query.page, @query.per_page, total)
+        if @query.cursor
+          CursorPaginatedCollection.new(collection, @query.per_page, total, @query.cursor, next_cursor)
+        else
+          PaginatedCollection.new(collection, @query.page, @query.per_page, total)
+        end
       end
-  
+
       def add_facet(name, facet)
         @facets << facet
         @facets_by_name[name.to_sym] = facet
       end
 
-      def add_group(name, group)
+      def add_stats(name, stats)
+        @stats << stats
+        @stats_by_name[name.to_sym] = stats
+      end
+
+      def add_subgroup(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
         @results = @hits = @verified_hits = @total = @solr_response = @doc_ids = nil