UnderpantsGnome-sunspot 0.9.1.1

data/lib/sunspot/instantiated_facet.rb

@@ -0,0 +1,38 @@
+module Sunspot
+  #
+  # InstantiatedFacet instances allow access to a model instance based on a
+  # primary key stored in facet rows' values. The rows are hydrated lazily, but
+  # all rows are hydrated the first time #instance is called on any of the rows.
+  #
+  # The #rows method returns InstantiatedFacetRow objects.
+  #
+  class InstantiatedFacet < Facet
+    # 
+    # Hydrate all rows for the facet. For data accessors that can efficiently
+    # batch load, this is more efficient than individually lazy-loading
+    # instances for each row, but allows us to still stay lazy and not do work
+    # in the persistent store if the instances are not needed.
+    #
+    def populate_instances! #:nodoc:
+      ids = rows.map { |row| row.value }
+      reference_class = Sunspot::Util.full_const_get(@field.reference.to_s)
+      accessor = Adapters::DataAccessor.create(reference_class)
+      instance_map = accessor.load_all(ids).inject({}) do |map, instance|
+        map[Adapters::InstanceAdapter.adapt(instance).id] = instance
+        map
+      end
+      for row in rows
+        row.instance = instance_map[row.value]
+      end
+    end
+
+    private
+
+    # 
+    # Override the Facet#new_row method to return an InstantiateFacetRow
+    #
+    def new_row(pair)
+      InstantiatedFacetRow.new(pair, self)
+    end
+  end
+end

data/lib/sunspot/instantiated_facet_row.rb

@@ -0,0 +1,12 @@
+module Sunspot
+  class InstantiatedFacetRow < FacetRow
+    attr_writer :instance
+
+    def instance
+      unless defined?(@instance)
+        @facet.populate_instances!
+      end
+      @instance
+    end
+  end
+end

data/lib/sunspot/query.rb

@@ -0,0 +1,190 @@
+%w(base_query scope field_query connective dynamic_query field_facet query_facet
+   query_facet_row pagination restriction sort sort_composite).each do |file|
+  require File.join(File.dirname(__FILE__), 'query', file)
+end
+
+module Sunspot
+  module Query #:nodoc:
+    # 
+    # This class encapsulates a query that is to be sent to Solr. The query is
+    # constructed in the block passed to the Sunspot.search method, using the
+    # Sunspot::DSL::Query interface. It can also be accessed directly by calling
+    # #query on a Search object (presumably a not-yet-run one created using
+    # Sunspot#new_search), which might be more suitable than the DSL when an
+    # intermediate object has responsibility for building the query dynamically.
+    #--
+    # Instances of Query, as well as all of the components it contains, respond to
+    # the #to_params method, which returns a hash of parameters in the format
+    # recognized by the solr-ruby API.
+    #
+    class Query < FieldQuery
+      attr_reader :query_facets #:nodoc:
+
+      def initialize(setup, configuration) #:nodoc:
+        @setup, @configuration = setup, configuration
+        @components = []
+        @query_facets = {}
+        @components << @base_query = BaseQuery.new(setup)
+        @components << @pagination = Pagination.new(@configuration)
+        @components << @sort = SortComposite.new
+      end
+
+      # 
+      # Set the keywords for this query. Keywords are parsed with Solr's dismax
+      # handler.
+      #
+      def keywords=(keywords)
+        set_keywords(keywords)
+      end
+
+      # 
+      # Add a component to the query. Used by objects that proxy to the query
+      # object.
+      # 
+      # ==== Parameters
+      # 
+      # component<~to_params>:: Query component to add.
+      # 
+      def add_component(component) #:nodoc:
+        @components << component
+      end
+
+      #
+      # Sets @start and @rows instance variables using pagination semantics
+      #
+      # ==== Parameters
+      #
+      # page<Integer>:: Page on which to start
+      # per_page<Integer>::
+      #   How many rows to display per page. Default taken from
+      #   Sunspot.config.pagination.default_per_page
+      #
+      def paginate(page, per_page = nil)
+        @pagination.page, @pagination.per_page = page, per_page
+      end
+
+      # 
+      # Add random ordering to the search. This can be added after other
+      # field-based sorts if desired.
+      #
+      def order_by_random
+        add_sort(Sort.new(RandomField.new))
+      end
+
+      # 
+      # Representation of this query as solr-ruby parameters. Constructs the hash
+      # by deep-merging scope and facet parameters, adding in various other
+      # parameters from instance data.
+      #
+      # Note that solr-ruby takes the :q parameter as a separate argument; for
+      # the sake of consistency, the Query object ignores this fact (the Search
+      # object extracts it back out).
+      #
+      # ==== Returns
+      #
+      # Hash:: Representation of query in solr-ruby form
+      #
+      def to_params #:nodoc:
+        params = {}
+        query_components = []
+        for component in @components
+          Util.deep_merge!(params, component.to_params)
+        end
+        params
+      end
+
+      # 
+      # Page that this query will return (used by Sunspot::Search to expose
+      # pagination)
+      #
+      # ==== Returns
+      #
+      # Integer:: Page number
+      #
+      def page #:nodoc:
+        @pagination.page
+      end
+
+      #
+      # Number of rows per page that this query will return (used by
+      # Sunspot::Search to expose pagination)
+      #
+      # ==== Returns
+      #
+      # Integer:: Rows per page
+      #
+      def per_page #:nodoc:
+        @pagination.per_page
+      end
+
+      # 
+      # Get the query facet with the given name. Used by the Search object to
+      # match query facet results with the requested query facets.
+      #
+      def query_facet(name) #:nodoc:
+        @query_facets[name.to_sym]
+      end
+
+      # 
+      # Add a Sort object into this query's sort composite.
+      #
+      def add_sort(sort) #:nodoc:
+        @sort << sort
+      end
+
+      # 
+      # Set the keywords for this query, along with keyword options. See
+      # Query::BaseQuery for information on what the options do.
+      #
+      def set_keywords(keywords, options = {}) #:nodoc:
+        @base_query.keywords = keywords
+        @base_query.keyword_options = options
+      end
+
+      # 
+      # Pass in search options as a hash. This is not the preferred way of
+      # building a Sunspot search, but it is made available as experience shows
+      # Ruby developers like to pass in hashes. Probably nice for quick one-offs
+      # on the console, anyway.
+      #
+      # ==== Options (+options+)
+      #
+      # :keywords:: Keyword string for fulltext search
+      # :conditions::
+      #   Hash of key-value pairs, where keys are field names, and values are one
+      #   of scalar, Array, or Range. Scalars are evaluated as EqualTo
+      #   restrictions; Arrays are AnyOf restrictions, and Ranges are Between
+      #   restrictions.
+      # :order::
+      #   Order the search results. Either a string or array of strings of the
+      #   form "field_name direction"
+      # :page::
+      #   Page to use for pagination
+      # :per_page::
+      #   Number of results to show per page
+      #
+      def options=(options) #:nodoc:
+        if options.has_key?(:keywords)
+          self.keywords = options[:keywords]
+        end
+        if options.has_key?(:conditions)
+          options[:conditions].each_pair do |field_name, value|
+            begin
+              add_shorthand_restriction(field_name, value)
+            rescue UnrecognizedFieldError
+              # ignore fields we don't recognize
+            end
+          end
+        end
+        if options.has_key?(:order)
+          for order in Array(options[:order])
+            order_by(*order.split(' '))
+          end
+        end
+        if options.has_key?(:page)
+          paginate(options[:page], options[:per_page])
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/base_query.rb

