rdx 0.9.0.pre

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

@@ -0,0 +1,130 @@
+--- core/orig/doc/syntax/calling_methods.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/calling_methods.rdoc	2015-06-28 11:43:44 +0000
+@@ -1,4 +1,5 @@
+ = Calling Methods
++:rdx: off
+ 
+ Calling a method sends a message to an object so it can perform some work.
+ 
+@@ -77,12 +78,13 @@
+ 
+ If the method definition doesn't include keyword arguments the keyword or
+ hash-type arguments are assigned as a single hash to the last argument:
++:rdx: on
+ 
+   def my_method(options)
+     p options
+   end
+ 
+-  my_method('a' => 1, b: 2) # prints: {'a'=>1, :b=>2}
++  my_method('a' => 1, b: 2) # prints: {"a"=>1, :b=>2}
+ 
+ If too many positional arguments are given an ArgumentError is raised.
+ 
+@@ -101,15 +103,11 @@
+ Here +c+ and +d+ have default values which ruby will apply for you.  If you
+ send only two arguments to this method:
+ 
+-  my_method(1, 2)
+-
+-You will see ruby print <code>[1, 2, 3, 4]</code>.
++  my_method(1, 2) # prints [1, 2, 3, 4]
+ 
+ If you send three arguments:
+ 
+-  my_method(1, 2, 5)
+-
+-You will see ruby print <code>[1, 2, 5, 4]</code>
++  my_method(1, 2, 5) # prints [1, 2, 5, 4]
+ 
+ Ruby fills in the missing arguments from left to right.
+ 
+@@ -123,15 +121,11 @@
+ Here +b+ and +c+ have default values.  If you send only two arguments to this
+ method:
+ 
+-  my_method(1, 4)
+-
+-You will see ruby print <code>[1, 2, 3, 4]</code>.
++  my_method(1, 4) # prints [1, 2, 3, 4]
+ 
+ If you send three arguments:
+ 
+-  my_method(1, 5, 6)
+-
+-You will see ruby print <code>[1, 5, 3, 6]</code>.
++  my_method(1, 5, 6) # prints [1, 5, 3, 6]
+ 
+ Describing this in words gets complicated and confusing. I'll describe it
+ in variables and values instead.
+@@ -142,6 +136,7 @@
+ +c+ uses its default value of <code>3</code>.
+ 
+ === Keyword Arguments
++:rdx: off
+ 
+ Keyword arguments follow any positional arguments and are separated by commas
+ like positional arguments:
+@@ -194,6 +189,7 @@
+   end
+ 
+ ==== Block Local Arguments
++:rdx: on
+ 
+ You may also declare block-local arguments to a block using <code>;</code> in
+ the block arguments list.  Assigning to a block-local argument will not
+@@ -212,17 +208,26 @@
+ 
+   puts "place is: #{place}"
+ 
+-This prints:
++Produces:
+ 
+   hello main this is block
+-  place is world
++  place is: world
+ 
+ So the +place+ variable in the block is not the same +place+ variable as
+ outside the block.  Removing <code>; place</code> from the block arguments
+ gives this result:
++-- rdx
++  place = "world"
++  my_method do |obj|
++    place = "block"
++    puts "hello #{obj} this is #{place}"
++  end
++  puts "place is: #{place}"
++:rdx: output
++++
+ 
+   hello main this is block
+-  place is block
++  place is: block
+ 
+ === Array to Arguments Conversion
+ 
+@@ -288,13 +293,14 @@
+ If the method definition uses <code>**</code> to gather arbitrary keyword
+ arguments they will not be gathered by <code>*</code>:
+ 
++:rdx: bug   on x64-mingw32 (but not on i386-mingw32) "3"=>4 is not captured by keywords
+   def my_method(*a, **kw)
+     p arguments: a, keywords: kw
+   end
+ 
+   my_method(1, 2, '3' => 4, five: 6)
+ 
+-Prints:
++Produces:
+ 
+   {:arguments=>[1, 2], :keywords=>{"3"=>4, :five=>6}}
+ 
+@@ -314,7 +320,7 @@
+ 
+   argument = proc { |a| puts "#{a.inspect} was yielded" }
+ 
+-  my_method(&argument)
++  my_method(&argument) # prints: main was yielded
+ 
+ If the splat operator comes first in the call, parenthesis must be used to
+ avoid a warning.

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

