runger_byebug 11.2.0

data/lib/byebug/commands/up.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../command"
+require_relative "../helpers/frame"
+require_relative "../helpers/parse"
+
+module Byebug
+  #
+  # Move the current frame up in the backtrace.
+  #
+  class UpCommand < Command
+    include Helpers::FrameHelper
+    include Helpers::ParseHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* up (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        up[ count]
+
+        #{short_description}
+
+        Use the "bt" command to find out where you want to go.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Moves to a higher frame in the stack trace"
+    end
+
+    def execute
+      pos, err = parse_steps(@match[1], "Up")
+      return errmsg(err) unless pos
+
+      jump_frames(pos)
+
+      ListCommand.new(processor).execute if Setting[:autolist]
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/var"
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +all+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows global, instance and local variables
+    #
+    class AllCommand < Command
+      include Helpers::VarHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* a(?:ll)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          v[ar] a[ll]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Shows local, global and instance variables of self."
+      end
+
+      def execute
+        var_global
+        var_instance("self")
+        var_local
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/var"
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +args+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Information about arguments of the current method/block
+    #
+    class ArgsCommand < Command
+      include Helpers::VarHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* a(?:rgs)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          v[ar] a[args]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Information about arguments of the current scope."
+      end
+
+      def execute
+        var_args
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/eval"
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +const+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows constants
+    #
+    class ConstCommand < Command
+      include Helpers::EvalHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* c(?:onst)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          v[ar] c[onstant]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Shows constants of an object."
+      end
+
+      def execute
+        obj = warning_eval(str_obj)
+        return errmsg(pr("variable.errors.not_module", object: str_obj)) unless obj.is_a?(Module)
+
+        constants = warning_eval("#{str_obj}.constants")
+        puts prv(constants.sort.map { |c| [c, obj.const_get(c)] }, "constant")
+      end
+
+      private
+
+      def str_obj
+        @str_obj ||= @match[1] || "self.class"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +global+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows global variables
+    #
+    class GlobalCommand < Command
+      include Helpers::VarHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* g(?:lobal)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          v[ar] g[lobal]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Shows global variables."
+      end
+
+      def execute
+        var_global
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/var"
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +instance+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows instance variables
+    #
+    class InstanceCommand < Command
+      include Helpers::VarHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* i(?:nstance)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          v[ar] i[nstance][ <object>]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Shows instance variables of self or a specific object."
+      end
+
+      def execute
+        var_instance(@match[1])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../helpers/var"
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +local+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows local variables in current scope
+    #
+    class LocalCommand < Command
+      include Helpers::VarHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* l(?:ocal)? \s*$/x
+      end
+
+      def self.description
+        <<-DESCRIPTION
+          v[ar] l[ocal]
+
+          #{short_description}
+        DESCRIPTION
+      end
+
+      def self.short_description
+        "Shows local variables in current scope."
+      end
+
+      def execute
+        var_local
+      end
+    end
+  end
+end

data/lib/byebug/commands/var.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../subcommands"
+
+require_relative "var/all"
+require_relative "var/args"
+require_relative "var/const"
+require_relative "var/instance"
+require_relative "var/local"
+require_relative "var/global"
+
+module Byebug
+  #
+  # Shows variables and its values
+  #
+  class VarCommand < Command
+    include Subcommands
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* v(?:ar)? (?:\s+ (.+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        [v]ar <subcommand>
+
+        #{short_description}
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Shows variables and its values"
+    end
+  end
+end

data/lib/byebug/commands/where.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../command"
+require_relative "../helpers/frame"
+
+module Byebug
+  #
+  # Show current backtrace.
+  #
+  class WhereCommand < Command
+    include Helpers::FrameHelper
+
+    self.allow_in_post_mortem = true
+
+    def self.regexp
+      /^\s* (?:w(?:here)?|bt|backtrace) (?:\s+(\S+))? \s*$/x
+    end
+
+    def self.description
+      <<-DESCRIPTION
+        w[here]|bt|backtrace[ maximum-frame]
+
+        #{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.
+        "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.
+
+        Without an argument, the command prints all the frames. With an argument,
+        the command prints the nth first frames, where n is the largest between
+        the argument or the maximum stack frame.
+      DESCRIPTION
+    end
+
+    def self.short_description
+      "Displays the backtrace"
+    end
+
+    def execute
+      print_backtrace
+    end
+
+    private
+
+    def print_backtrace
+      max_frame =
+        if @match[1] && @match[1].to_i <= context.stack_size
+          @match[1].to_i
+        else
+          context.stack_size
+        end
+
+      bt = prc("frame.line", (0...max_frame)) do |_, index|
+        Frame.new(context, index).to_hash
+      end
+
+      print(bt)
+    end
+  end
+end

data/lib/byebug/commands.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "commands/break"
+require_relative "commands/catch"
+require_relative "commands/condition"
+require_relative "commands/continue"
+require_relative "commands/debug"
+require_relative "commands/delete"
+require_relative "commands/disable"
+require_relative "commands/display"
+require_relative "commands/down"
+require_relative "commands/edit"
+require_relative "commands/enable"
+require_relative "commands/finish"
+require_relative "commands/frame"
+require_relative "commands/help"
+require_relative "commands/history"
+require_relative "commands/info"
+require_relative "commands/interrupt"
+require_relative "commands/irb"
+require_relative "commands/kill"
+require_relative "commands/list"
+require_relative "commands/method"
+require_relative "commands/next"
+require_relative "commands/pry"
+require_relative "commands/quit"
+require_relative "commands/restart"
+require_relative "commands/save"
+require_relative "commands/set"
+require_relative "commands/show"
+require_relative "commands/skip"
+require_relative "commands/source"
+require_relative "commands/step"
+require_relative "commands/thread"
+require_relative "commands/tracevar"
+require_relative "commands/undisplay"
+require_relative "commands/untracevar"
+require_relative "commands/up"
+require_relative "commands/var"
+require_relative "commands/where"

data/lib/byebug/context.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "frame"
+require_relative "helpers/path"
+require_relative "helpers/file"
+require_relative "processors/command_processor"
+
+module Byebug
+  #
+  # Mantains context information for the debugger and it's the main
+  # communication point between the library and the C-extension through the
+  # at_breakpoint, at_catchpoint, at_tracing, at_line and at_return callbacks
+  #
+  class Context
+    include Helpers::FileHelper
+
+    class << self
+      include Helpers::PathHelper
+
+      attr_writer :ignored_files
+
+      #
+      # 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
+
+    #
+    # Reader for the current frame
+    #
+    def frame
+      @frame ||= Frame.new(self, 0)
+    end
+
+    #
+    # Writer for the current frame
+    #
+    def frame=(pos)
+      @frame = Frame.new(self, pos)
+    end
+
+    extend Forwardable
+    def_delegators :frame, :file, :line
+
+    #
+    # Current file & line information
+    #
+    def location
+      "#{normalize(file)}:#{line}"
+    end
+
+    #
+    # Current file, line and source code information
+    #
+    def full_location
+      return location if virtual_file?(file)
+
+      "#{location} #{get_line(file, line)}"
+    end
+
+    #
+    # Context's stack size
+    #
+    def stack_size
+      return 0 unless backtrace
+
+      backtrace.drop_while { |l| ignored_file?(l.first.path) }
+               .take_while { |l| !ignored_file?(l.first.path) }
+               .size
+    end
+
+    def interrupt
+      step_into 1
+    end
+
+    #
+    # Line handler
+    #
+    def at_line
+      self.frame = 0
+      return if ignored_file?(file)
+
+      processor.at_line
+    end
+
+    #
+    # Tracing handler
+    #
+    def at_tracing
+      return if ignored_file?(file)
+
+      processor.at_tracing
+    end
+
+    #
+    # Breakpoint handler
+    #
+    def at_breakpoint(breakpoint)
+      processor.at_breakpoint(breakpoint)
+    end
+
+    #
+    # Catchpoint handler
+    #
+    def at_catchpoint(exception)
+      processor.at_catchpoint(exception)
+    end
+
+    #
+    # Return handler
+    #
+    def at_return(return_value)
+      return if ignored_file?(file)
+
+      processor.at_return(return_value)
+    end
+
+    #
+    # End of class definition handler
+    #
+    def at_end
+      return if ignored_file?(file)
+
+      processor.at_end
+    end
+
+    private
+
+    def processor
+      @processor ||= self.class.processor.new(self, self.class.interface)
+    end
+
+    #
+    # Tells whether a file is ignored by the debugger.
+    #
+    # @param path [String] filename to be checked.
+    #
+    def ignored_file?(path)
+      self.class.ignored_files.include?(path)
+    end
+  end
+end

data/lib/byebug/core.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "helpers/reflection"
+require "byebug/byebug"
+require_relative "context"
+require_relative "breakpoint"
+require_relative "interface"
+require_relative "processors/script_processor"
+require_relative "processors/post_mortem_processor"
+require_relative "commands"
+require_relative "remote"
+require_relative "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
+  #
+  attr_accessor :init_file
+  self.init_file = ".byebugrc"
+
+  #
+  # Debugger's display expressions
+  #
+  attr_accessor :displays
+  self.displays = []
+
+  #
+  # Running mode of the debugger. Can be either:
+  #
+  # * :attached => Attached to a running program through the `byebug` method.
+  # * :standalone => Started through `byebug` script.
+  # * :off => Ignoring any `byebug` method calls.
+  #
+  attr_accessor :mode
+
+  #
+  # Runs normal byebug initialization scripts.
+  #
+  # Reads and executes the commands from init file (if any) in the current
+  # working directory. This is only done if the current directory is different
+  # from your home directory. Thus, you can have more than one init file, one
+  # generic in your home directory, and another, specific to the program you
+  # are debugging, in the directory where you invoke byebug.
+  #
+  def run_init_script
+    rc_dirs.each do |dir|
+      rc_file = File.expand_path(File.join(dir, init_file))
+      next unless File.exist?(rc_file)
+
+      run_rc_file(rc_file)
+    end
+  end
+
+  def self.load_settings
+    Dir.glob(File.join(__dir__, "settings", "*.rb")).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
+
+  #
+  # Saves information about the unhandled exception and gives a byebug
+  # prompt back to the user before program termination.
+  #
+  def self.handle_post_mortem
+    return unless raised_exception
+
+    context = raised_exception.__bb_context
+
+    PostMortemProcessor.new(context).at_line
+  end
+
+  at_exit { Byebug.handle_post_mortem if Byebug.post_mortem? }
+
+  private
+
+  #
+  # Runs a initialization script file
+  #
+  def run_rc_file(rc_file)
+    interface = ScriptInterface.new(rc_file)
+
+    ScriptProcessor.new(nil, interface).process_commands
+  end
+
+  #
+  # List of folders to load rc files from
+  #
+  # @note Files will be loaded in the order specified here.
+  #
+  def rc_dirs
+    [ENV["HOME"], Dir.pwd].compact.uniq
+  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_context
+end