outoftime-sunspot 0.8.9 → 0.9.0

data/lib/sunspot/setup.rb

@@ -5,42 +5,69 @@ module Sunspot
   #
   class Setup #:nodoc:
     def initialize(clazz)
+      @clazz = clazz
       @class_name = clazz.name
-      @fields, @text_fields, @dynamic_fields = [], [], []
+      @field_factories, @text_field_factories, @dynamic_field_factories,
+        @field_factories_cache, @text_field_factories_cache,
+        @dynamic_field_factories_cache = *Array.new(6) { Hash.new }
       @dsl = DSL::Fields.new(self)
+      add_field_factory(:class, Type::ClassType)
+    end
+
+    def type_names
+      [@class_name]
     end
 
     # 
-    # Add fields for scope/ordering
+    # Add field_factories for scope/ordering
     # 
     # ==== Parameters
     #
-    # fields<Array>:: Array of Sunspot::Field objects
+    # field_factories<Array>:: Array of Sunspot::Field objects
     #
-    def add_fields(fields)
-      @fields.concat(Array(fields))
+    def add_field_factory(name, type, options = {}, &block)
+      field_factory = FieldFactory::Static.new(name, type, options, &block)
+      @field_factories[field_factory.signature] = field_factory
+      @field_factories_cache[field_factory.name] = field_factory
     end
 
     # 
-    # Add fields for fulltext search
+    # Add field_factories for fulltext search
     #
     # ==== Parameters
     #
-    # fields<Array>:: Array of Sunspot::Field objects
+    # field_factories<Array>:: Array of Sunspot::Field objects
     #
-    def add_text_fields(fields)
-      @text_fields.concat(Array(fields))
+    def add_text_field_factory(name, options = {}, &block)
+      field_factory = FieldFactory::Static.new(name, Type::TextType, options, &block)
+      @text_field_factories[name] = field_factory
+      @text_field_factories_cache[field_factory.name] = field_factory
     end
 
     #
-    # Add dynamic fields
+    # Add dynamic field_factories
     #
     # ==== Parameters
     # 
-    # fields<Array>:: Array of dynamic field objects
+    # field_factories<Array>:: Array of dynamic field objects
     # 
-    def add_dynamic_fields(fields)
-      @dynamic_fields.concat(Array(fields))
+    def add_dynamic_field_factory(name, type, options = {}, &block)
+      field_factory = FieldFactory::Dynamic.new(name, type, options, &block)
+      @dynamic_field_factories[field_factory.signature] = field_factory
+      @dynamic_field_factories_cache[field_factory.name] = field_factory
+    end
+
+    def add_document_boost(attr_name, &block)
+      @document_boost_extractor =
+        if attr_name
+          if attr_name.respond_to?(:to_f)
+            DataExtractor::Constant.new(attr_name)
+          else
+            DataExtractor::AttributeExtractor.new(attr_name)
+          end
+        else
+          DataExtractor::BlockExtractor.new(&block)
+        end
     end
 
     # 
@@ -50,63 +77,89 @@ module Sunspot
       @dsl.instance_eval(&block)
     end
 
-    # 
-    # Get the fields associated with this setup as well as all inherited fields
-    #
-    # ==== Returns
-    #
-    # Array:: Collection of all fields associated with this setup
-    #
+    def field(field_name)
+      if field_factory = @field_factories_cache[field_name.to_sym]
+        field_factory.build
+      else
+        raise(
+          UnrecognizedFieldError,
+          "No field configured for #{@clazz.name} with name '#{field_name}'"
+        )
+      end
+    end
+
+    def text_field(field_name)
+      if field_factory = @text_field_factories_cache[field_name.to_sym]
+        field_factory.build
+      else
+        raise(
+          UnrecognizedFieldError,
+          "No text field configured for #{@clazz.name} with name '#{field_name}'"
+        )
+      end
+    end
+
+    def dynamic_field_factory(field_name)
+      @dynamic_field_factories_cache[field_name.to_sym] || raise(
+        UnrecognizedFieldError,
+        "No dynamic field configured for #{@clazz.name} with name '#{field_name}'"
+      )
+    end
+
     def fields
-      get_inheritable_collection(:fields)
+      field_factories.map { |field_factory| field_factory.build }
+    end
+
+    def text_fields
+      text_field_factories.map { |text_field_factory| text_field_factory.build }
     end
 
     # 
-    # Get the text fields associated with this setup as well as all inherited
-    # text fields
+    # Get the field_factories associated with this setup as well as all inherited field_factories
     #
     # ==== Returns
     #
