gojee-sunspot 2.0.3 → 2.0.4

data/lib/sunspot/class_set.rb

@@ -0,0 +1,23 @@
+module Sunspot
+  class ClassSet
+    include Enumerable
+
+    def initialize
+      @name_to_klass = {}
+    end
+
+    def <<(klass)
+      @name_to_klass[klass.name.to_sym] = klass
+      self
+    end
+    alias_method :add, :<<
+
+    def each(&block)
+      @name_to_klass.values.each(&block)
+    end
+
+    def empty?
+      @name_to_klass.empty?
+    end
+  end
+end

data/lib/sunspot/composite_setup.rb

@@ -0,0 +1,202 @@
+module Sunspot
+  # 
+  # The CompositeSetup class encapsulates a collection of setups, and responds
+  # to a subset of the methods that Setup responds to (in particular, the
+  # methods required to build queries).
+  #
+  class CompositeSetup #:nodoc:
+    class << self
+      alias_method :for, :new
+    end
+
+    def initialize(types)
+      @types = types
+    end
+
+    # 
+    # Collection of Setup objects for the enclosed types
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of Setup objects
+    #
+    def setups
+      @setups ||= @types.map { |type| Setup.for(type) }
+    end
+
+    # 
+    # Return the names of the encapsulated types
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of class names
+    #
+    def type_names
+      @type_names ||= @types.map { |clazz| clazz.name }
+    end
+
+    # 
+    # Get a text field object by its public name. A field will be returned if
+    # it is configured for any of the enclosed types.
+    #
+    # ==== Returns
+    #
+    # Sunspot::FulltextField:: Text field with the given public name
+    #
+    # ==== Raises
+    #
+    # UnrecognizedFieldError::
+    #   If no field with that name is configured for any of the enclosed types.
+    #
+    def text_fields(field_name)
+      if text_fields = text_fields_hash[field_name.to_sym]
+        text_fields.to_a
+      else
+        raise(
+          UnrecognizedFieldError,
+          "No text field configured for #{@types * ', '} with name '#{field_name}'"
+        )
+      end
+    end
+
+    # 
+    # Get a Sunspot::AttributeField instance corresponding to the given field name
+    #
+    # ==== Parameters
+    #
+    # field_name<Symbol>:: The public field name for which to find a field
+    #
+    # ==== Returns
+    #
+    # Sunspot::AttributeField The field object corresponding to the given name
+    #
+    # ==== Raises
+    #
+    # ArgumentError::
+    #   If the given field name is not configured for the types being queried
+    #
+    def field(field_name) #:nodoc:
+      fields_hash[field_name.to_sym] || raise(
+        UnrecognizedFieldError,
+        "No field configured for #{@types * ', '} with name '#{field_name}'"
+      )
+    end
+
+    # 
+    # Get a dynamic field factory for the given base name.
+    #
+    # ==== Returns
+    #
+    # DynamicFieldFactory:: Factory for dynamic fields with the given base name
+    #
+    # ==== Raises
+    #
+    # UnrecognizedFieldError::
+    #   If the given base name is not configured as a dynamic field for the types being queried
+    #
+    def dynamic_field_factory(field_name)
+      dynamic_field_factories_hash[field_name.to_sym] || raise(
+        UnrecognizedFieldError,
+        "No dynamic field configured for #{@types * ', '} with name #{field_name.inspect}"
+      )
+    end
+
+    # 
+    # Collection of all text fields configured for any of the enclosed types.
+    #
+    # === Returns
+    #
+    # Array:: Text fields configured for the enclosed types
+    #
+    def all_text_fields
+      @text_fields ||= text_fields_hash.values.map { |set| set.to_a }.flatten
+    end
+
+    def all_more_like_this_fields
+      @more_like_this_fields ||= more_like_this_fields_hash.values.map { |set| set.to_a }.flatten
+    end
+
+    private
+
+    # 
+    # Return a hash of field names to text field objects, containing all fields
+    # that are configured for any of the types enclosed.
+    #
+    # ==== Returns
+    #
+    # Hash:: Hash of field names to text field objects.
+    #
+    def text_fields_hash
+      @text_fields_hash ||=
+        setups.inject({}) do |hash, setup|
+          setup.all_text_fields.each do |text_field|
+            (hash[text_field.name] ||= Set.new) << text_field
+          end
+          hash
+        end
+    end
+
+    def more_like_this_fields_hash
+      @more_like_this_fields_hash ||=
+        setups.inject({}) do |hash, setup|
+          setup.all_more_like_this_fields.each do |more_like_this_field|
+            (hash[more_like_this_field.name] ||= Set.new) << more_like_this_field
+          end
+          hash
+        end
+    end
+
+    # 
+    # Return a hash of field names to field objects, containing all fields
+    # that are common to all of the classes enclosed. In order for fields
+    # to be common, they must be of the same type and have the same
+    # value for allow_multiple? and stored?. This method is memoized.
+    #
+    # ==== Returns
+    #
+    # Hash:: field names keyed to field objects
+    #
+    def fields_hash
+      @fields_hash ||=
+        begin
+          field_sets_hash = Hash.new { |h, k| h[k] = Set.new }
+          @types.each do |type|
+            Setup.for(type).fields.each do |field|
+              field_sets_hash[field.name.to_sym] << field
+            end
+          end
+          fields_hash = {}
+          field_sets_hash.each_pair do |field_name, set|
+            if set.length == 1
+              fields_hash[field_name] = set.to_a.first
+            end
+          end
+          fields_hash
+        end
+    end
+
+    # 
+    # Return a hash of dynamic field base names to dynamic field factories for
+    # those base names. Criteria for the inclusion are the same as for
+    # #fields_hash()
+    #
+    def dynamic_field_factories_hash
+      @dynamic_field_factories_hash ||=
+        begin
+          dynamic_field_factories_hash = @types.inject({}) do |hash, type|
+            Setup.for(type).dynamic_field_factories.each do |field_factory|
+              (hash[field_factory.name.to_sym] ||= {})[type.name] = field_factory
+            end
+            hash
+          end
+          dynamic_field_factories_hash.each_pair do |field_name, field_configurations_hash|
+            if @types.any? { |type| field_configurations_hash[type.name].nil? }
+              dynamic_field_factories_hash.delete(field_name)
+            else
+              dynamic_field_factories_hash[field_name] = field_configurations_hash.values.first
+            end
+          end
+        end
+    end
+  end
+end

