rdx 0.9.0.pre

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

@@ -0,0 +1,11 @@
+--- core/orig/bignum.c	2015-06-11 07:51:44 +0000
++++ core/patched/bignum.c	2015-06-19 06:44:58 +0000
+@@ -3145,7 +3145,7 @@
+  *
+  *    123456789 ** 2      #=> 15241578750190521
+  *    123456789 ** 1.2    #=> 5126464716.09932
+- *    123456789 ** -2     #=> 6.5610001194102e-17
++ *    123456789 ** -2     #=> 1/15241578750190521
+  */
+ 
+ VALUE

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

@@ -0,0 +1,36 @@
+--- core/orig/class.c	2015-06-11 07:51:44 +0000
++++ core/patched/class.c	2015-06-11 07:51:45 +0000
+@@ -1042,7 +1042,7 @@
+  *     A.instance_methods                #=> [:method1]
+  *     B.instance_methods(false)         #=> [:method2]
+  *     C.instance_methods(false)         #=> [:method3]
+- *     C.instance_methods(true).length   #=> 43
++ *     C.instance_methods(true).length   #-> 43
+  */
+ 
+ VALUE
+@@ -1119,10 +1119,10 @@
+  *       end
+  *     end
+  *     k = Klass.new
+- *     k.methods[0..9]    #=> [:klass_method, :nil?, :===,
+- *                        #    :==~, :!, :eql?
++ *     k.methods[0..9]    #-> [:klass_method, :nil?, :===,
++ *                        #    :=~, :!, :eql?,
+  *                        #    :hash, :<=>, :class, :singleton_class]
+- *     k.methods.length   #=> 57
++ *     k.methods.length   #-> 57
+  */
+ 
+ VALUE
+@@ -1218,8 +1218,8 @@
+  *     end
+  *
+  *     Single.singleton_methods    #=> [:four]
+- *     a.singleton_methods(false)  #=> [:two, :one]
+- *     a.singleton_methods         #=> [:two, :one, :three]
++ *     a.singleton_methods(false)  #=> [:one, :two]
++ *     a.singleton_methods         #=> [:one, :two, :three]
+  */
+ 
+ VALUE

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

@@ -0,0 +1,11 @@
+--- core/orig/compar.c	2015-06-11 07:51:44 +0000
++++ core/patched/compar.c	2015-06-11 07:51:46 +0000
+@@ -216,7 +216,7 @@
+  *     s1 < s2                       #=> true
+  *     s4.between?(s1, s3)           #=> false
+  *     s4.between?(s3, s5)           #=> true
+- *     [ s3, s2, s5, s4, s1 ].sort   #=> [Z, YY, XXX, WWWW, VVVVV]
++ *     [ s3, s2, s5, s4, s1 ].sort   # > [Z, YY, XXX, WWWW, VVVVV]
+  *
+  */
+ 

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

