sunspot 0.9.8 → 0.10.0

data/lib/sunspot/query.rb

@@ -1,191 +1,5 @@
-%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
-
+%w(connective boost_query dismax field_facet highlighting local pagination restriction query query_facet query_field_facet query_facet_row scope sort sort_composite text_field_boost).each { |file| require(File.join(File.dirname(__FILE__), 'query', file)) }
 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
+  module Query #:nodoc:all
   end
 end

data/lib/sunspot/schema.rb

@@ -1,15 +1,4 @@
-using_rubygems = false
-begin
-  require 'haml'
-rescue LoadError => e
-  if using_rubygems
-    raise(e)
-  else
-    using_rubygems = true
-    require 'rubygems'
-    retry
-  end
-end
+require 'erb'
 
 module Sunspot
   # 
@@ -29,7 +18,9 @@ module Sunspot
       FieldType.new('sfloat', 'SortableFloat', 'f'),
       FieldType.new('date', 'Date', 'd'),
       FieldType.new('sint', 'SortableInt', 'i'),
-      FieldType.new('string', 'Str', 's')
+      FieldType.new('string', 'Str', 's'),
+      FieldType.new('sdouble', 'SortableDouble', 'e'),
+      FieldType.new('slong', 'SortableLong', 'l')
     ]
 
     FIELD_VARIANTS = [
@@ -89,20 +80,11 @@ module Sunspot
     end
 
     # 
-    # Return an XML representation of this schema using the Haml template
+    # Return an XML representation of this schema using the ERB 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)
+      template = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'schema.xml.erb')
+      ERB.new(File.read(template), nil, '-').result(binding)
     end
 
     private

data/lib/sunspot/search/highlight.rb

@@ -0,0 +1,38 @@
+module Sunspot
+  class Search
+    # 
+    # A Highlight represents a single highlighted fragment of text from a
+    # document. Depending on the highlighting parameters used for search, there
+    # may be more than one Highlight object for a given field in a given result.
+    #
+    class Highlight
+      HIGHLIGHT_MATCHER = /@@@hl@@@(.*?)@@@endhl@@@/ #:nodoc:
+      
+      #
+      # The name of the field in which the highlight appeared.
+      #
+      attr_reader :field_name
+            
+      def initialize(field_name, highlight) #:nodoc:
+        @field_name = field_name.to_sym
+        @highlight = highlight.to_s.strip
+      end
+      
+      #
+      # Returns the highlighted text with formatting according to the template given in &block.
+      # When no block is given, <em> and </em> are used to surround the highlight.
+      #
+      # ==== Example
+      #
+      #   search.highlights(:body).first.format { |word| "<strong>#{word}</strong>" }
+      #
+      def format(&block)
+        block ||= proc { |word| "<em>#{word}</em>" }
+        @highlight.gsub(HIGHLIGHT_MATCHER) do
+          block.call(Regexp.last_match[1])
+        end
+      end
+      alias_method :formatted, :format
+    end
+  end
+end

data/lib/sunspot/search/hit.rb

@@ -1,5 +1,11 @@
 module Sunspot
   class Search
+    # 
+    # Hit objects represent the raw information returned by Solr for a single
+    # document. As well as the primary key and class name, hit objects give
+    # access to stored field values, keyword relevance score, and geographical
+    # distance (for geographical search).
+    #
     class Hit
       SPECIAL_KEYS = Set.new(%w(id type score)) #:nodoc:
 
@@ -16,15 +22,34 @@ module Sunspot
       # is not from a keyword search.
       #
       attr_reader :score
+      #
+      # For geographical searches, this is the distance between the search
+      # centerpoint and the document's location. Otherwise, it's nil.
+      # 
+      attr_reader :distance
 
       attr_writer :instance #:nodoc:
 
-      def initialize(raw_hit, search) #:nodoc:
+      def initialize(raw_hit, highlights, search) #:nodoc:
         @class_name, @primary_key = *raw_hit['id'].match(/([^ ]+) (.+)/)[1..2]
         @score = raw_hit['score']
+        @distance = raw_hit['geo_distance'].to_f if raw_hit['geo_distance']
         @search = search
         @stored_values = raw_hit
         @stored_cache = {}
