sunspot_solr 2.0.0.pre.120924 → 2.0.0.pre.120925

data/sunspot/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/sunspot/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/sunspot/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/sunspot/lib/sunspot/query/query_facet.rb

@@ -1,53 +0,0 @@
-module Sunspot
-  module Query
-    class QueryFacet < Connective::Conjunction
-
-      def initialize(options = {}, negated = false)
-        if exclude_filters = options[:exclude]
-          @exclude_tag = Util.Array(exclude_filters).map do |filter|
-            filter.tag
-          end.join(',')
-        end
-        super(negated)
-      end
-
-
-      def to_params
-        if @components.empty?
-          {}
-        else
-          {
-            :facet => 'true',
-            :"facet.query" => to_boolean_phrase
-          }
-        end
-      end
-
-      def to_boolean_phrase
-        "#{to_local_params}#{super}"
-      end
-
-      private
-
-      def local_params
-        @local_params ||=
-          begin
-            local_params = {}
-            local_params[:ex] = @exclude_tag if @exclude_tag
-            local_params
-          end
-      end
-
-      def to_local_params
-        if local_params.empty?
-          ''
-        else
-          pairs = local_params.map do |key, value|
-            "#{key}=#{value}"
-          end
-          "{!#{pairs.join(' ')}}"
-        end
-      end 
-    end
-  end
-end

data/sunspot/lib/sunspot/query/range_facet.rb

@@ -1,15 +0,0 @@
-module Sunspot
-  module Query
-    class RangeFacet < AbstractFieldFacet
-      def to_params
-        params = super
-        params[:"facet.range"] = [@field.indexed_name]
-        params[qualified_param('range.start')] = @field.to_indexed(@options[:range].first)
-        params[qualified_param('range.end')] = @field.to_indexed(@options[:range].last)
-        params[qualified_param('range.gap')] = "#{@options[:range_interval] || 10}"
-        params[qualified_param('range.include')] = @options[:include].to_s if @options[:include]
-        params
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/query/restriction.rb

@@ -1,308 +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
-
-      class InRadius < Base
-        def initialize(negated, field, lat, lon, radius)
-          @lat, @lon, @radius = lat, lon, radius
-          super negated, field, [lat, lon, radius]
-        end
-
-        private
-          def to_positive_boolean_phrase
-            "_query_:\"{!geofilt sfield=#{@field.indexed_name} pt=#{@lat},#{@lon} d=#{@radius}}\""
-          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 less or equal to than given value
-      #
-      class LessThanOrEqualTo < 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 greater than or equal to given value
-      #
-      class GreaterThanOrEqualTo < 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