byebug 5.0.0 → 6.0.0

data/lib/byebug/helpers/eval.rb

@@ -1,46 +1,87 @@
 module Byebug
   module Helpers
     #
-    # Utilities used by the eval command
+    # Utilities to assist evaluation of code strings
     #
     module EvalHelper
       #
-      # Run block temporarily ignoring all TracePoint events.
+      # Evaluates +expression+ that might manipulate threads
       #
-      # 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.
+      # @param expression [String] Expression to evaluate
       #
-      def allowing_other_threads
-        Byebug.unlock
-        res = yield
-        Byebug.lock
-        res
+      def thread_safe_eval(expression)
+        allowing_other_threads { single_thread_eval(expression) }
+      end
+
+      #
+      # Evaluates an +expression+ that doesn't deal with threads
+      #
+      # @param expression [String] Expression to evaluate
+      #
+      def single_thread_eval(expression)
+        return error_eval(expression) if Setting[:stack_on_error]
+
+        warning_eval(expression)
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # returning nil in an error happens.
+      #
+      def silent_eval(str, binding = frame._binding)
+        binding.eval(str)
+      rescue StandardError, ScriptError
+        nil
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at an error level.
+      #
+      def error_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| error_msg(e) }
       end
 
       #
-      # Get current binding and yield it to the given block
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at a warning level.
       #
-      def run_with_binding
-        binding = get_binding
-        yield binding
+      def warning_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| warning_msg(e) }
+      end
+
+      private
+
+      def safe_eval(str, binding)
+        binding.eval(str)
+      rescue StandardError, ScriptError => e
+        raise(e, yield(e))
+      end
+
+      def error_msg(e)
+        at = e.backtrace
+        locations = ["#{at.shift}: #{e.class} Exception(#{e.message})"]
+        locations += at.map { |path| "\tfrom #{path}" }
+
+        pr('eval.exception', text_message: locations.join("\n"))
+      end
+
+      def warning_msg(e)
+        pr('eval.exception', text_message: "#{e.class} Exception: #{e.message}")
       end
 
       #
-      # Evaluate +expression+ using +binding+
+      # Run block temporarily ignoring all TracePoint events.
       #
-      # @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.
+      # 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 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
+      def allowing_other_threads
+        Byebug.unlock
+        res = yield
+        Byebug.lock
+        res
       end
     end
   end

data/lib/byebug/helpers/file.rb

@@ -33,13 +33,28 @@ module Byebug
       # Regularize file name.
       #
       def normalize(filename)
-        return filename if ['(irb)', '-e'].include?(filename)
+        return filename if virtual_file?(filename)
 
         return File.basename(filename) if Setting[:basename]
 
-        path = File.expand_path(filename)
+        File.exist?(filename) ? File.realpath(filename) : filename
+      end
+
+      #
+      # A short version of a long path
+      #
+      def shortpath(fullpath)
+        components = Pathname(fullpath).each_filename.to_a
+        return fullpath if components.size <= 2
 
-        File.exist?(path) ? File.realpath(path) : filename
+        File.join('...', components[-3..-1])
+      end
+
+      #
+      # True for special files like -e, false otherwise
+      #
+      def virtual_file?(name)
+        ['(irb)', '-e'].include?(name)
       end
     end
   end

data/lib/byebug/helpers/frame.rb

@@ -4,21 +4,36 @@ module Byebug
     # Utilities to assist frame navigation
     #
     module FrameHelper
-      def switch_to_frame(frame_no)
-        frame_no >= 0 ? frame_no : @state.context.stack_size + frame_no
+      def switch_to_frame(frame)
+        new_frame = index_from_start(frame)
+        return frame_err('c_frame') if Frame.new(context, new_frame).c_frame?
+
+        adjust_frame(new_frame)
       end
 
-      def navigate_to_frame(jump_no)
-        return if jump_no == 0
+      def jump_frames(steps)
+        adjust_frame(navigate_to_frame(steps))
+      end
+
+      private
+
+      def adjust_frame(new_frame)
+        return frame_err('too_low') if new_frame >= context.stack_size
+        return frame_err('too_high') if new_frame < 0
 
+        context.frame = new_frame
+        processor.prev_line = nil
+      end
+
+      def navigate_to_frame(jump_no)
         current_jumps = 0
-        current_pos = @state.frame
+        current_pos = context.frame.pos
 
         loop do
           current_pos += direction(jump_no)