+        @highlights = highlights
+      end
+      
+      #
+      # Returns all highlights for this hit when called without parameters.
+      # When a field_name is provided, returns only the highlight for this field.
+      #
+      def highlights(field_name = nil)
+        if field_name.nil?
+          highlights_cache.values.flatten 
+        else
+          highlights_cache[field_name.to_sym]
+        end
       end
 
       # 
@@ -41,7 +66,7 @@ module Sunspot
       def stored(field_name)
         @stored_cache[field_name.to_sym] ||=
           begin
-            field = Sunspot::Setup.for(@class_name).field(field_name)
+            field = setup.field(field_name)
             field.cast(@stored_values[field.indexed_name])
           end
       end
@@ -58,9 +83,31 @@ module Sunspot
         @instance
       end
 
-      def inspect
+      def inspect #:nodoc:
         "#<Sunspot::Search::Hit:#{@class_name} #{@primary_key}>"
       end
+
+      private
+
+      def setup
+        @setup ||= Sunspot::Setup.for(@class_name)
+      end
+
+      def highlights_cache
+        @highlights_cache ||=
+          begin
+            cache = {}
+            if @highlights
+              @highlights.each_pair do |indexed_field_name, highlight_strings|
+                field_name = indexed_field_name.sub(/_[a-z]+$/, '').to_sym
+                cache[field_name] = highlight_strings.map do |highlight_string|
+                  Highlight.new(field_name, highlight_string)
+                end
+              end
+            end
+            cache
+          end
+      end
     end
   end
 end

data/lib/sunspot/search.rb

@@ -1,4 +1,6 @@
-require File.join(File.dirname(__FILE__), 'search', 'hit')
+%w(hit highlight).each do |file|
+  require File.join(File.dirname(__FILE__), 'search', file)
+end
 
 module Sunspot
   # 
@@ -14,8 +16,9 @@ module Sunspot
     # in this case.
     attr_reader :query 
 
-    def initialize(connection, setup, query) #:nodoc:
+    def initialize(connection, setup, query, configuration) #:nodoc:
       @connection, @setup, @query = connection, setup, query
+      @query.paginate(1, configuration.pagination.default_per_page)
     end
 
     #
@@ -25,11 +28,13 @@ module Sunspot
     # Sunspot#new_search(), you will need to call this method after building the
     # query.
     #
-    def execute!
+    def execute
+      reset
       params = @query.to_params
       @solr_result = @connection.select(params)
       self
     end
+    alias_method :execute!, :execute #:nodoc: deprecated
 
     # 
     # Get the collection of results as instantiated objects. If WillPaginate is
@@ -60,7 +65,7 @@ module Sunspot
     # Array:: Ordered collection of Hit objects
     #
     def hits
-      @hits ||= solr_response['docs'].map { |doc| Hit.new(doc, self) }
+      @hits ||= solr_response['docs'].map { |doc| Hit.new(doc, highlights_for(doc), self) }
     end
     alias_method :raw_results, :hits
 
@@ -76,23 +81,16 @@ module Sunspot
     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
+    # Get the facet object for the given name. `name` can either be the name
+    # given to a query facet, or the field name of a field facet. Returns a
+    # Sunspot::Facet object.
     #
-    # Sunspot::Facet:: Facet object for the given field
-    #
-    def facet(field_name)
-      (@facets_cache ||= {})[field_name.to_sym] ||=
+    def facet(name)
+      (@facets_cache ||= {})[name.to_sym] ||=
         begin
-          facet_data = query_facet_data(field_name) ||
+          facet_data = query_facet_data(name) ||
             begin
-              field = field(field_name)
+              field = field(name)
               date_facet_data(field) ||
                 FacetData::FieldFacetData.new(@solr_result['facet_counts']['facet_fields'][field.indexed_name], field)
             end
@@ -144,19 +142,34 @@ module Sunspot
     # Sunspot::DSL::Search#data_accessor_for method when building searches using
     # the block DSL.
     #
