gojee-sunspot 2.0.2 → 2.0.3

data/lib/sunspot/query/more_like_this.rb

@@ -1,61 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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