-          break if current_pos < 0 || current_pos >= @state.context.stack_size
+          break if out_of_bounds?(current_pos)
 
-          next if @state.c_frame?(current_pos)
+          next if Frame.new(context, current_pos).c_frame?
 
           current_jumps += 1
           break if current_jumps == jump_no.abs
@@ -27,42 +42,14 @@ module Byebug
         current_pos
       end
 
-      def adjust_frame(frame, absolute)
-        if absolute
-          abs_frame = switch_to_frame(frame)
-          if @state.c_frame?(abs_frame)
-            return errmsg(pr('frame.errors.c_frame'))
-          end
-        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
+      def out_of_bounds?(pos)
+        !(0...context.stack_size).include?(pos)
       end
 
-      def get_pr_arguments(frame_no)
-        file = @state.frame_file(frame_no)
-        full_path = File.expand_path(file)
-        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,
-          full_path: full_path }
+      def frame_err(msg)
+        errmsg(pr("frame.errors.#{msg}"))
       end
 
-      private
-
       #
       # @param [Integer] A positive or negative integer
       #
@@ -71,6 +58,16 @@ module Byebug
       def direction(step)
         step / step.abs
       end
+
+      #
+      # Convert a possibly negative index to a positive index from the start
+      # of the callstack. -1 is the last position in the stack and so on.
+      #
+      # @param [Integer] Integer to be converted in a proper positive index.
+      #
+      def index_from_start(i)
+        i >= 0 ? i : context.stack_size + i
+      end
     end
   end
 end

data/lib/byebug/helpers/parse.rb

@@ -9,7 +9,7 @@ module Byebug
       #
       # If either +min+ or +max+ is nil, that value has no bound.
       #
-      # TODO: Remove the `cmd` parameter. It has nothing to do with the methods
+      # TODO: Remove the `cmd` parameter. It has nothing to do with the method's
       # purpose.
       #
       def get_int(str, cmd, min = nil, max = nil)
@@ -46,18 +46,6 @@ module Byebug
         end
       end
 
-      #
-      # Temporarily disable output to $stderr
-      #
-      def without_stderr
-        stderr = $stderr
-        $stderr.reopen(IO::NULL)
-
-        yield
-      ensure
-        $stderr.reopen(stderr)
-      end
-
       #
       # @return +str+ as an integer or 1 if +str+ is empty.
       #
@@ -69,6 +57,20 @@ module Byebug
 
         steps
       end
+
+      private
+
+      #
+      # Temporarily disable output to $stderr
+      #
+      def without_stderr
+        stderr = $stderr
+        $stderr.reopen(IO::NULL)
+
+        yield
+      ensure
+        $stderr.reopen(stderr)
+      end
     end
   end
 end

data/lib/byebug/helpers/path.rb

@@ -0,0 +1,21 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for managing gem paths
+    #
+    module PathHelper
+      def bin_file
+        @bin_file ||= Gem.bin_path('byebug', 'byebug')
+      end
+
+      def lib_files
+        @lib_files ||= Dir.glob(File.expand_path('../../../**/*.rb', __FILE__))
+      end
+
+      def all_files
+        @all_files ||=
+          Dir.glob(File.expand_path('../../../../**/*.rb', __FILE__))
+      end
+    end
+  end
+end

data/lib/byebug/helpers/reflection.rb

@@ -0,0 +1,17 @@
+module Byebug
+  module Helpers
+    #
+    # Reflection utilitie
+    #
+    module ReflectionHelper
+      #
+      # List of "command" classes in the including module
+      #
+      def commands
+        constants(false)
+          .map { |const| const_get(const, false) }
+          .select { |c| c.is_a?(Class) && c.name =~ /[a-z]Command$/ }
+      end
+    end
+  end
+end

data/lib/byebug/helpers/thread.rb

@@ -4,22 +4,24 @@ module Byebug
     # Utilities for thread subcommands
     #
     module ThreadHelper
-      def display_context(context)
-        puts pr('thread.context', thread_arguments(context))
+      def display_context(ctx)
+        puts pr('thread.context', thread_arguments(ctx))
       end
 
-      def thread_arguments(context)
-        status_flag = if context.suspended?
+      def thread_arguments(ctx)
+        status_flag = if ctx.suspended?
                         '$'
                       else
-                        context.thread == Thread.current ? '+' : ' '
+                        current_thread?(ctx) ? '+' : ' '
                       end
-        debug_flag = context.ignored? ? '!' : ' '
 
