byebug 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4921997bbc597c75dbd51c1a5abde4fa366ce05
-  data.tar.gz: e56edf6e9529823d52edfe543ed9f450258bf893
+  metadata.gz: 21d46be2dda181855988404a2aff8d7bc0c01873
+  data.tar.gz: 51485fdf716aec89695f1b6bff72dfab4d326ebd
 SHA512:
-  metadata.gz: 69d7c6ffe0e19f58695bc007a1b44b44e743cd669939a53b0c491d209d417f4f963ca18085d07c5b7ca5a9fe7820ca59455bd2ec269c9a6963d3bdfe0a75bffe
-  data.tar.gz: ce3049894fe8169c214ce6953dd468a3343caa1e45971f093d9a73e5f3c6b778d4fa51b0ecbdb3806094b776fb4adecb4965c77689e5470a2a7fed5503dc5fce
+  metadata.gz: e59c28c8f7ded85eaca1a7ef0af86c3226ac2db743c30f8b14326efa4584c9b4f5708c5b6019dff559e69a9b51d139504cf2b4bdaecbb0f93f69446bd33a32cd
+  data.tar.gz: ae2afdb68a86af438860f730477ee2af4a5ecb7b65c07171f27cc40028ecfcc664d526f9bcf964148b4bb38b864daee5ff369cf480612a949f6c4817c37a599f

data/.gitignore

@@ -9,6 +9,8 @@ doc
 .gdb_history
 .bundle
 .tags
+.ackrc
+.jrubyrc
 
 Gemfile.lock
 

data/.travis.yml

@@ -1,4 +1,3 @@
-before_install: gem install bundler
 before_script: rake compile
 rvm:
 - 2.0.0

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.6.0
+
+* `byebug` placed at the end of a block or method call now works as expected
+* Don't autolist when ruby '-e' option is used
+* Fixes callstyles. From now on, use 'long' for detailed frames in callstack and
+'short' for more concise frames
+
+
 ## 1.5.0
 
 * No more Byebug.start to get correct callstack information! Dropping `byebug`

data/GUIDE.md

@@ -5,7 +5,7 @@ Below we will debug a simple Ruby program to solve the classic Towers of Hanoi
 puzzle. It is augmented by the bane of programming: some command-parameter
 processing with error checking.
 
-```
+```bash
 $ byebug hanoi.rb
 [1, 10] in /home/davidr/Proyectos/byebug/old_doc/hanoi.rb
     1: # Solves the classic Towers of Hanoi puzzle.
@@ -25,7 +25,7 @@ Recall in the first section iwe said that before the `def` is run, the method it
 names is undefined. Let's check that out. First let's see what private methods
 we can call before running `def hanoi`.
 
