sunspot 0.9.7

data/lib/sunspot/indexer.rb

@@ -0,0 +1,123 @@
+module Sunspot
+  # 
+  # This class presents a service for adding, updating, and removing data
+  # from the Solr index. An Indexer instance is associated with a particular
+  # setup, and thus is capable of indexing instances of a certain class (and its
+  # subclasses).
+  #
+  class Indexer #:nodoc:
+    include RSolr::Char
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # 
+    # Construct a representation of the model for indexing and send it to the
+    # connection for indexing
+    #
+    # ==== Parameters
+    #
+    # model<Object>:: the model to index
+    #
+    def add(model)
+      documents = Array(model).map { |m| prepare(m) }
+      if @batch.nil?
+        add_documents(documents)
+      else
+        @batch.concat(documents)
+      end
+    end
+
+    # 
+    # Remove the given model from the Solr index
+    #
+    def remove(model)
+      @connection.delete_by_id(Adapters::InstanceAdapter.adapt(model).index_id)
+    end
+
+    def remove_by_id(class_name, id)
+      @connection.delete_by_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)
+      @connection.delete_by_query("type:#{escape(clazz.name)}")
+    end
+
+    def start_batch
+      @batch = []
+    end
+
+    def flush_batch
+      add_documents(@batch)
+      @batch = nil
+    end
+
+    private
+
+    # 
+    # Convert documents into hash of indexed properties
+    #
+    def prepare(model)
+      document = document_for(model)
+      setup = setup_for(model)
+      if boost = setup.document_boost_for(model)
+        document.attrs[:boost] = boost
+      end
+      for field_factory in setup.all_field_factories
+        field_factory.populate_document(document, model)
+      end
+      document
+    end
+
+    def add_documents(documents)
+      @connection.add(documents)
+    end
+
+    # 
+    # All indexed documents index and store the +id+ and +type+ fields.
+    # This method constructs the document hash containing those key-value
+    # pairs.
+    #
+    def document_for(model)
+      RSolr::Message::Document.new(
+        :id => Adapters::InstanceAdapter.adapt(model).index_id,
+        :type => Util.superclasses_for(model.class).map { |clazz| clazz.name }
+      )
+    end
+
+    # 
+    # Get the Setup object for the given object's class.
+    #
+    # ==== Parameters
+    #
+    # object<Object>:: The object whose setup is to be retrieved
+    #
+    # ==== Returns
+    #
+    # 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}")
+    end
+
+
+    class <<self
+      # 
+      # Delete all documents from the Solr index
+      #
+      # ==== Parameters
+      #
+      # connection<Solr::Connection>::
+      #   connection to which to send the delete request
+      def remove_all(connection)
+        connection.delete_by_query("type:[* TO *]")
+      end
+    end
+  end
+end

data/lib/sunspot/instantiated_facet.rb

@@ -0,0 +1,42 @@
+module Sunspot
+  #
+  # InstantiatedFacet instances allow access to a model instance based on a
+  # primary key stored in facet rows' values. The rows are hydrated lazily, but
+  # all rows are hydrated the first time #instance is called on any of the rows.
+  #
+  # The #rows method returns InstantiatedFacetRow objects.
+  #
+  class InstantiatedFacet < Facet
+    # 
+    # Hydrate all rows for the facet. For data accessors that can efficiently
+    # batch load, this is more efficient than individually lazy-loading
+    # instances for each row, but allows us to still stay lazy and not do work
+    # in the persistent store if the instances are not needed.
+    #
+    def populate_instances! #:nodoc:
+      ids = rows.map { |row| row.value }
+      reference_class = Sunspot::Util.full_const_get(@facet_data.reference.to_s)
+      accessor = Adapters::DataAccessor.create(reference_class)
+      instance_map = accessor.load_all(ids).inject({}) do |map, instance|
+        map[Adapters::InstanceAdapter.adapt(instance).id] = instance
+        map
+      end
+      for row in rows
+        row.instance = instance_map[row.value]
+      end
+    end
+
+    def rows
+      @facet_data.rows { |value, count| InstantiatedFacetRow.new(value, count, self) }
+    end
+
+    private
+
+    # 
+    # Override the Facet#new_row method to return an InstantiateFacetRow
+    #
+    def new_row(pair)
+      InstantiatedFacetRow.new(pair, self)
+    end
+  end
+end

data/lib/sunspot/instantiated_facet_row.rb