@@ -0,0 +1,90 @@
+module Sunspot
+  module Query
+    #
+    # Encapsulates information common to all queries - in particular, keywords
+    # and types.
+    #
+    class BaseQuery #:nodoc:
+      include RSolr::Char
+
+      attr_writer :keywords
+
+      def initialize(setup)
+        @setup = setup
+      end
+
+      # 
+      # Generate params for the base query. If keywords are specified, build
+      # params for a dismax query, request all stored fields plus the score,
+      # and put the types in a filter query. If keywords are not specified,
+      # put the types query in the q parameter.
+      #
+      def to_params
+        params = {}
+        if @keywords
+          params[:q] = @keywords
+          params[:fl] = '* score'
+          params[:fq] = types_phrase
+          params[:qf] = text_field_names.join(' ')
+          params[:defType] = 'dismax'
+        else
+          params[:q] = types_phrase
+        end
+        params
+      end
+
+      # 
+      # Set keyword options
+      #
+      def keyword_options=(options)
+        if options
+          @text_field_names = options.delete(:fields)
+        end
+      end
+
+      private
+
+      # 
+      # Boolean phrase that restricts results to objects of the type(s) under
+      # query. If this is an open query (no types specified) then it sends a
+      # no-op phrase because Solr requires that the :q parameter not be empty.
+      #
+      # ==== Returns
+      #
+      # String:: Boolean phrase for type restriction
+      #
+      def types_phrase
+        if escaped_types.length == 1 then "type:#{escaped_types.first}"
+        else "type:(#{escaped_types * ' OR '})"
+        end
+      end
+
+      #
+      # Wraps each type in quotes to escape names of the form Namespace::Class
+      #
+      def escaped_types
+        @escaped_types ||=
+          @setup.type_names.map { |name| escape(name)}
+      end
+
+      # 
+      # 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 text_field_names
+        text_fields =
+          if @text_field_names
+            Array(@text_field_names).map do |field_name|
+              @setup.text_field(field_name.to_sym)
+            end
+          else
+            @setup.text_fields
+          end
+        text_fields.map do |text_field|
+          text_field.indexed_name
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/connective.rb

@@ -0,0 +1,77 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract < Scope
+        def initialize(setup) #:nodoc:
+          @setup = setup
+          @components = []
+        end
+
+        # 
+        # Connective as solr params.
+        #
+        def to_params #:nodoc:
+          { :fq => to_boolean_phrase }
+        end
+
+        # 
+        # Express the connective as a Lucene boolean phrase.
+        #
+        def to_boolean_phrase #:nodoc:
+          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
+        end
+
+        # 
+        # Add a component to the connective. All components must implement the
+        # #to_boolean_phrase method.
+        #
+        def add_component(component) #:nodoc:
+          @components << component
+        end
+      end
+
+      # 
+      # Disjunctions combine their components with an OR operator.
+      #
+      class Disjunction < Abstract
+        # 
+        # 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
+
+        private
+
+        def connector
+          'OR'
+        end
+      end
+
+      # 
+      # Conjunctions combine their components with an AND operator.
+      #
+      class Conjunction < Abstract
+        private
+
+        def connector
+          'AND'
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/dynamic_query.rb

@@ -0,0 +1,69 @@
+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
+      def initialize(dynamic_field_factory, query) #:nodoc:
+        @dynamic_field_factory, @query = dynamic_field_factory, 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
+      
+      #
+      # DynamicFieldFactory implements the part of the Setup interface that we
+      # need, so methods in DynamicQuery's superclasses can rely on it without
+      # knowing what it is.
+      #
+      def setup
+        @dynamic_field_factory
+      end
+      
+      # 
+      # So query facets can be added to the query from within dynamic queries
+      #
+      def query_facets
+        @query.query_facets
+      end
+    end
+  end
+end