gojee-sunspot 2.0.2

data/lib/sunspot/query/more_like_this.rb

@@ -0,0 +1,61 @@
+module Sunspot
+  module Query
+    class MoreLikeThis
+      attr_reader :fields
+
+      def initialize(document)
+        @document_scope = Restriction::EqualTo.new(
+          false,
+          IdField.instance,
+          Adapters::InstanceAdapter.adapt(document).index_id
+        )
+        @fields = {}
+        @params = {}
+      end
+
+      def add_field(field, boost = nil)
+        raise(ArgumentError, "Field #{field.name} is not set up for more_like_this") unless field.more_like_this?
+        @fields[field.indexed_name] = TextFieldBoost.new(field, boost)
+      end
+
+      def minimum_term_frequency=(mintf)
+        @params[:"mlt.mintf"] = mintf
+      end
+
+      def minimum_document_frequency=(mindf)
+        @params[:"mlt.mindf"] = mindf
+      end
+
+      def minimum_word_length=(minwl)
+        @params[:"mlt.minwl"] = minwl
+      end
+
+      def maximum_word_length=(maxwl)
+        @params[:"mlt.maxwl"] = maxwl
+      end
+      
+      def maximum_query_terms=(maxqt)
+        @params[:"mlt.maxqt"] = maxqt
+      end
+
+      def boost_by_relevance=(should_boost)
+        @params[:"mlt.boost"] = should_boost
+      end
+
+      def to_params
+        params = Sunspot::Util.deep_merge(
+          @params,
+          :q => @document_scope.to_boolean_phrase
+        )
+        params[:"mlt.fl"] = @fields.keys.join(",")
+        boosted_fields = @fields.values.select { |field| field.boost }
+        unless boosted_fields.empty?
+          params[:qf] = boosted_fields.map do |field|
+            field.to_boosted_field
+          end.join(' ')
+        end
+        params
+      end
+    end
+  end
+end

data/lib/sunspot/query/more_like_this_query.rb

@@ -0,0 +1,12 @@
+module Sunspot
+  module Query
+    class MoreLikeThisQuery < CommonQuery
+      attr_accessor :scope, :more_like_this
+
+      def initialize(document, types)
+        super(types)
+        @components << @more_like_this = MoreLikeThis.new(document)
+      end
+    end
+  end
+end

data/lib/sunspot/query/pagination.rb

@@ -0,0 +1,42 @@
+module Sunspot
+  module Query
+    # 
+    # A query component that holds information about pagination. Unlike other
+    # query components, this one is mutable, because the query itself holds a
+    # reference to it and updates it if pagination is changed.
+    #
+    class Pagination #:nodoc:
+      attr_reader :page, :per_page, :offset
+
+      def initialize(page = nil, per_page = nil, offset = nil)
+        self.offset, self.page, self.per_page = offset, page, per_page
+      end
+
+      def to_params
+        { :start => start, :rows => rows }
+      end
+
+      def page=(page)
+        @page = page.to_i if page
+      end
+
+      def per_page=(per_page)
+        @per_page = per_page.to_i if per_page
+      end
+
+      def offset=(offset)
+        @offset = offset.to_i
+      end
+
+      private
+
+      def start
+        (@page - 1) * @per_page + @offset
+      end
+
+      def rows
+        @per_page
+      end
+    end
+  end
+end

data/lib/sunspot/query/query_facet.rb

@@ -0,0 +1,16 @@
+module Sunspot
+  module Query
+    class QueryFacet < Connective::Conjunction
+      def to_params
+        if @components.empty?
+          {}
+        else
+          {
+            :facet => 'true',
+            :"facet.query" => to_boolean_phrase
+          }
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/restriction.rb

