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

data/sunspot/lib/sunspot/query/date_field_facet.rb

@@ -1,14 +0,0 @@
-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/sunspot/lib/sunspot/query/dismax.rb

@@ -1,132 +0,0 @@
-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
-        params = { :q => @keywords }
-        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
-        unless @boost_functions.empty?
-          params[:bf] = @boost_functions.map do |boost_function|
-            boost_function.to_s
-          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
-        params.delete :fl
-        keywords = params.delete(:q)
-        options = params.map { |key, value| escape_param(key, 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_param(key, value)
-        "#{key}='#{escape_quotes(Array(value).join(" "))}'"
-      end
-
-      def escape_quotes(value)
-        return value unless value.is_a? String
-        value.gsub(/(['"])/, '\\\\\1')
-      end
-
-    end
-  end
-end

data/sunspot/lib/sunspot/query/field_facet.rb

@@ -1,41 +0,0 @@
-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/sunspot/lib/sunspot/query/field_group.rb

@@ -1,37 +0,0 @@
-module Sunspot
-  module Query
-    #
-    # A FieldGroup groups by the unique values of a given field.
-    #
-    class FieldGroup
-      attr_accessor :limit, :truncate
-
-      def initialize(field)
-        if field.multiple?
-          raise(ArgumentError, "#{field.name} cannot be used for grouping because it is a multiple-value field")
-        end
-        @field = field
-
-        @sort = SortComposite.new
-      end
-
-      def add_sort(sort)
-        @sort << sort
-      end
-
-      def to_params
-        params = {
-          :group            => "true",
-          :"group.ngroups"  => "true",
-          :"group.field"    => @field.indexed_name
-        }
-
-        params.merge!(@sort.to_params("group."))
-        params[:"group.limit"] = @limit if @limit
-        params[:"group.truncate"] = @truncate if @truncate
-
-        params
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/query/filter.rb

@@ -1,38 +0,0 @@
-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/sunspot/lib/sunspot/query/function_query.rb

@@ -1,52 +0,0 @@
-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/sunspot/lib/sunspot/query/geo.rb

@@ -1,53 +0,0 @@
-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/sunspot/lib/sunspot/query/geofilt.rb

@@ -1,16 +0,0 @@
-module Sunspot
-  module Query
-    class Geofilt
-      def initialize(field, lat, lon, radius, options = {})
-        @field, @lat, @lon, @radius, @options = field, lat, lon, radius, options
-      end
-
-      def to_params
-        func = @options[:bbox] ? "bbox" : "geofilt"
-
-        filter = "{!#{func} sfield=#{@field.indexed_name} pt=#{@lat},#{@lon} d=#{@radius}}"
-        {:fq => filter}
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/query/highlighting.rb

@@ -1,62 +0,0 @@
-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
-        if formatter = @options[:formatter]
-          params.merge!(make_params('formatter', formatter))
-        end
-        if fragmenter = @options[:fragmenter]
-          params.merge!(make_params('fragmenter', fragmenter))
-        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