byebug 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2ab6f03625dc6bba2088e27bff9ec5f6c335b57
-  data.tar.gz: 48cca8a66cb638c91a26728a334613c33359236b
+  metadata.gz: 497f9606e8de41c51c02441cdbda3092f7131ec3
+  data.tar.gz: 12a94e7916cc107fb392af1a7abc0cd8515ce696
 SHA512:
-  metadata.gz: 0a7c63ad6c37d3d23f13aa5db25db6dec3bed363ece29fc40402d3fa852ab2255183bb3d705c394d4a6c8a62a81f88e45e8bab5786dc06aff92eea02b9309112
-  data.tar.gz: 5274f6aa1ab234bd028ae07943cdbfa0bfa9f02a82e5925566a55e6f6a383fbabfeb6cbc9da64efb56b3098fbeb4320ba207485ccf4ed2aa812efe98c35bc1c7
+  metadata.gz: 7ffdf9b6cf8fc471af1b57efacabaa9e3159c115e59d718417792e6a70a7686070a7537a1d2c10da741988fb1416bf61cb95d71420718f89219d434d3c318b7f
+  data.tar.gz: f1ddc5b71c708a81de661402d52a2b758913cdd09d2b4827cf850643467ef857b50dc64fa0f98ed3ba774de0dc34f1dc6b69c6d3b68d4226f3a5ac835fb8ef7d

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.3.1
+
+* Byebug now works with Rails debugging flag
+* Fix bug which would make byebug crash when trying to print lines of code
+containing the character '%'
+* Fix bug which prevented basename and linetrace options from working together
+
+
 ## 1.3.0
 
 * Support colon-delimited include paths in command-line front-end (@ender672)

data/GUIDE.md

@@ -435,3 +435,212 @@ Much better. But again let me emphasize that the parameter types are those of
 the corresponding variables that _currently_ exist, and this might have changed
 since the time when the call was made.
 
