UnderpantsGnome-sunspot 0.9.1.1

data/lib/sunspot/search.rb

@@ -0,0 +1,222 @@
+require File.join(File.dirname(__FILE__), 'search', 'hit')
+
+module Sunspot
+  # 
+  # This class encapsulates the results of a Solr search. It provides access
+  # to search results, total result count, facets, and pagination information.
+  # Instances of Search are returned by the Sunspot.search and
+  # Sunspot.new_search methods.
+  #
+  class Search
+    # Query information for this search. If you wish to build the query without
+    # using the search DSL, this method allows you to access the query API
+    # directly. See Sunspot#new_search for how to construct the search object
+    # in this case.
+    attr_reader :query 
+
+    def initialize(connection, setup, query) #:nodoc:
+      @connection, @setup, @query = connection, setup, query
+    end
+
+    #
+    # Execute the search on the Solr instance and store the results. If you
+    # use Sunspot#search() to construct your searches, there is no need to call
+    # this method as it has already been called. If you use
+    # Sunspot#new_search(), you will need to call this method after building the
+    # query.
+    #
+    def execute!
+      params = @query.to_params
+      @solr_result = @connection.select(params)
+      self
+    end
+
+    # 
+    # Get the collection of results as instantiated objects. If WillPaginate is
+    # available, the results will be a WillPaginate::Collection instance; if
+    # not, it will be a vanilla Array.
+    #
+    # ==== Returns
+    #
+    # WillPaginate::Collection or Array:: Instantiated result objects
+    #
+    def results
+      @results ||= if @query.page && defined?(WillPaginate::Collection)
+        WillPaginate::Collection.create(@query.page, @query.per_page, total) do |pager|
+          pager.replace(hits.map { |hit| hit.instance })
+        end
+      else
+        hits.map { |hit| hit.instance }
+      end
+    end
+
+    # 
+    # Access raw Solr result information. Returns a collection of Hit objects
+    # that contain the class name, primary key, keyword relevance score (if
+    # applicable), and any stored fields.
+    #
+    # ==== Returns
+    #
+    # Array:: Ordered collection of Hit objects
+    #
+    def hits
+      @hits ||= solr_response['docs'].map { |doc| Hit.new(doc, self) }
+    end
+    alias_method :raw_results, :hits
+
+    # 
+    # The total number of documents matching the query parameters
+    #
+    # ==== Returns
+    #
+    # Integer:: Total matching documents
+    #
+    def total
+      @total ||= solr_response['numFound']
+    end
+
+    # 
+    # Get the facet object for the given field. This field will need to have
+    # been requested as a field facet inside the search block.
+    #
+    # ==== Parameters
+    #
+    # field_name<Symbol>:: field name for which to get the facet
+    #
+    # ==== Returns
+    #
+    # Sunspot::Facet:: Facet object for the given field
+    #
+    def facet(field_name)
+      (@facets_cache ||= {})[field_name.to_sym] ||=
+        begin
+          query_facet(field_name) ||
+            begin
+              field = field(field_name)
+              date_facet(field) ||
+                begin
+                  facet_class = field.reference ? InstantiatedFacet : Facet
+                  facet_class.new(@solr_result['facet_counts']['facet_fields'][field.indexed_name], field)
+                end
+            end
+        end
+    end
+
+    # 
+    # Get the facet object for a given dynamic field. This dynamic field will
+    # need to have been requested as a field facet inside the search block.
+    #
+    # ==== Parameters
+    #
+    # base_name<Symbol>::
+    #   Base name of the dynamic field definiton (as specified in the setup
+    #   block)
+    # dynamic_name<Symbol>::
+    #   Dynamic field name to facet on
+    # 
+    # ==== Returns
+    #
+    # Sunspot::Facet:: Facet object for given dynamic field
+    # 
+    # ==== Example
+    #
+    #   search = Sunspot.search(Post) do
+    #     dynamic :custom do
+    #       facet :cuisine
+    #     end
+    #   end
+    #   search.dynamic_facet(:custom, :cuisine)
+    #     #=> Facet for the dynamic field :cuisine in the :custom field definition
+    # 
+    def dynamic_facet(base_name, dynamic_name)
+      (@dynamic_facets_cache ||= {})[[base_name.to_sym, dynamic_name.to_sym]] ||=
+        begin
+          field = @setup.dynamic_field_factory(base_name).build(dynamic_name)
+          Facet.new(@solr_result['facet_counts']['facet_fields'][field.indexed_name], field)
+        end
+    end
+
+    # 
+    # Get the data accessor that will be used to load a particular class out of
+    # persistent storage. Data accessors can implement any methods that may be
+    # useful for refining how data is loaded out of storage. When building a
+    # search manually (e.g., using the Sunspot#new_search method), this should
+    # be used before calling #execute(). Use the
+    # Sunspot::DSL::Search#data_accessor_for method when building searches using
+    # the block DSL.
+    #
+    def data_accessor_for(clazz)
+      (@data_accessors ||= {})[clazz.name.to_sym] ||=
+        Adapters::DataAccessor.create(clazz)
+    end
+
+    # 
+    # Build this search using a DSL block.
+    #
+    def build(&block) #:nodoc:
+      Util.instance_eval_or_call(dsl, &block)
+      self
+    end
+
+    def populate_hits! #:nodoc:
+      type_hit_hash = Hash.new { |h, k| h[k] = [] }
+      id_hit_hash = {}
+      for hit in hits
+        type_hit_hash[hit.class_name] << hit
+        id_hit_hash[hit.primary_key] = hit
+      end
+      type_hit_hash.each_pair do |class_name, hits|
+        ids = hits.map { |hit| hit.primary_key }
+        for instance in data_accessor_for(Util.full_const_get(class_name)).load_all(ids)
+          hit = id_hit_hash[Adapters::InstanceAdapter.adapt(instance).id.to_s]
+          hit.instance = instance
+        end
+      end
+    end
+
+    private
+
+    def solr_response
+      @solr_response ||= @solr_result['response']
+    end
+
+    def doc_ids
+      @doc_ids ||= solr_response['docs'].map { |doc| doc['id'] }
+    end
+
+    def dsl
+      DSL::Search.new(self)
+    end
+
+    def raw_facet(field)
+      if field.type == Type::TimeType
+        @solr_result['facet_counts']['facet_dates'][field.indexed_name]
+      end || @solr_result['facet_counts']['facet_fields'][field.indexed_name]
+    end
+
+    def date_facet(field)
+      if field.type == Type::TimeType
+        if @solr_result['facet_counts'].has_key?('facet_dates')
+          if facet_result = @solr_result['facet_counts']['facet_dates'][field.indexed_name]
+            DateFacet.new(facet_result, field)
+          end
+        end
+      end
+    end
+
+    def query_facet(name)
+      if query_facet = @query.query_facet(name.to_sym)
+        if @solr_result['facet_counts'].has_key?('facet_queries')
+          QueryFacet.new(
+            query_facet,
+            @solr_result['facet_counts']['facet_queries']
+          )
+        end
+      end
+    end
+
+    def field(name)
+      @setup.field(name)
+    end
+  end
+end

