rdx 0.9.0.pre

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

@@ -0,0 +1,328 @@
+--- core/orig/doc/re.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/re.rdoc	2015-06-28 09:45:49 +0000
+@@ -11,7 +11,7 @@
+ example:
+ 
+     /hay/ =~ 'haystack'   #=> 0
+-    /y/.match('haystack') #=> #<MatchData "y">
++    /y/.match('haystack') # > #<MatchData "y">
+ 
+ If a string contains the pattern it is said to <i>match</i>. A literal
+ string matches itself.
+@@ -19,7 +19,7 @@
+     # 'haystack' does not contain the pattern 'needle', so doesn't match.
+     /needle/.match('haystack') #=> nil
+     # 'haystack' does contain the pattern 'hay', so it matches
+-    /hay/.match('haystack')    #=> #<MatchData "hay">
++    /hay/.match('haystack')    # > #<MatchData "hay">
+ 
+ Specifically, <tt>/st/</tt> requires that the string contains the letter
+ _s_ followed by the letter _t_, so it matches _haystack_, also.
+@@ -52,7 +52,7 @@
+ 
+ #match method return a MatchData object :
+ 
+-    /st/.match('haystack')   #=> #<MatchData "st">
++    /st/.match('haystack')   # > #<MatchData "st">
+ 
+ == Metacharacters and Escapes
+ 
+@@ -62,20 +62,23 @@
+ pattern. To match them literally they must be backslash-escaped. To match
+ a backslash literally backslash-escape that: <tt>\\\\\\</tt>.
+ 
+-    /1 \+ 2 = 3\?/.match('Does 1 + 2 = 3?') #=> #<MatchData "1 + 2 = 3?">
++    /1 \+ 2 = 3\?/.match('Does 1 + 2 = 3?') # > #<MatchData "1 + 2 = 3?">
+ 
+ Patterns behave like double-quoted strings so can contain the same
+ backslash escapes.
+ 
++:rdx: if Encoding.default_external == Encoding::UTF_8
++:rdx: # otherwise istead of the char "\u6771" it gives "\\u6771"
+     /\s\u{6771 4eac 90fd}/.match("Go to 東京都")
+-        #=> #<MatchData " 東京都">
++        # > #<MatchData " 東京都">
+ 
+ Arbitrary Ruby expressions can be embedded into patterns with the
+ <tt>#{...}</tt> construct.
+ 
++:rdx: if Encoding.default_external == Encoding::UTF_8
+     place = "東京都"
+     /#{place}/.match("Go to 東京都")
+-        #=> #<MatchData "東京都">
++        # > #<MatchData "東京都">
+ 
+ == Character Classes
+ 
+@@ -84,7 +87,7 @@
+ match. <tt>/[ab]/</tt> means _a_ or _b_, as opposed to <tt>/ab/</tt> which
+ means _a_ followed by _b_.
+ 
+-    /W[aeiou]rd/.match("Word") #=> #<MatchData "Word">
++    /W[aeiou]rd/.match("Word") # > #<MatchData "Word">
+ 
+ Within a character class the hyphen (<tt>-</tt>) is a metacharacter
+ denoting an inclusive range of characters. <tt>[abcd]</tt> is equivalent
+@@ -93,13 +96,13 @@
+ ranges or individual characters appear inside a character class is
+ irrelevant.
+ 
+-    /[0-9a-f]/.match('9f') #=> #<MatchData "9">
+-    /[9f]/.match('9f')     #=> #<MatchData "9">
++    /[0-9a-f]/.match('9f') # > #<MatchData "9">
++    /[9f]/.match('9f')     # > #<MatchData "9">
+ 
+ If the first character of a character class is a caret (<tt>^</tt>) the
+ class is inverted: it matches any character _except_ those named.
+ 
+-    /[^a-eg-z]/.match('f') #=> #<MatchData "f">
++    /[^a-eg-z]/.match('f') # > #<MatchData "f">
+ 
+ A character class may contain another character class. By itself this
+ isn't useful because <tt>[a-z[0-9]]</tt> describes the same set as
+@@ -107,7 +110,7 @@
+ operator which performs set intersection on its arguments. The two can be
+ combined as follows:
+ 
+-    /[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
++    /[a-w&&[^c-g]z]/ # means [a-w] AND ([^c-g] OR z)
+     # This is equivalent to:
+     /[abh-w]/
+ 
+@@ -153,10 +156,12 @@
+   <i>Connector_Punctuation</i>
+ * <tt>/[[:ascii:]]/</tt> - A character in the ASCII character set
+ 
++:rdx: if Encoding.default_external == Encoding::UTF_8
+     # U+06F2 is "EXTENDED ARABIC-INDIC DIGIT TWO"
+-    /[[:digit:]]/.match("\u06F2")    #=> #<MatchData "\u{06F2}">
+-    /[[:upper:]][[:lower:]]/.match("Hello") #=> #<MatchData "He">
+-    /[[:xdigit:]][[:xdigit:]]/.match("A6")  #=> #<MatchData "A6">
++    /[[:digit:]]/.match("\u06F2").inspect   #=> %Q{#<MatchData "\u{06F2}">}
++:rdx:
++    /[[:upper:]][[:lower:]]/.match("Hello") # > #<MatchData "He">
++    /[[:xdigit:]][[:xdigit:]]/.match("A6")  # > #<MatchData "A6">
+ 
+ == Repetition
+ 
+@@ -175,7 +180,7 @@
+ 
+     # At least one uppercase character ('H'), at least one lowercase
+     # character ('e'), two 'l' characters, then one 'o'
+-    "Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">
++    "Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) # > #<MatchData "Hello">
+ 
+ Repetition is <i>greedy</i> by default: as many occurrences as possible
+ are matched while still allowing the overall match to succeed. By
+@@ -186,8 +191,8 @@
+     # Both patterns below match the string. The first uses a greedy
+     # quantifier so '.+' matches '<a><b>'; the second uses a lazy
+     # quantifier so '.+?' matches '<a>'.
+-    /<.+>/.match("<a><b>")  #=> #<MatchData "<a><b>">
+-    /<.+?>/.match("<a><b>") #=> #<MatchData "<a>">
++    /<.+>/.match("<a><b>")  # > #<MatchData "<a><b>">
++    /<.+?>/.match("<a><b>") # > #<MatchData "<a>">
+ 
+ A quantifier followed by <tt>+</tt> matches <i>possessively</i>: once it
+ has matched it does not backtrack. They behave like greedy quantifiers,
+@@ -205,7 +210,7 @@
+     # 'at' is captured by the first group of parentheses, then referred to
+     # later with \1
+     /[csh](..) [csh]\1 in/.match("The cat sat in the hat")
+-        #=> #<MatchData "cat sat in" 1:"at">
++        # > #<MatchData "cat sat in" 1:"at">
+     # Regexp#match returns a MatchData object which makes the captured
+     # text available with its #[] method.
+     /[csh](..) [csh]\1 in/.match("The cat sat in the hat")[1] #=> 'at'
+@@ -215,14 +220,14 @@
+ constructs.
+ 
+     /\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")
+-        => #<MatchData "$3.67" dollars:"3" cents:"67">
++        # > #<MatchData "$3.67" dollars:"3" cents:"67">
+     /\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")[:dollars] #=> "3"
+ 
+ Named groups can be backreferenced with <tt>\k<</tt><i>name</i><tt>></tt>,
+ where _name_ is the group name.
+ 
+     /(?<vowel>[aeiou]).\k<vowel>.\k<vowel>/.match('ototomy')
+-        #=> #<MatchData "ototo" vowel:"o">
++        # > #<MatchData "ototo" vowel:"o">
+ 
+ *Note*: A regexp can't use named backreferences and numbered
+ backreferences simultaneously.
+@@ -241,11 +246,11 @@
+ 
+     # The pattern below matches a vowel followed by 2 word characters:
+     # 'aen'
+-    /[aeiou]\w{2}/.match("Caenorhabditis elegans") #=> #<MatchData "aen">
++    /[aeiou]\w{2}/.match("Caenorhabditis elegans") # > #<MatchData "aen">
+     # Whereas the following pattern matches a vowel followed by a word
+     # character, twice, i.e. <tt>[aeiou]\w[aeiou]\w</tt>: 'enor'.
+     /([aeiou]\w){2}/.match("Caenorhabditis elegans")
+-        #=> #<MatchData "enor" 1:"or">
++        # > #<MatchData "enor" 1:"or">
+ 
+ The <tt>(?:</tt>...<tt>)</tt> construct provides grouping without
+ capturing. That is, it combines the terms it contains into an atomic whole
+@@ -255,12 +260,12 @@
+     # The group of parentheses captures 'n' and the second 'ti'. The
+     # second group is referred to later with the backreference \2
+     /I(n)ves(ti)ga\2ons/.match("Investigations")
+-        #=> #<MatchData "Investigations" 1:"n" 2:"ti">
++        # > #<MatchData "Investigations" 1:"n" 2:"ti">
+     # The first group of parentheses is now made non-capturing with '?:',
+     # so it still matches 'n', but doesn't create the backreference. Thus,
+     # the backreference \1 now refers to 'ti'.
+     /I(?:n)ves(ti)ga\1ons/.match("Investigations")
+-        #=> #<MatchData "Investigations" 1:"ti">
++        # > #<MatchData "Investigations" 1:"ti">
+ 
+ === Atomic Grouping
+ 
+@@ -278,7 +283,7 @@
+     # overall match to fail, so the text matched by <tt>.*</tt> is
+     # backtracked by one position, which leaves the final character of the
+     # string available to match <tt>"</tt>
+-          /".*"/.match('"Quote"')     #=> #<MatchData "\"Quote\"">
++          /".*"/.match('"Quote"')     # > #<MatchData "\"Quote\"">
+     # If <tt>.*</tt> is grouped atomically, it refuses to backtrack
+     # <i>Quote"</i>, even though this means that the overall match fails
+     /"(?>.*)"/.match('"Quote"') #=> nil
+@@ -330,8 +335,8 @@
+ a single one that matches either of the expressions. Each expression is an
+ <i>alternative</i>.
+ 
+-    /\w(and|or)\w/.match("Feliformia") #=> #<MatchData "form" 1:"or">
+-    /\w(and|or)\w/.match("furandi")    #=> #<MatchData "randi" 1:"and">
++    /\w(and|or)\w/.match("Feliformia") # > #<MatchData "form" 1:"or">
++    /\w(and|or)\w/.match("furandi")    # > #<MatchData "randi" 1:"and">
+     /\w(and|or)\w/.match("dissemblance") #=> nil
+ 
+ == Character Properties
+@@ -426,16 +431,17 @@
+ <i>Tamil</i>, <i>Telugu</i>, <i>Thaana</i>, <i>Thai</i>, <i>Tibetan</i>,
+ <i>Tifinagh</i>, <i>Ugaritic</i>, <i>Vai</i>, and <i>Yi</i>.
+ 
++:rdx: if Encoding.default_external == Encoding::UTF_8
+     # Unicode codepoint U+06E9 is named "ARABIC PLACE OF SAJDAH" and
+     # belongs to the Arabic script.
+-    /\p{Arabic}/.match("\u06E9") #=> #<MatchData "\u06E9">
++    /\p{Arabic}/.match("\u06E9").inspect #=> %Q{#<MatchData "\u06E9">}
+ 
+ All character properties can be inverted by prefixing their name with a
+ caret (<tt>^</tt>).
+ 
+     # Letter 'A' is not in the Unicode Ll (Letter; Lowercase) category, so
+     # this match succeeds
+-    /\p{^Ll}/.match("A") #=> #<MatchData "A">
++    /\p{^Ll}/.match("A") # > #<MatchData "A">
+ 
+ == Anchors
+ 
+@@ -466,23 +472,23 @@
+   <i>pat</i>, but doesn't include those characters in the matched text
+ 
+     # If a pattern isn't anchored it can begin at any point in the string
+-    /real/.match("surrealist") #=> #<MatchData "real">
++    /real/.match("surrealist") # > #<MatchData "real">
+     # Anchoring the pattern to the beginning of the string forces the
+     # match to start there. 'real' doesn't occur at the beginning of the
+     # string, so now the match fails
+     /\Areal/.match("surrealist") #=> nil
+     # The match below fails because although 'Demand' contains 'and', the
+-    pattern does not occur at a word boundary.
++    # pattern does not occur at a word boundary.
+     /\band/.match("Demand")
+     # Whereas in the following example 'and' has been anchored to a
+     # non-word boundary so instead of matching the first 'and' it matches
+     # from the fourth letter of 'demand' instead
+-    /\Band.+/.match("Supply and demand curve") #=> #<MatchData "and curve">
++    /\Band.+/.match("Supply and demand curve") # > #<MatchData "and curve">
+     # The pattern below uses positive lookahead and positive lookbehind to
+     # match text appearing in <b></b> tags without including the tags in the
+     # match
+     /(?<=<b>)\w+(?=<\/b>)/.match("Fortune favours the <b>bold</b>")
+-        #=> #<MatchData "bold">
++        # > #<MatchData "bold">
+ 
+ == Options
+ 
+@@ -500,8 +506,8 @@
+ enables options <i>on</i>, and disables options <i>off</i> for the
+ expression enclosed by the parentheses.
+ 
+-    /a(?i:b)c/.match('aBc') #=> #<MatchData "aBc">
+-    /a(?i:b)c/.match('abc') #=> #<MatchData "abc">
++    /a(?i:b)c/.match('aBc') # > #<MatchData "aBc">
++    /a(?i:b)c/.match('abc') # > #<MatchData "abc">
+ 
+ Options may also be used with <tt>Regexp.new</tt>:
+ 
+@@ -525,7 +531,7 @@
+             [[:digit:]]+ # 1 or more digits after the decimal point
+         )? # The decimal point and following digits are optional
+     \Z/x
+-    float_pat.match('3.14') #=> #<MatchData "3.14" 1:".14">
++    float_pat.match('3.14') # > #<MatchData "3.14" 1:".14">
+ 
+ *Note*: To match whitespace in an <tt>x</tt> pattern use an escape such as
+ <tt>\s</tt> or <tt>\p{Space}</tt>.
+@@ -559,7 +565,10 @@
+ 
+     r = Regexp.new("a".force_encoding("iso-8859-1"),Regexp::FIXEDENCODING)
+     r =~"a\u3042"
+-       #=> Encoding::CompatibilityError: incompatible encoding regexp match
++
++raises the exception:
++
++    Encoding::CompatibilityError: incompatible encoding regexp match
+             (ISO-8859-1 regexp with UTF-8 string)
+ 
+ == Special global variables
+@@ -575,9 +584,9 @@
+ 
+ Example:
+ 
+-    m = /s(\w{2}).*(c)/.match('haystack') #=> #<MatchData "stac" 1:"ta" 2:"c">
+-    $~                                    #=> #<MatchData "stac" 1:"ta" 2:"c">
+-    Regexp.latch_match                    #=> #<MatchData "stac" 1:"ta" 2:"c">
++    m = /s(\w{2}).*(c)/.match('haystack') # > #<MatchData "stac" 1:"ta" 2:"c">
++    $~                                    # > #<MatchData "stac" 1:"ta" 2:"c">
++    Regexp.last_match                     # > #<MatchData "stac" 1:"ta" 2:"c">
+ 
+     $&      #=> "stac"
+             # same as m[0]
+@@ -611,10 +620,11 @@
+ 
+     /(b|a)/ =~ s #=> 0
+     /(b|a+)/ =~ s #=> 0
+-    /(b|a+)*\/ =~ s #=> 0
++    /(b|a+)*/ =~ s #=> 0
+ 
+ However, the following pattern takes appreciably longer:
+ 
++:rdx: is_slow
+     /(b|a+)*c/ =~ s #=> 26
+ 
+ This happens because an atom in the regexp is quantified by both an
+@@ -626,14 +636,17 @@
+ can be fixed by use of atomic grouping, which prevents the unnecessary
+ backtracking:
+ 
++:rdx: is_slow
+     (start = Time.now) && /(b|a+)*c/ =~ s && (Time.now - start)
+-       #=> 24.702736882
++       #-> 24.702736882
++
+     (start = Time.now) && /(?>b|a+)*c/ =~ s && (Time.now - start)
+-       #=> 0.000166571
++       #-> 0.000166571
+ 
+ A similar case is typified by the following example, which takes
+ approximately 60 seconds to execute for me:
+ 
++:rdx: is_slow
+     # Match a string of 29 <i>a</i>s against a pattern of 29 optional
+     # <i>a</i>s followed by 29 mandatory <i>a</i>s.
+     Regexp.new('a?' * 29 + 'a' * 29) =~ 'a' * 29

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

