Format documentation text to use less than 100 columns

Author: rranelli

lib/concurrent/actor.rb

@@ -81,7 +81,8 @@ def self.spawn!(*args, &block)
 
     # @overload spawn_optionify(context_class, name, *args)
     #   @param [AbstractContext] context_class to be spawned
-    #   @param [String, Symbol] name of the instance, it's used to generate the {Core#path} of the actor
+    #   @param [String, Symbol] name of the instance, it's used to generate the
+    #     {Core#path} of the actor
     #   @param args for context_class instantiation
     # @overload spawn_optionify(opts)
     #   see {Core#initialize} opts

lib/concurrent/actor/behaviour/buffer.rb

@@ -2,11 +2,12 @@ module Concurrent
   module Actor
     module Behaviour
 
-      # Any message reaching this behaviour is buffered. Only one message is is scheduled
-      # at any given time. Others are kept in buffer until another one can be scheduled.
-      # This effectively means that messages handled by behaviours before buffer have higher priority
-      # and they can be processed before messages arriving into buffer. This allows for
-      # the processing of internal actor messages like (`:link`, `:supervise`) first.
+      # Any message reaching this behaviour is buffered. Only one message is is
+      # scheduled at any given time. Others are kept in buffer until another one
+      # can be scheduled. This effectively means that messages handled by
+      # behaviours before buffer have higher priority and they can be processed
+      # before messages arriving into buffer. This allows for the processing of
+      # internal actor messages like (`:link`, `:supervise`) first.
       class Buffer < Abstract
         def initialize(core, subsequent)
           super core, subsequent

lib/concurrent/actor/context.rb

@@ -39,16 +39,19 @@ def on_envelope(envelope)
         @envelope = nil
       end
 
-      # if you want to pass the message to next behaviour, usually {Behaviour::ErrorsOnUnknownMessage}
+      # if you want to pass the message to next behaviour, usually
+      # {Behaviour::ErrorsOnUnknownMessage}
       def pass
         core.behaviour!(Behaviour::ExecutesContext).pass envelope
       end
 
-      # Defines an actor responsible for dead letters. Any rejected message send with
-      # {Reference#tell} is sent there, a message with ivar is considered already monitored for
-      # failures. Default behaviour is to use {AbstractContext#dead_letter_routing} of the parent,
-      # so if no {AbstractContext#dead_letter_routing} method is overridden in parent-chain the message ends up in
-      # `Actor.root.dead_letter_routing` agent which will log warning.
+      # Defines an actor responsible for dead letters. Any rejected message send
+      # with {Reference#tell} is sent there, a message with ivar is considered
+      # already monitored for failures. Default behaviour is to use
+      # {AbstractContext#dead_letter_routing} of the parent, so if no
+      # {AbstractContext#dead_letter_routing} method is overridden in
+      # parent-chain the message ends up in `Actor.root.dead_letter_routing`
+      # agent which will log warning.
       # @return [Reference]
       def dead_letter_routing
         parent.dead_letter_routing

lib/concurrent/actor/core.rb

@@ -4,9 +4,11 @@ module Actor
     require 'set'
 
     # Core of the actor
-    # @note Whole class should be considered private. An user should use {Context}s and {Reference}s only.
-    # @note devel: core should not block on anything, e.g. it cannot wait on children to terminate
-    #   that would eat up all threads in task pool and deadlock
+    # @note Whole class should be considered private. An user should use
+    #   {Context}s and {Reference}s only.
+    # @note devel: core should not block on anything, e.g. it cannot wait on
+    #   children to terminate that would eat up all threads in task pool and
+    #   deadlock
     class Core
       include TypeCheck
       include Concurrent::Logging
@@ -36,11 +38,14 @@ class Core
       # @option opts [Executor] executor, default is `Concurrent.configuration.global_task_pool`
       # @option opts [true, false] link, atomically link the actor to its parent
       # @option opts [true, false] supervise, atomically supervise the actor by its parent
