rdx 0.9.0.pre

data/examples/ruby-2.0.0-p0/install/core/diffs/load.c.diff

@@ -0,0 +1,53 @@
+--- core/orig/load.c	2015-06-11 07:51:44 +0000
++++ core/patched/load.c	2015-06-25 17:35:23 +0000
+@@ -730,6 +730,8 @@
+  *  loaded again if its path already appears in <code>$"</code>.  For example,
+  *  <code>require 'a'; require './a'</code> will not load <code>a.rb</code>
+  *  again.
++ * 
++ *  :rdx: off -
+  *
+  *    require "my-library.rb"
+  *    require "db-driver"
+@@ -986,11 +988,20 @@
+  *  Registers _filename_ to be loaded (using <code>Kernel::require</code>)
+  *  the first time that _module_ (which may be a <code>String</code> or
+  *  a symbol) is accessed in the namespace of _mod_.
+- *
++ * 
++ *     # File: b.rb
++ *     class A::B; end
++ *     puts 'File b required!'
++ *  
++ *  :rdx: toplevel
++ *     # in main
+  *     module A
+  *     end
+- *     A.autoload(:B, "b")
+- *     A::B.doit            # autoloads "b"
++ *     A.autoload(:B, File.expand_path("b"))
++ *     A::B   # prints: File b required!
++ *-- rdx
++ *     Object.send :remove_const, :A
++ *++
+  */
+ 
+ static VALUE
+@@ -1033,6 +1044,8 @@
+  *  Registers _filename_ to be loaded (using <code>Kernel::require</code>)
+  *  the first time that _module_ (which may be a <code>String</code> or
+  *  a symbol) is accessed.
++ * 
++ *  :rdx: off
+  *
+  *     autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
+  */
+@@ -1054,6 +1067,8 @@
+  *  Returns _filename_ to be loaded if _name_ is registered as
+  *  +autoload+.
+  *
++ *  :rdx: off
++ * 
+  *     autoload(:B, "b")
+  *     autoload?(:B)            #=> "b"
+  */

data/examples/ruby-2.0.0-p0/install/core/diffs/marshal.c.diff

@@ -0,0 +1,98 @@
+--- core/orig/marshal.c	2015-06-11 07:51:44 +0000
++++ core/patched/marshal.c	2015-06-19 21:20:55 +0000
+@@ -890,6 +890,7 @@
+  * traversal of subobjects will be limited to that depth. If limit is
+  * negative, no checking of depth will be performed.
+  *
++ * :rdx: toplevel
+  *     class Klass
+  *       def initialize(str)
+  *         @str = str
+@@ -899,12 +900,14 @@
+  *       end
+  *     end
+  *
+- * (produces no output)
+- *
+  *     o = Klass.new("hello\n")
+  *     data = Marshal.dump(o)
+  *     obj = Marshal.load(data)
+  *     obj.say_hello  #=> "hello\n"
++ * 
++ *-- rdx
++ *     Object.send :remove_const, :Klass
++ *++
+  *
+  * Marshal can't dump following objects:
+  * * anonymous Class/Module.
+@@ -1973,9 +1976,8 @@
+  * first two bytes of marshaled data.
+  *
+  *     str = Marshal.dump("thing")
+- *     RUBY_VERSION   #=> "1.9.0"
+- *     str[0].ord     #=> 4
+- *     str[1].ord     #=> 8
++ *     str.getbyte(0)     #=> 4
++ *     str.getbyte(1)     #=> 8
+  *
+  * Some objects cannot be dumped: if the objects to be dumped include
+  * bindings, procedure or method objects, instances of class IO, or
+@@ -2017,8 +2019,10 @@
+  * marshal_load must recreate the object from the information in the result.
+  *
+  * Example:
+- *
++ * :rdx: toplevel
++ * 
+  *   class MyObj
++ *     attr_reader :name, :version, :data
+  *     def initialize name, version, data
+  *       @name    = name
+  *       @version = version
+@@ -2033,7 +2037,17 @@
+  *       @name, @version = array
+  *     end
+  *   end
+- *
++ * 
++ *   obj = MyObj.new "MyName", 1.0, "secret data"
++ *   new_obj = Marshal.load(Marshal.dump(obj))
++ *   obj.name    == new_obj.name    #=> true
++ *   obj.version == new_obj.version #=> true
++ *   new_obj.data                   #=> nil
++ *   # The requested informations has been copied successfully!
++ *-- rdx
++ *   Object.send :remove_const, :MyObj
++ *++
++ * 
+  * == _dump and _load
+  *
+  * Use _dump and _load when you need to allocate the object you're restoring
+@@ -2050,6 +2064,7 @@
+  * Example:
+  *
+  *   class MyObj
++ *     attr_reader :name, :version, :data
+  *     def initialize name, version, data
+  *       @name    = name
+  *       @version = version
+@@ -2060,10 +2075,17 @@
+  *       [@name, @version].join ':'
+  *     end
+  *
+- *     def self._load args
+- *       new(*args.split(':'))
++ *     def self._load string
++ *       new(*string.split(':'),'Unknown data')
+  *     end
+  *   end
++ * 
++ *   obj = MyObj.new :the_name, 1.0, 'secret data'
++ *   new_obj = Marshal.load(Marshal.dump(obj))
++ *   new_obj.data #=> 'Unknown data'
++ *-- rdx
++ *   Object.send :remove_const, :MyObj
++ *++
+  *
+  * Since Marhsal.dump outputs a string you can have _dump return a Marshal
+  * string which is Marshal.loaded in _load for complex objects.

