byebug 5.0.0 → 6.0.0

data/lib/byebug/commands/down.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'pathname'
 require 'byebug/command'
 require 'byebug/helpers/frame'
@@ -13,27 +11,33 @@ module Byebug
     include Helpers::FrameHelper
     include Helpers::ParseHelper
 
-    def regexp
-      /^\s* down (?:\s+(\S+))? \s*$/x
-    end
+    self.allow_in_post_mortem = true
 
-    def execute
-      pos, err = parse_steps(@match[1], 'Down')
-      return errmsg(err) unless pos
-
-      adjust_frame(-pos, false)
-
-      ListCommand.new(@state).execute if Setting[:autolist]
+    def self.regexp
+      /^\s* down (?:\s+(\S+))? \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
         down[ count]
 
-        Move to a lower frame in the stack trace.
+        #{short_description}
 
         Use the "bt" command to find out where you want to go.
       EOD
     end
+
+    def self.short_description
+      'Moves to a lower frame in the stack trace'
+    end
+
+    def execute
+      pos, err = parse_steps(@match[1], 'Down')
+      return errmsg(err) unless pos
+
+      jump_frames(-pos)
+
+      ListCommand.new(processor).execute if Setting[:autolist]
+    end
   end
 end

data/lib/byebug/commands/edit.rb

@@ -6,45 +6,61 @@ module Byebug
   #
   class EditCommand < Command
     self.allow_in_control = true
+    self.allow_in_post_mortem = true
 
-    def regexp
+    def self.regexp
       /^\s* ed(?:it)? (?:\s+(\S+))? \s*$/x
     end
 
-    def execute
-      if !@match[1]
-        return errmsg(pr('edit.errors.state')) unless @state.file
-        file = @state.file
-        line = @state.line if @state.line
-      elsif (@pos_match = /([^:]+)[:]([0-9]+)/.match(@match[1]))
-        file, line = @pos_match.captures
-      else
-        file = @match[1]
-      end
+    def self.description
+      <<-EOD
+        edit[ file:lineno]
 
-      editor = ENV['EDITOR'] || 'vim'
-      file = File.expand_path(file)
+        #{short_description}
 
-      unless File.exist?(file)
-        return errmsg(pr('edit.errors.not_exist', file: file))
-      end
-      unless File.readable?(file)
-        return errmsg(pr('edit.errors.not_readable', file: file))
-      end
+        With no argumnt, edits file containing most re line listed. Editing
+        targets can also be specified to start editing at a specific line in a
+        specific file
+      EOD
+    end
+
+    def self.short_description
+      'Edits source files'
+    end
+
+    def execute
+      file, line = location(@match[1])
+      return edit_error('not_exist', file) unless File.exist?(file)
+      return edit_error('not_readable', file) unless File.readable?(file)
 
       cmd = line ? "#{editor} +#{line} #{file}" : "#{editor} #{file}"
 
       system(cmd)
     end
 
-    def description
-      <<-EOD
-        edit[ file:lineno] Edit specified files.
+    private
 
-        With no argument, edits file containing most recent line listed. Editing
-        targets can also be specified to start editing at a specific line in a
-        specific file.
-      EOD
+    def location(matched)
+      if matched.nil?
+        file = frame.file
+        return errmsg(pr('edit.errors.state')) unless file
+        line = frame.line
+      elsif (@pos_match = /([^:]+)[:]([0-9]+)/.match(matched))
+        file, line = @pos_match.captures
+      else
+        file = matched
+        line = nil
+      end
+
+      [File.expand_path(file), line]
+    end
+
+    def editor
+      ENV['EDITOR'] || 'vim'
+    end
+
+    def edit_error(type, file)
+      errmsg(pr("edit.errors.#{type}", file: file))
     end
   end
 end

data/lib/byebug/commands/enable.rb

@@ -10,16 +10,22 @@ module Byebug
   class EnableCommand < Command
     include Subcommands
 
