nobu	2011-06-18 07:33:54 +0900 (Sat, 18 Jun 2011)

  New Revision: 32152

  http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=32152

  Log:
    * remove trailing spaces.

  Modified files:
    trunk/lib/monitor.rb
    trunk/variable.c

Index: variable.c
===================================================================
--- variable.c	(revision 32151)
+++ variable.c	(revision 32152)
@@ -1373,7 +1373,7 @@
  * Invoked when a reference is made to an undefined constant in
  * <i>mod</i>. It is passed a symbol for the undefined constant, and
  * returns a value to be used for that constant. The
- * following code is an example of the same: 
+ * following code is an example of the same:
  *
  *   def Foo.const_missing(name)
  *     name # return the constant name as Symbol
Index: lib/monitor.rb
===================================================================
--- lib/monitor.rb	(revision 32151)
+++ lib/monitor.rb	(revision 32152)
@@ -1,14 +1,14 @@
 # = monitor.rb
-# 
+#
 # Copyright (C) 2001  Shugo Maeda <shugo@r...>
-# 
+#
 # This library is distributed under the terms of the Ruby license.
 # You can freely distribute/modify this library.
 #
 
 require 'thread'
 
-# 
+#
 # In concurrent programming, a monitor is an object or module intended to be
 # used safely by more than one thread.  The defining characteristic of a
 # monitor is that its methods are executed with mutual exclusion.  That is, at
@@ -19,17 +19,17 @@
 #
 # You can read more about the general principles on the Wikipedia page for
 # Monitors[http://en.wikipedia.org/wiki/Monitor_%28synchronization%29]
-# 
+#
 # == Examples
-# 
+#
 # === Simple object.extend
-# 
+#
 #   require 'monitor.rb'
-# 
+#
 #   buf = []
 #   buf.extend(MonitorMixin)
 #   empty_cond = buf.new_cond
-# 
+#
 #   # consumer
 #   Thread.start do
 #     loop do
@@ -39,7 +39,7 @@
 #       end
 #     end
 #   end
-# 
+#
 #   # producer
 #   while line = ARGF.gets
 #     buf.synchronize do
@@ -47,16 +47,16 @@
 #       empty_cond.signal
 #     end
 #   end
-# 
+#
 # The consumer thread waits for the producer thread to push a line to buf
 # while <tt>buf.empty?</tt>.  The producer thread (main thread) reads a
 # line from ARGF and pushes it into buf then calls <tt>empty_cond.signal</tt>
 # to notify the consumer thread of new data.
-# 
+#
 # === Simple Class include
 #
 #   require 'monitor'
-# 
+#
 #   class SynchronizedArray < Array
 #
 #     include MonitorMixin
@@ -64,22 +64,22 @@
 #     def initialize(*args)
 #       super(*args)
 #     end
-#     
+#
 #     alias :old_shift :shift
 #     alias :old_unshift :unshift
-#     
+#
 #     def shift(n=1)
 #       self.synchronize do
 #         self.old_shift(n)
 #       end
 #     end
-#   
+#
 #     def unshift(item)
 #       self.synchronize do
 #         self.old_unshift(item)
 #       end
 #     end
-#     
+#
 #     # other methods ...
 #   end
 #
@@ -261,7 +261,7 @@
 end
 
 # Use the Monitor class when you want to have a lock object for blocks with
-# mutual exclusion. 
+# mutual exclusion.
 #
 #   require 'monitor'
 #

--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/