-```
+```bash
 (byebug) private_methods
 [:public, :private, :include, :using, :define_method, :default_src_encoding, ...
 ```
@@ -39,7 +39,7 @@ whether `hanoi` method is in the list. Fortunately, byebug has nice formatting
 features: we can sort the output and put it into columns list using the print
 command `ps`.
 
-```
+```bash
 (byebug) ps private_methods
 Array             debug_program         open                        sprintf    
 Complex           default_src_encoding  p                           srand      
@@ -71,7 +71,7 @@ dbg_puts          method_missing        spawn
 
 Now let's see what happens after stepping:
 
-```
+```bash
 (byebug) private_methods.member?(:hanoi)
 false
 (byebug:1) step
@@ -93,7 +93,7 @@ true
 
 Okay, lets go on and talk about program arguments.
 
-```
+```bash
 (byebug) ARGV
 []
 ```
@@ -101,7 +101,7 @@ Okay, lets go on and talk about program arguments.
 Ooops. We forgot to specify any parameters to this program. Let's try again. We
 can use the `restart` command here.
 
-```
+```bash
 (byebug) restart 3
 Re exec'ing:
   /home/davidr/.rvm/gems/ruby-2.0.0-p195@byebug/gems/byebug-1.1.1/bin/byebug /home/davidr/Proyectos/byebug/old_doc/hanoi.rb 3
@@ -202,7 +202,7 @@ trace (see [callstyle]()).
 
 Now let's move around the callstack.
 
-```
+```bash
 (byebug) undisplay
 Clear all expressions? (y/n) y
 (byebug:1) i_args
@@ -253,7 +253,7 @@ look at the file, I have an example of how to run it.  Therefore we will
 conditionally run this line if that file is invoked directly, but skip it if it
 is not. _NOTE: `byebug` resets `$0` to try to make things like this work._
 
-```
+```ruby
 if __FILE__ == $0
   t = triangle(3)
   puts t
@@ -292,7 +292,8 @@ def test_basic
 ```
 
 Now we run the program, requiring `byebug`
-```
+
+```bash
 $ ruby -rbyebug test-triangle.rb
 Run options: --seed 13073
 
@@ -316,7 +317,8 @@ and we see that we are stopped at line 7 just before the initialization of the
 list `solutions`.
 
 Now let's see where we are...
-```
+
+```bash
 (byebug) set nofullpath
 Displaying frame's full file names is off.
 (byebug) bt
@@ -366,7 +368,7 @@ 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`:
 
-```
+```bash
 $ irb
 2.0.0p195 :001 > require 'byebug'
  => true
@@ -424,7 +426,6 @@ 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 = []
@@ -452,7 +453,7 @@ SievePrime.next_prime do |prime|
 end
 ```
 
-```
+```bash
 $ byebug primes.rb
 [1, 10] in /home/davidr/Proyectos/byebug/old_doc/primes.rb
     1: # Enumerator for primes
@@ -554,7 +555,7 @@ To be continued...
 There is a wrapper script called `byebug` which basically `require`'s the gem
 then loads `byebug` before its argument (the program to be debugged) is started.
 
-```
+```bash
 byebug [byebug-options] [--] ruby-script ruby-script-arguments
 ```
 
@@ -562,7 +563,7 @@ If you don't need to pass dash options to your program, which might be confused
 with byebug options, then you don't need to add the `--`. To get a brief list of
 options and descriptions, use the `--help` option.
 
-```
+```bash
 $ byebug --help
 byebug 1.4.0
 Usage: byebug [options] <script.rb> -- <script.rb parameters>
@@ -616,7 +617,7 @@ already a debugger. This option is compatible with Ruby's.
 <rubyscript>.rb`. If all you want to do however is get a linetrace, `tracer` is
 most likely faster than `byebug`
 
-```
+```bash
 $ time ruby -rtracer old_doc/gcd.rb 24 31 >/dev/null
 
 real  0m0.066s
@@ -657,7 +658,7 @@ Here are the default values in `options`
              stop=true, tracing=false, verbose_long=false>
 ```
 
-## Command Files
+### Command Files
 
 A command file is a file of lines that are `byebug` commands. Comments (lines
 starting with `#`) may also be included. An empty line in a command file does
@@ -679,14 +680,18 @@ directory where you invoke `byebug`.
 You can also request the execution of a command file with the `source` command
 (see [Source]()).
 
-## Quitting byebug
 
-Inside a byebug interpreter, use `quit` command to finish execution. Another way
-to terminate byebug is to use the `kill` command. This does the more forceful
-`kill -9`. It can be used in cases where `quit` doesn't work (I haven't seen it
-yet).
+### Quitting byebug
+
+To exit `byebug`, use the `quit` command (abbreviated `q` and aliased `exit`).
+Normally if you are in an interactive session, this command will prompt to ask
+if you really want to quit. If you don't want any questions asked, enter
+`quit unconditionally` (abbreviated `q!`). Another way to terminate byebug is to
+use the `kill` command. This does the more forceful `kill -9`. It can be used in
+cases where `quit` doesn't work (I haven't seen those yet).
+
 
-## Calling byebug from inside your program
+### Calling byebug from inside your program
 
 Running a program from byebug adds a bit of overhead and slows it down a little.
 Furthermore, by necessity, debuggers change the operation of the program they
