benjaminkrause-sunspot 0.9.7

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, setup)
+        super(setup)
+        @boost = boost
+      end
+
+      def to_boolean_phrase
+        "#{super}^#{@boost}"
+      end
+    end
+  end
+end

data/lib/sunspot/query/connective.rb

@@ -0,0 +1,148 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:all
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract < Scope
+        def initialize(setup, negated = false) #:nodoc:
+          super(setup)
+          @negated = negated
+        end
+
+        # 
+        # Connective as solr params.
+        #
+        def to_params #:nodoc:
+          if boolean_phrase = to_boolean_phrase
+            { :fq => to_boolean_phrase }
+          else
+            {}
+          end
+        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(@setup, !negated?)
+          for component in @components
+            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
+
+        # 
+        # Add a conjunction to the disjunction. This overrides the method in
+        # the Scope class since scopes are implicitly conjunctive and thus
+        # can return themselves as a conjunction. Inside a disjunction, however,
+        # a conjunction must explicitly be created.
+        #
+        def add_conjunction
+          @components << conjunction = Conjunction.new(@setup)
+          conjunction
+        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(@setup, !negated?)
+          for component in @components
+            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
+
+        private
+
+        def connector
+          'AND'
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/dynamic_query.rb

@@ -0,0 +1,61 @@
+module Sunspot
+  module Query
+    #
+    # A dynamic query is a proxy object that implements the API of the FieldQuery
+    # class, but wraps a dynamic field factory and thus applies the query
+    # components using dynamic field instances.
+    #--
+    # Dynamic queries do not hold their own state, but rather proxy to the query
+    # that generated them, adding components directly to the owning query's
+    # internal state.
+    #++
+    # DynamicQuery instances are publicly generated by the Query#dynamic_query
+    # factory method.
+    # 
+    class DynamicQuery < FieldQuery #:nodoc:
+      def initialize(dynamic_field_factory, query) #:nodoc:
+        super(dynamic_field_factory)
+        @query = query
+      end
+      
+      # 
+      # This has the same effect as calling Query#exclude_instance; it is
+      # included for interface completeness.
+      #
+      def exclude_instance(instance)
+        @query.exclude_instance(instance)
+      end
+
+      # 
+      # This has the same effect as calling Query#exclude_instance; it is
+      # included for interface completeness.
+      #
+      def dynamic_query(field_name)
+        @query.dynamic_query(field_name)
+      end
+
+      # 
+      # Add a Sort to the query
+      #
+      def add_sort(sort) #:nodoc:
+        @query.add_sort(sort)
+      end
+
+      # 
+      # Add a component to the query
+      #
+      def add_component(component) #:nodoc:
+        @query.add_component(component)
+      end
+
+      private
+      
+      # 
+      # So query facets can be added to the query from within dynamic queries
+      #
+      def query_facets
+        @query.query_facets
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_facet.rb

@@ -0,0 +1,129 @@
+require 'set'
+
+module Sunspot
+  module Query
+    #
+    # Encapsulates a query component representing a field facet. Users create
+    # instances using DSL::Query#facet
+    #
+    class FieldFacet #:nodoc:
+      class <<self
+        protected :new
+
+        # 
+        # Return the appropriate FieldFacet instance for the field and options.
+        # If a :time_range option is specified, and the field type is TimeType,
+        # build a DateFieldFacet. Otherwise, build a normal FieldFacet.
+        #
+        # ==== Returns
+        #
+        # FieldFacet:: FieldFacet instance of appropriate class.
+        #
+        def build(field, options)
+          if options.has_key?(:time_range)
+            unless field.type == Type::TimeType
+              raise(
+                ArgumentError,
+                ":time_range key can only be specified for time fields"
+              )
+            end
+            DateFieldFacet.new(field, options)
+          elsif options.has_key?(:only)
+            QueryFieldFacet.new(field, options.delete(:only))
+          else
+            FieldFacet.new(field, options)
+          end
+        end
+      end
+
+      def initialize(field, options)
+        @field, @options = field, options
+      end
+
+      # ==== Returns
+      #
+      # Hash:: solr-ruby params for this field facet
+      #
+      def to_params
+        params = { :"facet.field" => [@field.indexed_name], :facet => 'true' }
+        params[param_key(:sort)] = 
+          case @options[:sort]
+          when :count then 'true'
+          when :index then 'false'
+          when nil
+          else raise(ArgumentError, 'Allowed facet sort options are :count and :index')
+          end
+        params[param_key(:limit)] = @options[:limit]
+        params[param_key(:mincount)] =
+          if @options[:minimum_count] then @options[:minimum_count]
+          elsif @options[:zeros] then 0
+          else 1
+          end
+        params
+      end
+
+      private
+
+      # 
+      # Given a facet parameter name, return the appropriate Solr parameter for
+      # this facet.
+      #
+      # ==== Returns
+      #
+      # Symbol:: Solr query parameter key
+      #
+      def param_key(name)
+        :"f.#{@field.indexed_name}.facet.#{name}"
+      end
+    end
+
+    class DateFieldFacet < FieldFacet #:nodoc:
+      # 
+      # Convert the facet to date params.
+      #
+      def to_params
+        super.merge(
+          :"facet.date" => [@field.indexed_name],
+          param_key('date.start') => start_time.utc.xmlschema,
+          param_key('date.end') => end_time.utc.xmlschema,
+          param_key('date.gap') => "+#{interval}SECONDS"
+        )
+      end
+
+      private
+
+      # 
+      # Start time for facet range
+      #
+      # ==== Returns
+      #
+      # Time:: Start time
+      #
+      def start_time
+        @options[:time_range].first
+      end
+
+      # 
+      # End time for facet range
+      #
+      # ==== Returns
+      #
+      # Time:: End time
+      #
+      def end_time
+        @options[:time_range].last
+      end
+
+      # 
+      # Time interval that each facet row should cover. Default is 1 day.
+      #
+      # ===== Returns
+      #
+      # Integer:: Time interval in seconds
+      #
+      def interval
+        @options[:time_interval] || 86400
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_query.rb

