rdx 0.9.0.pre

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

@@ -0,0 +1,18 @@
+--- core/orig/pack.c	2015-06-11 07:51:44 +0000
++++ core/patched/pack.c	2015-06-25 17:35:23 +0000
+@@ -286,6 +286,7 @@
+  *     n.pack("ccc")      #=> "ABC"
+  *
+  *  Directives for +pack+.
++ *  :rdx: off -
+  *
+  *   Integer      | Array   |
+  *   Directive    | Element | Meaning
+@@ -1232,6 +1233,7 @@
+  *
+  *  This table summarizes the various formats and the Ruby classes
+  *  returned by each.
++ *  :rdx: off -
+  *
+  *   Integer      |         |
+  *   Directive    | Returns | Meaning

data/examples/ruby-2.0.0-p0/install/core/diffs/parse.y.diff

@@ -0,0 +1,23 @@
+--- core/orig/parse.y	2013-01-31 07:33:30 +0000
++++ core/patched/parse.y	2015-06-20 07:31:38 +0000
+@@ -10390,13 +10390,13 @@
+  *  Returns an array of all the symbols currently in Ruby's symbol
+  *  table.
+  *
+- *     Symbol.all_symbols.size    #=> 903
+- *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
+- *                                     :chown, :EOFError, :$;, :String,
+- *                                     :LOCK_SH, :"setuid?", :$<,
+- *                                     :default_proc, :compact, :extend,
+- *                                     :Tms, :getwd, :$=, :ThreadGroup,
+- *                                     :wait2, :$>]
++ *     Symbol.all_symbols.size    #-> 903
++ *     Symbol.all_symbols[1,20]   #-> [:floor, :ARGV, :Binding, :symlink,
++ *                                #    :chown, :EOFError, :$;, :String,
++ *                                #    :LOCK_SH, :"setuid?", :$<,
++ *                                #    :default_proc, :compact, :extend,
++ *                                #    :Tms, :getwd, :$=, :ThreadGroup,
++ *                                #    :wait2, :$>]
+  */
+ 
+ VALUE

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

