sunspot 0.9.8 → 0.10.0

data/lib/sunspot/query/query.rb

@@ -0,0 +1,93 @@
+module Sunspot
+  module Query
+    class Query
+      attr_accessor :scope
+      attr_accessor :fulltext
+
+      def initialize(types)
+        @scope = Scope.new
+        @field_facets = []
+        @query_facets = {}
+        @sort = SortComposite.new
+        if types.length == 1
+          @scope.add_restriction(TypeField.instance, Restriction::EqualTo, types.first)
+        else
+          @scope.add_restriction(TypeField.instance, Restriction::AnyOf, types)
+        end
+      end
+
+      def set_fulltext(keywords)
+        @fulltext = Dismax.new(keywords)
+      end
+
+      def add_location_restriction(coordinates, radius)
+        @local = Local.new(coordinates, radius)
+      end
+
+      def add_field_facet(field, options = {})
+        facet = FieldFacet.build(field, options)
+        if facet.is_a?(QueryFacet)
+          @query_facets[field.name.to_sym] = facet
+        else
+          @field_facets << facet
+        end
+      end
+
+      def add_query_facet(name, options = {})
+        @query_facets[name.to_sym] = QueryFacet.new(name, options)
+      end
+
+      def add_sort(sort)
+        @sort << sort
+      end
+
+      def paginate(page, per_page)
+        if @pagination
+          @pagination.page = page
+          @pagination.per_page = per_page
+        else
+          @pagination = Pagination.new(page, per_page)
+        end
+      end
+
+      def to_params
+        params = 
+          if @local
+            if @fulltext
+              raise(
+                IllegalSearchError,
+                "Can't perform search with both fulltext and geographical components due to LocalSolr limitations"
+              )
+            end
+            { :q => @scope.to_boolean_phrase }
+          else
+            @scope.to_params
+          end
+        Sunspot::Util.deep_merge!(params, @fulltext.to_params) if @fulltext
+        @field_facets.each do |facet|
+          Sunspot::Util.deep_merge!(params, facet.to_params)
+        end
+        @query_facets.values.each do |facet|
+          Sunspot::Util.deep_merge!(params, facet.to_params)
+        end
+        Sunspot::Util.deep_merge!(params, @sort.to_params)
+        Sunspot::Util.deep_merge!(params, @pagination.to_params) if @pagination
+        Sunspot::Util.deep_merge!(params, @local.to_params) if @local
+        params[:q] ||= '*:*'
+        params
+      end
+
+      def page
+        @pagination.page if @pagination
+      end
+
+      def per_page
+        @pagination.per_page if @pagination
+      end
+
+      def query_facet(name)
+        @query_facets[name] if @query_facets
+      end
+    end
+  end
+end

data/lib/sunspot/query/query_facet.rb

@@ -12,13 +12,13 @@ module Sunspot
     # query facet rows, instead returning each requested row individually, keyed
     # by the boolean phrase used in the facet query.
     #
-    class QueryFacet
+    class QueryFacet #:nodoc:
       attr_reader :name #:nodoc:
       attr_reader :field #:nodoc:
+      attr_reader :options #:nodoc:
 
-      def initialize(name, setup = nil) #:nodoc:
-        @name = name
-        @setup = setup
+      def initialize(name, options, setup = nil) #:nodoc:
+        @name, @options, @setup = name, options, setup
         @components = []
       end
 
@@ -51,11 +51,16 @@ module Sunspot
       #
       def to_params #:nodoc:
         components = @components.map { |component| component.to_boolean_phrase }
-        components = components.first if components.length == 1
-        {
-          :facet => 'true',
-          :"facet.query" => components
-        }
+        components.compact!
+        if components.empty?
+          {}
+        else
+          components = components.first if components.length == 1
+          {
+            :facet => 'true',
+            :"facet.query" => components
+          }
+        end
       end
 
       # 

data/lib/sunspot/query/query_facet_row.rb

@@ -7,10 +7,10 @@ module Sunspot
     #
     # See Query::Scope for the API provided.
     #