data/lib/sunspot/search/hit.rb

@@ -0,0 +1,62 @@
+module Sunspot
+  class Search
+    class Hit
+      SPECIAL_KEYS = Set.new(%w(id type score)) #:nodoc:
+
+      # 
+      # Primary key of object associated with this hit, as string.
+      #
+      attr_reader :primary_key
+      # 
+      # Class name of object associated with this hit, as string.
+      #
+      attr_reader :class_name
+      # 
+      # Keyword relevance score associated with this result. Nil if this hit
+      # is not from a keyword search.
+      #
+      attr_reader :score
+
+      attr_writer :instance #:nodoc:
+
+      def initialize(raw_hit, search) #:nodoc:
+        @class_name, @primary_key = *raw_hit['id'].match(/([^ ]+) (.+)/)[1..2]
+        @score = raw_hit['score']
+        @search = search
+        @stored_values = raw_hit
+        @stored_cache = {}
+      end
+
+      # 
+      # Retrieve stored field value. For any attribute field configured with
+      # :stored => true, the Hit object will contain the stored value for
+      # that field. The value of this field will be typecast according to the
+      # type of the field.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>::
+      #   The name of the field for which to retrieve the stored value.
+      #
+      def stored(field_name)
+        @stored_cache[field_name.to_sym] ||=
+          begin
+            field = Sunspot::Setup.for(@class_name).field(field_name)
+            field.cast(@stored_values[field.indexed_name])
+          end
+      end
+
+      # 
+      # Retrieve the instance associated with this hit. This is lazy-loaded, but
+      # the first time it is called on any hit, all the hits for the search will
+      # load their instances using the adapter's #load_all method.
+      #
+      def instance
+        if @instance.nil?
+          @search.populate_hits!
+        end
+        @instance
+      end
+    end
+  end
+end