@@ -0,0 +1,254 @@
+--- core/orig/doc/syntax/control_expressions.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/control_expressions.rdoc	2015-06-25 13:32:24 +0000
+@@ -19,13 +19,17 @@
+     puts "the test resulted in a true-value"
+   end
+ 
+-This will print "the test resulted in a true-value".
++Produces
++
++  the test resulted in a true-value
+ 
+ The +then+ is optional:
+ 
++:rdx: off
+   if true
+     puts "the test resulted in a true-value"
+   end
++:rdx: on
+ 
+ This document will omit the optional +then+ for all expressions as that is the
+ most common usage of +if+.
+@@ -39,7 +43,8 @@
+     puts "the test resulted in a false-value"
+   end
+ 
+-This will print "the test resulted in a false-value".
++Produces
++  the test resulted in a false-value
+ 
+ You may add an arbitrary number of extra tests to an if expression using
+ +elsif+.  An +elsif+ executes when all tests above the +elsif+ are false.
+@@ -54,15 +59,17 @@
+     puts "a is some other value"
+   end
+ 
+-This will print "a is one" as <code>1</code> is not equal to <code>0</code>.
+-Since +else+ is only executed when there are no matching conditions.
++Produces:
+ 
+-Once a condition matches, either the +if+ condition or any +elsif+ condition,
+-the +if+ expression is complete and no further tests will be performed.
++  a is one
++
++as <code>1</code> is not equal to <code>0</code>.
++Since +else+ is only executed when there are no matching conditions.
+ 
+ Like an +if+, an +elsif+ condition may be followed by a +then+.
+ 
+-In this example only "a is one" is printed:
++Once a condition matches, either the +if+ condition or any +elsif+ condition,
++the +if+ expression is complete and no further tests will be performed:
+ 
+   a = 1
+ 
+@@ -76,9 +83,15 @@
+     puts "a is some other value"
+   end
+ 
++Produces
++
++  a is one
++
+ The tests for +if+ and +elsif+ may have side-effects.  The most common use of
+ side-effect is to cache a value into a local variable:
+ 
++:rdx: off
++
+   if a = object.some_value
+     # do something to a
+   end
+@@ -108,6 +121,7 @@
+ expression as this can be confusing.
+ 
+ == +unless+ Expression
++:rdx: on
+ 
+ The +unless+ expression is the opposite of the +if+ expression.  If the value
+ is false the "then" expression is executed:
+@@ -134,7 +148,11 @@
+     puts "the value is true"
+   end
+ 
+-This prints "the value is true" from the +else+ condition.
++Produces
++
++  the value is true
++
++from the +else+ condition.
+ 
+ You may not use +elsif+ with an +unless+ expression.
+ 
+@@ -148,28 +166,23 @@
+ is the "test" expression:
+ 
+   a = 0
+-
+   a += 1 if a.zero?
+-
+-  p a
+-
+-This will print 1.
++  p a # prints 1
+ 
+   a = 0
+-
+   a += 1 unless a.zero?
+-
+-  p a
+-
+-This will print 0.
++  p a # prints 0
+ 
+ While the modifier and standard versions have both a "test" expression and a
+ "then" expression, they are not exact transformations of each other due to
+ parse order.  Here is an example that shows the difference:
++:rdx: new_binding
+ 
+   p a if a = 0.zero?
+ 
+-This raises the NameError "undefined local variable or method `a'".
++raises
++
++  undefined local variable or method `a' (NameError)
+ 
+ When ruby parses this expression it first encounters +a+ as a method call in
+ the "then" expression, then later it sees the assignment to +a+ in the "test"
+@@ -197,9 +210,9 @@
+ 
+   case "12345"
+   when /^1/
+-    puts "the string starts with one"
++    # the string starts with one
+   else
+-    puts "I don't know what the string starts with"
++    # I don't know what the string starts with
+   end
+ 
+ Here the string <code>"12345"</code> is compared with <code>/^1/</code> by
+@@ -214,14 +227,14 @@
+ 
+   case "12345"
+   when /^1/
+-    puts "the string starts with one"
++    # the string starts with one
+   end
+ 
+ You may place multiple conditions on the same +when+:
+ 
+   case "2"
+   when /^1/, "2"
+-    puts "the string starts with one or is '2'"
++    # the string starts with one or is '2'
+   end
+ 
+ Ruby will try each condition in turn, so first <code>/^1/ === "2"</code>
+@@ -231,23 +244,26 @@
+ You may use +then+ after the +when+ condition.  This is most frequently used
+ to place the body of the +when+ on a single line.
+ 
++:rdx: off
+   case a
+-  when 1, 2 then puts "a is one or two
++  when 1, 2 then puts "a is one or two"
+   when 3    then puts "a is three"
+   else           puts "I don't know what a is"
+   end
+ 
++
+ The other way to use a +case+ expression is like an if-elsif expression:
++:rdx: on
+ 
+   a = 2
+ 
+   case
+   when a == 1, a == 2
+-    puts "a is one or two"
++    # a is one or two
+   when a == 3
+-    puts "a is three"
++    # a is three
+   else
+-    puts "I don't know what a is"
++    # I don't know what a is
+   end
+ 
+ Again, the +then+ and +else+ are optional.
+@@ -256,6 +272,7 @@
+ expression.
+ 
+ == +while+ Loop
++:rdx: off
+ 
+ The +while+ loop executes while a condition is true:
+ 
+@@ -306,6 +323,7 @@
+ used.
+ 
+ == +for+ Loop
++:rdx: on
+ 
+ The +for+ loop consists of +for+ followed by a variable to contain the
+ iteration argument followed by +in+ and the value to iterate over using #each.
+@@ -315,7 +333,11 @@
+     puts value
+   end
+ 
+-Prints 1, 2 and 3.
++Produces
++
++  1
++  2
++  3
+ 
+ Like +while+ and +until+, the +do+ is optional.
+ 
+@@ -360,6 +382,7 @@
+ handling overhead.
+ 
+ == +break+ Statement
++:rdx: off
+ 
+ Use +break+ to leave a block early.  This will stop iterating over the items in +values+ if one of them is even:
+ 
+@@ -370,6 +393,7 @@
+   end
+ 
+ You can also terminate from a +while+ loop using +break+:
++:rdx: on
+ 
+   a = 0
+ 
+@@ -382,7 +406,10 @@
+ 
+   p a
+ 
+-This prints the numbers 0 and 1.
++Produces
++
++  0
++  1
+ 
+ +break+ accepts a value that supplies the result of the expression it is
+ "breaking" out of:
+@@ -430,9 +457,7 @@
+     result << result.length + 1
+   end
+ 
+-  p result
+-
+-This prints [0, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11]
++  p result # prints [0, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11]
+ 
+ In Ruby 1.8 you could also use +retry+ where you used +redo+.  This is no
+ longer true, now you will receive a SyntaxError when you use +retry+ outside

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

@@ -0,0 +1,54 @@
+--- core/orig/doc/syntax/literals.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/literals.rdoc	2015-06-25 17:35:23 +0000
+@@ -89,7 +89,7 @@
+ Double-quote strings allow interpolation of other values using
+ <tt>#{...}</tt>:
+ 
+-  "One plus one is two: #{1 + 1}"
++  "One plus one is two: #{1 + 1}" #=> "One plus one is two: 2"
+ 
+ Any expression may be placed inside the interpolated section, but it's best to
+ keep the expression small for readability.
+@@ -149,15 +149,18 @@
+   One plus one is #{1 + 1}
+   EXPECTED
+ 
+-  p expected_result # prints: "One plus one is \#{1 + 1}\n"
++  expected_result # => "One plus one is \#{1 + 1}\n"
+ 
+ The identifier may also be surrounded with double quotes (which is the same as
+ no quotes) or with backticks.  When surrounded by backticks the HEREDOC
+ behaves like Kernel#`:
+ 
+-  puts <<-`HEREDOC`
+-  cat #{__FILE__}
++:rdx: off -
++  heredoc = <<-`HEREDOC`
++  cat "#{__FILE__}"
+   HEREDOC
++  # If the shell command cat is available:
++  # heredoc == File.read(__FILE__)
+ 
+ To call a method on a heredoc place it after the opening identifier:
+ 
+@@ -174,6 +177,11 @@
+   content for heredoc two
+   TWO
+ 
++produces
++
++  content for heredoc one
++  content for heredoc two
++
+ == Symbols
+ 
+ A Symbol represents a name inside the ruby interpreter.  See Symbol for more
+@@ -191,7 +199,7 @@
+ 
+ Like strings, a single-quote may be used to disable interpolation:
+ 
+-  :"my_symbol#{1 + 1}" #=> :"my_symbol\#{1 + 1}"
++  :'my_symbol#{1 + 1}' #=> :"my_symbol\#{1 + 1}"
+ 
+ When creating a Hash there is a special syntax for referencing a Symbol as
+ well.

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

