outoftime-sunspot 0.8.9 → 0.9.0

data/lib/sunspot/schema.rb

@@ -0,0 +1,165 @@
+using_rubygems = false
+begin
+  require 'haml'
+rescue LoadError => e
+  if using_rubygems
+    raise(e)
+  else
+    using_rubygems = true
+    require 'rubygems'
+    retry
+  end
+end
+
+module Sunspot
+  # 
+  # Object that encapsulates schema information for building a Solr schema.xml
+  # file. This class is used by the schema:compile task as well as the
+  # sunspot-configure-solr executable.
+  #
+  class Schema #:nodoc:all
+    FieldType = Struct.new(:name, :class_name, :suffix)
+    FieldVariant = Struct.new(:attribute, :suffix)
+
+    DEFAULT_TOKENIZER = 'solr.StandardTokenizerFactory'
+    DEFAULT_FILTERS = %w(solr.StandardFilterFactory solr.LowerCaseFilterFactory)
+
+    FIELD_TYPES = [
+      FieldType.new('boolean', 'Bool', 'b'),
+      FieldType.new('sfloat', 'SortableFloat', 'f'),
+      FieldType.new('date', 'Date', 'd'),
+      FieldType.new('sint', 'SortableInt', 'i'),
+      FieldType.new('string', 'Str', 's')
+    ]
+
+    FIELD_VARIANTS = [
+      FieldVariant.new('multiValued', 'm'),
+      FieldVariant.new('stored', 's')
+    ]
+
+    attr_reader :tokenizer, :filters
+
+    def initialize
+      @tokenizer = DEFAULT_TOKENIZER
+      @filters = DEFAULT_FILTERS.dup
+    end
+
+    # 
+    # Attribute field types defined in the schema
+    #
+    def types
+      FIELD_TYPES
+    end
+
+    # 
+    # DynamicField instances representing all the available types and variants
+    #
+    def dynamic_fields
+      fields = []
+      for field_variants in variant_combinations
+        for type in FIELD_TYPES
+          fields << DynamicField.new(type, field_variants)
+        end
+      end
+      fields
+    end
+
+    # 
+    # Which tokenizer to use for text fields
+    #
+    def tokenizer=(tokenizer)
+      @tokenizer = 
+        if tokenizer =~ /\./
+          tokenizer
+        else
+          "solr.#{tokenizer}TokenizerFactory"
+        end
+    end
+
+    # 
+    # Add a filter for text field tokenization
+    #
+    def add_filter(filter)
+      @filters <<
+        if filter =~ /\./
+          filter
+        else
+          "solr.#{filter}FilterFactory"
+        end
+    end
+
+    # 
+    # Return an XML representation of this schema using the Haml template
+    #
+    def to_xml
+      template = File.read(
+        File.join(
+          File.dirname(__FILE__),
+          '..',
+          '..',
+          'templates',
+          'schema.xml.haml'
+        )
+      )
+      engine = Haml::Engine.new(template)
+      engine.render(Object.new, :schema => self)
+    end
+
+    private
+
+    #
+    # All of the possible combinations of variants
+    #
+    def variant_combinations
+      combinations = []
+      0.upto(2 ** FIELD_VARIANTS.length - 1) do |b|
+        combinations << combination = []
+        FIELD_VARIANTS.each_with_index do |variant, i|
+          combination << variant if b & 1<<i > 0
+        end
+      end
+      combinations
+    end
+
+    # 
+    # Represents a dynamic field (in the Solr schema sense, not the Sunspot
+    # sense).
+    #
+    class DynamicField
+      def initialize(type, field_variants)
+        @type, @field_variants = type, field_variants
+      end
+
+      # 
+      # Name of the field in the schema
+      #
+      def name
+        variant_suffixes = @field_variants.map { |variant| variant.suffix }.join
+        "*_#{@type.suffix}#{variant_suffixes}"
+      end
+
+      # 
+      # Name of the type as defined in the schema
+      #
+      def type
+        @type.name
+      end
+
+      # 
+      # Implement magic methods to ask if a field is of a particular variant.
+      # Returns "true" if the field is of that variant and "false" otherwise.
+      #
+      def method_missing(name, *args, &block)
+        if name.to_s =~ /\?$/ && args.empty?
+          if @field_variants.any? { |variant| "#{variant.attribute}?" == name.to_s }
+            'true'
+          else
+            'false'
+          end
+        else
+          super(name.to_sym, *args, &block)
+        end
+      end
+    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/search.rb

@@ -1,22 +1,21 @@
+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 method.
+  # Instances of Search are returned by the Sunspot.search and
+  # Sunspot.new_search methods.
   #
   class Search
-    # Objects of this class are returned by the #raw_results method.
-    RawResult = Struct.new(:class_name, :primary_key)
-
     # 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, query) #:nodoc:
-      @connection = connection
-      @query = query
+    def initialize(connection, setup, query) #:nodoc:
+      @connection, @setup, @query = connection, setup, query
     end
 
     #
@@ -28,7 +27,7 @@ module Sunspot
     #
     def execute!
       params = @query.to_params
-      @solr_result = @connection.query(params.delete(:q), params)
+      @solr_result = @connection.select(params)
       self
     end
 
@@ -43,27 +42,27 @@ module Sunspot
     #
     def results
       @results ||= if @query.page && defined?(WillPaginate::Collection)
-        WillPaginate::Collection.create(@query.page, @query.per_page, @solr_result.total_hits) do |pager|
-          pager.replace(result_objects)
+        WillPaginate::Collection.create(@query.page, @query.per_page, total) do |pager|
+          pager.replace(hits.map { |hit| hit.instance })
         end
       else
