rdx 0.9.0.pre

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/shellwords.rb.diff

@@ -0,0 +1,66 @@
+--- stdlib/orig/lib/shellwords.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/shellwords.rb	2015-06-25 16:25:25 +0000
+@@ -25,7 +25,7 @@
+ # Be careful you don't leave a quote unmatched.
+ #
+ #   argv = "they all ran after the farmer's wife".shellsplit
+-#        #=> ArgumentError: Unmatched double quote: ...
++#        # raises ArgumentError: Unmatched double quote
+ #
+ # In this case, you might want to use Shellwords.escape, or it's alias
+ # String#shellescape.
+@@ -33,13 +33,24 @@
+ # This method will escape the String for you to safely use with a Bourne shell.
+ #
+ #   argv = Shellwords.escape("special's.txt")
+-#   argv #=> "special\\s.txt"
++#   argv #=> "special\\'s.txt"
++# :rdx: off
+ #   system("cat " + argv)
++# :rdx: on
+ #
+ # Shellwords also comes with a core extension for Array, Array#shelljoin.
+ #
++# :rdx: off
+ #   argv = %w{ls -lta lib}
+ #   system(argv.shelljoin)
++# on my system produces:
++#   total 1020
++#   drwxr-xr-x 24 11270410 Administrators 40960 Apr 29 12:11 ..
++#   drwxr-xr-x 23 11270410 Administrators 16384 Apr 29 12:11 .
++#   drwxr-xr-x  5 11270410 Administrators     0 Apr 29 12:11 irb
++#   drwxr-xr-x  2 11270410 Administrators     0 Apr 29 12:11 matrix
++#   drwxr-xr-x  3 11270410 Administrators     0 Apr 29 12:11 net
++#   ... (many other lines) ...
+ #
+ # You can use this method to create an escaped string out of an array of tokens
+ # separated by a space. In this example we'll use the literal shortcut for
+@@ -105,6 +116,7 @@
+   #   argv = "It's better to give than to receive".shellescape
+   #   argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+   #
++	# :rdx: off
+   #   # Search files in lib for method definitions
+   #   pattern = "^[ \t]*def "
+   #   open("| grep -Ern #{pattern.shellescape} lib") { |grep|
+@@ -164,12 +176,18 @@
+   #
+   # You can also mix non-string objects in the elements as allowed in Array#join.
+   #
+-  #   output = `#{['ps', '-p', $$].shelljoin}`
++	# :rdx: off
++	#   system ['ps', '-p', $$].shelljoin
++	#   
++	# on my machine (running CYGWIN) produces:
++	#   
++	#      PID    PPID    PGID     WINPID   TTY     UID    STIME COMMAND
++  #     2736     888    2736       3692  pty1    1000 10:59:52 /usr/bin/bash
+   #
+   def shelljoin(array)
+     array.map { |arg| shellescape(arg) }.join(' ')
+   end
+-
++	
+   module_function :shelljoin
+ 
+   class << self

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/singleton.rb.diff

@@ -0,0 +1,37 @@
+--- stdlib/orig/lib/singleton.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/singleton.rb	2015-06-25 16:25:55 +0000
+@@ -19,7 +19,7 @@
+ #      # => true
+ #
+ #      Klass.new
+-#      # => NoMethodError - new is private ...
++#      # raises NoMethodError # new is private ...
+ #
+ # The instance is created at upon the first call of Klass.instance().
+ #
+@@ -62,7 +62,8 @@
+ # state, from the instance. Classes using Singleton can provide custom
+ # _load(str) and _dump(depth) methods to retain some of the previous state of
+ # the instance.
+-#
++# :rdx: toplevel
++# 
+ #    require 'singleton'
+ #
+ #    class Example
+@@ -89,9 +90,12 @@
+ #    a.keep = nil
+ #    a.strip = nil
+ #    b = Marshal.load(stored_state)
+-#    p a == b  #  => true
+-#    p a.keep  #  => "keep this"
+-#    p a.strip #  => nil
++#    a == b  #  => true
++#    a.keep  #  => "keep this"
++#    a.strip #  => nil
++#    
++#-- rdx
++#    Object.send :remove_const, :Example
+ #
+ module Singleton
+   # Raises a TypeError to prevent cloning.

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/tempfile.rb.diff

