rdx 0.9.0.pre

data/examples/ruby-2.0.0-p0/install/core/diffs/doc/syntax/miscellaneous.rdoc.diff

@@ -0,0 +1,91 @@
+--- core/orig/doc/syntax/miscellaneous.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/miscellaneous.rdoc	2015-06-19 07:39:39 +0000
+@@ -21,6 +21,9 @@
+ The +alias+ keyword is most frequently used to alias methods.  When aliasing a
+ method you can use either its name or a symbol:
+ 
++-- rdx
++  def old_name; end
++++
+   alias new_name old_name
+   alias :new_name :old_name
+ 
+@@ -33,6 +36,9 @@
+   alias $new $old
+ 
+   p $new # prints 0
++-- rdx
++  $old = $new = nil
++++
+ 
+ You may use +alias+ in any scope.
+ 
+@@ -41,13 +47,22 @@
+ The +undef+ keyword prevents the current class from responding to calls to the
+ named methods.
+ 
++-- rdx
++  def my_method; end
++++
+   undef my_method
+ 
+ You may use symbols instead of method names:
+ 
++-- rdx
++  def my_method; end
++++
+   undef :my_method
+ 
+ You may undef multiple methods:
++-- rdx
++  def method1; end; alias method2 method1
++++
+ 
+   undef method1, method2
+ 
+@@ -68,12 +83,14 @@
+ instance variable is zero:
+ 
+   defined? @instance_variable && @instance_variable.zero?
++  # => "expression"
+ 
+-This returns <code>"expression"</code> which is not what you want if the
++This result is not what you want if the
+ instance variable is not defined.
+ 
+   @instance_variable = 1
+   defined?(@instance_variable) && @instance_variable.zero?
++  # => false
+ 
+ Adding parentheses when checking if the instance variable is defined is a
+ better check.  This correctly returns +nil+ when the instance variable is not
+@@ -94,14 +111,26 @@
+ 
+ Here is an example:
+ 
++:rdx: off
++
+   BEGIN {
+     count = 0
+   }
+ 
+ You must use <code>{</code> and <code>}</code> you may not use +do+ and +end+.
+ 
+-Here is an example one-liner that adds numbers from standard input or any files
+-in the argument list:
++Follows an example that adds numbers from standard input or any files
++in the argument list. So having the file:
++
++:rdx: on
++
++  # File: number_list
++  2
++  4
++  -5
++  3
+ 
+-  ruby -ne 'BEGIN { count = 0 }; END { puts count }; count += gets.to_i'
++the one-liner command is
+ 
++  $ ruby -ne 'BEGIN { count = 0 }; END { puts count }; count += $_.to_i' number_list
++  4

data/examples/ruby-2.0.0-p0/install/core/diffs/doc/syntax/modules_and_classes.rdoc.diff