data/examples/ruby-2.0.0-p0/install/core/diffs/math.c.diff

@@ -0,0 +1,110 @@
+--- core/orig/math.c	2015-06-11 07:51:44 +0000
++++ core/patched/math.c	2015-06-19 21:23:37 +0000
+@@ -443,7 +443,7 @@
+  *    0.upto(10) {|x|
+  *      p [x, Math.sqrt(x), Math.sqrt(x)**2]
+  *    }
+- *    #=>
++ *  produces:
+  *    [0, 0.0, 0.0]
+  *    [1, 1.0, 1.0]
+  *    [2, 1.4142135623731, 2.0]
+@@ -481,7 +481,7 @@
+  *    -9.upto(9) {|x|
+  *      p [x, Math.cbrt(x), Math.cbrt(x)**3]
+  *    }
+- *    #=>
++ *  produces:
+  *    [-9, -2.0800838230519, -9.0]
+  *    [-8, -2.0, -8.0]
+  *    [-7, -1.91293118277239, -7.0]
+@@ -608,32 +608,33 @@
+  *
+  *   def fact(n) (1..n).inject(1) {|r,i| r*i } end
+  *   1.upto(26) {|i| p [i, Math.gamma(i), fact(i-1)] }
+- *   #=> [1, 1.0, 1]
+- *   #   [2, 1.0, 1]
+- *   #   [3, 2.0, 2]
+- *   #   [4, 6.0, 6]
+- *   #   [5, 24.0, 24]
+- *   #   [6, 120.0, 120]
+- *   #   [7, 720.0, 720]
+- *   #   [8, 5040.0, 5040]
+- *   #   [9, 40320.0, 40320]
+- *   #   [10, 362880.0, 362880]
+- *   #   [11, 3628800.0, 3628800]
+- *   #   [12, 39916800.0, 39916800]
+- *   #   [13, 479001600.0, 479001600]
+- *   #   [14, 6227020800.0, 6227020800]
+- *   #   [15, 87178291200.0, 87178291200]
+- *   #   [16, 1307674368000.0, 1307674368000]
+- *   #   [17, 20922789888000.0, 20922789888000]
+- *   #   [18, 355687428096000.0, 355687428096000]
+- *   #   [19, 6.402373705728e+15, 6402373705728000]
+- *   #   [20, 1.21645100408832e+17, 121645100408832000]
+- *   #   [21, 2.43290200817664e+18, 2432902008176640000]
+- *   #   [22, 5.109094217170944e+19, 51090942171709440000]
+- *   #   [23, 1.1240007277776077e+21, 1124000727777607680000]
+- *   #   [24, 2.5852016738885062e+22, 25852016738884976640000]
+- *   #   [25, 6.204484017332391e+23, 620448401733239439360000]
+- *   #   [26, 1.5511210043330954e+25, 15511210043330985984000000]
++ *  produces:
++ *   [1, 1.0, 1]
++ *   [2, 1.0, 1]
++ *   [3, 2.0, 2]
++ *   [4, 6.0, 6]
++ *   [5, 24.0, 24]
++ *   [6, 120.0, 120]
++ *   [7, 720.0, 720]
++ *   [8, 5040.0, 5040]
++ *   [9, 40320.0, 40320]
++ *   [10, 362880.0, 362880]
++ *   [11, 3628800.0, 3628800]
++ *   [12, 39916800.0, 39916800]
++ *   [13, 479001600.0, 479001600]
++ *   [14, 6227020800.0, 6227020800]
++ *   [15, 87178291200.0, 87178291200]
++ *   [16, 1307674368000.0, 1307674368000]
++ *   [17, 20922789888000.0, 20922789888000]
++ *   [18, 355687428096000.0, 355687428096000]
++ *   [19, 6.402373705728e+15, 6402373705728000]
++ *   [20, 1.21645100408832e+17, 121645100408832000]
++ *   [21, 2.43290200817664e+18, 2432902008176640000]
++ *   [22, 5.109094217170944e+19, 51090942171709440000]
++ *   [23, 1.1240007277776077e+21, 1124000727777607680000]
++ *   [24, 2.5852016738885062e+22, 25852016738884976640000]
++ *   [25, 6.204484017332391e+23, 620448401733239439360000]
++ *   [26, 1.5511210043330954e+25, 15511210043330985984000000]
+  *
+  */
+ 
+@@ -693,9 +694,17 @@
+  *  Calculates the logarithmic gamma of x and
+  *  the sign of gamma of x.
+  *
+- *  Math.lgamma(x) is same as
+- *   [Math.log(Math.gamma(x).abs), Math.gamma(x) < 0 ? -1 : 1]
+- *  but avoid overflow by Math.gamma(x) for large x.
++ *-- rdx
++ *    x = rand(100)
++ *++
++ * 
++ *  If +x+ isn't too large we have that:
++ *  :rdx: float
++ *    log_gamma,sgn_gamma = Math.lgamma(x)
++ *    log_gamma #=> Math.log(Math.gamma(x).abs)
++ *    sgn_gamma #=> Math.gamma(x) < 0 ? -1 : 1
++ *  otherwise Math.gamma(x) will overflow (yielding Infinity),
++ *  while Math.lgamma(x) does not
+  */
+ 
+ static VALUE
+@@ -759,7 +768,7 @@
+  *
+  *     Math.acos(42)
+  *
+- *  <em>produces:</em>
++ *  <em>raises the exception:</em>
+  *
+  *     Math::DomainError: Numerical argument is out of domain - "acos"
+  */