@@ -0,0 +1,104 @@
+--- stdlib/orig/lib/tempfile.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/tempfile.rb	2015-06-11 07:51:48 +0000
+@@ -21,9 +21,10 @@
+ #   require 'tempfile'
+ #
+ #   file = Tempfile.new('foo')
+-#   file.path      # => A unique filename in the OS's temp directory,
+-#                  #    e.g.: "/tmp/foo.24722.0"
+-#                  #    This filename contains 'foo' in its basename.
++#   # A unique filename in the OS's temp directory,
++#   # e.g.: "/tmp/foo.24722.0"
++#   # Its basename starts with 'foo':
++#   File.fnmatch? '**/foo*', file.path #=> true
+ #   file.write("hello world")
+ #   file.rewind
+ #   file.read      # => "hello world"
+@@ -42,12 +43,12 @@
+ # until they're garbage collected. The existence of these temp files can make
+ # it harder to determine a new Tempfile filename.
+ #
+-# Therefore, one should always call #unlink or close in an ensure block, like
++# Therefore, one should always call #unlink or #close in an ensure block, like
+ # this:
+ #
+ #   file = Tempfile.new('foo')
+ #   begin
+-#      ...do something with file...
++#      # ...do something with file...
+ #   ensure
+ #      file.close
+ #      file.unlink   # deletes the temp file
+@@ -95,11 +96,13 @@
+   # element, and end with the second element. For example:
+   #
+   #   file = Tempfile.new('hello')
+-  #   file.path  # => something like: "/tmp/hello2843-8392-92849382--0"
++	#   File.fnmatch? '**/hello*', file.path #=> true
++	#   # file.path is something like: "/tmp/hello2843-8392-92849382--0"
+   #
+   #   # Use the Array form to enforce an extension in the filename:
+   #   file = Tempfile.new(['hello', '.jpg'])
+-  #   file.path  # => something like: "/tmp/hello2843-8392-92849382--0.jpg"
++	#   File.fnmatch? '**/hello*.jpg', file.path #=> true
++  #   # file.path is something like: "/tmp/hello2843-8392-70154257--0.jpg"
+   #
+   # The temporary file will be placed in the directory as specified
+   # by the +tmpdir+ parameter. By default, this is +Dir.tmpdir+.
+@@ -108,15 +111,16 @@
+   # are tainted by default, and +Dir.tmpdir+'s return value might
+   # come from environment variables (e.g. <tt>$TMPDIR</tt>).
+   #
+-  #   file = Tempfile.new('hello', '/home/aisaka')
+-  #   file.path  # => something like: "/home/aisaka/hello2843-8392-92849382--0"
++  #   file = Tempfile.new('hello', Dir.pwd)
++	#   File.fnmatch? "#{Dir.pwd}/hello*", file.path
++  #   # file.path is something like: "./hello2843-8392-92849382--0"
+   #
+   # You can also pass an options hash. Under the hood, Tempfile creates
+   # the temporary file using +File.open+. These options will be passed to
+   # +File.open+. This is mostly useful for specifying encoding
+   # options, e.g.:
+   #
+-  #   Tempfile.new('hello', '/home/aisaka', :encoding => 'ascii-8bit')
++  #   Tempfile.new('hello', Dir.tmpdir, :encoding => 'ascii-8bit')
+   #
+   #   # You can also omit the 'tmpdir' parameter:
+   #   Tempfile.new('hello', :encoding => 'ascii-8bit')
+@@ -199,7 +203,7 @@
+   #
+   #   file = Tempfile.new('foo')
+   #   begin
+-  #      ...do something with file...
++  #      # ...do something with file...
+   #   ensure
+   #      file.close
+   #      file.unlink   # deletes the temp file
+@@ -220,7 +224,7 @@
+   #   file = Tempfile.new('foo')
+   #   file.unlink   # On Windows this silently fails.
+   #   begin
+-  #      ... do something with file ...
++  #      # ... do something with file ...
+   #   ensure
+   #      file.close!   # Closes the file handle. If the file wasn't unlinked
+   #                    # because #unlink failed, then this method will attempt
+@@ -305,14 +309,14 @@
+     #
+     # In any case, all arguments (+*args+) will be passed to Tempfile.new.
+     #
+-    #   Tempfile.open('foo', '/home/temp') do |f|
+-    #      ... do something with f ...
++    #   Tempfile.open('foo') do |f|
++    #      # ... do something with f ...
+     #   end
+     #
+     #   # Equivalent:
+-    #   f = Tempfile.open('foo', '/home/temp')
++    #   f = Tempfile.open('foo')
+     #   begin
+-    #      ... do something with f ...
++    #      # ... do something with f ...
+     #   ensure
+     #      f.close
+     #   end

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/thread.rb.diff

