gojee-sunspot 2.0.2

data/lib/sunspot/adapters.rb

@@ -0,0 +1,265 @@
+module Sunspot
+  # 
+  # Sunspot works by saving references to the primary key (or natural ID) of
+  # each indexed object, and then retrieving the objects from persistent storage
+  # when their IDs are referenced in search results. In order for Sunspot to
+  # know what an object's primary key is, and how to retrieve objects from
+  # persistent storage given a primary key, an adapter must be registered for
+  # that object's class or one of its superclasses (for instance, an adapter
+  # registered for ActiveRecord::Base would be used for all ActiveRecord
+  # models).
+  #
+  # To provide Sunspot with this ability, adapters must have two roles:
+  #
+  # Data accessor::
+  #   A subclass of Sunspot::Adapters::DataAccessor, this object is instantiated
+  #   with a particular class and must respond to the #load() method, which
+  #   returns an object from persistent storage given that object's primary key.
+  #   It can also optionally implement the #load_all() method, which returns
+  #   a collection of objects given a collection of primary keys, if that can be
+  #   done more efficiently than calling #load() on each key.
+  # Instance adapter::
+  #   A subclass of Sunspot::Adapters::InstanceAdapter, this object is
+  #   instantiated with a particular instance. Its only job is to tell Sunspot
+  #   what the object's primary key is, by implementing the #id() method.
+  #
+  # Adapters are registered by registering their two components, telling Sunspot
+  # that they are available for one or more classes, and all of their
+  # subclasses. See Sunspot::Adapters::DataAccessor.register and
+  # Sunspot::Adapters::InstanceAdapter.register for the details.
+  #
+  # See spec/mocks/mock_adapter.rb for an example of how adapter classes should
+  # be implemented.
+  #
+  module Adapters
+    # Subclasses of the InstanceAdapter class should implement the #id method,
+    # which returns the primary key of the instance stored in the @instance
+    # variable. The primary key must be unique within the scope of the
+    # instance's class.
+    #
+    # ==== Example:
+    #
+    #   class FileAdapter < Sunspot::Adapters::InstanceAdapter
+    #     def id
+    #       File.expand_path(@instance.path)
+    #     end
+    #   end
+    #
+    #   # then in your initializer
+    #   Sunspot::Adapters::InstanceAdapter.register(MyAdapter, File)
+    #
+    class InstanceAdapter
+      def initialize(instance) #:nodoc:
+        @instance = instance
+      end
+
+      # 
+      # The universally-unique ID for this instance that will be stored in solr
+      #
+      # ==== Returns
+      #
+      # String:: ID for use in Solr
+      #
+      def index_id #:nodoc:
+        InstanceAdapter.index_id_for(@instance.class.name, id)
+      end
+
+      class <<self
+        # Instantiate an InstanceAdapter for the given object, searching for
+        # registered adapters for the object's class.
+        #
+        # ==== Parameters
+        #
+        # instance<Object>:: The instance to adapt
+        #
+        # ==== Returns
+        #
+        # InstanceAdapter::
+        #   An instance of an InstanceAdapter implementation that
+        #   wraps the given instance
+        #
+        def adapt(instance) #:nodoc:
+          self.for(instance.class).new(instance)
+        end
+
+        # Register an instance adapter for a set of classes. When searching for
+        # an adapter for a given instance, Sunspot starts with the instance's
+        # class, and then searches for registered adapters up the class's
+        # ancestor chain.
+        #
+        # ==== Parameters
+        #
+        # instance_adapter<Class>:: The instance adapter class to register
+        # classes...<Class>::
+        #   One or more classes that this instance adapter adapts
+        #
+        def register(instance_adapter, *classes)
+          classes.each do |clazz|
+            instance_adapters[clazz.name.to_sym] = instance_adapter
+          end
+        end
+
+        # Find the best InstanceAdapter implementation that adapts the given
+        # class.  Starting with the class and then moving up the ancestor chain,
+        # looks for registered InstanceAdapter implementations.
+        #
+        # ==== Parameters
+        #
+        # clazz<Class>:: The class to find an InstanceAdapter for
+        #
+        # ==== Returns
+        #
+        # Class:: Subclass of InstanceAdapter, or nil if none found
+        #
+        # ==== Raises
+        #
+        # Sunspot::NoAdapterError:: If no adapter is registered for this class
+        #
+        def for(clazz) #:nodoc:
+          original_class_name = clazz.name
+          clazz.ancestors.each do |ancestor_class|
+            next if ancestor_class.name.nil? || ancestor_class.name.empty?
+            class_name = ancestor_class.name.to_sym
+            return instance_adapters[class_name] if instance_adapters[class_name]
+          end
+
+          raise(Sunspot::NoAdapterError,
+                "No adapter is configured for #{original_class_name} or its superclasses. See the documentation for Sunspot::Adapters")
+        end
+
+        def index_id_for(class_name, id) #:nodoc:
+          "#{class_name} #{id}"
+        end
+
+        protected
+
+        # Lazy-initialize the hash of registered instance adapters
+        #
+        # ==== Returns
+        #
+        # Hash:: Hash containing class names keyed to instance adapter classes
+        #
+        def instance_adapters #:nodoc:
+          @instance_adapters ||= {}
+        end
+      end
+    end
+
+    # Subclasses of the DataAccessor class take care of retreiving instances of
+    # the adapted class from (usually persistent) storage. Subclasses must
+    # implement the #load method, which takes an id (the value returned by
+    # InstanceAdapter#id, as a string), and returns the instance referenced by
+    # that ID. Optionally, it can also override the #load_all method, which
+    # takes an array of IDs and returns an array of instances in the order
+    # given. #load_all need only be implemented if it can be done more
+    # efficiently than simply iterating over the IDs and calling #load on each
+    # individually.
+    #
+    # ==== Example
+    #
+    #   class FileAccessor < Sunspot::Adapters::InstanceAdapter
+    #     def load(id)
+    #       @clazz.open(id)
+    #     end
+    #   end
+    #
+    #   Sunspot::Adapters::DataAccessor.register(FileAccessor, File)
+    #
+    class DataAccessor
+      def initialize(clazz) #:nodoc:
+        @clazz = clazz
+      end
+
+      # Subclasses can override this class to provide more efficient bulk
+      # loading of instances. Instances must be returned in the same order
+      # that the IDs were given.
+      #
+      # ==== Parameters
+      #
+      # ids<Array>:: collection of IDs
+      #
+      # ==== Returns
+      #
+      # Array:: collection of instances, in order of IDs given
+      #
+      def load_all(ids)
+        ids.map { |id| self.load(id) }
+      end
+
+      class <<self
+        # Create a DataAccessor for the given class, searching registered
+        # adapters for the best match. See InstanceAdapter#adapt for discussion
+        # of inheritence.
+        #
+        # ==== Parameters
+        #
+        # clazz<Class>:: Class to create DataAccessor for
+        #
+        # ==== Returns
+        #
+        # DataAccessor::
+        #   DataAccessor implementation which provides access to given class
+        #
+        def create(clazz) #:nodoc:
+          self.for(clazz).new(clazz)
+        end
+
+        # Register data accessor for a set of classes. When searching for
+        # an accessor for a given class, Sunspot starts with the class,
+        # and then searches for registered adapters up the class's ancestor
+        # chain.
+        #
+        # ==== Parameters
+        #
+        # data_accessor<Class>:: The data accessor class to register
+        # classes...<Class>::
+        #   One or more classes that this data accessor providess access to
+        #
+        def register(data_accessor, *classes)
+          classes.each do |clazz|
+            data_accessors[clazz.name.to_sym] = data_accessor
+          end
+        end
+
+        # Find the best DataAccessor implementation that adapts the given class.
+        # Starting with the class and then moving up the ancestor chain, looks
+        # for registered DataAccessor implementations.
+        #
+        # ==== Parameters
+        #
+        # clazz<Class>:: The class to find a DataAccessor for
+        #
+        # ==== Returns
+        #
+        # Class:: Implementation of DataAccessor
+        #
+        # ==== Raises
+        #
+        # Sunspot::NoAdapterError:: If no data accessor exists for the given class
+        #
+        def for(clazz) #:nodoc:
+          original_class_name = clazz.name
+          clazz.ancestors.each do |ancestor_class|
+            next if ancestor_class.name.nil? || ancestor_class.name.empty?
+            class_name = ancestor_class.name.to_sym
+            return data_accessors[class_name] if data_accessors[class_name]
+          end
+          raise(Sunspot::NoAdapterError,
+                "No data accessor is configured for #{original_class_name} or its superclasses. See the documentation for Sunspot::Adapters")
+        end
+
+        protected
+
+        # Lazy-initialize the hash of registered data accessors
+        #
+        # ==== Returns
+        #
+        # Hash:: Hash containing class names keyed to data accessor classes
+        #
+        def data_accessors #:nodoc:
+          @adapters ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/batcher.rb