-        if context == Byebug.current_context
-          file_line = "#{@state.file}:#{@state.line}"
+        debug_flag = ctx.ignored? ? '!' : ' '
+
+        # Check whether it is Byebug.current_context or context
+        if ctx == Byebug.current_context
+          file_line = context.location
         else
-          backtrace = context.thread.backtrace_locations
+          backtrace = ctx.thread.backtrace_locations
           if backtrace && backtrace[0]
             file_line = "#{backtrace[0].path}:#{backtrace[0].lineno}"
           end
@@ -28,21 +30,25 @@ module Byebug
         {
           status_flag: status_flag,
           debug_flag: debug_flag,
-          id: context.thnum,
-          thread: context.thread.inspect,
+          id: ctx.thnum,
+          thread: ctx.thread.inspect,
           file_line: file_line || '',
           pid: Process.pid,
-          status: context.thread.status,
-          current: (context.thread == Thread.current)
+          status: ctx.thread.status,
+          current: current_thread?(ctx)
         }
       end
 
+      def current_thread?(ctx)
+        ctx.thread == Thread.current
+      end
+
       def context_from_thread(thnum)
         ctx = Byebug.contexts.find { |c| c.thnum.to_s == thnum }
 
         err = case
               when ctx.nil? then pr('thread.errors.no_thread')
-              when ctx == @state.context then pr('thread.errors.current_thread')
+              when ctx == context then pr('thread.errors.current_thread')
               when ctx.ignored? then pr('thread.errors.ignored', arg: thnum)
               end
 

data/lib/byebug/helpers/toggle.rb

@@ -39,18 +39,23 @@ module Byebug
       end
 
       def enable_disable_display(is_enable, args)
-        display = @state.display
-        return errmsg(pr('toggle.errors.no_display')) if 0 == display.size
+        return errmsg(pr('toggle.errors.no_display')) if 0 == n_displays
 
-        selected_displays = args.nil? ? [1..display.size + 1] : args.split(/ +/)
+        selected_displays = args ? args.split(/ +/) : [1..n_displays + 1]
 
         selected_displays.each do |pos|
-          pos, err = get_int(pos, "#{is_enable} display", 1, display.size)
+          pos, err = get_int(pos, "#{is_enable} display", 1, n_displays)
           return errmsg(err) unless err.nil?
 
-          display[pos - 1][0] = ('enable' == is_enable)
+          Byebug.displays[pos - 1][0] = ('enable' == is_enable)
         end
       end
+
+      private
+
+      def n_displays
+        Byebug.displays.size
+      end
     end
   end
 end

data/lib/byebug/helpers/var.rb

@@ -1,22 +1,18 @@
+require 'byebug/helpers/eval'
+
 module Byebug
   module Helpers
     #
     # Utilities for variable subcommands
     #
     module VarHelper
-      def var_list(ary, b = get_binding)
-        vars = ary.sort.map do |v|
-          s = begin
-            b.eval(v.to_s).inspect
-          rescue
-            begin
-              b.eval(v.to_s).to_s
-            rescue
-              '*Error in evaluation*'
-            end
-          end
-          [v, s]
+      include EvalHelper
+
+      def var_list(ary, binding = context.frame._binding)
+        vars = ary.sort.map do |name|
+          [name, safe_inspect(silent_eval(name.to_s, binding))]
         end
+
         puts prv(vars, 'instance')
       end
 
@@ -29,17 +25,42 @@ module Byebug
       end
 
       def var_instance(str)
-        obj = bb_warning_eval(str || 'self')
+        obj = single_thread_eval(str || 'self')
 
         var_list(obj.instance_variables, obj.instance_eval { binding })
       end
 
       def var_local
-        locals = @state.context.frame_locals
-        cur_self = @state.context.frame_self(@state.frame)
+        locals = context.frame.locals
+        cur_self = context.frame._self
         locals[:self] = cur_self unless cur_self.to_s == 'main'
         puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, 'instance')
       end
+
+      def var_args
+        args = context.frame.args
+        return if args == [[:rest]]
+
+        all_locals = context.frame.locals
+        arg_values = args.map { |arg| arg[1] }
+
+        locals = all_locals.select { |k, _| arg_values.include?(k) }
+        puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, 'instance')
+      end
+
+      private
+
+      def safe_inspect(var)
+        var.inspect
+      rescue
+        safe_to_s(var)
+      end
+
+      def safe_to_s(var)
+        var.to_s
+      rescue
+        '*Error in evaluation*'
+      end
     end
   end
 end