byebug 3.4.2 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51062987a9c4c26728720d8416eb99354576fa00
-  data.tar.gz: 2c85de15d46650690562bc84533ad254890efb18
+  metadata.gz: 1e311c958672db924c18ba6c50b079b8d0b02071
+  data.tar.gz: 9b5b874f7334cf8f2de778c6587d87717b79b780
 SHA512:
-  metadata.gz: c6840103b5586afd62b89c16a28e512e73b4365734e4fc7e3c06f6e93f2563d7d9e255ef9bbe978b4557e9152c576e7800177a464f56ac93d5396a543ea18ba8
-  data.tar.gz: bf2fee35bad9a06b866f6350435ad81b7807f6d7b8e42394de54b22e9f82bdbe2244d2a6b124b300b311b1072426e0587081e523ec4b9e11f16b75780b70110f
+  metadata.gz: 6804f3c19226009adecad6208753584bf3b9364e290c70b7be4e3ae92a8d7e300f4f6bb5a2aec029b7c3ac9df4ded55efa144ff7fff530364fec7d7058f42b10
+  data.tar.gz: 25f86abebed81ad2667b6fea393c8f4404d46d2556688fa900da8e5c5c45a223485eadab5ec0f599d9a62f978b597f379b625d182649ce7b95fa8cf0687980a9

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# 3.5.0
+- Bugfixes
+  * Fix #81, byebug's history does not mess with other programs that use
+Readline too.
+  * Fix more issues with readline's history. Now it should always be properly
+saved and inmediately available.
+  * Fix issue where user would not be notified when trying to debug a non
+existent script.
+
+- Improvements
+  * Complete rewrite of byebug's history.
+  * Complete rewrite of list command.
+  * Docs about stacktrace related commands (up, down, frame, backtrace).
+
+
 # 3.4.2
 * Fix #67, you can debug commands starting with `ruby` now, as in `byebug --
 ruby -Itest test/controllers/posts_controller_test.rb -n test_should_get_index`

data/GUIDE.md

@@ -941,18 +941,18 @@ want to debug, add a call to `byebug` as was done without remote execution:
 ## 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.
+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.
+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.
+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 }
@@ -975,10 +975,11 @@ nil
 8
 ```
 
-You might also consider using the [irb]() or [pry]() commands and then you won't have
-to escape semicolons.
+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.
+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
@@ -1309,7 +1310,7 @@ same as running `ps <object>.instance_methods(false)`.
 `<class-or-module>`. Basically this is the same as running
 `ps <class-or-module>.methods`.
 
-### Examining Program Source Files (`list`)
+### Examining Program Source Files: list
 
 `byebug` can print parts of your script's source.  When your script stops,
 `byebug` spontaneously lists the source code around the line where it stopped
@@ -1342,7 +1343,7 @@ equivalent to typing just `list`.  This is more useful than listing the same
 lines again. An exception is made for an argument of `-`: that argument is
 preserved in repetition so that each repetition moves up in the source file.
 
-### Editing Source files (`edit`)
+### Editing Source files: edit
 
 To edit a source file, use the `edit` command.  The editor of your choice is invoked
 with the current line set to the active line in the program. Alternatively, you can