-    # Array:: Collection of all text fields associated with this setup
+    # Array:: Collection of all field_factories associated with this setup
     #
-    def text_fields
-      get_inheritable_collection(:text_fields)
+    def field_factories
+      collection_from_inheritable_hash(:field_factories)
     end
 
     # 
-    # Get all static, dynamic, and text fields associated with this setup as
-    # well as all inherited fields
+    # Get the text field_factories associated with this setup as well as all inherited
+    # text field_factories
     #
     # ==== Returns
     #
-    # Array:: Collection of all text and scope fields associated with this setup
+    # Array:: Collection of all text field_factories associated with this setup
     #
-    def all_fields
-      all_fields = []
-      all_fields.concat(fields).concat(text_fields).concat(dynamic_fields)
-      all_fields
+    def text_field_factories
+      collection_from_inheritable_hash(:text_field_factories)
     end
 
     # 
-    # Get all dynamic fields for this and parent setups
-    # 
+    # Get all static, dynamic, and text field_factories associated with this setup as
+    # well as all inherited field_factories
+    #
     # ==== Returns
     #
-    # Array:: Dynamic fields
+    # Array:: Collection of all text and scope field_factories associated with this setup
     #
-    def dynamic_fields
-      get_inheritable_collection(:dynamic_fields)
+    def all_field_factories
+      all_field_factories = []
+      all_field_factories.concat(field_factories).concat(text_field_factories).concat(dynamic_field_factories)
+      all_field_factories
     end
 
     # 
-    # Factory method for an Indexer object configured to use this setup
-    #
+    # Get all dynamic field_factories for this and parent setups
+    # 
     # ==== Returns
     #
-    # Sunspot::Indexer:: Indexer configured with this setup
+    # Array:: Dynamic field_factories
     #
-    def indexer(connection)
-      Indexer.new(connection, self)
+    def dynamic_field_factories
+      collection_from_inheritable_hash(:dynamic_field_factories)
     end
 
     # 
@@ -120,6 +173,12 @@ module Sunspot
       Util.full_const_get(@class_name)
     end
 
+    def document_boost_for(model)
+      if @document_boost_extractor
+        @document_boost_extractor.value_for(model)
+      end
+    end
+
     protected
 
     # 
@@ -133,12 +192,18 @@ module Sunspot
       Setup.for(clazz.superclass)
     end
 
+    def get_inheritable_hash(name)
+      hash = instance_variable_get(:"@#{name}")
+      parent.get_inheritable_hash(name).each_pair do |key, value|
+        hash[key] = value unless hash.has_key?(key)
+      end if parent
+      hash
+    end
+
     private
 
-    def get_inheritable_collection(name)
-      collection = instance_variable_get(:"@#{name}").dup
-      collection.concat(parent.send(name)) if parent
-      collection
+    def collection_from_inheritable_hash(name)
+      get_inheritable_hash(name).values
     end
 
     class <<self
@@ -164,7 +229,13 @@ module Sunspot
       #   Setup instance associated with the given class or its nearest ancestor
       #   
       def for(clazz) #:nodoc:
-        setups[clazz.name.to_sym] || self.for(clazz.superclass) if clazz
+        class_name =
+          if clazz.respond_to?(:name)
+            clazz.name
+          else
+            clazz
+          end
+        setups[class_name.to_sym] || self.for(clazz.superclass) if clazz
       end
 
       protected

data/lib/sunspot/type.rb

@@ -109,8 +109,6 @@ module Sunspot
             time =
               if value.respond_to?(:utc)
                 value
-              elsif %w(year mon mday).each { |method| value.respond_to?(method) }
-                Time.gm(value.year, value.mon, value.mday)
               else
                 Time.parse(value.to_s)
               end
@@ -124,6 +122,38 @@ module Sunspot
       end
     end
 
+    # 
+    # The DateType encapsulates dates (without time information). Internally,
+    # Solr does not have a date-only type, so this type indexes data using
+    # Solr's DateField type (which is actually date/time), midnight UTC of the
+    # indexed date.
+    #
+    module DateType
+      class <<self
+        def indexed_name(name) #:nodoc:
+          "#{name}_d"
+        end
+
+        def to_indexed(value) #:nodoc:
+          if value
+            time = 
+              if %w(year mon mday).all? { |method| value.respond_to?(method) }
+                Time.utc(value.year, value.mon, value.mday)
+              else
+                date = Date.parse(value.to_s)
+                Time.utc(date.year, date.mon, date.mday)
+              end
+            time.utc.xmlschema
+          end
+        end
+
+        def cast(string)
+          time = Time.xmlschema(string)
+          Date.civil(time.year, time.mon, time.mday)
+        end
+      end
+    end
+
     # 
     # The boolean type represents true/false values. Note that +nil+ will not be
     # indexed at all; only +false+ will be indexed with a false value.
