byebug 5.0.0 → 6.0.0

data/lib/byebug/commands/var/local.rb

@@ -8,28 +8,30 @@ module Byebug
     #
     # Shows local variables in current scope
     #
-    class LocalSubcommand < Command
+    class LocalCommand < Command
       include Helpers::VarHelper
 
-      def regexp
-        /^\s* l(?:ocal)? \s*$/x
-      end
-
-      def execute
-        var_local
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Shows local variables in current scope.'
+      def self.regexp
+        /^\s* l(?:ocal)? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           v[ar] l[ocal]
 
           #{short_description}
         EOD
       end
+
+      def self.short_description
+        'Shows local variables in current scope.'
+      end
+
+      def execute
+        var_local
+      end
     end
   end
 end

data/lib/byebug/commands/where.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'pathname'
 require 'byebug/command'
 require 'byebug/helpers/frame'
@@ -11,19 +9,17 @@ module Byebug
   class WhereCommand < Command
     include Helpers::FrameHelper
 
-    def regexp
-      /^\s* (?:w(?:here)?|bt|backtrace) \s*$/x
-    end
+    self.allow_in_post_mortem = true
 
-    def execute
-      print_backtrace
+    def self.regexp
+      /^\s* (?:w(?:here)?|bt|backtrace) \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
         w[here]|bt|backtrace
 
-        Display stack frames.
+        #{short_description}
 
         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.
@@ -34,11 +30,19 @@ module Byebug
       EOD
     end
 
+    def self.short_description
+      'Displays the backtrace'
+    end
+
+    def execute
+      print_backtrace
+    end
+
     private
 
     def print_backtrace
-      bt = prc('frame.line', (0...@state.context.stack_size)) do |_, index|
-        get_pr_arguments(index)
+      bt = prc('frame.line', (0...context.stack_size)) do |_, index|
+        Frame.new(context, index).to_hash
       end
 
       print(bt)

data/lib/byebug/context.rb

@@ -1,3 +1,8 @@
+require 'byebug/frame'
+require 'byebug/helpers/path'
+require 'byebug/helpers/file'
+require 'byebug/processors/command_processor'
+
 module Byebug
   #
   # Mantains context information for the debugger and it's the main
@@ -5,19 +10,32 @@ module Byebug
   # at_breakpoint, at_catchpoint, at_tracing, at_line and at_return callbacks
   #
   class Context
-    #
-    # List of files byebug will ignore while debugging
-    #
-    def self.ignored_files
-      Byebug.mode == :standalone ? lib_files + [bin_file] : lib_files
-    end
+    include Helpers::FileHelper
 
-    def self.bin_file
-      @bin_file ||= Gem.bin_path('byebug', 'byebug')
-    end
+    class << self
+      include Helpers::PathHelper
+
+      attr_writer :ignored_files
 
-    def self.lib_files
-      @lib_files ||= Dir.glob(File.expand_path('../../**/*.rb', __FILE__))
+      #
+      # List of files byebug will ignore while debugging
+      #
+      def ignored_files
+        @ignored_files ||=
+          Byebug.mode == :standalone ? lib_files + [bin_file] : lib_files
+      end
+
+      attr_writer :interface
+
+      def interface
+        @interface ||= LocalInterface.new
+      end
+
+      attr_writer :processor
+
+      def processor
+        @processor ||= CommandProcessor
+      end
     end
 
     #
@@ -29,6 +47,32 @@ module Byebug
       self.class.ignored_files.include?(path)
     end
 
+    def frame
+      @frame ||= Frame.new(self, 0)
+    end
+
+    def frame=(pos)
+      @frame = Frame.new(self, pos)
+    end
+
+    def file
+      frame.file
+    end
+
+    def line
+      frame.line
+    end
+
+    def location
+      "#{normalize(file)}:#{line}"
+    end
+
+    def full_location
+      return location if virtual_file?(file)
+
+      "#{location} #{get_line(file, line)}"
+    end
+
     #
     # Context's stack size
     #
@@ -44,83 +88,37 @@ module Byebug
       step_into 1
     end
 
-    #
-    # Gets local variables for a frame.
-    #
-    # @param frame_no Frame index in the backtrace. Defaults to 0.
-    #
-    # TODO: Use brand new local_variable_{get,set,defined?} for rubies >= 2.1
-    #
-    def frame_locals(frame_no = 0)
-      bind = frame_binding(frame_no)
-      return [] unless bind
-
-      bind.eval('local_variables.inject({}){|h, v| h[v] = eval(v.to_s); h}')
+    def at_breakpoint(breakpoint)
+      new_processor.at_breakpoint(breakpoint)
     end
 
-    #
-    # Gets current method arguments for a frame.
-    #
-    # @param frame_no Frame index in the backtrace. Defaults to 0.
-    #
-    def frame_args(frame_no = 0)
-      bind = frame_binding(frame_no)
-      return c_frame_args(frame_no) unless bind
-
-      ruby_frame_args(bind)
+    def at_catchpoint(exception)
+      new_processor.at_catchpoint(exception)
     end
 