-    def data_accessor_for(clazz)
+    def data_accessor_for(clazz) #:nodoc:
       (@data_accessors ||= {})[clazz.name.to_sym] ||=
         Adapters::DataAccessor.create(clazz)
     end
 
     # 
-    # Build this search using a DSL block.
+    # Build this search using a DSL block. This method can be called more than
+    # once on an unexecuted search (e.g., Sunspot.new_search) in order to build
+    # a search incrementally.
+    #
+    # === Example
+    #
+    #   search = Sunspot.new_search(Post)
+    #   search.build do
+    #     with(:published_at).less_than Time.now
+    #   end
+    #   search.execute!
     #
-    def build(&block) #:nodoc:
+    def build(&block)
       Util.instance_eval_or_call(dsl, &block)
       self
     end
 
+    # 
+    # Populate the Hit objects with their instances. This is invoked the first
+    # time any hit has its instance requested, and all hits are loaded as a
+    # batch.
+    #
     def populate_hits! #:nodoc:
       id_hit_hash = Hash.new { |h, k| h[k] = {} }
       hits.each do |hit|
@@ -171,24 +184,18 @@ module Sunspot
       end
     end
 
+    def inspect #:nodoc:
+      "<Sunspot::Search:#{query.to_params.inspect}>"
+    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]
+      DSL::Search.new(self, @setup)
     end
 
     def date_facet_data(field)
@@ -212,8 +219,20 @@ module Sunspot
       end
     end
 
+    def highlights_for(doc)
+      if @solr_result['highlighting']
+        @solr_result['highlighting'][doc['id']]
+      end
+    end
+
     def field(name)
       @setup.field(name)
     end
+    
+    # Clear out all the cached ivars so the search can be called again.
+    def reset
+      @results = @hits = @total = @facets_cache = 
+        @dynamic_facets_cache = @solr_response = @doc_ids = nil
+    end
   end
 end

data/lib/sunspot/session.rb

@@ -29,10 +29,11 @@ module Sunspot
     # connection. Usually you will want to stick with the default arguments
     # when instantiating your own sessions.
     #
-    def initialize(config = Configuration.build, connection = nil)
+    def initialize(config = Configuration.build, connection = nil, master_connection = nil)
       @config = config
       yield(@config) if block_given?
       @connection = connection
+      @master_connection = master_connection
       @updates = 0
     end
 
@@ -41,23 +42,24 @@ module Sunspot
     #
     def new_search(*types)
       types.flatten!
+      if types.empty?
+        raise(ArgumentError, "You must specify at least one type to search")
+      end
       setup =
         if types.length == 1
           Setup.for(types.first)
         else
           CompositeSetup.for(types)
           end
-      Search.new(connection, setup, Query::Query.new(types, setup, @config))
+      Search.new(connection, setup, Query::Query.new(types), @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
 
@@ -83,7 +85,7 @@ module Sunspot
     #
     def commit
       @updates = 0
-      connection.commit
+      master_connection.commit
     end
 
     # 
@@ -133,7 +135,7 @@ module Sunspot
       classes.flatten!
       if classes.empty?
         @updates += 1
-        Indexer.remove_all(connection)
+        Indexer.remove_all(master_connection)
       else
         @updates += classes.length
         for clazz in classes
@@ -187,16 +189,34 @@ module Sunspot
       @connection ||=
         begin
           self.class.connection_class.connect(:url => config.solr.url, :adapter => config.http_client)
-          # 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
+
+    # 
+    # Retrieve the Solr connection to the master for this session, creating one
+    # if it does not already exist.
+    #
+    # ==== Returns
+    #
+    # Solr::Connection:: The connection for this session
+    #
+    def master_connection
+      @master_connection ||=
+        begin
+          if config.master_solr.url && config.master_solr.url != config.solr.url
+            master_connection = self.class.connection_class.new(
+              RSolr::Adapter::HTTP.new(:url => config.master_solr.url)
+            )
+            master_connection.adapter.connector.adapter_name = config.http_client
+            master_connection
+          else
+            connection
+          end
         end
     end
 
     def indexer
-      @indexer ||= Indexer.new(connection)
+      @indexer ||= Indexer.new(master_connection)
     end
   end
 end