@@ -150,5 +180,21 @@ module Sunspot
         end
       end
     end
+
+    module ClassType
+      class <<self
+        def indexed_name(name)
+          'class_name'
+        end
+
+        def to_indexed(value)
+          value.name
+        end
+
+        def cast(string)
+          Sunspot::Util.full_const_get(string)
+        end
+      end
+    end
   end
 end

data/lib/sunspot.rb

@@ -1,9 +1,18 @@
-gem 'solr-ruby'
-require 'solr'
+begin
+  require 'time'
+  require 'date'
+  require 'rsolr'
+rescue LoadError
+  require 'rubygems'
+  require 'rsolr'
+end
+
 require File.join(File.dirname(__FILE__), 'light_config')
 
-%w(adapters configuration setup field data_extractor indexer
-   query search facet facet_row session type util dsl).each do |filename|
+%w(util adapters configuration setup composite_setup field field_factory
+   data_extractor indexer query search facet facet_row instantiated_facet
+   instantiated_facet_row date_facet date_facet_row query_facet query_facet_row
+   session type dsl).each do |filename|
   require File.join(File.dirname(__FILE__), 'sunspot', filename)
 end
 
@@ -282,8 +291,8 @@ module Sunspot
     #     query.with(:blog_id, @current_blog.id)
     #   end
     #
-    # See Sunspot::DSL::Scope and Sunspot::DSL::Query for the full API presented
-    # inside the block.
+    # See Sunspot::DSL::Search, Sunspot::DSL::Scope, Sunspot::DSL::FieldQuery
+    # and Sunspot::DSL::Query for the full API presented inside the block.
     #
     def search(*types, &block)
       session.search(*types, &block)
@@ -319,6 +328,30 @@ module Sunspot
       session.remove!(*objects)
     end
 
+    # 
+    # Remove an object from the index using its class name and primary key.
+    # Useful if you know this information and want to remove an object without
+    # instantiating it from persistent storage
+    #
+    # ==== Parameters
+    #
+    # clazz<Class>:: Class of the object, or class name as a string or symbol
+    # id::
+    #   Primary key of the object. This should be the same id that would be
+    #   returned by the class's instance adapter.
+    #
+    def remove_by_id(clazz, id)
+      session.remove_by_id(clazz, id)
+    end
+
+    # 
+    # Remove an object by class name and primary key, and immediately commit.
+    # See #remove_by_id and #commit
+    #
+    def remove_by_id!(clazz, id)
+      session.remove_by_id!(clazz, id)
+    end
+
     # Remove all objects of the given classes from the index. There isn't much
     # use for this in general operations but it can be useful for maintenance,
     # testing, etc. If no arguments are passed, remove everything from the
@@ -350,6 +383,27 @@ module Sunspot
       session.remove_all!(*classes)
     end
 
+    # 
+    # Process all adds in a batch. Any Sunspot adds initiated inside the block
+    # will be sent in bulk when the block finishes. Useful if your application
+    # initiates index adds from various places in code as part of a single
+    # operation; doing a batch add will give better performance.
+    #
+    # ==== Example
+    #
+    #   Sunspot.batch do
+    #     post = Post.new
+    #     Sunspot.add(post)
+    #     comment = Comment.new
+    #     Sunspot.add(comment)
+    #   end
+    #
+    # Sunspot will send both the post and the comment in a single request.
+    #
+    def batch(&block)
+      session.batch(&block)
+    end
+
     #
     # True if documents have been added, updated, or removed since the last
     # commit.
@@ -384,8 +438,20 @@ module Sunspot
     # Resets the singleton session. This is useful for clearing out all
     # static data between tests, but probably nowhere else.
     #
-    def reset!
-      @session = Session.new(session.config)
+    # ==== Parameters
+    #
+    # keep_config<Boolean>::
+    #   Whether to retain the configuration used by the current singleton
+    #   session. Default false.
+    #
+    def reset!(keep_config = false)
+      config =
+        if keep_config
+          session.config
+        else
+          Configuration.build
+        end
+      @session = Session.new(config)
     end
 
     private