kuahyeow-sunspot 0.9.8 → 0.10.3

data/lib/sunspot/query/scope.rb

@@ -1,164 +1,8 @@
 module Sunspot
   module Query
-    # 
-    # The Scope class encapsulates a set of restrictions that scope search
-    # results (as well as query facets rows). This class's API is exposed by
-    # Query::Query and Query::QueryFacetRow.
-    # 
-    class Scope
-      # 
-      # Add a restriction to the query.
-      # 
-      # ==== Parameters
-      #
-      # field_name<Symbol>:: Name of the field to which the restriction applies
-      # restriction_type<Class,Symbol>::
-      #   Subclass of Sunspot::Query::Restriction::Base, or snake_cased name as symbol
-      #   (e.g., +:equal_to+)
-      # value<Object>::
-      #   Value against which the restriction applies (e.g. less_than(2) has a
-      #   value of 2)
-      # negated::
-      #   Whether this restriction should be negated (use add_negated_restriction)
-      #
-      def add_restriction(field_name, restriction_type, value, negated = false)
-        if restriction_type.is_a?(Symbol)
-          restriction_type = Restriction[restriction_type]
-        end
-        add_component(
-          restriction = restriction_type.new(
-            build_field(field_name), value, negated
-          )
-        )
-        restriction
-      end
-
-      # 
-      # Add a negated restriction to the query. The restriction will be taken as
-      # the opposite of its usual meaning (e.g., an :equal_to restriction will
-      # be "not equal to".
-      #
-      # ==== Parameters
-      #
-      # field_name<Symbol>:: Name of the field to which the restriction applies
-      # restriction_type<Class>::
-      #   Subclass of Sunspot::Query::Restriction::Base to instantiate
-      # value<Object>::
-      #   Value against which the restriction applies (e.g. less_than(2) has a
-      #   value of 2)
-      #
-      def add_negated_restriction(field_name, restriction_type, value)
-        add_restriction(field_name, restriction_type, value, true)
-      end
-
-      # 
-      # Add a disjunction to the scope. The disjunction can then take a set of
-      # restrictions, which are combined with OR semantics.
-      #
-      # ==== Returns
-      #
-      # Connective::Disjunction:: New disjunction
-      #
-      def add_disjunction
-        add_component(disjunction = Connective::Disjunction.new(setup))
-        disjunction
-      end
-
-      # 
-      # Add a conjunction to the scope. In most cases, this will simply return
-      # the Scope object itself, since scopes by default combine their
-      # restrictions with OR semantics. The Connective::Disjunction class
-      # overrides this method to return a Connective::Conjunction.
-      #
-      # ==== Returns
-      #
-      # Scope:: Self or another scope with conjunctive semantics.
-      #
-      def add_conjunction
-        self
-      end
-      
-      #
-      # Exclude a particular instance from the search results
-      #
-      # ==== Parameters
-      #
-      # instance<Object>:: instance to exclude from results
-      #
-      def exclude_instance(instance)
-        add_component(Restriction::SameAs.new(instance, true))
-      end
-
-      # 
-      # Generate a DynamicQuery instance for the given base name.
-      # This gives you access to a subset of the Query API but the operations
-      # apply to dynamic fields inside the dynamic field definition specified
-      # by +base_name+.
-      # 
-      # ==== Parameters
-      # 
-      # base_name<Symbol>::
-      #   Base name of the dynamic field definition to use in the dynamic query
-      #   operations
-      #
-      # ==== Returns
-      #
-      # DynamicQuery::
-      #   Instance providing dynamic query functionality for the given field
-      #   definitions.
-      #
-      def dynamic_query(base_name)
-        DynamicQuery.new(setup.dynamic_field_factory(base_name), self)
-      end
-
-      # 
-      # Determine which restriction type to add based on the type of the value.
-      # Used to interpret query conditions passed as a hash, as well as the
-      # short-form DSL::Scope#with method.
-      #
-      # ==== Parameters
-      #
-      # field_name<Symbol>:: Name of the field on which to apply the restriction
-      # value<Object,Array,Range>:: Value to which to apply to the restriction
-      #--
-      # negated<Boolean>:: Whether to negate the restriction.
-      #
-      def add_shorthand_restriction(field_name, value, negated = false) #:nodoc:
-        restriction_type =
-          case value
-          when Range
-            Restriction::Between
-          when Array
-            Restriction::AnyOf
-          else
-            Restriction::EqualTo
-          end
-        add_restriction(field_name, restriction_type, value, negated)
-      end
-
-      # 
-      # Add a negated shorthand restriction. See #add_shorthand_restriction
-      #
-      def add_negated_shorthand_restriction(field_name, value)
-        add_shorthand_restriction(field_name, value, true)
-      end
-
-      private
-
-      # 
-      # Build a field with the given field name. Subclasses may override this
-      # method.
-      #
-      def build_field(field_name)
-        setup.field(field_name)
-      end
-
-      # 
-      # Return a setup object which can return a field object given a name.
-      # Subclasses may override this method.
-      #
-      def setup
-        @setup
+    class Scope < Connective::Conjunction
+      def to_params
+        { :fq => @components.map { |component| component.to_boolean_phrase }}
       end
     end
   end

data/lib/sunspot/query/sort.rb