@@ -0,0 +1,161 @@
+--- core/orig/doc/syntax/modules_and_classes.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/modules_and_classes.rdoc	2015-06-19 08:02:30 +0000
+@@ -84,15 +84,26 @@
+ the constant <code>A::Z</code> is accessible from B as A is part of the
+ nesting:
+ 
++:rdx: toplevel
++
+   module A
+     Z = 1
+ 
+     module B
+-      p Module.nesting #=> [A::B, A]
+-      p Z #=> 1
++      p Module.nesting
++      p Z
+     end
+   end
+ 
++-- rdx
++  Object.send :remove_const, :A
++++
++
++produces
++
++  [A::B, A]
++  1
++
+ However, if you use <code>::</code> to define <code>A::B</code> without
+ nesting it inside +A+ a NameError exception will be raised because the nesting
+ does not include +A+:
+@@ -102,24 +113,47 @@
+   end
+ 
+   module A::B
+-    p Module.nesting #=> [A::B]
+-    p Z #=> raises NameError
++    p Module.nesting
++    p Z
+   end
+ 
++produces
++:rdx: error NameError
++
++  [A::B]
++
++(then raises the exception)
++
++-- rdx
++  Object.send :remove_const, :A
++++
++
+ If a constant is defined at the top-level you may preceded it with
+ <code>::</code> to reference it:
+ 
++:rdx: toplevel
++
+   Z = 0
+ 
+   module A
+     Z = 1
+ 
+     module B
+-      p ::Z #=> 0
++      p ::Z
+     end
+   end
+ 
++-- rdx
++  Object.send :remove_const, :Z
++  Object.send :remove_const, :A
++++
++
++produces
++
++  0
++
+ === Methods
++:rdx: new_binding
+ 
+ For method definition documentation see the {syntax documentation for
+ methods}[rdoc-ref:syntax/methods.rdoc].
+@@ -146,8 +180,8 @@
+ 
+   include A
+ 
+-  p self.class.ancestors #=> [Object, A, Kernel, BasicObject]
+-  p z #=> 1
++  self.is_a? A #=> true
++  z #=> 1
+ 
+ === Visibility
+ 
+@@ -163,6 +197,7 @@
+ state to any caller and would like to restrict it only to inherited classes.
+ 
+ Here is an example:
++:rdx: new_binding
+ 
+   class A
+     def n(other)
+@@ -186,9 +221,9 @@
+   b = B.new
+   c = C.new
+ 
+-  c.n b #=> 1 -- C is a subclass of B
+-  b.n b #=> 1 -- m called on defining class
+-  a.n b # raises NoMethodError A is not a subclass of B
++  c.n b #=> 1 # C is a subclass of B
++  b.n b #=> 1 # m called on defining class
++  a.n b # raises NoMethodError # A is not a subclass of B
+ 
+ The third visibility is +private+.  A private method may not be called with a
+ receiver, not even +self+.  If a private method is called with a receiver a
+@@ -201,6 +236,7 @@
+ section}[rdoc-ref:syntax/miscellaneous.rdoc] for documentation.
+ 
+ = Classes
++:rdx: new_binding
+ 
+ Every class is also a module, but unlike modules a class may not be mixed-in to
+ another module (or class).  Like a module, a class can be used as a namespace.
+@@ -242,9 +278,10 @@
+   class B < A
+   end
+ 
+-  p B.new.z #=> 1
++  B.new.z #=> 1
+ 
+ The same is true for constants:
++:rdx: new_binding
+ 
+   class A
+     Z = 1
+@@ -256,7 +293,7 @@
+     end
+   end
+ 
+-  p B.new.z #=> 1
++  B.new.z #=> 1
+ 
+ You can override the functionality of a superclass method by redefining the
+ method:
+@@ -273,7 +310,7 @@
+     end
+   end
+ 
+-  p B.new.m #=> 2
++  B.new.m #=> 2
+ 
+ If you wish to invoke the superclass functionality from a method use +super+:
+ 
+@@ -289,7 +326,7 @@
+     end
+   end
+ 
+-  p B.new.m #=> 3
++  B.new.m #=> 3
+ 
+ When used without any arguments +super+ uses the arguments given to the
+ subclass method.  To send no arguments to the superclass method use

data/examples/ruby-2.0.0-p0/install/core/diffs/doc/syntax/precedence.rdoc.diff

@@ -0,0 +1,8 @@
+--- core/orig/doc/syntax/precedence.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/precedence.rdoc	2015-06-19 07:43:40 +0000
+@@ -1,4 +1,5 @@
+ = Precedence
++:rdx: off
+ 
+ From highest to lowest, this is the precedence table for ruby.  High precedence
+ operations happen before low precedence operations.

data/examples/ruby-2.0.0-p0/install/core/diffs/doc/syntax/refinements.rdoc.diff

