sunspot 2.1.1 → 2.2.0

data/lib/sunspot/query/restriction.rb

@@ -38,7 +38,6 @@ module Sunspot
       #
       class Base #:nodoc:
         include Filter
-        include RSolr::Char
 
         RESERVED_WORDS = Set['AND', 'OR', 'NOT']
 
@@ -92,7 +91,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
 
         # 
@@ -138,7 +137,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
@@ -168,7 +167,7 @@ module Sunspot
           unless @value.nil?
             super
           else
-            "#{escape(@field.indexed_name)}:[* TO *]"
+            "#{Util.escape(@field.indexed_name)}:[* TO *]"
           end
         end
 

data/lib/sunspot/query/sort.rb

@@ -115,6 +115,12 @@ module Sunspot
         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

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/search/abstract_search.rb

@@ -1,4 +1,5 @@
 require 'sunspot/search/paginated_collection'
+require 'sunspot/search/cursor_paginated_collection'
 require 'sunspot/search/hit_enumerable'
 
 module Sunspot
@@ -276,12 +277,20 @@ module Sunspot
         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)

data/lib/sunspot/search/cursor_paginated_collection.rb

@@ -0,0 +1,32 @@
+module Sunspot
+  module Search
+
+    class CursorPaginatedCollection < Array
+      attr_reader :per_page, :total_count, :current_cursor, :next_page_cursor
+      alias :total_entries :total_count
+      alias :limit_value :per_page
+
+      def initialize(collection, per_page, total, current_cursor, next_page_cursor)
+        @per_page         = per_page
+        @total_count      = total
+        @current_cursor   = current_cursor
+        @next_page_cursor = next_page_cursor
+
+        replace collection
+      end
+
+      def total_pages
+        (total_count.to_f / per_page).ceil
+      end
+      alias :num_pages :total_pages
+
+      def first_page?
+        current_cursor == '*'
+      end
+
+      def last_page?
+        count < per_page
+      end
+    end
+  end
+end

data/lib/sunspot/search/paginated_collection.rb

@@ -32,6 +32,7 @@ module Sunspot
       def previous_page
         current_page > 1 ? (current_page - 1) : nil
       end
+      alias :prev_page :previous_page
 
       def next_page
         current_page < total_pages ? (current_page + 1) : nil

data/lib/sunspot/search/standard_search.rb

@@ -1,6 +1,6 @@
 module Sunspot
   module Search
-    # 
+    #
     # 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
@@ -10,9 +10,77 @@ module Sunspot
       def request_handler
         super || :select
       end
-  
+
+      # Return the raw spellcheck block from the Solr response
+      def solr_spellcheck
+        @solr_spellcheck ||= @solr_result['spellcheck'] || {}
+      end
+
+      # Reformat the oddly-formatted spellcheck suggestion array into a
+      # more useful hash.
+      #
+      # Original: [term, suggestion, term, suggestion, ..., "correctlySpelled", bool, "collation", str]
+      #           "collation" is only included if spellcheck.collation was set to true
+      # Returns: { term => suggestion, term => suggestion }
+      def spellcheck_suggestions
+        unless defined?(@spellcheck_suggestions)
+          @spellcheck_suggestions = {}
+          count = ((solr_spellcheck['suggestions'] || []).length) / 2
+          (0..(count - 1)).each do |i|
+            break if ["correctlySpelled", "collation"].include? solr_spellcheck[i]
+            term = solr_spellcheck['suggestions'][i * 2]
+            suggestion = solr_spellcheck['suggestions'][(i * 2) + 1]
+            @spellcheck_suggestions[term] = suggestion
+          end
+        end
+        @spellcheck_suggestions
+      end
+
+      # Return the suggestion with the single highest frequency.
+      # Requires the extended results format.
+      def spellcheck_suggestion_for(term)
+        spellcheck_suggestions[term]['suggestion'].sort_by do |suggestion|
+          suggestion['freq']
+        end.last['word']
+      end
+
+      # Provide a collated query. If the user provides a query string,
+      # tokenize it on whitespace and replace terms strictly not present in
+      # the index. Otherwise return Solr's suggested collation.
+      #
+      # Solr's suggested collation is more liberal, replacing even terms that
+      # are present in the index. This may not be useful if only one term is
+      # misspelled and preventing useful results.
+      #
+      # Mix and match in your views for a blend of strict and liberal collations.
+      def spellcheck_collation(*terms)
+        if solr_spellcheck['suggestions'] && solr_spellcheck['suggestions'].length > 2
+          collation = terms.join(" ").dup if terms
+
+          # If we are given a query string, tokenize it and strictly replace
+          # the terms that aren't present in the index
+          if terms.length > 0
+            terms.each do |term|
+              if (spellcheck_suggestions[term]||{})['origFreq'] == 0
+                collation[term] = spellcheck_suggestion_for(term)
+              end
+            end
+          end
+
+          # If no query was given, or all terms are present in the index,
+          # return Solr's suggested collation.
+          if terms.length == 0
+            collation = solr_spellcheck['suggestions'][-1]
+          end
+
+          collation
+        else
+          nil
+        end
+      end
+
       private
