erichummel-sunspot 1.2.1a

data/lib/sunspot/query/field_facet.rb

@@ -0,0 +1,41 @@
+module Sunspot
+  module Query
+    class FieldFacet < AbstractFieldFacet
+      def initialize(field, options)
+        if exclude_filters = options[:exclude]
+          @exclude_tag = Util.Array(exclude_filters).map do |filter|
+            filter.tag
+          end.join(',')
+        end
+        super
+      end
+
+      def to_params
+        super.merge(:"facet.field" => [field_name_with_local_params])
+      end
+
+      private
+
+      def local_params
+        @local_params ||=
+          begin
+            local_params = {}
+            local_params[:ex] = @exclude_tag if @exclude_tag
+            local_params[:key] = @options[:name] if @options[:name]
+            local_params
+          end
+      end
+
+      def field_name_with_local_params
+        if local_params.empty?
+          @field.indexed_name
+        else
+          pairs = local_params.map do |key, value|
+            "#{key}=#{value}"
+          end
+          "{!#{pairs.join(' ')}}#{@field.indexed_name}"
+        end
+      end 
+    end
+  end
+end

data/lib/sunspot/query/filter.rb

@@ -0,0 +1,38 @@
+module Sunspot
+  module Query
+    module Filter
+
+      # 
+      # Express this filter as an :fq parameter; i.e., the boolean phrase,
+      # maybe prefixed by local params.
+      #
+      def to_filter_query
+        if tagged? then "{!tag=#{tag}}#{to_boolean_phrase}"
+        else to_boolean_phrase
+        end
+      end
+
+      #
+      # Generate and return a tag that can be attached to this restriction,
+      # for use with multiselect faceting. This needs to be unique, but doesn't
+      # really need to be human-readable, so just generate a string based on the
+      # hash of the boolean phrase.
+      #
+      def tag
+        @tag ||= to_boolean_phrase.hash.abs.to_s(36)
+      end
+      
+      private
+
+      # 
+      # True if a tag has been generated for this filter (e.g., if it's been
+      # excluded from a given facet). If a tag has not been generated at the
+      # time that the filter query param is requested, then it is not necessary
+      # to include a tag in the local params.
+      #
+      def tagged?
+        !!@tag
+      end
+    end
+  end
+end

data/lib/sunspot/query/function_query.rb

@@ -0,0 +1,52 @@
+module Sunspot
+  module Query
+    # 
+    # Abstract class for function queries.
+    #
+    class FunctionQuery 
+      include RSolr::Char
+    end
+
+    #
+    # Function query which represents a constant.
+    #
+    class ConstantFunctionQuery < FunctionQuery
+      def initialize(constant)
+        @constant = constant
+      end
+
+      def to_s
+        Type.to_literal(@constant)
+      end
+    end
+
+    #
+    # Function query which represents a field.
+    #
+    class FieldFunctionQuery < FunctionQuery
+      def initialize(field)
+        @field = field
+      end
+
+      def to_s
+        "#{escape(@field.indexed_name)}"
+      end
+    end
+
+    #
+    # Function query which represents an actual function invocation.
+    # Takes a function name and arguments as parameters.
+    # Arguments are in turn FunctionQuery objects.
+    #
+    class FunctionalFunctionQuery < FunctionQuery
+      def initialize(function_name, function_args)
+        @function_name, @function_args = function_name, function_args
+      end
+
+      def to_s
+        params = @function_args.map { |arg| arg.to_s }.join(",")
+        "#{@function_name}(#{params})"
+      end
+    end
+  end
+end

data/lib/sunspot/query/geo.rb

@@ -0,0 +1,53 @@
+begin
+  require 'geohash'
+rescue LoadError => e
+  require 'pr_geohash'
+end
+
+module Sunspot
+  module Query
+    class Geo
+      MAX_PRECISION = 12
+      DEFAULT_PRECISION = 7
+      DEFAULT_PRECISION_FACTOR = 16.0
+
+      def initialize(field, lat, lng, options)
+        @field, @options = field, options
+        @geohash = GeoHash.encode(lat.to_f, lng.to_f, MAX_PRECISION)
+      end
+
+      def to_params
+        { :q => to_boolean_query }
+      end
+
+      def to_subquery
+        "(#{to_boolean_query})"
+      end
+
+      private
+
+      def to_boolean_query
+        queries = []
+        MAX_PRECISION.downto(precision) do |i|
+          star = i == MAX_PRECISION ? '' : '*'
+          precision_boost = Util.format_float(
+            boost * precision_factor ** (i-MAX_PRECISION).to_f, 3)
+          queries << "#{@field.indexed_name}:#{@geohash[0, i]}#{star}^#{precision_boost}"
+        end
+        queries.join(' OR ')
+      end
+
+      def precision
+        @options[:precision] || DEFAULT_PRECISION
+      end
+
+      def precision_factor
+        @options[:precision_factor] || DEFAULT_PRECISION_FACTOR
+      end
+
+      def boost
+        @options[:boost] || 1.0
+      end
+    end
+  end
+end

data/lib/sunspot/query/highlighting.rb

@@ -0,0 +1,55 @@
+module Sunspot
+  module Query
+    #
+    # A query component that builds parameters for requesting highlights
+    #
+    class Highlighting #:nodoc:
+      def initialize(fields=[], options={})
+        @fields  = fields
+        @options = options
+      end
+
+      # 
+      # Return Solr highlighting params
+      #
+      def to_params
+        params = {
+          :hl => 'on',
+          :"hl.simple.pre" => '@@@hl@@@',
+          :"hl.simple.post" => '@@@endhl@@@'
+        }
+        unless @fields.empty?
+          params[:"hl.fl"] = @fields.map { |field| field.indexed_name }
+        end
+        if max_snippets = @options[:max_snippets]
+          params.merge!(make_params('snippets', max_snippets))
+        end
+        if fragment_size = @options[:fragment_size]
+          params.merge!(make_params('fragsize', fragment_size))
+        end
+        if @options[:merge_contiguous_fragments]
+          params.merge!(make_params('mergeContiguous', 'true'))
+        end
+        if @options[:phrase_highlighter]
+          params.merge!(make_params('usePhraseHighlighter', 'true'))
+          if @options[:require_field_match]
+            params.merge!(make_params('requireFieldMatch', 'true'))
+          end
+        end
+        params
+      end
+
+      private
+
+      def make_params(name, value)
+        if @fields.empty?
+          { :"hl.#{name}" => value }
+        else
+          @fields.inject({}) do |hash, field|
+            hash.merge!(:"f.#{field.indexed_name}.hl.#{name}" => value)
+          end
+        end
+      end
+    end
+  end
+end

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,38 @@
+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
+
+      def initialize(page = nil, per_page = nil)
+        self.page, self.per_page = 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
+
+      private
+
+      def start
+        (@page - 1) * @per_page
+      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