@@ -0,0 +1,146 @@
+--- core/orig/doc/syntax/refinements.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/refinements.rdoc	2015-06-19 07:46:50 +0000
+@@ -11,14 +11,14 @@
+ 
+ Refinements are an experimental feature in Ruby 2.0.  At the time of writing,
+ refinements are expected to exist in future versions of Ruby but the
+-specification of refinements may change.  You will receive a warning the first
+-time you define or activate a refinement.
++specification of refinements may change.
+ 
+ Here is a basic refinement:
++:rdx: toplevel
+ 
+   class C
+     def foo
+-      puts "C#foo
++      puts "C#foo"
+     end
+   end
+ 
+@@ -30,6 +30,11 @@
+     end
+   end
+ 
++You will receive a warning the first time you define or activate a refinement:
++:rdx: stderr
++
++  warning: Refinements are experimental, and the behavior may change in future versions of Ruby!
++
+ First, a class +C+ is defined.  Next a refinement for +C+ is created using
+ Module#refine.  Refinements only modify classes, not modules so the argument
+ must be a class.
+@@ -42,9 +47,14 @@
+ 
+   using M
+ 
+-  x = C.new
++  c = C.new
+ 
+-  c.foo # prints "C#foo in M"
++  c.foo # prints: C#foo in M
++
++-- rdx
++  Object.send :remove_const, :C
++  Object.send :remove_const, :M
++++
+ 
+ == Scope
+ 
+@@ -75,20 +85,25 @@
+   using M
+ 
+   x = C.new
+-  x.foo       # prints "C#foo in M"
+-  call_foo(x) #=> raises NoMethodError
++  x.foo       # prints: C#foo in M
++  call_foo(x) # raises NoMethodError
++
++-- rdx
++  Object.send :remove_const, :C
++  Object.send :remove_const, :M
++  Object.send :remove_method, :call_foo
++++
+ 
+ If a method is defined in a scope where a refinement is active the refinement
+ will be active when the method is called.  This example spans multiple files:
+ 
+-c.rb:
+-
++  # File: c.rb
+   class C
+   end
+ 
+-m.rb:
+-
+-  require "c"
++:rdx: # start a new example, so that implicit directives kicks in again
++  # File: m.rb
++  load File.expand_path 'c.rb'
+ 
+   module M
+     refine C do
+@@ -98,9 +113,9 @@
+     end
+   end
+ 
+-m_user.rb:
+-
+-  require "m"
++:rdx:
++  # File: m_user.rb
++  load File.expand_path 'm.rb'
+ 
+   using M
+ 
+@@ -110,14 +125,20 @@
+     end
+   end
+ 
+-main.rb:
+-
+-  require "m_user"
++:rdx:
++  # in main:
++  load File.expand_path 'm_user.rb'
+ 
+   x = C.new
+   m_user = MUser.new
+-  m_user.call_foo(x) # prints "C#foo in M"
+-  x.foo              #=> raises NoMethodError
++  m_user.call_foo(x) # prints: C#foo in M
++  x.foo              # raises NoMethodError
++
++-- rdx
++  Object.send :remove_const, :C
++  Object.send :remove_const, :M
++  Object.send :remove_const, :MUser
++++
+ 
+ Since the refinement +M+ is active in <code>m_user.rb</code> where
+ <code>MUser#call_foo</code> is defined it is also active when
+@@ -127,6 +148,7 @@
+ are examples of where a refinement +M+ is and is not active.
+ 
+ In a file:
++:rdx: off
+ 
+   # not activated here
+   using M
+@@ -161,6 +183,7 @@
+ When defining multiple refinements in the same module, inside a refine block
+ all refinements from the same module are active when a refined method is
+ called:
++:rdx: on
+ 
+   module ToJSON
+     refine Integer do
+@@ -184,7 +207,7 @@
+ 
+   using ToJSON
+ 
+-  p [{1=>2}, {3=>4}].to_json # prints "[{\"1\":2},{\"3\":4}]"
++  puts [{1=>2}, {3=>4}].to_json # prints [{"1":2},{"3":4}]
+ 
+ == Method Lookup
+ 

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