@@ -0,0 +1,301 @@
+--- core/orig/complex.c	2015-06-11 07:51:43 +0000
++++ core/patched/complex.c	2015-06-28 11:38:56 +0000
+@@ -440,7 +440,7 @@
+  *
+  * Returns a complex object which denotes the given rectangular form.
+  *
+- *    Complex.rectangular(1, 2)  #=> (1+2i)
++ *    Complex.rectangular(1, 2)  #=> 1+2i
+  */
+ static VALUE
+ nucomp_s_new(int argc, VALUE *argv, VALUE klass)
+@@ -481,8 +481,8 @@
+  *
+  * Returns x+i*y;
+  *
+- *    Complex(1, 2)    #=> (1+2i)
+- *    Complex('1+2i')  #=> (1+2i)
++ *    Complex(1, 2)    #=> 1+2i
++ *    Complex('1+2i')  #=> 1+2i
+  */
+ static VALUE
+ nucomp_f_complex(int argc, VALUE *argv, VALUE klass)
+@@ -592,10 +592,10 @@
+  *
+  * Returns a complex object which denotes the given polar form.
+  *
+- *    Complex.polar(3, 0)            #=> (3.0+0.0i)
+- *    Complex.polar(3, Math::PI/2)   #=> (1.836909530733566e-16+3.0i)
+- *    Complex.polar(3, Math::PI)     #=> (-3.0+3.673819061467132e-16i)
+- *    Complex.polar(3, -Math::PI/2)  #=> (1.836909530733566e-16-3.0i)
++ *    Complex.polar(3, 0)            #=> 3.0+0.0i
++ *    Complex.polar(3, Math::PI/2)   #=> 1.836909530733566e-16+3.0i
++ *    Complex.polar(3, Math::PI)     #=> -3.0+3.673819061467132e-16i
++ *    Complex.polar(3, -Math::PI/2)  #=> 1.836909530733566e-16-3.0i
+  */
+ static VALUE
+ nucomp_s_polar(int argc, VALUE *argv, VALUE klass)
+@@ -654,7 +654,7 @@
+  *
+  * Returns negation of the value.
+  *
+- *    -Complex(1, 2)  #=> (-1-2i)
++ *    -Complex(1, 2)  #=> -1-2i
+  */
+ static VALUE
+ nucomp_negate(VALUE self)
+@@ -693,11 +693,11 @@
+  *
+  * Performs addition.
+  *
+- *    Complex(2, 3)  + Complex(2, 3)   #=> (4+6i)
+- *    Complex(900)   + Complex(1)      #=> (901+0i)
+- *    Complex(-2, 9) + Complex(-9, 2)  #=> (-11+11i)
+- *    Complex(9, 8)  + 4               #=> (13+8i)
+- *    Complex(20, 9) + 9.8             #=> (29.8+9i)
++ *    Complex(2, 3)  + Complex(2, 3)   #=> 4+6i
++ *    Complex(900)   + Complex(1)      #=> 901+0i
++ *    Complex(-2, 9) + Complex(-9, 2)  #=> -11+11i
++ *    Complex(9, 8)  + 4               #=> 13+8i
++ *    Complex(20, 9) + 9.8             #=> 29.8+9i
+  */
+ static VALUE
+ nucomp_add(VALUE self, VALUE other)
+@@ -711,11 +711,11 @@
+  *
+  * Performs subtraction.
+  *
+- *    Complex(2, 3)  - Complex(2, 3)   #=> (0+0i)
+- *    Complex(900)   - Complex(1)      #=> (899+0i)
+- *    Complex(-2, 9) - Complex(-9, 2)  #=> (7+7i)
+- *    Complex(9, 8)  - 4               #=> (5+8i)
+- *    Complex(20, 9) - 9.8             #=> (10.2+9i)
++ *    Complex(2, 3)  - Complex(2, 3)   #=> 0+0i
++ *    Complex(900)   - Complex(1)      #=> 899+0i
++ *    Complex(-2, 9) - Complex(-9, 2)  #=> 7+7i
++ *    Complex(9, 8)  - 4               #=> 5+8i
++ *    Complex(20, 9) - 9.8             #=> 10.2+9i
+  */
+ static VALUE
+ nucomp_sub(VALUE self, VALUE other)
+@@ -729,11 +729,11 @@
+  *
+  * Performs multiplication.
+  *
+- *    Complex(2, 3)  * Complex(2, 3)   #=> (-5+12i)
+- *    Complex(900)   * Complex(1)      #=> (900+0i)
+- *    Complex(-2, 9) * Complex(-9, 2)  #=> (0-85i)
+- *    Complex(9, 8)  * 4               #=> (36+32i)
+- *    Complex(20, 9) * 9.8             #=> (196.0+88.2i)
++ *    Complex(2, 3)  * Complex(2, 3)   #=> -5+12i
++ *    Complex(900)   * Complex(1)      #=> 900+0i
++ *    Complex(-2, 9) * Complex(-9, 2)  #=> 0-85i
++ *    Complex(9, 8)  * 4               #=> 36+32i
++ *    Complex(20, 9) * 9.8             #=> 196.0+88.2i
+  */
+ static VALUE
+ nucomp_mul(VALUE self, VALUE other)
+@@ -821,11 +821,11 @@
+  *
+  * Performs division.
+  *
+- *    Complex(2, 3)  / Complex(2, 3)   #=> ((1/1)+(0/1)*i)
+- *    Complex(900)   / Complex(1)      #=> ((900/1)+(0/1)*i)
+- *    Complex(-2, 9) / Complex(-9, 2)  #=> ((36/85)-(77/85)*i)
+- *    Complex(9, 8)  / 4               #=> ((9/4)+(2/1)*i)
+- *    Complex(20, 9) / 9.8             #=> (2.0408163265306123+0.9183673469387754i)
++ *    Complex(2, 3)  / Complex(2, 3)   # > ((1/1)+(0/1)*i)
++ *    Complex(900)   / Complex(1)      # > ((900/1)+(0/1)*i)
++ *    Complex(-2, 9) / Complex(-9, 2)  # > ((36/85)-(77/85)*i)
++ *    Complex(9, 8)  / 4               # > ((9/4)+(2/1)*i)
++ *    Complex(20, 9) / 9.8             # > (2.0408163265306123+0.9183673469387754i)
+  */
+ static VALUE
+ nucomp_div(VALUE self, VALUE other)
+@@ -841,7 +841,7 @@
+  *
+  * Performs division as each part is a float, never returns a float.
+  *
+- *    Complex(11, 22).fdiv(3)  #=> (3.6666666666666665+7.333333333333333i)
++ *    Complex(11, 22).fdiv(3)  #=> 3.6666666666666665+7.333333333333333i
+  */
+ static VALUE
+ nucomp_fdiv(VALUE self, VALUE other)
+@@ -861,8 +861,8 @@
+  *
+  * Performs exponentiation.
+  *
+- *    Complex('i') ** 2              #=> (-1+0i)
+- *    Complex(-8) ** Rational(1, 3)  #=> (1.0000000000000002+1.7320508075688772i)
++ *    Complex('i') ** 2              #=> -1+0i
++ *    Complex(-8) ** Rational(1, 3)  #=> 1.0000000000000002+1.7320508075688772i
+  */
+ static VALUE
+ nucomp_expt(VALUE self, VALUE other)
+@@ -1087,7 +1087,7 @@
+  *
+  * Returns the complex conjugate.
+  *
+- *    Complex(1, 2).conjugate  #=> (1-2i)
++ *    Complex(1, 2).conjugate  #=> 1-2i
+  */
+ static VALUE
+ nucomp_conj(VALUE self)
+@@ -1154,17 +1154,19 @@
+  *    cmp.numerator  ->  numeric
+  *
+  * Returns the numerator.
++ * :rdx: off
+  *
+  *        1   2       3+4i  <-  numerator
+  *        - + -i  ->  ----
+  *        2   3        6    <-  denominator
+  *
+- *    c = Complex('1/2+2/3i')  #=> ((1/2)+(2/3)*i)
+- *    n = c.numerator          #=> (3+4i)
+- *    d = c.denominator        #=> 6
+- *    n / d                    #=> ((1/2)+(2/3)*i)
++ * :rdx: on
++ *    c = Complex('1/2+2/3i')  # > ((1/2)+(2/3)*i)
++ *    n = c.numerator          # > (3+4i)
++ *    d = c.denominator        # > 6
++ *    n / d                    # > ((1/2)+(2/3)*i)
+  *    Complex(Rational(n.real, d), Rational(n.imag, d))
+- *                             #=> ((1/2)+(2/3)*i)
++ *                             # > ((1/2)+(2/3)*i)
+  * See denominator.
+  */
+ static VALUE
+@@ -1379,8 +1381,8 @@
+  * should be exactly zero).
+  *
+  *    Complex(1, 0).to_i    #=> 1
+- *    Complex(1, 0.0).to_i  # RangeError
+- *    Complex(1, 2).to_i    # RangeError
++ *    Complex(1, 0.0).to_i  # raises RangeError
++ *    Complex(1, 2).to_i    # raises RangeError
+  */
+ static VALUE
+ nucomp_to_i(VALUE self)
+@@ -1403,8 +1405,8 @@
+  * be exactly zero).
+  *
+  *    Complex(1, 0).to_f    #=> 1.0
+- *    Complex(1, 0.0).to_f  # RangeError
+- *    Complex(1, 2).to_f    # RangeError
++ *    Complex(1, 0.0).to_f  # raises RangeError
++ *    Complex(1, 2).to_f    # raises RangeError
+  */
+ static VALUE
+ nucomp_to_f(VALUE self)
+@@ -1426,9 +1428,9 @@
+  * Returns the value as a rational if possible (the imaginary part
+  * should be exactly zero).
+  *
+- *    Complex(1, 0).to_r    #=> (1/1)
+- *    Complex(1, 0.0).to_r  # RangeError
+- *    Complex(1, 2).to_r    # RangeError
++ *    Complex(1, 0).to_r    #=> 1/1
++ *    Complex(1, 0.0).to_r  # raises RangeError
++ *    Complex(1, 2).to_r    # raises RangeError
+  *
+  * See rationalize.
+  */
+@@ -1452,9 +1454,9 @@
+  * Returns the value as a rational if possible (the imaginary part
+  * should be exactly zero).
+  *
+- *    Complex(1.0/3, 0).rationalize  #=> (1/3)
+- *    Complex(1, 0.0).rationalize    # RangeError
+- *    Complex(1, 2).rationalize      # RangeError
++ *    Complex(1.0/3, 0).rationalize  #=> 1/3
++ *    Complex(1, 0.0).rationalize    # raises RangeError
++ *    Complex(1, 2).rationalize      # raises RangeError
+  *
+  * See to_r.
+  */
+@@ -1479,8 +1481,8 @@
+  *
+  * Returns self.
+  *
+- *    Complex(2).to_c      #=> (2+0i)
+- *    Complex(-8, 6).to_c  #=> (-8+6i)
++ *    Complex(2).to_c      #=> 2+0i
++ *    Complex(-8, 6).to_c  #=> -8+6i
+  */
+ static VALUE
+ nucomp_to_c(VALUE self)
+@@ -1814,17 +1816,17 @@
+  * sequences can be separated by an underscore.  Returns zero for null
+  * or garbage string.
+  *
+- *    '9'.to_c           #=> (9+0i)
+- *    '2.5'.to_c         #=> (2.5+0i)
+- *    '2.5/1'.to_c       #=> ((5/2)+0i)
+- *    '-3/2'.to_c        #=> ((-3/2)+0i)
+- *    '-i'.to_c          #=> (0-1i)
+- *    '45i'.to_c         #=> (0+45i)
+- *    '3-4i'.to_c        #=> (3-4i)
+- *    '-4e2-4e-2i'.to_c  #=> (-400.0-0.04i)
+- *    '-0.0-0.0i'.to_c   #=> (-0.0-0.0i)
+- *    '1/2+3/4i'.to_c    #=> ((1/2)+(3/4)*i)
+- *    'ruby'.to_c        #=> (0+0i)
++ *    '9'.to_c           # > (9+0i)
++ *    '2.5'.to_c         # > (2.5+0i)
++ *    '2.5/1'.to_c       # > ((5/2)+0i)
++ *    '-3/2'.to_c        # > ((-3/2)+0i)
++ *    '-i'.to_c          # > (0-1i)
++ *    '45i'.to_c         # > (0+45i)
++ *    '3-4i'.to_c        # > (3-4i)
++ *    '-4e2-4e-2i'.to_c  # > (-400.0-0.04i)
++ *    '-0.0-0.0i'.to_c   # > (-0.0-0.0i)
++ *    '1/2+3/4i'.to_c    # > ((1/2)+(3/4)*i)
++ *    'ruby'.to_c        # > (0+0i)
+  */
+ static VALUE
+ string_to_c(VALUE self)
+@@ -2055,28 +2057,29 @@
+  * In ruby, you can create complex object with Complex, Complex::rect,
+  * Complex::polar or to_c method.
+  *
+- *    Complex(1)           #=> (1+0i)
+- *    Complex(2, 3)        #=> (2+3i)
+- *    Complex.polar(2, 3)  #=> (-1.9799849932008908+0.2822400161197344i)
+- *    3.to_c               #=> (3+0i)
++ *    Complex(1)           # > (1+0i)
++ *    Complex(2, 3)        # > (2+3i)
++ *    Complex.polar(2, 3)  # > (-1.9799849932008908+0.2822400161197344i)
++ *    3.to_c               # > (3+0i)
+  *
+  * You can also create complex object from floating-point numbers or
+  * strings.
+  *
+- *    Complex(0.3)         #=> (0.3+0i)
+- *    Complex('0.3-0.5i')  #=> (0.3-0.5i)
+- *    Complex('2/3+3/4i')  #=> ((2/3)+(3/4)*i)
+- *    Complex('1@2')       #=> (-0.4161468365471424+0.9092974268256817i)
+- *
+- *    0.3.to_c             #=> (0.3+0i)
+- *    '0.3-0.5i'.to_c      #=> (0.3-0.5i)
+- *    '2/3+3/4i'.to_c      #=> ((2/3)+(3/4)*i)
+- *    '1@2'.to_c           #=> (-0.4161468365471424+0.9092974268256817i)
++ *    Complex(0.3)         # > (0.3+0i)
++ *    Complex('0.3-0.5i')  # > (0.3-0.5i)
++ *    Complex('2/3+3/4i')  # > ((2/3)+(3/4)*i)
++ *    Complex('1@2')       # > (-0.4161468365471424+0.9092974268256817i)
++ *
++ *    0.3.to_c             # > (0.3+0i)
++ *    '0.3-0.5i'.to_c      # > (0.3-0.5i)
++ *    '2/3+3/4i'.to_c      # > ((2/3)+(3/4)*i)
++ *    '1@2'.to_c           # > (-0.4161468365471424+0.9092974268256817i)
+  *
+  * A complex object is either an exact or an inexact number.
+  *
+- *    Complex(1, 1) / 2    #=> ((1/2)+(1/2)*i)
+- *    Complex(1, 1) / 2.0  #=> (0.5+0.5i)
++ *    Complex(1, 1) / 2    # > ((1/2)+(1/2)*i)
++ * :rdx: bug   the result is again ((1/2)+(1/2)*i)
++ *    Complex(1, 1) / 2.0  # > (0.5+0.5i)
+  */
+ void
+ Init_Complex(void)

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

