lisausa-sunspot 1.2.1

data/lib/sunspot/search/standard_search.rb

@@ -0,0 +1,21 @@
+module Sunspot
+  module Search
+    # 
+    # This class encapsulates the results of a Solr search. It provides access
+    # to search results, total result count, facets, and pagination information.
+    # Instances of Search are returned by the Sunspot.search and
+    # Sunspot.new_search methods.
+    #
+    class StandardSearch < AbstractSearch
+      def request_handler
+        super || :select
+      end
+  
+      private
+  
+      def dsl
+        DSL::Search.new(self, @setup)
+      end
+    end
+  end
+end

data/lib/sunspot/server.rb

@@ -0,0 +1,152 @@
+require 'escape'
+require 'set'
+require 'tempfile'
+
+module Sunspot
+  class Server #:nodoc:
+    # Raised if #stop is called but the server is not running
+    ServerError = Class.new(RuntimeError)
+    AlreadyRunningError = Class.new(ServerError)
+    NotRunningError = Class.new(ServerError)
+
+    # Name of the sunspot executable (shell script)
+    SOLR_START_JAR = File.expand_path(
+      File.join(File.dirname(__FILE__), '..', '..', 'solr', 'start.jar')
+    )
+
+    LOG_LEVELS = Set['SEVERE', 'WARNING', 'INFO', 'CONFIG', 'FINE', 'FINER', 'FINEST']
+
+    attr_accessor :min_memory, :max_memory, :port, :solr_data_dir, :solr_home, :log_file
+    attr_writer :pid_dir, :pid_file, :log_level, :solr_data_dir, :solr_home, :solr_jar
+
+    #
+    # Start the sunspot-solr server. Bootstrap solr_home first,
+    # if neccessary.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def start
+      if File.exist?(pid_path)
+        existing_pid = IO.read(pid_path).to_i
+        begin
+          Process.kill(0, existing_pid)
+          raise(AlreadyRunningError, "Server is already running with PID #{existing_pid}")
+        rescue Errno::ESRCH
+          STDERR.puts("Removing stale PID file at #{pid_path}")
+          FileUtils.rm(pid_path)
+        end
+      end
+      fork do
+        pid = fork do
+          Process.setsid
+          STDIN.reopen('/dev/null')
+          STDOUT.reopen('/dev/null', 'a')
+          STDERR.reopen(STDOUT)
+          run
+        end
+        FileUtils.mkdir_p(pid_dir)
+        File.open(pid_path, 'w') do |file|
+          file << pid
+        end
+      end
+    end
+
+    # 
+    # Run the sunspot-solr server in the foreground. Boostrap
+    # solr_home first, if neccessary.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def run
+      command = ['java']
+      command << "-Xms#{min_memory}" if min_memory
+      command << "-Xmx#{max_memory}" if max_memory
+      command << "-Djetty.port=#{port}" if port
+      command << "-Dsolr.data.dir=#{solr_data_dir}" if solr_data_dir
+      command << "-Dsolr.solr.home=#{solr_home}" if solr_home
+      command << "-Djava.util.logging.config.file=#{logging_config_path}" if logging_config_path
+      command << '-jar' << File.basename(solr_jar)
+      FileUtils.cd(File.dirname(solr_jar)) do
+        exec(Escape.shell_command(command))
+      end
+    end
+
+    # 
+    # Stop the sunspot-solr server.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def stop
+      if File.exist?(pid_path)
+        pid = IO.read(pid_path).to_i
+        begin
+          Process.kill('TERM', pid)
+        rescue Errno::ESRCH
+          raise NotRunningError, "Process with PID #{pid} is no longer running"
+        ensure
+          FileUtils.rm(pid_path)
+        end
+      else
+        raise NotRunningError, "No PID file at #{pid_path}"
+      end
+    end
+
+    def log_level=(level)
+      unless LOG_LEVELS.include?(level.to_s.upcase)
+        raise(ArgumentError, "#{level} is not a valid log level: Use one of #{LOG_LEVELS.to_a.join(',')}")
+      end
+      @log_level = level.to_s.upcase
+    end
+
+    def log_level
+      @log_level || 'WARNING'
+    end
+
+    def pid_path
+      File.join(pid_dir, pid_file)
+    end
+
+    def pid_file
+      @pid_file || 'sunspot-solr.pid'
+    end
+
+    def pid_dir
+      File.expand_path(@pid_dir || FileUtils.pwd)
+    end
+
+    def solr_data_dir
+      File.expand_path(@solr_data_dir || Dir.tmpdir)
+    end
+
+    def solr_home
+      File.expand_path(@solr_home || File.join(File.dirname(solr_jar), 'solr'))
+    end
+
+    def solr_jar
+      @solr_jar || SOLR_START_JAR
+    end
+
+    private
+
+    def logging_config_path
+      return @logging_config_path if defined?(@logging_config_path)
+      @logging_config_path =
+        if log_file
+          logging_config = Tempfile.new('logging.properties')
+          logging_config.puts("handlers = java.util.logging.FileHandler")
+          logging_config.puts("java.util.logging.FileHandler.level = #{log_level.to_s.upcase}")
+          logging_config.puts("java.util.logging.FileHandler.pattern = #{log_file}")
+          logging_config.puts("java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter")
+          logging_config.flush
+          logging_config.close
+          logging_config.path
+        end
+    end
+  end
+end

data/lib/sunspot/session.rb

