* lib/mutex_m.rb: Add rdoc for Mutex_m module

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@39328 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 37 insertions, 21 deletions

diff --git a/lib/mutex_m.rb b/lib/mutex_m.rb
index 722754b8d5..6698cb5ac6 100644
--- a/lib/mutex_m.rb
+++ b/lib/mutex_m.rb
@@ -8,25 +8,36 @@
 #       patched by akira yamada
 #
 # --
-#   Usage:
-#       require "mutex_m.rb"
-#       obj = Object.new
-#       obj.extend Mutex_m
-#       ...
-#       extended object can be handled like Mutex
-#       or
-#       class Foo
-#         include Mutex_m
-#         ...
-#       end
-#       obj = Foo.new
-#       this obj can be handled like Mutex
-#
+
 
 require 'thread'
 
+# = mutex_m.rb
+#
+# When 'mutex_m' is required, any object that extends or includes Mutex_m will
+# be treated like a Mutex.
+#
+# Start by requiring the standard library Mutex_m:
+#
+#   require "mutex_m.rb"
+#
+# From here you can extend an object with Mutex instance methods:
+#
+#   obj = Object.new
+#   obj.extend Mutex_m
+#
+# Or mixin Mutex_m into your module to your class inherit Mutex instance
+# methods.
+#
+#   class Foo
+#     include Mutex_m
+#     # ...
+#   end
+#   obj = Foo.new
+#   # this obj can be handled like Mutex
+#
 module Mutex_m
-  def Mutex_m.define_aliases(cl)
+  def Mutex_m.define_aliases(cl) # :nodoc:
     cl.module_eval %q{
       alias locked? mu_locked?
       alias lock mu_lock
@@ -36,17 +47,17 @@ module Mutex_m
     }
   end
 
-  def Mutex_m.append_features(cl)
+  def Mutex_m.append_features(cl) # :nodoc:
     super
     define_aliases(cl) unless cl.instance_of?(Module)
   end
 
-  def Mutex_m.extend_object(obj)
+  def Mutex_m.extend_object(obj) # :nodoc:
     super
     obj.mu_extended
   end
 
-  def mu_extended
+  def mu_extended # :nodoc:
     unless (defined? locked? and
             defined? lock and
             defined? unlock and
@@ -57,38 +68,43 @@ module Mutex_m
     mu_initialize
   end
 
-  # locking
+  # See Mutex#synchronize
   def mu_synchronize(&block)
     @_mutex.synchronize(&block)
   end
 
+  # See Mutex#locked?
   def mu_locked?
     @_mutex.locked?
   end
 
+  # See Mutex#try_lock
   def mu_try_lock
     @_mutex.try_lock
   end
 
+  # See Mutex#lock
   def mu_lock
     @_mutex.lock
   end
 
+  # See Mutex#unlock
   def mu_unlock
     @_mutex.unlock
   end
 
+  # See Mutex#sleep
   def sleep(timeout = nil)
     @_mutex.sleep(timeout)
   end
 
   private
 
-  def mu_initialize
+  def mu_initialize # :nodoc:
     @_mutex = Mutex.new
   end
 
-  def initialize(*args)
+  def initialize(*args) # :nodoc:
     mu_initialize
     super
   end