@@ -0,0 +1,8 @@
+--- core/orig/doc/security.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/security.rdoc	2015-06-11 07:51:46 +0000
+@@ -1,4 +1,5 @@
+ = Ruby Security
++:rdx: off
+ 
+ The Ruby programming language is large and complex and there are many security
+ pitfalls often encountered by newcomers and experienced Rubyists alike.

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

@@ -0,0 +1,160 @@
+--- core/orig/doc/syntax/assignment.rdoc	2015-06-11 07:51:44 +0000
++++ core/patched/doc/syntax/assignment.rdoc	2015-06-25 13:32:09 +0000
+@@ -27,6 +27,7 @@
+ rest of the scope are considered local variables.
+ 
+ Here is an example:
++:rdx: new_binding
+ 
+   1.times do
+     a = 1
+@@ -35,7 +36,7 @@
+ 
+   puts "no local variables outside the block" if local_variables.empty?
+ 
+-This prints:
++Produces:
+ 
+   local variables in the block: a
+   no local variables outside the block
+@@ -44,6 +45,7 @@
+ not leak to the surrounding scope.
+ 
+ Variables defined in an outer scope appear inner scope:
++:rdx: new_binding
+ 
+   a = 0
+ 
+@@ -51,7 +53,7 @@
+     puts "local variables: #{local_variables.join ", "}"
+   end
+ 
+-This prints:
++Produces:
+ 
+   local variables: a
+ 
+@@ -72,6 +74,7 @@
+ 
+ The local variable is created when the parser encounters the assignment, not
+ when the assignment occurs:
++:rdx: new_binding
+ 
+   a = 0 if false # does not assign to a
+ 
+@@ -96,11 +99,16 @@
+ receiver may raise a NameError if the method's visibility is not public.
+ 
+ Another commonly confusing case is when using a modifier +if+:
++:rdx: new_binding
+ 
+   p a if a = 0.zero?
+ 
+-Rather than printing "true" you receive a NameError, "undefined local variable
+-or method `a'".  Since ruby parses the bare +a+ left of the +if+ first and has
++Rather than printing "true" you receive the exception
++:rdx: error
++
++  undefined local variable or method `a' (NameError)
++
++Since ruby parses the bare +a+ left of the +if+ first and has
+ not yet seen an assignment to +a+ it assumes you wish to call a method.  Ruby
+ then sees the assignment to +a+ and will assume you are referencing a local
+ method.
+@@ -110,6 +118,7 @@
+ method.
+ 
+ == Instance Variables
++:rdx: new_binding
+ 
+ Instance variables are shared across all methods for the same object.
+ 
+@@ -144,6 +153,7 @@
+ only for the same object.
+ 
+ == Class Variables
++:rdx: new_binding
+ 
+ Class variables are shared between a class, its subclasses and its instances.
+ 
+@@ -176,7 +186,7 @@
+   puts "A value: #{a.value}"
+   puts "B value: #{b.value}"
+ 
+-This prints:
++Produces:
+ 
+   A value: 0
+   B value: 0
+@@ -202,7 +212,7 @@
+   puts "A value: #{a.value}"
+   puts "B value: #{b.value}"
+ 
+-This prints:
++Produces:
+ 
+   update A
+   A value: 1
+@@ -220,6 +230,7 @@
+ try not to confuse class and instance variables.
+ 
+ == Global Variables
++:rdx: new_binding
+ 
+ Global variables are accessible everywhere.
+ 
+@@ -244,8 +255,11 @@
+   C.new.my_method
+ 
+   puts "at top-level, $global: #{$global}, $other_global: #{$other_global}"
++-- rdx
++  $global = nil
++++
+ 
+-This prints:
++Produces:
+ 
+   in a class: 0
+   in a method: 0
+@@ -259,6 +273,7 @@
+ for details.
+ 
+ == Assignment Methods
++:rdx: new_binding
+ 
+ You can define methods that will behave like assignment, for example:
+ 
+@@ -294,7 +309,7 @@
+ 
+   C.new.my_method
+ 
+-This prints:
++Produces:
+ 
+   local_variables: value
+   @value: nil
+@@ -314,12 +329,13 @@
+ 
+   C.new.my_method
+ 
+-This prints:
++Produces:
+ 
+   local_variables:
+   @value: 42
+ 
+ == Abbreviated Assignment
++:rdx: new_binding
+ 
+ You can mix several of the operators and assignment.  To add 1 to an object
+ you can write:
+@@ -398,6 +414,9 @@
+   self.value, $global = 1, 2 # prints {:assigned=>1}
+ 
+   p $global # prints 2
++-- rdx
++  $global = nil
++++
+ 
+ You can use multiple assignment to swap two values in-place:
+