@@ -0,0 +1,69 @@
+module Sunspot
+  module Query
+    # 
+    # This class acts as a base class for query components that encapsulate
+    # operations on fields. It is subclassed by the Query::Query class and the
+    # Query::DynamicQuery class.
+    #
+    class FieldQuery < Scope #:nodoc:
+      # 
+      # Add a field facet. See Sunspot::Facet for more information.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to get a facet
+      #
+      # ==== Returns
+      #
+      # FieldFacet:: The field facet object
+      #
+      def add_field_facet(field_name, options = nil)
+        options ||= {}
+        facet =
+          if only = options.delete(:only)
+            query_facets[field_name.to_sym] = QueryFieldFacet.new(@setup.field(field_name), only, options) 
+          else
+            FieldFacet.build(build_field(field_name), options)
+          end
+        add_component(facet)
+      end
+
+      # 
+      # Add a query facet.
+      #
+      # ==== Parameters
+      #
+      # name<Symbol>::
+      #   The name associated with the query facet. This is not passed to Solr,
+      #   but allows the user to retrieve the facet result by passing the name
+      #   to the Search#facet method.
+      #
+      # ==== Returns
+      #
+      # QueryFacet:: The query facet object
+      #
+      def add_query_facet(name, options)
+        add_component(facet = QueryFacet.new(name, options, @setup))
+        query_facets[name.to_sym] = facet
+      end
+
+      # 
+      # Set result ordering.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to order
+      # direction<Symbol>:: :asc or :desc (default :asc)
+      #
+      def order_by(field_name, direction = nil)
+        sort =
+          if special = Sort.special(field_name)
+            special.new(direction)
+          else
+            Sort::FieldSort.new(build_field(field_name), direction)
+          end
+        add_sort(sort)
+      end
+    end
+  end
+end

data/lib/sunspot/query/fulltext_base_query.rb

@@ -0,0 +1,86 @@
+module Sunspot
+  module Query
+    class FulltextBaseQuery < BaseQuery #:nodoc:
+      def initialize(keywords, options, types, setup)
+        super(types, setup)
+        @keywords = keywords
+        if highlight_options = options.delete(:highlight)
+          if highlight_options == true
+            set_highlight
+          else
+            set_highlight(highlight_options)
+          end
+        end
+        if fulltext_fields = options.delete(:fields)
+          Array(fulltext_fields).each do |field|
+            add_fulltext_field(field)
+          end
+        end
+      end
+
+      def to_params
+        params = { :q => @keywords }
+        params[:fl] = '* score'
+        params[:fq] = types_phrase
+        params[:qf] = query_fields
+        params[:defType] = 'dismax'
+        if @phrase_fields
+          params[:pf] = @phrase_fields.map { |field| field.to_boosted_field }.join(' ')
+        end
+        if @boost_query
+          params[:bq] = @boost_query.to_boolean_phrase
+        end
+        if @highlight
+          Sunspot::Util.deep_merge!(params, @highlight.to_params)
+        end
+        params
+      end
+
+      def add_fulltext_field(field_name, boost = nil)
+        @fulltext_fields ||= []
+        @fulltext_fields.concat(
+          @setup.text_fields(field_name).map do |field|
+            TextFieldBoost.new(field, boost)
+          end
+        )
+      end
+
+      def add_phrase_field(field_name, boost = nil)
+        @phrase_fields ||= []
+        @phrase_fields.concat(
+          @setup.text_fields(field_name).map do |field|
+            TextFieldBoost.new(field, boost)
+          end
+        )
+      end
+
+      def create_boost_query(factor)
+        @boost_query ||= BoostQuery.new(factor, @setup)
+      end
+
+      def set_highlight(options = {})
+        @highlight = Highlighting.new(options)
+      end
+
+      private
+
+      # 
+      # Returns the names of text fields that should be queried in a keyword
+      # search. If specific fields are requested, use those; otherwise use the
+      # union of all fields configured for the types under search.
+      #
+      def query_fields
+        @query_fields ||=
+          begin
+            fulltext_fields =
+              @fulltext_fields || @setup.all_text_fields.map do |field|
+                TextFieldBoost.new(field)
+              end
+            fulltext_fields.map do |fulltext_field|
+              fulltext_field.to_boosted_field
+            end.join(' ')
+          end
+      end
+    end
+  end
+end