@@ -0,0 +1,157 @@
+--- core/orig/doc/syntax/methods.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/methods.rdoc	2015-06-19 07:38:11 +0000
+@@ -82,7 +82,7 @@
+ 
+   obj = C.new
+ 
+-  -obj # prints "you inverted this object"
++  -obj # prints: you inverted this object
+ 
+ Unary methods accept zero arguments.
+ 
+@@ -152,13 +152,16 @@
+     self + ", world!"
+   end
+ 
+-  greeting.broaden # returns "Hello, world!"
++  greeting.broaden # => "Hello, world!"
+ 
+ +self+ is a keyword referring to the current object under consideration
+ by the compiler, which might make the use of +self+ in defining a class
+ method above a little clearer.  Indeed, the example of adding a +hello+
+ method to the class +String+ can be rewritten thus:
+ 
++-- rdx
++  String = 'Not true ::String'
++++
+   def String.hello
+     "Hello, world!"
+   end
+@@ -172,23 +175,32 @@
+ method already exists: it simply redefines it.  This is called
+ _overriding_.  Rather like extending core classes, this is a potentially
+ dangerous ability, and should be used sparingly because it can cause unexpected
+-results.  For example, consider this irb session:
++results.  For example, consider the following:
+ 
+-  >> "43".to_i
+-  => 43
+-  >> class String
+-  >>   def to_i
+-  >>     42
+-  >>   end
+-  >> end
+-  => nil
+-  >> "43".to_i
+-  => 42
++:rdx: toplevel
++
++  "43".to_i #=> 43
++  class String
++-- rdx
++    alias rdx_doc_methods_to_i to_i
++++
++    def to_i
++      42
++    end
++  end
++  "43".to_i #=> 42
++-- rdx
++  class String
++    alias to_i rdx_doc_methods_to_i
++    remove_method :rdx_doc_methods_to_i
++  end
++++
+ 
+ This will effectively sabotage any code which makes use of the method
+ <code>String#to_i</code> to parse numbers from strings.
+ 
+ == Arguments
++:rdx: new_binding
+ 
+ A method may accept arguments.  The argument list follows the method name:
+ 
+@@ -231,12 +243,15 @@
+     a + b + c
+   end
+ 
+-This will raise a SyntaxError:
++But this
+ 
+   def add_values(a = 1, b, c = 1)
+     a + b + c
+   end
+ 
++will raise a SyntaxError.
++:rdx: error SyntaxError
++
+ === Array Decomposition
+ 
+ You can decompose (unpack or extract values from) an Array using extra
+@@ -248,7 +263,7 @@
+ 
+   my_method([1, 2])
+ 
+-This prints:
++produces
+ 
+   {:a=>1, :b=>2}
+ 
+@@ -260,6 +275,8 @@
+ 
+   my_method([1, 2, 3])
+ 
++:rdx: output {:a=>1, :b=>2}
++
+ This has the same output as above.
+ 
+ You can use a <code>*</code> to collect the remaining arguments.  This splits
+@@ -271,7 +288,7 @@
+ 
+   my_method([1, 2, 3])
+ 
+-This prints:
++produces
+ 
+   {:a=>1, :b=>[2, 3]}
+ 
+@@ -288,7 +305,7 @@
+ 
+   my_method(1, 2, 3)
+ 
+-This prints:
++produces
+ 
+   {:a=>1, :b=>2, :c=>nil, :d=>3}
+ 
+@@ -324,7 +341,7 @@
+   end
+ 
+   gather_arguments_keyword 1, 2, three: 3
+-  #=> raises: unknown keyword: three (ArgumentError)
++  # raises ArgumentError: unknown keyword: three
+ 
+ Also, note that a bare <code>*</code> can be used to ignore arguments:
+ 
+@@ -346,7 +363,11 @@
+   end
+ 
+   gather_arguments first: 1, second: 2, third: 3
+-  # prints 1 then {:second=>2, :third=>3}
++
++produces
++
++  1
++  {:second=>2, :third=>3}
+ 
+ When calling a method with keyword arguments the arguments may appear in any
+ order.  If an unknown keyword argument is sent by the caller an ArgumentError
+@@ -360,7 +381,7 @@
+ The block argument is indicated by <code>&</code> and must come last:
+ 
+   def my_method(&my_block)
+-    my_method.call(self)
++    my_block.call(self)
+   end
+ 
+ Most frequently the block argument is used to pass a block to another method: