Updated YARD to support Markdown.

Author: jdantonio

.yardopts

@@ -0,0 +1 @@
+--protected --private --embed-mixins --output-dir ./doc --markup markdown

lib/concurrent/actor_context.rb

@@ -15,18 +15,18 @@ module Concurrent
   #
   # The actor framework in this library is heavily influenced by the Akka toolkit,
   # with additional inspiration from Erlang and Scala. Unlike many of the abstractions
-  # in this library, +ActorContext+ takes an *object-oriented* approach to asynchronous
+  # in this library, `ActorContext` takes an *object-oriented* approach to asynchronous
   # concurrency, rather than a *functional programming* approach.
   #
-  # Creating an actor class is achieved by including the +ActorContext+ module
-  # within a standard Ruby class. One +ActorContext+ is mixed in, however, everything
-  # changes. Objects of the class can no longer be instanced with the +#new+ method.
-  # Instead, the various factor methods, such as +#spawn+, must be used. These factory
+  # Creating an actor class is achieved by including the `ActorContext` module
+  # within a standard Ruby class. One `ActorContext` is mixed in, however, everything
+  # changes. Objects of the class can no longer be instanced with the `#new` method.
+  # Instead, the various factor methods, such as `#spawn`, must be used. These factory
   # methods do not return direct references to the actor object. Instead they return
-  # objects of one of the +ActorRef+ subclasses. The +ActorRef+ objects encapsulate
+  # objects of one of the `ActorRef` subclasses. The `ActorRef` objects encapsulate
   # actor objects. This encapsulation is necessary to prevent synchronous method calls
   # froom being made against the actors. It also allows the messaging and lifecycle
-  # behavior to be implemented within the +ActorRef+ subclasses, allowing for better
+  # behavior to be implemented within the `ActorRef` subclasses, allowing for better
   # separation of responsibility.
   #
   # @see Concurrent::ActorRef
@@ -36,19 +36,19 @@ module Concurrent
   # @see http://www.scala-lang.org/api/current/index.html#scala.actors.Actor
   module ActorContext
 
-    # Callback method called by the +ActorRef+ which encapsulates the actor instance.
+    # Callback method called by the `ActorRef` which encapsulates the actor instance.
     def on_start
     end
 
-    # Callback method called by the +ActorRef+ which encapsulates the actor instance.
+    # Callback method called by the `ActorRef` which encapsulates the actor instance.
     def on_reset
     end
 
-    # Callback method called by the +ActorRef+ which encapsulates the actor instance.
+    # Callback method called by the `ActorRef` which encapsulates the actor instance.
     def on_shutdown
     end
 
-    # Callback method called by the +ActorRef+ which encapsulates the actor instance.
+    # Callback method called by the `ActorRef` which encapsulates the actor instance.
     #
     # @param [Time] time the date/time at which the error occurred
     # @param [Array] message the message that caused the error
@@ -65,9 +65,9 @@ class << base
         # Should the thread ever die it will be restarted the next time a message is post.
         #
         # @param [Hash] opts the options defining actor behavior
-        # @option opts [Array] :args (+nil+) arguments to be passed to the actor constructor
+        # @option opts [Array] :args (`nil`) arguments to be passed to the actor constructor
         #
-        # @return [SimpleActorRef] the +ActorRef+ encapsulating the actor
+        # @return [SimpleActorRef] the `ActorRef` encapsulating the actor
         def spawn(opts = {})
           args = opts.fetch(:args, [])
           Concurrent::SimpleActorRef.new(self.new(*args), opts)

lib/concurrent/actor_ref.rb

@@ -2,7 +2,7 @@
 
 module Concurrent
 
-  # Base class for classes that encapsulate +ActorContext+ objects.
+  # Base class for classes that encapsulate `ActorContext` objects.
   #
   # @see Concurrent::ActorContext
   module ActorRef
@@ -20,8 +20,8 @@ module ActorRef
     #
     #   @yield a callback operation to be performed when the operation is complete.
     #   @yieldparam [Time] time the date/time at which the error occurred
-    #   @yieldparam [Object] result the result of message processing or +nil+ on error
-    #   @yieldparam [Exception] exception the exception object that was raised or +nil+ on success
+    #   @yieldparam [Object] result the result of message processing or `nil` on error
+    #   @yieldparam [Exception] exception the exception object that was raised or `nil` on success
     #
     #   @return [IVar] a future that will eventually contain the result of message processing
 
