nuatt_sunspot 1.1.0.3

data/lib/sunspot/configuration.rb

@@ -0,0 +1,46 @@
+module Sunspot
+  # The Sunspot::Configuration module provides a factory method for Sunspot
+  # configuration objects. Available properties are:
+  #
+  # Sunspot.config.solr.url::
+  #   The URL at which to connect to Solr
+  #   (default: 'http://localhost:8983/solr')
+  # Sunspot.config.pagination.default_per_page::
+  #   Solr always paginates its results. This sets Sunspot's default result
+  #   count per page if it is not explicitly specified in the query.
+  #
+  module Configuration
+    class <<self
+      # Factory method to build configuration instances.
+      #
+      # ==== Returns
+      #
+      # LightConfig::Configuration:: new configuration instance with defaults
+      #
+      def build #:nodoc:
+        LightConfig.build do
+          solr do
+            url 'http://127.0.0.1:8983/solr'
+          end
+          master_solr do
+            url nil
+          end
+          pagination do
+            default_per_page 30
+          end
+        end
+      end
+      
+      # Location for the default solr configuration files,
+      # required for bootstrapping a new solr installation
+      #
+      # ==== Returns
+      #
+      # String:: Directory with default solr config files
+      #
+      def solr_default_configuration_location
+        File.join( File.dirname(__FILE__), '../../solr/solr/conf' )
+      end
+    end
+  end
+end

data/lib/sunspot/data_extractor.rb

@@ -0,0 +1,50 @@
+module Sunspot
+  # 
+  # DataExtractors present an internal API for the indexer to use to extract
+  # field values from models for indexing. They must implement the #value_for
+  # method, which takes an object and returns the value extracted from it.
+  #
+  module DataExtractor #:nodoc: all
+    # 
+    # AttributeExtractors extract data by simply calling a method on the block.
+    #
+    class AttributeExtractor
+      def initialize(attribute_name)
+        @attribute_name = attribute_name
+      end
+
+      def value_for(object)
+        object.send(@attribute_name)
+      end
+    end
+
+    # 
+    # BlockExtractors extract data by evaluating a block in the context of the
+    # object instance, or if the block takes an argument, by passing the object
+    # as the argument to the block. Either way, the return value of the block is
+    # the value returned by the extractor.
+    #
+    class BlockExtractor
+      def initialize(&block)
+        @block = block
+      end
+
+      def value_for(object)
+        Util.instance_eval_or_call(object, &@block)
+      end
+    end
+
+    # 
+    # Constant data extractors simply return the same value for every object.
+    #
+    class Constant
+      def initialize(value)
+        @value = value
+      end
+
+      def value_for(object)
+        @value
+      end
+    end
+  end
+end

data/lib/sunspot/dsl.rb

@@ -0,0 +1,5 @@
+%w(fields scope paginatable adjustable field_query standard_query query_facet
+   functional fulltext restriction search more_like_this_query
+   function).each do |file|
+  require File.join(File.dirname(__FILE__), 'dsl', file)
+end

data/lib/sunspot/dsl/adjustable.rb

@@ -0,0 +1,47 @@
+module Sunspot
+  module DSL #:nodoc:
+    module Adjustable #:nodoc
+      # <strong>Expert:</strong> Adjust or reset the parameters passed to Solr.
+      # The adjustment will take place just before sending the params to solr,
+      # after Sunspot builds the Solr params based on the methods called in the
+      # DSL.
+      #
+      # Under normal circumstances, using this method should not be necessary;
+      # if you find that it is, please consider submitting a feature request.
+      # Using this method requires knowledge of Sunspot's internal Solr schema
+      # and Solr query representations, which are not part of Sunspot's public
+      # API; they could change at any time. <strong>This method is unsupported
+      # and your mileage may vary.</strong>
+      #
+      # ==== Examples
+      #
+      #   Sunspot.search(Post) do
+      #     adjust_solr_params do |params|
+      #       params[:q] += ' AND something_s:more'
+      #     end
+      #   end
+      #
+      #   Sunspot.more_like_this(my_post) do
+      #     adjust_solr_params do |params|
+      #       params["mlt.match.include"] = true
+      #     end
+      #   end
+      # 
+      def adjust_solr_params( &block )
+        @query.solr_parameter_adjustment = block
+      end
+
+      #
+      # <strong>Expert:</strong> Use a custom request handler for this search.
+      # The general use case for this would be a request handler configuration
+      # you've defined in solrconfig that has different search components,
+      # defaults, etc. Using this to point at an entirely different type of
+      # request handler that Sunspot doesn't support probably won't get you very
+      # far.
+      #
+      def request_handler(request_handler)
+        @search.request_handler = request_handler
+      end
+    end
+  end
+end

data/lib/sunspot/dsl/field_query.rb

@@ -0,0 +1,266 @@
+module Sunspot
+  module DSL
+    # 
+    # Provides an API for areas of the query DSL that operate on specific
+    # fields. This functionality is provided by the query DSL and the dynamic
+    # query DSL.
+    #
+    class FieldQuery < Scope
+      def initialize(search, query, setup) #:nodoc:
+        @search, @query = search, query
+        super(query.scope, setup)
+      end
+
+      # Specify the order that results should be returned in. This method can
+      # be called multiple times; precedence will be in the order given.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: the field to use for ordering
+      # direction<Symbol>:: :asc or :desc (default :asc)
+      #
+      def order_by(field_name, direction = nil)
+        sort =
+          if special = Sunspot::Query::Sort.special(field_name)
+            special.new(direction)
+          else
+            Sunspot::Query::Sort::FieldSort.new(
+              @setup.field(field_name), direction
+            )
+          end
+        @query.add_sort(sort)
+      end
+
+      # 
+      # DEPRECATED Use <code>order_by(:random)</code>
+      #
+      def order_by_random
+        order_by(:random)
+      end
+
+      #
+      # Request a facet on the search query. A facet is a feature of Solr that
+      # determines the number of documents that match the existing search *and*
+      # an additional criterion. This allows you to build powerful drill-down
+      # interfaces for search, at each step presenting the searcher with a set
+      # of refinements that are known to return results.
+      #
+      # In Sunspot, each facet returns zero or more rows, each of which
+      # represents a particular criterion conjoined with the actual query being
+      # performed. For _field_ _facets_, each row represents a particular value
+      # for a given field. For _query_ _facets_, each row represents an
+      # arbitrary scope; the facet itself is just a means of logically grouping
+      # the scopes.
+      #
+      # === Examples
+      #
+      # ==== Field Facets
+      #
+      # A field facet is specified by passing one or more Symbol arguments to
+      # this method:
+      #
+      #   Sunspot.search(Post) do
+      #     with(:blog_id, 1)
+      #     facet(:category_id)
+      #   end
+      #   
+      # The facet specified above will have a row for each category_id that is
+      # present in a document which also has a blog_id of 1.
+      #
+      # ==== Multiselect Facets
+      #
+      # In certain circumstances, it is beneficial to exclude certain query
+      # scopes from a facet; the most common example is multi-select faceting,
+      # where the user has selected a certain value, but the facet should still
+      # show all options that would be available if they had not:
+      #
+      #   Sunspot.search(Post) do
+      #     with(:blog_id, 1)
+      #     category_filter = with(:category_id, 2)
+      #     facet(:category_id, :exclude => category_filter)
+      #   end
+      # 
+      # Although the results of the above search will be restricted to those
+      # with a category_id of 2, the category_id facet will operate as if a
+      # category had not been selected, allowing the user to select additional
+      # categories (which will presumably be ORed together).
+      #
+      # <strong>As far as I can tell, Solr only supports multi-select with
+      # field facets; if +:exclude+ is passed to a query facet, this method will
+      # raise an error. Also, the +:only+ and +:extra+ options use query
+      # faceting under the hood, so these can't be used with +:extra+ either.
+      # </strong>
+      #
+      # ==== Query Facets
+      #
+      # A query facet is a collection of arbitrary scopes, each of which
+      # represents a row. This is specified by passing a block into the #facet
+      # method; the block then contains one or more +row+ blocks, each of which
+      # creates a query facet row. The +row+ blocks follow the usual Sunspot
+      # scope DSL.
+      #
+      # For example, a query facet can be used to facet over a set of ranges:
+      #
+      #   Sunspot.search(Post) do
+      #     facet(:average_rating) do
+      #       row(1.0..2.0) do
+      #         with(:average_rating, 1.0..2.0)
+      #       end
+      #       row(2.0..3.0) do
+      #         with(:average_rating, 2.0..3.0)
+      #       end
+      #       row(3.0..4.0) do
+      #         with(:average_rating, 3.0..4.0)
+      #       end
+      #       row(4.0..5.0) do
+      #         with(:average_rating, 4.0..5.0)
+      #       end
+      #     end
+      #   end
+      #
+      # Note that the arguments to the +facet+ and +row+ methods simply provide
+      # labels for the facet and its rows, so that they can be retrieved and
+      # identified from the Search object. They are not passed to Solr and no
+      # semantic meaning is attached to them. The label for +facet+ should be
+      # a symbol; the label for +row+ can be whatever you'd like.
+      #
+      # ==== Parameters
+      #
+      # field_names...<Symbol>:: fields for which to return field facets
+      #
+      # ==== Options
+      #
+      # :sort<Symbol>::
+      #   Either :count (values matching the most terms first) or :index (lexical)
+      # :limit<Integer>::
+      #   The maximum number of facet rows to return
+      # :minimum_count<Integer>::
+      #   The minimum count a facet row must have to be returned
+      # :zeros<Boolean>::
+      #   Return facet rows for which there are no matches (equivalent to
+      #   :minimum_count => 0). Default is false.
+      # :exclude<Object,Array>::
+      #   Exclude one or more filters when performing the faceting (see
+      #   Multiselect Faceting above). The object given for this argument should
+      #   be the return value(s) of a scoping method (+with+, +any_of+,
+      #   +all_of+, etc.). <strong>Only can be used for field facets that do not
+      #   use the +:extra+ or +:only+ options.</strong>
+      # :name<Symbol>::
+      #   Give a custom name to a field facet. The main use case for this option
+      #   is for requesting the same field facet multiple times, using different
+      #   filter exclusions (see Multiselect Faceting above). If you pass this
+      #   option, it is also the argument that should be passed to Search#facet
+      #   when retrieving the facet result.
+      # :only<Array>::
+      #   Only return facet rows for the given values. Useful if you are only
+      #   interested in faceting on a subset of values for a given field.
+      #   <strong>Only applies to field facets.</strong>
+      # :extra<Symbol,Array>::
+      #   One or more of :any and :none. :any returns a facet row with a count
+      #   of all matching documents that have some value for this field. :none
+      #   returns a facet row with a count of all matching documents that have
+      #   no value for this field. The facet row(s) corresponding to the extras
+      #   have a value of the symbol passed. <strong>Only applies to field
+      #   facets.</strong>
+      #
+      def facet(*field_names, &block)
+        options = Sunspot::Util.extract_options_from(field_names)
+
+        if block
+          if field_names.length != 1
+            raise(
+              ArgumentError,
+              "wrong number of arguments (#{field_names.length} for 1)"
+            )
+          end
+          if options.has_key?(:exclude)
+            raise(
+              ArgumentError,
+              "can't use :exclude with query facets"
+            )
+          end
+          search_facet = @search.add_query_facet(field_names.first, options)
+          Sunspot::Util.instance_eval_or_call(
+            QueryFacet.new(@query, @setup, search_facet),
+            &block
+          )
+        elsif options[:only]
+          if options.has_key?(:exclude)
+            raise(
+              ArgumentError,
+              "can't use :exclude with :only (see documentation)"
+            )
+          end
+          field_names.each do |field_name|
+            field = @setup.field(field_name)
+            search_facet = @search.add_field_facet(field, options)
+            Util.Array(options[:only]).each do |value|
+              facet = Sunspot::Query::QueryFacet.new
+              facet.add_restriction(field, Sunspot::Query::Restriction::EqualTo, value)
+              @query.add_query_facet(facet)
+              search_facet.add_row(value, facet.to_boolean_phrase)
+            end
+          end
+        else
+          field_names.each do |field_name|
+            search_facet = nil
+            field = @setup.field(field_name)
+            facet =
+              if options[:time_range]
+                unless field.type.is_a?(Sunspot::Type::TimeType)
+                  raise(
+                    ArgumentError,
+                    ':time_range can only be specified for Date or Time fields'
+                  )
+                end
+                search_facet = @search.add_date_facet(field, options)
+                Sunspot::Query::DateFieldFacet.new(field, options)
+              else
+                search_facet = @search.add_field_facet(field, options)
+                Sunspot::Query::FieldFacet.new(field, options)
+              end
+            @query.add_field_facet(facet)
+            Util.Array(options[:extra]).each do |extra|
+              if options.has_key?(:exclude)
+                raise(
+                  ArgumentError,
+                  "can't use :exclude with :extra (see documentation)"
+                )
+              end
+              extra_facet = Sunspot::Query::QueryFacet.new
+              case extra
+              when :any
+                extra_facet.add_negated_restriction(
+                  field,
+                  Sunspot::Query::Restriction::EqualTo,
+                  nil
+                )
+              when :none
+                extra_facet.add_restriction(
+                  field,
+                  Sunspot::Query::Restriction::EqualTo,
+                  nil
+                )
+              else
+                raise(
+                  ArgumentError,
+                  "Allowed values for :extra are :any and :none"
+                )
+              end
+              search_facet.add_row(extra, extra_facet.to_boolean_phrase)
+              @query.add_query_facet(extra_facet)
+            end
+          end
+        end
+      end
+
+      def dynamic(base_name, &block)
+        dynamic_field_factory = @setup.dynamic_field_factory(base_name)
+        Sunspot::Util.instance_eval_or_call(
+          FieldQuery.new(@search, @query, dynamic_field_factory),
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/sunspot/dsl/fields.rb

@@ -0,0 +1,113 @@
+module Sunspot
+  module DSL #:nodoc:
+    # The Fields class provides a DSL for specifying field definitions in the
+    # Sunspot.setup block. As well as the #text method, which creates fulltext
+    # fields, uses #method_missing to allow definition of typed fields. The
+    # available methods are determined by the constants defined in 
+    # Sunspot::Type - in theory (though this is untested), plugin developers
+    # should be able to add support for new types simply by creating new
+    # implementations in Sunspot::Type
+    #
+    class Fields
+      def initialize(setup) #:nodoc:
+        @setup = setup
+      end
+
+      # Add a text field. Text fields are tokenized before indexing and are
+      # the only fields searched in fulltext searches. If a block is passed,
+      # create a virtual field; otherwise create an attribute field.
+      #
+      # If options are passed, they will be applied to all the given fields.
+      #
+      # ==== Parameters
+      #
+      # names...<Symbol>:: One or more field names
+      #
+      # ==== Options
+      #
+      # :boost<Float>::
+      #   Index-time boost that should be applied to this field for keyword search
+      # :default_boost<Float>::
+      #   Default search-time boost to apply to this field during keyword
+      #   search. Can be overriden with DSL::Fulltext#fields or
+      #   DSL::Fulltext#boost_fields method.
+      #
+      def text(*names, &block)
+        options = names.pop if names.last.is_a?(Hash)
+        names.each do |name|
+          @setup.add_text_field_factory(
+            name,
+            options || {},
+            &block
+          )
+        end
+      end
+
+      # 
+      # Specify a method or block that returns the geographical coordinates
+      # associated with the document. The object returned must respond to #first
+      # and #last (e.g., a two-element Array); or to #lat and one of #lng, #lon,
+      # or #long
+      #
+      def coordinates(name = nil, &block)
+        @setup.set_coordinates_field(name, &block)
+      end
+
+      # 
+      # Specify a document-level boost. As with fields, you have the option of
+      # passing an attribute name which will be called on each model, or a block
+      # to be evaluated in the model's context. As well as these two options,
+      # this method can also take a constant number, meaning that all indexed
+      # documents of this class will have the specified boost.
+      #
+      # ==== Parameters
+      #
+      # attr_name<Symbol,~.to_f>:: Attribute name to call or a numeric constant
+      #
+      def boost(attr_name = nil, &block)
+        @setup.add_document_boost(attr_name, &block)
+      end
+
+      # method_missing is used to provide access to typed fields, because
+      # developers should be able to add new Sunspot::Type implementations
+      # dynamically and have them recognized inside the Fields DSL. Like #text,
+      # these methods will create a VirtualField if a block is passed, or an
+      # AttributeField if not.
+      #
+      # ==== Example
+      #
+      #   Sunspot.setup(File) do
+      #     time :mtime
+      #   end
+      #
+      # The call to +time+ will create a field of type Sunspot::Types::TimeType
+      #
+      def method_missing(method, *args, &block)
+        options = Util.extract_options_from(args)
+        type_const_name = "#{Util.camel_case(method.to_s.sub(/^dynamic_/, ''))}Type"
+        trie = options.delete(:trie)
+        type_const_name = "Trie#{type_const_name}" if trie
+        begin
+          type_class = Type.const_get(type_const_name)
+        rescue(NameError)
+          if trie
+            raise ArgumentError, "Trie fields are only valid for numeric and time types"
+          else
+            super(method, *args, &block)
+          end
+        end
+        type = type_class.instance
+        name = args.shift
+        if method.to_s =~ /^dynamic_/
+          if type.accepts_dynamic?
+            @setup.add_dynamic_field_factory(name, type, options, &block)
+          else
+            super(method, *args, &block)
+          end
+        else
+          @setup.add_field_factory(name, type, options, &block)
+        end
+      end
+    end
+  end
+end