-    class QueryFacetRow < Connective::Conjunction
-      attr_reader :label #:nodoc:
+    class QueryFacetRow < Connective::Conjunction #:nodoc:
+      attr_reader :label
 
-      def initialize(label, setup) #:nodoc:
+      def initialize(label, setup)
         super(setup)
         @label = label
       end

data/lib/sunspot/query/query_field_facet.rb

@@ -1,8 +1,15 @@
 module Sunspot
   module Query
-    class QueryFieldFacet < QueryFacet
-      def initialize(field, values)
-        super(field.name)
+    # 
+    # QueryFieldFacets are used for the "restricted field facet" feature, which
+    # allows an :only parameter for field facets, specifying a set of values in
+    # which the searcher is interested. Since Solr does not support this feature
+    # directly in field facets, build query facets that replicate field facet
+    # behavior.
+    #
+    class QueryFieldFacet < QueryFacet #:nodoc:
+      def initialize(field, values, options)
+        super(field.name, options)
         @field = field
         values.each do |value|
           add_row(value).add_component(Restriction::EqualTo.new(field, value))

data/lib/sunspot/query/restriction.rb

@@ -11,9 +11,13 @@ module Sunspot
         # Array:: Collection of restriction class names
         #
         def names
-          constants - %w(Base SameAs) #XXX this seems ugly
+          constants - %w(Base) #XXX this seems ugly
         end
 
+        # 
+        # Convenience method to access a restriction class by an underscored
+        # symbol or string
+        #
         def [](restriction_name)
           @types ||= {}
           @types[restriction_name.to_sym] ||= const_get(Sunspot::Util.camel_case(restriction_name.to_s))
@@ -104,6 +108,10 @@ module Sunspot
           !!@negated
         end
 
+        # 
+        # Return a new restriction that is the negated version of this one. It
+        # is used by disjunction denormalization.
+        #
         def negate
           self.class.new(@field, @value, !@negated)
         end
@@ -123,7 +131,7 @@ module Sunspot
         # String:: Solr API representation of given value
         #
         def solr_value(value = @value)
-          escape(@field.to_indexed(value))
+          solr_value = escape(@field.to_indexed(value))
         end
       end
 
@@ -161,6 +169,12 @@ module Sunspot
       class LessThan < Base
         private
 
+        def solr_value(value = @value)
+          solr_value = super
+          solr_value = "\"#{solr_value}\"" if solr_value.index(' ')
+          solr_value
+        end
+
         def to_solr_conditional
           "[* TO #{solr_value}]"
         end
@@ -172,6 +186,12 @@ module Sunspot
       class GreaterThan < Base
         private
 
+        def solr_value(value = @value)
+          solr_value = super
+          solr_value = "\"#{solr_value}\"" if solr_value.index(' ')
+          solr_value
+        end
+
         def to_solr_conditional
           "[#{solr_value} TO *]"
         end
@@ -183,8 +203,15 @@ module Sunspot
       class Between < Base
         private
 
+        def solr_value(value = @value)
+          solr_value = super
+          solr_value = "\"#{solr_value}\"" if solr_value.index(' ')
+          solr_value
+        end
+
         def to_solr_conditional
-          "[#{solr_value(@value.first)} TO #{solr_value(@value.last)}]"
+          first, last = [@value.first, @value.last].sort
+          "[#{solr_value(first)} TO #{solr_value(last)}]"
         end
       end
 
@@ -212,20 +239,14 @@ module Sunspot
       end
 
       # 
-      # Result must be the exact instance given (only useful when negated).
+      # Results must have a field with a value that begins with the argument.
+      # Most useful for strings, but in theory will work with anything.
       #
-      class SameAs < Base
-        def initialize(object, negated = false)
-          @object, @negated = object, negated
-        end
-
-        def to_positive_boolean_phrase
-          adapter = Adapters::InstanceAdapter.adapt(@object)
-          "id:#{escape(adapter.index_id)}"
-        end
+      class StartingWith < Base
+        private
 
-        def negate
-          SameAs.new(@object, !negated?)
+        def to_solr_conditional
+          "#{solr_value(@value)}*"
         end
       end
     end

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