sunspot 2.1.1 → 2.2.0

data/lib/sunspot.rb

@@ -196,23 +196,27 @@ module Sunspot
       session.index!(*objects)
     end
 
-    # Commits the singleton session
+    # Commits (soft or hard) the singleton session
     #
     # When documents are added to or removed from Solr, the changes are
     # initially stored in memory, and are not reflected in Solr's existing
-    # searcher instance. When a commit message is sent, the changes are written
+    # searcher instance. When a hard commit message is sent, the changes are written
     # to disk, and a new searcher is spawned. Commits are thus fairly
     # expensive, so if your application needs to index several documents as part
     # of a single operation, it is advisable to index them all and then call
     # commit at the end of the operation.
+    # Solr 4 introduced the concept of a soft commit which is much faster
+    # since it only makes index changes visible while not writing changes to disk.
+    # If Solr crashes or there is a loss of power, changes that occurred after
+    # the last hard commit will be lost.
     #
     # Note that Solr can also be configured to automatically perform a commit
     # after either a specified interval after the last change, or after a
     # specified number of documents are added. See
     # http://wiki.apache.org/solr/SolrConfigXml
     #
-    def commit
-      session.commit
+    def commit(soft_commit = false)
+      session.commit soft_commit
     end
 
     # Optimizes the index on the singletion session.
@@ -510,10 +514,10 @@ module Sunspot
     end
 
     # 
-    # Sends a commit if the session is dirty (see #dirty?).
+    # Sends a commit (soft or hard) if the session is dirty (see #dirty?).
     #
-    def commit_if_dirty
-      session.commit_if_dirty
+    def commit_if_dirty(soft_commit = false)
+      session.commit_if_dirty soft_commit
     end
     
     #
@@ -530,8 +534,8 @@ module Sunspot
     # 
     # Sends a commit if the session has deletes since the last commit (see #delete_dirty?).
     #
-    def commit_if_delete_dirty
-      session.commit_if_delete_dirty
+    def commit_if_delete_dirty(soft_commit = false)
+      session.commit_if_delete_dirty soft_commit
     end
     
     # Returns the configuration associated with the singleton session. See

data/lib/sunspot/dsl.rb