data/lib/sunspot/session.rb

@@ -0,0 +1,201 @@
+module Sunspot
+  # 
+  # A Sunspot session encapsulates a connection to Solr and a set of
+  # configuration choices. Though users of Sunspot may manually instantiate
+  # Session objects, in the general case it's easier to use the singleton
+  # stored in the Sunspot module. Since the Sunspot module provides all of
+  # the instance methods of Session as class methods, they are not documented
+  # again here.
+  #
+  class Session
+    class <<self
+      attr_writer :connection_class #:nodoc:
+      
+      # 
+      # For testing purposes
+      #
+      def connection_class #:nodoc:
+        @connection_class ||= RSolr::Connection
+      end
+    end
+
+    # 
+    # Sunspot::Configuration object for this session
+    #
+    attr_reader :config
+
+    # 
+    # Sessions are initialized with a Sunspot configuration and a Solr
+    # connection. Usually you will want to stick with the default arguments
+    # when instantiating your own sessions.
+    #
+    def initialize(config = Configuration.build, connection = nil)
+      @config = config
+      yield(@config) if block_given?
+      @connection = connection
+      @updates = 0
+    end
+
+    # 
+    # See Sunspot.new_search
+    #
+    def new_search(*types)
+      types.flatten!
+      setup =
+        if types.length == 1
+          Setup.for(types.first)
+        else
+          CompositeSetup.for(types)
+        end
+      Search.new(connection, setup, Query::Query.new(setup, @config))
+    end
+
+    #
+    # See Sunspot.search
+    #
+    def search(*types, &block)
+      options = types.last.is_a?(Hash) ? types.pop : {}
+      search = new_search(*types)
+      search.build(&block) if block
+      search.query.options = options
+      search.execute!
+    end
+
+    #
+    # See Sunspot.index
+    #
+    def index(*objects)
+      objects.flatten!
+      @updates += objects.length
+      indexer.add(objects)
+    end
+
+    # 
+    # See Sunspot.index!
+    #
+    def index!(*objects)
+      index(*objects)
+      commit
+    end
+
+    #
+    # See Sunspot.commit
+    #
+    def commit
+      @updates = 0
+      connection.commit
+    end
+
+    # 
+    # See Sunspot.remove
+    #
+    def remove(*objects)
+      objects.flatten!
+      @updates += objects.length
+      for object in objects
+        indexer.remove(object)
+      end
+    end
+
+    # 
+    # See Sunspot.remove!
+    #
+    def remove!(*objects)
+      remove(*objects)
+      commit
+    end
+
+    # 
+    # See Sunspot.remove_by_id
+    #
+    def remove_by_id(clazz, id)
+      class_name =
+        if clazz.is_a?(Class)
+          clazz.name
+        else
+          clazz.to_s
+        end
+      indexer.remove_by_id(class_name, id)
+    end
+
+    # 
+    # See Sunspot.remove_by_id!
+    #
+    def remove_by_id!(clazz, id)
+      remove_by_id(clazz, id)
+      commit
+    end
+
+    #
+    # See Sunspot.remove_all
+    #
+    def remove_all(*classes)
+      classes.flatten!
+      if classes.empty?
+        @updates += 1
+        Indexer.remove_all(connection)
+      else
+        @updates += classes.length
+        for clazz in classes
+          indexer.remove_all(clazz)
+        end
+      end
+    end
+
+    # 
+    # See Sunspot.remove_all!
+    #
+    def remove_all!(*classes)
+      remove_all(*classes)
+      commit
+    end
+
+    # 
+    # See Sunspot.dirty?
+    #
+    def dirty?
+      @updates > 0
+    end
+
+    # 
+    # See Sunspot.commit_if_dirty
+    #
+    def commit_if_dirty
+      commit if dirty?
+    end
+
+    # 
+    # See Sunspot.batch
+    #
+    def batch
+      indexer.start_batch
+      yield
+      indexer.flush_batch
+    end
+
+    private
+
+    # 
+    # Retrieve the Solr connection for this session, creating one if it does not
+    # already exist.
+    #
+    # ==== Returns
+    #
+    # Solr::Connection:: The connection for this session
+    #
+    def connection
+      @connection ||=
+        begin
+          connection = self.class.connection_class.new(
+            RSolr::Adapter::HTTP.new(:url => config.solr.url)
+          )
+          connection.adapter.connector.adapter_name = config.http_client
+          connection
+        end
+    end
+
+    def indexer
+      @indexer ||= Indexer.new(connection)
+    end
+  end
+end