+
+## Byebug.start with a block
+
+We saw that `Byebug.start()` and `Byebug.stop()` allow fine-grain control over
+where byebug tracking should occur.
+
+Rather than use an explicit `stop()`, you can also pass a block to the `start()`
+method. This causes `start()` to run and then `yield` to that block. When the
+block is finished, `stop()` is run. In other words, this wraps a
+`Byebug.start()` and `Byebug.stop()` around the block of code. But it also has a
+side benefit of ensuring that in the presence of an uncaught exception `stop` is
+run, without having to explicitly use `begin ... ensure Byebug.stop() end`.
+
+For example, in Ruby on Rails you might want to debug code in one of the
+controllers without causing any slowdown to any other code. And this can be done
+by wrapping the controller in a `start()` with a block; when the method wrapped
+this way finishes, byebug is turned off and the application proceeds at regular
+speed.
+
+Of course, inside the block you will probably want to enter the byebug using
+`Byebug.byebug()`, otherwise there would be little point in using the `start`.
+For example, you can do this in `irb`:
+
+```
+$ irb
+2.0.0p195 :001 > require 'byebug'
+ => true 
+2.0.0p195 :002 > def foo
+2.0.0p195 :003?>   x=1
+2.0.0p195 :004?>   puts 'foo'
+2.0.0p195 :005?>   end
+ => nil 
+2.0.0p195 :006 > Byebug.start{byebug; foo}
+(irb) @ 6
+(byebug) s
+(irb) @ 3
+(byebug) s
+(irb) @ 4
+(byebug) p x
+1
+(byebug) s
+foo
+ => true 
+2.0.0p195 :007 > 
+```
+
+There is a counter inside of `Byebug.start` method to make sure that this works
+when another `Byebug.start` method is called inside of the outer one. However,
+if you are stopped inside byebug, issuing another `byebug` call will not have
+any effect even if it is nested inside another `Byebug.start`.
+
+## Debugging Oddities: How debugging Ruby may be different from debugging other
+languages
+
+If you are used to debugging in other languages like C, C++, Perl, Java or even
+Bash (see [bashdb](http://bashdb.sf.net)), there may be a number of things that
+seem or feel a little bit different and may confuse you. A number of these
+things aren't oddities of the debugger per se but differences in how Ruby works
+compared to those other languages. Because Ruby works a little differently from
+those other languages, writing a debugger has to also be a little different as
+well if it is to be useful. In this respect, using byebug may help you
+understand Ruby better.
+
+We've already seen two examples of such differences. One difference is the fact
+that we stop on method definitions or `def`'s and that is because these are in
+fact executable statements. In other compiled languages this would not happen
+because that's already been done when you compile the program (or in Perl when
+it scans in the program). The other difference we saw was our inability to show
+call stack parameter types without having made arrangements for byebug to track
+this. In other languages call stack information is usually available without
+asking assistance of the debugger (in C and C++, however, you generally have to
+ask the compiler to add such information.).
+
+In this section we'll consider some other things that might throw off new users
+to Ruby who are familiar with other languages and debugging in them.
+
+* Bouncing Around in Blocks (iterators)
+* No Parameter Values in a Call Stack
+* Lines You Can Stop At
+
+## Bouncing Around in Blocks (iterators)
+
+When debugging languages with coroutines like Python and Ruby, a method call may
+not necessarily go to the first statement after the method header. It's possible
+that the call will continue after a `yield` statement from a prior call.
+
+```ruby
+
+# Enumerator for primes
+class SievePrime
+  @@odd_primes = []
+  def self.next_prime(&block)
+    candidate = 2
+    yield candidate
+    not_prime = false
+    candidate += 1
+    while true do
+      @@odd_primes.each do |p|
+        not_prime = (0 == (candidate % p))
+        break if not_prime
+      end
+      unless not_prime
+        @@odd_primes << candidate
+        yield candidate
+      end
+      candidate += 2
+    end
+  end
+end
+SievePrime.next_prime do |prime|
+  puts prime
+  break if prime > 10
+end
+```
+
+```
+$ byebug primes.rb
+[1, 10] in /home/davidr/Proyectos/byebug/old_doc/primes.rb
+    1: # Enumerator for primes
+=>  2: class SievePrime
+    3:   @@odd_primes = []
+    4:   def self.next_prime(&block)
+    5:     candidate = 2
+    6:     yield candidate
+    7:     not_prime = false
+    8:     candidate += 1
+    9:     while true do
+   10:       @@odd_primes.each do |p|
+(byebug) set linetrace
+line tracing is on.
+(byebug) set basename
+basename in on.
+(byebug) step 9
+Tracing: primes.rb:3 @@odd_primes = []
+Tracing: primes.rb:4 def self.next_prime(&block)
+Tracing: primes.rb:22 SievePrime.next_prime do |prime|
+Tracing: primes.rb:5 candidate = 2
+Tracing: primes.rb:6 yield candidate
+Tracing: primes.rb:23 puts prime
+2
+Tracing: primes.rb:24 break if prime > 10
+Tracing: primes.rb:7 not_prime = false
+Tracing: primes.rb:8 candidate += 1
+[3, 12] in /home/davidr/Proyectos/byebug/old_doc/primes.rb
+    3:   @@odd_primes = []
+    4:   def self.next_prime(&block)
+    5:     candidate = 2
+    6:     yield candidate
+    7:     not_prime = false
+=>  8:     candidate += 1
+    9:     while true do
+   10:       @@odd_primes.each do |p|
+   11:         not_prime = (0 == (candidate % p))
+   12:         break if not_prime
+(byebug)
+```
+
+The loop between lines 23-26 gets interleaved between those of
+`Sieve::next_prime`, lines 6-19 above.
+
+
+### No Parameter Values in a Call Stack
+
+In traditional debuggers, in a call stack you can generally see the names of the
+parameters and the values that were passed in.
+
+Ruby is a very dynamic language and it tries to be efficient within the confines
+of the language definition. Values generally aren't taken out of a variable or
+expression and pushed onto a stack. Instead a new scope is created and the
+parameters are given initial values. Parameter passing is by _reference_ not by
+_value_ as it is say Algol, C, or Perl. During the execution of a method,
+parameter values can change (and often do). In fact even the _class_ of the
+object can change.
+
+So at present, the name of the parameter is shown. The call-style setting
+([callstyle]()) can be used to set whether the name is shown or the name and the
+_current_ class of the object. It has been contemplated that a style might be
+added which saves on call shorter "scalar" types of values and the class name.
+
+
+### Lines You Can Stop At
+
+As with the duplicate stops per control (e.g. `if` statement), until tools like
+debuggers get more traction among core ruby developers there are going to be
+weirdness. Here we describe the stopping locations which effects the breakpoint
+line numbers you can stop at.
+
+Consider the following little Ruby program.
+
+```ruby
+'Yes it does' =~ /
+(Yes) \s+
+it  \s+
+does
+/ix
+puts $1
+```
+
+The stopping points that Ruby records are the last two lines, lines 5 and 6.
+
+Inside `byebug` you can get a list of stoppable lines for a file using the `info
+file` command with the attribute `breakpoints`.
+
+To be continued...
+* more complex example with objects, pretty printing and irb.
+* line tracing and non-interactive tracing.
+* mixing in Byebug.debug with byebug
+* post-mortem debugging and setting up for that
+* references to videos

data/README.md

@@ -1,7 +1,7 @@
-# Byebug [![Gem Version](https://badge.fury.io/rb/byebug.png)](http://badge.fury.io/rb/byebug) [![Build Status](https://secure.travis-ci.org/deivid-rodriguez/byebug.png)](http://travis-ci.org/deivid-rodriguez/byebug) [![Code Climate](https://codeclimate.com/github/deivid-rodriguez/byebug.png)](https://codeclimate.com/github/deivid-rodriguez/byebug) [![Dependency Status](https://gemnasium.com/deivid-rodriguez/byebug.png)](https://gemnasium.com/deivid-rodriguez/byebug)
+# Byebug [![Gem Version][1]][2] [![Build Status][3]][4] [![Code Climate][5]][6] [![Dependency Status][7]][8]
 
 <img src="https://raw.github.com/deivid-rodriguez/byebug/master/logo.png"
-     alt="Byebug logo" align="right" />
+     alt="Byebug logo" align="right" style="margin-left: 10px" />
 
 _Debugging in Ruby 2.0_
 
@@ -254,3 +254,12 @@ software, specially:
 * Dennis Ushakov, author of [debase](https://github.com/denofevil/debase), the
 starting point of this.
 * Logo by [Ivlichev Victor Petrovich](http://www.aha-soft.com/)
+
+[1]: https://badge.fury.io/rb/byebug.png
+[2]: http://badge.fury.io/rb/byebug
+[3]: https://secure.travis-ci.org/deivid-rodriguez/byebug.png
+[4]: http://travis-ci.org/deivid-rodriguez/byebug
+[5]: https://codeclimate.com/github/deivid-rodriguez/byebug.png
+[6]: https://codeclimate.com/github/deivid-rodriguez/byebug
+[7]: https://gemnasium.com/deivid-rodriguez/byebug.png
+[8]: https://gemnasium.com/deivid-rodriguez/byebug

data/Rakefile

@@ -17,3 +17,15 @@ end
 base_spec = eval(File.read('byebug.gemspec'), binding, 'byebug.gemspec')
 
 task :default => :test
+
+desc 'Run a test in looped mode so that you can look for memory leaks'
+task 'test_loop' do
+  code = %Q[loop{ require '#{$*[1]}' }]
+  cmd = %Q[ruby -Itest -e "#{ code }"]
+  system cmd
+end
+
+desc 'Watch memory use of a looping test'
+task 'test_loop_mem' do
+  system "watch \"ps aux | grep -v 'sh -c r' | grep [I]test\""
+end

data/ext/byebug/byebug.c

@@ -95,22 +95,22 @@ load_frame_info(VALUE trace_point, VALUE *path, VALUE *lineno, VALUE *method_id,
 }
 
 static void
-call_at_line(debug_context_t *context, char *file, int line,
-             VALUE context_object, VALUE path, VALUE lineno)
+call_at_line(debug_context_t *context, VALUE context_obj,
+                                       VALUE path, VALUE lineno)
 {
   CTX_FL_UNSET(context, CTX_FL_ENABLE_BKPT);
   CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
-  context->last_file = file;
-  context->last_line = line;
-  rb_funcall(context_object, rb_intern("at_line"), 2, path, lineno);
+  context->last_file = RSTRING_PTR(path);
+  context->last_line = FIX2INT(lineno);
+  rb_funcall(context_obj, rb_intern("at_line"), 2, path, lineno);
 }
 
 #define EVENT_SETUP                                                        \
   VALUE path, lineno, method_id, defined_class, binding, self;             \
-  VALUE context_object;                                                    \
+  VALUE context_obj;                                                       \
   debug_context_t *context;                                                \
-  context_object = Byebug_context(mByebug);                                \
-  Data_Get_Struct(context_object, debug_context_t, context);               \
+  context_obj = Byebug_context(mByebug);                                   \
+  Data_Get_Struct(context_obj, debug_context_t, context);                  \
   if (!check_start_processing(context)) return;                            \
   load_frame_info(trace_point, &path, &lineno, &method_id, &defined_class, \
                                &binding, &self);                           \
@@ -140,7 +140,7 @@ process_line_event(VALUE trace_point, void *data)
   }
 
   if (RTEST(tracing))
-    rb_funcall(context_object, rb_intern("at_tracing"), 2, path, lineno);
+    rb_funcall(context_obj, rb_intern("at_tracing"), 2, path, lineno);
 
   if (context->dest_frame == -1 || context->stack_size == context->dest_frame)
   {
@@ -159,18 +159,17 @@ process_line_event(VALUE trace_point, void *data)
   {
     context->stop_reason = CTX_STOP_STEP;
     reset_stepping_stop_points(context);
-    call_at_line(
-      context, RSTRING_PTR(path), FIX2INT(lineno), context_object, path, lineno);
+    call_at_line(context, context_obj, path, lineno);
   }
   else if (CTX_FL_TEST(context, CTX_FL_ENABLE_BKPT))
   {
     breakpoint = find_breakpoint_by_pos(breakpoints, path, lineno, binding);
-    if (breakpoint != Qnil) {
+    if (breakpoint != Qnil)
+    {
       context->stop_reason = CTX_STOP_BREAKPOINT;
       reset_stepping_stop_points(context);
-      rb_funcall(context_object, rb_intern("at_breakpoint"), 1, breakpoint);
-      call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
-                            path, lineno);
+      rb_funcall(context_obj, rb_intern("at_breakpoint"), 1, breakpoint);
+      call_at_line(context, context_obj, path, lineno);
     }
   }
 
@@ -224,11 +223,11 @@ process_call_event(VALUE trace_point, void *data)
   breakpoint = find_breakpoint_by_method(breakpoints, defined_class,
                                                       SYM2ID(method_id),
                                                       binding, self);
-  if (breakpoint != Qnil) {
-      context->stop_reason = CTX_STOP_BREAKPOINT;
-      rb_funcall(context_object, rb_intern("at_breakpoint"), 1, breakpoint);
-      call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
-                 path, lineno);
+  if (breakpoint != Qnil)
+  {
+    context->stop_reason = CTX_STOP_BREAKPOINT;
+    rb_funcall(context_obj, rb_intern("at_breakpoint"), 1, breakpoint);
+    call_at_line(context, context_obj, path, lineno);
   }
 
   cleanup(context);
@@ -277,9 +276,8 @@ process_raise_event(VALUE trace_point, void *data)
       /* increment exception */
       rb_hash_aset(catchpoints, mod_name, INT2FIX(FIX2INT(hit_count) + 1));
       context->stop_reason = CTX_STOP_CATCHPOINT;
-      rb_funcall(context_object, rb_intern("at_catchpoint"), 1, rb_errinfo());
-      call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
-                   path, lineno);
+      rb_funcall(context_obj, rb_intern("at_catchpoint"), 1, rb_errinfo());
+      call_at_line(context, context_obj, path, lineno);
       break;
     }
   }
