byebug 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2380cd5fcec35d3f595370d2616036b95d6431a9
-  data.tar.gz: c4d94d6eaf87f359546b4b0d490a17a6e7f436cf
+  metadata.gz: 929419c640bdf958d5322f770be797f1d8bfd0c0
+  data.tar.gz: 6697013f9ff97a9e453cf777041f4108c3274c65
 SHA512:
-  metadata.gz: c84394861f16b1ddffd011f93665e4c8a11234c50c697ce9abafd7fee41e992d363e38026083f6f9ef16d4ca8578b1f7705e630c82d9694b45c5f0c47797c94c
-  data.tar.gz: 5fe396fa9105f429a5da215e14507a0160376a0a36c29dc788fcd9e467ab24d84b57022b8914acf7a52305cfc4cf87eb65add335fb2825d48cb180ddc7c02b21
+  metadata.gz: 62ad75b1a082c60a1cfe65c13fd654c538006cfcb0c02fc751658994a838b8e365ce659428e3381a4a4393feab58f62dec9268afd040bf1c4ebcc21f46a41f56
+  data.tar.gz: 21a6754ad1fa31fda1564c44fb1786c55de5d2f30e13c82fe8a8319ec70b62df8ec43499df3d1e95fd126a4c00aacb597e555c6ff488b711471ad1cd2f39c12c

data/.travis.yml

@@ -1,3 +1,8 @@
+before_install: gem install bundler
 before_script: rake compile
 rvm:
 - 2.0.0
+- ruby-head
+matrix:
+  allow_failures:
+  - rvm: ruby-head

data/CHANGELOG.md

@@ -1,6 +1,16 @@
+## 1.4.2
+
+* Fixes crash when using "help command subcommand"
+* Byebug now works with Rails Console debugging flag
+* Fix post-mortem mode when running byebug from the outset
+* Fix --no-quit flag when running byebug from the outset
+
+
 ## 1.4.1
 
 * Fixes crash when printing some filenames in backtraces
+* Allows byebug developers to easily use compilers different from gcc (thanks
+@GarthSnyder!)
 
 
 ## 1.4.0

data/GUIDE.md

@@ -669,9 +669,9 @@ Options:
  -d, --debug               Set $DEBUG=true
  -I, --include PATH        Add PATH (single or multiple:path:list) to $LOAD_PATH
      --no-quit             Do not quit when script finishes
-     --no-rewrite-program  Don't set $0 to the program debugged
      --no-stop             Do not stop when script is loaded
- -nx                       Don't run any byebug initialization files
+     --nx                  Don't run any byebug initialization files
+     --post-mortem         Enable post-mortem mode for uncaught exceptions
  -r, --require SCRIPT      Require library before script
      --restart-script FILE Name of the script file to run. Erased after read
      --script FILE         Name of the script file to run
@@ -697,13 +697,10 @@ information without having to poll for it.
 * **-d | --debug**. Set `$DEBUG` to `true`. Compatible with Ruby's.
 * **-I | --include <path>**. Add `path` to load path. `path` can be a single
 path ar a colon separated path list.
-* **-m | --post-mortem**. If your program raises an exception that isn't caught
-you can enter byebug for inspection of what went wrong. You may also want to use
+* **--post-mortem**. If your program raises an exception that isn't caught you
+can enter byebug for inspection of what went wrong. You may also want to use
 this option in conjunction with `--no-stop`. See also [Post-Mortem Debugging]().
 * **--no-quit**. Restart `byebug` when your program terminates normally.
-* **--no-rewrite-program**. Normally `byebug` will reset the program's name `$0`
-from its name to the debugged program, and set the name in variable
-`$BYEBUG_SCRIPT`. In the unlikely event you don't want to use this option.
 * **--no-stop**. Normally `byebug` stops before executing the first statement.
 If instead you want it to start running initially and perhaps break it later in
 the execution, use this option.