@@ -0,0 +1,38 @@
+--- stdlib/orig/lib/thread.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/thread.rb	2015-06-25 16:26:51 +0000
+@@ -1,4 +1,4 @@
+-#
++# :rdx: off
+ #               thread.rb - thread support classes
+ #                       by Yukihiro Matsumoto <matz@netlab.co.jp>
+ #
+@@ -120,6 +120,8 @@
+ # This class provides a way to synchronize communication between threads.
+ #
+ # Example:
++# 
++# :rdx: is_slow
+ #
+ #   require 'thread'
+ #
+@@ -142,6 +144,20 @@
+ #   end
+ #
+ #   consumer.join
++#   
++# produces something like:
++# :rdx: indicative_output
++# 
++#   0 produced
++#   1 produced
++#   consumed 0
++#   2 produced
++#   3 produced
++#   consumed 1
++#   consumed 2
++#   consumed 3
++#   4 produced
++#   consumed 4
+ #
+ class Queue
+   #

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/time.rb.diff

@@ -0,0 +1,140 @@
+--- stdlib/orig/lib/time.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/time.rb	2015-06-25 17:34:52 +0000
+@@ -28,21 +28,21 @@
+ # === Converting to a String
+ #
+ #   t = Time.now
+-#   t.iso8601  # => "2011-10-05T22:26:12-04:00"
+-#   t.rfc2822  # => "Wed, 05 Oct 2011 22:26:12 -0400"
+-#   t.httpdate # => "Thu, 06 Oct 2011 02:26:12 GMT"
++#   t.iso8601  # -> "2011-10-05T22:26:12-04:00"
++#   t.rfc2822  # -> "Wed, 05 Oct 2011 22:26:12 -0400"
++#   t.httpdate # -> "Thu, 06 Oct 2011 02:26:12 GMT"
+ #
+ # === Time.parse
+ #
+ # #parse takes a string representation of a Time and attempts to parse it
+ # using a heuristic.
+ #
+-#   Date.parse("2010-10-31") #=> 2010-10-31 00:00:00 -0500
++#   Date.parse("2010-10-31") # 2010-10-31 00:00:00 -0500
+ #
+ # Any missing pieces of the date are inferred based on the current date.
+ #
+ #   # assuming the current date is "2011-10-31"
+-#   Time.parse("12:00") #=> 2011-10-31 12:00:00 -0500
++#   Time.parse("12:00") # 2011-10-31 12:00:00 -0500
+ #
+ # We can change the date used to infer our missing elements by passing a second
+ # object that responds to #mon, #day and #year, such as Date, Time or DateTime.
+@@ -61,10 +61,10 @@
+ #   dt = DateTime.parse("2010-10-30")
+ #   md = MyDate.new(10,31,2010)
+ #
+-#   Time.parse("12:00", d)  #=> 2010-10-28 12:00:00 -0500
+-#   Time.parse("12:00", t)  #=> 2010-10-29 12:00:00 -0500
+-#   Time.parse("12:00", dt) #=> 2010-10-30 12:00:00 -0500
+-#   Time.parse("12:00", md) #=> 2010-10-31 12:00:00 -0500
++#   Time.parse("12:00", d)  #=> Time.new(2010,10,28, 12,0,0)
++#   Time.parse("12:00", t)  #=> Time.new(2010,10,29, 12,0,0)
++#   Time.parse("12:00", dt) #=> Time.new(2010,10,30, 12,0,0)
++#   Time.parse("12:00", md) #=> Time.new(2010,10,31, 12,0,0)
+ #
+ # #parse also accepts an optional block. You can use this block to specify how
+ # to handle the year component of the date. This is specifically designed for
+@@ -72,9 +72,9 @@
+ # years prior to 70 as the year 2000+ you could write this:
+ #
+ #   Time.parse("01-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
+-#   #=> 2001-10-31 00:00:00 -0500
++#   #=> Time.new(2001,10,31)
+ #   Time.parse("70-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
+-#   #=> 1970-10-31 00:00:00 -0500
++#   #=> Time.new(1970,10,31)
+ #
+ # === Time.strptime
+ #
+@@ -82,7 +82,7 @@
+ # to detect the format of the input string, you provide a second argument that
+ # is describes the format of the string. For example:
+ #
+-#   Time.strptime("2000-10-31", "%Y-%m-%d") #=> 2000-10-31 00:00:00 -0500
++#   Time.strptime("2000-10-31", "%Y-%m-%d") #=> Time.new(2000,10,31)
+ 
+ class Time
+   class << Time
+@@ -272,6 +272,7 @@
+     # If a block is given, the year described in +date+ is converted by the
+     # block.  For example:
+     #
++		# :rdx: off -
+     #     Time.parse(...) {|y| 0 <= y && y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}
+     #
+     # If the upper components of the given time are broken or missing, they are
+@@ -281,16 +282,16 @@
+     #     # Suppose it is "Thu Nov 29 14:33:20 GMT 2001" now and
+     #     # your time zone is GMT:
+     #     now = Time.parse("Thu Nov 29 14:33:20 GMT 2001")
+-    #     Time.parse("16:30", now)     #=> 2001-11-29 16:30:00 +0900
+-    #     Time.parse("7/23", now)      #=> 2001-07-23 00:00:00 +0900
+-    #     Time.parse("Aug 31", now)    #=> 2001-08-31 00:00:00 +0900
+-    #     Time.parse("Aug 2000", now)  #=> 2000-08-01 00:00:00 +0900
++    #     Time.parse("16:30", now)     #=> Time.new(2001,11,29, 16,30,0)
++    #     Time.parse("7/23", now)      #=> Time.new(2001, 7,23)
++    #     Time.parse("Aug 31", now)    #=> Time.new(2001, 8,31)
++    #     Time.parse("Aug 2000", now)  #=> Time.new(2000, 8, 1)
+     #
+     # Since there are numerous conflicts among locally defined time zone
+     # abbreviations all over the world, this method is not intended to
+     # understand all of them.  For example, the abbreviation "CST" is
+     # used variously as:
+-    #
++    # :rdx: off -
+     #     -06:00 in America/Chicago,
+     #     -05:00 in America/Havana,
+     #     +08:00 in Asia/Harbin,
+@@ -311,7 +312,7 @@
+     # +date+ or if the Time class cannot represent specified date.
+     #
+     # This method can be used as a fail-safe for other parsing methods as:
+-    #
++		# :rdx: off -
+     #   Time.rfc2822(date) rescue Time.parse(date)
+     #   Time.httpdate(date) rescue Time.parse(date)
+     #   Time.xmlschema(date) rescue Time.parse(date)
+@@ -336,7 +337,7 @@
+     #
+     # If a block is given, the year described in +date+ is converted by the
+     # block.  For example:
+-    #
++		# :rdx: off -
+     #   Time.strptime(...) {|y| y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}
+     #
+     # Below is a list of the formating options:
+@@ -553,7 +554,7 @@
+ 
+   #
+   # Returns a string which represents the time as date-time defined by RFC 2822:
+-  #
++	# :rdx: off -
+   #   day-of-week, DD month-name CCYY hh:mm:ss zone
+   #
+   # where zone is [+-]hhmm.
+@@ -588,7 +589,7 @@
+   #
+   # Returns a string which represents the time as RFC 1123 date of HTTP-date
+   # defined by RFC 2616:
+-  #
++	# :rdx: off -
+   #   day-of-week, DD month-name CCYY hh:mm:ss GMT
+   #
+   # Note that the result is always UTC (GMT).
+@@ -606,7 +607,7 @@
+   #
+   # Returns a string which represents the time as a dateTime defined by XML
+   # Schema:
+-  #
++	# :rdx: off -
+   #   CCYY-MM-DDThh:mm:ssTZD
+   #   CCYY-MM-DDThh:mm:ss.sssTZD
+   #

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/tmpdir.rb.diff

