ruben-sunspot 1.1.0

data/lib/sunspot/query/date_field_facet.rb

@@ -0,0 +1,14 @@
+module Sunspot
+  module Query
+    class DateFieldFacet < AbstractFieldFacet
+      def to_params
+        params = super
+        params[:"facet.date"] = [@field.indexed_name]
+        params[qualified_param('date.start')] = @field.to_indexed(@options[:time_range].first)
+        params[qualified_param('date.end')] = @field.to_indexed(@options[:time_range].last)
+        params[qualified_param('date.gap')] = "+#{@options[:time_interval] || 86400}SECONDS"
+        params
+      end
+    end
+  end
+end

data/lib/sunspot/query/dismax.rb

@@ -0,0 +1,126 @@
+module Sunspot
+  module Query
+
+    #
+    # Solr full-text queries use Solr's DisMaxRequestHandler, a search handler
+    # designed to process user-entered phrases, and search for individual
+    # words across a union of several fields.
+    #
+    class Dismax
+      attr_writer :minimum_match, :phrase_slop, :query_phrase_slop, :tie
+
+      def initialize(keywords)
+        @keywords        = keywords
+        @fulltext_fields = {}
+        @boost_queries   = []
+        @boost_functions = []
+        @highlights      = []
+      end
+
+      #
+      # The query as Solr parameters
+      #
+      def to_params
+        if @boost_functions.empty?
+          params = {:q => @keywords}
+        else
+          params = {:q => "{!boost b=#{@boost_functions.map { |boost_function| boost_function.to_s }} v=#{@keywords} defType=dismax}"}
+        end
+        params[:fl]      = '* score'
+        params[:qf]      = @fulltext_fields.values.map { |field| field.to_boosted_field }.join(' ')
+        params[:defType] = 'dismax'
+        if @phrase_fields
+          params[:pf] = @phrase_fields.map { |field| field.to_boosted_field }.join(' ')
+        end
+        unless @boost_queries.empty?
+          params[:bq] = @boost_queries.map do |boost_query|
+            boost_query.to_boolean_phrase
+          end
+        end
+        if @minimum_match
+          params[:mm] = @minimum_match
+        end
+        if @phrase_slop
+          params[:ps] = @phrase_slop
+        end
+        if @query_phrase_slop
+          params[:qs] = @query_phrase_slop
+        end
+        if @tie
+          params[:tie] = @tie
+        end
+        @highlights.each do |highlight|
+          Sunspot::Util.deep_merge!(params, highlight.to_params)
+        end
+        params
+      end
+
+      #
+      # Serialize the query as a Solr nested subquery.
+      #
+      def to_subquery
+        params = self.to_params
+        params.delete :defType
+        keywords = params.delete(:q)
+        options  = params.map { |key, value| "#{key}='#{escape_quotes(value)}'" }.join(' ')
+        "_query_:\"{!dismax #{options}}#{escape_quotes(keywords)}\""
+      end
+
+      #
+      # Assign a new boost query and return it.
+      #
+      def create_boost_query(factor)
+        @boost_queries << boost_query = BoostQuery.new(factor)
+        boost_query
+      end
+
+      # 
+      # Add a boost function
+      #
+      def add_boost_function(function_query)
+        @boost_functions << function_query
+      end
+
+      #
+      # Add a fulltext field to be searched, with optional boost.
+      #
+      def add_fulltext_field(field, boost = nil)
+        @fulltext_fields[field.indexed_name] = TextFieldBoost.new(field, boost)
+      end
+
+      #
+      # Add a phrase field for extra boost.
+      #
+      def add_phrase_field(field, boost = nil)
+        @phrase_fields ||= []
+        @phrase_fields << TextFieldBoost.new(field, boost)
+      end
+
+      #
+      # Set highlighting options for the query. If fields is empty, the
+      # Highlighting object won't pass field names at all, which means
+      # the dismax's :qf parameter will be used by Solr.
+      #
+      def add_highlight(fields=[], options={})
+        @highlights << Highlighting.new(fields, options)
+      end
+
+      #
+      # Determine if a given field is being searched. Used by DSL to avoid
+      # overwriting boost parameters when injecting defaults.
+      #
+      def has_fulltext_field?(field)
+        @fulltext_fields.has_key?(field.indexed_name)
+      end
+
+
+      private
+
+      def escape_quotes(value)
+        return value unless value.is_a? String
+        value.gsub(/(['"])/, '\\\\\1')
+      end
+
+    end
+  end
+end

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/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/local.rb

@@ -0,0 +1,26 @@
+module Sunspot
+  module Query
+    # 
+    # This query component generates parameters for LocalSolr geo-radial
+    # searches. The LocalSolr API is fairly rigid, so the Local component
+    # doesn't have any options - it just takes coordinates and a radius, and
+    # generates the appropriate parameters.
+    #
+    class Local #:nodoc:
+      def initialize(coordinates, options)
+        @coordinates, @options = Util::Coordinates.new(coordinates), options
+      end
+
+      def to_params
+        local_params = [
+          [:radius, @options[:distance]],
+          [:sort, @options[:sort]]
+        ].map do |key,value|
+          "#{key}=#{value}" if value
+        end.compact.join(" ") #TODO Centralized local param builder
+        query = "{!#{local_params}}#{@coordinates.lat},#{@coordinates.lng}"
+        { :spatial => query }
+      end
+    end
+  end
+end

data/lib/sunspot/query/more_like_this.rb

@@ -0,0 +1,60 @@
+module Sunspot
+  module Query
+    class MoreLikeThis
+      attr_reader :fields
+
+      def initialize(document)
+        @document_scope = Restriction::EqualTo.new(
+          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