-    def handler
-      Byebug.handler || fail('No interface loaded')
-    end
+    def at_tracing(file, _line)
+      return if ignored_file?(file)
 
-    def at_breakpoint(brkpnt)
-      handler.at_breakpoint(self, brkpnt)
+      new_processor.at_tracing
     end
 
-    def at_catchpoint(excpt)
-      handler.at_catchpoint(self, excpt)
-    end
+    def at_line(file, _l)
+      self.frame = 0
+      return if ignored_file?(file)
 
-    def at_tracing(file, line)
-      handler.at_tracing(self, file, line) unless ignored_file?(file)
+      new_processor.at_line
     end
 
-    def at_line(file, line)
-      handler.at_line(self, file, line) unless ignored_file?(file)
-    end
+    def at_return(file, _line)
+      return if ignored_file?(file)
 
-    def at_return(file, line)
-      handler.at_return(self, file, line) unless ignored_file?(file)
+      new_processor.at_return
     end
 
     private
 
-    #
-    # Gets method arguments for a c-frame.
-    #
-    # @param frame_no Frame index in the backtrace.
-    #
-    def c_frame_args(frame_no)
-      myself = frame_self(frame_no)
-      return [] unless myself.to_s != 'main'
-
-      myself.method(frame_method(frame_no)).parameters
-    end
-
-    #
-    # Gets method arguments for a ruby-frame.
-    #
-    # @param bind Binding for the ruby-frame.
-    #
-    def ruby_frame_args(bind)
-      return [] unless bind.eval('__method__')
-
-      bind.eval('method(__method__).parameters')
-    rescue NameError => e
-      Byebug.errmsg \
-        "Exception #{e.class} (#{e.message}) while retreving frame params"
-      []
+    def new_processor
+      @processor ||= self.class.processor.new(self)
     end
   end
 end

data/lib/byebug/core.rb

@@ -1,34 +1,33 @@
+require 'byebug/helpers/reflection'
 require 'byebug/byebug'
-require 'byebug/version'
 require 'byebug/context'
 require 'byebug/breakpoint'
 require 'byebug/interface'
-require 'byebug/processor'
+require 'byebug/processors/script_processor'
+require 'byebug/processors/post_mortem_processor'
+require 'byebug/commands'
 require 'byebug/remote'
 require 'byebug/printers/plain'
 
+#
+# Main debugger's container module. Everything is defined under this module
+#
 module Byebug
+  include Helpers::ReflectionHelper
+
   extend self
 
   #
   # Configuration file used for startup commands. Default value is .byebugrc
   #
-  INIT_FILE = '.byebugrc' unless defined?(INIT_FILE)
-
-  #
-  # Main debugger's processor
-  #
-  attr_accessor :handler
-  self.handler = CommandProcessor.new
-
-  extend Forwardable
-  def_delegators :handler, :errmsg, :puts
+  attr_accessor :init_file
+  self.init_file = '.byebugrc'
 
   #
-  # Main debugger's printer
+  # Debugger's display expressions
   #
-  attr_accessor :printer
-  self.printer = Printers::Plain.new
+  attr_accessor :displays
+  self.displays = []
 
   #
   # Running mode of the debugger. Can be either:
@@ -48,39 +47,59 @@ module Byebug
   # are debugging, in the directory where you invoke byebug.
   #
   def run_init_script
-    home_rc = File.expand_path(File.join(ENV['HOME'].to_s, INIT_FILE))
+    home_rc = File.expand_path(File.join(ENV['HOME'].to_s, init_file))
     run_script(home_rc) if File.exist?(home_rc)
 
-    cwd_rc = File.expand_path(File.join('.', INIT_FILE))
+    cwd_rc = File.expand_path(File.join('.', init_file))
     run_script(cwd_rc) if File.exist?(cwd_rc) && cwd_rc != home_rc
   end
 
+  def self.load_settings
+    Dir.glob(File.expand_path('../settings/*.rb', __FILE__)).each do |file|
+      require file
+    end
+
+    constants.grep(/[a-z]Setting/).map do |name|
+      setting = const_get(name).new
+      Byebug::Setting.settings[setting.to_sym] = setting
+    end
+  end
+
   #
-  # A Byebug command is a class defined right under the Byebug module and
-  # named <something>Command
+  # Saves information about the unhandled exception and gives a byebug
+  # prompt back to the user before program termination.
   #
-  def commands
-    const_list = constants.map { |const| const_get(const, false) }
+  def self.handle_post_mortem
+    return unless raised_exception
+
+    context = raised_exception.__bb_context
 
-    const_list.select { |c| c.is_a?(Class) && c.name =~ /[a-z]Command$/ }
+    PostMortemProcessor.new(context).at_line
   end
 
+  at_exit { Byebug.handle_post_mortem if Byebug.post_mortem? }
+
   private
 
   #
   # Runs a script file
   #
   def run_script(file, verbose = false)
-    interface = ScriptInterface.new(file, verbose)
-    processor = ControlCommandProcessor.new(interface)
-    processor.process_commands
+    old_interface = Context.interface
+    Context.interface = ScriptInterface.new(file, verbose)
+
+    ScriptProcessor.new(nil).process_commands
+  ensure
+    Context.interface = old_interface
   end
 end
 