data/lib/sunspot/configuration.rb

@@ -0,0 +1,53 @@
+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.
+  # Sunspot.config.indexing.default_batch_size::
+  #   This sets the batch size for indexing, default is 50
+  #
+  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'
+            read_timeout nil
+            open_timeout nil
+          end
+          master_solr do
+            url nil
+          end
+          pagination do
+            default_per_page 30
+          end
+          indexing do
+            default_batch_size 50
+          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/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_group.rb

@@ -0,0 +1,57 @@
+module Sunspot
+  module DSL
+    class FieldGroup
+      def initialize(query, setup, group)
+        @query, @setup, @group = query, setup, group
+      end
+
+      #
+      # Sets the number of results (documents) to return for each group.
+      # Defaults to 1.
+      #
+      def limit(num)
+        @group.limit = num
+      end
+
+      #
+      # If set, facet counts are based on the most relevant document of
+      # each group matching the query.
+      #
+      # Supported in Solr 3.4 and above.
+      #
+      # ==== Example
+      #
+      #     Sunspot.search(Post) do
+      #       group :title do
+      #         truncate
+      #       end
+      #
+      #       facet :title, :extra => :any
+      #     end
+      #
+      def truncate
+        @group.truncate = true
+      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
+        @group.add_sort(sort)
+      end
+    end
+  end
+end