@@ -0,0 +1,52 @@
+--- stdlib/orig/lib/tmpdir.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/tmpdir.rb	2015-06-11 07:51:48 +0000
+@@ -47,15 +47,16 @@
+   # - If it is a string, it is used as the prefix and no suffix is used.
+   # - If it is an array, first element is used as the prefix and second element is used as a suffix.
+   #
+-  #  Dir.mktmpdir {|dir| dir is ".../d..." }
+-  #  Dir.mktmpdir("foo") {|dir| dir is ".../foo..." }
+-  #  Dir.mktmpdir(["foo", "bar"]) {|dir| dir is ".../foo...bar" }
++  #  Dir.mktmpdir {|dir| File.fnmatch? '**/d*', dir } #=> true
++  #  Dir.mktmpdir("foo") {|dir| File.fnmatch? '**/foo*', dir } #=> true
++  #  Dir.mktmpdir(["foo", "bar"]) {|dir| File.fnmatch? '**/foo*bar', dir } #=> true
+   #
+   # The directory is created under Dir.tmpdir or
+   # the optional second argument <i>tmpdir</i> if non-nil value is given.
+   #
+-  #  Dir.mktmpdir {|dir| dir is "#{Dir.tmpdir}/d..." }
+-  #  Dir.mktmpdir(nil, "/var/tmp") {|dir| dir is "/var/tmp/d..." }
++  #  Dir.mktmpdir {|dir| File.fnmatch? "#{Dir.tmpdir}/d*", dir } #=> true
++	# :rdx: if File.directory? '/tmp'
++  #  Dir.mktmpdir(nil, "/tmp") {|dir| File.fnmatch? "/tmp/d*", dir } #=> true
+   #
+   # If a block is given,
+   # it is yielded with the path of the directory.
+@@ -63,10 +64,15 @@
+   # using FileUtils.remove_entry before Dir.mktmpdir returns.
+   # The value of the block is returned.
+   #
++	#  tmp_path = nil
+   #  Dir.mktmpdir {|dir|
++	#    tmp_path = dir
+   #    # use the directory...
+-  #    open("#{dir}/foo", "w") { ... }
++  #    open("#{dir}/foo", "w") { |file|
++	#      # ...
++	#    }
+   #  }
++	#  File.exist? tmp_path #=> false 
+   #
+   # If a block is not given,
+   # The path of the directory is returned.
+@@ -75,7 +81,9 @@
+   #  dir = Dir.mktmpdir
+   #  begin
+   #    # use the directory...
+-  #    open("#{dir}/foo", "w") { ... }
++  #    open("#{dir}/foo", "w") {
++	#      # ...
++	#    }
+   #  ensure
+   #    # remove the directory.
+   #    FileUtils.remove_entry dir

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/uri.rb.diff