-    def regexp
+    self.allow_in_post_mortem = true
+
+    def self.regexp
       /^\s* en(?:able)? (?:\s+ (.+))? \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
         en[able][[ b[reakpoints]| d[isplay])][ n1[ n2[ ...[ nn]]]]]
 
-        Enables breakpoints or displays.
+        #{short_description}
       EOD
     end
+
+    def self.short_description
+      'Enables breakpoints or displays'
+    end
   end
 end

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

@@ -8,22 +8,16 @@ module Byebug
     #
     # Enables all or specific breakpoints
     #
-    class BreakpointsSubcommand < Command
+    class BreakpointsCommand < Command
       include Helpers::ToggleHelper
 
-      def regexp
-        /^\s* b(?:reakpoints)? (?:\s+ (.+))? \s*$/x
-      end
-
-      def execute
-        enable_disable_breakpoints('enable', @match[1])
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Disable all or specific breakpoints'
+      def self.regexp
+        /^\s* b(?:reakpoints)? (?:\s+ (.+))? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           en[able] b[reakpoints][ <ids>]
 
@@ -33,6 +27,14 @@ module Byebug
           argument at all if you want to enable every breakpoint.
         EOD
       end
+
+      def self.short_description
+        'Disable all or specific breakpoints'
+      end
+
+      def execute
+        enable_disable_breakpoints('enable', @match[1])
+      end
     end
   end
 end

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

@@ -8,22 +8,16 @@ module Byebug
     #
     # Enables all or specific displays
     #
-    class DisplaySubcommand < Command
+    class DisplayCommand < Command
       include Helpers::ToggleHelper
 
-      def regexp
-        /^\s* d(?:isplay)? (?:\s+ (.+))? \s*$/x
-      end
-
-      def execute
-        enable_disable_display('enable', @match[1])
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Enables expressions to be displayed when program stops.'
+      def self.regexp
+        /^\s* d(?:isplay)? (?:\s+ (.+))? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           en[able] d[isplay][ <id1> <id2> .. <idn>]
 
@@ -34,6 +28,14 @@ module Byebug
           specified, all displays are enabled.
         EOD
       end
+
+      def self.short_description
+        'Enables expressions to be displayed when program stops.'
+      end
+
+      def execute
+        enable_disable_display('enable', @match[1])
+      end
     end
   end
 end

data/lib/byebug/commands/finish.rb

@@ -12,12 +12,27 @@ module Byebug
 
     self.allow_in_post_mortem = false
 