-      # @option opts [Array<Array(Behavior::Abstract, Array<Object>)>] behaviour_definition, array of pairs
-      #   where each pair is behaviour class and its args, see {Behaviour.basic_behaviour_definition}
-      # @option opts [IVar, nil] initialized, if present it'll be set or failed after {Context} initialization
-      # @option opts [Proc, nil] logger a proc accepting (level, progname, message = nil, &block) params,
-      #   can be used to hook actor instance to any logging system
+      # @option opts [Array<Array(Behavior::Abstract, Array<Object>)>]
+      #   behaviour_definition, array of pairs where each pair is behaviour
+      #   class and its args, see {Behaviour.basic_behaviour_definition}
+      # @option opts [IVar, nil] initialized, if present it'll be set or failed
+      #   after {Context} initialization
+      # @option opts [Proc, nil] logger a proc accepting (level, progname,
+      #   message = nil, &block) params, can be used to hook actor instance to
+      #   any logging system
       # @param [Proc] block for class instantiation
       def initialize(opts = {}, &block)
         synchronize do

lib/concurrent/agent.rb

@@ -32,8 +32,8 @@ class Agent
     #
     # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
     # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
-    # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
-    #   returning the value returned from the proc
+    # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing
+    #   the internal value and returning the value returned from the proc
     def initialize(initial, opts = {})
       @value                = initial
       @rescuers             = []
@@ -63,7 +63,7 @@ def initialize(initial, opts = {})
     #             rescue(NoMethodError){|ex| puts "Bam!" }.
     #             rescue(ArgumentError){|ex| puts "Pow!" }.
     #             rescue{|ex| puts "Boom!" }
-    #   
+    #
     #   score << proc{|current| raise ArgumentError }
     #   sleep(0.1)
     #   #=> puts "Pow!"

lib/concurrent/atomic/condition.rb

@@ -1,13 +1,14 @@
 module Concurrent
 
-  # Condition is a better implementation of standard Ruby ConditionVariable.
-  # The biggest difference is the wait return value: Condition#wait returns
-  # Condition::Result which make possible to know if waiting thread has been woken up
-  # by an another thread (using #signal or #broadcast) or due to timeout.
+  # Condition is a better implementation of standard Ruby ConditionVariable. The
+  # biggest difference is the wait return value: Condition#wait returns
+  # Condition::Result which make possible to know if waiting thread has been
+  # woken up by an another thread (using #signal or #broadcast) or due to
+  # timeout.
   #
-  # Every #wait must be guarded by a locked Mutex or a ThreadError will be risen.
-  # Although it's not mandatory, it's recommended to call also #signal and #broadcast within
-  # the same mutex
+  # Every #wait must be guarded by a locked Mutex or a ThreadError will be
+  # risen. Although it's not mandatory, it's recommended to call also #signal
+  # and #broadcast within the same mutex
   class Condition
 
     class Result
@@ -17,12 +18,14 @@ def initialize(remaining_time)
 
       attr_reader :remaining_time
 
-      # @return [Boolean] true if current thread has been waken up by a #signal or a #broadcast call, otherwise false
+      # @return [Boolean] true if current thread has been waken up by a #signal
+      #  or a #broadcast call , otherwise false
       def woken_up?
         @remaining_time.nil? || @remaining_time > 0
       end
 
-      # @return [Boolean] true if current thread has been waken up due to a timeout, otherwise false
+      # @return [Boolean] true if current thread has been waken up due to a
+      #   timeout, otherwise false
       def timed_out?
         @remaining_time != nil && @remaining_time <= 0
       end

lib/concurrent/atomic/copy_on_notify_observer_set.rb

@@ -11,10 +11,12 @@ def initialize
       @observers = {}
     end
 
-    # Adds an observer to this set
-    # If a block is passed, the observer will be created by this method and no other params should be passed
+    # Adds an observer to this set. If a block is passed, the observer will be
+    # created by this method and no other params should be passed
+    #
     # @param [Object] observer the observer to add