@@ -724,9 +729,23 @@ possible to enclose it in a conditional expression, for example
 byebug if 'bar' == foo and 20 == iter_count
 ```
 
+### Restarting Byebug
+
+You can restart the program using `restart [program args]`. This is a re-exec -
+all byebug state is lost. If command arguments are passed, those are used.
+Otherwise program arguments from the last invocation are used.
+
+You won't be able to restart your program in all cases. First, the program
+should have been invoked at the outset rather than having been called from
+inside your program or invoked as a result of post-mortem handling.
+
+Also, since this relies on the OS `exec` call, this command is available only if
+your OS supports `exec`.
+
+
 ## Byebug Command Reference
 
-## Command Syntax
+### Command Syntax
 Usually a command is put on a single line. There is no limit on how long it can be.
 It starts with a command name, which is followed by arguments whose meaning depends
 on the command name. For example, the command `step` accepts an argument which is the
@@ -740,7 +759,7 @@ backslash.
 For example, if you have [autoeval]() set, which is the default, you might want to
 enter the following code to compute the 5th Fibonacci number.
 
-```
+```bash
 (byebug) fib1=0; fib2=1; 5.times {|temp| temp=fib1; fib1=fib2; fib2 += temp }
 0
 1
@@ -784,13 +803,14 @@ location position, it will generally preface the message with `***`. However if
 annotation mode is on then the message is put in a `begin-error` annotation and no
 `***` appears.
 
-### Help
+### Command Help
+
 Once inside `byebug` you can always ask it for information on its commands using the
 `help` command. You can use `help` (abbreviated `h`) with no arguments to display a
 short list of named classes of commands
 
-```
-(byebug) `help`
+```bash
+(byebug) help
 Type "help <command-name>" for help on a specific command
 
 Available commands:
@@ -805,7 +825,7 @@ var
 With a command name as `help` argument, `byebug` displays short information on how to
 use that command.
 
-```
+```bash
 (byebug) help list
 l[ist]    list forward
 l[ist] -  list backward
@@ -827,7 +847,7 @@ letters to make that subcommand distinct from others will do. For example,
 
 Some examples follow.
 
-```
+```bash
 (byebug) help info
 info[ subcommand]
 
@@ -854,14 +874,14 @@ info variables          -- Local and instance variables of the current stack
 frame
 ```
 