@@ -0,0 +1,260 @@
+module Sunspot
+  # 
+  # A Sunspot session encapsulates a connection to Solr and a set of
+  # configuration choices. Though users of Sunspot may manually instantiate
+  # Session objects, in the general case it's easier to use the singleton
+  # stored in the Sunspot module. Since the Sunspot module provides all of
+  # the instance methods of Session as class methods, they are not documented
+  # again here.
+  #
+  class Session
+    class <<self
+      attr_writer :connection_class #:nodoc:
+      
+      # 
+      # For testing purposes
+      #
+      def connection_class #:nodoc:
+        @connection_class ||= RSolr
+      end
+    end
+
+    # 
+    # Sunspot::Configuration object for this session
+    #
+    attr_reader :config
+
+    # 
+    # Sessions are initialized with a Sunspot configuration and a Solr
+    # connection. Usually you will want to stick with the default arguments
+    # when instantiating your own sessions.
+    #
+    def initialize(config = Configuration.build, connection = nil)
+      @config = config
+      yield(@config) if block_given?
+      @connection = connection
+      @deletes = @adds = 0
+    end
+
+    # 
+    # See Sunspot.new_search
+    #
+    def new_search(*types, &block)
+      types.flatten!
+      search = Search::StandardSearch.new(
+        connection,
+        setup_for_types(types),
+        Query::StandardQuery.new(types),
+        @config
+      )
+      search.build(&block) if block
+      search
+    end
+
+    #
+    # See Sunspot.search
+    #
+    def search(*types, &block)
+      search = new_search(*types, &block)
+      search.execute
+    end
+
+    # 
+    # See Sunspot.new_more_like_this
+    #
+    def new_more_like_this(object, *types, &block)
+      types[0] ||= object.class
+      mlt = Search::MoreLikeThisSearch.new(
+        connection,
+        setup_for_types(types),
+        Query::MoreLikeThisQuery.new(object, types),
+        @config
+      )
+      mlt.build(&block) if block
+      mlt
+    end
+
+    #
+    # See Sunspot.more_like_this
+    #
+    def more_like_this(object, *types, &block)
+      mlt = new_more_like_this(object, *types, &block)
+      mlt.execute
+    end
+
+    #
+    # See Sunspot.index
+    #
+    def index(*objects)
+      objects.flatten!
+      @adds += objects.length
+      indexer.add(objects)
+    end
+
+    # 
+    # See Sunspot.index!
+    #
+    def index!(*objects)
+      index(*objects)
+      commit
+    end
+
+    #
+    # See Sunspot.commit
+    #
+    def commit
+      @adds = @deletes = 0
+      connection.commit
+    end
+
+    #
+    # See Sunspot.optimize
+    #
+    def optimize
+      @adds = @deletes = 0
+      connection.optimize
+    end
+
+    # 
+    # See Sunspot.remove
+    #
+    def remove(*objects, &block)
+      if block
+        types = objects
+        conjunction = Query::Connective::Conjunction.new
+        if types.length == 1
+          conjunction.add_positive_restriction(TypeField.instance, Query::Restriction::EqualTo, types.first)
+        else
+          conjunction.add_positive_restriction(TypeField.instance, Query::Restriction::AnyOf, types)
+        end
+        dsl = DSL::Scope.new(conjunction, setup_for_types(types))
+        Util.instance_eval_or_call(dsl, &block)
+        indexer.remove_by_scope(conjunction)
+      else
+        objects.flatten!
+        @deletes += objects.length
+        objects.each do |object|
+          indexer.remove(object)
+        end
+      end
+    end
+
+    # 
+    # See Sunspot.remove!
+    #
+    def remove!(*objects)
+      remove(*objects)
+      commit
+    end
+
+    # 
+    # See Sunspot.remove_by_id
+    #
+    def remove_by_id(clazz, id)
+      class_name =
+        if clazz.is_a?(Class)
+          clazz.name
+        else
+          clazz.to_s
+        end
+      indexer.remove_by_id(class_name, id)
+    end
+
+    # 
+    # See Sunspot.remove_by_id!
+    #
+    def remove_by_id!(clazz, id)
+      remove_by_id(clazz, id)
+      commit
+    end
+
+    #
+    # See Sunspot.remove_all
+    #
+    def remove_all(*classes)
+      classes.flatten!
+      if classes.empty?
+        @deletes += 1
+        indexer.remove_all
+      else
+        @deletes += classes.length
+        classes.each { |clazz| indexer.remove_all(clazz) }
+      end
+    end
+
+    # 
+    # See Sunspot.remove_all!
+    #
+    def remove_all!(*classes)
+      remove_all(*classes)
+      commit
+    end
+
+    # 
+    # See Sunspot.dirty?
+    #
+    def dirty?
+      (@deletes + @adds) > 0
+    end
+
+    # 
+    # See Sunspot.commit_if_dirty
+    #
+    def commit_if_dirty
+      commit if dirty?
+    end
+    
+    # 
+    # See Sunspot.delete_dirty?
+    #
+    def delete_dirty?
+      @deletes > 0
+    end
+
+    # 
+    # See Sunspot.commit_if_delete_dirty
+    #
+    def commit_if_delete_dirty
+      commit if delete_dirty?
+    end
+    
+    # 
+    # See Sunspot.batch
+    #
+    def batch
+      indexer.start_batch
+      yield
+      indexer.flush_batch
+    end
+
+    private
+
+    # 
+    # Retrieve the Solr connection for this session, creating one if it does not
+    # already exist.
+    #
+    # ==== Returns
+    #
+    # RSolr::Connection::Base:: The connection for this session
+    #
+    def connection
+      @connection ||=
+        self.class.connection_class.connect(:url => config.solr.url)
+    end
+
+    def indexer
+      @indexer ||= Indexer.new(connection)
+    end
+
+    def setup_for_types(types)
+      if types.empty?
+        raise(ArgumentError, "You must specify at least one type to search")
+      end
+      if types.length == 1
+        Setup.for(types.first)
+      else
+        CompositeSetup.for(types)
+      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