gojee-sunspot 2.0.2 → 2.0.3

data/lib/sunspot/adapters.rb

@@ -1,265 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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