@@ -0,0 +1,62 @@
+module Sunspot
+  #
+  # Keeps a stack of batches and helps out when Indexer is asked to batch documents.
+  #
+  # If the client does something like 
+  #   
+  #   Sunspot.batch do
+  #     some_code_here
+  #     which_triggers_some_other_code
+  #     which_again_calls
+  #     Sunspot.batch { ... }
+  #   end
+  #
+  # it is the Batcher's job to keep track of these nestings. The inner will
+  # be sent of to be indexed first.
+  #
+  class Batcher
+    include Enumerable
+
+    # Raised if you ask to end current, but no current exists
+    class NoCurrentBatchError < StandardError; end
+
+    def initialize
+      @stack = []
+    end
+
+    def current
+      @stack.last or start_new
+    end
+
+    def start_new
+      (@stack << []).last
+    end
+
+    def end_current
+      fail NoCurrentBatchError if @stack.empty?
+
+      @stack.pop
+    end
+
+    def depth
+      @stack.length
+    end
+
+    def batching?
+      depth > 0
+    end
+
+    def each(&block)
+      current.each(&block)
+    end
+
+    def push(value)
+      current << value
+    end
+    alias << push
+
+    def concat(values)
+      current.concat values
+    end
+  end
+end

data/lib/sunspot/class_set.rb

