byebug 4.0.5 → 5.0.0

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

@@ -0,0 +1,38 @@
+require 'byebug/helpers/toggle'
+
+module Byebug
+  #
+  # Reopens the +enable+ command to define the +breakpoints+ subcommand
+  #
+  class EnableCommand < Command
+    #
+    # Enables all or specific breakpoints
+    #
+    class BreakpointsSubcommand < Command
+      include Helpers::ToggleHelper
+
+      def regexp
+        /^\s* b(?:reakpoints)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def execute
+        enable_disable_breakpoints('enable', @match[1])
+      end
+
+      def short_description
+        'Disable all or specific breakpoints'
+      end
+
+      def description
+        <<-EOD
+          en[able] b[reakpoints][ <ids>]
+
+          #{short_description}
+
+          Give breakpoint numbers (separated by spaces) as arguments or no
+          argument at all if you want to enable every breakpoint.
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'byebug/helpers/toggle'
+
+module Byebug
+  #
+  # Reopens the +enable+ command to define the +display+ subcommand
+  #
+  class EnableCommand < Command
+    #
+    # Enables all or specific displays
+    #
+    class DisplaySubcommand < Command
+      include Helpers::ToggleHelper
+
+      def regexp
+        /^\s* d(?:isplay)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def execute
+        enable_disable_display('enable', @match[1])
+      end
+
+      def short_description
+        'Enables expressions to be displayed when program stops.'
+      end
+
+      def description
+        <<-EOD
+          en[able] d[isplay][ <id1> <id2> .. <idn>]
+
+          #{short_description}
+
+          Arguments are the code numbers of the expressions to enable. Do "info
+          display" to see the current list of code numbers. If no arguments are
+          specified, all displays are enabled.
+        EOD
+      end
+    end
+  end
+end

data/lib/byebug/commands/eval.rb

@@ -1,60 +1,13 @@
-require 'byebug/command'
-
 require 'English'
-require 'pp'
+require 'byebug/command'
+require 'byebug/helpers/eval'
 
 module Byebug
-  #
-  # Utilities used by the eval command
-  #
-  module EvalFunctions
-    #
-    # Run block temporarily ignoring all TracePoint events.
-    #
-    # Used to evaluate stuff within Byebug's prompt. Otherwise, any code
-    # creating new threads won't be properly evaluated because new threads will
-    # get blocked by byebug's main thread.
-    #
-    def allowing_other_threads
-      Byebug.unlock
-      res = yield
-      Byebug.lock
-      res
-    end
-
-    #
-    # Get current binding and yield it to the given block
-    #
-    def run_with_binding
-      binding = get_binding
-      yield binding
-    end
-
-    #
-    # Evaluate +expression+ using +binding+
-    #
-    # @param binding [Binding] Context where to evaluate the expression
-    # @param expression [String] Expression to evaluation
-    # @param stack_on_error [Boolean] Whether to show a stack trace on error.
-    #
-    def eval_with_setting(binding, expression, stack_on_error)
-      allowing_other_threads do
-        if stack_on_error
-          bb_eval(expression, binding)
-        else
-          bb_warning_eval(expression, binding)
-        end
-      end
-    end
-  end
-
   #
   # Evaluation of expressions from byebug's prompt.
   #
   class EvalCommand < Command
-    include EvalFunctions
-
-    self.allow_in_control = true
+    include Helpers::EvalHelper
 
     def match(input)
       @input = input
@@ -76,150 +29,15 @@ module Byebug
       puts "#{$ERROR_INFO.class} Exception: #{$ERROR_INFO.message}"
     end
 
-    class << self
-      def names
-        %w(eval)
-      end
-
-      def description
-        prettify <<-EOD
-          e[val] <expression>
-
-          Evaluates <expression> and prints its value.
-
-          * NOTE - unknown input is automatically evaluated, to turn this off
-          use 'set noautoeval'.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Evaluation and pretty printing from byebug's prompt.
-  #
-  class PPCommand < Command
-    include EvalFunctions
-
-    self.allow_in_control = true
-
-    def regexp
-      /^\s* pp \s+/x
-    end
-
-    def execute
-      out = StringIO.new
-      run_with_binding do |b|
-        if Setting[:stack_on_error]
-          PP.pp(bb_eval(@match.post_match, b), out)
-        else
-          PP.pp(bb_warning_eval(@match.post_match, b), out)
-        end
-      end
-      puts out.string
-    rescue
-      out.puts $ERROR_INFO.message
-    end
-
-    class << self
-      def names
-        %w(pp)
-      end
-
-      def description
-        prettify <<-EOD
-          pp <expression>
+    def description
+      <<-EOD
+        e[val] <expression>
 
