Fixed yardoc

Author: jdantonio

lib/concurrent/actor/behaviour.rb

@@ -17,9 +17,9 @@ module Actor
     #
     #     > {include:Actor::Behaviour::Pausing}
     #
-    # -   {Behaviour::Supervised}:
+    # -   {Behaviour::Supervising}:
     #
-    #     > {include:Actor::Behaviour::Supervised}
+    #     > {include:Actor::Behaviour::Supervising}
     #
     # -   {Behaviour::Supervising}:
     #

lib/concurrent/atom.rb

@@ -18,7 +18,40 @@ module Concurrent
   # new value to the result of running the given block if and only if that
   # value validates.
   #
-  # @!macro copy_options
+  # @!macro [attach] copy_options
+  #   ## Copy Options
+  #
+  #   Object references in Ruby are mutable. This can lead to serious
+  #   problems when the {#value} of an object is a mutable reference. Which
+  #   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
+  #   "primative" data type. Each instance can be configured with a few
+  #   options that can help protect the program from potentially dangerous
+  #   operations. Each of these options can be optionally set when the oject
+  #   instance is created: 
+  #
+  #   * `:dup_on_deref` When true the object will call the `#dup` method on
+  #     the `value` object every time the `#value` methid is called
+  #     (default: false)
+  #   * `:freeze_on_deref` When true the object will call the `#freeze`
+  #     method on the `value` object every time the `#value` method is called
+  #     (default: false)
+  #   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
+  #     every time   the `#value` method is called. The `Proc` will be given
+  #     the current `value` as its only argument and the result returned by
+  #     the block will be the return   value of the `#value` call. When `nil`
+  #     this option will be ignored (default: nil)
+  #  
+  #   When multiple deref options are set the order of operations is strictly defined.
+  #   The order of deref operations is:
+  #   * `:copy_on_deref`
+  #   * `:dup_on_deref`
+  #   * `:freeze_on_deref`
+  #  
+  #   Because of this ordering there is no need to `#freeze` an object created by a
+  #   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
+  #   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
+  #   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
+  #   or Haskell) as we are likely to get in Ruby.
   #
   # @see http://clojure.org/atoms Clojure Atoms
   class Atom < Synchronization::Object
@@ -33,7 +66,14 @@ class Atom < Synchronization::Object
     #   intended new value. The validator will return true if the new value
     #   is acceptable else return false (preferrably) or raise an exception.
     #
-    # @!macro deref_options
+    # @!macro [attach] deref_options
+    #   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
+    #     returning the data from {#value}
+    #   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
+    #     returning the data from {#value}
+    #   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
+    #     method, call the given proc passing the internal value as the sole
+    #     argument then return the new value returned from the proc.
     # 
     # @raise [ArgumentError] if the validator is not a `Proc` (when given)
     def initialize(value, opts = {})

lib/concurrent/ivar.rb

@@ -27,8 +27,6 @@ module Concurrent
   # when the values they depend on are ready you want `dataflow`. `IVar` is
   # generally a low-level primitive.
   #
-  # @!macro copy_options
-  #
   # ## Examples
   #
   # Create, set and get an `IVar`
@@ -58,8 +56,12 @@ class IVar < Synchronization::Object
     #
     # @param [Object] value the initial value
     # @param [Hash] opts the options to create a message with
-    #
-    # @!macro deref_options
+    # @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(value = NO_VALUE, opts = {}, &block)
       if value != NO_VALUE && block_given?
         raise ArgumentError.new('provide only a value or a block')

lib/concurrent/mvar.rb

@@ -24,40 +24,7 @@ module Concurrent
   # Note that unlike the original Haskell paper, our `#take` is blocking. This is how
   # Haskell and Scala do it today.
   #
-  # @!macro [attach] copy_options
-  #   ## Copy Options
-  #
-  #   Object references in Ruby are mutable. This can lead to serious
-  #   problems when the {#value} of an object is a mutable reference. Which
-  #   is always the case unless the value is a `Fixnum`, `Symbol`, or similar
-  #   "primative" data type. Each instance can be configured with a few
-  #   options that can help protect the program from potentially dangerous
-  #   operations. Each of these options can be optionally set when the oject
-  #   instance is created: 
-  #
-  #   * `:dup_on_deref` When true the object will call the `#dup` method on
-  #     the `value` object every time the `#value` methid is called
-  #     (default: false)
-  #   * `:freeze_on_deref` When true the object will call the `#freeze`
-  #     method on the `value` object every time the `#value` method is called
-  #     (default: false)
-  #   * `:copy_on_deref` When given a `Proc` object the `Proc` will be run
-  #     every time   the `#value` method is called. The `Proc` will be given
-  #     the current `value` as its only argument and the result returned by
-  #     the block will be the return   value of the `#value` call. When `nil`
-  #     this option will be ignored (default: nil)
-  #  
-  #   When multiple deref options are set the order of operations is strictly defined.
-  #   The order of deref operations is:
-  #   * `:copy_on_deref`
-  #   * `:dup_on_deref`
-  #   * `:freeze_on_deref`
-  #  
-  #   Because of this ordering there is no need to `#freeze` an object created by a
-  #   provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
-  #   Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
-  #   as close to the behavior of a "pure" functional language (like Erlang, Clojure,
-  #   or Haskell) as we are likely to get in Ruby.
+  # @!macro copy_options
   #
   # ## See Also
   #
@@ -82,14 +49,7 @@ class MVar
     #
     # @param [Hash] opts the options controlling how the future will be processed
     #
-    # @!macro [attach] deref_options
-    #   @option opts [Boolean] :dup_on_deref (false) Call `#dup` before
-    #     returning the data from {#value}
-    #   @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before
-    #     returning the data from {#value}
-    #   @option opts [Proc] :copy_on_deref (nil) When calling the {#value}
-    #     method, call the given proc passing the internal value as the sole
-    #     argument then return the new value returned from the proc.
+    # @!macro deref_options
     def initialize(value = EMPTY, opts = {})
       @value = value
       @mutex = Mutex.new