diff --git a/lib/drb/drb.rb b/lib/drb/drb.rb
index fa914f8..850747c 100644
--- a/lib/drb/drb.rb
+++ b/lib/drb/drb.rb
@@ -426,6 +426,7 @@ module DRb
 
   # An exception wrapping an error object
   class DRbRemoteError < DRbError
+    # Create a new DRb::DRbRemoteError
     def initialize(error)
       @reason = error.class.to_s
       super("#{error.message} (#{error.class})")
@@ -505,7 +506,29 @@ module DRb
     end
   end
 
+  # Class to wrap an Array.
+  #
+  # === Description
+  #
+  # A DRbArray can be provided in a DRb call. When the marshalled value
+  # of a DRbArray object is unmarshalled, it returns the wrapped Array.
+  #
+  #
+  # === Examples
+  #
+  #   a = %w{ cats and dogs }
+  #   => ["cats", "and", "dogs"]
+  #   da = DRb::DRbArray.new(a)
+  #   => #<DRb::DRbArray:0x0000000068b0f0 @ary=["cats", "and", "dogs"]>
+  #   bin = Marshal.dump(h)
+  #   => "\x04\bu:\x12DRb::DRbArray*\x04\b[\bI\"\tcats\x06:\x06ETI\"\band\x06;\0TI\"\tdogs\x06;\0T"
+  #   Marshal.load(bin)
+  #   => ["cats", "and", "dogs"]
+  #
   class DRbArray
+    # Create a DRb::DRbArray object
+    #
+    # +ary+ is an Array
     def initialize(ary)
       @ary = ary.collect { |obj|
         if obj.kind_of? DRbUndumped
@@ -521,11 +544,11 @@ module DRb
       }
     end
 
-    def self._load(s)
+    def self._load(s) # :nodoc:
       Marshal::load(s)
     end
 
-    def _dump(lv)
+    def _dump(lv) # :nodoc:
       Marshal.dump(@ary)
     end
   end
@@ -629,7 +652,7 @@ module DRb
     end
 
     private
-    def make_proxy(obj, error=false)
+    def make_proxy(obj, error=false) # :nodoc:
       if error
         DRbRemoteError.new(obj)
       else
@@ -798,7 +821,7 @@ module DRb
   # Communicates over a TCP socket.
   class DRbTCPSocket
     private
-    def self.parse_uri(uri)
+    def self.parse_uri(uri) # :nodoc:
       if uri =~ /^druby:\/\/(.*?):(\d+)(\?(.*))?$/
         host = $1
         port = $2.to_i
@@ -812,7 +835,12 @@ module DRb
 
     public
 
-    # Open a client connection to +uri+ using configuration +config+.
+    # Open a client connection to +uri+ (String)
+    # using configuration +config+.
+    #
+    # Can raise DRbBadScheme or DRbBadURI if +uri+
+    # is not 'druby:...' or is malformed
+    # See DRb::DRbServer.new for information on the uri.
     def self.open(uri, config)
       host, port, = parse_uri(uri)
       host.untaint
@@ -821,6 +849,7 @@ module DRb
       self.new(uri, soc, config)
     end
 
+    # Return the hostname (String) of this server
     def self.getservername
       host = Socket::gethostname
       begin
@@ -830,6 +859,8 @@ module DRb
       end
     end
 