@@ -1370,3 +1371,75 @@ or in the `csh` shell,
 setenv EDITOR /usr/bin/vi
 byebug ...
 ```
+
+### The stack trace
+
+When your script has stopped, one thing you'll probably want to know is where
+it stopped and some idea of how it got there.
+
+Each time your script calls a method or enters a block, information about this
+action is saved. This information is what we call a _stack frame_ or just a
+_frame_. The set of all frames at a certain point in the program's execution is
+called the _stack trace_ or just the _stack_. Each frame contains a line number
+and the source-file name that the line refers to. If the frame is the beginning
+of a method it also contains the method name.
+
+When your script is started, the stack has only one frame, that of the `main`
+method. This is called the _initial frame_ or the _outermost frame_. Each time
+a method is called, a new frame is added to the stack trace. Each time a method
+returns, the frame for that method invocation is removed. If a method is
+recursive, there can be many frames for the same method. The frame for the
+method in which execution is actually occurring is called the _innermost
+frame_. This is the most recently created of all the stack frames that still
+exist.
+
+Every time the debugger stops, one entry in the stack is selected as the
+current frame. Many byebug commands refer implicitly to the selected block. In
+particular, whenever you ask Byebug to list lines without giving a line number
+or location the value is found in the selected frame. There are special
+commands to select whichever frame you're interested in, such as `up`, `down`
+and `frame`.
+
+After switching frames, when you issue a `list` command without any position
+information, the position used is the location in the frame that you just
+switched between, rather than a location that got updated via a prior `list`
+command.
+
+Byebug assigns numbers to all existing stack frames, starting with zero for the
+_innermost frame_, one for the frame that called it, and so on upward. These
+numbers do not really exist in your script, they are assigned by Byebug to give
+you a way of designating stack frames in commands.
+
+### Printing the Stack: `where` command
+
+The command `where`, aliased to `bt` or `backtrace` prints the call stack., It
+shows one line per frame, for many frames, starting with the place that you are
+stopped at (frame zero), followed by its caller (frame one), and on up the
+stack. Each frame is numbered and can be referred to in the `frame` command.
+The position of the current frame is marked with `-->`.
+
+The are some special frames generated for methods that are implemented in C.
+One such method is `each`. They are marked differently in the call stack to
+indicate that we cannot switch to those frames. This is because they have no
+source code in Ruby, so we can not debug them using Byebug.
+
+```bash
+(byebug) where
+--> #0 Object.gcd(a#Fixnum, b#Fixnum) at line gcd.rb:6
+    #1 at line gcd.rb:19
+```
+
+### Selecting a frame: `up`, `down` and `frame` commands
+
+* `up <n>`: Move `n` frames up the stack, towards the outermost frame (higher
+frame numbers, frames that have existed longer). `n` defaults to one.
+
+* `down <n>`: Move `n` frames down the stack, towards the _innermost frame_
+(lower frame numbers, frames that were created more recently). `n` defaults to
+one.
+
+* `frame <n>`: Allows you to move to an arbitrary frame. `n` is the stack frame
+number or 0 if no frame number is given. `frame 0` will show the current and
+most recent stack frame. If a negative number is given, counting is from the
+other end of the stack frame, so `frame -1` shows the least-recent, outermost
+stack frame. Without an argument, `frame` prints the current stack frame.

data/lib/byebug/attacher.rb

@@ -5,6 +5,7 @@ module Byebug
   #
   def self.attach(steps_out, before)
     start
+    self.debugged_program = $PROGRAM_NAME
     run_init_script(StringIO.new)
     current_context.step_out(steps_out, before)
   end

data/lib/byebug/commands/enable_disable.rb

@@ -41,7 +41,7 @@ module Byebug
 
       args.each do |pos|
         pos, err = get_int(pos, "#{is_enable} display", 1, @state.display.size)
-        return errmsg(err) unless pos
+        return errmsg(err) unless err.nil?
 
         @state.display[pos - 1][0] = ('enable' == is_enable)
       end

data/lib/byebug/commands/frame.rb

@@ -45,7 +45,7 @@ module Byebug
       @state.frame_pos = abs_frame_pos
       @state.file = @state.context.frame_file @state.frame_pos
       @state.line = @state.context.frame_line @state.frame_pos
-      @state.previous_line = nil
+      @state.prev_line = nil
       ListCommand.new(@state).execute
     end
 

data/lib/byebug/commands/history.rb

@@ -8,17 +8,14 @@ module Byebug
     end
 
     def execute
-      unless Setting[:autosave]
-        return errmsg('Not currently saving history. ' \
-                      "Enable it with \"set autosave\"")
-      end
+      history = @state.interface.history
 
       if @match[:num_cmds]
-        size, err = get_int(@match[:num_cmds], 'history', 1, Setting[:histsize])
+        size, _ = get_int(@match[:num_cmds], 'history', 1, history.size)
         return errmsg(err) unless size
       end
 
-      puts History.to_s(size || Setting[:histsize])
+      puts history.to_s(size)
     end
 
     class << self

data/lib/byebug/commands/list.rb

@@ -11,17 +11,14 @@ module Byebug
       Byebug.source_reload if Setting[:autoreload]
 
       lines = get_lines(@state.file)
-      unless lines
-        errmsg "No sourcefile available for #{@state.file}\n"
-        return @state.previous_line
-      end
-
-      b, e = set_line_range(Setting[:listsize], lines.size)
-      return @state.previous_line if b < 0
+      return errmsg "No sourcefile available for #{@state.file}\n" unless lines
 
+      @match ||= match('list')
+      b, e = range(@match[2], lines.size)
+      return errmsg('Invalid line range') unless valid_range?(b, e, lines.size)
       display_lines(b, e, lines)
 
-      @state.previous_line = b > lines.size ? @previous_line : b
+      @state.prev_line = b
     end
 
     class << self
@@ -42,57 +39,70 @@ module Byebug
 
     private
 
-    ##
+    #
+    # Line range to be printed by `list`.
+    #
+    # If <input> is set, range is parsed from it.
+    #
+    # Otherwise it's automatically chosen.
+    #
+    def range(input, max_line)
+      size = [Setting[:listsize], max_line].min
+
+      return set_range(size, max_line) unless input
+
+      parse_range(input, size, max_line)
+    end
+
+    def valid_range?(first, last, max)
+      first <= last && (1..max).include?(first) && (1..max).include?(last)
+    end
+
+    #
     # Set line range to be printed by list
     #
-    # @param listsize - number of lines to be printed
-    # @param maxline - max line number that can be printed
+    # @param size - number of lines to be printed
+    # @param max_line - max line number that can be printed
     #
-    def set_line_range(listsize, maxline)
-      if !@match || !(@match[1] || @match[2])
-        b = if @state.previous_line
-              @state.previous_line + listsize
-            else
-              @state.line - (listsize / 2)
-            end
-      elsif @match[1] == '-'
-        b = if @state.previous_line
-              if  @state.previous_line > 0
-                @state.previous_line - listsize
-              else
-                @state.previous_line
-              end
-            else
-              @state.line - (listsize / 2)
-            end
-      elsif @match[1] == '='
-        @state.previous_line = nil
-        b = @state.line - (listsize / 2)
+    # @return first line number to list
+    # @return last line number to list
+    #
+    def set_range(size, max_line)
+      first = amend(lower(size, @match[1] || '+'), size, max_line - size + 1)
+
+      [first, move(first, size - 1)]
+    end
+
+    def parse_range(input, size, max_line)
+      first, err = get_int(input.split(/[-,]/)[0], 'List', 1, max_line)
+      return [-1, -1] if err
+
+      if input.split(/[-,]/)[1]
+        last, err = get_int(input.split(/[-,]/)[1], 'List', 1, max_line)
+        return [-1, -1] unless last
+
+        last = amend(last, size, max_line)
       else
-        b, e = @match[2].split(/[-,]/)
-        if e
-          b = b.to_i
-          e = e.to_i
-        else
-          b = b.to_i - (listsize / 2)
-        end
+        first -= (size / 2)
       end
 
-      if b > maxline
-        errmsg 'Invalid line range'
-        return [-1, -1]
-      end
+      [first, last || move(first, size - 1)]
+    end
 
-      b = [1, b].max
-      e ||=  b + listsize - 1
+    def amend(line, size, max_line)
+      return 1 if line < 1
 
-      if e > maxline
-        e = maxline
-        b = e - listsize + 1
-        b = [1, b].max
-      end
+      [max_line, line].min
+    end
+
+    def lower(size, direction = '+')
+      return @state.line - size / 2 if direction == '=' || !@state.prev_line
+
+      move(@state.prev_line, size, direction)
+    end
 
-      [b, e]
+    def move(line, size, direction = '+')
+      line.send(direction, size)
     end
 
     #

data/lib/byebug/commands/pry.rb

@@ -1,10 +1,3 @@
-begin
-  require 'pry'
-  has_pry = true
-rescue LoadError
-  has_pry = false
-end
-
 module Byebug
   #
   # Enter Pry from byebug's prompt
@@ -32,4 +25,4 @@ module Byebug
       end
     end
   end
-end if has_pry
+end if defined?(Pry)

data/lib/byebug/commands/restart.rb

@@ -12,10 +12,6 @@ module Byebug
     def execute
       prog = Byebug.debugged_program
 
-      unless File.exist?(File.expand_path(prog))
-        return errmsg("Ruby program #{prog} doesn't exist")
-      end
-
       if defined?(BYEBUG_SCRIPT)
         cmd = "#{BYEBUG_SCRIPT} #{prog}"
       else
@@ -23,8 +19,7 @@ module Byebug
         if File.executable?(prog)
           cmd = prog
         else
-          puts "Ruby program #{prog} not executable... " \
-               "We'll wrap it in a ruby call"
+          puts "Program #{prog} not executable... Wrapping it in a ruby call"
           cmd = "ruby -rbyebug -I#{$LOAD_PATH.join(' -I')} #{prog}"
         end
       end

data/lib/byebug/commands/save.rb

@@ -1,19 +1,8 @@
 module Byebug
   #
-  # Utilities for the save command.
+  # Default file where commands are saved
   #
-  module SaveFunctions
-    # Create a temporary file to write in if file is nil
-    def open_save
-      require 'tempfile'
-      file = Tempfile.new('byebug-save')
-      # We want close to not unlink, so redefine.
-      def file.close
-        @tmpfile.close if @tmpfile
-      end
-      file
-    end
-  end
+  RESTART_FILE = '.byebug-save' unless defined?(RESTART_FILE)
 
   #
   # Save current settings to use them in another debug session.
@@ -48,17 +37,14 @@ module Byebug
     end
 
     def execute
-      if !@match[1]
-        file = open_save
-      else
-        file = open(@match[1], 'w')
-      end
+      file = open(@match[1] || RESTART_FILE, 'w')
+
       save_breakpoints(file)
       save_catchpoints(file)
       save_displays(file)
       save_settings(file)
+
       puts "Saved to '#{file.path}'"
-      @state.interface.restart_file = file.path if @state && @state.interface
       file.close
     end
 

data/lib/byebug/commands/undisplay.rb

@@ -11,8 +11,8 @@ module Byebug
 
     def execute
       if @match[1]
-        pos, err = get_int(@match[1], 'Undisplay')
-        return errmsg(err) unless pos
+        pos, err = get_int(@match[1], 'Undisplay', 1, @state.display.size)
+        return errmsg(err) unless err.nil?
 
         unless @state.display[pos - 1]
           return errmsg("Display expression #{pos} is not defined.")

data/lib/byebug/core.rb

@@ -12,26 +12,25 @@ require 'tracer'
 require 'linecache19'
 
 module Byebug
+  #
   # List of files byebug will ignore while debugging
+  #
   IGNORED_FILES = Dir.glob(File.expand_path('../**/*.rb', __FILE__))
 
+  #
   # Configuration file used for startup commands. Default value is .byebugrc
-  INITFILE = '.byebugrc' unless defined?(INITFILE)
+  #
+  INIT_FILE = '.byebugrc' unless defined?(INIT_FILE)
 
   class << self
-    attr_accessor :handler
-    attr_writer :debugged_program
+    attr_accessor :handler, :debugged_program
+
+    extend Forwardable
+    def_delegators :handler, :errmsg, :puts
   end
 
   Byebug.handler = CommandProcessor.new
 
-  #
-  # Program being debugged (or a default one if not set yet)
-  #
-  def self.debugged_program
-    @debugged_program ||= $PROGRAM_NAME
-  end
-
   def self.source_reload
     hsh = 'SCRIPT_LINES__'
     Object.send(:remove_const, hsh) if Object.const_defined?(hsh)
@@ -45,13 +44,6 @@ module Byebug
     handler.interface = value
   end
 
-  #
-  # Byebug's prints according to its handler's interface
-  #
-  def self.puts(message)
-    handler.interface.puts(message)
-  end
-
   #
   # Runs normal byebug initialization scripts.
   #
@@ -62,10 +54,10 @@ module Byebug
   # program you are debugging, in the directory where you invoke byebug.
   #
   def self.run_init_script(out = handler.interface)
-    cwd_script  = File.expand_path(File.join('.', INITFILE))
+    cwd_script  = File.expand_path(File.join('.', INIT_FILE))
     run_script(cwd_script, out, true) if File.exist?(cwd_script)
 
-    home_script = File.expand_path(File.join(ENV['HOME'].to_s, INITFILE))
+    home_script = File.expand_path(File.join(ENV['HOME'].to_s, INIT_FILE))
     if File.exist?(home_script) && cwd_script != home_script
       run_script(home_script, out, true)
     end