@@ -39,21 +39,21 @@ module ActorRef
 
     # @!method running?()
     #   Is the actor running and processing messages?
-    #   @return [Boolean] +true+ if running else +false+
+    #   @return [Boolean] `true` if running else `false`
 
     # @!method shutdown?()
     #   Is the actor shutdown and no longer processing messages?
-    #   @return [Boolean] +true+ if shutdown else +false+
+    #   @return [Boolean] `true` if shutdown else `false`
 
     # @!method shutdown()
     #   Shutdown the actor, gracefully exit all threads, and stop processing messages.
-    #   @return [Boolean] +true+ if shutdown is successful else +false+
+    #   @return [Boolean] `true` if shutdown is successful else `false`
 
     # @!method join(limit = nil)
     #   Suspend the current thread until the actor has been shutdown
     #   @param [Integer] limit the maximum number of seconds to block waiting for the
-    #     actor to shutdown. Block indefinitely when +nil+ or not given
-    #   @return [Boolean] +true+ if the actor shutdown before the limit expired else +false+
+    #     actor to shutdown. Block indefinitely when `nil` or not given
+    #   @return [Boolean] `true` if the actor shutdown before the limit expired else `false`
     #   @see http://www.ruby-doc.org/core-2.1.1/Thread.html#method-i-join
 
     def <<(message)

lib/concurrent/agent.rb

@@ -8,8 +8,8 @@
 module Concurrent
 
   # An agent is a single atomic value that represents an identity. The current value
-  # of the agent can be requested at any time (#deref). Each agent has a work queue and operates on
-  # the global thread pool. Consumers can #post code blocks to the agent. The code block (function)
+  # of the agent can be requested at any time (`#deref`). Each agent has a work queue and operates on
+  # the global thread pool. Consumers can `#post` code blocks to the agent. The code block (function)
   # will receive the current value of the agent as its sole parameter. The return value of the block
   # will become the new value of the agent. Agents support two error handling modes: fail and continue.
   # A good example of an agent is a shared incrementing counter, such as the score in a video game.
@@ -50,15 +50,15 @@ class Agent
     #
     # @option opts [Fixnum] :timeout (TIMEOUT) maximum number of seconds before an update is cancelled
     #
-    # @option opts [Boolean] :operation (false) when +true+ will execute the future on the global
-    #   operation pool (for long-running operations), when +false+ will execute the future on the
+    # @option opts [Boolean] :operation (false) when `true` will execute the future on the global
+    #   operation pool (for long-running operations), when `false` will execute the future on the
     #   global task pool (for short-running tasks)
     # @option opts [object] :executor when provided will run all operations on
     #   this executor rather than the global thread pool (overrides :operation)
     #
-    # @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
+    # @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
     def initialize(initial, opts = {})
       @value = initial
@@ -73,9 +73,9 @@ def initialize(initial, opts = {})
 
     # Specifies a block operation to be performed when an update operation raises
     # an exception. Rescue blocks will be checked in order they were added. The first
-    # block for which the raised exception "is-a" subclass of the given +clazz+ will
-    # be called. If no +clazz+ is given the block will match any caught exception.
-    # This behavior is intended to be identical to Ruby's +begin/rescue/end+ behavior.
+    # block for which the raised exception "is-a" subclass of the given `clazz` will
+    # be called. If no `clazz` is given the block will match any caught exception.
+    # This behavior is intended to be identical to Ruby's `begin/rescue/end` behavior.
     # Any number of rescue handlers can be added. If no rescue handlers are added then
     # caught exceptions will be suppressed.
     #

lib/concurrent/async.rb

@@ -17,20 +17,20 @@ module Concurrent
   # Stateful, mutable objects must be managed carefully when used asynchronously.
   # But Ruby is an object-oriented language so designing with objects and classes
   # plays to Ruby's strengths and is often more natural to many Ruby programmers.
-  # The +Async+ module is a way to mix simple yet powerful asynchronous capabilities
+  # The `Async` module is a way to mix simple yet powerful asynchronous capabilities
   # into any plain old Ruby object or class. These capabilities provide a reasonable
   # level of thread safe guarantees when used correctly.
   #
   # When this module is mixed into a class or object it provides to new methods:
-  # +async+ and +await+. These methods are thread safe with respect to the enclosing
+  # `async` and `await`. These methods are thread safe with respect to the enclosing
   # object. The former method allows methods to be called asynchronously by posting
   # to the global thread pool. The latter allows a method to be called synchronously
   # on the current thread but does so safely with respect to any pending asynchronous
-  # method calls. Both methods return an +Obligation+ which can be inspected for
-  # the result of the method call. Calling a method with +async+ will return a
-  # +:pending+ +Obligation+ whereas +await+ will return a +:complete+ +Obligation+.
+  # method calls. Both methods return an `Obligation` which can be inspected for
+  # the result of the method call. Calling a method with `async` will return a
+  # `:pending` `Obligation` whereas `await` will return a `:complete` `Obligation`.
   #
-  # Very loosely based on the +async+ and +await+ keywords in C#.
+  # Very loosely based on the `async` and `await` keywords in C#.
   #
   # @example Defining an asynchronous class
   #   class Echo
@@ -64,9 +64,9 @@ module Concurrent
   # @note Thread safe guarantees can only be made when asynchronous method calls
   #       are not mixed with synchronous method calls. Use only synchronous calls
   #       when the object is used exclusively on a single thread. Use only
-  #       +async+ and +await+ when the object is shared between threads. Once you
-  #       call a method using +async+, you should no longer call any methods
-  #       directly on the object. Use +async+ and +await+ exclusively from then on.
+  #       `async` and `await` when the object is shared between threads. Once you
+  #       call a method using `async`, you should no longer call any methods
+  #       directly on the object. Use `async` and `await` exclusively from then on.
   #       With careful programming it is possible to switch back and forth but it's
   #       also very easy to create race conditions and break your application.
   #       Basically, it's "async all the way down."
@@ -83,14 +83,14 @@ module Async
     # @param [Symbol] method the method to check the object for
     # @param [Array] args zero or more arguments for the arity check
     #
-    # @raise [NameError] the object does not respond to +method+ method
-    # @raise [ArgumentError] the given +args+ do not match the arity of +method+
+    # @raise [NameError] the object does not respond to `method` method
+    # @raise [ArgumentError] the given `args` do not match the arity of `method`
     #
     # @note This check is imperfect because of the way Ruby reports the arity of
     #   methods with a variable number of arguments. It is possible to determine
     #   if too few arguments are given but impossible to determine if too many
     #   arguments are given. This check may also fail to recognize dynamic behavior
-    #   of the object, such as methods simulated with +method_missing+.
+    #   of the object, such as methods simulated with `method_missing`.
     #
     # @see http://www.ruby-doc.org/core-2.1.1/Method.html#method-i-arity Method#arity
     # @see http://ruby-doc.org/core-2.1.0/Object.html#method-i-respond_to-3F Object#respond_to?
@@ -112,8 +112,8 @@ def validate_argc(obj, method, *args)
     # @!visibility private
     class AwaitDelegator # :nodoc:
 
-      # Create a new delegator object wrapping the given +delegate+ and
-      # protecting it with the given +mutex+.
+      # Create a new delegator object wrapping the given `delegate` and
+      # protecting it with the given `mutex`.
       #
       # @param [Object] delegate the object to wrap and delegate method calls to
       # @param [Mutex] mutex the mutex lock to use when delegating method calls
@@ -124,15 +124,15 @@ def initialize(delegate, mutex)
 
       # Delegates method calls to the wrapped object. For performance,
       # dynamically defines the given method on the delegator so that
-      # all future calls to +method+ will not be directed here.
+      # all future calls to `method` will not be directed here.
       #
       # @param [Symbol] method the method being called
       # @param [Array] args zero or more arguments to the method
       #
       # @return [IVar] the result of the method call
       #
-      # @raise [NameError] the object does not respond to +method+ method
-      # @raise [ArgumentError] the given +args+ do not match the arity of +method+
+      # @raise [NameError] the object does not respond to `method` method
+      # @raise [ArgumentError] the given `args` do not match the arity of `method`
       def method_missing(method, *args, &block)
         super unless @delegate.respond_to?(method)
         Async::validate_argc(@delegate, method, *args)
@@ -166,8 +166,8 @@ def method_missing(method, *args, &block)
     # @!visibility private
     class AsyncDelegator # :nodoc:
 
-      # Create a new delegator object wrapping the given +delegate+ and
-      # protecting it with the given +mutex+.
+      # Create a new delegator object wrapping the given `delegate` and
+      # protecting it with the given `mutex`.
       #
       # @param [Object] delegate the object to wrap and delegate method calls to
       # @param [Mutex] mutex the mutex lock to use when delegating method calls