@@ -403,11 +401,11 @@ Byebug_start(VALUE self)
 static VALUE
 set_current_skipped_status(VALUE status)
 {
-  VALUE context_object;
+  VALUE context_obj;
   debug_context_t *context;
 
-  context_object = Byebug_context(mByebug);
-  Data_Get_Struct(context_object, debug_context_t, context);
+  context_obj = Byebug_context(mByebug);
+  Data_Get_Struct(context_obj, debug_context_t, context);
   if (status)
     CTX_FL_SET(context, CTX_FL_SKIPPED);
   else
@@ -418,39 +416,38 @@ set_current_skipped_status(VALUE status)
 static VALUE
 Byebug_load(int argc, VALUE *argv, VALUE self)
 {
-    VALUE file, stop, context_object;
-    debug_context_t *context;
-    int state = 0;
+  VALUE file, stop, context_obj;
+  debug_context_t *context;
+  int state = 0;
 
-    if (rb_scan_args(argc, argv, "11", &file, &stop) == 1)
-    {
-        stop = Qfalse;
-    }
+  if (rb_scan_args(argc, argv, "11", &file, &stop) == 1)
+  {
+      stop = Qfalse;
+  }
 
-    Byebug_start(self);
+  Byebug_start(self);
 
-    context_object = Byebug_context(self);
-    Data_Get_Struct(context_object, debug_context_t, context);
-    context->stack_size = 0;
-    if (RTEST(stop)) context->steps = 1;
+  context_obj = Byebug_context(self);
+  Data_Get_Struct(context_obj, debug_context_t, context);
+  context->stack_size = 0;
+  if (RTEST(stop)) context->steps = 1;
 
-    /* Initializing $0 to the script's path */
-    ruby_script(RSTRING_PTR(file));
-    rb_load_protect(file, 0, &state);
-    if (0 != state)
-    {
-        VALUE errinfo = rb_errinfo();
-        //debug_suspend(self);
-        reset_stepping_stop_points(context);
-        rb_set_errinfo(Qnil);
-        return errinfo;
-    }
+  /* Initializing $0 to the script's path */
+  ruby_script(RSTRING_PTR(file));
+  rb_load_protect(file, 0, &state);
+  if (0 != state)
+  {
+      VALUE errinfo = rb_errinfo();
+      reset_stepping_stop_points(context);
+      rb_set_errinfo(Qnil);
+      return errinfo;
+  }
 
-    /* We should run all at_exit handler's in order to provide, for instance, a
-     * chance to run all defined test cases */
-    rb_exec_end_proc();
+  /* We should run all at_exit handler's in order to provide, for instance, a
+   * chance to run all defined test cases */
+  rb_exec_end_proc();
 
-    return Qnil;
+  return Qnil;
 }
 
 static VALUE

data/ext/byebug/context.c

@@ -247,28 +247,6 @@ Context_frame_class(int argc, VALUE *argv, VALUE self)
   return frame->defined_class;
 }
 