@@ -1,9 +1,12 @@
 module Sunspot
   module Query
     # 
-    # The Sort class is a query component representing a sort by a given field.
+    # The classes in this module implement query components that build sort
+    # parameters for Solr. As well as regular sort on fields, there are several
+    # "special" sorts that allow ordering for metrics calculated during the
+    # search.
     # 
-    class Sort #:nodoc:
+    module Sort #:nodoc: all
       DIRECTIONS = {
         :asc => 'asc',
         :ascending => 'asc',
@@ -11,25 +14,91 @@ module Sunspot
         :descending => 'desc'
       }
 
-      def initialize(field, direction = nil)
-        if field.multiple?
-          raise(ArgumentError, "#{field.name} cannot be used for ordering because it is a multiple-value field")
+      class <<self
+        # 
+        # Certain field names are "special", referring to specific non-field
+        # sorts, which are generally by other metrics associated with hits.
+        #
+        # XXX I'm not entirely convinced it's a good idea to prevent anyone from
+        # ever sorting by a field named 'score', etc.
+        #
+        def special(name)
+          special_class_name = "#{Util.camel_case(name.to_s)}Sort"
+          if const_defined?(special_class_name) && special_class_name != 'FieldSort'
+            const_get(special_class_name)
+          end
         end
-        @field, @direction = field, (direction || :asc).to_sym
       end
 
-      def to_param
-        "#{@field.indexed_name.to_sym} #{direction_for_solr}"
+      # 
+      # Base class for sorts. All subclasses should implement the #to_param
+      # method, which is a string that is then concatenated with other sort
+      # strings by the SortComposite to form the sort parameter.
+      #
+      class Abstract
+        def initialize(direction)
+          @direction = (direction || :asc).to_sym
+        end
+
+        private
+
+        # 
+        # Translate fairly forgiving direction argument into solr direction
+        #
+        def direction_for_solr
+          DIRECTIONS[@direction] || 
+            raise(
+              ArgumentError,
+              "Unknown sort direction #{@direction}. Acceptable input is: #{DIRECTIONS.keys.map { |input| input.inspect } * ', '}"
+          )
+        end
       end
 
-      private
+      # 
+      # A FieldSort is the usual kind of sort, by the value of a particular
+      # field, ascending or descending
+      #
+      class FieldSort < Abstract
+        def initialize(field, direction = nil)
+          if field.multiple?
+            raise(ArgumentError, "#{field.name} cannot be used for ordering because it is a multiple-value field")
+          end
+          @field, @direction = field, (direction || :asc).to_sym
+        end
+
+        def to_param
+          "#{@field.indexed_name.to_sym} #{direction_for_solr}"
+        end
+      end
 
-      def direction_for_solr
-        DIRECTIONS[@direction] || 
-          raise(
-            ArgumentError,
-            "Unknown sort direction #{@direction}. Acceptable input is: #{DIRECTIONS.keys.map { |input| input.inspect } * ', '}"
-        )
+      # 
+      # A RandomSort uses Solr's random field functionality to sort results
+      # (usually) randomly.
+      #
+      class RandomSort < Abstract
+        def to_param
+          "random_#{rand(1<<16)} #{direction_for_solr}"
+        end
+      end
+
+      # 
+      # A ScoreSort sorts by keyword relevance score. This is only useful when
+      # performing fulltext search.
+      #
+      class ScoreSort < Abstract
+        def to_param
+          "score #{direction_for_solr}"
+        end
+      end
+
+      # 
+      # A DistanceSort sorts by distance from the origin coordinates of a
+      # geographical distance search.
+      #
+      class DistanceSort < Abstract
+        def to_param
+          "geo_distance #{direction_for_solr}"
+        end
       end
     end
   end

data/lib/sunspot/query/text_field_boost.rb

@@ -0,0 +1,15 @@
+module Sunspot
+  module Query
+    class TextFieldBoost #:nodoc:
+      def initialize(field, boost = nil)
+        @field, @boost = field, boost
+      end
+
+      def to_boosted_field
+        boosted_field = @field.indexed_name
+        boosted_field.concat("^#{@boost}") if @boost
+        boosted_field
+      end
+    end
+  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.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,29 +81,21 @@ 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
-          query_facet(field_name) ||
+          facet_data = query_facet_data(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
+              field = field(name)
+              date_facet_data(field) ||
+                FacetData::FieldFacetData.new(@solr_result['facet_counts']['facet_fields'][field.indexed_name], field)
             end
+          facet_class = facet_data.reference ? InstantiatedFacet : Facet
+          facet_class.new(facet_data)
         end
     end
 
@@ -132,7 +129,7 @@ module Sunspot
       (@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)
+          Facet.new(FacetData::FieldFacetData.new(@solr_result['facet_counts']['facet_fields'][field.indexed_name], field))
         end
     end
 
@@ -145,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|
@@ -172,49 +184,55 @@ 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)
+      DSL::Search.new(self, @setup)
     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)
+    def date_facet_data(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)
+            FacetData::DateFacetData.new(facet_result, field)
           end
         end
       end
     end
 
-    def query_facet(name)
+    def query_facet_data(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']
-          )
+            FacetData::QueryFacetData.new(
+              query_facet,
+              @solr_result['facet_counts']['facet_queries']
+            )
         end
       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