-    def regexp
+    def self.regexp
       /^\s* fin(?:ish)? (?:\s+(\S+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        fin[ish][ n_frames]
+
+        #{short_description}
+
+        If no number is given, we run until the current frame returns. If a
+        number of frames `n_frames` is given, then we run until `n_frames`
+        return from the current position.
+      EOD
+    end
+
+    def self.short_description
+      'Runs the program until frame returns'
+    end
+
     def execute
-      max_frames = @state.context.stack_size - @state.frame
       if @match[1]
         n_frames, err = get_int(@match[1], 'finish', 0, max_frames - 1)
         return errmsg(err) unless n_frames
@@ -26,21 +41,15 @@ module Byebug
       end
 
       force = n_frames == 0 ? true : false
-      @state.context.step_out(@state.frame + n_frames, force)
-      @state.frame = 0
-      @state.proceed
+      context.step_out(context.frame.pos + n_frames, force)
+      context.frame = 0
+      processor.proceed!
     end
 
-    def description
-      <<-EOD
-        fin[ish][ n_frames]
-
-        Execute until frame returns.
+    private
 
-        If no number is given, we run until the current frame returns. If a
-        number of frames `n_frames` is given, then we run until `n_frames`
-        return from the current position.
-      EOD
+    def max_frames
+      context.stack_size - context.frame.pos
     end
   end
 end

data/lib/byebug/commands/frame.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'pathname'
 require 'byebug/command'
 require 'byebug/helpers/frame'
@@ -13,28 +11,20 @@ module Byebug
     include Helpers::FrameHelper
     include Helpers::ParseHelper
 
-    def regexp
-      /^\s* f(?:rame)? (?:\s+(\S+))? \s*$/x
-    end
-
-    def execute
-      unless @match[1]
-        print(pr('frame.line', get_pr_arguments(@state.frame)))
-        return
-      end
-
-      pos, err = get_int(@match[1], 'Frame')
-      return errmsg(err) unless pos
+    self.allow_in_post_mortem = true
 
-      adjust_frame(pos, true)
+    def self.regexp
+      /^\s* f(?:rame)? (?:\s+(\S+))? \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
         f[rame][ frame-number]
 
-        Move the current frame to the specified frame number, or the 0 if no
-        frame-number has been given.
+        #{short_description}
+
+        If a frame number has been specified, to moves to that frame. Otherwise
+        it moves to the newest frame.
 
         A negative number indicates position from the other end, so "frame -1"
         moves to the oldest frame, and "frame 0" moves to the newest frame.
@@ -46,5 +36,18 @@ module Byebug
         Use the "bt" command to find out where you want to go.
       EOD
     end
+
+    def self.short_description
+      'Moves to a frame in the call stack'
+    end
+
+    def execute
+      return print(pr('frame.line', context.frame.to_hash)) unless @match[1]
+
+      pos, err = get_int(@match[1], 'Frame')
+      return errmsg(err) unless pos
+
+      switch_to_frame(pos)
+    end
   end
 end

data/lib/byebug/commands/help.rb

@@ -1,4 +1,5 @@
 require 'byebug/command'
+require 'byebug/errors'
 
 module Byebug
   #
@@ -6,34 +7,56 @@ module Byebug
   #
   class HelpCommand < Command
     self.allow_in_control = true
+    self.allow_in_post_mortem = true
 
-    def regexp
+    def self.regexp
       /^\s* h(?:elp)? (?:\s+(\S+))? (?:\s+(\S+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        h[elp][ <cmd>[ <subcmd>]]
+
+        #{short_description}
+
+        help                -- prints a summary of all commands
+        help <cmd>          -- prints help on command <cmd>
+        help <cmd> <subcmd> -- prints help on <cmd>'s subcommand <subcmd>
+      EOD
+    end
+
+    def self.short_description
+      'Helps you using byebug'
+    end
+
     def execute
-      return puts(help) unless @match[1]
+      return help_for_all unless @match[1]
 
-      cmd = Byebug.commands.find { |c| c.to_name == @match[1] }
-      return errmsg(pr('help.errors.undefined', cmd: @match[1])) unless cmd
+      return help_for(@match[1], command) unless @match[2]
 
-      cmd = cmd.new(@state)
-      return puts(cmd.help) unless @match[2]
+      help_for(@match[2], subcommand)
+    end
 
-      subcmd = cmd.subcommands.find(@match[2])
-      return errmsg(pr('help.errors.undefined', cmd: @match[2])) unless subcmd
+    private
 
-      puts(subcmd.help)
+    def help_for_all
+      puts(processor.command_list.to_s)
     end
 
-    def description
-      <<-EOD
-        h[elp][ <cmd>[ <subcmd>]]
+    def help_for(input, cmd)
+      fail CommandNotFound.new(input, command) unless cmd
 
-        help                -- prints this help.
-        help <cmd>          -- prints help on command <cmd>.
-        help <cmd> <subcmd> -- prints help on <cmd>'s subcommand <subcmd>.
-      EOD
+      puts(cmd.help)
+    end
+
+    def command
+      @command ||= processor.command_list.match(@match[1])
+    end
+
+    def subcommand
+      return unless command
+
+      @subcommand ||= command.subcommand_list.match(@match[2])
     end
   end
 end