-          Evaluates <expression> and pretty-prints its value.
-        EOD
-      end
-    end
-  end
+        Evaluates <expression> and prints its value.
 
-  #
-  # Evaluation, pretty printing and columnizing from byebug's prompt.
-  #
-  class PutLCommand < Command
-    include EvalFunctions
-    include Columnize
-
-    self.allow_in_control = true
-
-    def regexp
-      /^\s* putl \s+/x
-    end
-
-    def execute
-      out = StringIO.new
-      run_with_binding do |b|
-        res = eval_with_setting(b, @match.post_match, Setting[:stack_on_error])
-
-        if res.is_a?(Array)
-          puts "#{columnize(res.map(&:to_s), Setting[:width])}"
-        else
-          PP.pp(res, out)
-          puts out.string
-        end
-      end
-    rescue
-      out.puts $ERROR_INFO.message
-    end
-
-    class << self
-      def names
-        %w(putl)
-      end
-
-      def description
-        prettify <<-EOD
-          putl <expression>
-
-          Evaluates <expression>, an array, and columnize its value.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Evaluation, pretty printing, columnizing and sorting from byebug's prompt
-  #
-  class PSCommand < Command
-    include EvalFunctions
-    include Columnize
-
-    self.allow_in_control = true
-
-    def regexp
-      /^\s* ps \s+/x
-    end
-
-    def execute
-      out = StringIO.new
-      run_with_binding do |b|
-        res = eval_with_setting(b, @match.post_match, Setting[:stack_on_error])
-
-        if res.is_a?(Array)
-          puts "#{columnize(res.map(&:to_s).sort!, Setting[:width])}"
-        else
-          PP.pp(res, out)
-          puts out.string
-        end
-      end
-    rescue
-      out.puts $ERROR_INFO.message
-    end
-
-    class << self
-      def names
-        %w(ps)
-      end
-
-      def description
-        prettify <<-EOD
-          ps <expression>
-
-          Evaluates <expression>, an array, sort and columnize its value.
-        EOD
-      end
+        * NOTE - unknown input is automatically evaluated, to turn this off use
+        'set noautoeval'.
+      EOD
     end
   end
 end

data/lib/byebug/commands/finish.rb

@@ -1,4 +1,5 @@
 require 'byebug/command'
+require 'byebug/helpers/parse'
 
 module Byebug
   #
@@ -7,6 +8,8 @@ module Byebug
   # Allows the user to continue execution until certain frames are finished.
   #
   class FinishCommand < Command
+    include Helpers::ParseHelper
+
     self.allow_in_post_mortem = false
 
     def regexp
@@ -28,20 +31,16 @@ module Byebug
       @state.proceed
     end
 
-    class << self
-      def names
-        %w(finish)
-      end
+    def description
+      <<-EOD
+        fin[ish][ n_frames]
 
-      def description
-        prettify <<-EOD
-          fin[ish][ n_frames]  Execute until frame returns.
+        Execute until frame returns.
 
-          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
+        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
   end
 end

data/lib/byebug/commands/frame.rb

@@ -1,177 +1,17 @@
-require 'byebug/command'
-
 # encoding: utf-8
 
 require 'pathname'
+require 'byebug/command'
+require 'byebug/helpers/frame'
+require 'byebug/helpers/parse'
 
 module Byebug