-        result_objects
+        hits.map { |hit| hit.instance }
       end
     end
 
     # 
-    # Access raw results without instantiating objects from persistent storage.
-    # This may be useful if you are using search as an intermediate step in data
-    # retrieval. Returns an ordered collection of objects that respond to
-    # #class_name and #primary_key
+    # 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 raw results
+    # Array:: Ordered collection of Hit objects
     #
-    def raw_results
-      @raw_results ||= hit_ids.map { |hit_id| RawResult.new(*hit_id.match(/([^ ]+) (.+)/)[1..2]) }
+    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
@@ -73,7 +72,7 @@ module Sunspot
     # Integer:: Total matching documents
     #
     def total
-      @total ||= @solr_result.total_hits
+      @total ||= solr_response['numFound']
     end
 
     # 
@@ -91,8 +90,15 @@ module Sunspot
     def facet(field_name)
       (@facets_cache ||= {})[field_name.to_sym] ||=
         begin
-          field = @query.field(field_name)
-          Facet.new(@solr_result.field_facets(field.indexed_name), field)
+          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
 
@@ -125,35 +131,92 @@ module Sunspot
     def dynamic_facet(base_name, dynamic_name)
       (@dynamic_facets_cache ||= {})[[base_name.to_sym, dynamic_name.to_sym]] ||=
         begin
-          field = @query.dynamic_field(base_name).build(dynamic_name)
-          Facet.new(@solr_result.field_facets(field.indexed_name), field)
+          field = @setup.dynamic_field_factory(base_name).build(dynamic_name)
+          Facet.new(@solr_result['facet_counts']['facet_fields'][field.indexed_name], field)
         end
     end
 
-    private
+    # 
+    # 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
 
     # 
-    # Collection of instantiated result objects corresponding to the results
-    # returned by Solr.
-    #
-    # ==== Returns
+    # Build this search using a DSL block.
     #
-    # Array:: Collection of instantiated result objects
-    #
-    def result_objects
-      raw_results.inject({}) do |type_id_hash, raw_result|
-        (type_id_hash[raw_result.class_name] ||= []) << raw_result.primary_key
-        type_id_hash
-      end.inject([]) do |results, pair|
-        type_name, ids = pair
-        results.concat(Adapters::DataAccessor.create(Util.full_const_get(type_name)).load_all(ids))
-      end.sort_by do |result|
-        hit_ids.index(Adapters::InstanceAdapter.adapt(result).index_id)
+    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 hit_ids
-      @hit_ids ||= @solr_result.hits.map { |hit| hit['id'] }
+    def field(name)
+      @setup.field(name)
     end
   end
 end

data/lib/sunspot/session.rb

@@ -8,6 +8,20 @@ module Sunspot
   # 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
 
     # 
@@ -27,7 +41,13 @@ module Sunspot
     #
     def new_search(*types)
       types.flatten!
-      Search.new(connection, Query.new(types, @config))
+      setup =
+        if types.length == 1
+          Setup.for(types.first)
+        else
+          CompositeSetup.for(types)
+        end
+      Search.new(connection, setup, Query::Query.new(setup, @config))
     end
 
     #
@@ -36,7 +56,7 @@ module Sunspot
     def search(*types, &block)
       options = types.last.is_a?(Hash) ? types.pop : {}
       search = new_search(*types)
-      search.query.build(&block) if block
+      search.build(&block) if block
       search.query.options = options
       search.execute!
     end
@@ -44,20 +64,10 @@ module Sunspot
     #
     # See Sunspot.index
     #
-    #--
-    # FIXME The fact that we have to break this out by class and index each
-    #       class separately is artificial, imposed by the fact that indexers
-    #       are initialized with a particular setup, and are responsible for
-    #       sending add messages to Solr. It might be worth considering a
-    #       singleton indexer (per session) and have the indexer itself find
-    #       the appropriate setup to use for each object.
-    #
     def index(*objects)
       objects.flatten!
       @updates += objects.length
-      objects.group_by { |object| object.class }.to_hash.each_pair do |clazz, objs|
-        indexer_for(objs.first).add(objs)
-      end
+      indexer.add(objects)
     end
 
     # 
@@ -83,7 +93,7 @@ module Sunspot
       objects.flatten!
       @updates += objects.length
       for object in objects
-        indexer_for(object).remove(object)
+        indexer.remove(object)
       end
     end
 
@@ -95,6 +105,27 @@ module Sunspot
       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
     #
@@ -106,7 +137,7 @@ module Sunspot
       else
         @updates += classes.length
         for clazz in classes
-          Setup.for(clazz).indexer(connection).remove_all
+          indexer.remove_all(clazz)
         end
       end
     end
@@ -133,26 +164,16 @@ module Sunspot
       commit if dirty?
     end
 
-    private
-
     # 
-    # 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
+    # See Sunspot.batch
     #
-    def setup_for(object)
-      Setup.for(object.class) || raise(NoSetupError, "Sunspot is not configured for #{object.class.inspect}")
+    def batch
+      indexer.start_batch
+      yield
+      indexer.flush_batch
     end
 
-    def indexer_for(object)
-      setup_for(object).indexer(connection)
-    end
+    private
 
     # 
     # Retrieve the Solr connection for this session, creating one if it does not
@@ -163,7 +184,18 @@ module Sunspot
     # Solr::Connection:: The connection for this session
     #
     def connection
-      @connection ||= Solr::Connection.new(config.solr.url)
+      @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