sunspot_rbg 1.3.0

data/lib/sunspot/session_proxy/silent_fail_session_proxy.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'abstract_session_proxy')
+
+module Sunspot
+  module SessionProxy
+    class SilentFailSessionProxy < AbstractSessionProxy
+      
+      attr_reader :search_session
+      
+      delegate :new_search, :search, :config,
+                :new_more_like_this, :more_like_this,
+                :delete_dirty, :delete_dirty?,
+                :to => :search_session
+      
+      def initialize(search_session = Sunspot.session)
+        @search_session = search_session
+      end
+      
+      def rescued_exception(method, e)
+        $stderr.puts("Exception in #{method}: #{e.message}")
+      end
+
+      SUPPORTED_METHODS = [
+        :batch, :commit, :commit_if_dirty, :commit_if_delete_dirty, :dirty?,
+        :index!, :index, :optimize, :remove!, :remove, :remove_all!, :remove_all,
+        :remove_by_id!, :remove_by_id
+      ]
+
+      SUPPORTED_METHODS.each do |method|
+        module_eval(<<-RUBY)
+          def #{method}(*args, &block)
+            begin
+              search_session.#{method}(*args, &block)
+            rescue => e
+              self.rescued_exception(:#{method}, e)
+            end
+          end
+        RUBY
+      end
+      
+    end
+  end
+end

data/lib/sunspot/session_proxy/thread_local_session_proxy.rb

@@ -0,0 +1,37 @@
+require 'monitor'
+require File.join(File.dirname(__FILE__), 'abstract_session_proxy')
+
+module Sunspot
+  module SessionProxy
+    # 
+    # This class implements a session proxy that creates a different Session
+    # object for each thread. Any multithreaded application should use this
+    # proxy.
+    #
+    class ThreadLocalSessionProxy < AbstractSessionProxy
+      FINALIZER = Proc.new do |object_id|
+        Thread.current[:"sunspot_session_#{object_id}"] = nil
+      end
+
+      # The configuration with which the thread-local sessions are initialized.
+      attr_reader :config
+      @@next_id = 0
+
+      delegate :batch, :commit, :commit_if_delete_dirty, :commit_if_dirty, :delete_dirty?, :dirty?, :index, :index!, :new_search, :optimize, :remove, :remove!, :remove_all, :remove_all!, :remove_by_id, :remove_by_id!, :search, :more_like_this, :new_more_like_this, :to => :session
+
+      # 
+      # Optionally pass an existing Sunspot::Configuration object. If none is
+      # passed, a default configuration is used; it can then be modified using
+      # the #config attribute.
+      #
+      def initialize(config = Sunspot::Configuration.new)
+        @config = config
+        ObjectSpace.define_finalizer(self, FINALIZER)
+      end
+
+      def session #:nodoc:
+        Thread.current[:"sunspot_session_#{object_id}"] ||= Session.new(config)
+      end
+    end
+  end
+end

data/lib/sunspot/session_proxy.rb

@@ -0,0 +1,87 @@
+module Sunspot
+  # 
+  # This module contains several Session Proxy implementations, which can be
+  # used to decorate one or more Session objects and add extra functionality.
+  # The user can also implement their own Session Proxy classes; a Session Proxy
+  # must simply implement the same public API as the Sunspot::Session class.
+  #
+  # When implementing a session proxy, some methods of Session may not be
+  # practical, or even logical, to implement. In this case, the method should
+  # raise a Sunspot::SessionProxy::NotSupportedError (several methods in the
+  # built-in session proxies raise this error).
+  #
+  # To use a session proxy in normal Sunspot usage, you can use the
+  # Sunspot.session= method, which will cause Sunspot to delegate all of its
+  # session-related class methods (most of them) to the proxy. Session proxies
+  # can also easily be chained, although the details of chaining depend on the
+  # proxy implementation.
+  #
+  # ===== Example: Chain a MasterSlaveSessionProxy with a ThreadLocalSessionProxy
+  #
+  #   master_session = Sunspot::SessionProxy::ThreadLocalSessionProxy.new
+  #   slave_session = Sunspot::SessionProxy::ThreadLocalSessionProxy.new
+  #   master_session.config.solr.url = 'http://master-solr.local:9080/solr'
+  #   slave_session.config.solr.url = 'http://slave-solr.local:9080/solr'
+  #   Sunspot.session = Sunspot::SessionProxy::MasterSlaveSessionProxy.new(master_session, slave_session)
+  #
+  module SessionProxy
+    NotSupportedError = Class.new(StandardError)
+
+    autoload(
+      :AbstractSessionProxy,
+      File.join(
+        File.dirname(__FILE__),
+        'session_proxy',
+        'abstract_session_proxy'
+      )
+    )
+    autoload(
+      :ThreadLocalSessionProxy,
+      File.join(
+        File.dirname(__FILE__),
+        'session_proxy',
+        'thread_local_session_proxy'
+      )
+    )
+    autoload(
+      :MasterSlaveSessionProxy,
+      File.join(
+        File.dirname(__FILE__),
+        'session_proxy',
+        'master_slave_session_proxy'
+      )
+    )
+    autoload(
+      :ShardingSessionProxy,
+      File.join(
+        File.dirname(__FILE__),
+        'session_proxy',
+        'sharding_session_proxy'
+      )
+    )
+    autoload(
+      :ClassShardingSessionProxy,
+      File.join(
+        File.dirname(__FILE__),
+        'session_proxy',
+        'class_sharding_session_proxy'
+      )
+    )
+    autoload(
+      :IdShardingSessionProxy,
+      File.join(
+        File.dirname(__FILE__),
+        'session_proxy',
+        'id_sharding_session_proxy'
+      )
+    )
+    autoload(
+      :SilentFailSessionProxy,
+      File.join(
+        File.dirname(__FILE__),
+        'session_proxy',
+        'silent_fail_session_proxy'
+      )
+    )
+  end
+end

data/lib/sunspot/setup.rb

@@ -0,0 +1,350 @@
+module Sunspot
+  # 
+  # This class encapsulates the search/indexing setup for a given class. Its
+  # contents are built using the Sunspot.setup method.
+  #
+  class Setup #:nodoc:
+    attr_reader :class_object_id
+    def initialize(clazz)
+      @class_object_id = clazz.object_id
+      @class_name = clazz.name
+      @field_factories, @text_field_factories, @dynamic_field_factories,
+        @field_factories_cache, @text_field_factories_cache,
+        @dynamic_field_factories_cache = *Array.new(6) { Hash.new }
+      @stored_field_factories_cache = Hash.new { |h, k| h[k] = [] }
+      @more_like_this_field_factories_cache = Hash.new { |h, k| h[k] = [] }
+      @dsl = DSL::Fields.new(self)
+      add_field_factory(:class, Type::ClassType.instance)
+    end
+
+    def type_names
+      [@class_name]
+    end
+
+    # 
+    # Add field factory for scope/ordering
+    #
+    def add_field_factory(name, type, options = {}, &block)
+      stored, more_like_this = options[:stored], options[:more_like_this]
+      field_factory = FieldFactory::Static.new(name, type, options, &block)
+      @field_factories[field_factory.signature] = field_factory
+      @field_factories_cache[field_factory.name] = field_factory
+      if stored
+        @stored_field_factories_cache[field_factory.name] << field_factory
+      end
+      if more_like_this
+        @more_like_this_field_factories_cache[field_factory.name] << field_factory
+      end
+    end
+
+    # 
+    # Add field_factories for fulltext search
+    #
+    # ==== Parameters
+    #
+    # field_factories<Array>:: Array of Sunspot::Field objects
+    #
+    def add_text_field_factory(name, options = {}, &block)
+      stored, more_like_this = options[:stored], options[:more_like_this]
+      field_factory = FieldFactory::Static.new(name, Type::TextType.instance, options, &block)
+      @text_field_factories[name] = field_factory
+      @text_field_factories_cache[field_factory.name] = field_factory
+      if stored
+        @stored_field_factories_cache[field_factory.name] << field_factory
+      end
+      if more_like_this
+        @more_like_this_field_factories_cache[field_factory.name] << field_factory
+      end
+    end
+
+    #
+    # Add dynamic field_factories
+    #
+    # ==== Parameters
+    # 
+    # field_factories<Array>:: Array of dynamic field objects
+    # 
+    def add_dynamic_field_factory(name, type, options = {}, &block)
+      stored, more_like_this = options[:stored], options[:more_like_this]
+      field_factory = FieldFactory::Dynamic.new(name, type, options, &block)
+      @dynamic_field_factories[field_factory.signature] = field_factory
+      @dynamic_field_factories_cache[field_factory.name] = field_factory
+      if stored
+        @stored_field_factories_cache[field_factory.name] << field_factory
+      end
+      if more_like_this
+        @more_like_this_field_factories_cache[field_factory.name] << field_factory
+      end
+    end
+
+    # 
+    # Add a document boost to documents at index time. Document boost can be
+    # static (the same for all documents of this class), or extracted on a per-
+    # document basis using either attribute or block extraction as per usual.
+    #
+    def add_document_boost(attr_name, &block)
+      @document_boost_extractor =
+        if attr_name
+          if attr_name.respond_to?(:to_f)
+            DataExtractor::Constant.new(attr_name)
+          else
+            DataExtractor::AttributeExtractor.new(attr_name)
+          end
+        else
+          DataExtractor::BlockExtractor.new(&block)
+        end
+    end
+
+    # 
+    # Builder method for evaluating the setup DSL
+    #
+    def setup(&block)
+      Util.instance_eval_or_call(@dsl, &block)
+    end
+
+    # 
+    # Return the Field with the given (public-facing) name
+    #
+    def field(field_name)
+      if field_factory = @field_factories_cache[field_name.to_sym]
+        field_factory.build
+      else
+        raise(
+          UnrecognizedFieldError,
+          "No field configured for #{@class_name} with name '#{field_name}'"
+        )
+      end
+    end
+
+    # 
+    # Return one or more text fields with the given public-facing name. This
+    # implementation will always return a single field (in an array), but
+    # CompositeSetup objects might return more than one.
+    #
+    def text_fields(field_name)
+      text_field = 
+        if field_factory = @text_field_factories_cache[field_name.to_sym]
+          field_factory.build
+        else
+          raise(
+            UnrecognizedFieldError,
+            "No text field configured for #{@class_name} with name '#{field_name}'"
+          )
+        end
+      [text_field]
+    end
+
+    #
+    # Return one or more stored fields (can be either attribute or text fields)
+    # for the given name.
+    #
+    def stored_fields(field_name, dynamic_field_name = nil)
+      @stored_field_factories_cache[field_name.to_sym].map do |field_factory|
+        if dynamic_field_name
+          field_factory.build(dynamic_field_name)
+        else
+          field_factory.build
+        end
+      end
+    end
+
+    #
+    # Return one or more more_like_this fields (can be either attribute or text fields)
+    # for the given name.
+    #
+    def more_like_this_fields(field_name)
+      @more_like_this_field_factories_cache[field_name.to_sym].map do |field_factory|
+        field_factory.build
+      end
+    end
+
+    # 
+    # Return the DynamicFieldFactory with the given base name
+    #
+    def dynamic_field_factory(field_name)
+      @dynamic_field_factories_cache[field_name.to_sym] || raise(
+        UnrecognizedFieldError,
+        "No dynamic field configured for #{@class_name} with name '#{field_name}'"
+      )
+    end
+
+    # 
+    # Return all attribute fields
+    #
+    def fields
+      field_factories.map { |field_factory| field_factory.build }
+    end
+
+    # 
+    # Return all text fields
+    #
+    def all_text_fields
+      text_field_factories.map { |text_field_factory| text_field_factory.build }
+    end
+
+    # 
+    # Return all more_like_this fields
+    #
+    def all_more_like_this_fields
+      @more_like_this_field_factories_cache.values.map do |field_factories| 
+        field_factories.map { |field_factory| field_factory.build }
+      end.flatten
+    end
+
+    # 
+    # Get the field_factories associated with this setup as well as all inherited field_factories
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of all field_factories associated with this setup
+    #
+    def field_factories
+      collection_from_inheritable_hash(:field_factories)
+    end
+
+    # 
+    # Get the text field_factories associated with this setup as well as all inherited
+    # text field_factories
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of all text field_factories associated with this setup
+    #
+    def text_field_factories
+      collection_from_inheritable_hash(:text_field_factories)
+    end
+
+    # 
+    # Get all static, dynamic, and text field_factories associated with this setup as
+    # well as all inherited field_factories
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of all text and scope field_factories associated with this setup
+    #
+    def all_field_factories
+      all_field_factories = []
+      all_field_factories.concat(field_factories).concat(text_field_factories).concat(dynamic_field_factories)
+      all_field_factories
+    end
+
+    # 
+    # Get all dynamic field_factories for this and parent setups
+    # 
+    # ==== Returns
+    #
+    # Array:: Dynamic field_factories
+    #
+    def dynamic_field_factories
+      collection_from_inheritable_hash(:dynamic_field_factories)
+    end
+
+    # 
+    # Return the class associated with this setup.
+    #
+    # ==== Returns
+    #
+    # clazz<Class>:: Class setup is configured for
+    #
+    def clazz
+      Util.full_const_get(@class_name)
+    end
+
+    # 
+    # Get the document boost for a given model
+    #
+    def document_boost_for(model)
+      if @document_boost_extractor
+        @document_boost_extractor.value_for(model)
+      end
+    end
+
+    protected
+
+    # 
+    # Get the nearest inherited setup, if any
+    #
+    # ==== Returns
+    # 
+    # Sunspot::Setup:: Setup for the nearest ancestor of this setup's class
+    #
+    def parent
+      Setup.for(clazz.superclass)
+    end
+
+    def get_inheritable_hash(name)
+      hash = instance_variable_get(:"@#{name}")
+      parent.get_inheritable_hash(name).each_pair do |key, value|
+        hash[key] = value unless hash.has_key?(key)
+      end if parent
+      hash
+    end
+
+    private
+
+    def collection_from_inheritable_hash(name)
+      get_inheritable_hash(name).values
+    end
+
+    class <<self
+      # 
+      # Retrieve or create the Setup instance for the given class, evaluating
+      # the given block to add to the setup's configuration
+      #
+      def setup(clazz, &block) #:nodoc:
+        self.for!(clazz).setup(&block)
+      end
+
+      # 
+      # Retrieve the setup instance for the given class, or for the nearest
+      # ancestor that has a setup, if any.
+      #
+      # ==== Parameters
+      #
+      # clazz<Class>:: Class for which to retrieve a setup
+      #
+      # ==== Returns
+      #
+      # Sunspot::Setup::
+      #   Setup instance associated with the given class or its nearest ancestor
+      #   
+      def for(clazz) #:nodoc:
+        setups[clazz.name.to_sym] || self.for(clazz.superclass) if clazz
+      end
+
+      protected
+
+      # 
+      # Retrieve or create a Setup instance for this class
+      #
+      # ==== Parameters
+      #
+      # clazz<Class>:: Class for which to retrieve a setup
+      #
+      # ==== Returns
+      #
+      # Sunspot::Setup:: New or existing setup for this class
+      #
+      def for!(clazz) #:nodoc:
+        setup = setups[clazz.name.to_sym]
+        if setup && setup.class_object_id == clazz.object_id
+          setup
+        else
+          setups[clazz.name.to_sym] = new(clazz)
+        end
+      end
+
+      private
+
+      # Singleton hash of class names to Setup instances
+      #
+      # ==== Returns
+      #
+      # Hash:: Class names keyed to Setup instances
+      #
+      def setups
+        @setups ||= {}
+      end
+    end
+  end
+end

data/lib/sunspot/text_field_setup.rb

@@ -0,0 +1,29 @@
+module Sunspot
+  # 
+  # A TextFieldSetup encapsulates a regular (or composite) setup, and exposes
+  # the #field() method returning text fields instead of attribute fields.
+  #
+  class TextFieldSetup #:nodoc:
+    def initialize(setup)
+      @setup = setup
+    end
+
+    # 
+    # Return a text field with the given name. Duck-type compatible with
+    # Setup and CompositeSetup, but return text fields instead.
+    #
+    def field(name)
+      fields = @setup.text_fields(name)
+      if fields
+        if fields.length == 1
+          fields.first
+        else
+          raise(
+            Sunspot::UnrecognizedFieldError,
+            "The text field with name #{name} has incompatible configurations for the classes #{@setup.type_names.join(', ')}"
+          )
+        end
+      end
+    end
+  end
+end