-  #
-  # Mixin to assist command parsing
-  #
-  module FrameFunctions
-    def switch_to_frame(frame_no)
-      frame_no >= 0 ? frame_no : @state.context.stack_size + frame_no
-    end
-
-    def navigate_to_frame(jump_no)
-      return if jump_no == 0
-      total_jumps, current_jumps, new_pos = jump_no.abs, 0, @state.frame
-      step = jump_no / total_jumps # +1 (up) or -1 (down)
-
-      loop do
-        new_pos += step
-        break if new_pos < 0 || new_pos >= @state.context.stack_size
-
-        next if @state.c_frame?(new_pos)
-
-        current_jumps += 1
-        break if current_jumps == total_jumps
-      end
-      new_pos
-    end
-
-    def adjust_frame(frame, absolute)
-      if absolute
-        abs_frame = switch_to_frame(frame)
-        return errmsg(pr('frame.errors.c_frame')) if @state.c_frame?(abs_frame)
-      else
-        abs_frame = navigate_to_frame(frame)
-      end
-
-      if abs_frame >= @state.context.stack_size
-        return errmsg(pr('frame.errors.too_low'))
-      elsif abs_frame < 0
-        return errmsg(pr('frame.errors.too_high'))
-      end
-
-      @state.frame = abs_frame
-      @state.file = @state.context.frame_file(@state.frame)
-      @state.line = @state.context.frame_line(@state.frame)
-      @state.prev_line = nil
-
-      ListCommand.new(@state).execute if Setting[:autolist]
-    end
-
-    def get_pr_arguments(frame_no)
-      file = @state.frame_file(frame_no)
-      line = @state.frame_line(frame_no)
-      call = @state.frame_call(frame_no)
-      mark = @state.frame_mark(frame_no)
-      pos = @state.frame_pos(frame_no)
-
-      { mark: mark, pos: pos, call: call, file: file, line: line }
-    end
-  end
-
-  #
-  # Show current backtrace.
-  #
-  class WhereCommand < Command
-    include FrameFunctions
-
-    def regexp
-      /^\s* (?:w(?:here)?|bt|backtrace) \s*$/x
-    end
-
-    def execute
-      print_backtrace
-    end
-
-    class << self
-      def names
-        %w(where backtrace bt)
-      end
-
-      def description
-        prettify <<-EOD
-          w[here]|bt|backtrace        Display stack frames.
-
-          Print the entire stack frame. Each frame is numbered; the most recent
-          frame is 0. A frame number can be referred to in the "frame" command;
-          "up" and "down" add or subtract respectively to frame numbers shown.
-          The position of the current frame is marked with -->. C-frames hang
-          from their most immediate Ruby frame to indicate that they are not
-          navigable.
-        EOD
-      end
-    end
-
-    private
-
-    def print_backtrace
-      bt = prc('frame.line', (0...@state.context.stack_size)) do |_, index|
-        get_pr_arguments(index)
-      end
-
-      print(bt)
-    end
-  end
-
-  #
-  # Move the current frame up in the backtrace.
-  #
-  class UpCommand < Command
-    include FrameFunctions
-
-    def regexp
-      /^\s* u(?:p)? (?:\s+(\S+))? \s*$/x
-    end
-
-    def execute
-      pos, err = parse_steps(@match[1], 'Up')
-      return errmsg(err) unless pos
-
-      adjust_frame(pos, false)
-    end
-
-    class << self
-      def names
-        %w(up)
-      end
-
-      def description
-        prettify <<-EOD
-          up[ count] Move to higher frame.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Move the current frame down in the backtrace.
-  #
-  class DownCommand < Command
-    include FrameFunctions
-
-    def regexp
-      /^\s* down (?:\s+(\S+))? \s*$/x
-    end
-
-    def execute
-      pos, err = parse_steps(@match[1], 'Down')
-      return errmsg(err) unless pos
-
-      adjust_frame(-pos, false)
-    end
-
-    class << self
-      def names
-        %w(down)
-      end
-
-      def description
-        prettify <<-EOD
-          down[ count] Move to lower frame.
-        EOD
-      end
-    end
-  end
-
   #
   # Move to specific frames in the backtrace.
   #
   class FrameCommand < Command
-    include FrameFunctions
+    include Helpers::FrameHelper
+    include Helpers::ParseHelper
 
     def regexp
       /^\s* f(?:rame)? (?:\s+(\S+))? \s*$/x
@@ -189,27 +29,22 @@ module Byebug
       adjust_frame(pos, true)
     end
 
-    class << self
-      def names
-        %w(frame)
-      end
+    def description
+      <<-EOD
+        f[rame][ frame-number]
 
-      def description
-        prettify <<-EOD
-          f[rame][ frame-number]
+        Move the current frame to the specified frame number, or the 0 if no
+        frame-number has been given.
 
-          Move the current frame to the specified frame number, or the 0 if no
-          frame-number has been given.
+        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.
 
-          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.
+        Without an argument, the command prints the current stack frame. Since
+        the current position is redisplayed, it may trigger a resyncronization
+        if there is a front end also watching over things.
 
-          Without an argument, the command prints the current stack frame. Since
-          the current position is redisplayed, it may trigger a resyncronization
-          if there is a front end also watching over things.
-        EOD
-      end
+        Use the "bt" command to find out where you want to go.
+      EOD
     end
   end
 end