Fixed yardoc errors.

Author: jdantonio

lib/concurrent/ivar.rb

@@ -26,40 +26,7 @@ module Concurrent
   # when the values they depend on are ready you want `dataflow`. `IVar` is
   # generally a low-level primitive.
   #
-  # @!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
   #
   # ## Examples
   #
@@ -91,14 +58,7 @@ class IVar < Synchronization::Object
     # @param [Object] value the initial value
     # @param [Hash] opts the options to create a message with
     #
-    # @!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 = 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,7 +24,40 @@ module Concurrent
   # Note that unlike the original Haskell paper, our `#take` is blocking. This is how
   # Haskell and Scala do it today.
   #
-  # @!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 Also
   #
@@ -49,7 +82,14 @@ class MVar
     #
     # @param [Hash] opts the options controlling how the future will be processed
     #
-    # @!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.
     def initialize(value = EMPTY, opts = {})
       @value = value
       @mutex = Mutex.new