data/lib/sunspot/query/highlighting.rb

@@ -0,0 +1,36 @@
+module Sunspot
+  module Query
+    #
+    # A query component that builds parameters for requesting highlights
+    #
+    class Highlighting #:nodoc:
+      def initialize(options)
+        @options = options
+      end
+
+      def to_params
+        params = {
+          :hl => 'on',
+          :"hl.simple.pre" => '@@@hl@@@',
+          :"hl.simple.post" => '@@@endhl@@@'
+        }
+        if max_snippets = @options[:max_snippets]
+          params[:"hl.snippets"] = max_snippets
+        end
+        if fragment_size = @options[:fragment_size]
+          params[:"hl.fragsize"] = fragment_size
+        end
+        if @options[:merge_continuous_fragments]
+          params[:"hl.mergeContinuous"] = 'true'
+        end
+        if @options[:phrase_highlighter]
+          params[:"hl.usePhraseHighlighter"] = 'true'
+          if @options[:require_field_match]
+            params[:"hl.requireFieldMatch"] = 'true'
+          end
+        end
+        params
+      end
+    end
+  end
+end

data/lib/sunspot/query/local.rb

@@ -0,0 +1,24 @@
+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)
+        @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

data/lib/sunspot/query/pagination.rb

@@ -0,0 +1,39 @@
+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(configuration, page = nil, per_page = nil)
+        @configuration = configuration
+        self.page, self.per_page = page, per_page
+      end
+
+      def to_params
+        { :start => start, :rows => rows }
+      end
+
+      def page=(page)
+        @page = (page || 1).to_i
+      end
+
+      def per_page=(per_page)
+        @per_page = (per_page || @configuration.pagination.default_per_page).to_i
+      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,78 @@
+module Sunspot
+  module Query
+    # 
+    # QueryFacets encapsulate requests for Sunspot's query faceting capability.
+    # They are created by the FieldQuery#add_query_facet method.
+    #
+    #--
+    #
+    # The actual concept of a QueryFacet is somewhat artificial - it provides a
+    # grouping for the facet at the Sunspot level, which provides a nicer and
+    # more consistent API in Sunspot; Solr does not provide any grouping for
+    # query facet rows, instead returning each requested row individually, keyed
+    # by the boolean phrase used in the facet query.
+    #
+    class QueryFacet #:nodoc:
+      attr_reader :name #:nodoc:
+      attr_reader :field #:nodoc:
+      attr_reader :options #:nodoc:
+
+      def initialize(name, options, setup = nil) #:nodoc:
+        @name, @options, @setup = name, options, setup
+        @components = []
+      end
+
+      #
+      # Add a QueryFacetRow to this facet. The label argument becomes the value
+      # of the Sunspot::QueryFacetRow object corresponding to this query facet
+      # row.
+      #
+      # ==== Parameters
+      #
+      # label<Object>::
+      #   An object that will become the value of the result row. Use whatever
+      #   type is most intuitive.
+      #
+      # ==== Returns
+      #
+      # QueryFacetRow:: QueryFacetRow object containing scope for this row
+      #
+      def add_row(label)
+        @components << row = QueryFacetRow.new(label, @setup)
+        row
+      end
+
+      # 
+      # Express this query facet as Solr parameters
+      #
+      # ==== Returns
+      #
+      # Hash:: Solr params hash
+      #
+      def to_params #:nodoc:
+        components = @components.map { |component| component.to_boolean_phrase }
+        components.compact!
+        if components.empty?
+          {}
+        else
+          components = components.first if components.length == 1
+          {
+            :facet => 'true',
+            :"facet.query" => components
+          }
+        end
+      end
+
+      # 
+      # Get query facet rows (used when constructing results)
+      #
+      # ==== Returns
+      #
+      # Array:: Array of QueryFacetRow objects.
+      #
+      def rows #:nodoc:
+        @components
+      end
+    end
+  end
+end