@@ -0,0 +1,262 @@
+module Sunspot
+  module Query
+    module Restriction #:nodoc:
+      class <<self
+        #
+        # Return the names of all of the restriction classes that should be made
+        # available to the DSL.
+        #
+        # ==== Returns
+        # 
+        # Array:: Collection of restriction class names
+        #
+        def names
+          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))
+        end
+      end
+
+      # 
+      # Subclasses of this class represent restrictions that can be applied to
+      # a Sunspot query. The Sunspot::DSL::Restriction class presents a builder
+      # API for instances of this class.
+      #
+      # Implementations of this class must respond to #to_params and
+      # #to_negated_params. Instead of implementing those methods, they may
+      # choose to implement any of:
+      #
+      # * #to_positive_boolean_phrase, and optionally #to_negated_boolean_phrase
+      # * #to_solr_conditional
+      #
+      class Base #:nodoc:
+        include Filter
+        include RSolr::Char
+
+        RESERVED_WORDS = Set['AND', 'OR', 'NOT']
+
+        def initialize(negated, field, value)
+          raise ArgumentError.new("RFCTR") unless [true, false].include?(negated)
+          @negated, @field, @value = negated, field, value
+        end
+
+        # 
+        # A hash representing this restriction in solr-ruby's parameter format.
+        # All restriction implementations must respond to this method; however,
+        # the base implementation delegates to the #to_positive_boolean_phrase method, so
+        # subclasses may (and probably should) choose to implement that method
+        # instead.
+        #
+        # ==== Returns
+        #
+        # Hash:: Representation of this restriction as solr-ruby parameters
+        #
+        def to_params
+          { :fq => [to_filter_query] }
+        end
+
+        # 
+        # Return the boolean phrase associated with this restriction object.
+        # Differentiates between positive and negated boolean phrases depending
+        # on whether this restriction is negated.
+        #
+        def to_boolean_phrase
+          unless negated?
+            to_positive_boolean_phrase
+          else
+            to_negated_boolean_phrase
+          end
+        end
+
+        # 
+        # Boolean phrase representing this restriction in the positive. Subclasses
+        # may choose to implement this method rather than #to_params; however,
+        # this method delegates to the abstract #to_solr_conditional method, which
+        # in most cases will be what subclasses will want to implement.
+        # #to_solr_conditional contains the boolean phrase representing the
+        # condition but leaves out the field name (see built-in implementations
+        # for examples)
+        #
+        # ==== Returns
+        #
+        # String:: Boolean phrase for restriction in the positive
+        #
+        def to_positive_boolean_phrase
+          "#{escape(@field.indexed_name)}:#{to_solr_conditional}"
+        end
+
+        # 
+        # Boolean phrase representing this restriction in the negated. Subclasses
+        # may choose to implement this method, but it is not necessary, as the
+        # base implementation delegates to #to_positive_boolean_phrase.
+        #
+        # ==== Returns
+        #
+        # String:: Boolean phrase for restriction in the negated
+        #
+        def to_negated_boolean_phrase
+          "-#{to_positive_boolean_phrase}"
+        end
+
+        # 
+        # Whether this restriction should be negated from its original meaning
+        #
+        def negated? #:nodoc:
+          !!@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(!@negated, @field, @value)
+        end
+
+        protected
+
+        # 
+        # Return escaped Solr API representation of given value
+        #
+        # ==== Parameters
+        #
+        # value<Object>::
+        #   value to convert to Solr representation (default: @value)
+        #
+        # ==== Returns
+        #
+        # String:: Solr API representation of given value
+        #
+        def solr_value(value = @value)
+          solr_value = escape(@field.to_indexed(value))
+          if RESERVED_WORDS.include?(solr_value)
+            %Q("#{solr_value}")
+          else
+            solr_value
+          end
+        end
+      end
+
+      # 
+      # Results must have field with value equal to given value. If the value
+      # is nil, results must have no value for the given field.
+      #
+      class EqualTo < Base
+        def to_positive_boolean_phrase
+          unless @value.nil?
+            super
+          else
+            "#{escape(@field.indexed_name)}:[* TO *]"
+          end
+        end
+
+        def negated?
+          if @value.nil?
+            !super
+          else
+            super
+          end
+        end
+
+        private
+
+        def to_solr_conditional
+          "#{solr_value}"
+        end
+      end
+
+      # 
+      # Results must have field with value less than given value
+      #
+      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
+      end
+
+      # 
+      # Results must have field with value greater than given value
+      #
+      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
+      end
+
+      # 
+      # Results must have field with value in given range
+      #
+      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)}]"
+        end
+      end
+
+      # 
+      # Results must have field with value included in given collection
+      #
+      class AnyOf < Base
+        private
+
+        def to_solr_conditional
+          "(#{@value.map { |v| solr_value v } * ' OR '})"
+        end
+      end
+
+      #
+      # Results must have field with values matching all values in given
+      # collection (only makes sense for fields with multiple values)
+      #
+      class AllOf < Base
+        private
+
+        def to_solr_conditional
+          "(#{@value.map { |v| solr_value v } * ' AND '})"
+        end
+      end
+
+      # 
+      # 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 StartingWith < Base
+        private
+
+        def to_solr_conditional
+          "#{solr_value(@value)}*"
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/scope.rb

@@ -0,0 +1,9 @@
+module Sunspot
+  module Query
+    class Scope < Connective::Conjunction
+      def to_params
+        { :fq => @components.map { |component| component.to_filter_query }}
+      end
+    end
+  end
+end

data/lib/sunspot/query/sort.rb

@@ -0,0 +1,109 @@
+module Sunspot
+  module Query
+    # 
+    # 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.
+    # 
+    module Sort #:nodoc: all
+      DIRECTIONS = {
+        :asc => 'asc',
+        :ascending => 'asc',
+        :desc => 'desc',
+        :descending => 'desc'
+      }
+
+      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
+      end
+
+      # 
+      # 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
+
+      # 
+      # 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
+
+      # 
+      # 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 GeodistSort sorts by distance from a given point.
+      #
+      class GeodistSort < FieldSort
+        def initialize(field, lat, lon, direction)
+          @lat, @lon = lat, lon
+          super(field, direction)
+        end
+
+        def to_param
+          "geodist(#{@field.indexed_name.to_sym},#{@lat},#{@lon}) #{direction_for_solr}"
+        end
+      end
+    end
+  end
+end