+Byebug.load_settings
+
 #
 # Extends the extension class to be able to pass information about the
 # debugging environment from the c-extension to the user.
 #
 class Exception
-  attr_reader :__bb_file, :__bb_line, :__bb_binding, :__bb_context
+  attr_reader :__bb_context
 end

data/lib/byebug/errors.rb

@@ -0,0 +1,27 @@
+module Byebug
+  #
+  # Custom exception exception to signal "command not found" errors
+  #
+  class CommandNotFound < NoMethodError
+    def initialize(input, parent = nil)
+      @input = input
+      @parent = parent
+
+      super("Unknown command '#{name}'. Try '#{help}'")
+    end
+
+    private
+
+    def name
+      build_cmd(@parent, @input)
+    end
+
+    def help
+      build_cmd('help', @parent)
+    end
+
+    def build_cmd(*args)
+      args.compact.join(' ')
+    end
+  end
+end

data/lib/byebug/frame.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+
+require 'byebug/helpers/file'
+
+module Byebug
+  #
+  # Represents a frame in the stack trace
+  #
+  class Frame
+    include Helpers::FileHelper
+
+    attr_reader :pos
+
+    def initialize(context, pos)
+      @context = context
+      @pos = pos
+    end
+
+    def file
+      @context.frame_file(pos)
+    end
+
+    def line
+      @context.frame_line(pos)
+    end
+
+    def _self
+      @context.frame_self(pos)
+    end
+
+    def _binding
+      @context.frame_binding(pos)
+    end
+
+    def _class
+      @context.frame_class(pos)
+    end
+
+    def _method
+      @context.frame_method(pos)
+    end
+
+    def current?
+      @context.frame.pos == pos
+    end
+
+    #
+    # Gets local variables for the frame.
+    #
+    # TODO: Use brand new local_variable_{get,set,defined?} for rubies >= 2.1
+    #
+    def locals
+      return [] unless _binding
+
+      _binding.eval('local_variables.inject({}){|h, v| h[v] = eval(v.to_s); h}')
+    end
+
+    #
+    # Gets current method arguments for the frame.
+    #
+    def args
+      return c_args unless _binding
+
+      ruby_args
+    end
+
+    #
+    # Returns the current class in the frame or an empty string if the current
+    # +callstyle+ setting is 'short'
+    #
+    def deco_class
+      Setting[:callstyle] == 'short' || _class.to_s.empty? ? '' : "#{_class}."
+    end
+
+    def deco_block
+      _method[/(?:block(?: \(\d+ levels\))?|rescue) in /] || ''
+    end
+
+    def deco_method
+      _method[/((?:block(?: \(\d+ levels\))?|rescue) in )?(.*)/]
+    end
+
+    #
+    # Builds a string containing all available args in the frame number, in a
+    # verbose or non verbose way according to the value of the +callstyle+
+    # setting
+    #
+    def deco_args
+      return '' if args.empty?
+
+      my_args = args.map do |arg|
+        prefix, default = prefix_and_default(arg[0])
+
+        kls = use_short_style?(arg) ? '' : "##{locals[arg[1]].class}"
+
+        "#{prefix}#{arg[1] || default}#{kls}"
+      end
+
+      "(#{my_args.join(', ')})"
+    end
+
+    #
+    # Builds a formatted string containing information about current method call
+    #
+    def deco_call
+      deco_block + deco_class + deco_method + deco_args
+    end
+
+    #
+    # Formatted filename in frame
+    #
+    def deco_file
+      Setting[:fullpath] ? File.expand_path(file) : shortpath(file)
+    end
+
+    #
+    # Properly formatted frame number of frame
+    #
+    def deco_pos
+      format('%-2d', pos)
+    end
+
+    #
+    # Formatted mark for the frame.
+    #
+    # --> marks the current frame
+    # ͱ-- marks c-frames
+    #     marks regular frames
+    #
+    def mark
+      return '-->' if current?
+      return '    ͱ--' if c_frame?
+
+      '   '
+    end
+
+    #
+    # Checks whether the frame is a c-frame
+    #
+    def c_frame?
+      _binding.nil?
+    end
+
+    def to_hash
+      {
+        mark: mark,
+        pos: deco_pos,
+        call: deco_call,
+        file: deco_file,
+        line: line,
+        full_path: File.expand_path(deco_file)
+      }
+    end
+
+    private
+
+    def c_args
+      return [] unless _self.to_s != 'main'
+
+      _self.method(_method).parameters
+    end
+
+    def ruby_args
+      return [] unless _binding.eval('__method__')
+      return [] unless _binding.eval('method(__method__)')
+
+      _binding.eval('method(__method__).parameters')
+    end
+
+    def use_short_style?(arg)
+      Setting[:callstyle] == 'short' || arg[1].nil? || locals.empty?
+    end
+
+    def prefix_and_default(arg_type)
+      return ['&', 'block'] if arg_type == :block
+      return ['*', 'args'] if arg_type == :rest
+
+      ['', nil]
+    end
+  end
+end