byebug 4.0.5 → 5.0.0

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

@@ -0,0 +1,42 @@
+module Byebug
+  #
+  # Reopens the +info+ command to define the +display+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about display expressions
+    #
+    class DisplaySubcommand < Command
+      def regexp
+        /^\s* d(?:isplay)? \s*$/x
+      end
+
+      def execute
+        display = @state.display
+
+        unless display.find { |d| d[0] }
+          return puts('There are no auto-display expressions now.')
+        end
+
+        puts 'Auto-display expressions now in effect:'
+        puts 'Num Enb Expression'
+
+        display.each_with_index do |d, i|
+          puts(format('%3d: %s  %s', i + 1, d[0] ? 'y' : 'n', d[1]))
+        end
+      end
+
+      def short_description
+        'List of expressions to display when program stops'
+      end
+
+      def description
+        <<-EOD
+          inf[o] d[display]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'byebug/helpers/file'
+
+module Byebug
+  #
+  # Reopens the +info+ command to define the +file+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about a particular source file
+    #
+    class FileSubcommand < Command
+      include Helpers::FileHelper
+
+      def regexp
+        /^\s* f(?:ile)? (?:\s+ (\S+))? \s*$/x
+      end
+
+      def execute
+        file = @match[1] || @state.file
+        unless File.exist?(file)
+          return errmsg(pr('info.errors.undefined_file', file: file))
+        end
+
+        puts <<-EOC.gsub(/^ {6}/, '')
+
+          File #{info_file_basic(file)}
+
+          Breakpoint line numbers:
+          #{info_file_breakpoints(file)}
+
+          Modification time: #{info_file_mtime(file)}
+
+          Sha1 Signature: #{info_file_sha1(file)}
+
+        EOC
+      end
+
+      def short_description
+        'Information about a particular source file.'
+      end
+
+      def description
+        <<-EOD
+          inf[o] f[ile]
+
+          #{short_description}
+
+          It informs about file name, number of lines, possible breakpoints in
+          the file, last modification time and sha1 digest.
+        EOD
+      end
+
+      private
+
+      def info_file_basic(file)
+        path = File.expand_path(file)
+        return unless File.exist?(path)
+
+        s = n_lines(path) == 1 ? '' : 's'
+        "#{path} (#{n_lines(path)} line#{s})"
+      end
+
+      def info_file_breakpoints(file)
+        breakpoints = Breakpoint.potential_lines(file)
+        return unless breakpoints
+
+        breakpoints.to_a.sort.columnize(line_prefix: '  ',
+                                        displaywidth: Setting[:width])
+      end
+
+      def info_file_mtime(file)
+        File.stat(file).mtime
+      end
+
+      def info_file_sha1(file)
+        require 'digest/sha1'
+        Digest::SHA1.hexdigest(file)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Byebug
+  #
+  # Reopens the +info+ command to define the +line+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about current location
+    #
+    class LineSubcommand < Command
+      def regexp
+        /^\s* l(?:ine)? \s*$/x
+      end
+
+      def execute
+        puts "Line #{@state.line} of \"#{@state.file}\""
+      end
+
+      def short_description
+        'Line number and file name of current position in source file.'
+      end
+
+      def description
+        <<-EOD
+          inf[o] l[ine]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Byebug
+  #
+  # Reopens the +info+ command to define the +args+ subcommand
+  #
+  class InfoCommand < Command
+    #
+    # Information about arguments of the current method/block
+    #
+    class ProgramSubcommand < Command
+      def regexp
+        /^\s* p(?:rogram)? \s*$/x
+      end
+
+      def execute
+        if @state.context.dead?
+          puts 'The program crashed.'
+          excpt = Byebug.last_exception
+          return puts("Exception: #{excpt.inspect}") if excpt
+        end
+
+        puts 'Program stopped. '
+        format_stop_reason @state.context.stop_reason
+      end
+
+      def short_description
+        'Information about the current status of the debugged program.'
+      end
+
+      def description
+        <<-EOD
+          inf[o] p[rogram]
+
+          #{short_description}
+        EOD
+      end
+
+      private
+
+      def format_stop_reason(stop_reason)
+        case stop_reason
+        when :step
+          puts "It stopped after stepping, next'ing or initial start."
+        when :breakpoint
+          puts 'It stopped at a breakpoint.'
+        when :catchpoint
+          puts 'It stopped at a catchpoint.'
+        end
+      end
+    end
+  end
+end

data/lib/byebug/commands/interrupt.rb

@@ -17,16 +17,12 @@ module Byebug
       context.interrupt
     end
 
-    class << self
-      def names
-        %w(interrupt)
-      end
+    def description
+      <<-EOD
+        i[nterrupt]
 
-      def description
-        prettify <<-EOD
-          i[nterrupt]  Interrupts the program.
-        EOD
-      end
+        Interrupts the program.
+      EOD
     end
   end
 end

data/lib/byebug/commands/irb.rb

@@ -18,16 +18,12 @@ module Byebug
       IRB.start(__FILE__)
     end
 
-    class << self
-      def names
-        %w(irb)
-      end
+    def description
+      <<-EOD
+        irb
 
-      def description
-        prettify <<-EOD
-          irb  Starts an Interactive Ruby (IRB) session.
-        EOD
-      end
+        Starts an Interactive Ruby (IRB) session.
+      EOD
     end
   end
 end