-  
+
       def dsl
         DSL::Search.new(self, @setup)
       end

data/lib/sunspot/session.rb

@@ -102,9 +102,9 @@ module Sunspot
     #
     # See Sunspot.commit
     #
-    def commit
+    def commit(soft_commit = false)
       @adds = @deletes = 0
-      connection.commit
+      connection.commit :commit_attributes => {:softCommit => soft_commit}
     end
 
     #
@@ -200,8 +200,8 @@ module Sunspot
     # 
     # See Sunspot.commit_if_dirty
     #
-    def commit_if_dirty
-      commit if dirty?
+    def commit_if_dirty(soft_commit = false)
+      commit soft_commit if dirty?
     end
     
     # 
@@ -214,8 +214,8 @@ module Sunspot
     # 
     # See Sunspot.commit_if_delete_dirty
     #
-    def commit_if_delete_dirty
-      commit if delete_dirty?
+    def commit_if_delete_dirty(soft_commit = false)
+      commit soft_commit if delete_dirty?
     end
     
     # 

data/lib/sunspot/setup.rb

@@ -41,7 +41,12 @@ module Sunspot
     def add_join_field_factory(name, type, options = {}, &block)
       field_factory = FieldFactory::Join.new(name, type, options, &block)
       @field_factories[field_factory.signature] = field_factory
-      @field_factories_cache[field_factory.name] = field_factory
+
+      if type.is_a?(Type::TextType)
+        @text_field_factories_cache[field_factory.name] = field_factory
+      else
+        @field_factories_cache[field_factory.name] = field_factory
+      end
     end
 
     # 

data/lib/sunspot/util.rb

@@ -1,14 +1,14 @@
 module Sunspot
-  # 
+  #
   # The Sunspot::Util module provides utility methods used elsewhere in the
   # library.
   #
   module Util #:nodoc:
     class <<self
-      # 
+      #
       # Get all of the superclasses for a given class, including the class
       # itself.
-      # 
+      #
       # ==== Parameters
       #
       # clazz<Class>:: class for which to get superclasses
@@ -23,7 +23,7 @@ module Sunspot
         superclasses
       end
 
-      # 
+      #
       # Convert a string to snake case
       #
       # ==== Parameters
@@ -38,7 +38,7 @@ module Sunspot
         string.scan(/(^|[A-Z])([^A-Z]+)/).map! { |word| word.join.downcase }.join('_')
       end
 
-      # 
+      #
       # Convert a string to camel case
       #
       # ==== Parameters
@@ -53,7 +53,23 @@ module Sunspot
         string.split('_').map! { |word| word.capitalize }.join
       end
 
-      # 
+      #
+      # Convert snake case string to method case (Java style)
+      #
+      # ==== Parameters
+      #
+      # string<String>:: String to convert to method case
+      #
+      # ==== Returns
+      #
+      # String:: String in method case
+      #
+      def method_case(string)
+        first = true
+        string.split('_').map! { |word| word = first ? word : word.capitalize; first = false; word }.join
+      end
+
+      #
       # Get a constant from a fully qualified name
       #
       # ==== Parameters
@@ -70,13 +86,13 @@ module Sunspot
         end
       end
 
-      # 
+      #
       # Evaluate the given proc in the context of the given object if the
       # block's arity is non-positive, or by passing the given object as an
       # argument if it is negative.
-      # 
+      #
       # ==== Parameters
-      # 
+      #
       # object<Object>:: Object to pass to the proc
       #
       def instance_eval_or_call(object, &block)
@@ -108,7 +124,7 @@ module Sunspot
         end
       end
 
-      # 
+      #
       # When generating boosts, Solr requires that the values be in standard
       # (not scientific) notation. We would like to ensure a minimum number of
       # significant digits (i.e., digits that are not prefix zeros) for small
@@ -122,7 +138,7 @@ module Sunspot
         end
       end
 
-      # 
+      #
       # Perform a deep merge of hashes, returning the result as a new hash.
       # See #deep_merge_into for rules used to merge the hashes
       #
@@ -139,7 +155,7 @@ module Sunspot
         deep_merge_into({}, left, right)
       end
 
-      # 
+      #
       # Perform a deep merge of the right hash into the left hash
       #
       # ==== Parameters
@@ -155,9 +171,26 @@ module Sunspot
         deep_merge_into(left, left, right)
       end
 
+      #
+      # Escapes characters for the Solr query parser
+      #
+      # ==== Parameters
+      #
+      # string<String>:: String to escape
+      #
+      # ==== Returns
+      #
+      # String:: escaped string
+      #
+      def escape(value)
+        # RSolr.solr_escape doesn't handle spaces or period chars,
+        # which do need to be escaped
+        RSolr.solr_escape(value).gsub(/([\s\.])/, '\\\\\1')
+      end
+
       private
 
-      # 
+      #
       # Deep merge two hashes into a third hash, using rules that produce nice
       # merged parameter hashes. The rules are as follows, for a given key:
       #