gojee-sunspot 2.0.3 → 2.0.4

data/lib/sunspot/query/common_query.rb

@@ -0,0 +1,96 @@
+module Sunspot
+  module Query #:nodoc:
+    class CommonQuery
+      def initialize(types)
+        @scope = Scope.new
+        @sort = SortComposite.new
+        @components = [@scope, @sort]
+        if types.length == 1
+          @scope.add_positive_restriction(TypeField.instance, Restriction::EqualTo, types.first)
+        else
+          @scope.add_positive_restriction(TypeField.instance, Restriction::AnyOf, types)
+        end
+      end
+
+      def solr_parameter_adjustment=(block)
+        @parameter_adjustment = block
+      end
+
+      def add_sort(sort)
+        @sort << sort
+      end
+
+      def add_group(group)
+        @components << group
+        group
+      end
+
+      def add_field_facet(facet)
+        @components << facet
+        facet
+      end
+
+      def add_query_facet(facet)
+        @components << facet
+        facet
+      end
+
+      def add_function(function)
+        @components << function
+        function
+      end
+
+      def add_geo(geo)
+        @components << geo
+        geo
+      end
+
+      def paginate(page, per_page, offset = nil)
+        if @pagination
+          @pagination.offset = offset
+          @pagination.page = page
+          @pagination.per_page = per_page
+        else
+          @components << @pagination = Pagination.new(page, per_page, offset)
+        end
+      end
+
+      def to_params
+        params = {}
+        @components.each do |component|
+          Sunspot::Util.deep_merge!(params, component.to_params)
+        end
+        @parameter_adjustment.call(params) if @parameter_adjustment
+        params[:q] ||= '*:*'
+        params
+      end
+
+      def [](key)
+        to_params[key.to_sym]
+      end
+
+      def page
+        @pagination.page if @pagination
+      end
+
+      def per_page
+        @pagination.per_page if @pagination
+      end
+
+
+      private
+
+      #
+      # If we have a single fulltext query, merge is normally. If there are
+      # multiple nested queries, serialize them as `_query_` subqueries.
+      #
+      def merge_fulltext(params)
+        return nil if @fulltexts.empty?
+        return Sunspot::Util.deep_merge!(params, @fulltexts.first.to_params) if @fulltexts.length == 1
+        subqueries = @fulltexts.map {|fulltext| fulltext.to_subquery }.join(' ')
+        Sunspot::Util.deep_merge!(params, {:q => subqueries})
+      end
+
+    end
+  end
+end

data/lib/sunspot/query/composite_fulltext.rb

@@ -0,0 +1,36 @@
+module Sunspot
+  module Query
+    class CompositeFulltext
+      def initialize
+        @components = []
+      end
+
+      def add(keywords)
+        @components << dismax = Dismax.new(keywords)
+        dismax
+      end
+      
+      def add_location(field, lat, lng, options)
+        @components << location = Geo.new(field, lat, lng, options)
+        location
+      end
+
+      def to_params
+        case @components.length
+        when 0
+          {}
+        when 1
+          @components.first.to_params.merge(:fl => '* score')
+        else
+          to_subqueries.merge(:fl => '* score')
+        end
+      end
+
+      private
+
+      def to_subqueries
+        { :q => @components.map { |dismax| dismax.to_subquery }.join(' ') }
+      end
+    end
+  end
+end

data/lib/sunspot/query/connective.rb

