rdx 0.9.0.pre

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

@@ -0,0 +1,164 @@
+--- core/orig/vm_backtrace.c	2015-06-11 07:51:44 +0000
++++ core/patched/vm_backtrace.c	2015-06-20 09:00:52 +0000
+@@ -147,8 +147,14 @@
+  *
+  * For example, using +caller_locations.rb+ from Thread::Backtrace::Location
+  *
+- *	loc = c(0..1).first
+- *	loc.lineno #=> 2
++ *   # File: caller_locations.rb
++ *   loc = caller_locations(0).first
++ *   puts loc.lineno
++ * 
++ * Running the file:
++ * 
++ *   $ ruby caller_locations.rb
++ *   1
+  */
+ static VALUE
+ location_lineno_m(VALUE self)
+@@ -179,8 +185,14 @@
+  *
+  * For example, using +caller_locations.rb+ from Thread::Backtrace::Location
+  *
+- *	loc = c(0..1).first
+- *	loc.label #=> a
++ *   # File: caller_locations.rb
++ *   loc = caller_locations(0).first
++ *   puts loc.label
++ * 
++ * Running the file:
++ * 
++ *   $ ruby caller_locations.rb
++ *   <main>
+  */
+ static VALUE
+ location_label_m(VALUE self)
+@@ -239,8 +251,14 @@
+  *
+  * For example, using +caller_locations.rb+ from Thread::Backtrace::Location
+  *
+- *	loc = c(0..1).first
+- *	loc.path #=> caller_locations.rb
++ *   # File: tmp/caller_locations.rb
++ *   loc = caller_locations(0).first
++ *   puts loc.path
++ * 
++ * Running the file:
++ * 
++ *   $ ruby tmp/caller_locations.rb
++ *   tmp/caller_locations.rb
+  */
+ static VALUE
+ location_path_m(VALUE self)
+@@ -870,22 +888,49 @@
+  *
+  *  Optionally you can pass a range, which will return an array containing the
+  *  entries within the specified range.
+- *
++ * 
++ *     # File: prog.rb
+  *     def a(skip)
+- *       caller(skip)
++ *       caller(skip)   # line 2
+  *     end
+  *     def b(skip)
+- *       a(skip)
++ *       a(skip)        # line 5
+  *     end
+  *     def c(skip)
+- *       b(skip)
++ *       b(skip)        # line 8
+  *     end
+- *     c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10:in `<main>'"]
+- *     c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11:in `<main>'"]
+- *     c(2)   #=> ["prog:8:in `c'", "prog:12:in `<main>'"]
+- *     c(3)   #=> ["prog:13:in `<main>'"]
+- *     c(4)   #=> []
+- *     c(5)   #=> nil
++ * 
++ *     puts "caller(0):", c(0), "\n"              # line 11
++ *     puts "caller(1):", c(1), "\n"              # line 12
++ *     puts "caller(2):", c(2), "\n"              # line 13
++ *     puts "caller(3):", c(3), "\n"              # line 14
++ *     puts "caller(4): #{c(4).inspect}", "\n"
++ *     puts "caller(5): #{c(5).inspect}", "\n"
++ * 
++ *  then from the command line:
++ * 
++ *     $ ruby prog.rb
++ *     caller(0):
++ *     prog.rb:2:in `a'
++ *     prog.rb:5:in `b'
++ *     prog.rb:8:in `c'
++ *     prog.rb:11:in `<main>'
++ * 
++ *     caller(1):
++ *     prog.rb:5:in `b'
++ *     prog.rb:8:in `c'
++ *     prog.rb:12:in `<main>'
++ * 
++ *     caller(2):
++ *     prog.rb:8:in `c'
++ *     prog.rb:13:in `<main>'
++ * 
++ *     caller(3):
++ *     prog.rb:14:in `<main>'
++ * 
++ *     caller(4): []
++ * 
++ *     caller(5): nil
+  */
+ 
+ static VALUE
+@@ -938,7 +983,7 @@
+      *
+      *	For example:
+      *
+-     *		# caller_locations.rb
++     *		# File: caller_locations.rb
+      *		def a(skip)
+      *		  caller_locations(skip)
+      *		end
+@@ -949,19 +994,20 @@
+      *		  b(skip)
+      *		end
+      *
+-     *		c(0..2).map do |call|
++     *		c(0..2).each do |call|
+      *		  puts call.to_s
+      *		end
+      *
+-     *	Running <code>ruby caller_locations.rb</code> will produce:
++     *	Then from the command line:
+      *
++     *   $ ruby caller_locations.rb
+      *		caller_locations.rb:2:in `a'
+      *		caller_locations.rb:5:in `b'
+      *		caller_locations.rb:8:in `c'
+      *
+      *	Here's another example with a slightly different result:
+      *
+-     *		# foo.rb
++     *		# File: foo.rb
+      *		class Foo
+      *		  attr_accessor :locations
+      *		  def initialize(skip)
+@@ -973,11 +1019,12 @@
+      *		  puts call.to_s
+      *		end
+      *
+-     *	Now run <code>ruby foo.rb</code> and you should see:
+-     *
+-     *		init.rb:4:in `initialize'
+-     *		init.rb:8:in `new'
+-     *		init.rb:8:in `<main>'
++     *	Then from the command line:
++     * 
++     *   $ ruby foo.rb
++     *		foo.rb:4:in `initialize'
++     *		foo.rb:8:in `new'
++     *		foo.rb:8:in `<main>'
+      */
+     rb_cBacktraceLocation = rb_define_class_under(rb_cBacktrace, "Location", rb_cObject);
+     rb_undef_alloc_func(rb_cBacktraceLocation);

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

@@ -0,0 +1,99 @@
+--- core/orig/vm_eval.c	2015-06-11 07:51:45 +0000
++++ core/patched/vm_eval.c	2015-06-11 07:51:47 +0000
+@@ -603,8 +603,14 @@
+  *  values.
+  *
+  *     class Roman
+- *       def roman_to_int(str)
++ *       ROMAN_2_NUM = {
++ *         'I' =>  1,  'V' =>  5,
++ *         'X' => 10,  'L' => 50,
+  *         # ...
++ *       }
++ *       def roman_to_int(str)
++ *         # compute integers - for this example will suffice the table -
++ *         ROMAN_2_NUM[str.upcase]
+  *       end
+  *       def method_missing(methId)
+  *         str = methId.id2name
+@@ -613,9 +619,9 @@
+  *     end
+  *
+  *     r = Roman.new
+- *     r.iv      #=> 4
+- *     r.xxiii   #=> 23
+- *     r.mm      #=> 2000
++ *     r.i      #=> 1
++ *     r.v      #=> 5
++ *     r.x      #=> 10
+  */
+ 
+ static VALUE
+@@ -893,7 +899,7 @@
+  *  arguments specified. Unlike send, public_send calls public
+  *  methods only.
+  *
+- *     1.public_send(:puts, "hello")  # causes NoMethodError
++ *     1.public_send(:puts, "hello")  # raises NoMethodError
+  */
+ 
+ VALUE
+@@ -984,13 +990,27 @@
+  *  Repeatedly executes the block.
+  *
+  *  If no block is given, an enumerator is returned instead.
+- *
++ * 
++ *  When the following input
++ *     First line given
++ *     Second line given
++ *     Last line given
++ *     Quit!
++ *
++ *  is given into this program
++ *  :rdx: stdin
++ * 
+  *     loop do
+- *       print "Input: "
+  *       line = gets
+- *       break if !line or line =~ /^qQ/
+- *       # ...
++ *       break if !line or line =~ /^[qQ]/
++ *       puts "Got: #{line}"
+  *     end
++ * 
++ *  produces:
++ * 
++ *     Got: First line given
++ *     Got: Second line given
++ *     Got: Last line given
+  *
+  *  StopIteration raised in the block breaks the loop.
+  */
+@@ -1630,14 +1650,12 @@
+  *     end
+  *     a = %q{def hello() "Hello there!" end}
+  *     Thing.module_eval(a)
+- *     puts Thing.new.hello()
++ *     puts Thing.new.hello() # prints: Hello there!
+  *     Thing.module_eval("invalid code", "dummy", 123)
+  *
+- *  <em>produces:</em>
++ *  <em>raises the exception:</em>
+  *
+- *     Hello there!
+- *     dummy:123:in `module_eval': undefined local variable
+- *         or method `code' for Thing:Class
++ *     undefined local variable or method `code' for Thing (NameError)
+  */
+ 
+ VALUE
+@@ -1826,7 +1844,7 @@
+  *     for i in 1..10
+  *        # ...
+  *     end
+- *     local_variables   #=> [:fred, :i]
++ *     local_variables   #=> [:i, :fred]
+  */
+ 
+ static VALUE

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