@@ -0,0 +1,276 @@
+--- core/orig/encoding.c	2015-06-11 07:51:44 +0000
++++ core/patched/encoding.c	2015-06-28 11:38:56 +0000
+@@ -1022,7 +1022,7 @@
+  *
+  * Returns the list of name and aliases of the encoding.
+  *
+- *   Encoding::WINDOWS_31J.names  #=> ["Windows-31J", "CP932", "csWindows31J"]
++ *   Encoding::WINDOWS_31J.names  #=> ["Windows-31J", "CP932", "csWindows31J", "SJIS", "PCK"]
+  */
+ static VALUE
+ enc_names(VALUE self)
+@@ -1042,15 +1042,13 @@
+  * Returns the list of loaded encodings.
+  *
+  *   Encoding.list
+- *   #=> [#<Encoding:ASCII-8BIT>, #<Encoding:UTF-8>,
+- *         #<Encoding:ISO-2022-JP (dummy)>]
++ *   #-> [Encoding::ASCII_8BIT, Encoding::UTF_8]
+  *
+  *   Encoding.find("US-ASCII")
+- *   #=> #<Encoding:US-ASCII>
++ *   #=> Encoding::US_ASCII
+  *
+  *   Encoding.list
+- *   #=> [#<Encoding:ASCII-8BIT>, #<Encoding:UTF-8>,
+- *         #<Encoding:US-ASCII>, #<Encoding:ISO-2022-JP (dummy)>]
++ *   #-> [Encoding::ASCII_8BIT, Encoding::UTF_8, Encoding::US_ASCII]
+  *
+  */
+ static VALUE
+@@ -1069,8 +1067,9 @@
+  * Search the encoding with specified <i>name</i>.
+  * <i>name</i> should be a string or symbol.
+  *
+- *   Encoding.find("US-ASCII")  #=> #<Encoding:US-ASCII>
+- *   Encoding.find(:Shift_JIS)  #=> #<Encoding:Shift_JIS>
++ *   Encoding.find("US-ASCII")  #=> Encoding::US_ASCII
++ * :rdx: bug symbols aren't accepted
++ *   Encoding.find(:Shift_JIS)  #=> Encoding::Shift_JIS
+  *
+  * Names which this method accept are encoding names and aliases
+  * including following special aliases
+@@ -1107,7 +1106,7 @@
+  * if they are compatible, nil if they are not.
+  *
+  *   Encoding.compatible?("\xa1".force_encoding("iso-8859-1"), "b")
+- *   #=> #<Encoding:ISO-8859-1>
++ *   #=> Encoding::ISO_8859_1
+  *
+  *   Encoding.compatible?(
+  *     "\xa1".force_encoding("iso-8859-1"),
+@@ -1454,18 +1453,20 @@
+  *
+  * Returns the locale charmap name.
+  * It returns nil if no appropriate information.
++ * 
++ * :rdx: off
+  *
+- *   Debian GNU/Linux
+- *     LANG=C
+- *       Encoding.locale_charmap  #=> "ANSI_X3.4-1968"
+- *     LANG=ja_JP.EUC-JP
+- *       Encoding.locale_charmap  #=> "EUC-JP"
+- *
+- *   SunOS 5
+- *     LANG=C
+- *       Encoding.locale_charmap  #=> "646"
+- *     LANG=ja
+- *       Encoding.locale_charmap  #=> "eucJP"
++ *   # on Debian GNU/Linux
++ *   $ LANG=C ruby -e 'puts Encoding.locale_charmap'
++ *   ANSI_X3.4-1968
++ *   $ LANG=ja_JP.EUC-JP ruby -e 'puts Encoding.locale_charmap'
++ *   EUC-JP
++ *   
++ *   # on SunOS 5
++ *   $ LANG=C ruby -e 'puts Encoding.locale_charmap'
++ *   646
++ *   $ LANG=ja_JP.EUC-JP ruby -e 'puts Encoding.locale_charmap'
++ *   eucJP
+  *
+  * The result is highly platform dependent.
+  * So Encoding.find(Encoding.locale_charmap) may cause an error.
+@@ -1569,10 +1570,12 @@
+  * Returns the list of available encoding names.
+  *
+  *   Encoding.name_list
+- *   #=> ["US-ASCII", "ASCII-8BIT", "UTF-8",
+- *         "ISO-8859-1", "Shift_JIS", "EUC-JP",
+- *         "Windows-31J",
+- *         "BINARY", "CP932", "eucJP"]
++ *   # -> ["US-ASCII", "ASCII-8BIT", "UTF-8",
++ *   #       "ISO-8859-1", "Shift_JIS", "EUC-JP",
++ *   #       "Windows-31J",
++ *   #       "BINARY", "CP932", "eucJP",
++ *   #       # ...
++ *   #    ]
+  *
+  */
+ 
+@@ -1616,8 +1619,10 @@
+  * Returns the hash of available encoding alias and original encoding name.
+  *
+  *   Encoding.aliases
+- *   #=> {"BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII",
+- *         "SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J"}
++ *   #-> { "BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII",
++ *   #      "SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J",
++ *   #      # ...
++ *   #   }
+  *
+  */
+ 
+@@ -1637,7 +1642,7 @@
+  * optionally, aliases:
+  *
+  *   Encoding::ISO_8859_1.name
+- *   #=> #<Encoding:ISO-8859-1>
++ *   #=> "ISO-8859-1"
+  *
+  *   Encoding::ISO_8859_1.names
+  *   #=> ["ISO-8859-1", "ISO8859-1"]
+@@ -1647,12 +1652,12 @@
+  * can be passed an Encoding name or alias instead).
+  *
+  *   "some string".encoding
+- *   #=> #<Encoding:UTF-8>
++ *   #=> Encoding::UTF_8
+  *
+  *   string = "some string".encode(Encoding::ISO_8859_1)
+  *   #=> "some string"
+  *   string.encoding
+- *   #=> #<Encoding:ISO-8859-1>
++ *   #=> Encoding::ISO_8859_1
+  *
+  *   "some string".encode "ISO-8859-1"
+  *   #=> "some string"
+@@ -1672,12 +1677,12 @@
+  * String#force_encoding. This is how you can tell Ruby the correct encoding
+  * of a string.
+  *
+- *   string
+- *   #=> "R\xC3\xA9sum\xC3\xA9"
++ *   string = "R\xC3\xA9sum\xC3\xA9"
+  *   string.encoding
+- *   #=> #<Encoding:ISO-8859-1>
+- *   string.force_encoding(Encoding::UTF-8)
+- *   #=> "R\u00E9sum\u00E9"
++ *   #=> Encoding::UTF_8
++ *   string.force_encoding(Encoding::ISO_8859_1)
++ *   #=> "R\xC3\xA9sum\xC3\xA9"
++ *   # same bytes!
+  *
+  * Second, it is possible to transcode a string, i.e. translate its internal
+  * byte representation to another encoding. Its associated encoding is also
+@@ -1685,14 +1690,14 @@
+  * transcoding, and the Encoding::Converter class for additional control over
+  * the transcoding process.
+  *
+- *   string
+- *   #=> "R\u00E9sum\u00E9"
++ *   string = "R\xC3\xA9sum\xC3\xA9"
+  *   string.encoding
+- *   #=> #<Encoding:UTF-8>
+- *   string = string.encode!(Encoding::ISO_8859_1)
++ *   #=> Encoding::UTF_8
++ *   string.encode!(Encoding::ISO_8859_1)
+  *   #=> "R\xE9sum\xE9"
++ *   # bytes have been changed!
+  *   string.encoding
+- *   #=> #<Encoding::ISO-8859-1>
++ *   #=> Encoding::ISO_8859_1
+  *
+  * == Script encoding
+  *
+@@ -1708,7 +1713,7 @@
+  *   # encoding: UTF-8
+  *
+  *   "some string".encoding
+- *   #=> #<Encoding:UTF-8>
++ *   #=> Encoding::UTF_8
+  *
+  * The <code>__ENCODING__</code> keyword returns the script encoding of the file
+  * which the keyword is written:
+@@ -1716,7 +1721,7 @@
+  *   # encoding: ISO-8859-1
+  *
+  *   __ENCODING__
+- *   #=> #<Encoding:ISO-8859-1>
++ *   #=> Encoding::ISO_8859_1
+  *
+  * <code>ruby -K</code> will change the default locale encoding, but this is
+  * not recommended. Ruby source files should declare its script encoding by a
+@@ -1744,17 +1749,17 @@
+  * encoding is set by locale encoding or the interpreter <code>-E</code> option.
+  * Encoding.default_external returns the current value of the external
+  * encoding.
+- *
+- *   ENV["LANG"]
+- *   #=> "UTF-8"
+- *   Encoding.default_external
+- *   #=> #<Encoding:UTF-8>
+- *
++ * 
++ * :rdx: off
++ * 
++ *   $ LANG="UTF-8" ruby -e 'p Encoding.default_external'
++ *   #<Encoding:UTF-8>
+  *   $ ruby -E ISO-8859-1 -e "p Encoding.default_external"
+  *   #<Encoding:ISO-8859-1>
+- *
+  *   $ LANG=C ruby -e 'p Encoding.default_external'
+  *   #<Encoding:US-ASCII>
++ * 
++ * :rdx: on
+  *
+  * The default external encoding may also be set through
+  * Encoding.default_external=, but you should not do this as strings created
+@@ -1788,9 +1793,8 @@
+  *
+  *    $ ruby -e 'p Encoding.default_internal'
+  *    nil
+- *
+  *    $ ruby -E ISO-8859-1:UTF-8 -e "p [Encoding.default_external, \
+- *      Encoding.default_internal]"
++ *    > Encoding.default_internal]"
+  *    [#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>]
+  *
+  * The default internal encoding may also be set through
+@@ -1801,8 +1805,14 @@
+  * == IO encoding example
+  *
+  * In the following example a UTF-8 encoded string "R\u00E9sum\u00E9" is transcoded for
+- * output to ISO-8859-1 encoding, then read back in and transcoded to UTF-8:
+- *
++ * output to ISO-8859-1 encoding, then read back in and transcoded to UTF-8.
++ * 
++ * While writing the file, the internal encoding is not specified as it is
++ * only necessary for reading.  While reading the file both the internal and
++ * external encoding must be specified to obtain the correct result:
++ * 
++ * :rdx: in_tmpdir
++ * 
+  *   string = "R\u00E9sum\u00E9"
+  *
+  *   open("transcoded.txt", "w:ISO-8859-1") do |io|
+@@ -1810,24 +1820,21 @@
+  *   end
+  *
+  *   puts "raw text:"
+- *   p File.binread("transcoded.txt")
++ *   puts File.binread("transcoded.txt").dump
+  *   puts
+  *
+  *   open("transcoded.txt", "r:ISO-8859-1:UTF-8") do |io|
+  *     puts "transcoded text:"
+- *     p io.read
++ *     puts io.read.dump
+  *   end
+  *
+- * While writing the file, the internal encoding is not specified as it is
+- * only necessary for reading.  While reading the file both the internal and
+- * external encoding must be specified to obtain the correct result.
+- *
+- *   $ ruby t.rb
++ * produces:
++ * 
+  *   raw text:
+  *   "R\xE9sum\xE9"
+  *
+  *   transcoded text:
+- *   "R\u00E9sum\u00E9"
++ *   "R\u{e9}sum\u{e9}"
+  *
+  */
+