-```
+```bash
 (byebug) help info breakpoints
 Status of user-settable breakpoints.
 Without argument, list info about all breakpoints.
 With an integer argument, list info on that breakpoint.
 ```
 
-```
+```bash
 (byebug) help info br
 Status of user-settable breakpoints.
 Without argument, list info about all breakpoints.

data/README.md

@@ -32,6 +32,10 @@ in your Gemfile and run
 
     bundle install
 
+**Please upgrade your ruby to 2.0.0-p247 or higher** - a bug in ruby core was
+directly affecting byebug and a fix for it has been released with this
+patchlevel (see [#5](https://github.com/deivid-rodriguez/byebug/issues/5) for
+more information)
 
 ## Usage
 
@@ -73,6 +77,8 @@ because it is a default option in byebug.
   - Colon delimited include paths.
   - Nice markdow guide.
   - Ruby 2.0 support.
+  - where/bt does not in fact give a backtrace.
+  - `byebug` can now be placed at the end of a block or method call.
 * Very actively mantained.
 * Editor agnostic: no external editor built-in support.
 * No thread support as not supported by the new API yet (I hope it will come

data/ext/byebug/byebug.c

@@ -117,6 +117,14 @@ call_at_catchpoint(VALUE context_obj, debug_context_t *dc, VALUE exp)
   return call_at(context_obj, dc, rb_intern("at_catchpoint"), 1, exp, 0);
 }
 
+static VALUE
+call_at_return(VALUE context_obj, debug_context_t *dc, VALUE file, VALUE line)
+{
+  dc->stop_reason = CTX_STOP_BREAKPOINT;
+  return call_at(context_obj, dc, rb_intern("at_return"), 2, file, line);
+
+}
+
 static void
 call_at_line_check(VALUE context_obj, debug_context_t *dc,
                    VALUE breakpoint, VALUE file, VALUE line)
@@ -226,10 +234,18 @@ process_return_event(VALUE trace_point, void *data)
   if (dc->stack_size > 0) dc->stack_size--;
   EVENT_COMMON();
 
-  if (dc->stack_size + 1 == dc->stop_frame)
+  if (dc->stack_size + 1 == dc->before_frame)
   {
-    dc->steps      = 1;
-    dc->stop_frame = -1;
+    reset_stepping_stop_points(dc);
+    VALUE file = rb_tracearg_path(trace_arg);
+    VALUE line = rb_tracearg_lineno(trace_arg);
+    call_at_return(context, dc, file, line);
+  }
+
+  if (dc->stack_size + 1 == dc->after_frame)
+  {
+    reset_stepping_stop_points(dc);
+    dc->steps = 1;
   }
 
   cleanup(dc);

data/ext/byebug/byebug.h

@@ -32,9 +32,10 @@ typedef struct {
   ctx_stop_reason stop_reason;
 
   int dest_frame;
-  int lines;                   /* # of lines in dest_frame before stopping */
-  int steps;                   /* # of steps before stopping */
-  int stop_frame;              /* frame number after which we must stop */
+  int lines;                   /* # of lines in dest_frame before stopping    */
+  int steps;                   /* # of steps before stopping                  */
+  int after_frame;             /* stop rigth after returning from this frame  */
+  int before_frame;            /* stop right before returning from this frame */
 
   VALUE last_file;
   VALUE last_line;

data/ext/byebug/context.c

@@ -7,10 +7,11 @@ static VALUE cContext;
 extern void
 reset_stepping_stop_points(debug_context_t *context)
 {
-  context->dest_frame = -1;
-  context->lines      = -1;
-  context->steps      = -1;
-  context->stop_frame = -1;
+  context->dest_frame   = -1;
+  context->lines        = -1;
+  context->steps        = -1;
+  context->after_frame  = -1;
+  context->before_frame = -1;
 }
 
 static inline VALUE
@@ -384,7 +385,21 @@ Context_step_out(VALUE self, VALUE frame)
   if (FIX2INT(frame) < 0 || FIX2INT(frame) >= context->stack_size)
     rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
 
-  context->stop_frame = context->stack_size - FIX2INT(frame);
+  context->after_frame = context->stack_size - FIX2INT(frame);
+
+  return frame;
+}
+
+static VALUE
+Context_stop_return(VALUE self, VALUE frame)
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+
+  if (FIX2INT(frame) < 0 || FIX2INT(frame) >= context->stack_size)
+    rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
+
+  context->before_frame = context->stack_size - FIX2INT(frame);
 
   return frame;
 }
@@ -414,6 +429,7 @@ Init_context(VALUE mByebug)
   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);
+  rb_define_method(cContext, "stop_return", Context_stop_return, 1);
 
   return cContext;
 }

data/lib/byebug.rb

@@ -246,22 +246,13 @@ end
 
 module Kernel
   ##
-  # Enters byebug after _steps_ line events occur.
+  # Enters byebug after _steps_into_ line events and _steps_out_ return events
+  # occur. Before entering byebug startup, the init script is read.
   #
-  # Before entering byebug startup, the init script is read. Setting _steps_ to
-  # 0 will cause a break in byebug's subroutine and not wait for a line event to
-  # occur. You will have to go "up 1" in order to be back to your debugged
-  # program from byebug. Setting _steps_ to 0 could be useful if you want to
-  # stop right after the last statement in some scope, because the next step
-  # will take you out of some scope.
-  def byebug(steps = 1)
+  def byebug(steps_into = 1, steps_out = 2)
     Byebug.start
     Byebug.run_init_script(StringIO.new)
-    if 0 == steps
-      Byebug.context.step_out
-    else
-      Byebug.context.step_into steps
-    end
+    Byebug.context.stop_return steps_out if steps_out >= 1
+    Byebug.context.step_into steps_into if steps_into >= 0
   end
-  alias breakpoint byebug unless respond_to?(:breakpoint)
 end

data/lib/byebug/command.rb

@@ -152,7 +152,7 @@ module Byebug
 
     # Register default settings
     register_setting_var(:basename, false)
-    register_setting_var(:callstyle, :last)
+    register_setting_var(:callstyle, :long)
     register_setting_var(:testing, false)
     register_setting_var(:force_stepping, false)
     register_setting_var(:frame_fullpath, true)