@@ -0,0 +1,65 @@
+--- core/orig/cont.c	2015-06-11 07:51:44 +0000
++++ core/patched/cont.c	2015-06-12 23:25:36 +0000
+@@ -965,15 +965,9 @@
+  *      2
+  *    end
+  *
+- *    puts fiber.resume
+- *    puts fiber.resume
+- *    puts fiber.resume
+- *
+- *  <em>produces</em>
+- *
+- *    1
+- *    2
+- *    FiberError: dead fiber called
++ *    fiber.resume #=> 1
++ *    fiber.resume #=> 2
++ *    fiber.resume # raises FiberError: dead fiber called
+  *
+  *  The <code>Fiber#resume</code> method accepts an arbitrary number of
+  *  parameters, if it is the first call to <code>resume</code> then they
+@@ -986,15 +980,9 @@
+  *      second = Fiber.yield first + 2
+  *    end
+  *
+- *    puts fiber.resume 10
+- *    puts fiber.resume 14
+- *    puts fiber.resume 18
+- *
+- *  <em>produces</em>
+- *
+- *    12
+- *    14
+- *    FiberError: dead fiber called
++ *    fiber.resume 10 #=> 12
++ *    fiber.resume 14 #=> 14
++ *    fiber.resume 18 # raises FiberError: dead fiber called
+  *
+  */
+ 
+@@ -1455,11 +1443,11 @@
+  *    fiber2.resume
+  *    fiber3.resume
+  *
+- *    <em>produces</em>
++ *  <em>produces</em>
+  *
+- *    In fiber 2
+- *    In fiber 1
+- *    In fiber 3
++ *    In Fiber 2
++ *    In Fiber 1
++ *    In Fiber 3
+  *
+  */
+ static VALUE
+@@ -1513,7 +1501,7 @@
+  *
+  *     fiber = Fiber.new{}
+  *     fiber.resume #=> nil
+- *     fiber.resume #=> FiberError: dead fiber called
++ *     fiber.resume # raises FiberError: dead fiber called
+  */
+ 
+ void

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

