byebug 6.0.2 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bd941f093c6a49a371dfefe4cb06d9285eb5154
-  data.tar.gz: cc056395c95ece29b62647a4875d759ac18708c6
+  metadata.gz: 075e48a583d6bdc5ec0cd4ce6cf195412476d722
+  data.tar.gz: 8e755e6afcc87f2fb06109c9fdc0dd8e052a1736
 SHA512:
-  metadata.gz: 092d68626a8dc9190494a66d84405c5e36b709e1ca2548eb4b76e7b949aa1605548e3cc7a19aeb5988cc1480adfc21619f5603dce31471020ef2c04c83c287e7
-  data.tar.gz: e6d15db6847705de02000c299a1ca7be98d63e4f15ac306348a82d19d9667f90451c01dbee66c12744d4166f558bffbb1cf9f3ac7f46861b3cbde8257cda2576
+  metadata.gz: def5daed567d526f9cf7ad3af964a997e18aeedaf9349f23c5e9e25534c9c3711a6e1688efbfc317da99b83508035ff9db4a9d64f12ba56fb671422044a8103b
+  data.tar.gz: bac9c0be89f64f58403218158b92686734bcf7a5771f4d6eac6e9c7cd4a91ebcf28d476d3e8c3e447c4bf01ba534a60651ce33dec7e04ad81edc4372ff89110a

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 7.0.0 - 2015-11-04
+### Fixed
+* [#177](https://github.com/deivid-rodriguez/byebug/issues/177). Some issues
+with formatting results of evaluations.
+* [#144](https://github.com/deivid-rodriguez/byebug/issues/144). Ruby process
+after using byebug does no longer get slow.
+* [#121](https://github.com/deivid-rodriguez/byebug/issues/121). `byebug`
+commands inside code evaluated from debugger's prompt are now properly working.
+* Another evaluation bug in autocommands.
+* `finish 0` command would sometimes fail to stop right before exiting the
+current frame.
+* Runner's `--[no-]stop` option now works (thanks @windwiny).
+* Change variable name `bool`, avoid conflict clang's predefined macro
+
+### Removed
+* `ps` command.
+
+### Changed
+* [#166](https://github.com/deivid-rodriguez/byebug/issues/166). Don't load
+the entire library on require, but only when a `byebug` call is issued. Thanks
+@bquorning.
+* The above fix to the `finish 0` command cause `byebug`'s entrypoint to
+require 3 steps out instead of 2. In general, plugins using
+`Byebug::Context.step_out` will need to be changed to consider "c return events"
+as well.
+
+### Added
+* `autopry` setting that calls `pry` on every stop.
+* Return value information to debugger's output when `finish 0` is used.
+
 ## 6.0.2 - 2015-08-20
 ### Fixed
 * The user should always be given back a prompt unless (s)he explicitly states

data/CONTRIBUTING.md

@@ -1,4 +1,18 @@
-## Getting started
+## Contributing to Byebug
+
+### Bug Reports
+
+* Try to reproduce the issue against the latest revision. There might be
+unrealeased work that fixes your problem!
+
+* Ensure that your issue has not already been reported.
+
+* Include the steps you carried out to produce the problem. If we can't
+reproduce it, we can't fix it.
+
+* Include the behavior you observed along with the behavior you expected,
+and why you expected it.
+
 
 ### Development dependencies
 
@@ -25,16 +39,20 @@ test`.
 * If you want to run specific tests, use the provided test runner, like so:
 
   - Specific test files. For example,
-`script/minitest_runner test/commands/break_test.rb`
+`script/minitest_runner.rb test/commands/break_test.rb`
 
   - Specific test classes. For example,
-`script/minitest_runner Byebug::BreakAtLinesTestCase`
+`script/minitest_runner.rb Byebug::BreakAtLinesTestCase`
 
   - Specific tests. For example,
-`script/minitest_runner test_catch_removes_specific_catchpoint`
+`script/minitest_runner.rb test_catch_removes_specific_catchpoint`
+
+  - Specific fully qualified tests. For example,
+`script/minitest_runner.rb
+BreakAtLinesTest#test_setting_breakpoint_sets_correct_fields`
 
   - You can combine any of them and you will get the union of all filters. For
-example: `script/minitest_runner Byebug::BreakAtLinesTestCase
+example: `script/minitest_runner.rb Byebug::BreakAtLinesTestCase
 test_catch_removes_specific_catchpoint`
 
 

data/GUIDE.md

@@ -297,98 +297,7 @@ false
 `private_methods` is not a byebug command but a Ruby feature. By default, when
 `byebug` doesn't understand a command, it will evaluate it as if it was a Ruby
 command. You can use any Ruby to inspect your program's state at the place it
-is stopped. Additional, `byebug` provides a specific evaluation command, `ps`
-that automatically enhances the evaluated results a bit. For example, it
-automatically sorts arrays.
-
-```
-[:Array,
- :Complex,
- :DelegateClass,
- :Digest,
- :Float,
- :Hash,
- :Integer,
- :Pathname,
- :Rational,
- :String,
- :URI,
- :__callee__,
- :__dir__,
- :__method__,
- :`,
- :abort,
- :at_exit,
- :autoload,
- :autoload?,
- :binding,
- :block_given?,
- :caller,
- :caller_locations,
- :catch,
- :default_src_encoding,
- :define_method,
- :eval,
- :exec,
- :exit,
- :exit!,
- :fail,
- :fork,
- :format,
- :gem_original_require,
- :gets,
- :global_variables,
- :include,
- :initialize,
- :initialize_clone,
- :initialize_copy,
- :initialize_dup,
- :iterator?,
- :lambda,
- :load,
- :local_variables,
- :loop,
- :method_missing,
- :open,
- :p,
- :pp,
- :print,
- :printf,
- :private,
- :proc,
- :public,
- :putc,
- :puts,
- :raise,
- :rand,
- :readline,
- :readlines,
- :require,
- :require_relative,
- :respond_to_missing?,
- :rubygems_require,
- :select,
- :set_trace_func,
- :singleton_method_added,
- :singleton_method_removed,
- :singleton_method_undefined,
- :sleep,
- :spawn,
- :sprintf,
- :srand,
- :syscall,
- :system,
- :test,
- :throw,
- :timeout,
- :trace_var,
- :trap,
- :untrace_var,
- :using,
- :warn,
- :y]
-
-```
+is stopped.
 
 Now let's see what happens after stepping:
 
@@ -766,7 +675,7 @@ $ byebug primes.rb
     8:
     9:   def self.next_prime(&block)
    10:    candidate = 2
-(byebug) set tracing
+(byebug) set linetrace
 line tracing is on.
 (byebug) set basename
 basename in on.
@@ -1553,7 +1462,6 @@ short list of named classes of commands
   method     -- Shows methods of an object, class or module
   next       -- Runs one or more lines of code
   pry        -- Starts a Pry session
-  ps         -- Evaluates an expression and prettyprints & sort the result
   quit       -- Exits byebug
   restart    -- Restarts the debugged program
   save       -- Saves current byebug session to a file
@@ -1768,10 +1676,10 @@ basically listing `<object>.instance_variables`.
 * `var global`. Show global variables.
 * `var all`. Show local, global and instance and class variables of `self`.
 * `method instance <object>`. Show methods of `<object>`. Basically this is the
-same as running `ps <object>.instance_methods(false)`.
+same as running `<object>.instance_methods(false)`.
 * `method <class-or-module>`. Show methods of the class or module
-`<class-or-module>`. Basically this is the same as running `ps
-<class-or-module>.methods`.
+`<class-or-module>`. Basically this is the same as running
+`<class-or-module>.methods`.
 
 ### Examining Program Source Files: list
 

data/README.md

@@ -1,19 +1,22 @@
 # Byebug
 
-[![Ver][gem]][gem_url]
-[![Gpa][gpa]][gpa_url]
-[![Cov][cov]][cov_url]
-[![Git][tip]][tip_url]
+[![Version][gem]][gem_url]
+[![Quality][gpa]][gpa_url]
+[![Coverage][cov]][cov_url]
+[![Gratipay][tip]][tip_url]
+[![Gitter][irc]][irc_url]
 
 [gem]: https://img.shields.io/gem/v/byebug.svg
 [gpa]: https://img.shields.io/codeclimate/github/deivid-rodriguez/byebug.svg
 [cov]: https://img.shields.io/codeclimate/coverage/github/deivid-rodriguez/byebug.svg
 [tip]: https://img.shields.io/gittip/deivid-rodriguez.svg
+[irc]: https://img.shields.io/badge/IRC%20(gitter)-devs%20%26%20users-brightgreen.svg
 
 [gem_url]: https://rubygems.org/gems/byebug
 [gpa_url]: https://codeclimate.com/github/deivid-rodriguez/byebug
 [cov_url]: https://codeclimate.com/github/deivid-rodriguez/byebug
 [tip_url]: https://www.gittip.com/deivid-rodriguez
+[irc_url]: https://gitter.im/deivid-rodriguez/byebug
 
 _Debugging in Ruby 2_
 
@@ -99,12 +102,11 @@ are debugging rails, start the server and once the execution gets to your
     `method`    |              | `instance`
     `next`      |              |
     `pry`       |              |
-    `ps`        |              |
     `quit`      |              |
     `restart`   |              |
     `save`      |              |
-    `set`       |              | `autoirb` `autolist` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `width`
-    `show`      |              | `autoirb` `autolist` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `width`
+    `set`       |              | `autoirb` `autolist` `autopry` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `width`
+    `show`      |              | `autoirb` `autolist` `autopry` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `width`
     `source`    |              |
     `step`      |              |
     `thread`    |              | `current` `list` `resume` `stop` `switch`

data/ext/byebug/breakpoint.c

@@ -38,17 +38,17 @@ brkpt_enabled(VALUE self)
 
 /*
  *  call-seq:
- *    breakpoint.enabled = bool
+ *    breakpoint.enabled = true | false
  *
  *  Enables or disables breakpoint.
  */
 static VALUE
-brkpt_set_enabled(VALUE self, VALUE bool)
+brkpt_set_enabled(VALUE self, VALUE enabled)
 {
   breakpoint_t *breakpoint;
 
   Data_Get_Struct(self, breakpoint_t, breakpoint);
-  return breakpoint->enabled = bool;
+  return breakpoint->enabled = enabled;
 }
 
 /*

data/ext/byebug/byebug.c

@@ -13,6 +13,7 @@ static VALUE tracepoints = Qnil;
 static VALUE raised_exception = Qnil;
 
 static ID idPuts;
+static ID idEmpty;
 
 /* Hash table with active threads and their associated contexts */
 VALUE threads = Qnil;
@@ -63,6 +64,7 @@ Raised_exception(VALUE self)
 }
 
 #define IS_STARTED  (catchpoints != Qnil)
+
 static void
 check_started()
 {
@@ -157,20 +159,32 @@ cleanup(debug_context_t * dc)
     trace_print(trace_arg, dc, 0, 0);                   \
 
 
+#define CALL_EVENT_SETUP                                      \
+  dc->calced_stack_size++;                                    \
+  dc->steps_out = dc->steps_out < 0 ? -1 : dc->steps_out + 1;
+
+#define RETURN_EVENT_SETUP \
+  dc->calced_stack_size--; \
+                           \
+  if (dc->steps_out == 1)  \
+    dc->steps = 1;
+
+#define RETURN_EVENT_TEARDOWN \
+  dc->steps_out = dc->steps_out <= 0 ? -1 : dc->steps_out - 1;
+
+
 /* Functions that return control to byebug after the different events */
 
 static VALUE
-call_at(VALUE context_obj, debug_context_t * dc, ID mid, int argc, VALUE a0,
-        VALUE a1)
+call_at(VALUE ctx, debug_context_t * dc, ID mid, int argc, VALUE arg)
 {
   struct call_with_inspection_data cwi;
-  VALUE argv[2];
+  VALUE argv[1];
 
-  argv[0] = a0;
-  argv[1] = a1;
+  argv[0] = arg;
 
   cwi.dc = dc;
-  cwi.context_obj = context_obj;
+  cwi.ctx = ctx;
   cwi.id = mid;
   cwi.argc = argc;
   cwi.argv = &argv[0];
@@ -179,49 +193,52 @@ call_at(VALUE context_obj, debug_context_t * dc, ID mid, int argc, VALUE a0,
 }
 
 static VALUE
-call_at_line(VALUE context_obj, debug_context_t * dc, VALUE file, VALUE line)
+call_at_line(VALUE ctx, debug_context_t * dc)
 {
-  return call_at(context_obj, dc, rb_intern("at_line"), 2, file, line);
+  return call_at(ctx, dc, rb_intern("at_line"), 0, Qnil);
 }
 
 static VALUE
-call_at_tracing(VALUE context_obj, debug_context_t * dc, VALUE file, VALUE line)
+call_at_tracing(VALUE ctx, debug_context_t * dc)
 {
-  return call_at(context_obj, dc, rb_intern("at_tracing"), 2, file, line);
+  return call_at(ctx, dc, rb_intern("at_tracing"), 0, Qnil);
 }
 
 static VALUE
-call_at_breakpoint(VALUE context_obj, debug_context_t * dc, VALUE breakpoint)
+call_at_breakpoint(VALUE ctx, debug_context_t * dc, VALUE breakpoint)
 {
   dc->stop_reason = CTX_STOP_BREAKPOINT;
-  return call_at(context_obj, dc, rb_intern("at_breakpoint"), 1, breakpoint, 0);
+
+  return call_at(ctx, dc, rb_intern("at_breakpoint"), 1, breakpoint);
 }
 
 static VALUE
-call_at_catchpoint(VALUE context_obj, debug_context_t * dc, VALUE exp)
+call_at_catchpoint(VALUE ctx, debug_context_t * dc, VALUE exp)
 {
   dc->stop_reason = CTX_STOP_CATCHPOINT;
-  return call_at(context_obj, dc, rb_intern("at_catchpoint"), 1, exp, 0);
+
+  return call_at(ctx, dc, rb_intern("at_catchpoint"), 1, exp);
 }
 
 static VALUE
-call_at_return(VALUE context_obj, debug_context_t * dc, VALUE file, VALUE line)
+call_at_return(VALUE ctx, debug_context_t * dc, VALUE return_value)
 {
   dc->stop_reason = CTX_STOP_BREAKPOINT;
-  return call_at(context_obj, dc, rb_intern("at_return"), 2, file, line);
+
+  return call_at(ctx, dc, rb_intern("at_return"), 1, return_value);
 }
 
 static void
-call_at_line_check(VALUE context_obj, debug_context_t * dc, VALUE breakpoint,
-                   VALUE file, VALUE line)
+call_at_line_check(VALUE ctx, debug_context_t * dc, VALUE breakpoint)
 {
   dc->stop_reason = CTX_STOP_STEP;
 
   if (breakpoint != Qnil)
-    call_at_breakpoint(context_obj, dc, breakpoint);
+    call_at_breakpoint(ctx, dc, breakpoint);
 
   reset_stepping_stop_points(dc);
-  call_at_line(context_obj, dc, file, line);
+
+  call_at_line(ctx, dc);
 }
 
 
@@ -239,7 +256,7 @@ line_event(VALUE trace_point, void *data)
   binding = rb_tracearg_binding(trace_arg);
 
   if (RTEST(tracing))
-    call_at_tracing(context, dc, file, line);
+    call_at_tracing(context, dc);
 
   if (!CTX_FL_TEST(dc, CTX_FL_IGNORE_STEPS))
     dc->steps = dc->steps <= 0 ? -1 : dc->steps - 1;
@@ -253,7 +270,7 @@ line_event(VALUE trace_point, void *data)
   }
 
   if (dc->steps == 0 || dc->lines == 0)
-    call_at_line_check(context, dc, Qnil, file, line);
+    call_at_line_check(context, dc, Qnil);
 
   brkpnt = Qnil;
 
@@ -261,7 +278,7 @@ line_event(VALUE trace_point, void *data)
     brkpnt = find_breakpoint_by_pos(breakpoints, file, line, binding);
 
   if (!NIL_P(brkpnt))
-    call_at_line_check(context, dc, brkpnt, file, line);
+    call_at_line_check(context, dc, brkpnt);
 
   EVENT_TEARDOWN;
 }
@@ -269,16 +286,14 @@ line_event(VALUE trace_point, void *data)
 static void
 call_event(VALUE trace_point, void *data)
 {
-  VALUE brkpnt, klass, msym, mid, binding, self, file, line;
+  VALUE brkpnt, klass, msym, mid, binding, self;
 
   EVENT_SETUP;
 
   if (dc->calced_stack_size <= dc->dest_frame)
     CTX_FL_UNSET(dc, CTX_FL_IGNORE_STEPS);
 
-  dc->calced_stack_size++;
-
-  dc->steps_out = dc->steps_out <= 0 ? -1 : dc->steps_out + 1;
+  CALL_EVENT_SETUP;
 
   /* nil method_id means we are at top level so there can't be a method
    * breakpoint here. Just leave then. */
@@ -293,8 +308,6 @@ call_event(VALUE trace_point, void *data)
   klass = rb_tracearg_defined_class(trace_arg);
   binding = rb_tracearg_binding(trace_arg);
   self = rb_tracearg_self(trace_arg);
-  file = rb_tracearg_path(trace_arg);
-  line = rb_tracearg_lineno(trace_arg);
 
   brkpnt = Qnil;
 
@@ -304,7 +317,7 @@ call_event(VALUE trace_point, void *data)
   if (!NIL_P(brkpnt))
   {
     call_at_breakpoint(context, dc, brkpnt);
-    call_at_line(context, dc, file, line);
+    call_at_line(context, dc);
   }
 
   EVENT_TEARDOWN;
@@ -313,23 +326,26 @@ call_event(VALUE trace_point, void *data)
 static void
 return_event(VALUE trace_point, void *data)
 {
+  VALUE return_value;
+
   EVENT_SETUP;
 
-  dc->calced_stack_size--;
+  RETURN_EVENT_SETUP;
 
-  if (dc->steps_out == 1)
-    dc->steps = 1;
-  else if ((dc->steps_out == 0) && (CTX_FL_TEST(dc, CTX_FL_STOP_ON_RET)))
+  if ((dc->steps_out == 0) && (CTX_FL_TEST(dc, CTX_FL_STOP_ON_RET)))
   {
-    VALUE file, line;
-
     reset_stepping_stop_points(dc);
-    file = rb_tracearg_path(trace_arg);
-    line = rb_tracearg_lineno(trace_arg);
-    call_at_return(context, dc, file, line);
+
+    if (rb_tracearg_event_flag(trace_arg) &
+        (RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN))
+      return_value = rb_tracearg_return_value(trace_arg);
+    else
+      return_value = Qnil;
+
+    call_at_return(context, dc, return_value);
   }
 
-  dc->steps_out = dc->steps_out <= 0 ? -1 : dc->steps_out - 1;
+  RETURN_EVENT_TEARDOWN;
 
   EVENT_TEARDOWN;
 }
@@ -339,7 +355,7 @@ raw_call_event(VALUE trace_point, void *data)
 {
   EVENT_SETUP;
 
-  dc->calced_stack_size++;
+  CALL_EVENT_SETUP;
 
   EVENT_TEARDOWN;
 }
@@ -349,7 +365,9 @@ raw_return_event(VALUE trace_point, void *data)
 {
   EVENT_SETUP;
 
-  dc->calced_stack_size--;
+  RETURN_EVENT_SETUP;
+
+  RETURN_EVENT_TEARDOWN;
 
   EVENT_TEARDOWN;
 }
@@ -357,14 +375,12 @@ raw_return_event(VALUE trace_point, void *data)
 static void
 raise_event(VALUE trace_point, void *data)
 {
-  VALUE expn_class, ancestors, path, lineno, pm_context;
+  VALUE expn_class, ancestors, pm_context;
   int i;
   debug_context_t *new_dc;
 
   EVENT_SETUP;
 
-  path = rb_tracearg_path(trace_arg);
-  lineno = rb_tracearg_lineno(trace_arg);
   raised_exception = rb_tracearg_raised_exception(trace_arg);
 
   if (post_mortem == Qtrue)
@@ -397,8 +413,10 @@ raise_event(VALUE trace_point, void *data)
     if (hit_count != Qnil)
     {
       rb_hash_aset(catchpoints, module_name, INT2FIX(FIX2INT(hit_count) + 1));
+
       call_at_catchpoint(context, dc, raised_exception);
-      call_at_line(context, dc, path, lineno);
+      call_at_line(context, dc);
+
       break;
     }
   }
@@ -540,8 +558,6 @@ Current_context(VALUE self)
 
   UNUSED(self);
 
-  check_started();
-
   thread_context_lookup(rb_thread_current(), &context);
 
   return context;
@@ -579,7 +595,6 @@ Stop(VALUE self)
 
     breakpoints = Qnil;
     catchpoints = Qnil;
-    threads = Qnil;
 
     return Qfalse;
   }
@@ -587,6 +602,36 @@ Stop(VALUE self)
   return Qtrue;
 }
 
+static VALUE
+Stoppable(VALUE self)
+{
+  VALUE context;
+  debug_context_t *dc;
+
+  if (!IS_STARTED)
+    return Qfalse;
+
+  if (breakpoints != Qnil && rb_funcall(breakpoints, idEmpty, 0) == Qfalse)
+    return Qfalse;
+
+  if (catchpoints != Qnil && rb_funcall(catchpoints, idEmpty, 0) == Qfalse)
+    return Qfalse;
+
+  if (post_mortem == Qtrue)
+    return Qfalse;
+
+  context = Current_context(self);
+  if (context != Qnil)
+  {
+    Data_Get_Struct(context, debug_context_t, dc);
+
+    if (dc->steps > 0)
+      return Qfalse;
+  }
+
+  return Qtrue;
+}
+
 /*
  *  call-seq:
  *    Byebug.start -> bool
@@ -750,6 +795,7 @@ Init_byebug()
   rb_define_module_function(mByebug, "start", Start, 0);
   rb_define_module_function(mByebug, "started?", Started, 0);
   rb_define_module_function(mByebug, "stop", Stop, 0);
+  rb_define_module_function(mByebug, "stoppable?", Stoppable, 0);
   rb_define_module_function(mByebug, "thread_context", Thread_context, 1);
   rb_define_module_function(mByebug, "tracing?", Tracing, 0);
   rb_define_module_function(mByebug, "tracing=", Set_tracing, 1);
@@ -765,4 +811,5 @@ Init_byebug()
   rb_global_variable(&threads);
 
   idPuts = rb_intern("puts");
+  idEmpty = rb_intern("empty?");
 }

data/ext/byebug/byebug.h

@@ -54,7 +54,7 @@ typedef enum {
 
 struct call_with_inspection_data {
   debug_context_t *dc;
-  VALUE context_obj;
+  VALUE ctx;
   ID id;
   int argc;
   VALUE *argv;

data/ext/byebug/context.c

@@ -168,7 +168,7 @@ open_debug_inspector_i(const rb_debug_inspector_t * inspector, void *data)
 
   cwi->dc->backtrace = load_backtrace(inspector);
 
-  return rb_funcall2(cwi->context_obj, cwi->id, cwi->argc, cwi->argv);
+  return rb_funcall2(cwi->ctx, cwi->id, cwi->argc, cwi->argv);
 }
 
 static VALUE
@@ -344,7 +344,7 @@ Context_resume(VALUE self)
 
 /*
  *  call-seq:
- *    context.backtrace-> int
+ *    context.backtrace-> Array
  *
  *  Returns the frame stack of a context.
  */

data/lib/byebug.rb

@@ -1,2 +1 @@
-require 'byebug/core'
 require 'byebug/attacher'

data/lib/byebug/attacher.rb

@@ -7,6 +7,8 @@ module Byebug
   # events occur. Before entering byebug the init script is read.
   #
   def self.attach
+    require 'byebug/core'
+
     unless started?
       self.mode = :attached
 
@@ -14,7 +16,7 @@ module Byebug
       run_init_script
     end
 
-    current_context.step_out(2, true)
+    current_context.step_out(3, true)
   end
 end
 

data/lib/byebug/commands.rb

@@ -20,7 +20,6 @@ require 'byebug/commands/list'
 require 'byebug/commands/method'
 require 'byebug/commands/next'
 require 'byebug/commands/pry'
-require 'byebug/commands/ps'
 require 'byebug/commands/quit'
 require 'byebug/commands/restart'
 require 'byebug/commands/save'

data/lib/byebug/commands/continue.rb

@@ -41,6 +41,8 @@ module Byebug
       end
 
       processor.proceed!
+
+      Byebug.stop if Byebug.stoppable?
     end
   end
 end

data/lib/byebug/commands/history.rb

@@ -16,7 +16,7 @@ module Byebug
 
     def self.description
       <<-EOD
-        hist[ory] [num_cmds]
+        hist[ory][ num_cmds]
 
         #{short_description}
       EOD
@@ -29,10 +29,7 @@ module Byebug
     def execute
       history = processor.interface.history
 
-      if @match[:num_cmds]
-        size, err = get_int(@match[:num_cmds], 'history', 1, history.size)
-        return errmsg(err) unless size
-      end
+      size, = get_int(@match[:num_cmds], 'history', 1) if @match[:num_cmds]
 
       puts history.to_s(size)
     end

data/lib/byebug/commands/info/breakpoints.rb

@@ -54,7 +54,7 @@ module Byebug
         return unless hits > 0
 
         s = (hits > 1) ? 's' : ''
-        puts "\tbreakpoint already hit #{hits} time#{s}"
+        puts "  breakpoint already hit #{hits} time#{s}"
       end
     end
   end

data/lib/byebug/context.rb

@@ -89,35 +89,35 @@ module Byebug
     end
 
     def at_breakpoint(breakpoint)
-      new_processor.at_breakpoint(breakpoint)
+      processor.at_breakpoint(breakpoint)
     end
 
     def at_catchpoint(exception)
-      new_processor.at_catchpoint(exception)
+      processor.at_catchpoint(exception)
     end
 
-    def at_tracing(file, _line)
+    def at_tracing
       return if ignored_file?(file)
 
-      new_processor.at_tracing
+      processor.at_tracing
     end
 
-    def at_line(file, _l)
+    def at_line
       self.frame = 0
       return if ignored_file?(file)
 
-      new_processor.at_line
+      processor.at_line
     end
 
-    def at_return(file, _line)
+    def at_return(return_value)
       return if ignored_file?(file)
 
-      new_processor.at_return
+      processor.at_return(return_value)
     end
 
     private
 
-    def new_processor
+    def processor
       @processor ||= self.class.processor.new(self)
     end
   end

data/lib/byebug/helpers/eval.rb

@@ -64,7 +64,7 @@ module Byebug
         at = e.backtrace
 
         locations = ["#{at.shift}: #{warning_msg(e)}"]
-        locations += at.map { |path| "\tfrom #{path}" }
+        locations += at.map { |path| "  from #{path}" }
         locations.join("\n")
       end
 
@@ -80,11 +80,26 @@ module Byebug
       # will get blocked by byebug's main thread.
       #
       def allowing_other_threads
+        res = nil
         Byebug.unlock
-        res = yield
+
+        Thread.new { res = yield }.join
+
         Byebug.lock
         res
       end
+
+      def safe_inspect(var)
+        var.inspect
+      rescue
+        safe_to_s(var)
+      end
+
+      def safe_to_s(var)
+        var.to_s
+      rescue
+        '*Error in evaluation*'
+      end
     end
   end
 end

data/lib/byebug/helpers/var.rb

@@ -47,20 +47,6 @@ module Byebug
         locals = all_locals.select { |k, _| arg_values.include?(k) }
         puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, 'instance')
       end
-
-      private
-
-      def safe_inspect(var)
-        var.inspect
-      rescue
-        safe_to_s(var)
-      end
-
-      def safe_to_s(var)
-        var.to_s
-      rescue
-        '*Error in evaluation*'
-      end
     end
   end
 end

data/lib/byebug/interfaces/local_interface.rb

@@ -3,6 +3,8 @@ module Byebug
   # Interface class for standard byebug use.
   #
   class LocalInterface < Interface
+    EOF_ALIAS = 'continue'
+
     def initialize
       super()
       @input = STDIN
@@ -13,12 +15,12 @@ module Byebug
     #
     # Reads a single line of input using Readline. If Ctrl-C is pressed in the
     # middle of input, the line is reset to only the prompt and we ask for input
-    # again.
+    # again. If Ctrl-D is pressed, it returns "continue".
     #
     # @param prompt Prompt to be displayed.
     #
     def readline(prompt)
-      Readline.readline(prompt, false)
+      Readline.readline(prompt, false) || EOF_ALIAS
     rescue Interrupt
       puts('^C')
       retry

data/lib/byebug/interfaces/test_interface.rb

@@ -13,15 +13,15 @@ module Byebug
     end
 
     def errmsg(message)
-      error.concat(message.to_s.split("\n"))
+      error.concat(prepare(message))
     end
 
     def print(message)
-      output.concat(message.to_s.split("\n"))
+      output.concat(prepare(message))
     end
 
     def puts(message)
-      output.concat(message.to_s.split("\n"))
+      output.concat(prepare(message))
     end
 
     def read_command(prompt)
@@ -54,5 +54,13 @@ module Byebug
       cmd = input.shift
       cmd.is_a?(Proc) ? cmd.call : cmd
     end
+
+    private
+
+    def prepare(message)
+      return message.map(&:to_s) if message.respond_to?(:map)
+
+      message.to_s.split("\n")
+    end
   end
 end

data/lib/byebug/option_setter.rb

@@ -31,7 +31,7 @@ module Byebug
     end
 
     def include_flag
-      @opts.on('-I', '--include list', 'Add to paths to $LOAD_PATH') do |list|
+      @opts.on '-I', '--include list', 'Add to paths to $LOAD_PATH' do |list|
         $LOAD_PATH.push(list.split(':')).flatten!
       end
     end
@@ -85,7 +85,7 @@ module Byebug
     end
 
     def help
-      @opts.on('-h', '--help', 'Display this message') do
+      @opts.on '-h', '--help', 'Display this message' do
         @runner.help = @opts.help
       end
     end

data/lib/byebug/printers/texts/plain.yml

@@ -15,7 +15,7 @@ method:
   methods: "{name}|c"
 
 restart:
-  success: "Re exec'ing:\n\t{cmd}"
+  success: "Re exec'ing:\n  {cmd}"
 
 thread:
   context: "{status_flag}{debug_flag}{id} {thread} {file_line}"

data/lib/byebug/processors/command_processor.rb

@@ -26,7 +26,7 @@ module Byebug
     end
 
     def interface
-      @interface ||= context.class.interface
+      @interface ||= Context.interface
     end
 
     def printer
@@ -68,14 +68,16 @@ module Byebug
     def at_tracing
       puts "Tracing: #{context.full_location}"
 
-      run_auto_commands(2)
+      run_auto_cmds(2)
     end
 
     def at_line
       process_commands
     end
 
-    def at_return
+    def at_return(return_value)
+      puts "Return value is: #{safe_inspect(return_value)}"
+
       process_commands
     end
 
@@ -108,22 +110,24 @@ module Byebug
 
     private
 
-    def auto_commands_for(run_level)
+    def auto_cmds_for(run_level)
       command_list.select { |cmd| cmd.always_run >= run_level }
     end
 
     #
     # Run permanent commands.
     #
-    def run_auto_commands(run_level)
-      auto_commands_for(run_level).each { |cmd| cmd.new(self).execute }
+    def run_auto_cmds(run_level)
+      safely do
+        auto_cmds_for(run_level).each { |cmd| cmd.new(self).execute }
+      end
     end
 
     def before_repl
       @proceed = false
       @prev_line = nil
 
-      run_auto_commands(1)
+      run_auto_cmds(1)
       interface.autorestore
     end
 
@@ -152,10 +156,16 @@ module Byebug
     # command is not found, it evaluates the unknown input.
     #
     def run_cmd(input)
-      command = command_list.match(input)
-      return command.new(self, input).execute if command
+      safely do
+        command = command_list.match(input)
+        return command.new(self, input).execute if command
+
+        puts safe_inspect(thread_safe_eval(input))
+      end
+    end
 
-      puts thread_safe_eval(input)
+    def safely
+      yield
     rescue => e
       errmsg(e.message)
     end

data/lib/byebug/processors/control_processor.rb

@@ -3,6 +3,10 @@ module Byebug
   # Processes commands when there's not program running
   #
   class ControlProcessor < CommandProcessor
+    def initialize(context = nil)
+      @context = context
+    end
+
     #
     # Available commands
     #

data/lib/byebug/processors/script_processor.rb

@@ -27,7 +27,7 @@ module Byebug
     rescue
       without_exceptions do
         puts "INTERNAL ERROR!!! #{$ERROR_INFO}"
-        puts $ERROR_INFO.backtrace.map { |l| "\t#{l}" }.join("\n")
+        puts $ERROR_INFO.backtrace.map { |l| "  #{l}" }.join("\n")
       end
     end
 

data/lib/byebug/remote.rb

@@ -62,7 +62,7 @@ module Byebug
         while (session = server.accept)
           Context.interface = RemoteInterface.new(session)
 
-          ControlCommandProcessor.new(Byebug.current_context).process_commands
+          ControlProcessor.new(Byebug.current_context).process_commands
         end
       end
 

data/lib/byebug/runner.rb

@@ -38,6 +38,11 @@ module Byebug
     #
     attr_accessor :quit
 
+    #
+    # Signals that we should stop before program starts
+    #
+    attr_accessor :stop
+
     #
     # @param stop [Boolean] Whether the runner should stop right before
     # starting the program.
@@ -102,6 +107,8 @@ module Byebug
       end
     end
 
+    attr_writer :interface
+
     def interface
       @interface ||= LocalInterface.new
     end
@@ -139,7 +146,7 @@ module Byebug
       ok = syntax_valid?(File.read($PROGRAM_NAME))
       fail(InvalidScript, 'The script has incorrect syntax') unless ok
 
-      error = Byebug.debug_load($PROGRAM_NAME, @stop)
+      error = Byebug.debug_load($PROGRAM_NAME, stop)
       puts "#{error}\n#{error.backtrace}" if error
     end
 

data/lib/byebug/settings/autopry.rb

@@ -0,0 +1,27 @@
+require 'byebug/setting'
+require 'byebug/commands/pry'
+
+module Byebug
+  #
+  # Setting for automatically invoking Pry on every stop.
+  #
+  class AutoprySetting < Setting
+    DEFAULT = 0
+
+    def initialize
+      PryCommand.always_run = DEFAULT
+    end
+
+    def banner
+      'Invoke Pry on every stop'
+    end
+
+    def value=(v)
+      PryCommand.always_run = v ? 1 : 0
+    end
+
+    def value
+      PryCommand.always_run == 1
+    end
+  end
+end

data/lib/byebug/version.rb

@@ -2,5 +2,5 @@
 # Reopen main module to define the library version
 #
 module Byebug
-  VERSION = '6.0.2'
+  VERSION = '7.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: byebug
 version: !ruby/object:Gem::Version
-  version: 6.0.2
+  version: 7.0.0
 platform: ruby
 authors:
 - David Rodriguez
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-20 00:00:00.000000000 Z
+date: 2015-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,7 +94,6 @@ files:
 - lib/byebug/commands/method.rb
 - lib/byebug/commands/next.rb
 - lib/byebug/commands/pry.rb
-- lib/byebug/commands/ps.rb
 - lib/byebug/commands/quit.rb
 - lib/byebug/commands/restart.rb
 - lib/byebug/commands/save.rb
@@ -154,6 +153,7 @@ files:
 - lib/byebug/setting.rb
 - lib/byebug/settings/autoirb.rb
 - lib/byebug/settings/autolist.rb
+- lib/byebug/settings/autopry.rb
 - lib/byebug/settings/autosave.rb
 - lib/byebug/settings/basename.rb
 - lib/byebug/settings/callstyle.rb

data/lib/byebug/commands/ps.rb

@@ -1,42 +0,0 @@
-require 'English'
-require 'pp'
-require 'byebug/command'
-require 'byebug/helpers/eval'
-
-module Byebug
-  #
-  # Enhanced evaluation of expressions from byebug's prompt. Besides
-  # evaluating, it sorts and pretty prints arrays.
-  #
-  class PsCommand < Command
-    include Helpers::EvalHelper
-
-    self.allow_in_post_mortem = true
-
-    def self.regexp
-      /^\s* ps (\s+ (.+)) \s*$/x
-    end
-
-    def self.description
-      <<-EOD
-        ps <expression>
-
-        #{short_description}
-      EOD
-    end
-
-    def self.short_description
-      'Evaluates an expression and prettyprints & sort the result'
-    end
-
-    def execute
-      return puts(help) unless @match[1]
-
-      res = thread_safe_eval(@match[1])
-      res = res.sort if res.respond_to?(:sort)
-
-      out = PP.pp(res, StringIO.new, Setting[:width])
-      print pr('eval.result', expr: @match[1], result: out.string)
-    end
-  end
-end