nxa-sunspot 0.10.7

data/lib/sunspot/query.rb

@@ -0,0 +1,9 @@
+%w(abstract_field_facet connective boost_query date_field_facet dismax
+   field_facet highlighting local pagination restriction query query_facet
+   scope sort sort_composite text_field_boost).each do |file|
+  require(File.join(File.dirname(__FILE__), 'query', file))
+end
+module Sunspot
+  module Query #:nodoc:all
+  end
+end

data/lib/sunspot/query/abstract_field_facet.rb

@@ -0,0 +1,43 @@
+module Sunspot
+  module Query
+    class AbstractFieldFacet
+      def initialize(field, options)
+        @field, @options = field, options
+      end
+
+      def to_params
+        params = {
+          :facet => 'true',
+        }
+        case @options[:sort]
+        when :count
+          params[qualified_param('sort')] = 'true'
+        when :index
+          params[qualified_param('sort')] = 'false'
+        when nil
+        else
+          raise(
+            ArgumentError,
+            "#{@options[:sort].inspect} is not an allowed value for :sort. Allowed options are :count and :index"
+          )
+        end
+        if @options[:limit]
+          params[qualified_param('limit')] = @options[:limit].to_i
+        end
+        params[qualified_param('mincount')] = 
+          case
+          when @options[:minimum_count] then @options[:minimum_count].to_i
+          when @options[:zeros] then 0
+          else 1
+          end
+        params
+      end
+
+      private
+
+      def qualified_param(param)
+        :"f.#{@field.indexed_name}.facet.#{param}"
+      end
+    end
+  end
+end

data/lib/sunspot/query/boost_query.rb

@@ -0,0 +1,20 @@
+module Sunspot
+  module Query
+    # 
+    # Representation of a BoostQuery, which allows the searcher to specify a
+    # scope for which matching documents should have an extra boost. This is
+    # essentially a conjunction, with an extra instance variable containing
+    # the boost that should be applied.
+    #
+    class BoostQuery < Connective::Conjunction #:nodoc:
+      def initialize(boost)
+        super(false)
+        @boost = boost
+      end
+
+      def to_boolean_phrase
+        "#{super}^#{@boost}"
+      end
+    end
+  end
+end

data/lib/sunspot/query/connective.rb

@@ -0,0 +1,189 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:all
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract
+        def initialize(negated = false) #:nodoc:
+          @negated = negated
+          @components = []
+        end
+
+        # 
+        # Add a restriction to the connective.
+        #
+        def add_restriction(field, restriction_type, value, negated = false)
+          @components << restriction_type.new(field, value, negated)
+        end
+
+        # 
+        # Add a shorthand restriction; the restriction type is determined by
+        # the value.
+        #
+        def add_shorthand_restriction(field, value, negated = false)
+          restriction_type =
+            case value
+            when Array then Restriction::AnyOf
+            when Range then Restriction::Between
+            else Restriction::EqualTo
+            end
+          add_restriction(field, restriction_type, value, negated)
+        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(field, restriction_type, value, true)
+        end
+
+        # 
+        # Add a negated shorthand restriction (see add_shorthand_restriction)
+        #
+        def add_negated_shorthand_restriction(field, value)
+          add_shorthand_restriction(field, value, true)
+        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,88 @@
+module Sunspot
+  module Query
+    class Dismax
+      attr_writer :minimum_match, :phrase_slop, :query_phrase_slop, :tie
+
+      def initialize(keywords)
+        @keywords = keywords
+        @fulltext_fields = {}
+        @boost_queries = []
+        @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
+        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
+
+      # 
+      # 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 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
+    end
+  end
+end

data/lib/sunspot/query/field_facet.rb

@@ -0,0 +1,9 @@
+module Sunspot
+  module Query
+    class FieldFacet < AbstractFieldFacet
+      def to_params
+        super.merge(:"facet.field" => [@field.indexed_name])
+      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,27 @@
+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, radius)
+        if radius < 1
+          raise ArgumentError, "LocalSolr does not seem to support a radius of less than 1 mile."
+        end
+        @coordinates, @radius = Util::Coordinates.new(coordinates), radius
+      end
+
+      def to_params
+        {
+          :qt => 'geo',
+          :lat => @coordinates.lat,
+          :long => @coordinates.lng,
+          :radius => @radius
+        }
+      end
+    end
+  end
+end