@@ -0,0 +1,39 @@
+--- stdlib/orig/lib/uri.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/uri.rb	2015-06-25 16:33:12 +0000
+@@ -13,8 +13,7 @@
+ #   require 'uri'
+ #
+ #   uri = URI("http://foo.com/posts?id=30&limit=5#time=1305298413")
+-#   #=> #<URI::HTTP:0x00000000b14880
+-#         URL:http://foo.com/posts?id=30&limit=5#time=1305298413>
++#   # > #<URI::HTTP:0x00000000b14880 URL:http://foo.com/posts?id=30&limit=5#time=1305298413>
+ #   uri.scheme
+ #   #=> "http"
+ #   uri.host
+@@ -30,22 +29,21 @@
+ #   #=> "http://foo.com/posts?id=30&limit=5#time=1305298413"
+ #
+ # == Adding custom URIs
+-#
++# :rdx: toplevel
+ #   module URI
+ #     class RSYNC < Generic
+ #       DEFAULT_PORT = 873
+ #     end
+ #     @@schemes['RSYNC'] = RSYNC
+ #   end
+-#   #=> URI::RSYNC
+ #
+ #   URI.scheme_list
+ #   #=> {"FTP"=>URI::FTP, "HTTP"=>URI::HTTP, "HTTPS"=>URI::HTTPS,
+-#        "LDAP"=>URI::LDAP, "LDAPS"=>URI::LDAPS, "MAILTO"=>URI::MailTo,
+-#        "RSYNC"=>URI::RSYNC}
++#   #     "LDAP"=>URI::LDAP, "LDAPS"=>URI::LDAPS, "MAILTO"=>URI::MailTo,
++#   #     "RSYNC"=>URI::RSYNC}
+ #
+ #   uri = URI("rsync://rsync.foo.com")
+-#   #=> #<URI::RSYNC:0x00000000f648c8 URL:rsync://rsync.foo.com>
++#   # > #<URI::RSYNC:0x00000000f648c8 URL:rsync://rsync.foo.com>
+ #
+ # == RFC References
+ #