sunspot 2.0.0 → 2.5.0

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/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,46 @@ 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
+
+    #
+    # Whether the field is stored or not.
+    #
+    # ==== Returns
+    #
+    # Boolean:: True if this field is a stored field
+    #
+    def stored?
+      !!@stored
+    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 +136,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 +159,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,9 +185,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?
+
+      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)
 
+      @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 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

@@ -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,20 @@ 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?
-          Util.Array(@field.to_indexed(value)).each do |scalar_value|
-            options = {}
-            options[:boost] = @field.boost if @field.boost
+      def populate_document(document, model, options = {}) #:nodoc:
+        atomic_operation = options[:update] == :set
+        value = extract_value(model, options)
+        if value != nil || atomic_operation
+          indexed_values = Util.Array(@field.to_indexed(value))
+          indexed_values = [nil] if indexed_values.empty? && atomic_operation
+          indexed_values.each do |scalar_value|
+            field_options = {}
+            field_options[:boost] = @field.boost if @field.boost
+            field_options[:null] = true if scalar_value.nil? && atomic_operation
             document.add_field(
               @field.indexed_name.to_sym,
               scalar_value,
-              options
+              field_options.merge(options)
             )
           end
         end
@@ -76,23 +98,48 @@ module Sunspot
       end
     end
 
+    class Join < Abstract
+      def initialize(name, type, 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(self.name, type, options)
+      end
+
+      # 
+      # Return the field instance built by this factory
+      #
+      def build
+        @field
+      end
+
+      #
+      # A unique signature identifying this field by name and type.
+      #
+      def signature
+        ['join', @field.name, @field.type]
+      end
+    end
+
     # 
     # DynamicFieldFactories create dynamic field instances based on dynamic
     # configuration.
     #
     class Dynamic < Abstract
-      attr_accessor :name, :type
+      attr_accessor :name, :type, :separator
 
       def initialize(name, type, options = {}, &block)
         super(name, options, &block)
         @type, @options = type, options
+        @separator = @options.delete(:separator) || ':'
       end
 
       #
       # Build a field based on the dynamic name given.
       #
       def build(dynamic_name)
-        AttributeField.new("#{@name}:#{dynamic_name}", @type, @options.dup)
+        AttributeField.new([@name, dynamic_name].join(separator), @type, @options.dup)
       end
       # 
       # This alias allows a DynamicFieldFactory to be used in place of a Setup
@@ -104,14 +151,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

@@ -8,7 +8,6 @@ module Sunspot
   # subclasses).
   #
   class Indexer #:nodoc:
-    include RSolr::Char
 
     def initialize(connection)
       @connection = connection
@@ -23,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
 
     # 
@@ -44,17 +54,18 @@ module Sunspot
     # Remove the model from the Solr index by specifying the class and ID
     #
     def remove_by_id(class_name, *ids)
+      ids.flatten!
       @connection.delete_by_id(
         ids.map { |id| Adapters::InstanceAdapter.index_id_for(class_name, id) }
       )
     end
 
-    # 
+    #
     # Delete all documents of the class indexed by this indexer from Solr.
     #
     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
@@ -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_full_update(model)
+      setup = setup_for_object(model)
       if boost = setup.document_boost_for(model)
         document.attrs[:boost] = boost
       end
@@ -102,22 +113,48 @@ module Sunspot
       document
     end
 
+    def prepare_atomic_update(clazz, id, updates = {})
+      document = document_for_atomic_update(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
+    # These methods construct the document hash containing those key-value
     # pairs.
     #
-    def document_for(model)
+    def document_for_full_update(model)
       RSolr::Xml::Document.new(
-        :id => Adapters::InstanceAdapter.adapt(model).index_id,
-        :type => Util.superclasses_for(model.class).map { |clazz| clazz.name }
+        id: Adapters::InstanceAdapter.adapt(model).index_id,
+        type: Util.superclasses_for(model.class).map(&:name)
       )
     end
 
+    def document_for_atomic_update(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
     # 
     # Get the Setup object for the given object's class.
     #
@@ -129,8 +166,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