@@ -0,0 +1,155 @@
+--- core/orig/proc.c	2015-06-11 07:51:43 +0000
++++ core/patched/proc.c	2015-06-12 23:46:09 +0000
+@@ -147,9 +147,9 @@
+  *
+  * A Proc object generated by +lambda+ doesn't have such tricks.
+  *
+- *   lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
+- *   lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
+- *   lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError
++ *   lambda {|a,b| [a,b] }.call(1,2,3)  # raises ArgumentError
++ *   lambda {|a,b| [a,b] }.call(1)      # raises ArgumentError
++ *   lambda {|a,b| [a,b] }.call([1,2])  # raises ArgumentError
+  *
+  * Proc#lambda? is a predicate for the tricks.
+  * It returns +true+ if no tricks apply.
+@@ -198,7 +198,7 @@
+  *   class C
+  *     define_method(:d) {}
+  *   end
+- *   C.new.d(1,2)       #=> ArgumentError
++ *   C.new.d(1,2)       # raises ArgumentError
+  *   C.new.method(:d).to_proc.lambda?   #=> true
+  *
+  * +define_method+ always defines a method without the tricks,
+@@ -208,7 +208,7 @@
+  *   class C
+  *     define_method(:e, &proc {})
+  *   end
+- *   C.new.e(1,2)       #=> ArgumentError
++ *   C.new.e(1,2)       # raises ArgumentError
+  *   C.new.method(:e).to_proc.lambda?   #=> true
+  *
+  * This exception insures that methods never have tricks
+@@ -221,7 +221,7 @@
+  *
+  *     def2(:f) {}
+  *   end
+- *   C.new.f(1,2)       #=> ArgumentError
++ *   C.new.f(1,2)       # raises ArgumentError
+  *
+  * The wrapper <i>def2</i> defines a method which has no tricks.
+  *
+@@ -547,11 +547,9 @@
+  *     a_proc = lambda {|a,b| a}
+  *     a_proc.call(1,2,3)
+  *
+- *  <em>produces:</em>
++ *  <em>raises the exception:</em>
+  *
+- *     prog.rb:4:in `block in <main>': wrong number of arguments (3 for 2) (ArgumentError)
+- *     	from prog.rb:5:in `call'
+- *     	from prog.rb:5:in `<main>'
++ *     wrong number of arguments (3 for 2) (ArgumentError)
+  *
+  */
+ 
+@@ -649,7 +647,7 @@
+  *
+  *     proc   { |x = 0| }.arity       #=> 0
+  *     lambda { |a = 0| }.arity       #=> -1
+- *     proc   { |x=0, y| }.arity      #=> 0
++ *     proc   { |x=0, y| }.arity      #=> 1
+  *     lambda { |x=0, y| }.arity      #=> -2
+  *     proc   { |x=0, y=0| }.arity    #=> 0
+  *     lambda { |x=0, y=0| }.arity    #=> -1
+@@ -1434,7 +1432,7 @@
+  *     A.define_singleton_method(:who_am_i) do
+  *       "I am: #{class_name}"
+  *     end
+- *     A.who_am_i   # ==> "I am: A"
++ *     A.who_am_i   # => "I am: A"
+  *
+  *     guy = "Bob"
+  *     guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
+@@ -1635,15 +1633,12 @@
+  *     bm.call
+  *     bm = um.bind(B.new)
+  *     bm.call
+- *     bm = um.bind(A.new)
+- *     bm.call
++ *     bm = um.bind(A.new) # raises TypeError: bind argument must be an instance of B
+  *
+  *  <em>produces:</em>
+  *
+  *     In test, class = C
+  *     In test, class = B
+- *     prog.rb:16:in `bind': bind argument must be an instance of B (TypeError)
+- *     	from prog.rb:16
+  */
+ 
+ static VALUE
+@@ -2043,7 +2038,7 @@
+ }
+ 
+ /*
+- * call_seq:
++ * call-seq:
+  *   local_jump_error.exit_value  -> obj
+  *
+  * Returns the exit value associated with this +LocalJumpError+.
+@@ -2167,34 +2162,34 @@
+   *  takes the rest of arguments.
+   *
+   *     b = proc {|x, y, z| (x||0) + (y||0) + (z||0) }
+-  *     p b.curry[1][2][3]           #=> 6
+-  *     p b.curry[1, 2][3, 4]        #=> 6
+-  *     p b.curry(5)[1][2][3][4][5]  #=> 6
+-  *     p b.curry(5)[1, 2][3, 4][5]  #=> 6
+-  *     p b.curry(1)[1]              #=> 1
++  *     b.curry[1][2][3]           #=> 6
++  *     b.curry[1, 2][3, 4]        #=> 6
++  *     b.curry(5)[1][2][3][4][5]  #=> 6
++  *     b.curry(5)[1, 2][3, 4][5]  #=> 6
++  *     b.curry(1)[1]              #=> 1
+   *
+   *     b = proc {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) }
+-  *     p b.curry[1][2][3]           #=> 6
+-  *     p b.curry[1, 2][3, 4]        #=> 10
+-  *     p b.curry(5)[1][2][3][4][5]  #=> 15
+-  *     p b.curry(5)[1, 2][3, 4][5]  #=> 15
+-  *     p b.curry(1)[1]              #=> 1
++  *     b.curry[1][2][3]           #=> 6
++  *     b.curry[1, 2][3, 4]        #=> 10
++  *     b.curry(5)[1][2][3][4][5]  #=> 15
++  *     b.curry(5)[1, 2][3, 4][5]  #=> 15
++  *     b.curry(1)[1]              #=> 1
+   *
+   *     b = lambda {|x, y, z| (x||0) + (y||0) + (z||0) }
+-  *     p b.curry[1][2][3]           #=> 6
+-  *     p b.curry[1, 2][3, 4]        #=> wrong number of arguments (4 for 3)
+-  *     p b.curry(5)                 #=> wrong number of arguments (5 for 3)
+-  *     p b.curry(1)                 #=> wrong number of arguments (1 for 3)
++  *     b.curry[1][2][3]           #=> 6
++  *     b.curry[1, 2][3, 4]        # raises ArgumentError: wrong number of arguments (4 for 3)
++  *     b.curry(5)                 # raises ArgumentError: wrong number of arguments (5 for 3)
++  *     b.curry(1)                 # raises ArgumentError: wrong number of arguments (1 for 3)
+   *
+   *     b = lambda {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) }
+-  *     p b.curry[1][2][3]           #=> 6
+-  *     p b.curry[1, 2][3, 4]        #=> 10
+-  *     p b.curry(5)[1][2][3][4][5]  #=> 15
+-  *     p b.curry(5)[1, 2][3, 4][5]  #=> 15
+-  *     p b.curry(1)                 #=> wrong number of arguments (1 for 3)
++  *     b.curry[1][2][3]           #=> 6
++  *     b.curry[1, 2][3, 4]        #=> 10
++  *     b.curry(5)[1][2][3][4][5]  #=> 15
++  *     b.curry(5)[1, 2][3, 4][5]  #=> 15
++  *     b.curry(1)                 # raises ArgumentError: wrong number of arguments (1 for 3+)
+   *
+   *     b = proc { :foo }
+-  *     p b.curry[]                  #=> :foo
++  *     b.curry[]                  #=> :foo
+   */
+ static VALUE
+ proc_curry(int argc, VALUE *argv, VALUE self)

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