@@ -0,0 +1,22 @@
+module Sunspot
+  class InstantiatedFacetRow < FacetRow
+    attr_writer :instance
+
+    def initialize(value, count, facet)
+      super(value, count)
+      @facet = facet
+    end
+
+    #
+    # Get the persistent object referenced by this row's value. Instances are
+    # batch-lazy-loaded, which means that for a given facet, all of the
+    # instances are loaded the first time any row's instance is requested.
+    #
+    def instance
+      unless defined?(@instance)
+        @facet.populate_instances!
+      end
+      @instance
+    end
+  end
+end

data/lib/sunspot/query.rb

@@ -0,0 +1,191 @@
+%w(base_query scope field_query connective dynamic_query field_facet query_facet
+   query_facet_row query_field_facet pagination restriction sort
+   sort_composite).each do |file|
+  require File.join(File.dirname(__FILE__), 'query', file)
+end
+
+module Sunspot
+  module Query #:nodoc:
+    # 
+    # This class encapsulates a query that is to be sent to Solr. The query is
+    # constructed in the block passed to the Sunspot.search method, using the
+    # Sunspot::DSL::Query interface. It can also be accessed directly by calling
+    # #query on a Search object (presumably a not-yet-run one created using
+    # Sunspot#new_search), which might be more suitable than the DSL when an
+    # intermediate object has responsibility for building the query dynamically.
+    #--
+    # Instances of Query, as well as all of the components it contains, respond to
+    # the #to_params method, which returns a hash of parameters in the format
+    # recognized by the solr-ruby API.
+    #
+    class Query < FieldQuery
+      attr_reader :query_facets #:nodoc:
+
+      def initialize(types, setup, configuration) #:nodoc:
+        @setup = setup
+        @components = []
+        @query_facets = {}
+        @components << @base_query = BaseQuery.new(types, setup)
+        @components << @pagination = Pagination.new(configuration)
+        @components << @sort = SortComposite.new
+      end
+
+      # 
+      # Set the keywords for this query. Keywords are parsed with Solr's dismax
+      # handler.
+      #
+      def keywords=(keywords)
+        set_keywords(keywords)
+      end
+
+      # 
+      # Add a component to the query. Used by objects that proxy to the query
+      # object.
+      # 
+      # ==== Parameters
+      # 
+      # component<~to_params>:: Query component to add.
+      # 
+      def add_component(component) #:nodoc:
+        @components << component
+      end
+
+      #
+      # Sets @start and @rows instance variables using pagination semantics
+      #
+      # ==== Parameters
+      #
+      # page<Integer>:: Page on which to start
+      # per_page<Integer>::
+      #   How many rows to display per page. Default taken from
+      #   Sunspot.config.pagination.default_per_page
+      #
+      def paginate(page, per_page = nil)
+        @pagination.page, @pagination.per_page = page, per_page
+      end
+
+      # 
+      # Add random ordering to the search. This can be added after other
+      # field-based sorts if desired.
+      #
+      def order_by_random
+        add_sort(Sort.new(RandomField.new))
+      end
+
+      # 
+      # Representation of this query as solr-ruby parameters. Constructs the hash
+      # by deep-merging scope and facet parameters, adding in various other
+      # parameters from instance data.
+      #
+      # Note that solr-ruby takes the :q parameter as a separate argument; for
+      # the sake of consistency, the Query object ignores this fact (the Search
+      # object extracts it back out).
+      #
+      # ==== Returns
+      #
+      # Hash:: Representation of query in solr-ruby form
+      #
+      def to_params #:nodoc:
+        params = {}
+        query_components = []
+        for component in @components
+          Util.deep_merge!(params, component.to_params)
+        end
+        params
+      end
+
+      # 
+      # Page that this query will return (used by Sunspot::Search to expose
+      # pagination)
+      #
+      # ==== Returns
+      #
+      # Integer:: Page number
+      #
+      def page #:nodoc:
+        @pagination.page
+      end
+
+      #
+      # Number of rows per page that this query will return (used by
+      # Sunspot::Search to expose pagination)
+      #
+      # ==== Returns
+      #
+      # Integer:: Rows per page
+      #
+      def per_page #:nodoc:
+        @pagination.per_page
+      end
+
+      # 
+      # Get the query facet with the given name. Used by the Search object to
+      # match query facet results with the requested query facets.
+      #
+      def query_facet(name) #:nodoc:
+        @query_facets[name.to_sym]
+      end
+
+      # 
+      # Add a Sort object into this query's sort composite.
+      #
+      def add_sort(sort) #:nodoc:
+        @sort << sort
+      end
+
+      # 
+      # Set the keywords for this query, along with keyword options. See
+      # Query::BaseQuery for information on what the options do.
+      #
+      def set_keywords(keywords, options = {}) #:nodoc:
+        @base_query.keywords = keywords
+        @base_query.keyword_options = options
+      end
+
+      # 
+      # Pass in search options as a hash. This is not the preferred way of
+      # building a Sunspot search, but it is made available as experience shows
+      # Ruby developers like to pass in hashes. Probably nice for quick one-offs
+      # on the console, anyway.
+      #
+      # ==== Options (+options+)
+      #
+      # :keywords:: Keyword string for fulltext search
+      # :conditions::
+      #   Hash of key-value pairs, where keys are field names, and values are one
+      #   of scalar, Array, or Range. Scalars are evaluated as EqualTo
+      #   restrictions; Arrays are AnyOf restrictions, and Ranges are Between
+      #   restrictions.
+      # :order::
+      #   Order the search results. Either a string or array of strings of the
+      #   form "field_name direction"
+      # :page::
+      #   Page to use for pagination
+      # :per_page::
+      #   Number of results to show per page
+      #
+      def options=(options) #:nodoc:
+        if options.has_key?(:keywords)
+          self.keywords = options[:keywords]
+        end
+        if options.has_key?(:conditions)
+          options[:conditions].each_pair do |field_name, value|
+            begin
+              add_shorthand_restriction(field_name, value)
+            rescue UnrecognizedFieldError
+              # ignore fields we don't recognize
+            end
+          end
+        end
+        if options.has_key?(:order)
+          for order in Array(options[:order])
+            order_by(*order.split(' '))
+          end
+        end
+        if options.has_key?(:page)
+          paginate(options[:page], options[:per_page])
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/base_query.rb