data/lib/byebug/commands/kill.rb

@@ -27,19 +27,13 @@ module Byebug
       Process.kill(signame, Process.pid)
     end
 
-    class << self
-      def names
-        %w(kill)
-      end
-
-      def description
-        prettify <<-EOD
-          kill[ SIGNAL]
+    def description
+      <<-EOD
+        kill[ signal]
 
-          Send [signal] to Process.pid
-          Equivalent of Process.kill(Process.pid)
-        EOD
-      end
+        Send [signal] to Process.pid
+        Equivalent of Process.kill(Process.pid)
+      EOD
     end
   end
 end

data/lib/byebug/commands/list.rb

@@ -1,10 +1,15 @@
 require 'byebug/command'
+require 'byebug/helpers/file'
+require 'byebug/helpers/parse'
 
 module Byebug
   #
   # List parts of the source code.
   #
   class ListCommand < Command
+    include Helpers::FileHelper
+    include Helpers::ParseHelper
+
     def regexp
       /^\s* l(?:ist)? (?:\s*([-=])|\s+(\S+))? \s*$/x
     end
@@ -23,22 +28,16 @@ module Byebug
       @state.prev_line = b
     end
 
-    class << self
-      def names
-        %w(list)
-      end
-
-      def description
-        prettify <<-EOD
-          l[ist][[-=]][ nn-mm]
+    def description
+      <<-EOD
+        l[ist][[-=]][ nn-mm]
 
-          Lists lines of code forward from current line or from the place where
-          code was last listed. If "list-" is specified, lists backwards
-          instead. If "list=" is specified, lists from current line regardless
-          of where code was last listed. A line range can also be specified to
-          list specific sections of code.
-        EOD
-      end
+        Lists lines of code forward from current line or from the place where
+        code was last listed. If "list-" is specified, lists backwards instead.
+        If "list=" is specified, lists from current line regardless of where
+        code was last listed. A line range can also be specified to list
+        specific sections of code.
+      EOD
     end
 
     private
@@ -78,11 +77,11 @@ module Byebug
     end
 
     def parse_range(input, size, max_line)
-      first, err = get_int(input.split(/[-,]/)[0], 'List', 1, max_line)
+      first, err = get_int(lower_bound(input), 'List', 1, max_line)
       return [-1, -1] if err
 
-      if input.split(/[-,]/)[1]
-        last, _ = get_int(input.split(/[-,]/)[1], 'List', 1, max_line)
+      if upper_bound(input)
+        last, = get_int(upper_bound(input), 'List', 1, max_line)
         return [-1, -1] unless last
 
         last = amend(last, max_line)
@@ -116,12 +115,41 @@ module Byebug
       puts "\n[#{min}, #{max}] in #{@state.file}"
 
       File.foreach(@state.file).with_index do |line, lineno|
-        return if lineno + 1 > max
+        break if lineno + 1 > max
         next unless (min..max).include?(lineno + 1)
 
         mark = lineno + 1 == @state.line ? '=> ' : '   '
         puts format("#{mark}%#{max.to_s.size}d: %s", lineno + 1, line)
       end
     end
+
+    private
+
+    #
+    # @param range [String] A string with an integer range format
+    #
+    # @return [String] The lower bound of the given range
+    #
+    def lower_bound(range)
+      split_range(range)[0]
+    end
+
+    #
+    # @param range [String] A string with an integer range format
+    #
+    # @return [String] The upper bound of the given range
+    #
+    def upper_bound(range)
+      split_range(range)[1]
+    end
+
+    #
+    # @param range [String] A string with an integer range format
+    #
+    # @return [Array] The upper & lower bounds of the given range
+    #
+    def split_range(str)
+      str.split(/[-,]/)
+    end
   end
 end

data/lib/byebug/commands/method.rb

@@ -26,22 +26,16 @@ module Byebug
       puts result
     end
 
-    class << self
-      def names
-        %w(method)
-      end
+    def description
+      <<-EOD
+        m[ethod] (i[nstance][ <obj>]|<class|module>)
 
-      def description
-        prettify <<-EOD
-          m[ethod] (i[nstance][ <obj>]|<class|module>)
+        When invoked with "instance", shows instance methods of the object
+        specified as argument or of self no object was specified.
 
-          When invoked with "instance", shows instance methods of the object
-          specified as argument or of self no object was specified.
-
-          When invoked only with a class or module, shows class methods of the
-          class or module specified as argument.
-        EOD
-      end
+        When invoked only with a class or module, shows class methods of the
+        class or module specified as argument.
+      EOD
     end
   end
 end

data/lib/byebug/commands/next.rb

@@ -0,0 +1,36 @@
+require 'byebug/command'
+require 'byebug/helpers/parse'
+
+module Byebug
+  #
+  # Implements the next functionality.
+  #
+  # Allows the user the continue execution until the next instruction in the
+  # current frame.
+  #
+  class NextCommand < Command
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = false
+
+    def regexp
+      /^\s* n(?:ext)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def execute
+      steps, err = parse_steps(@match[1], 'Next')
+      return errmsg(err) unless steps
+
+      @state.context.step_over(steps, @state.frame)
+      @state.proceed
+    end
+
+    def description
+      <<-EOD
+        n[ext][ nnn]
+
+        Steps over once or nnn times.
+      EOD
+    end
+  end
+end