@@ -753,6 +750,235 @@ puts "rocky's byebugrc run"
 Here are the default values in `options`
 
 ```ruby
-#<OpenStruct annotate=nil, no_rewrite_program=false, nx=false, quit=true,
-restart_script=nil, script=nil, stop=true, tracing=false, verbose_long=false>
+#<OpenStruct annotate=nil, nx=false, quit=true, restart_script=nil, script=nil,
+stop=true, tracing=false, verbose_long=false>
+```
+
+## 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
+nothing; it does not mean to repeat the last command, as it would from the
+terminal.
+
+When you start `byebug`, it automatically executes commands from its
+_init file_, called `.byebugrc`. During startup, `byebug` does the following:
+
+* __Processes command line options and operands.__ Reads the init file in your
+current directory, if any, and then checks your home directory. The home
+directory is the directory named in the `$HOME` or `$HOMEPATH` environment
+variable. Thus, you can have more than one init file, one generic in your home
+directory, and another, specific to the program you are debugging, in the
+directory where you invoke `byebug`.
+
+* __Reads command files specified by the `--script` option.__
+
+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).
+
+## 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
+are debugging. And this can lead to unexpected and unwanted differences. It has
+happened so often that the term
+[Heisenbugs](http://en.wikipedia.org/wiki/Heisenbug}) was coined to describe the
+situation where using a debugger (among other possibilities) changes the
+behavior of the program so that the bug doesn't manifest itself anymore.
+
+There is another way to get into byebug which adds no overhead or slowdown until
+you reach the point at which you want to start debugging. However here you must
+change the script and make an explicit call to byebug. Because byebug isn't
+involved before the first call, there is no overhead and the script will run
+at the same speed as if there were no byebug.
+
+There are three parts to calling byebug from inside the script, ``requiring''
+the gem, telling byebug to start tracking things and then making an explicit
+breakpoints.
+
+Unless you're using bundler, do this to get byebug class accessible from your
+Ruby program
+
+```ruby
+require 'byebug'
+```
+
+To tell byebug to start tracking things, do
+
+```ruby
+Byebug.start
+```
+
+There is also a `Byebug.stop` to turn off byebug tracking. If speed is crucial,
+you may want to start and stop this around certain sections of code.
+Alternatively, instead of issuing an explicit `Byebug.stop` you can add a block
+to the `Byebug.start` and debugging is turned on for that block. If the block of
+code raises an uncaught exception that would cause the block to terminate, the
+`stop` will occur.  See [here](Byebug.start with a block).
+
+And finally to enter byebug
+
+```ruby
+byebug
+```
+
+When `byebug`is run, `.byebugrc` is read.
+
+You may want to enter byebug at several points in the program where there is a
+problem you want to investigate. And since `byebug` is just a method call it's
+possible to enclose it in a conditional expression, for example
+
+```ruby
+byebug if 'bar' == foo and 20 == iter_count
+```
+
+## Byebug Command Reference
+
+## 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
+number of times to step, as in `step 5`. You can also use the `step` command with no
+arguments. Some commands do not allow any arguments.
+
+Multiple commands can be put on a line by separating each with a semicolon `;`. You
+can disable the meaning of a semicolon to separate commands by escaping it with a
+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.
+
+```
+(byebug) fib1=0; fib2=1; 5.times {|temp| temp=fib1; fib1=fib2; fib2 += temp }
+0
+1
+SyntaxError Exception: /home/davidr/Proyectos/sample_app/trace.rb:1: syntax
+error, unexpected end-of-input, expecting '}'
+ 5.times { |temp| temp=fib1
+                           ^
+nil
+1
+SyntaxError Exception: /home/davidr/Proyectos/sample_app/trace.rb:1: syntax
+error, unexpected tSTRING_DEND, expecting end-of-input
+ fib2 += temp }
+               ^
+nil
+(byebug) fib1=0\; fib2=1\; 5.times {|temp| temp=fib1\; fib1=fib2\; fib2 += temp }
+5
+(byebug) fib2
+8
+```
+
+You might also consider using the [irb]() or [pry]() commands and then you won't have
+to escape semicolons.
+
+A blank line as input (typing just `<RET>`) means to repeat the previous command.
+
+Byebug uses readline, which handles line editing and retrieval of previous commands.
+Up arrow, for example, moves to the previous byebug command; down arrow moves to the
+next more recent command (provided you are not already at the last command). Command
+history is saved in file `.byebug_hist`. A limit is put on the history size. You
+can see this with the `show history size` command. See [history]() for history
+parameters.
+
+### Command Output
+In the command-line interface, when `byebug` is waiting for input it presents a
+prompt of the form `(byebug)`. If the program has terminated normally the prompt will
+be `(byebug:ctrl)` and in post-mortem debugging it will be
+`(byebug:post-mortem)`.
+
+Whenever `byebug` gives an error message such as for an invalid command or an invalid
+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
+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`
+Type "help <command-name>" for help on a specific command
+
+Available commands:
+backtrace  catch   continue  disable  down   enable  exit       frame
+info       jump    list      next     pp     putl    reload     save
+show       source  trace     up       where  break   condition  delete
+display    edit    eval      finish   help   irb     kill       method
+p          ps      quit      restart  set    skip    step       undisplay
+var
+```
+
+With a command name as `help` argument, `byebug` displays short information on how to
+use that command.
+
+```
+(byebug) help list
+l[ist]    list forward
+l[ist] -  list backward
+l[ist] =  list current line
+l[ist] nn-mm  list given lines
+* NOTE - to turn on autolist, use 'set autolist'
+(byebug)
+```
+
+A number of commands, namely `info`, `set`, `show`, `enable` and `disable`, have many
+sub-parameters or _subcommands_. When you ask for help for one of these commands, you
+will get help for all of the subcommands that command offers. Sometimes you may want
+help only on a subcommand and to do this just follow the command with its subcommand
+name. For example `help set annotate` will just give help about the annotate command.
+Furthermore it will give longer help than the summary information that appears when
+you ask for help. You don't need to list the full subcommand name, just enough
+letters to make that subcommand distinct from others will do. For example,
+`help set an` is the same as `help set annotate`.
+
+Some examples follow.
+
+```
+(byebug) help info
+info[ subcommand]
+
+Generic command for showing things about the program being debugged.
+
+--
+List of "info" subcommands:
+--
+info args               -- Argument variables of current stack frame
+info breakpoints        -- Status of user-settable breakpoints
+info catch              -- Exceptions that can be caught in the current stack
+frame
+info display            -- Expressions to display when program stops
+info file               -- Info about a particular file read in
+info files              -- File names and timestamps of files read in
+info global_variables   -- Global variables
+info instance_variables -- Instance variables of the current stack frame
+info line               -- Line number and file name of current position in
+source file
+info locals             -- Local variables of the current stack frame
+info program            -- Execution status of the program
+info stack              -- Backtrace of the stack
+info variables          -- Local and instance variables of the current stack
+frame
+```
+
+```
+(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.
+```
+
+```
+(byebug) help info br
+Status of user-settable breakpoints.
+Without argument, list info about all breakpoints.
+With an integer argument, list info on that breakpoint.
 ```

data/bin/byebug

@@ -28,7 +28,7 @@
 #    Add <i>path</i> to <tt>$LOAD_PATH</tt>. Like the <tt>ruby -I</tt> command,
 #    it supports multiple load paths separated by colons.
 #
-#<tt>-m | --post-mortem</tt>::
+#<tt>--post-mortem</tt>::
 #    Activate post-mortem mode.
 #
 #<tt>--no-quit</tt>::
@@ -77,10 +77,9 @@ def debug_program(options)
   print "\032\032starting\n" if Byebug.annotate and Byebug.annotate > 2
 
   # Record where we are we can know if the call stack has been truncated or not.
-  Byebug.start_sentinal=caller(0)[1]
+  Byebug.start_sentinal = caller[0]
 
-  bt = Byebug.debug_load(Byebug::PROG_SCRIPT, options.stop)
-  if bt
+  if bt = Byebug.debug_load(Byebug::PROG_SCRIPT, options.stop)
     print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
     print "Uncaught exception: #{bt}\n"
   end
@@ -103,8 +102,8 @@ end
 
 options = OpenStruct.new(
   'annotate'           => Byebug.annotate,
-  'no_rewrite_program' => false,
   'nx'                 => false,
+  'post_mortem'        => false,
   'quit'               => true,
   'restart_script'     => nil,
   'script'             => nil,
@@ -132,12 +131,12 @@ EOB
       |path| $LOAD_PATH.unshift(*path.split(':')) }
     opts.on('--no-quit', 'Do not quit when script finishes') {
       options.quit = false }
-    opts.on('--no-rewrite-program', 'Don\'t set $0 to the program debugged') {
-      options.no_rewrite_program = true }
     opts.on('--no-stop', 'Do not stop when script is loaded') {
       options.stop = false }
     opts.on('-nx', 'Don\'t run any byebug initialization files') {
       options.nx = true }
+    opts.on('--post-mortem', 'Run byebug in post-mortem mode') {
+      options.post_mortem = true }
     opts.on('-r', '--require SCRIPT', String, 'Require library before script') {
       |name| if name == 'debug'
         puts 'byebug not compatible with Ruby\'s \'debug\' lib, option ignored'
@@ -227,7 +226,7 @@ prog_script = whence_file(prog_script) unless File.exist?(prog_script)
 Byebug::PROG_SCRIPT = File.expand_path prog_script
 
 # Set up trace hook for byebug
-Byebug.start
+Byebug.start post_mortem: options.post_mortem
 
 # load initrc script (e.g. .byebugrc)
 Byebug.run_init_script(StringIO.new) unless options.nx
@@ -247,10 +246,7 @@ end
 options.stop = false if options.tracing
 Byebug.tracing = options.tracing
 
-if !options.quit
-  if Byebug.started?
-    until Byebug.stop do end
-  end
+loop do
   begin
     debug_program(options)
   rescue SyntaxError
@@ -260,13 +256,13 @@ if !options.quit
     print $!.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
     print "Uncaught exception: #{$!}\n"
   end
-  print "The program finished.\n" unless
-    Byebug.annotate.to_i > 1 # annotate has its own way
+  print "The program finished.\n" unless Byebug.annotate.to_i > 1
+
+  break if options.quit
+
   interface = Byebug::LocalInterface.new
   # Not sure if ControlCommandProcessor is really the right
   # thing to use. CommandProcessor requires a state.
   processor = Byebug::ControlCommandProcessor.new(interface)
   processor.process_commands
-else
-  debug_program(options)
 end

data/byebug.gemspec

@@ -29,5 +29,4 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake', '~> 10.0.4'
   s.add_development_dependency 'rake-compiler', '~> 0.8.3'
   s.add_development_dependency 'mocha', '~> 0.14.0'
-  s.add_development_dependency 'minitest', '~> 5.0.3'
 end

data/ext/byebug/byebug.c

@@ -449,11 +449,12 @@ Byebug_load(int argc, VALUE *argv, VALUE self)
 {
   VALUE file, stop, context_obj;
   debug_context_t *dc;
+  VALUE status = Qnil;
   int state = 0;
 
   if (rb_scan_args(argc, argv, "11", &file, &stop) == 1)
   {
-      stop = Qfalse;
+    stop = Qfalse;
   }
 
   Byebug_start(self);
@@ -470,17 +471,15 @@ Byebug_load(int argc, VALUE *argv, VALUE self)
   rb_load_protect(file, 0, &state);
   if (0 != state)
   {
-      VALUE errinfo = rb_errinfo();
-      reset_stepping_stop_points(dc);
-      rb_set_errinfo(Qnil);
-      return errinfo;
+    status = rb_errinfo();
+    reset_stepping_stop_points(dc);
   }
 
   /* 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 status;
 }
 
 static VALUE

data/lib/byebug.rb

@@ -111,15 +111,13 @@ module Byebug
         Byebug.const_set('INITIAL_DIR', Dir.pwd) unless defined? Byebug::INITIAL_DIR
       end
       Byebug.tracing = options[:tracing] unless options[:tracing].nil?
-      Byebug.start_sentinal=caller(0)[1]
+      Byebug.start_sentinal = caller[0]
       if Byebug.started?
         retval = block && block.call(self)
       else
         retval = Byebug._start(&block)
       end
-      if options[:post_mortem]
-        post_mortem
-      end
+      post_mortem if options[:post_mortem]
       return retval
     end
 
@@ -189,7 +187,7 @@ module Byebug
         return if self.post_mortem?
         self.post_mortem = true
         debug_at_exit do
-          handle_post_mortem($!) if $! && post_mortem?
+          handle_post_mortem($!) if post_mortem?
         end
       end
     end
@@ -286,9 +284,9 @@ module Rails
         ::Byebug.start
         puts "=> Byebug enabled"
       rescue LoadError
-        puts "You're missing the 'byebug' gem. Add it to your Gemfile, bundle " \
-             "it and try again."
-        exit(1)
+        puts "You're missing the 'byebug' gem. Add it to your Gemfile, " \
+             "bundle it and try again."
+        exit
       end
 
       def call(env)
@@ -296,4 +294,15 @@ module Rails
       end
     end
   end
+
+  class Console
+    def require_debugger
+      require 'byebug'
+      puts "=> Byebug enabled"
+    rescue LoadError
+      puts "You're missing the 'byebug' gem. Add it to your Gemfile, bundle, " \
+           "it and try again."
+      exit
+    end
+  end
 end