@@ -0,0 +1,206 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:all
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract
+        include Filter
+
+        def initialize(negated = false) #:nodoc:
+          @negated = negated
+          @components = []
+        end
+
+        # 
+        # Add a restriction to the connective.
+        #
+        def add_restriction(negated, field, restriction_type, *value)
+          add_component(restriction_type.new(negated, field, *value))
+        end
+
+        # 
+        # Add a shorthand restriction; the restriction type is determined by
+        # the value.
+        #
+        def add_shorthand_restriction(negated, field, value)
+          restriction_type =
+            case value
+            when Array then Restriction::AnyOf
+            when Range then Restriction::Between
+            else Restriction::EqualTo
+            end
+          add_restriction(negated, field, restriction_type, value)
+        end
+
+        # 
+        # Add a positive restriction. The restriction will match all
+        # documents who match the terms fo the restriction.
+        #
+        def add_positive_restriction(field, restriction_type, value)
+          add_restriction(false, field, restriction_type, value)
+        end
+
+        # 
+        # Add a positive shorthand restriction (see add_shorthand_restriction)
+        #
+        def add_positive_shorthand_restriction(field, value)
+          add_shorthand_restriction(false, field, value)
+        end
+
+        # 
+        # Add a negated restriction. The added restriction will match all
+        # documents who do not match the terms of the restriction.
+        #
+        def add_negated_restriction(field, restriction_type, value)
+          add_restriction(true, field, restriction_type, value)
+        end
+
+        # 
+        # Add a negated shorthand restriction (see add_shorthand_restriction)
+        #
+        def add_negated_shorthand_restriction(field, value)
+          add_shorthand_restriction(true, field, value)
+        end
+
+        # 
+        # Add a new conjunction and return it.
+        #
+        def add_conjunction
+          add_component(Conjunction.new)
+        end
+
+        # 
+        # Add a new disjunction and return it.
+        #
+        def add_disjunction
+          add_component(Disjunction.new)
+        end
+
+        # 
+        # Add an arbitrary component to the conjunction, and return it.
+        # The component must respond to #to_boolean_phrase
+        #
+        def add_component(component)
+          @components << component
+          component
+        end
+
+        # 
+        # Express the connective as a Lucene boolean phrase.
+        #
+        def to_boolean_phrase #:nodoc:
+          unless @components.empty?
+            phrase =
+              if @components.length == 1
+                @components.first.to_boolean_phrase
+              else
+                component_phrases = @components.map do |component|
+                  component.to_boolean_phrase
+                end
+                "(#{component_phrases.join(" #{connector} ")})"
+              end
+            if negated?
+              "-#{phrase}"
+            else
+              phrase
+            end
+          end
+        end
+
+        # 
+        # Connectives can be negated during the process of denormalization that
+        # is performed when a disjunction contains a negated component. This
+        # method conforms to the duck type for all boolean query components.
+        #
+        def negated?
+          @negated
+        end
+
+        # 
+        # Returns a new connective that's a negated version of this one.
+        #
+        def negate
+          negated = self.class.new(!negated?)
+          @components.each do |component|
+            negated.add_component(component)
+          end
+          negated
+        end
+      end
+
+      # 
+      # Disjunctions combine their components with an OR operator.
+      #
+      class Disjunction < Abstract
+        class <<self
+          def inverse
+            Conjunction
+          end
+        end
+
+        # 
+        # Express this disjunction as a Lucene boolean phrase
+        #
+        def to_boolean_phrase
+          if @components.any? { |component| component.negated? }
+            denormalize.to_boolean_phrase
+          else
+            super
+          end
+        end
+
+        # 
+        # No-op - this is already a disjunction
+        #
+        def add_disjunction
+          self
+        end
+
+        private
+
+        def connector
+          'OR'
+        end
+
+        # 
+        # If a disjunction contains negated components, it must be
+        # "denormalized", because the Lucene parser interprets any negated
+        # boolean phrase using AND semantics (this isn't a bug, it's just a
+        # subtlety of how Lucene parses queries). So, per DeMorgan's law we
+        # create a negated conjunction and add to it all of our components,
+        # negated themselves, which creates a query whose Lucene semantics are
+        # in line with our intentions.
+        #
+        def denormalize
+          denormalized = self.class.inverse.new(!negated?)
+          @components.each do |component|
+            denormalized.add_component(component.negate)
+          end
+          denormalized
+        end
+      end
+
+      # 
+      # Conjunctions combine their components with an AND operator.
+      #
+      class Conjunction < Abstract
+        class <<self
+          def inverse
+            Disjunction
+          end
+        end
+
+        def add_conjunction
+          self
+        end
+
+        private
+
+        def connector
+          'AND'
+        end
+      end
+    end
+  end
+end

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,132 @@
+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/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/field_group.rb

@@ -0,0 +1,36 @@
+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.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/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