@@ -0,0 +1,17 @@
+--- core/orig/vm_method.c	2015-06-11 07:51:45 +0000
++++ core/patched/vm_method.c	2015-06-11 07:51:47 +0000
+@@ -908,13 +908,12 @@
+  *     class Child
+  *       undef_method :hello   # prevent any calls to 'hello'
+  *     end
+- *     c.hello
++ *     c.hello # raises NoMethodError
+  *
+  *  <em>produces:</em>
+  *
+  *     In child
+  *     In parent
+- *     prog.rb:23: undefined method `hello' for #<Child:0x401b3bb4> (NoMethodError)
+  */
+ 
+ static VALUE

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

@@ -0,0 +1,393 @@
+--- core/orig/vm_trace.c	2015-06-11 07:51:43 +0000
++++ core/patched/vm_trace.c	2015-06-25 17:35:23 +0000
+@@ -415,29 +415,37 @@
+  *
+  *  Tracing is disabled within the context of _proc_.
+  *
++ *      # File: prog.rb
+  *      class Test
+- *	def test
+- *	  a = 1
+- *	  b = 2
+- *	end
++ *        def test
++ *          a = 1
++ *          b = 2
++ *        end
+  *      end
+  *
+  *      set_trace_func proc { |event, file, line, id, binding, classname|
+- *	   printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
++ *        printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
+  *      }
+  *      t = Test.new
+  *      t.test
+- *
+- *	  line prog.rb:11               false
++ *      set_trace_func nil
++ * 
++ *  Running the file we obtain:
++ * 
++ *    $ ruby prog.rb
++ *    c-return prog.rb:8  set_trace_func   Kernel
++ *        line prog.rb:11
+  *      c-call prog.rb:11        new    Class
+- *      c-call prog.rb:11 initialize   Object
+- *    c-return prog.rb:11 initialize   Object
++ *      c-call prog.rb:11 initialize BasicObject
++ *    c-return prog.rb:11 initialize BasicObject
+  *    c-return prog.rb:11        new    Class
+- *	  line prog.rb:12               false
+- *  	  call prog.rb:2        test     Test
+- *	  line prog.rb:3        test     Test
+- *	  line prog.rb:4        test     Test
+- *      return prog.rb:4        test     Test
++ *        line prog.rb:12
++ *        call prog.rb:2        test     Test
++ *        line prog.rb:3        test     Test
++ *        line prog.rb:4        test     Test
++ *      return prog.rb:5        test     Test
++ *        line prog.rb:13
++ *      c-call prog.rb:13 set_trace_func   Kernel
+  */
+ 
+ static VALUE
+@@ -850,23 +858,32 @@
+ /*
+  * Return class or module of the method being called.
+  *
+- *	class C; def foo; end; end
+- * 	trace = TracePoint.new(:call) do |tp|
+- * 	  p tp.defined_class #=> C
+- * 	end.enable do
+- * 	  C.new.foo
+- * 	end
++ *   class C; def foo; end; end
++ *   trace = TracePoint.new(:call) do |tp|
++ *     puts tp.defined_class
++ *   end.enable do
++ *     C.new.foo
++ *   end
++ * 
++ * produces:
++ * 
++ *   C
+  *
+  * If method is defined by a module, then that module is returned.
++ * :rdx: new_binding
+  *
+- *	module M; def foo; end; end
+- * 	class C; include M; end;
+- * 	trace = TracePoint.new(:call) do |tp|
+- * 	  p tp.defined_class #=> M
+- * 	end.enable do
+- * 	  C.new.foo
+- * 	end
+- *
++ *   module M; def foo; end; end
++ *   class C; include M; end;
++ *   trace = TracePoint.new(:call) do |tp|
++ *     puts tp.defined_class
++ *   end.enable do
++ *     C.new.foo
++ *   end
++ * 
++ * produces:
++ * 
++ *   M
++ * 
+  * <b>Note:</b> #defined_class returns singleton class.
+  *
+  * 6th block parameter of Kernel#set_trace_func passes original class
+@@ -874,12 +891,17 @@
+  *
+  * <b>This is a difference between Kernel#set_trace_func and TracePoint.</b>
+  *
+- *	class C; def self.foo; end; end
+- * 	trace = TracePoint.new(:call) do |tp|
+- * 	  p tp.defined_class #=> #<Class:C>
+- * 	end.enable do
+- * 	  C.foo
+- * 	end
++ *   class C; def self.foo; end; end
++ *   trace = TracePoint.new(:call) do |tp|
++ *     puts tp.defined_class
++ *   end.enable do
++ *     C.foo
++ *   end
++ * 
++ * produces:
++ * 
++ *   #<Class:C>
++ * 
+  */
+ static VALUE
+ tracepoint_attr_defined_class(VALUE tpval)
+@@ -900,7 +922,8 @@
+  * Return the trace object during event
+  *
+  * Same as TracePoint#binding:
+- *	trace.binding.eval('self')
++ * :rdx: off -
++ *   trace.binding.eval('self')
+  */
+ static VALUE
+ tracepoint_attr_self(VALUE tpval)
+@@ -979,39 +1002,45 @@
+ 
+ /*
+  * call-seq:
+- *	trace.enable		-> true or false
+- *	trace.enable { block }	-> obj
++ *   trace.enable   -> true or false
++ *   trace.enable { block }  -> obj
+  *
+  * Activates the trace
+  *
+  * Return true if trace was enabled.
+  * Return false if trace was disabled.
+  *
+- *	trace.enabled?  #=> false
+- *	trace.enable    #=> false (previous state)
++ *-- rdx
++ *   trace = TracePoint.new{}
++ *++
++ *   trace.enabled?  #=> false
++ *   trace.enable    #=> false # previous state
+  *                      #   trace is enabled
+- *	trace.enabled?  #=> true
+- *	trace.enable    #=> true (previous state)
++ *   trace.enabled?  #=> true
++ *   trace.enable    #=> true # previous state
+  *                      #   trace is still enabled
+  *
+  * If a block is given, the trace will only be enabled within the scope of the
+  * block.
+  *
+- *	trace.enabled?
+- *	#=> false
+- *
+- *	trace.enable do
+- *	    trace.enabled?
+- *	    # only enabled for this block
+- *	end
++ *-- rdx
++ *   trace.disable
++ *++
++ *   trace.enabled?
++ *   #=> false
++ *
++ *   trace.enable do
++ *       # only enabled for this block
++ *       trace.enabled?
++ *   end #=> true
+  *
+- *	trace.enabled?
+- *	#=> false
++ *   trace.enabled?
++ *   #=> false
+  *
+  * Note: You cannot access event hooks within the block.
+  *
+- *	trace.enable { p tp.lineno }
+- *	#=> RuntimeError: access from outside
++ *   trace.enable { trace.lineno }
++ *   # raises RuntimeError: access from outside
+  *
+  */
+ static VALUE
+@@ -1033,37 +1062,47 @@
+ 
+ /*
+  * call-seq:
+- *	trace.disable		-> true or false
+- *	trace.disable { block } -> obj
++ *   trace.disable		-> true or false
++ *   trace.disable { block } -> obj
+  *
+  * Deactivates the trace
+  *
+  * Return true if trace was enabled.
+  * Return false if trace was disabled.
+  *
+- *	trace.enabled?	#=> true
+- *	trace.disable	#=> false (previous status)
+- *	trace.enabled?	#=> false
+- *	trace.disable	#=> false
++ *-- rdx
++ *   trace = TracePoint.new{}
++ *   trace.enable
++ *++
++ *   trace.enabled? #=> true
++ *   trace.disable  #=> true # previous status
++ *   trace.enabled? #=> false
++ *   trace.disable  #=> false
+  *
+  * If a block is given, the trace will only be disable within the scope of the
+  * block.
+  *
+- *	trace.enabled?
+- *	#=> true
+- *
+- *	trace.disable do
+- *	    trace.enabled?
+- *	    # only disabled for this block
+- *	end
+- *
+- *	trace.enabled?
+- *	#=> true
++ *-- rdx
++ *   trace.enable
++ *++
++ *   trace.enabled?
++ *   #=> true
++ *
++ *   trace.disable do
++ *     # only disabled for this block
++ *     trace.enabled?
++ *   end #=> false
++ *
++ *   trace.enabled?
++ *   #=> true
++ *-- rdx
++ *   trace.disable
++ *++
+  *
+  * Note: You cannot access event hooks within the block.
+  *
+- *	trace.disable { p tp.lineno }
+- *	#=> RuntimeError: access from outside
++ *   trace.disable { trace.lineno }
++ *   # raises RuntimeError: access from outside
+  */
+ static VALUE
+ tracepoint_disable_m(VALUE tpval)
+@@ -1084,7 +1123,7 @@
+ 
+ /*
+  * call-seq:
+- *	trace.enabled?	    -> true or false
++ *   trace.enabled?	    -> true or false
+  *
+  * The current status of the trace
+  */
+@@ -1126,28 +1165,40 @@
+ 
+ /*
+  * call-seq:
+- *	TracePoint.new(*events) { |obj| block }	    -> obj
++ *   TracePoint.new(*events) { |obj| block }	    -> obj
+  *
+  * Returns a new TracePoint object, not enabled by default.
+  *
+  * Next, in order to activate the trace, you must use TracePoint.enable
+  *
+- *	trace = TracePoint.new(:call) do |tp|
+- *	    p [tp.lineno, tp.defined_class, tp.method_id, tp.event]
+- *	end
+- *	#=> #<TracePoint:0x007f17372cdb20>
+- *
+- *	trace.enable
+- *	#=> #<TracePoint:0x007f17372cdb20>
+- *
+- *	puts "Hello, TracePoint!"
+- *	# ...
+- *	# [48, IRB::Notifier::AbstractNotifier, :printf, :call]
+- *	# ...
++ *   trace = TracePoint.new(:call) do |tp|
++ *     p [tp.lineno, tp.defined_class, tp.method_id, tp.event]
++ *   end
++ *   #=> #<TracePoint:0x007f17372cdb20>
++ *
++ *   trace.enable
++ *
++ *   puts "Hello, TracePoint!"
++ * 
++ *-- rdx
++ *   trace.disable
++ *++
++ * 
++ * produces many lines of output, such as:
++ * :rdx: indicative_output
++ * 
++ *   ...
++ *   [69, IRB::Notifier::AbstractNotifier, :printf, :call]
++ *   [204, IRB::Notifier::LeveledNotifier, :notify?, :call]
++ *   [198, IRB::Notifier::LeveledNotifier, :<=>, :call]
++ *   [102, RubyLex, :getc, :call]
++ *   [145, RubyLex, :ungetc, :call]
++ *   ...
+  *
+  * When you want to deactivate the trace, you must use TracePoint.disable
++ * :rdx: discard_output
+  *
+- *	trace.disable
++ *   trace.disable
+  *
+  * See TracePoint@Events for possible events and more information.
+  *
+@@ -1155,18 +1206,24 @@
+  *
+  * If the trace method isn't included in the given events filter, a
+  * RuntimeError is raised.
++ * :rdx: off
++ * :rdx: # actually it doesn't seem a rescuable exception, but a message displayed to $stderr before exiting
+  *
+- *	TracePoint.trace(:line) do |tp|
+- *	    p tp.raised_exception
+- *	end
+- *	#=> RuntimeError: 'raised_exception' not supported by this event
++ *   TracePoint.trace(:line) do |tp|
++ *     tp.raised_exception
++ *   end
++ *   #=> RuntimeError: 'raised_exception' not supported by this event
+  *
+  * If the trace method is called outside block, a RuntimeError is raised.
++ * :rdx: on
+  *
+- *      TracePoint.trace(:line) do |tp|
+- *        $tp = tp
+- *      end
+- *      $tp.line #=> access from outside (RuntimeError)
++ *   TracePoint.trace(:line) do |tp|
++ *     $tp = tp
++ *   end
++ *   $tp.lineno # raises RuntimeError: access from outside
++ *-- rdx
++ *   $tp = nil
++ *++
+  *
+  * Access from other threads is also forbidden.
+  *
+@@ -1275,16 +1332,23 @@
+      *
+      * We can use TracePoint to gather information specifically for exceptions:
+      *
+-     *	    trace = TracePoint.new(:raise) do |tp|
+-     *		p [tp.lineno, tp.event, tp.raised_exception]
+-     *	    end
+-     *	    #=> #<TracePoint:0x007f786a452448>
++     *    trace = TracePoint.new(:raise) do |tp|
++     *      p [tp.method_id, tp.event, tp.raised_exception]
++     *    end
++     *    #=> #<TracePoint:0x007f786a452448>
+      *
+-     *	    trace.enable
+-     *	    #=> #<TracePoint:0x007f786a452448>
++     *    trace.enable
++     *    #=> false
+      *
+-     *	    0 / 0
+-     *	    #=> [5, :raise, #<ZeroDivisionError: divided by 0>]
++     *    begin
++     *      0 / 0
++     *    rescue
++     *      trace.disable
++     *    end
++     * 
++     * produces:
++     * 
++     *    [:/, :raise, #<ZeroDivisionError: divided by 0>]
+      *
+      * == Events
+      *