data/examples/ruby-2.0.0-p0/install/core/diffs/numeric.c.diff

@@ -0,0 +1,103 @@
+--- core/orig/numeric.c	2015-06-11 07:51:44 +0000
++++ core/patched/numeric.c	2015-06-25 17:35:23 +0000
+@@ -417,7 +417,12 @@
+  *  call-seq:
+  *     num.modulo(numeric)  ->  real
+  *
+- *     x.modulo(y) means x-y*(x/y).floor
++ *-- rdx
++ *     x = (-1)**rand(2) * (1+rand(10)*1.5)
++ *     y = (-1)**rand(2) * (1+rand(10)*1.5)
++ *++
++ *  The <code>modulo</code> is defined as:
++ *     x.modulo(y) #=> x-y*(x/y).floor
+  *
+  *  Equivalent to
+  *  <i>num</i>.<code>divmod(</code><i>aNumeric</i><code>)[1]</code>.
+@@ -437,7 +442,12 @@
+  *  call-seq:
+  *     num.remainder(numeric)  ->  real
+  *
+- *     x.remainder(y) means x-y*(x/y).truncate
++ *-- rdx
++ *     x = (-1)**rand(2) * (1+rand(10)*1.5)
++ *     y = (-1)**rand(2) * (1+rand(10)*1.5)
++ *++
++ *  The <code>remainder</code> is defined as:
++ *     x.remainder(y) #=> x-y*(x/y).truncate
+  *
+  *  See <code>Numeric#divmod</code>.
+  */
+@@ -462,13 +472,20 @@
+  *     num.divmod(numeric)  ->  array
+  *
+  *  Returns an array containing the quotient and modulus obtained by
+- *  dividing <i>num</i> by <i>numeric</i>. If <code>q, r =
+- *  x.divmod(y)</code>, then
++ *  dividing <i>num</i> by <i>numeric</i>.
+  *
+- *      q = floor(x/y)
+- *      x = q*y+r
++ *-- rdx
++ *     x = (-1)**rand(2) * (1+rand(10)*1.5)
++ *     y = (-1)**rand(2) * (1+rand(10)*1.5)
++ *++
++ *  If
++ *     q, r = x.divmod(y)
++ *  then:
++ *     q #=> (x/y).floor
++ *     x #=> q*y+r
+  *
+  *  The quotient is rounded toward -infinity, as shown in the following table:
++ *  :rdx: off -
+  *
+  *     a    |  b  |  a.divmod(b)  |   a/b   | a.modulo(b) | a.remainder(b)
+  *    ------+-----+---------------+---------+-------------+---------------
+@@ -1413,7 +1430,7 @@
+  *
+  *     a = -1.0      #=> -1.0
+  *     a.nan?        #=> false
+- *     a = 0.0/0.0   #=> NaN
++ *     a = 0.0/0.0   # > NaN
+  *     a.nan?        #=> true
+  */
+ 
+@@ -1855,6 +1872,7 @@
+  *  If no block is given, an enumerator is returned instead.
+  *
+  *     1.step(10, 2) { |i| print i, " " }
++ *     puts
+  *     Math::E.step(Math::PI, 0.2) { |f| print f, " " }
+  *
+  *  <em>produces:</em>
+@@ -2939,7 +2957,7 @@
+  *  be negative or fractional.
+  *
+  *    2 ** 3      #=> 8
+- *    2 ** -1     #=> (1/2)
++ *    2 ** -1     #=> 1/2
+  *    2 ** 0.5    #=> 1.4142135623731
+  */
+ 
+@@ -3680,9 +3698,9 @@
+  *
+  *  Note that only division by an exact 0 will raise that exception:
+  *
+- *     42 /  0.0 #=> Float::INFINITY
+- *     42 / -0.0 #=> -Float::INFINITY
+- *     0  /  0.0 #=> NaN
++ *     42 /  0.0 # > Infinity
++ *     42 / -0.0 # > -Infinity
++ *     0  /  0.0 # > NaN
+  */
+ 
+ /*
+@@ -3696,7 +3714,7 @@
+  *
+  *  <em>raises the exception:</em>
+  *
+- *     FloatDomainError: Infinity
++ *     FloatDomainError: NaN
+  */
+ 
+ void