@@ -0,0 +1,90 @@
+module Sunspot
+  module Query
+    #
+    # Encapsulates information common to all queries - in particular, keywords
+    # and types.
+    #
+    class BaseQuery #:nodoc:
+      include RSolr::Char
+
+      attr_writer :keywords
+
+      def initialize(types, setup)
+        @types, @setup = types, setup
+      end
+
+      # 
+      # Generate params for the base query. If keywords are specified, build
+      # params for a dismax query, request all stored fields plus the score,
+      # and put the types in a filter query. If keywords are not specified,
+      # put the types query in the q parameter.
+      #
+      def to_params
+        params = {}
+        if @keywords
+          params[:q] = @keywords
+          params[:fl] = '* score'
+          params[:fq] = types_phrase
+          params[:qf] = text_field_names.join(' ')
+          params[:defType] = 'dismax'
+        else
+          params[:q] = types_phrase
+        end
+        params
+      end
+
+      # 
+      # Set keyword options
+      #
+      def keyword_options=(options)
+        if options
+          @text_field_names = options.delete(:fields)
+        end
+      end
+
+      private
+
+      # 
+      # Boolean phrase that restricts results to objects of the type(s) under
+      # query. If this is an open query (no types specified) then it sends a
+      # no-op phrase because Solr requires that the :q parameter not be empty.
+      #
+      # ==== Returns
+      #
+      # String:: Boolean phrase for type restriction
+      #
+      def types_phrase
+        if escaped_types.length == 1 then "type:#{escaped_types.first}"
+        else "type:(#{escaped_types * ' OR '})"
+        end
+      end
+
+      #
+      # Wraps each type in quotes to escape names of the form Namespace::Class
+      #
+      def escaped_types
+        @escaped_types ||=
+          @types.map { |type| escape(type.name)}
+      end
+
+      # 
+      # Returns the names of text fields that should be queried in a keyword
+      # search. If specific fields are requested, use those; otherwise use the
+      # union of all fields configured for the types under search.
+      #
+      def text_field_names
+        text_fields =
+          if @text_field_names
+            Array(@text_field_names).map do |field_name|
+              @setup.text_field(field_name.to_sym)
+            end
+          else
+            @setup.text_fields
+          end
+        text_fields.map do |text_field|
+          text_field.indexed_name
+        end
+      end
+    end
+  end
+end