@@ -0,0 +1,147 @@
+--- core/orig/dir.c	2015-06-11 07:51:44 +0000
++++ core/patched/dir.c	2015-06-25 17:35:23 +0000
+@@ -644,7 +644,7 @@
+  *     d = Dir.new("testdir")
+  *     d.tell   #=> 0
+  *     d.read   #=> "."
+- *     d.tell   #=> 12
++ *     d.tell   #=> 1
+  */
+ static VALUE
+ dir_tell(VALUE dir)
+@@ -668,11 +668,11 @@
+  *  Seeks to a particular location in <em>dir</em>. <i>integer</i>
+  *  must be a value returned by <code>Dir#tell</code>.
+  *
+- *     d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
++ *     d = Dir.new("testdir")   # > #<Dir:testdir>
+  *     d.read                   #=> "."
+- *     i = d.tell               #=> 12
++ *     i = d.tell               #=> 1
+  *     d.read                   #=> ".."
+- *     d.seek(i)                #=> #<Dir:0x401b3c40>
++ *     d.seek(i)                # > #<Dir:testdir>
+  *     d.read                   #=> ".."
+  */
+ static VALUE
+@@ -696,11 +696,11 @@
+  *  Synonym for <code>Dir#seek</code>, but returns the position
+  *  parameter.
+  *
+- *     d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
++ *     d = Dir.new("testdir")   # > #<Dir:testdir>
+  *     d.read                   #=> "."
+- *     i = d.pos                #=> 12
++ *     i = d.pos                #=> 1
+  *     d.read                   #=> ".."
+- *     d.pos = i                #=> 12
++ *     d.pos = i                #=> 1
+  *     d.read                   #=> ".."
+  */
+ static VALUE
+@@ -718,7 +718,7 @@
+  *
+  *     d = Dir.new("testdir")
+  *     d.read     #=> "."
+- *     d.rewind   #=> #<Dir:0x401b3fb0>
++ *     d.rewind   # > #<Dir:testdir>
+  *     d.read     #=> "."
+  */
+ static VALUE
+@@ -814,6 +814,7 @@
+  *  to open a <code>chdir</code> block while another thread has one
+  *  open.
+  *
++ *  :rdx: off
+  *     Dir.chdir("/var/spool/mail")
+  *     puts Dir.pwd
+  *     Dir.chdir("/tmp") do
+@@ -893,6 +894,7 @@
+  *  Returns the path to the current working directory of this process as
+  *  a string.
+  *
++ *  :rdx: if File.directory? '/tmp'
+  *     Dir.chdir("/tmp")   #=> 0
+  *     Dir.getwd           #=> "/tmp"
+  */
+@@ -957,7 +959,7 @@
+  *  also the discussion of permissions in the class documentation for
+  *  <code>File</code>.
+  *
+- *    Dir.mkdir(File.join(Dir.home, ".foo"), 0700) #=> 0
++ *    Dir.mkdir(File.join(Dir.pwd, ".foo"), 0700) #=> 0
+  *
+  */
+ static VALUE
+@@ -1804,6 +1806,9 @@
+  *                          i.e. <code>Dir["c:\\foo*"]</code> will not work,
+  *                          use <code>Dir["c:/foo*"]</code> instead.
+  *
++ *  :rdx: no_warnings stderr
++ *     Dir.chdir 'testdir'
++ *  :rdx:
+  *     Dir["config.?"]                     #=> ["config.h"]
+  *     Dir.glob("config.?")                #=> ["config.h"]
+  *     Dir.glob("*.[a-z][a-z]")            #=> ["main.rb"]
+@@ -1812,16 +1817,33 @@
+  *     Dir.glob("*")                       #=> ["config.h", "main.rb"]
+  *     Dir.glob("*", File::FNM_DOTMATCH)   #=> [".", "..", "config.h", "main.rb"]
+  *
++ *  Now let's enhance the tree structure in order to show other stuff:
++ *  :rdx: off -
++ *    testdir (Dir.pwd)
++ *     |- config.h
++ *     |- main.rb
++ *     +- lib
++ *         |- song.rb
++ *         +- song
++ *             +- karaoke.rb
++ *-- rdx
++ *  :rdx:
++ *     FileUtils.mkpath 'lib/song'
++ *     File.write 'lib/song.rb', 'rb'
++ *     File.write 'lib/song/karaoke.rb', 'rb'
++ *++
++ *  Returning to the examples:
++ * 
+  *     rbfiles = File.join("**", "*.rb")
+- *     Dir.glob(rbfiles)                   #=> ["main.rb",
++ *     Dir.glob(rbfiles)                   #=> ["lib/song/karaoke.rb",
+  *                                         #    "lib/song.rb",
+- *                                         #    "lib/song/karaoke.rb"]
++ *                                         #    "main.rb",]
+  *     libdirs = File.join("**", "lib")
+  *     Dir.glob(libdirs)                   #=> ["lib"]
+  *
+  *     librbfiles = File.join("**", "lib", "**", "*.rb")
+- *     Dir.glob(librbfiles)                #=> ["lib/song.rb",
+- *                                         #    "lib/song/karaoke.rb"]
++ *     Dir.glob(librbfiles)                #=> ["lib/song/karaoke.rb",
++ *                                         #    "lib/song.rb"]
+  *
+  *     librbfiles = File.join("**", "lib", "*.rb")
+  *     Dir.glob(librbfiles)                #=> ["lib/song.rb"]
+@@ -2086,6 +2108,23 @@
+  *  (<code>config.h</code> and <code>main.rb</code>), the parent
+  *  directory (<code>..</code>), and the directory itself
+  *  (<code>.</code>).
++ * 
++ *  In the following examples we assume that we are located in a temporary
++ *  directory with the following structure:
++ * 
++ *  :rdx: off -
++ * 
++ *    Dir.pwd
++ *     +- testdir
++ *         |- config.h
++ *         +- main.rb
++ * 
++ *  :rdx: in_tmpdir!!
++ * 
++ *  :rdx: setup
++ *    Dir.mkdir  'testdir'
++ *    File.write 'testdir/config.h', 'h'
++ *    File.write 'testdir/main.rb', 'rb'
+  */
+ void
+ Init_Dir(void)