data/examples/ruby-2.0.0-p0/install/core/diffs/object.c.diff

@@ -0,0 +1,295 @@
+--- core/orig/object.c	2015-06-11 07:51:44 +0000
++++ core/patched/object.c	2015-06-25 17:35:23 +0000
+@@ -88,9 +88,9 @@
+  *    obj = "a"
+  *    other = obj.dup
+  *
+- *    a == other      #=> true
+- *    a.equal? other  #=> false
+- *    a.equal? a      #=> true
++ *    obj == other       #=> true
++ *    obj.equal? other   #=> false
++ *    obj.equal? obj     #=> true
+  *
+  *  The <code>eql?</code> method returns <code>true</code> if +obj+ and
+  *  +other+ refer to the same hash key.  This is used by Hash to test members
+@@ -208,8 +208,8 @@
+  *  respectively.
+  *  If <i>obj</i> is a Fixnum or a Symbol, it raises a TypeError.
+  *
+- *     Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
+- *     String.singleton_class      #=> #<Class:String>
++ *     Object.new.singleton_class  # > #<Class:#<Object:0xb7ce1e24>>
++ *     String.singleton_class      # > #<Class:String>
+  *     nil.singleton_class         #=> NilClass
+  */
+ 
+@@ -280,12 +280,12 @@
+  *     class Klass
+  *        attr_accessor :str
+  *     end
+- *     s1 = Klass.new      #=> #<Klass:0x401b3a38>
++ *     s1 = Klass.new      # > #<Klass:0x401b3a38>
+  *     s1.str = "Hello"    #=> "Hello"
+- *     s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
++ *     s2 = s1.clone       # > #<Klass:0x401b3998 @str="Hello">
+  *     s2.str[1,4] = "i"   #=> "i"
+- *     s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
+- *     s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"
++ *     s1                  # > #<Klass:0x401b3a38 @str="Hi">
++ *     s2                  # > #<Klass:0x401b3998 @str="Hi">
+  *
+  *  This method may have class-specific behavior.  If so, that
+  *  behavior will be documented under the #+initialize_copy+ method of
+@@ -471,25 +471,25 @@
+  * encoding.
+  *
+  *     [ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
+- *     Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"
++ *     Time.new.inspect                 #-> "2008-03-08 19:43:39 +0900"
+  *
+  *     class Foo
+  *     end
+- *     Foo.new.inspect                  #=> "#<Foo:0x0300c868>"
++ *     Foo.new.inspect                  # -> "#<Foo:0x0300c868>"
+  *
+  *     class Bar
+  *       def initialize
+  *         @bar = 1
+  *       end
+  *     end
+- *     Bar.new.inspect                  #=> "#<Bar:0x0300c868 @bar=1>"
++ *     Bar.new.inspect                  # -> "#<Bar:0x0300c868 @bar=1>"
+  *
+  *     class Baz
+  *       def to_s
+  *         "baz"
+  *       end
+  *     end
+- *     Baz.new.inspect                  #=> "#<Baz:0x0300c868>"
++ *     Baz.new.inspect                  # -> "#<Baz:0x0300c868>"
+  */
+ 
+ static VALUE
+@@ -601,10 +601,18 @@
+  *  The primary purpose of this method is to "tap into" a method chain,
+  *  in order to perform operations on intermediate results within the chain.
+  *
+- *	(1..10)                .tap {|x| puts "original: #{x.inspect}"}
+- *	  .to_a                .tap {|x| puts "array: #{x.inspect}"}
+- *	  .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
+- *	  .map { |x| x*x }     .tap {|x| puts "squares: #{x.inspect}"}
++ *    (1..10)               .tap {|x| puts "original: #{x.inspect}"}
++ *      .to_a                .tap {|x| puts "array: #{x.inspect}"}
++ *      .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
++ *      .map { |x| x*x }     .tap {|x| puts "squares: #{x.inspect}"}
++ *    # => [4, 16, 36, 64, 100]
++ * 
++ *  produces:
++ *  
++ *    original: 1..10
++ *    array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
++ *    evens: [2, 4, 6, 8, 10]
++ *    squares: [4, 16, 36, 64, 100]
+  *
+  */
+ 
+@@ -790,7 +798,7 @@
+  *        module Enumerable
+  *          include A
+  *        end
+- *         # => prints "A included in Enumerable"
++ *        # prints: A included in Enumerable
+  */
+ 
+ /*
+@@ -809,7 +817,7 @@
+  *        module Enumerable
+  *          prepend A
+  *        end
+- *         # => prints "A prepended to Enumerable"
++ *        # prints: A prepended to Enumerable
+  */
+ 
+ /*
+@@ -960,10 +968,9 @@
+  *     a.freeze
+  *     a << "z"
+  *
+- *  <em>produces:</em>
++ *  <em>raises the exception:</em>
+  *
+- *     prog.rb:3:in `<<': can't modify frozen array (RuntimeError)
+- *     	from prog.rb:3
++ *     can't modify frozen Array (RuntimeError)
+  */
+ 
+ VALUE
+@@ -1058,8 +1065,6 @@
+ }
+ 
+ /*
+- * Document-method: to_a
+- *
+  *  call-seq:
+  *     nil.to_a    -> []
+  *
+@@ -1075,8 +1080,6 @@
+ }
+ 
+ /*
+- * Document-method: to_h
+- *
+  *  call-seq:
+  *     nil.to_h    -> {}
+  *
+@@ -1256,7 +1259,7 @@
+ }
+ 
+ /*
+- * call_seq:
++ * call-seq:
+  *   nil.nil?               -> true
+  *
+  * Only the object <i>nil</i> responds <code>true</code> to <code>nil?</code>.
+@@ -1269,7 +1272,7 @@
+ }
+ 
+ /*
+- * call_seq:
++ * call-seq:
+  *   nil.nil?               -> true
+  *   <anything_else>.nil?   -> false
+  *
+@@ -1352,7 +1355,7 @@
+  *       end
+  *     end
+  *     Mod.class              #=> Module
+- *     Mod.constants          #=> [:CONST, :PI, :E]
++ *     Mod.constants          #-> [:CONST, :PI, :E]
+  *     Mod.instance_methods   #=> [:meth]
+  *
+  */
+@@ -1628,7 +1631,7 @@
+  *       end
+  *     end
+  *
+- *     a = fred.new     #=> #<#<Class:0x100381890>:0x100376b98>
++ *     a = fred.new     # > #<#<Class:0x100381890>:0x100376b98>
+  *     a.meth1          #=> "hello"
+  *     a.meth2          #=> "bye"
+  *
+@@ -1886,8 +1889,9 @@
+  *  This method will recursively look up constant names if a namespaced
+  *  class name is provided.  For example:
+  *
+- *     module Foo; class Bar; end end
+- *     Object.const_get 'Foo::Bar'
++ *     module Foo; class Bar; class Bat; end end end
++ *     Foo.const_get 'Bar::Bat' #=> Foo::Bar::Bat
++ *  :rdx: # we are hiding that Foo isn't Object::Foo
+  *
+  *  The +inherit+ flag is respected on each lookup.  For example:
+  *
+@@ -1899,8 +1903,8 @@
+  *       class Baz < Bar; end
+  *     end
+  *
+- *     Object.const_get 'Foo::Baz::VAL'         # => 10
+- *     Object.const_get 'Foo::Baz::VAL', false  # => NameError
++ *     Foo.const_get 'Baz::VAL'         # => 10
++ *     Foo.const_get 'Baz::VAL', false  # raises NameError
+  */
+ 
+ static VALUE
+@@ -2035,9 +2039,9 @@
+  *
+  *  Returns whether or not a definition is found:
+  *
+- *     Math.const_defined? "PI"   #=> true
+- *     IO.const_defined? :SYNC   #=> true
+- *     IO.const_defined? :SYNC, false   #=> false
++ *     Math.const_defined? "PI"               #=> true
++ *     File.const_defined? :SEEK_END          #=> true   # Defined in IO class
++ *     File.const_defined? :SEEK_END, false   #=> false
+  */
+ 
+ static VALUE
+@@ -2127,7 +2131,7 @@
+  *     fred = Fred.new('cat', 99)
+  *     fred.instance_variable_set(:@a, 'dog')   #=> "dog"
+  *     fred.instance_variable_set(:@c, 'cat')   #=> "cat"
+- *     fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
++ *     fred                                     # > #<Fred:0x401b3da8 @a="dog", @b=99, @c="cat">
+  */
+ 
+ static VALUE
+@@ -2474,7 +2478,7 @@
+  *
+  *     Integer(123.999)    #=> 123
+  *     Integer("0x1a")     #=> 26
+- *     Integer(Time.new)   #=> 1204973019
++ *     Integer(Time.new)   #-> 1204973019
+  *     Integer("0930", 10) #=> 930
+  *     Integer("111", 2)   #=> 7
+  */
+@@ -2784,9 +2788,9 @@
+  *  <i>arg</i> is <tt>nil</tt> or <tt>[]</tt>.
+  *
+  *     Hash([])          #=> {}
+- *     Hash(nil)         #=> nil
++ *     Hash(nil)         #=> {}
+  *     Hash(key: :value) #=> {:key => :value}
+- *     Hash([1, 2, 3])   #=> TypeError
++ *     Hash([1, 2, 3])   # raises TypeError
+  */
+ 
+ static VALUE
+@@ -2815,20 +2819,33 @@
+  *  This can be demonstrated by overriding <code>new</code> in
+  *  <code>Class</code>:
+  *
++ *  :rdx: toplevel
+  *     class Class
+- *        alias oldNew  new
+- *        def new(*args)
++ *        alias old_new  new
++ *        def new(*args,&blk)
++ *-- rdx
++ *          unless self.name =~ /^RDX/ # Don't hook the internals!
++ *++
+  *          print "Creating a new ", self.name, "\n"
+- *          oldNew(*args)
++ *-- rdx
++ *          end
++ *++
++ *          old_new(*args,&blk)
+  *        end
+  *      end
+  *
+- *
++ * 
+  *      class Name
+  *      end
+  *
+- *
++ * 
+  *      n = Name.new
++ *-- rdx
++ *     class Class
++ *       alias new old_new
++ *       remove_method :old_new
++ *     end
++ *++
+  *
+  *  <em>produces:</em>
+  *
+@@ -2838,6 +2855,8 @@
+  *  that follows, the vertical arrows represent inheritance, and the
+  *  parentheses meta-classes. All metaclasses are instances
+  *  of the class `Class'.
++ * 
++ *  :rdx: off -
+  *                             +---------+             +-...
+  *                             |         |             |
+  *             BasicObject-----|-->(BasicObject)-------|-...