@@ -1,5 +1,6 @@
-%w(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|
+%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|
   require File.join(File.dirname(__FILE__), 'dsl', file)
 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
 
@@ -74,35 +71,33 @@ module Sunspot
       #
       def method_missing(method, *args, &block)
         options = Util.extract_options_from(args)
-        if method.to_s == 'join'
-          type_string = options.delete(:type).to_s
-        else
-          type_string = method.to_s
-        end
+        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 = options[:type]
           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 method.to_s == 'join'
-          @setup.add_join_field_factory(name, type, options, &block)
+        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/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/spellcheckable.rb

@@ -0,0 +1,14 @@
+module Sunspot
+  module DSL #:nodoc:
+    module Spellcheckable #:nodoc
+      # Ask Solr to suggest alternative spellings for the query
+      #
+      # ==== Options
+      #
+      # The list of options can be found here: http://wiki.apache.org/solr/SpellCheckComponent
+      def spellcheck(options = {})
+        @query.add_spellcheck(options)
+      end
+    end
+  end
+end

data/lib/sunspot/dsl/standard_query.rb

@@ -9,7 +9,7 @@ module Sunspot
     # See Sunspot.search for usage examples
     #
     class StandardQuery < FieldQuery
-      include Paginatable, Adjustable
+      include Paginatable, Adjustable, Spellcheckable
 
       # Specify a phrase that should be searched as fulltext. Only +text+
       # fields are searched - see DSL::Fields.text
@@ -56,67 +56,95 @@ module Sunspot
       #   a pizza" will not. Default behavior is a query phrase slop of zero.
       #
       def fulltext(keywords, options = {}, &block)
-        if keywords && !(keywords.to_s =~ /^\s*$/)
-          fulltext_query = @query.add_fulltext(keywords)
-          if field_names = options.delete(:fields)
-            Util.Array(field_names).each do |field_name|
-              @setup.text_fields(field_name).each do |field|
-                fulltext_query.add_fulltext_field(field, field.default_boost)
-              end
-            end
-          end
-          if minimum_match = options.delete(:minimum_match)
-            fulltext_query.minimum_match = minimum_match.to_i
-          end
-          if tie = options.delete(:tie)
-            fulltext_query.tie = tie.to_f
-          end
-          if query_phrase_slop = options.delete(:query_phrase_slop)
-            fulltext_query.query_phrase_slop = query_phrase_slop.to_i
-          end
+        return if not keywords or keywords.to_s =~ /^\s*$/
+
+        field_names = Util.Array(options.delete(:fields)).compact
+
+        add_fulltext(keywords, field_names) do |query, fields|
+          query.minimum_match = options.delete(:minimum_match).to_i if options.key?(:minimum_match)
+          query.tie = options.delete(:tie).to_f if options.key?(:tie)
+          query.query_phrase_slop = options.delete(:query_phrase_slop).to_i if options.key?(:query_phrase_slop)
+
           if highlight_field_names = options.delete(:highlight)
             if highlight_field_names == true
-              fulltext_query.add_highlight
+              query.add_highlight
             else
               highlight_fields = []
               Util.Array(highlight_field_names).each do |field_name|
                 highlight_fields.concat(@setup.text_fields(field_name))
               end
-              fulltext_query.add_highlight(highlight_fields)
+              query.add_highlight(highlight_fields)
             end
           end
-          if block && fulltext_query
-            fulltext_dsl = Fulltext.new(fulltext_query, @setup)
-            Util.instance_eval_or_call(
-              fulltext_dsl,
-              &block
-            )
+
+          if block && query
+            fulltext_dsl = Fulltext.new(query, @setup)
+            Util.instance_eval_or_call(fulltext_dsl, &block)
+          else
+            fulltext_dsl = nil
           end
-          if !field_names && (!fulltext_dsl || !fulltext_dsl.fields_added?)
+
+          if fields.empty? && (!fulltext_dsl || !fulltext_dsl.fields_added?)
             @setup.all_text_fields.each do |field|
-              unless fulltext_query.has_fulltext_field?(field)
+              unless query.has_fulltext_field?(field)
                 unless fulltext_dsl && fulltext_dsl.exclude_fields.include?(field.name)
-                  fulltext_query.add_fulltext_field(field, field.default_boost)
+                  query.add_fulltext_field(field, field.default_boost)
                 end
               end
             end
           end
         end
       end
+
       alias_method :keywords, :fulltext
 
       def with(*args)
         case args.first
-        when String, Symbol
-          if args.length == 1 # NONE
-            field = @setup.field(args[0].to_sym)
-            return DSL::RestrictionWithNear.new(field, @scope, @query, false)
-          end
+          when String, Symbol
+            if args.length == 1 # NONE
+              field = @setup.field(args[0].to_sym)
+              return DSL::RestrictionWithNear.new(field, @scope, @query, false)
+            end
         end
 
         # else
         super
       end
+
+      def any(&block)
+        @query.disjunction do
+          Util.instance_eval_or_call(self, &block)
+        end
+      end
+
+      def all(&block)
+        @query.conjunction do
+          Util.instance_eval_or_call(self, &block)
+        end
+      end
+
+      private
+
+      def add_fulltext(keywords, field_names)
+        return yield(@query.add_fulltext(keywords), []) unless field_names.any?
+
+        all_fields = field_names.map { |name| @setup.text_fields(name) }.flatten
+        all_fields -= join_fields = all_fields.find_all(&:joined?)
+
+        if all_fields.any?
+          fulltext_query = @query.add_fulltext(keywords)
+          all_fields.each { |field| fulltext_query.add_fulltext_field(field, field.default_boost) }
+          yield(fulltext_query, all_fields)
+        end
+
+        if join_fields.any?
+          join_fields.group_by { |field| [field.target, field.from, field.to] }.each_pair do |(target, from, to), fields|
+            join_query = @query.add_join(keywords, target, from, to)
+            fields.each { |field| join_query.add_fulltext_field(field, field.default_boost) }
+            yield(join_query, fields)
+          end
+        end
+      end
     end
   end
 end

data/lib/sunspot/field.rb

@@ -82,17 +82,35 @@ module Sunspot
       !!@more_like_this
     end
 
+    #
+    # Whether the field was joined from another model.
+    #
+    # ==== Returns
+    #
+    # Boolean:: True if this field was joined from another model
+    #
+    def joined?
+      !!@joined
+    end
+
     def hash
       indexed_name.hash
     end
 
     def eql?(field)
-      indexed_name == field.indexed_name
+      field.is_a?(self.class) && indexed_name == field.indexed_name
     end
     alias_method :==, :eql?
 
     private
 
+    #
+    # Raise if an unknown option passed
+    #
+    def check_options(options)
+      raise ArgumentError, "Unknown field option #{options.keys.first.inspect} provided for field #{name.inspect}" unless options.empty?
+    end
+
     #
     # Determine the indexed name. If the :as option is given use that, otherwise
     # create the value based on the indexed_name of the type with additional
@@ -107,7 +125,8 @@ module Sunspot
         if options[:as]
           options.delete(:as).to_s
         else
-          "#{@type.indexed_name(@name).to_s}#{'m' if multiple? }#{'s' if @stored}#{'v' if more_like_this?}"
+          name = options[:prefix] ? @name.to_s.sub(/^#{options[:prefix]}_/, '') : @name
+          "#{@type.indexed_name(name)}#{'m' if multiple? }#{'s' if @stored}#{'v' if more_like_this?}"
         end
     end
 
@@ -129,7 +148,8 @@ module Sunspot
       @multiple = true
       @boost = options.delete(:boost)
       @default_boost = options.delete(:default_boost)
-      raise ArgumentError, "Unknown field option #{options.keys.first.inspect} provided for field #{name.inspect}" unless options.empty?
+
+      check_options(options)
     end
 
     def indexed_name
@@ -154,24 +174,50 @@ module Sunspot
         elsif reference.respond_to?(:to_sym)
           reference.to_sym
         end
-      raise ArgumentError, "Unknown field option #{options.keys.first.inspect} provided for field #{name.inspect}" unless options.empty?
-    end
 
+      check_options(options)
+    end
   end
 
+  #
+  # JoinField encapsulates attributes from referenced models.
+  # Could be of any type
+  #
   class JoinField < Field #:nodoc:
+    attr_reader :default_boost, :target
 
     def initialize(name, type, options = {})
       @multiple = !!options.delete(:multiple)
+
       super(name, type, options)
-      @join_string = options.delete(:join_string)
-      raise ArgumentError, "Unknown field option #{options.keys.first.inspect} provided for field #{name.inspect}" unless options.empty?
+
+      @prefix = options.delete(:prefix)
+      @join = options.delete(:join)
+      @clazz = options.delete(:clazz)
+      @target = options.delete(:target)
+      @default_boost = options.delete(:default_boost)
+      @joined = true
+
+      check_options(options)
+    end
+
+    def from
+      Sunspot::Setup.for(@target).field(@join[:from]).indexed_name
+    end
+
+    def to
+      Sunspot::Setup.for(@clazz).field(@join[:to]).indexed_name
     end
 
     def local_params
-      "{!join #{@join_string}}"
+      "{!join from=#{from} to=#{to}}"
     end
 
+    def eql?(field)
+      super && target == field.target && from == field.from && to == field.to
+    end
+
+    alias_method :==, :eql?
   end
 
   class TypeField #:nodoc:

data/lib/sunspot/field_factory.rb

@@ -78,12 +78,11 @@ module Sunspot
 
     class Join < Abstract
       def initialize(name, type, options = {}, &block)
-        super(name, options, &block)
+        super(options[:prefix] ? "#{options[:prefix]}_#{name}" : name, options, &block)
         unless name.to_s =~ /^\w+$/
           raise ArgumentError, "Invalid field name #{name}: only letters, numbers, and underscores are allowed."
         end
-        @field =
-          JoinField.new(name, type, options)
+        @field = JoinField.new(self.name, type, options)
       end
 
       # 
@@ -98,7 +97,6 @@ module Sunspot
       # into the Solr document for indexing. (noop here for joins)
       #
       def populate_document(document, model) #:nodoc:
-
       end
 
       # 

data/lib/sunspot/indexer.rb

@@ -8,7 +8,6 @@ module Sunspot
   # subclasses).
   #
   class Indexer #:nodoc:
-    include RSolr::Char
 
     def initialize(connection)
       @connection = connection
@@ -55,7 +54,7 @@ module Sunspot
     #
     def remove_all(clazz = nil)
       if clazz
-        @connection.delete_by_query("type:#{escape(clazz.name)}")
+        @connection.delete_by_query("type:#{Util.escape(clazz.name)}")
       else
         @connection.delete_by_query("*:*")
       end