@@ -0,0 +1,126 @@
+--- core/orig/random.c	2015-06-11 07:51:44 +0000
++++ core/patched/random.c	2015-06-20 07:58:39 +0000
+@@ -563,7 +563,7 @@
+  * Returns an arbitrary seed value. This is used by Random.new
+  * when no seed value is specified as an argument.
+  *
+- *   Random.new_seed  #=> 115032730400174366788466674494640623225
++ *   Random.new_seed  #-> 115032730400174366788466674494640623225
+  */
+ static VALUE
+ random_seed(void)
+@@ -582,10 +582,10 @@
+  *
+  *   prng1 = Random.new(1234)
+  *   prng1.seed       #=> 1234
+- *   prng1.rand(100)  #=> 47
++ *   rand = prng1.rand(100)  #-> 47
+  *
+  *   prng2 = Random.new(prng1.seed)
+- *   prng2.rand(100)  #=> 47
++ *   prng2.rand(100)  #=> rand # 47
+  */
+ static VALUE
+ random_get_seed(VALUE obj)
+@@ -782,11 +782,19 @@
+  * between different runs of the program. By setting the seed to a known value,
+  * programs can be made deterministic during testing.
+  *
+- *   srand 1234               # => 268519324636777531569100071560086917274
+- *   [ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
+- *   [ rand(10), rand(1000) ] # => [4, 664]
++ *-- rdx
++ *   orig_srand = srand
++ *++
++ *   srand 1234               # -> 268519324636777531569100071560086917274
++ *   rand1,rand2 = rand,rand  # -> [0.1915194503788923,0.6221087710398319]
++ *   [ rand(10), rand(1000) ] # -> [4, 664]
+  *   srand 1234               # => 1234
+- *   [ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
++ *   [ rand, rand ]           # => [rand1, rand2]
++ *                            #    [0.1915194503788923,0.6221087710398319]
++ *-- rdx
++ *   srand orig_srand
++ *++
++ * 
+  */
+ 
+ static VALUE
+@@ -963,7 +971,7 @@
+  *
+  * Returns a random binary string containing +size+ bytes.
+  *
+- *   random_string = Random.new.bytes(10) # => "\xD7:R\xAB?\x83\xCE\xFAkO"
++ *   random_string = Random.new.bytes(10) # -> "\xD7:R\xAB?\x83\xCE\xFAkO"
+  *   random_string.size                   # => 10
+  */
+ static VALUE
+@@ -1159,20 +1167,20 @@
+  * is a negative integer or zero, +rand+ raises an ArgumentError.
+  *
+  *   prng = Random.new
+- *   prng.rand(100)       # => 42
++ *   prng.rand(100)       # -> 42
+  *
+  * When +max+ is a Float, +rand+ returns a random floating point number
+  * between 0.0 and +max+, including 0.0 and excluding +max+.
+  *
+- *   prng.rand(1.5)       # => 1.4600282860034115
++ *   prng.rand(1.5)       # -> 1.4600282860034115
+  *
+  * When +max+ is a Range, +rand+ returns a random number where
+  * range.member?(number) == true.
+  *
+- *   prng.rand(5..9)      # => one of [5, 6, 7, 8, 9]
+- *   prng.rand(5...9)     # => one of [5, 6, 7, 8]
+- *   prng.rand(5.0..9.0)  # => between 5.0 and 9.0, including 9.0
+- *   prng.rand(5.0...9.0) # => between 5.0 and 9.0, excluding 9.0
++ *   prng.rand(5..9)      # -> 6 # one of [5, 6, 7, 8, 9]
++ *   prng.rand(5...9)     # -> 8 # one of [5, 6, 7, 8]
++ *   prng.rand(5.0..9.0)  # -> 5.484030000720008 # between 5.0 and 9.0, including 9.0
++ *   prng.rand(5.0...9.0) # -> 7.121666988157002 # between 5.0 and 9.0, excluding 9.0
+  *
+  * Both the beginning and ending values of the range must respond to subtract
+  * (<tt>-</tt>) and add (<tt>+</tt>)methods, or rand will raise an
+@@ -1243,10 +1251,11 @@
+  *   prng2 = Random.new(1234)
+  *   prng1 == prng2 # => true
+  *
+- *   prng1.rand     # => 0.1915194503788923
++ *   rand1 = prng1.rand     # -> 0.1915194503788923
+  *   prng1 == prng2 # => false
+  *
+- *   prng2.rand     # => 0.1915194503788923
++ *   rand2 = prng2.rand     # -> 0.1915194503788923
++ *   rand1 == rand2 # => true
+  *   prng1 == prng2 # => true
+  */
+ static VALUE
+@@ -1271,12 +1280,12 @@
+  * returns a pseudo-random floating point number between 0.0 and 1.0,
+  * including 0.0 and excluding 1.0.
+  *
+- *   rand        #=> 0.2725926052826416
++ *   rand        #-> 0.2725926052826416
+  *
+  * When +max.abs+ is greater than or equal to 1, +rand+ returns a pseudo-random
+  * integer greater than or equal to 0 and less than +max.to_i.abs+.
+  *
+- *   rand(100)   #=> 12
++ *   rand(100)   #-> 12
+  *
+  * When +max+ is a Range, +rand+ returns a random number where
+  * range.member?(number) == true.
+@@ -1284,9 +1293,9 @@
+  * Negative or floating point values for +max+ are allowed, but may give
+  * surprising results.
+  *
+- *   rand(-100) # => 87
+- *   rand(-0.5) # => 0.8130921818028143
+- *   rand(1.9)  # equivalent to rand(1), which is always 0
++ *   rand(-100) # -> 87
++ *   rand(-0.5) # -> 0.8130921818028143
++ *   rand(1.9)  # => 0 # equivalent to rand(1), which is always 0
+  *
+  * Kernel.srand may be used to ensure that sequences of random numbers are
+  * reproducible between different runs of a program.

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

@@ -0,0 +1,49 @@
+--- core/orig/range.c	2015-06-11 07:51:44 +0000
++++ core/patched/range.c	2015-06-20 08:08:42 +0000
+@@ -356,7 +356,7 @@
+  *  range elements.
+  *
+  *  If no block is given, an enumerator is returned instead.
+- *
++ * 
+  *    range = Xs.new(1)..Xs.new(10)
+  *    range.step(2) {|x| puts x}
+  *    puts
+@@ -550,7 +550,7 @@
+  *  satisfies the condition, it returns nil.
+  *
+  *     ary = [0, 100, 100, 100, 200]
+- *     (0..4).bsearch {|i| 100 - ary[i] } #=> 1, 2 or 3
++ *     (0..4).bsearch {|i| 100 - ary[i] } # -> 2 # may be even 1 or 3
+  *     (0..4).bsearch {|i| 300 - ary[i] } #=> nil
+  *     (0..4).bsearch {|i|  50 - ary[i] } #=> nil
+  *
+@@ -729,7 +729,7 @@
+  *     # prints: 10 11 12 13 14 15
+  *
+  *     (2.5..5).each {|n| print n, ' ' }
+- *     # raises: TypeError: can't iterate from Float
++ *     # raises TypeError: can't iterate from Float
+  */
+ 
+ static VALUE
+@@ -1271,6 +1271,8 @@
+  *  to construct ranges. Note that the Comparable module is included
+  *  so the <code>==</code> method is defined in terms of <code><=></code>.
+  *
++ *  :rdx: setup
++ * 
+  *     class Xs                # represent a string of 'x's
+  *       include Comparable
+  *       attr :length
+@@ -1293,8 +1295,8 @@
+  *
+  *  An example of using <code>Xs</code> to construct a range:
+  *
+- *     r = Xs.new(3)..Xs.new(6)   #=> xxx..xxxxxx
+- *     r.to_a                     #=> [xxx, xxxx, xxxxx, xxxxxx]
++ *     r = Xs.new(3)..Xs.new(6)   # > xxx..xxxxxx
++ *     r.to_a                     # > [xxx, xxxx, xxxxx, xxxxxx]
+  *     r.member?(Xs.new(5))       #=> true
+  *
+  */

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

@@ -0,0 +1,312 @@
+--- core/orig/rational.c	2015-06-11 07:51:44 +0000
++++ core/patched/rational.c	2015-06-28 11:41:38 +0000
+@@ -569,8 +569,8 @@
+  *
+  * Returns x/y;
+  *
+- *    Rational(1, 2)   #=> (1/2)
+- *    Rational('1/2')  #=> (1/2)
++ *    Rational(1, 2)   #=> 1/2
++ *    Rational('1/2')  #=> 1/2
+  */
+ static VALUE
+ nurat_f_rational(int argc, VALUE *argv, VALUE klass)
+@@ -606,6 +606,15 @@
+  *    Rational(7, 1).denominator          #=> 1
+  *    Rational(9, -4).denominator         #=> 4
+  *    Rational(-2, -10).denominator       #=> 5
++ * Rationals are automatically reduced when created:
++ *    Rational(6,4) #=> 3/2
++ * therefore for every Rational <i>rat</i>
++ *-- rdx
++ *    num = (-1)**rand(2) * rand(1000)
++ *    den = 1 + rand(1000)
++ *    rat = Rational(num, den)
++ *++
++ * we always end up with:
+  *    rat.numerator.gcd(rat.denominator)  #=> 1
+  */
+ static VALUE
+@@ -706,10 +715,10 @@
+  *
+  * Performs addition.
+  *
+- *    Rational(2, 3)  + Rational(2, 3)   #=> (4/3)
+- *    Rational(900)   + Rational(1)      #=> (900/1)
+- *    Rational(-2, 9) + Rational(-9, 2)  #=> (-85/18)
+- *    Rational(9, 8)  + 4                #=> (41/8)
++ *    Rational(2, 3)  + Rational(2, 3)   #=> 4/3
++ *    Rational(900)   + Rational(1)      #=> 901/1
++ *    Rational(-2, 9) + Rational(-9, 2)  #=> -85/18
++ *    Rational(9, 8)  + 4                #=> 41/8
+  *    Rational(20, 9) + 9.8              #=> 12.022222222222222
+  */
+ static VALUE
+@@ -746,10 +755,10 @@
+  *
+  * Performs subtraction.
+  *
+- *    Rational(2, 3)  - Rational(2, 3)   #=> (0/1)
+- *    Rational(900)   - Rational(1)      #=> (899/1)
+- *    Rational(-2, 9) - Rational(-9, 2)  #=> (77/18)
+- *    Rational(9, 8)  - 4                #=> (23/8)
++ *    Rational(2, 3)  - Rational(2, 3)   #=> 0/1
++ *    Rational(900)   - Rational(1)      #=> 899/1
++ *    Rational(-2, 9) - Rational(-9, 2)  #=> 77/18
++ *    Rational(9, 8)  - 4                #=> -23/8
+  *    Rational(20, 9) - 9.8              #=> -7.577777777777778
+  */
+ static VALUE
+@@ -825,10 +834,10 @@
+  *
+  * Performs multiplication.
+  *
+- *    Rational(2, 3)  * Rational(2, 3)   #=> (4/9)
+- *    Rational(900)   * Rational(1)      #=> (900/1)
+- *    Rational(-2, 9) * Rational(-9, 2)  #=> (1/1)
+- *    Rational(9, 8)  * 4                #=> (9/2)
++ *    Rational(2, 3)  * Rational(2, 3)   #=> 4/9
++ *    Rational(900)   * Rational(1)      #=> 900/1
++ *    Rational(-2, 9) * Rational(-9, 2)  #=> 1/1
++ *    Rational(9, 8)  * 4                #=> 9/2
+  *    Rational(20, 9) * 9.8              #=> 21.77777777777778
+  */
+ static VALUE
+@@ -866,10 +875,10 @@
+  *
+  * Performs division.
+  *
+- *    Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
+- *    Rational(900)   / Rational(1)      #=> (900/1)
+- *    Rational(-2, 9) / Rational(-9, 2)  #=> (4/81)
+- *    Rational(9, 8)  / 4                #=> (9/32)
++ *    Rational(2, 3)  / Rational(2, 3)   #=> 1/1
++ *    Rational(900)   / Rational(1)      #=> 900/1
++ *    Rational(-2, 9) / Rational(-9, 2)  #=> 4/81
++ *    Rational(9, 8)  / 4                #=> 9/32
+  *    Rational(20, 9) / 9.8              #=> 0.22675736961451246
+  */
+ static VALUE
+@@ -952,11 +961,11 @@
+  *
+  * Performs exponentiation.
+  *
+- *    Rational(2)    ** Rational(3)    #=> (8/1)
+- *    Rational(10)   ** -2             #=> (1/100)
++ *    Rational(2)    ** Rational(3)    #=> 8/1
++ *    Rational(10)   ** -2             #=> 1/100
+  *    Rational(10)   ** -2.0           #=> 0.01
+- *    Rational(-4)   ** Rational(1,2)  #=> (1.2246063538223773e-16+2.0i)
+- *    Rational(1, 2) ** 0              #=> (1/1)
++ *    Rational(-4)   ** Rational(1,2)  #=> 1.2246063538223773e-16+2.0i
++ *    Rational(1, 2) ** 0              #=> 1/1
+  *    Rational(1, 2) ** 0.0            #=> 1.0
+  */
+ static VALUE
+@@ -1198,8 +1207,7 @@
+  *
+  * Returns the truncated value as an integer.
+  *
+- * Equivalent to
+- *    rat.truncate.
++ * Equivalent to <code>rat.truncate</code>.
+  *
+  *    Rational(2, 3).to_i   #=> 0
+  *    Rational(3).to_i      #=> 3
+@@ -1281,12 +1289,13 @@
+  *
+  *    Rational(3).floor      #=> 3
+  *    Rational(2, 3).floor   #=> 0
+- *    Rational(-3, 2).floor  #=> -1
+- *
++ *    Rational(-3, 2).floor  #=> -2
++ * 
++ * :rdx: off -
+  *           decimal      -  1  2  3 . 4  5  6
+  *                          ^  ^  ^  ^   ^  ^
+  *          precision      -3 -2 -1  0  +1 +2
+- *
++ * :rdx:
+  *    '%f' % Rational('-123.456').floor(+1)  #=> "-123.500000"
+  *    '%f' % Rational('-123.456').floor(-1)  #=> "-130.000000"
+  */
+@@ -1307,10 +1316,11 @@
+  *    Rational(2, 3).ceil   #=> 1
+  *    Rational(-3, 2).ceil  #=> -1
+  *
++ * :rdx: off -
+  *           decimal      -  1  2  3 . 4  5  6
+  *                          ^  ^  ^  ^   ^  ^
+  *          precision      -3 -2 -1  0  +1 +2
+- *
++ * :rdx:
+  *    '%f' % Rational('-123.456').ceil(+1)  #=> "-123.400000"
+  *    '%f' % Rational('-123.456').ceil(-1)  #=> "-120.000000"
+  */
+@@ -1331,10 +1341,11 @@
+  *    Rational(2, 3).truncate   #=> 0
+  *    Rational(-3, 2).truncate  #=> -1
+  *
++ * :rdx: off -
+  *           decimal      -  1  2  3 . 4  5  6
+  *                          ^  ^  ^  ^   ^  ^
+  *          precision      -3 -2 -1  0  +1 +2
+- *
++ * :rdx:
+  *    '%f' % Rational('-123.456').truncate(+1)  #=>  "-123.400000"
+  *    '%f' % Rational('-123.456').truncate(-1)  #=>  "-120.000000"
+  */
+@@ -1356,10 +1367,11 @@
+  *    Rational(2, 3).round   #=> 1
+  *    Rational(-3, 2).round  #=> -2
+  *
++ * :rdx: off -
+  *           decimal      -  1  2  3 . 4  5  6
+  *                          ^  ^  ^  ^   ^  ^
+  *          precision      -3 -2 -1  0  +1 +2
+- *
++ * :rdx:
+  *    '%f' % Rational('-123.456').round(+1)  #=> "-123.500000"
+  *    '%f' % Rational('-123.456').round(-1)  #=> "-120.000000"
+  */
+@@ -1393,8 +1405,8 @@
+  *
+  * Returns self.
+  *
+- *    Rational(2).to_r      #=> (2/1)
+- *    Rational(-8, 6).to_r  #=> (-4/3)
++ *    Rational(2).to_r      #=> 2/1
++ *    Rational(-8, 6).to_r  #=> -4/3
+  */
+ static VALUE
+ nurat_to_r(VALUE self)
+@@ -1508,9 +1520,9 @@
+  * otherwise.
+  *
+  *    r = Rational(5033165, 16777216)
+- *    r.rationalize                    #=> (5033165/16777216)
+- *    r.rationalize(Rational('0.01'))  #=> (3/10)
+- *    r.rationalize(Rational('0.1'))   #=> (1/3)
++ *    r.rationalize                    #=> 5033165/16777216
++ *    r.rationalize(Rational('0.01'))  #=> 3/10
++ *    r.rationalize(Rational('0.1'))   #=> 1/3
+  */
+ static VALUE
+ nurat_rationalize(int argc, VALUE *argv, VALUE self)
+@@ -1863,8 +1875,8 @@
+  *
+  * Returns the value as a rational.
+  *
+- *    1.to_r        #=> (1/1)
+- *    (1<<64).to_r  #=> (18446744073709551616/1)
++ *    1.to_r        #=> 1/1
++ *    (1<<64).to_r  #=> 18446744073709551616/1
+  */
+ static VALUE
+ integer_to_r(VALUE self)
+@@ -1922,10 +1934,10 @@
+  * NOTE: 0.3.to_r isn't the same as '0.3'.to_r.  The latter is
+  * equivalent to '3/10'.to_r, but the former isn't so.
+  *
+- *    2.0.to_r    #=> (2/1)
+- *    2.5.to_r    #=> (5/2)
+- *    -0.75.to_r  #=> (-3/4)
+- *    0.0.to_r    #=> (0/1)
++ *    2.0.to_r    #=> 2/1
++ *    2.5.to_r    #=> 5/2
++ *    -0.75.to_r  #=> -3/4
++ *    0.0.to_r    #=> 0/1
+  *
+  * See rationalize.
+  */
+@@ -1959,9 +1971,9 @@
+  * <= flt+|eps|).  if the optional eps is not given, it will be chosen
+  * automatically.
+  *
+- *    0.3.rationalize          #=> (3/10)
+- *    1.333.rationalize        #=> (1333/1000)
+- *    1.333.rationalize(0.01)  #=> (4/3)
++ *    0.3.rationalize          #=> 3/10
++ *    1.333.rationalize        #=> 1333/1000
++ *    1.333.rationalize(0.01)  #=> 4/3
+  *
+  * See to_r.
+  */
+@@ -2246,14 +2258,14 @@
+  * NOTE: '0.3'.to_r isn't the same as 0.3.to_r.  The former is
+  * equivalent to '3/10'.to_r, but the latter isn't so.
+  *
+- *    '  2  '.to_r       #=> (2/1)
+- *    '300/2'.to_r       #=> (150/1)
+- *    '-9.2'.to_r        #=> (-46/5)
+- *    '-9.2e2'.to_r      #=> (-920/1)
+- *    '1_234_567'.to_r   #=> (1234567/1)
+- *    '21 june 09'.to_r  #=> (21/1)
+- *    '21/06/09'.to_r    #=> (7/2)
+- *    'bwv 1079'.to_r    #=> (0/1)
++ *    '  2  '.to_r       #=> 2/1
++ *    '300/2'.to_r       #=> 150/1
++ *    '-9.2'.to_r        #=> -46/5
++ *    '-9.2e2'.to_r      #=> -920/1
++ *    '1_234_567'.to_r   #=> 1234567/1
++ *    '21 june 09'.to_r  #=> 21/1
++ *    '21/06/09'.to_r    #=> 7/2
++ *    'bwv 1079'.to_r    #=> 0/1
+  */
+ static VALUE
+ string_to_r(VALUE self)
+@@ -2376,37 +2388,39 @@
+  * In ruby, you can create rational object with Rational, to_r or
+  * rationalize method.  The return values will be irreducible.
+  *
+- *    Rational(1)      #=> (1/1)
+- *    Rational(2, 3)   #=> (2/3)
+- *    Rational(4, -6)  #=> (-2/3)
+- *    3.to_r           #=> (3/1)
++ *    Rational(1)      #=> 1/1
++ *    Rational(2, 3)   #=> 2/3
++ *    Rational(4, -6)  #=> -2/3
++ *    3.to_r           #=> 3/1
+  *
+  * You can also create rational object from floating-point numbers or
+  * strings.
+  *
+- *    Rational(0.3)    #=> (5404319552844595/18014398509481984)
+- *    Rational('0.3')  #=> (3/10)
+- *    Rational('2/3')  #=> (2/3)
+- *
+- *    0.3.to_r         #=> (5404319552844595/18014398509481984)
+- *    '0.3'.to_r       #=> (3/10)
+- *    '2/3'.to_r       #=> (2/3)
+- *    0.3.rationalize  #=> (3/10)
++ *    Rational(0.3)    #=> 5404319552844595/18014398509481984
++ *    Rational('0.3')  #=> 3/10
++ *    Rational('2/3')  #=> 2/3
++ *
++ *    0.3.to_r         #=> 5404319552844595/18014398509481984
++ *    '0.3'.to_r       #=> 3/10
++ *    '2/3'.to_r       #=> 2/3
++ *    0.3.rationalize  #=> 3/10
+  *
+  * A rational object is an exact number, which helps you to write
+  * program without any rounding errors.
+  *
+  *    10.times.inject(0){|t,| t + 0.1}              #=> 0.9999999999999999
+- *    10.times.inject(0){|t,| t + Rational('0.1')}  #=> (1/1)
++ *    10.times.inject(0){|t,| t + Rational('0.1')}  #=> 1/1
+  *
+  * However, when an expression has inexact factor (numerical value or
+  * operation), will produce an inexact result.
+  *
+- *    Rational(10) / 3   #=> (10/3)
++ *    Rational(10) / 3   #=> 10/3
++ * :rdx: bug   the result is again 10/3
+  *    Rational(10) / 3.0 #=> 3.3333333333333335
++ * :rdx:
+  *
+  *    Rational(-8) ** Rational(1, 3)
+- *                       #=> (1.0000000000000002+1.7320508075688772i)
++ *                       #=> 1.0000000000000002+1.7320508075688772i
+  */
+ void
+ Init_Rational(void)