-static VALUE
-Context_frame_locals(int argc, VALUE *argv, VALUE self)
-{
-  VALUE binding = Context_frame_binding(argc, argv, self);
-  const char src[] =
-              "local_variables.inject({}){|h, v| h[v] = eval(\"#{v}\"); h}";
-  return NIL_P(binding) ?
-         rb_hash_new() :
-         rb_funcall(binding, rb_intern("eval"), 1, rb_str_new2(src));
-}
-
-static VALUE
-Context_frame_args_info(int argc, VALUE *argv, VALUE self)
-{
-  VALUE binding = Context_frame_binding(argc, argv, self);
-  const char src[] = "method(__method__).parameters";
-
-  return NIL_P(binding) ?
-         rb_ary_new() :
-         rb_funcall(binding, rb_intern("eval"), 1, rb_str_new2(src));
-}
-
 static VALUE
 Context_tracing(VALUE self)
 {
@@ -427,8 +405,6 @@ Init_context(VALUE mByebug)
   rb_define_method(cContext, "frame_binding", Context_frame_binding, -1);
   rb_define_method(cContext, "frame_self", Context_frame_self, -1);
   rb_define_method(cContext, "frame_class", Context_frame_class, -1);
-  rb_define_method(cContext, "frame_args_info", Context_frame_args_info, -1);
-  rb_define_method(cContext, "frame_locals", Context_frame_locals, -1);
   rb_define_method(cContext, "step_into", Context_step_into, -1);
   rb_define_method(cContext, "step_over", Context_step_over, -1);
   rb_define_method(cContext, "step_out", Context_step_out, 1);