-    # @param [Symbol] func the function to call on the observer during notification. Default is :update
+    # @param [Symbol] func the function to call on the observer during notification.
+    #   Default is :update
     # @return [Object] the added observer
     def add_observer(observer=nil, func=:update, &block)
       if observer.nil? && block.nil?

lib/concurrent/atomic/copy_on_write_observer_set.rb

@@ -11,9 +11,11 @@ def initialize
     end
 
     # Adds an observer to this set
-    # If a block is passed, the observer will be created by this method and no other params should be passed
+    # If a block is passed, the observer will be created by this method and no
+    #   other params should be passed
     # @param [Object] observer the observer to add
-    # @param [Symbol] func the function to call on the observer during notification. Default is :update
+    # @param [Symbol] func the function to call on the observer during notification.
+    #   Default is :update
     # @return [Object] the added observer
     def add_observer(observer=nil, func=:update, &block)
       if observer.nil? && block.nil?

lib/concurrent/atomic/cyclic_barrier.rb

@@ -8,7 +8,8 @@ class CyclicBarrier
     # Create a new `CyclicBarrier` that waits for `parties` threads
     #
     # @param [Fixnum] parties the number of parties
-    # @yield an optional block that will be executed that will be executed after the last thread arrives and before the others are released
+    # @yield an optional block that will be executed that will be executed after
+    #  the last thread arrives and before the others are released
     #
     # @raise [ArgumentError] if `parties` is not an integer or is less than zero
     def initialize(parties, &block)
@@ -31,10 +32,14 @@ def number_waiting
       @number_waiting
     end
 
-    # Blocks on the barrier until the number of waiting threads is equal to `parties` or until `timeout` is reached or `reset` is called
-    # If a block has been passed to the constructor, it will be executed once by the last arrived thread before releasing the others
-    # @param [Fixnum] timeout the number of seconds to wait for the counter or `nil` to block indefinitely
-    # @return [Boolean] `true` if the `count` reaches zero else false on `timeout` or on `reset` or if the barrier is broken
+    # Blocks on the barrier until the number of waiting threads is equal to
+    # `parties` or until `timeout` is reached or `reset` is called
+    # If a block has been passed to the constructor, it will be executed once by
+    #  the last arrived thread before releasing the others
+    # @param [Fixnum] timeout the number of seconds to wait for the counter or
+    #  `nil` to block indefinitely
+    # @return [Boolean] `true` if the `count` reaches zero else false on
+    #  `timeout` or on `reset` or if the barrier is broken
     def wait(timeout = nil)
       @mutex.synchronize do
 
@@ -55,7 +60,8 @@ def wait(timeout = nil)
 
 
     # resets the barrier to its initial state
-    # If there is at least one waiting thread, it will be woken up, the `wait` method will return false and the barrier will be broken
+    # If there is at least one waiting thread, it will be woken up, the `wait`
+    # method will return false and the barrier will be broken
     # If the barrier is broken, this method restores it to the original state
     #
     # @return [nil]
@@ -103,4 +109,4 @@ def wait_while_waiting(generation, timeout)
     end
 
   end
-end
+end

lib/concurrent/atomic/semaphore.rb

@@ -154,11 +154,12 @@ def try_acquire_timed(permits, timeout)
 
     # @!macro semaphore
     #
-    #   A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each {#acquire} blocks if necessary
-    #   until a permit is available, and then takes it. Each {#release} adds a permit,
-    #   potentially releasing a blocking acquirer.
-    #   However, no actual permit objects are used; the Semaphore just keeps a count of the number available and
-    #   acts accordingly.
+    #   A counting semaphore. Conceptually, a semaphore maintains a set of
+    #   permits. Each {#acquire} blocks if necessary until a permit is
+    #   available, and then takes it. Each {#release} adds a permit, potentially
+    #   releasing a blocking acquirer.
+    #   However, no actual permit objects are used; the Semaphore just keeps a
+    #   count of the number available and acts accordingly.
     class Semaphore < JavaSemaphore
     end