rdx 0.9.0.pre

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

@@ -0,0 +1,207 @@
+--- core/orig/re.c	2015-06-11 07:51:44 +0000
++++ core/patched/re.c	2015-06-20 08:15:30 +0000
+@@ -1006,7 +1006,7 @@
+  *     /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").names
+  *     #=> ["foo", "bar", "baz"]
+  *
+- *     m = /(?<x>.)(?<y>.)?/.match("a") #=> #<MatchData "a" x:"a" y:nil>
++ *     m = /(?<x>.)(?<y>.)?/.match("a") # > #<MatchData "a" x:"a" y:nil>
+  *     m.names                          #=> ["x", "y"]
+  */
+ 
+@@ -1090,8 +1090,8 @@
+  *     m.offset(4)      #=> [6, 7]
+  *
+  *     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
+- *     p m.offset(:foo) #=> [0, 1]
+- *     p m.offset(:bar) #=> [2, 3]
++ *     m.offset(:foo) #=> [0, 1]
++ *     m.offset(:bar) #=> [2, 3]
+  *
+  */
+ 
+@@ -1127,8 +1127,8 @@
+  *     m.begin(2)       #=> 2
+  *
+  *     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
+- *     p m.begin(:foo)  #=> 0
+- *     p m.begin(:bar)  #=> 2
++ *     m.begin(:foo)  #=> 0
++ *     m.begin(:bar)  #=> 2
+  */
+ 
+ static VALUE
+@@ -1162,8 +1162,8 @@
+  *     m.end(2)         #=> 3
+  *
+  *     m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
+- *     p m.end(:foo)    #=> 1
+- *     p m.end(:bar)    #=> 3
++ *     m.end(:foo)    #=> 1
++ *     m.end(:bar)    #=> 3
+  */
+ 
+ static VALUE
+@@ -1207,16 +1207,16 @@
+  *
+  *      r = /a/u
+  *      r.fixed_encoding?                               #=> true
+- *      r.encoding                                      #=> #<Encoding:UTF-8>
++ *      r.encoding                                      #=> Encoding::UTF_8
+  *      r =~ "\u{6666} a"                               #=> 2
+- *      r =~ "\xa1\xa2".force_encoding("euc-jp")        #=> ArgumentError
++ *      r =~ "\xa1\xa2".force_encoding("euc-jp")        # raises Encoding::CompatibilityError
+  *      r =~ "abc".force_encoding("euc-jp")             #=> 0
+  *
+  *      r = /\u{6666}/
+  *      r.fixed_encoding?                               #=> true
+- *      r.encoding                                      #=> #<Encoding:UTF-8>
++ *      r.encoding                                      #=> Encoding::UTF_8
+  *      r =~ "\u{6666} a"                               #=> 0
+- *      r =~ "\xa1\xa2".force_encoding("euc-jp")        #=> ArgumentError
++ *      r =~ "\xa1\xa2".force_encoding("euc-jp")        # raises Encoding::CompatibilityError
+  *      r =~ "abc".force_encoding("euc-jp")             #=> nil
+  */
+ 
+@@ -1696,14 +1696,14 @@
+  *  pattern between parentheses).
+  *
+  *     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
+- *     m          #=> #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
++ *     m          # > #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
+  *     m[0]       #=> "HX1138"
+  *     m[1, 2]    #=> ["H", "X"]
+  *     m[1..3]    #=> ["H", "X", "113"]
+  *     m[-3, 2]   #=> ["X", "113"]
+  *
+  *     m = /(?<foo>a+)b/.match("ccaaab")
+- *     m          #=> #<MatchData "aaab" foo:"aaa">
++ *     m          # > #<MatchData "aaab" foo:"aaa">
+  *     m["foo"]   #=> "aaa"
+  *     m[:foo]    #=> "aaa"
+  */
+@@ -1846,17 +1846,17 @@
+  *
+  * Returns a printable version of <i>mtch</i>.
+  *
+- *     puts /.$/.match("foo").inspect
+- *     #=> #<MatchData "o">
++ *     /.$/.match("foo").inspect
++ *     #=> '#<MatchData "o">'
+  *
+- *     puts /(.)(.)(.)/.match("foo").inspect
+- *     #=> #<MatchData "foo" 1:"f" 2:"o" 3:"o">
++ *     /(.)(.)(.)/.match("foo").inspect
++ *     #=> '#<MatchData "foo" 1:"f" 2:"o" 3:"o">'
+  *
+- *     puts /(.)(.)?(.)/.match("fo").inspect
+- *     #=> #<MatchData "fo" 1:"f" 2:nil 3:"o">
++ *     /(.)(.)?(.)/.match("fo").inspect
++ *     #=> '#<MatchData "fo" 1:"f" 2:nil 3:"o">'
+  *
+- *     puts /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").inspect
+- *     #=> #<MatchData "hog" foo:"h" bar:"o" baz:"g">
++ *     /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").inspect
++ *     #=> '#<MatchData "hog" foo:"h" bar:"o" baz:"g">'
+  *
+  */
+ 
+@@ -2708,37 +2708,39 @@
+  *  the capture names.
+  *
+  *     /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ "  x = y  "
+- *     p lhs    #=> "x"
+- *     p rhs    #=> "y"
++ *     lhs    #=> "x"
++ *     rhs    #=> "y"
+  *
+  *  If it is not matched, nil is assigned for the variables.
+  *
+  *     /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ "  x = "
+- *     p lhs    #=> nil
+- *     p rhs    #=> nil
++ *     lhs    #=> nil
++ *     rhs    #=> nil
+  *
+  *  This assignment is implemented in the Ruby parser.
+  *  The parser detects 'regexp-literal =~ expression' for the assignment.
+  *  The regexp must be a literal without interpolation and placed at left hand side.
+  *
++ *  :rdx: new_binding
+  *  The assignment does not occur if the regexp is not a literal.
+  *
+  *     re = /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/
+  *     re =~ "  x = y  "
+- *     p lhs    # undefined local variable
+- *     p rhs    # undefined local variable
++ *     lhs    # raises NameError: undefined local variable
++ *     rhs    # raises NameError: undefined local variable
+  *
+  *  A regexp interpolation, <code>#{}</code>, also disables
+  *  the assignment.
+  *
+  *     rhs_pat = /(?<rhs>\w+)/
+  *     /(?<lhs>\w+)\s*=\s*#{rhs_pat}/ =~ "x = y"
+- *     p lhs    # undefined local variable
++ *     lhs    # raises NameError: undefined local variable
+  *
+  *  The assignment does not occur if the regexp is placed at the right hand side.
+  *
+  *    "  x = y  " =~ /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/
+- *    p lhs, rhs # undefined local variable
++ *    lhs     # raises NameError: undefined local variable
++ *    rhs     # raises NameError: undefined local variable
+  *
+  */
+ 
+@@ -2763,13 +2765,13 @@
+  *     when /^[A-Z]*$/; print "Upper case\n"
+  *     else;            print "Mixed case\n"
+  *     end
+- *     #=> "Upper case"
++ *     # prints Upper case
+  *
+  *  Following a regular expression literal with the #=== operator allows you to
+  *  compare against a String.
+  *
+- *	/^[a-z]*$/ === "HELLO" #=> false
+- *	/^[A-Z]*$/ === "HELLO" #=> true
++ *     /^[a-z]*$/ === "HELLO" #=> false
++ *     /^[A-Z]*$/ === "HELLO" #=> true
+  */
+ 
+ VALUE
+@@ -2838,6 +2840,8 @@
+  *  If a block is given, invoke the block with MatchData if match succeed, so
+  *  that you can write
+  *
++ *  :rdx: off
++ *
+  *     pat.match(str) {|m| ...}
+  *
+  *  instead of
+@@ -3069,7 +3073,7 @@
+  *  escaped.  For any string,
+  *  <code>Regexp.new(Regexp.escape(<i>str</i>))=~<i>str</i></code> will be true.
+  *
+- *     Regexp.escape('\*?{}.')   #=> \\\*\?\{\}\.
++ *     puts Regexp.escape('\*?{}.')   # prints: \\\*\?\{\}\.
+  *
+  */
+ 
+@@ -3463,13 +3467,13 @@
+  *  method that did the pattern match.
+  *
+  *     /c(.)t/ =~ 'cat'        #=> 0
+- *     Regexp.last_match       #=> #<MatchData "cat" 1:"a">
++ *     Regexp.last_match       # > #<MatchData "cat" 1:"a">
+  *     Regexp.last_match(0)    #=> "cat"
+  *     Regexp.last_match(1)    #=> "a"
+  *     Regexp.last_match(2)    #=> nil
+  *
+  *     /(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ "var = val"
+- *     Regexp.last_match       #=> #<MatchData "var = val" lhs:"var" rhs:"val">
++ *     Regexp.last_match       # > #<MatchData "var = val" lhs:"var" rhs:"val">
+  *     Regexp.last_match(:lhs) #=> "var"
+  *     Regexp.last_match(:rhs) #=> "val"
+  */

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

@@ -0,0 +1,21 @@
+--- core/orig/ruby.c	2015-06-11 07:51:44 +0000
++++ core/patched/ruby.c	2015-06-20 08:17:17 +0000
+@@ -1713,12 +1713,12 @@
+ 	/*
+ 	 * DATA is a File that contains the data section of the executed file.
+ 	 * To create a data section use <tt>__END__</tt>:
+-	 *
+-	 *   $ cat t.rb
+-	 *   puts DATA.gets
+-	 *   __END__
+-	 *   hello world!
+-	 *
++	 * 
++	 *   $ cat > t.rb <<EOS
++	 *   > puts DATA.gets
++	 *   > __END__
++	 *   > hello world!
++	 *   > EOS
+ 	 *   $ ruby t.rb
+ 	 *   hello world!
+ 	 */

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

@@ -0,0 +1,67 @@
+--- core/orig/signal.c	2015-06-11 07:51:44 +0000
++++ core/patched/signal.c	2015-06-20 08:21:43 +0000
+@@ -219,11 +219,14 @@
+  *
+  *  convert signal number to signal name
+  *
++ *     # File: prog.rb
+  *     Signal.trap("INT") { |signo| puts Signal.signame(signo) }
+- *     Process.kill("INT", 0)
++ *     Process.kill("INT", Process.pid)
+  *
+- *  <em>produces:</em>
++ *  Then from command line:
++ *  :rdx: if Signal.list["INT"]
+  *
++ *     $ ruby prog.rb
+  *     INT
+  */
+ static VALUE
+@@ -957,6 +960,8 @@
+  * invoked just prior to program termination.
+  * trap returns the previous handler for the given signal.
+  *
++ * :rdx: if Process.respond_to?(:fork) && Signal.list["CLD"]
++ * 
+  *     Signal.trap(0, proc { puts "Terminating: #{$$}" })
+  *     Signal.trap("CLD")  { puts "Child died" }
+  *     fork && Process.wait
+@@ -1008,7 +1013,16 @@
+  * Returns a list of signal names mapped to the corresponding
+  * underlying signal numbers.
+  *
+- *   Signal.list   #=> {"EXIT"=>0, "HUP"=>1, "INT"=>2, "QUIT"=>3, "ILL"=>4, "TRAP"=>5, "IOT"=>6, "ABRT"=>6, "FPE"=>8, "KILL"=>9, "BUS"=>7, "SEGV"=>11, "SYS"=>31, "PIPE"=>13, "ALRM"=>14, "TERM"=>15, "URG"=>23, "STOP"=>19, "TSTP"=>20, "CONT"=>18, "CHLD"=>17, "CLD"=>17, "TTIN"=>21, "TTOU"=>22, "IO"=>29, "XCPU"=>24, "XFSZ"=>25, "VTALRM"=>26, "PROF"=>27, "WINCH"=>28, "USR1"=>10, "USR2"=>12, "PWR"=>30, "POLL"=>29}
++ *   Signal.list
++ *   # -> {
++ *   #   "EXIT" =>  0,  "HUP"  =>  1,   "INT"  =>  2,   "QUIT" =>  3,   "ILL"  =>  4,
++ *   #   "TRAP" =>  5,  "IOT"  =>  6,   "ABRT" =>  6,   "BUS"  =>  7,   "FPE"  =>  8,
++ *   #   "KILL" =>  9,  "USR1" => 10,   "SEGV" => 11,   "USR2" => 12,   "PIPE" => 13,
++ *   #   "ALRM" => 14,  "TERM" => 15,   "CHLD" => 17,   "CLD"  => 17,   "CONT" => 18,
++ *   #   "STOP" => 19,  "TSTP" => 20,   "TTIN" => 21,   "TTOU" => 22,   "URG"  => 23,
++ *   #   "XCPU" => 24,  "XFSZ" => 25,   "VTALRM"=>26,   "PROF" => 27,   "WINCH"=> 28,
++ *   #   "IO"   => 29,  "POLL" => 29,   "PWR"  => 30,   "SYS"  => 31
++ *   # }
+  */
+ static VALUE
+ sig_list(void)
+@@ -1078,6 +1092,11 @@
+  * example, your process may trap the USR1 signal and use it to toggle
+  * debugging, and may use TERM to initiate a controlled shutdown.
+  *
++ * :rdx: if Process.respond_to?(:fork) && Signal.list['USR1'] && Signal.list['TERM']
++ * 
++ *-- rdx
++ *     def shutdown; end
++ *++
+  *     pid = fork do
+  *       Signal.trap("USR1") do
+  *         $debug = !$debug
+@@ -1102,7 +1121,7 @@
+  * produces:
+  *     Debug now: true
+  *     Debug now: false
+- *    Terminating...
++ *     Terminating...
+  *
+  * The list of available signal names and their interpretation is
+  * system dependent. Signal delivery semantics may also vary between

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

@@ -0,0 +1,29 @@
+--- core/orig/sprintf.c	2015-06-11 07:51:44 +0000
++++ core/patched/sprintf.c	2015-06-20 08:22:18 +0000
+@@ -178,7 +178,8 @@
+  *  other than format sequences are copied to the result.
+  *
+  *  The syntax of a format sequence is follows.
+- *
++ * 
++ *  :rdx: off
+  *    %[flags][width][.precision]type
+  *
+  *  A format
+@@ -287,6 +288,7 @@
+  *             |               | sign, use the indicated argument as the width.
+  *
+  *  Examples of flags:
++ *  :rdx: on
+  *
+  *   # `+' and space flag specifies the sign of non-negative numbers.
+  *   sprintf("%d", 123)  #=> "123"
+@@ -424,7 +426,7 @@
+  *
+  *  Exapmles:
+  *    sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
+- *      #=> 1 : 2.000000
++ *      #=> "1 : 2.000000"
+  *    sprintf("%{foo}f", { :foo => 1 })
+  *      # => "1f"
+  */

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

@@ -0,0 +1,73 @@
+--- core/orig/string.c	2015-06-11 07:51:43 +0000
++++ core/patched/string.c	2015-06-20 08:27:22 +0000
+@@ -1289,7 +1289,7 @@
+  *  details of the format string.
+  *
+  *     "%05d" % 123                              #=> "00123"
+- *     "%-5s: %08x" % [ "ID", self.object_id ]   #=> "ID   : 200e14d6"
++ *     "%-5s: %08x" % [ "ID", 0x2b45 ]           #=> "ID   : 00002b45"
+  *     "foo = %{foo}" % { :foo => 'bar' }        #=> "foo = bar"
+  */
+ 
+@@ -2752,13 +2752,14 @@
+  *  parameter is present, it specifies the position in the string to begin the
+  *  search.
+  *
+- *     'hello'.match('(.)\1')      #=> #<MatchData "ll" 1:"l">
++ *     'hello'.match('(.)\1')      # > #<MatchData "ll" 1:"l">
+  *     'hello'.match('(.)\1')[0]   #=> "ll"
+  *     'hello'.match(/(.)\1/)[0]   #=> "ll"
+  *     'hello'.match('xx')         #=> nil
+  *
+  *  If a block is given, invoke the block with MatchData if match succeed, so
+  *  that you can write
++ *  :rdx: off
+  *
+  *     str.match(pat) {|m| ...}
+  *
+@@ -3057,6 +3058,7 @@
+  *  If no block is given, an enumerator is returned instead.
+  *
+  *     "a8".upto("b6") {|s| print s, ' ' }
++ *     puts
+  *     for s in "a8".."b6"
+  *       print s, ' '
+  *     end
+@@ -3791,7 +3793,8 @@
+  *     "hello".sub(/([aeiou])/, '<\1>')             #=> "h<e>llo"
+  *     "hello".sub(/./) {|s| s.ord.to_s + ' ' }     #=> "104 ello"
+  *     "hello".sub(/(?<foo>[aeiou])/, '*\k<foo>*')  #=> "h*e*llo"
+- *     'Is SHELL your preferred shell?'.sub(/[[:upper:]]{2,}/, ENV)
++ *     env = { 'SHELL' => '/bin/bash' }
++ *     'Is SHELL your preferred shell?'.sub(/[[:upper:]]{2,}/, env)
+  *      #=> "Is /bin/bash your preferred shell?"
+  */
+ 
+@@ -4576,7 +4579,7 @@
+  *  Produces a version of +str+ with all non-printing characters replaced by
+  *  <code>\nnn</code> notation and all special characters escaped.
+  *
+- *    "hello \n ''".dump  #=> "\"hello \\n ''\"
++ *    "hello \n ''".dump  #=> "\"hello \\n ''\""
+  */
+ 
+ VALUE
+@@ -7722,10 +7725,14 @@
+  *     def Fred()
+  *     end
+  *     $f3 = :Fred
+- *     $f1.object_id   #=> 2514190
+- *     $f2.object_id   #=> 2514190
+- *     $f3.object_id   #=> 2514190
+- *
++ *     id_1 = $f1.object_id   #-> 2514190
++ *     id_2 = $f2.object_id   #-> 2514190
++ *     id_3 = $f3.object_id   #-> 2514190
++ *     (id_1 == id_2) && (id_2 == id_3) #=> true
++ *-- rdx
++ *     $f1 = $f2 = $f3 = nil
++ *++
++ * 
+  */
+ 
+ 

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

@@ -0,0 +1,20 @@
+--- core/orig/struct.c	2015-06-11 07:51:44 +0000
++++ core/patched/struct.c	2015-06-11 07:51:47 +0000
+@@ -319,11 +319,15 @@
+  *
+  *     # Create a structure with a name in Struct
+  *     Struct.new("Customer", :name, :address)    #=> Struct::Customer
+- *     Struct::Customer.new("Dave", "123 Main")   #=> #<struct Struct::Customer name="Dave", address="123 Main">
++ *     Struct::Customer.new("Dave", "123 Main")   # > #<struct Struct::Customer name="Dave", address="123 Main">
+  *
++ *  :rdx: toplevel
+  *     # Create a structure named by its constant
+  *     Customer = Struct.new(:name, :address)     #=> Customer
+- *     Customer.new("Dave", "123 Main")           #=> #<struct Customer name="Dave", address="123 Main">
++ *     Customer.new("Dave", "123 Main")           # > #<struct Customer name="Dave", address="123 Main">
++ *-- rdx
++ *     Object.send :remove_const, :Customer
++ *++
+  */
+ 
+ static VALUE

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

@@ -0,0 +1,691 @@
+--- core/orig/time.c	2015-06-11 07:51:44 +0000
++++ core/patched/time.c	2015-06-25 17:35:23 +0000
+@@ -2241,13 +2241,13 @@
+  *  +utc_offset+ is the offset from UTC.
+  *  It can be a string such as "+09:00" or a number of seconds such as 32400.
+  *
+- *     a = Time.new      #=> 2007-11-19 07:50:02 -0600
+- *     b = Time.new      #=> 2007-11-19 07:50:02 -0600
+- *     a == b            #=> false
+- *     "%.6f" % a.to_f   #=> "1195480202.282373"
+- *     "%.6f" % b.to_f   #=> "1195480202.283415"
++ *     a = Time.new      # 2007-11-19 07:50:02 -0600
++ *     b = Time.new      # 2007-11-19 07:50:02 -0600
++ *     a == b            #-> false
++ *     "%.6f" % a.to_f   #-> "1195480202.282373"
++ *     "%.6f" % b.to_f   #-> "1195480202.283415"
+  *
+- *     Time.new(2008,6,21, 13,30,0, "+09:00") #=> 2008-06-21 13:30:00 +0900
++ *     Time.new(2008,6,21, 13,30,0, "+09:00") # > 2008-06-21 13:30:00 +0900
+  *
+  *     # A trip for RubyConf 2007
+  *     t1 = Time.new(2007,11,1,15,25,0, "+09:00") # JST (Narita)
+@@ -2258,10 +2258,10 @@
+  *     t6 = Time.new(2007,11,5,11,21,0, "-05:00") # EST (Detroit)
+  *     t7 = Time.new(2007,11,5,13,45,0, "-05:00") # EST (Detroit)
+  *     t8 = Time.new(2007,11,6,17,10,0, "+09:00") # JST (Narita)
+- *     p((t2-t1)/3600.0)                          #=> 10.666666666666666
+- *     p((t4-t3)/3600.0)                          #=> 2.466666666666667
+- *     p((t6-t5)/3600.0)                          #=> 1.95
+- *     p((t8-t7)/3600.0)                          #=> 13.416666666666666
++ *     (t2-t1)/3600.0                             #=> 10.666666666666666
++ *     (t4-t3)/3600.0                             #=> 2.466666666666667
++ *     (t6-t5)/3600.0                             #=> 1.95
++ *     (t8-t7)/3600.0                             #=> 13.416666666666666
+  *
+  */
+ 
+@@ -2497,7 +2497,7 @@
+  *
+  *  Creates a new Time object for the current time.
+  *
+- *     Time.now            #=> 2009-06-24 12:39:54 +0900
++ *     Time.now            # 2009-06-24 12:39:54 +0900
+  */
+ 
+ static VALUE
+@@ -2521,10 +2521,11 @@
+  *
+  *  If a numeric argument is given, the result is in local time.
+  *
+- *     Time.at(0)                           #=> 1969-12-31 18:00:00 -0600
+- *     Time.at(Time.at(0))                  #=> 1969-12-31 18:00:00 -0600
+- *     Time.at(946702800)                   #=> 1999-12-31 23:00:00 -0600
+- *     Time.at(-284061600)                  #=> 1960-12-31 00:00:00 -0600
++ *     Time.at(0)                           # => Time.utc(1970).getlocal
++ *                                          # something like: 1969-12-31 18:00:00 -0600
++ *     Time.at(Time.at(0))                  # 1969-12-31 18:00:00 -0600
++ *     Time.at(946702800)                   # 1999-12-31 23:00:00 -0600
++ *     Time.at(-284061600)                  # 1960-12-31 00:00:00 -0600
+  *     Time.at(946684800.2).usec            #=> 200000
+  *     Time.at(946684800, 123456.789).nsec  #=> 123456789
+  */
+@@ -3135,8 +3136,8 @@
+  *
+  *  +sec_with_frac+ and +usec_with_frac+ can have a fractional part.
+  *
+- *     Time.utc(2000,"jan",1,20,15,1)  #=> 2000-01-01 20:15:01 UTC
+- *     Time.gm(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
++ *     Time.utc(2000,"jan",1,20,15,1)  # > 2000-01-01 20:15:01 UTC
++ *     Time.gm(2000,"jan",1,20,15,1)   # > 2000-01-01 20:15:01 UTC
+  */
+ static VALUE
+ time_s_mkutc(int argc, VALUE *argv, VALUE klass)
+@@ -3166,7 +3167,7 @@
+  *  Same as Time::gm, but interprets the values in the
+  *  local time zone.
+  *
+- *     Time.local(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
++ *     Time.local(2000,"jan",1,20,15,1)   # 2000-01-01 20:15:01 -0600
+  */
+ 
+ static VALUE
+@@ -3184,8 +3185,8 @@
+  *  since the Epoch.
+  *
+  *     t = Time.now
+- *     "%10.5f" % t.to_f   #=> "1270968656.89607"
+- *     t.to_i              #=> 1270968656
++ *     "%10.5f" % t.to_f   #-> "1270968656.89607"
++ *     t.to_i              #-> 1270968656
+  */
+ 
+ static VALUE
+@@ -3205,8 +3206,8 @@
+  *  seconds since the Epoch.
+  *
+  *     t = Time.now
+- *     "%10.5f" % t.to_f   #=> "1270968744.77658"
+- *     t.to_i              #=> 1270968744
++ *     "%10.5f" % t.to_f   #-> "1270968744.77658"
++ *     t.to_i              #-> 1270968744
+  *
+  *  Note that IEEE 754 double is not accurate enough to represent
+  *  the number of nanoseconds since the Epoch.
+@@ -3228,8 +3229,8 @@
+  *  Returns the value of _time_ as a rational number of seconds
+  *  since the Epoch.
+  *
+- *     t = Time.now
+- *     p t.to_r            #=> (1270968792716287611/1000000000)
++ *     t = Time.at(15)
++ *     t.to_r            #=> 15/1
+  *
+  *  This methods is intended to be used to get an accurate value
+  *  representing the nanoseconds since the Epoch. You can use this method
+@@ -3257,9 +3258,9 @@
+  *
+  *  Returns the number of microseconds for _time_.
+  *
+- *     t = Time.now        #=> 2007-11-19 08:03:26 -0600
+- *     "%10.6f" % t.to_f   #=> "1195481006.775195"
+- *     t.usec              #=> 775195
++ *     t = Time.now
++ *     "%10.6f" % t.to_f   #-> "1195481006.775195"
++ *     t.usec              #-> 775195
+  */
+ 
+ static VALUE
+@@ -3282,9 +3283,9 @@
+  *
+  *  Returns the number of nanoseconds for _time_.
+  *
+- *     t = Time.now        #=> 2007-11-17 15:18:03 +0900
+- *     "%10.9f" % t.to_f   #=> "1195280283.536151409"
+- *     t.nsec              #=> 536151406
++ *     t = Time.now
++ *     "%10.9f" % t.to_f   #-> "1195280283.536151409"
++ *     t.nsec              #-> 536151406
+  *
+  *  The lowest digits of #to_f and #nsec are different because
+  *  IEEE 754 double is not accurate enough to represent
+@@ -3310,9 +3311,9 @@
+  *
+  *  The return value can be a rational number.
+  *
+- *     t = Time.now        #=> 2009-03-26 22:33:12 +0900
+- *     "%10.9f" % t.to_f   #=> "1238074392.940563917"
+- *     t.subsec            #=> (94056401/100000000)
++ *     t = Time.now
++ *     "%10.9f" % t.to_f   #-> "1238074392.940563917"
++ *     t.subsec            # 94056401/100000000
+  *
+  *  The lowest digits of #to_f and #subsec are different because
+  *  IEEE 754 double is not accurate enough to represent
+@@ -3339,15 +3340,15 @@
+  *  +other_time+, +0+ if _time_ is equal to +other_time+ and
+  *  +-1+ if _time_ is smaller than +other_time+.
+  *
+- *     t = Time.now       #=> 2007-11-19 08:12:12 -0600
+- *     t2 = t + 2592000   #=> 2007-12-19 08:12:12 -0600
++ *     t = Time.now
++ *     t2 = t + 2592000
+  *     t <=> t2           #=> -1
+- *     t2 <=> t           #=> 1
++ *     t2 <=> t           #=> +1
+  *
+- *     t = Time.now       #=> 2007-11-19 08:13:38 -0600
+- *     t2 = t + 0.1       #=> 2007-11-19 08:13:38 -0600
+- *     t.nsec             #=> 98222999
+- *     t2.nsec            #=> 198222999
++ *     t = Time.now       # 2007-11-19 08:13:38 -0600
++ *     t2 = t + 0.1       # 2007-11-19 08:13:38 -0600
++ *     t.nsec             #->  98222999
++ *     t2.nsec            #-> 198222999
+  *     t <=> t2           #=> -1
+  *     t2 <=> t           #=> 1
+  *     t <=> t            #=> 0
+@@ -3400,14 +3401,14 @@
+  *
+  *  Returns +true+ if _time_ represents a time in UTC (GMT).
+  *
+- *     t = Time.now                        #=> 2007-11-19 08:15:23 -0600
++ *     t = Time.now                        #   2007-11-19 08:15:23 -0600
+  *     t.utc?                              #=> false
+- *     t = Time.gm(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
++ *     t = Time.gm(2000,"jan",1,20,15,1)   # > 2000-01-01 20:15:01 UTC
+  *     t.utc?                              #=> true
+- *
+- *     t = Time.now                        #=> 2007-11-19 08:16:03 -0600
++ * 
++ *     t = Time.now                        #   2007-11-19 08:16:03 -0600
+  *     t.gmt?                              #=> false
+- *     t = Time.gm(2000,1,1,20,15,1)       #=> 2000-01-01 20:15:01 UTC
++ *     t = Time.gm(2000,1,1,20,15,1)       # > 2000-01-01 20:15:01 UTC
+  *     t.gmt?                              #=> true
+  */
+ 
+@@ -3493,14 +3494,14 @@
+  *
+  *  If +utc_offset+ is given, it is used instead of the local time.
+  *
+- *     t = Time.utc(2000, "jan", 1, 20, 15, 1) #=> 2000-01-01 20:15:01 UTC
+- *     t.utc?                                  #=> true
++ *     t = Time.utc(2000, "jan", 1, 20, 15, 1)   # > 2000-01-01 20:15:01 UTC
++ *     t.utc?                                    #=> true
+  *
+- *     t.localtime                             #=> 2000-01-01 14:15:01 -0600
+- *     t.utc?                                  #=> false
++ *     t.localtime                               #   2000-01-01 14:15:01 -0600
++ *     t.utc?                                    #=> false
+  *
+- *     t.localtime("+09:00")                   #=> 2000-01-02 05:15:01 +0900
+- *     t.utc?                                  #=> false
++ *     t.localtime("+09:00")                     # > 2000-01-02 05:15:01 +0900
++ *     t.utc?                                    #=> false
+  */
+ 
+ static VALUE
+@@ -3527,14 +3528,14 @@
+  *
+  *  Converts _time_ to UTC (GMT), modifying the receiver.
+  *
+- *     t = Time.now   #=> 2007-11-19 08:18:31 -0600
++ *     t = Time.now   # 2007-11-19 08:18:31 -0600
+  *     t.gmt?         #=> false
+- *     t.gmtime       #=> 2007-11-19 14:18:31 UTC
++ *     t.gmtime       # 2007-11-19 14:18:31 UTC
+  *     t.gmt?         #=> true
+  *
+- *     t = Time.now   #=> 2007-11-19 08:18:51 -0600
++ *     t = Time.now   # 2007-11-19 08:18:51 -0600
+  *     t.utc?         #=> false
+- *     t.utc          #=> 2007-11-19 14:18:51 UTC
++ *     t.utc          # 2007-11-19 14:18:51 UTC
+  *     t.utc?         #=> true
+  */
+ 
+@@ -3604,14 +3605,14 @@
+  *
+  *  If +utc_offset+ is given, it is used instead of the local time.
+  *
+- *     t = Time.utc(2000,1,1,20,15,1)  #=> 2000-01-01 20:15:01 UTC
++ *     t = Time.utc(2000,1,1,20,15,1)  # > 2000-01-01 20:15:01 UTC
+  *     t.utc?                          #=> true
+  *
+- *     l = t.getlocal                  #=> 2000-01-01 14:15:01 -0600
++ *     l = t.getlocal                  #   2000-01-01 14:15:01 -0600
+  *     l.utc?                          #=> false
+  *     t == l                          #=> true
+  *
+- *     j = t.getlocal("+09:00")        #=> 2000-01-02 05:15:01 +0900
++ *     j = t.getlocal("+09:00")        # > 2000-01-02 05:15:01 +0900
+  *     j.utc?                          #=> false
+  *     t == j                          #=> true
+  */
+@@ -3641,9 +3642,9 @@
+  *
+  *  Returns a new Time object representing _time_ in UTC.
+  *
+- *     t = Time.local(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
++ *     t = Time.local(2000,1,1,20,15,1)   # 2000-01-01 20:15:01 -0600
+  *     t.gmt?                             #=> false
+- *     y = t.getgm                        #=> 2000-01-02 02:15:01 UTC
++ *     y = t.getgm                        # 2000-01-02 02:15:01 UTC
+  *     y.gmt?                             #=> true
+  *     t == y                             #=> true
+  */
+@@ -3671,7 +3672,7 @@
+  *
+  *  Returns a canonical string representation of _time_.
+  *
+- *     Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"
++ *     Time.now.asctime   #-> "Wed Apr  9 08:56:03 2003"
+  */
+ 
+ static VALUE
+@@ -3689,11 +3690,11 @@
+  *  #strftime with the appropriate format string.
+  *
+  *     t = Time.now
+- *     t.to_s                              => "2012-11-10 18:16:12 +0100"
+- *     t.strftime "%Y-%m-%d %H:%M:%S %z"   => "2012-11-10 18:16:12 +0100"
++ *     t.to_s                              #-> "2012-11-10 18:16:12 +0100"
++ *     t.strftime "%Y-%m-%d %H:%M:%S %z"   #-> "2012-11-10 18:16:12 +0100"
+  *
+- *     t.utc.to_s                          => "2012-11-10 17:16:12 UTC"
+- *     t.strftime "%Y-%m-%d %H:%M:%S UTC"  => "2012-11-10 17:16:12 UTC"
++ *     t.utc.to_s                          #-> "2012-11-10 17:16:12 UTC"
++ *     t.strftime "%Y-%m-%d %H:%M:%S UTC"  #-> "2012-11-10 17:16:12 UTC"
+  */
+ 
+ static VALUE
+@@ -3736,8 +3737,9 @@
+  *  Addition --- Adds some number of seconds (possibly fractional) to
+  *  _time_ and returns that value as a new Time object.
+  *
+- *     t = Time.now         #=> 2007-11-19 08:22:21 -0600
+- *     t + (60 * 60 * 24)   #=> 2007-11-20 08:22:21 -0600
++ *     t = Time.now              # 2007-11-19 08:22:21 -0600
++ *     t2 = t + (60 * 60 * 24)   # 2007-11-20 08:22:21 -0600
++ *     t2 - t                    #=> 60 * 60 * 24
+  */
+ 
+ static VALUE
+@@ -3761,10 +3763,10 @@
+  *  between _time_ and +other_time+, or subtracts the given number
+  *  of seconds in +numeric+ from _time_.
+  *
+- *     t = Time.now       #=> 2007-11-19 08:23:10 -0600
+- *     t2 = t + 2592000   #=> 2007-12-19 08:23:10 -0600
++ *     t = Time.now       # 2007-11-19 08:23:10 -0600
++ *     t2 = t + 2592000   # 2007-12-19 08:23:10 -0600
+  *     t2 - t             #=> 2592000.0
+- *     t2 - 2592000       #=> 2007-11-19 08:23:10 -0600
++ *     t2 - 2592000 == t  #=> true
+  */
+ 
+ static VALUE
+@@ -3789,12 +3791,15 @@
+  * Returns a new Time object, one second later than _time_.
+  * Time#succ is obsolete since 1.9.2 for time is not a discrete value.
+  *
+- *     t = Time.now       #=> 2007-11-19 08:23:57 -0600
+- *     t.succ             #=> 2007-11-19 08:23:58 -0600
++ *     t = Time.now       # 2007-11-19 08:23:57 -0600
++ *     t.succ             # 2007-11-19 08:23:58 -0600
++ * produces on stderr:
++ * :rdx: stderr
++ *     warning: Time#succ is obsolete; use time + 1
+  *
+  * Use instead <code>time + 1</code>
+- *
+- *     t + 1              #=> 2007-11-19 08:23:58 -0600
++ * :rdx: no_warnings stderr
++ *     t + 1 == t.succ    #=> true
+  */
+ 
+ VALUE
+@@ -3824,30 +3829,30 @@
+  *     require 'time'
+  *
+  *     t = Time.utc(2010,3,30, 5,43,"25.123456789".to_r)
+- *     p t.iso8601(10)           #=> "2010-03-30T05:43:25.1234567890Z"
+- *     p t.round.iso8601(10)     #=> "2010-03-30T05:43:25.0000000000Z"
+- *     p t.round(0).iso8601(10)  #=> "2010-03-30T05:43:25.0000000000Z"
+- *     p t.round(1).iso8601(10)  #=> "2010-03-30T05:43:25.1000000000Z"
+- *     p t.round(2).iso8601(10)  #=> "2010-03-30T05:43:25.1200000000Z"
+- *     p t.round(3).iso8601(10)  #=> "2010-03-30T05:43:25.1230000000Z"
+- *     p t.round(4).iso8601(10)  #=> "2010-03-30T05:43:25.1235000000Z"
+- *     p t.round(5).iso8601(10)  #=> "2010-03-30T05:43:25.1234600000Z"
+- *     p t.round(6).iso8601(10)  #=> "2010-03-30T05:43:25.1234570000Z"
+- *     p t.round(7).iso8601(10)  #=> "2010-03-30T05:43:25.1234568000Z"
+- *     p t.round(8).iso8601(10)  #=> "2010-03-30T05:43:25.1234567900Z"
+- *     p t.round(9).iso8601(10)  #=> "2010-03-30T05:43:25.1234567890Z"
+- *     p t.round(10).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
++ *     t.iso8601(10)           #=> "2010-03-30T05:43:25.1234567890Z"
++ *     t.round.iso8601(10)     #=> "2010-03-30T05:43:25.0000000000Z"
++ *     t.round(0).iso8601(10)  #=> "2010-03-30T05:43:25.0000000000Z"
++ *     t.round(1).iso8601(10)  #=> "2010-03-30T05:43:25.1000000000Z"
++ *     t.round(2).iso8601(10)  #=> "2010-03-30T05:43:25.1200000000Z"
++ *     t.round(3).iso8601(10)  #=> "2010-03-30T05:43:25.1230000000Z"
++ *     t.round(4).iso8601(10)  #=> "2010-03-30T05:43:25.1235000000Z"
++ *     t.round(5).iso8601(10)  #=> "2010-03-30T05:43:25.1234600000Z"
++ *     t.round(6).iso8601(10)  #=> "2010-03-30T05:43:25.1234570000Z"
++ *     t.round(7).iso8601(10)  #=> "2010-03-30T05:43:25.1234568000Z"
++ *     t.round(8).iso8601(10)  #=> "2010-03-30T05:43:25.1234567900Z"
++ *     t.round(9).iso8601(10)  #=> "2010-03-30T05:43:25.1234567890Z"
++ *     t.round(10).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z"
+  *
+  *     t = Time.utc(1999,12,31, 23,59,59)
+- *     p((t + 0.4).round.iso8601(3))    #=> "1999-12-31T23:59:59.000Z"
+- *     p((t + 0.49).round.iso8601(3))   #=> "1999-12-31T23:59:59.000Z"
+- *     p((t + 0.5).round.iso8601(3))    #=> "2000-01-01T00:00:00.000Z"
+- *     p((t + 1.4).round.iso8601(3))    #=> "2000-01-01T00:00:00.000Z"
+- *     p((t + 1.49).round.iso8601(3))   #=> "2000-01-01T00:00:00.000Z"
+- *     p((t + 1.5).round.iso8601(3))    #=> "2000-01-01T00:00:01.000Z"
++ *     (t + 0.4).round.iso8601(3)    #=> "1999-12-31T23:59:59.000Z"
++ *     (t + 0.49).round.iso8601(3)   #=> "1999-12-31T23:59:59.000Z"
++ *     (t + 0.5).round.iso8601(3)    #=> "2000-01-01T00:00:00.000Z"
++ *     (t + 1.4).round.iso8601(3)    #=> "2000-01-01T00:00:00.000Z"
++ *     (t + 1.49).round.iso8601(3)   #=> "2000-01-01T00:00:00.000Z"
++ *     (t + 1.5).round.iso8601(3)    #=> "2000-01-01T00:00:01.000Z"
+  *
+  *     t = Time.utc(1999,12,31, 23,59,59)
+- *     p (t + 0.123456789).round(4).iso8601(6)  #=> "1999-12-31T23:59:59.123500Z"
++ *     (t + 0.123456789).round(4).iso8601(6)  #=> "1999-12-31T23:59:59.123500Z"
+  */
+ 
+ static VALUE
+@@ -3897,8 +3902,8 @@
+  *  leap seconds. See http://en.wikipedia.org/wiki/Leap_second for further
+  *  details.
+  *
+- *     t = Time.now   #=> 2007-11-19 08:25:02 -0600
+- *     t.sec          #=> 2
++ *     t = Time.now   # 2007-11-19 08:25:02 -0600
++ *     t.sec          #-> 2
+  */
+ 
+ static VALUE
+@@ -3917,8 +3922,8 @@
+  *
+  *  Returns the minute of the hour (0..59) for _time_.
+  *
+- *     t = Time.now   #=> 2007-11-19 08:25:51 -0600
+- *     t.min          #=> 25
++ *     t = Time.now   # 2007-11-19 08:25:51 -0600
++ *     t.min          #-> 25
+  */
+ 
+ static VALUE
+@@ -3937,8 +3942,8 @@
+  *
+  *  Returns the hour of the day (0..23) for _time_.
+  *
+- *     t = Time.now   #=> 2007-11-19 08:26:20 -0600
+- *     t.hour         #=> 8
++ *     t = Time.now   # 2007-11-19 08:26:20 -0600
++ *     t.hour         #-> 8
+  */
+ 
+ static VALUE
+@@ -3958,9 +3963,9 @@
+  *
+  *  Returns the day of the month (1..n) for _time_.
+  *
+- *     t = Time.now   #=> 2007-11-19 08:27:03 -0600
+- *     t.day          #=> 19
+- *     t.mday         #=> 19
++ *     t = Time.now   # 2007-11-19 08:27:03 -0600
++ *     t.day          #-> 19
++ *     t.mday         #-> 19
+  */
+ 
+ static VALUE
+@@ -3980,9 +3985,9 @@
+  *
+  *  Returns the month of the year (1..12) for _time_.
+  *
+- *     t = Time.now   #=> 2007-11-19 08:27:30 -0600
+- *     t.mon          #=> 11
+- *     t.month        #=> 11
++ *     t = Time.now   # 2007-11-19 08:27:30 -0600
++ *     t.mon          #-> 11
++ *     t.month        #-> 11
+  */
+ 
+ static VALUE
+@@ -4001,8 +4006,8 @@
+  *
+  *  Returns the year for _time_ (including the century).
+  *
+- *     t = Time.now   #=> 2007-11-19 08:27:51 -0600
+- *     t.year         #=> 2007
++ *     t = Time.now   # 2007-11-19 08:27:51 -0600
++ *     t.year         #-> 2007
+  */
+ 
+ static VALUE
+@@ -4022,15 +4027,15 @@
+  *  Returns an integer representing the day of the week, 0..6, with
+  *  Sunday == 0.
+  *
+- *     t = Time.now   #=> 2007-11-20 02:35:35 -0600
+- *     t.wday         #=> 2
+- *     t.sunday?      #=> false
+- *     t.monday?      #=> false
+- *     t.tuesday?     #=> true
+- *     t.wednesday?   #=> false
+- *     t.thursday?    #=> false
+- *     t.friday?      #=> false
+- *     t.saturday?    #=> false
++ *     t = Time.now   # 2007-11-20 02:35:35 -0600
++ *     t.wday         #-> 2
++ *     t.sunday?      #-> false
++ *     t.monday?      #-> false
++ *     t.tuesday?     #-> true
++ *     t.wednesday?   #-> false
++ *     t.thursday?    #-> false
++ *     t.friday?      #-> false
++ *     t.saturday?    #-> false
+  */
+ 
+ static VALUE
+@@ -4056,8 +4061,8 @@
+  *
+  *  Returns +true+ if _time_ represents Sunday.
+  *
+- *     t = Time.local(1990, 4, 1)       #=> 1990-04-01 00:00:00 -0600
+- *     t.sunday?                        #=> true
++ *     t = Time.utc(1990, 4, 1)       # > 1990-04-01 00:00:00 UTC
++ *     t.sunday?                      #=> true
+  */
+ 
+ static VALUE
+@@ -4072,8 +4077,8 @@
+  *
+  *  Returns +true+ if _time_ represents Monday.
+  *
+- *     t = Time.local(2003, 8, 4)       #=> 2003-08-04 00:00:00 -0500
+- *     p t.monday?                      #=> true
++ *     t = Time.utc(2003, 8, 4)       # > 2003-08-04 00:00:00 UTC
++ *     t.monday?                      #=> true
+  */
+ 
+ static VALUE
+@@ -4088,8 +4093,8 @@
+  *
+  *  Returns +true+ if _time_ represents Tuesday.
+  *
+- *     t = Time.local(1991, 2, 19)      #=> 1991-02-19 00:00:00 -0600
+- *     p t.tuesday?                     #=> true
++ *     t = Time.utc(1991, 2, 19)      # > 1991-02-19 00:00:00 UTC
++ *     t.tuesday?                     #=> true
+  */
+ 
+ static VALUE
+@@ -4104,8 +4109,8 @@
+  *
+  *  Returns +true+ if _time_ represents Wednesday.
+  *
+- *     t = Time.local(1993, 2, 24)      #=> 1993-02-24 00:00:00 -0600
+- *     p t.wednesday?                   #=> true
++ *     t = Time.utc(1993, 2, 24)      # > 1993-02-24 00:00:00 UTC
++ *     t.wednesday?                   #=> true
+  */
+ 
+ static VALUE
+@@ -4120,8 +4125,8 @@
+  *
+  *  Returns +true+ if _time_ represents Thursday.
+  *
+- *     t = Time.local(1995, 12, 21)     #=> 1995-12-21 00:00:00 -0600
+- *     p t.thursday?                    #=> true
++ *     t = Time.utc(1995, 12, 21)     # > 1995-12-21 00:00:00 UTC
++ *     t.thursday?                      #=> true
+  */
+ 
+ static VALUE
+@@ -4136,8 +4141,8 @@
+  *
+  *  Returns +true+ if _time_ represents Friday.
+  *
+- *     t = Time.local(1987, 12, 18)     #=> 1987-12-18 00:00:00 -0600
+- *     t.friday?                        #=> true
++ *     t = Time.utc(1987, 12, 18)     # > 1987-12-18 00:00:00 UTC
++ *     t.friday?                      #=> true
+  */
+ 
+ static VALUE
+@@ -4152,8 +4157,8 @@
+  *
+  *  Returns +true+ if _time_ represents Saturday.
+  *
+- *     t = Time.local(2006, 6, 10)      #=> 2006-06-10 00:00:00 -0500
+- *     t.saturday?                      #=> true
++ *     t = Time.utc(2006, 6, 10)      # > 2006-06-10 00:00:00 UTC
++ *     t.saturday?                    #=> true
+  */
+ 
+ static VALUE
+@@ -4168,8 +4173,8 @@
+  *
+  *  Returns an integer representing the day of the year, 1..366.
+  *
+- *     t = Time.now   #=> 2007-11-19 08:32:31 -0600
+- *     t.yday         #=> 323
++ *     t = Time.now   # 2007-11-19 08:32:31 -0600
++ *     t.yday         #-> 323
+  */
+ 
+ static VALUE
+@@ -4190,6 +4195,7 @@
+  *  Returns +true+ if _time_ occurs during Daylight
+  *  Saving Time in its time zone.
+  *
++ *  :rdx: if Time.now.zone == "CST"
+  *   # CST6CDT:
+  *     Time.local(2000, 1, 1).zone    #=> "CST"
+  *     Time.local(2000, 1, 1).isdst   #=> false
+@@ -4198,6 +4204,7 @@
+  *     Time.local(2000, 7, 1).isdst   #=> true
+  *     Time.local(2000, 7, 1).dst?    #=> true
+  *
++ *  :rdx: if Time.now.zone == "JST"
+  *   # Asia/Tokyo:
+  *     Time.local(2000, 1, 1).zone    #=> "JST"
+  *     Time.local(2000, 1, 1).isdst   #=> false
+@@ -4227,7 +4234,7 @@
+  *     t = Time.gm(2000, "jan", 1, 20, 15, 1)
+  *     t.zone   #=> "UTC"
+  *     t = Time.local(2000, "jan", 1, 20, 15, 1)
+- *     t.zone   #=> "CST"
++ *     t.zone   #-> "CST"
+  */
+ 
+ static VALUE
+@@ -4255,10 +4262,10 @@
+  *  Returns the offset in seconds between the timezone of _time_
+  *  and UTC.
+  *
+- *     t = Time.gm(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
++ *     t = Time.gm(2000,1,1,20,15,1)   # > 2000-01-01 20:15:01 UTC
+  *     t.gmt_offset                    #=> 0
+- *     l = t.getlocal                  #=> 2000-01-01 14:15:01 -0600
+- *     l.gmt_offset                    #=> -21600
++ *     l = t.getlocal                  #   2000-01-01 14:15:01 -0600
++ *     l.gmt_offset                    #-> -21600
+  */
+ 
+ static VALUE
+@@ -4282,16 +4289,18 @@
+  *     time.to_a -> array
+  *
+  *  Returns a ten-element _array_ of values for _time_:
+- *
++ * 
++ *  :rdx: off -
+  *     [sec, min, hour, day, month, year, wday, yday, isdst, zone]
+  *
+  *  See the individual methods for an explanation of the
+  *  valid ranges of each value. The ten elements can be passed directly
+  *  to Time::utc or Time::local to create a
+  *  new Time object.
+- *
+- *     t = Time.now     #=> 2007-11-19 08:36:01 -0600
+- *     now = t.to_a     #=> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]
++ *  
++ *  :rdx: on
++ *     t = Time.now     #   2007-11-19 08:36:01 -0600
++ *     now = t.to_a     #-> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]
+  */
+ 
+ static VALUE
+@@ -4392,6 +4401,7 @@
+  *  zero or more flags, optional minimum field width,
+  *  optional modifier and a conversion specifier
+  *  as follows:
++ *  :rdx: off
+  *
+  *    %<flags><width><modifier><conversion>
+  *
+@@ -4519,12 +4529,14 @@
+  *  So the numeric time zone offset, %z, is recommended.
+  *
+  *  Examples:
++ *  :rdx: on
+  *
+- *    t = Time.new(2007,11,19,8,37,48,"-06:00") #=> 2007-11-19 08:37:48 -0600
++ *    t = Time.new(2007,11,19,8,37,48,"-06:00") # > 2007-11-19 08:37:48 -0600
+  *    t.strftime("Printed on %m/%d/%Y")   #=> "Printed on 11/19/2007"
+  *    t.strftime("at %I:%M%p")            #=> "at 08:37AM"
+  *
+  *  Various ISO 8601 formats:
++ *  :rdx: off -
+  *    %Y%m%d           => 20071119                  Calendar date (basic)
+  *    %F               => 2007-11-19                Calendar date (extended)
+  *    %Y-%m            => 2007-11                   Calendar date, reduced accuracy, specific month
+@@ -4889,10 +4901,10 @@
+  *  pass the year with nothing else time will default to January 1 of that year
+  *  at 00:00:00 with the current system timezone. Here are some examples:
+  *
+- *    Time.new(2002)         #=> 2002-01-01 00:00:00 -0500
+- *    Time.new(2002, 10)     #=> 2002-10-01 00:00:00 -0500
+- *    Time.new(2002, 10, 31) #=> 2002-10-31 00:00:00 -0500
+- *    Time.new(2002, 10, 31, 2, 2, 2, "+02:00") #=> 2002-10-31 02:02:02 -0200
++ *    Time.new(2002)         # 2002-01-01 00:00:00 -0500
++ *    Time.new(2002, 10)     # 2002-10-01 00:00:00 -0500
++ *    Time.new(2002, 10, 31) # 2002-10-31 00:00:00 -0500
++ *    Time.new(2002, 10, 31, 2, 2, 2, "+02:00") # > 2002-10-31 02:02:02 +0200
+  *
+  *  You can also use #gm, #local and
+  *  #utc to infer GMT, local and UTC timezones instead of using
+@@ -4902,7 +4914,7 @@
+  *  seconds (or fraction of seconds) since the {Unix
+  *  Epoch}[http://en.wikipedia.org/wiki/Unix_time].
+  *
+- *    Time.at(628232400) #=> 1989-11-28 00:00:00 -0500
++ *    Time.at(628232400) # 1989-11-28 00:00:00 -0500
+  *
+  *  == Working with an instance of Time
+  *
+@@ -4926,7 +4938,7 @@
+  *
+  *  What's the day a year later?
+  *
+- *    t + (60*60*24*365) #=> 1994-02-24 12:00:00 +0900
++ *    t + (60*60*24*365) # > 1994-02-24 12:00:00 +0900
+  *
+  *  How many seconds was that since the Unix Epoch?
+  *