+    # For the +host+ (String) provided
+    # return a TCPServer on +port+ (Fixnum)
     def self.open_server_inaddr_any(host, port)
       infos = Socket::getaddrinfo(host, nil,
                                   Socket::AF_UNSPEC,
@@ -1008,6 +1039,8 @@ module DRb
       self.new_with(uri, ref)
     end
 
+    # Create a DRb::DRbObject given the reference information to the
+    # remote host uri String, and ref
     def self.new_with(uri, ref)
       it = self.allocate
       it.instance_variable_set(:@uri, uri)
@@ -1094,6 +1127,10 @@ module DRb
       end
     end
 
+    # Given the +uri+ String of another dRuby host,
+    # execute the &blok provided.
+    #
+    # Returns Array with [<boolean of success>, <result object>]
     def self.with_friend(uri)
       friend = DRb.fetch_server(uri)
       return yield() unless friend
@@ -1105,6 +1142,8 @@ module DRb
       Thread.current['DRb'] = save if friend
     end
 
+    # Given +uri+ String and a +result+, that responds like an Exception,
+    # return an Array of the backtrace, relative the +uri+
     def self.prepare_backtrace(uri, result)
       prefix = "(#{uri}) "
       bt = []
@@ -1238,6 +1277,8 @@ module DRb
 
     # Set the default value for the :acl option.
     #
+    # +acl+ is expected to be an ACL object.
+    #
     # See #new().  The initial default value is nil.
     def self.default_acl(acl)
       @@acl = acl
@@ -1250,6 +1291,9 @@ module DRb
       @@idconv = idconv
     end
 
+    # Set the default value for the :safe_level option.
+    #
+    # See #new().  The initial default value is 0.
     def self.default_safe_level(level)
       @@safe_level = level
     end
@@ -1307,6 +1351,9 @@ module DRb
     # :argc_limit :: the maximum number of arguments to a remote
     #                method accepted by the server.  Defaults to
     #                256.
+    # :safe_level :: The safety level of the DRbServer. The attribute
+    #                sets the $SAFE for methods performed in 
+    #                #main_loop.  Defaults to 0.
     #
     # The default values of these options can be modified on
     # a class-wide basis by the class methods #default_argc_limit,
@@ -1366,6 +1413,11 @@ module DRb
     # The configuration of this DRbServer
     attr_reader :config
 
+    # The safety level of this DRbServer
+    #
+    # This is to be a Fixnum, corresponding with $SAFE
+    #
+    # Default +safe_level+ is 0
     attr_reader :safe_level
 
     # Set whether to operate in verbose mode.
@@ -1383,6 +1435,7 @@ module DRb
       @thread.alive?
     end
 
+    # Check whether +uri+ (String) is in the set of known URIs
     def here?(uri)
       @exported_uri.include?(uri)
     end
@@ -1411,7 +1464,7 @@ module DRb
     end
 
     private
-    def run
+    def run # :nodoc:
       Thread.start do
         begin
           while true
@@ -1722,13 +1775,16 @@ module DRb
 
   # Set the default id conv object.
   #
+  # This expected to be an instance, like DRb::DRbIdConv,
+  # that responds to #to_id and #to_obj
+  #
   # See DRbServer#default_id_conv.
   def install_id_conv(idconv)
     DRbServer.default_id_conv(idconv)
   end
   module_function :install_id_conv
 
-  # Set the default acl.
+  # Set the default ACL +acl+.
   #
   # See DRb::DRbServer.default_acl.
   def install_acl(acl)
@@ -1737,12 +1793,26 @@ module DRb
   module_function :install_acl
 
   @mutex = Mutex.new
+  # Get the semaphore for this DRb module
+  #
+  # Returns a Mutex instance
   def mutex
     @mutex
   end
   module_function :mutex
 
   @server = {}
+  # Recored the DRb::DRbServer +server+
+  #
+  # This is called when a new DRb::DRbServer instance is created.
+  #
+  #   require 'drb'
+  #
+  #   s = DRb::DRbServer.new
+  #   => #<DRb::DRbServer:0x00000001dcb440 @config={:idconv=>#<DRb::...
+  #   DRb.fetch_server(s.uri)
+  #   => #<DRb::DRbServer:0x00000001dcb440 @config={:idconv=>#<DRb::...
+  #
   def regist_server(server)
     @server[server.uri] = server
     mutex.synchronize do
@@ -1751,11 +1821,16 @@ module DRb
   end
   module_function :regist_server
 
+  # Remove the DRb::DRbServer +server+ from the registered list
   def remove_server(server)
     @server.delete(server.uri)
   end
   module_function :remove_server
 
+  # Return the DRb::DRbServer object, provided the String +uri+.
+  #
+  # This is provided from the registered servers.
+  # See also #regist_server and #remove_server
   def fetch_server(uri)
     @server[uri]
   end
diff --git a/lib/drb/ssl.rb b/lib/drb/ssl.rb
index c4f7698..e8fbb03 100644
--- a/lib/drb/ssl.rb
+++ b/lib/drb/ssl.rb
@@ -5,10 +5,21 @@ require 'singleton'
 
 module DRb
 
+  # DRb::DRbSSLSocket handles making a dRuby connection over an SSL connection
   class DRbSSLSocket < DRbTCPSocket
 
+    # SSLConfig handles the needed SSL information for establishing 
+    # a DRbSSLSocket connection, including generating the X509 / RSA pair.
+    #
+    # An instance of this config can be passed to DRbSSLSocket.new,
+    # DRbSSLSocket.open and DRbSSLSocket.open_server
+    #
+    # See DRb::DRbSSLSocket::SSLConfig.new for more details
     class SSLConfig
 
+      # Default values for a SSLConfig instance.
+      # 
+      # See DRb::DRbSSLSocket::SSLConfig.new for more details
       DEFAULT = {
         :SSLCertificate       => nil,
         :SSLPrivateKey        => nil,
@@ -25,6 +36,66 @@ module DRb
         :SSLCertComment       => "Generated by Ruby/OpenSSL"
       }
 
+      # Create a new DRb::DRbSSLSocket::SSLConfig instance
+      #
+      # The DRb::DRbSSLSocket will take either a +config+ Hash or an instance
+      # of SSLConfg, and will setup the certificate for its session for the 
+      # configuration. If want it to generate a generic certificate, the bare
+      # minimum is to provide the :SSLCertName 
+      #
+      # === Config options
+      # From +config+ Hash
+      #
+      # :SSLCertificate :: An instance of OpenSSL::X509::Certificate.
+      #                    If this is not provided, then a generic X509 is 
+      #                    generated, with a correspond :SSLPrivateKey
+      # :SSLPrivateKey :: A private key instance, like OpenSSL::PKey::RSA.
+      #                   This key must be the key that signed the
+      #                   :SSLCertificate
+      # :SSLClientCA :: An OpenSSL::X509::Certificate, or Array of certificates
+      #                 that will used as ClientCAs in the SSL Context
+      # :SSLCACertificatePath :: A path to the directory of CA certificates.
+      #                          The certificates are to be in PEM format.
+      # :SSLCACertificateFile :: A path to a CA certificate file, in PEM format.
+      # :SSLTmpDhCallback :: A DH callback. See
+      #                      OpenSSL::SSL::SSLContext.tmp_dh_callback
+      # :SSLVerifyMode :: This is the SSL verification mode.
+      #                   See OpenSSL::SSL::VERIFY_* for available modes.
+      #                   Default is OpenSSL::SSL::VERIFY_NONE
+      # :SSLVerifyDepth :: Number of CA certificates to walk, when verify a 
+      #                    certificate chain.
+      # :SSLVerifyCallback :: A callback to be used for additional verification.
+      #                       See OpenSSL::SSL::SSLContext.verify_callback
+      # :SSLCertificateStore :: A OpenSSL::X509::Store used for verification
+      #                         of certificates
+      # :SSLCertName :: Issuer name for the certificate.
+      #                 This is required when generating the certificate
+      #                 (if :SSLCertificate and :SSLPrivateKey were not given)
+      #                 The value of this is to be an Array of pairs. i.e.
+      #                 [["C", "Raleigh"], ["ST","North Carolina"], ["CN","fqdn.example.com"]]
+      # :SSLCertComment :: A comment to be used for generating the certificate.
+      #                    Default is "Generated by Ruby/OpenSSL"
+      #
+      #
+      # === Example
+      # These values can be added after the fact, like a Hash.
+      # 
+      #   require 'drb/ssl'
+      #   c = DRb::DRbSSLSocket::SSLConfig.new {}
+      #   c[:SSLCertificate] = OpenSSL::X509::Certificate.new(File.read('mycert.crt'))
+      #   c[:SSLPrivateKey] = OpenSSL::PKey::RSA.new(File.read('mycert.key'))
+      #   c[:SSLVerifyMode] = OpenSSL::SSL::VERIFY_PEER
+      #   c[:SSLCACertificatePath] = "/etc/ssl/certs/"
+      #   c.setup_certificate
+      #
+      # or
+      #
+      #   require 'drb/ssl'
+      #   c = DRb::DRbSSLSocket::SSLConfig.new({
+      #           :SSLCertName => [["CN" => DRb::DRbSSLSocket.getservername]]
+      #           })
+      #   c.setup_certificate
+      #
       def initialize(config)
         @config  = config
         @cert    = config[:SSLCertificate]
@@ -32,10 +103,13 @@ module DRb
         @ssl_ctx = nil
       end
 
+      # A convenience method to access the values like a Hash
       def [](key);
         @config[key] || DEFAULT[key]
       end
 
+      # Connect to IO +tcp+,
+      # with context of the current certificate configuration
       def connect(tcp)
         ssl = ::OpenSSL::SSL::SSLSocket.new(tcp, @ssl_ctx)
         ssl.sync = true
@@ -43,6 +117,8 @@ module DRb
         ssl
       end
 
+      # Accept connection to IO +tcp+,
+      # with context of the current certificate configuration
       def accept(tcp)
         ssl = OpenSSL::SSL::SSLSocket.new(tcp, @ssl_ctx)
         ssl.sync = true
@@ -50,6 +126,9 @@ module DRb
         ssl
       end
 
+      # Ensures that :SSLCertificate and :SSLPrivateKey have been provided
+      # or that a new certificate is generated with the other parameters
+      # provided.
       def setup_certificate
         if @cert && @pkey
           return
@@ -95,6 +174,8 @@ module DRb
         @pkey = rsa
       end
 
+      # Establish the OpenSSL::SSL::SSLContext with the configuration
+      # parameters provided.
       def setup_ssl_context
         ctx = ::OpenSSL::SSL::SSLContext.new
         ctx.cert            = @cert
@@ -111,6 +192,11 @@ module DRb
       end
     end
 
+    # Parse the dRuby +uri+ for an SSL connection.
+    #
+    # Expects drbssl://...
+    #
+    # Raises DRbBadScheme or DRbBadURI if +uri+ is not matching or malformed
     def self.parse_uri(uri)
       if uri =~ /^drbssl:\/\/(.*?):(\d+)(\?(.*))?$/
         host = $1
@@ -123,6 +209,12 @@ module DRb
       end
     end
 
+    # Return an DRb::DRbSSLSocket instance as a client-side connection,
+    # with the SSL connected.
+    #
+    # +uri+ is the URI we are connected to.
+    # +config+ is our configuration. Either a Hash or DRb::DRbSSLSocket::SSLConfig
+    #  
     def self.open(uri, config)
       host, port, = parse_uri(uri)
       host.untaint
@@ -134,6 +226,12 @@ module DRb
       self.new(uri, ssl, ssl_conf, true)
     end
 
+    # Return an DRb::DRbSSLSocket instance as a server-side connection,
+    # with the SSL connected.
+    #
+    # +uri+ is the URI we are connected to.
+    # +config+ is our configuration. Either a Hash or DRb::DRbSSLSocket::SSLConfig
+    #  
     def self.open_server(uri, config)
       uri = 'drbssl://:0' unless uri
       host, port, = parse_uri(uri)
@@ -152,18 +250,32 @@ module DRb
       self.new(@uri, soc, ssl_conf, false)
     end
 
+    # This is a convenience method to parse +uri+ and separate out any
+    # additional options appended in the +uri+.
+    #
+    # Returns an option-less uri and the option => [uri,option]
+    #
+    # The +config+ is completely unused, so passing nil is sufficient.
     def self.uri_option(uri, config)
       host, port, option = parse_uri(uri)
       return "drbssl://#{host}:#{port}", option
     end
 
+    # Create a DRb::DRbSSLSocket instance. 
+    #
+    # +uri+ is the URI we are connected to.
+    # +soc+ is the tcp socket we are bound to.
+    # +config+ is our configuration. Either a Hash or SSLConfig
+    # +is_established+ is a boolean of whether +soc+ is currenly established
     def initialize(uri, soc, config, is_established)
       @ssl = is_established ? soc : nil
       super(uri, soc.to_io, config)
     end
 
+    # Returns the SSL stream
     def stream; @ssl; end
 
+    # Closes the SSL stream before closing the dRuby connection.
     def close
       if @ssl
         @ssl.close