@@ -179,15 +179,15 @@ def initialize(delegate, executor, mutex)
 
       # Delegates method calls to the wrapped object. For performance,
       # dynamically defines the given method on the delegator so that
-      # all future calls to +method+ will not be directed here.
+      # all future calls to `method` will not be directed here.
       #
       # @param [Symbol] method the method being called
       # @param [Array] args zero or more arguments to the method
       #
       # @return [IVar] the result of the method call
       #
-      # @raise [NameError] the object does not respond to +method+ method
-      # @raise [ArgumentError] the given +args+ do not match the arity of +method+
+      # @raise [NameError] the object does not respond to `method` method
+      # @raise [ArgumentError] the given `args` do not match the arity of `method`
       def method_missing(method, *args, &block)
         super unless @delegate.respond_to?(method)
         Async::validate_argc(@delegate, method, *args)
@@ -214,29 +214,29 @@ def method_missing(method, *args, &block)
 
     # Causes the chained method call to be performed asynchronously on the
     # global thread pool. The method called by this method will return a
-    # +Future+ object in the +:pending+ state and the method call will have
+    # `Future` object in the `:pending` state and the method call will have
     # been scheduled on the global thread pool. The final disposition of the
-    # method call can be obtained by inspecting the returned +Future+.
+    # method call can be obtained by inspecting the returned `Future`.
     #
     # Before scheduling the method on the global thread pool a best-effort
     # attempt will be made to validate that the method exists on the object
     # and that the given arguments match the arity of the requested function.
     # Due to the dynamic nature of Ruby and limitations of its reflection
     # library, some edge cases will be missed. For more information see
-    # the documentation for the +validate_argc+ method.
+    # the documentation for the `validate_argc` method.
     #
     # @note The method call is guaranteed to be thread safe  with respect to
     #   all other method calls against the same object that are called with
-    #   either +async+ or +await+. The mutable nature of Ruby references
+    #   either `async` or `await`. The mutable nature of Ruby references
     #   (and object orientation in general) prevent any other thread safety
     #   guarantees. Do NOT mix non-protected method calls with protected
     #   method call. Use ONLY protected method calls when sharing the object
     #   between threads.
     #
     # @return [Concurrent::Future] the pending result of the asynchronous operation
     #
-    # @raise [NameError] the object does not respond to +method+ method
-    # @raise [ArgumentError] the given +args+ do not match the arity of +method+
+    # @raise [NameError] the object does not respond to `method` method
+    # @raise [ArgumentError] the given `args` do not match the arity of `method`
     #
     # @see Concurrent::Future
     def async
@@ -246,29 +246,29 @@ def async
 
     # Causes the chained method call to be performed synchronously on the
     # current thread. The method called by this method will return an
-    # +IVar+ object in either the +:fulfilled+ or +rejected+ state and the
+    # `IVar` object in either the `:fulfilled` or `rejected` state and the
     # method call will have completed. The final disposition of the
-    # method call can be obtained by inspecting the returned +IVar+.
+    # method call can be obtained by inspecting the returned `IVar`.
     #
     # Before scheduling the method on the global thread pool a best-effort
     # attempt will be made to validate that the method exists on the object
     # and that the given arguments match the arity of the requested function.
     # Due to the dynamic nature of Ruby and limitations of its reflection
     # library, some edge cases will be missed. For more information see
-    # the documentation for the +validate_argc+ method.
+    # the documentation for the `validate_argc` method.
     #
     # @note The method call is guaranteed to be thread safe  with respect to
     #   all other method calls against the same object that are called with
-    #   either +async+ or +await+. The mutable nature of Ruby references
+    #   either `async` or `await`. The mutable nature of Ruby references
     #   (and object orientation in general) prevent any other thread safety
     #   guarantees. Do NOT mix non-protected method calls with protected
     #   method call. Use ONLY protected method calls when sharing the object
     #   between threads.
     #
     # @return [Concurrent::IVar] the completed result of the synchronous operation
     #
-    # @raise [NameError] the object does not respond to +method+ method
-    # @raise [ArgumentError] the given +args+ do not match the arity of +method+
+    # @raise [NameError] the object does not respond to `method` method
+    # @raise [ArgumentError] the given `args` do not match the arity of `method`
     #
     # @see Concurrent::IVar
     def await