@@ -0,0 +1,23 @@
+module Sunspot
+  class ClassSet
+    include Enumerable
+
+    def initialize
+      @name_to_klass = {}
+    end
+
+    def <<(klass)
+      @name_to_klass[klass.name.to_sym] = klass
+      self
+    end
+    alias_method :add, :<<
+
+    def each(&block)
+      @name_to_klass.values.each(&block)
+    end
+
+    def empty?
+      @name_to_klass.empty?
+    end
+  end
+end

data/lib/sunspot/composite_setup.rb

@@ -0,0 +1,202 @@
+module Sunspot
+  # 
+  # The CompositeSetup class encapsulates a collection of setups, and responds
+  # to a subset of the methods that Setup responds to (in particular, the
+  # methods required to build queries).
+  #
+  class CompositeSetup #:nodoc:
+    class << self
+      alias_method :for, :new
+    end
+
+    def initialize(types)
+      @types = types
+    end
+
+    # 
+    # Collection of Setup objects for the enclosed types
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of Setup objects
+    #
+    def setups
+      @setups ||= @types.map { |type| Setup.for(type) }
+    end
+
+    # 
+    # Return the names of the encapsulated types
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of class names
+    #
+    def type_names
+      @type_names ||= @types.map { |clazz| clazz.name }
+    end
+
+    # 
+    # Get a text field object by its public name. A field will be returned if
+    # it is configured for any of the enclosed types.
+    #
+    # ==== Returns
+    #
+    # Sunspot::FulltextField:: Text field with the given public name
+    #
+    # ==== Raises
+    #
+    # UnrecognizedFieldError::
+    #   If no field with that name is configured for any of the enclosed types.
+    #
+    def text_fields(field_name)
+      if text_fields = text_fields_hash[field_name.to_sym]
+        text_fields.to_a
+      else
+        raise(
+          UnrecognizedFieldError,
+          "No text field configured for #{@types * ', '} with name '#{field_name}'"
+        )
+      end
+    end
+
+    # 
+    # Get a Sunspot::AttributeField instance corresponding to the given field name
+    #
+    # ==== Parameters
+    #
+    # field_name<Symbol>:: The public field name for which to find a field
+    #
+    # ==== Returns
+    #
+    # Sunspot::AttributeField The field object corresponding to the given name
+    #
+    # ==== Raises
+    #
+    # ArgumentError::
+    #   If the given field name is not configured for the types being queried
+    #
+    def field(field_name) #:nodoc:
+      fields_hash[field_name.to_sym] || raise(
+        UnrecognizedFieldError,
+        "No field configured for #{@types * ', '} with name '#{field_name}'"
+      )
+    end
+
+    # 
+    # Get a dynamic field factory for the given base name.
+    #
+    # ==== Returns
+    #
+    # DynamicFieldFactory:: Factory for dynamic fields with the given base name
+    #
+    # ==== Raises
+    #
+    # UnrecognizedFieldError::
+    #   If the given base name is not configured as a dynamic field for the types being queried
+    #
+    def dynamic_field_factory(field_name)
+      dynamic_field_factories_hash[field_name.to_sym] || raise(
+        UnrecognizedFieldError,
+        "No dynamic field configured for #{@types * ', '} with name #{field_name.inspect}"
+      )
+    end
+
+    # 
+    # Collection of all text fields configured for any of the enclosed types.
+    #
+    # === Returns
+    #
+    # Array:: Text fields configured for the enclosed types
+    #
+    def all_text_fields
+      @text_fields ||= text_fields_hash.values.map { |set| set.to_a }.flatten
+    end
+
+    def all_more_like_this_fields
+      @more_like_this_fields ||= more_like_this_fields_hash.values.map { |set| set.to_a }.flatten
+    end
+
+    private
+
+    # 
+    # Return a hash of field names to text field objects, containing all fields
+    # that are configured for any of the types enclosed.
+    #
+    # ==== Returns
+    #
+    # Hash:: Hash of field names to text field objects.
+    #
+    def text_fields_hash
+      @text_fields_hash ||=
+        setups.inject({}) do |hash, setup|
+          setup.all_text_fields.each do |text_field|
+            (hash[text_field.name] ||= Set.new) << text_field
+          end
+          hash
+        end
+    end
+
+    def more_like_this_fields_hash
+      @more_like_this_fields_hash ||=
+        setups.inject({}) do |hash, setup|
+          setup.all_more_like_this_fields.each do |more_like_this_field|
+            (hash[more_like_this_field.name] ||= Set.new) << more_like_this_field
+          end
+          hash
+        end
+    end
+
+    # 
+    # Return a hash of field names to field objects, containing all fields
+    # that are common to all of the classes enclosed. In order for fields
+    # to be common, they must be of the same type and have the same
+    # value for allow_multiple? and stored?. This method is memoized.
+    #
+    # ==== Returns
+    #
+    # Hash:: field names keyed to field objects
+    #
+    def fields_hash
+      @fields_hash ||=
+        begin
+          field_sets_hash = Hash.new { |h, k| h[k] = Set.new }
+          @types.each do |type|
+            Setup.for(type).fields.each do |field|
+              field_sets_hash[field.name.to_sym] << field
+            end
+          end
+          fields_hash = {}
+          field_sets_hash.each_pair do |field_name, set|
+            if set.length == 1
+              fields_hash[field_name] = set.to_a.first
+            end
+          end
+          fields_hash
+        end
+    end
+
+    # 
+    # Return a hash of dynamic field base names to dynamic field factories for
+    # those base names. Criteria for the inclusion are the same as for
+    # #fields_hash()
+    #
+    def dynamic_field_factories_hash
+      @dynamic_field_factories_hash ||=
+        begin
+          dynamic_field_factories_hash = @types.inject({}) do |hash, type|
+            Setup.for(type).dynamic_field_factories.each do |field_factory|
+              (hash[field_factory.name.to_sym] ||= {})[type.name] = field_factory
+            end
+            hash
+          end
+          dynamic_field_factories_hash.each_pair do |field_name, field_configurations_hash|
+            if @types.any? { |type| field_configurations_hash[type.name].nil? }
+              dynamic_field_factories_hash.delete(field_name)
+            else
+              dynamic_field_factories_hash[field_name] = field_configurations_hash.values.first
+            end
+          end
+        end
+    end
+  end
+end