ed-precompiled_debug 1.11.0

data/lib/debug/frame_info.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module DEBUGGER__
+  FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
+                          :has_return_value,     :return_value,
+                          :has_raised_exception, :raised_exception,
+                          :show_line,
+                          :_local_variables, :_callee, # for recorder
+                          :dupped_binding,
+                        )
+
+  # extend FrameInfo with debug.so
+  begin
+    ruby_version = /(\d+\.\d+)/.match(::RUBY_VERSION)
+    require "#{ruby_version}/debug/debug.so"
+  rescue LoadError
+    require 'debug/debug.so'
+  end
+
+  class FrameInfo
+    HOME = ENV['HOME'] ? (ENV['HOME'] + '/') : nil
+
+    def path
+      location.path
+    end
+
+    def realpath
+      location.absolute_path
+    end
+
+    def self.pretty_path path
+      return '#<none>' unless path
+      use_short_path = CONFIG[:use_short_path]
+
+      case
+      when use_short_path && path.start_with?(dir = RbConfig::CONFIG["rubylibdir"] + '/')
+        path.sub(dir, '$(rubylibdir)/')
+      when use_short_path && Gem.path.any? do |gp|
+          path.start_with?(dir = gp + '/gems/')
+        end
+        path.sub(dir, '$(Gem)/')
+      when HOME && path.start_with?(HOME)
+        path.sub(HOME, '~/')
+      else
+        path
+      end
+    end
+
+    def pretty_path
+      FrameInfo.pretty_path path
+    end
+
+    def name
+      # p frame_type: frame_type, self: self
+      case frame_type
+      when :block
+        level, block_loc = block_identifier
+        "block in #{block_loc}#{level}"
+      when :method
+        method_identifier
+      when :c
+        c_identifier
+      when :other
+        other_identifier
+      end
+    end
+
+    def file_lines
+      SESSION.source(self.iseq)
+    end
+
+    def frame_type
+      if self.local_variables && iseq
+        if iseq.type == :block
+          :block
+        elsif callee
+          :method
+        else
+          :other
+        end
+      else
+        :c
+      end
+    end
+
+    BLOCK_LABL_REGEXP = /\Ablock( \(\d+ levels\))* in (.+)\z/
+
+    def block_identifier
+      return unless frame_type == :block
+      re_match = location.label.match(BLOCK_LABL_REGEXP)
+      _, level, block_loc = re_match ? re_match.to_a : [nil, nil, location.label]
+
+      [level || "", block_loc]
+    end
+
+    def method_identifier
+      return unless frame_type == :method
+      "#{klass_sig}#{callee}"
+    end
+
+    def c_identifier
+      return unless frame_type == :c
+      "[C] #{klass_sig}#{location.base_label}"
+    end
+
+    def other_identifier
+      return unless frame_type == :other
+      location.label
+    end
+
+    def callee
+      self._callee ||= begin
+                         self.binding&.eval('__callee__')
+                       rescue NameError # BasicObject
+                         nil
+                       end
+    end
+
+    def return_str
+      if self.binding && iseq && has_return_value
+        DEBUGGER__.safe_inspect(return_value, short: true)
+      end
+    end
+
+    def matchable_location
+      # realpath can sometimes be nil so we can't use it here
+      "#{path}:#{location.lineno}"
+    end
+
+    def location_str
+      "#{pretty_path}:#{location.lineno}"
+    end
+
+    def eval_binding
+      if b = self.dupped_binding
+        b
+      else
+        b = self.binding || TOPLEVEL_BINDING
+        self.dupped_binding = b.dup
+      end
+    end
+
+    def local_variables
+      if lvars = self._local_variables
+        lvars
+      elsif b = self.binding
+        b.local_variables.map{|var|
+          [var, b.local_variable_get(var)]
+        }.to_h
+      end
+    end
+
+    def iseq_parameters_info
+      case frame_type
+      when :block, :method
+        parameters_info
+      else
+        nil
+      end
+    end
+
+    def parameters_info
+      vars = iseq.parameters_symbols
+      vars.map{|var|
+        begin
+          { name: var, value: DEBUGGER__.safe_inspect(local_variable_get(var), short: true) }
+        rescue NameError, TypeError
+          nil
+        end
+      }.compact
+    end
+
+    private def get_singleton_class obj
+      obj.singleton_class # TODO: don't use it
+    rescue TypeError
+      nil
+    end
+
+    private def local_variable_get var
+      local_variables[var]
+    end
+
+    private def klass_sig
+      if self.class == get_singleton_class(self.self)
+        "#{self.self}."
+      else
+        "#{self.class}#"
+      end
+    end
+  end
+end

data/lib/debug/irb_integration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'irb'
+
+module DEBUGGER__
+  module IrbPatch
+    def evaluate(line, line_no)
+      SESSION.send(:restart_all_threads)
+      super
+      # This is to communicate with the test framework so it can feed the next input
+      puts "INTERNAL_INFO: {}" if ENV['RUBY_DEBUG_TEST_UI'] == 'terminal'
+    ensure
+      SESSION.send(:stop_all_threads)
+    end
+  end
+
+  class ThreadClient
+    def activate_irb_integration
+      IRB.setup(location, argv: [])
+      workspace = IRB::WorkSpace.new(current_frame&.binding || TOPLEVEL_BINDING)
+      irb = IRB::Irb.new(workspace)
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+      IRB::Debug.setup(irb)
+      IRB::Context.prepend(IrbPatch)
+    end
+  end
+
+  class Session
+    def deactivate_irb_integration
+      Reline.completion_proc = nil
+      Reline.output_modifier_proc = nil
+      Reline.autocompletion = false
+      Reline.dig_perfect_match_proc = nil
+      reset_ui UI_LocalConsole.new
+    end
+  end
+end

data/lib/debug/local.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'io/console/size'
+require_relative 'console'
+
+module DEBUGGER__
+  class UI_LocalConsole < UI_Base
+    def initialize
+      @console = Console.new
+    end
+
+    def remote?
+      false
+    end
+
+    def activate_sigint
+      prev_handler = trap(:SIGINT){
+        if SESSION.active?
+          ThreadClient.current.on_trap :SIGINT
+        end
+      }
+      SESSION.intercept_trap_sigint_start prev_handler
+    end
+
+    def deactivate_sigint
+      if SESSION.intercept_trap_sigint?
+        prev = SESSION.intercept_trap_sigint_end
+        trap(:SIGINT, prev)
+      end
+    end
+
+    def activate session, on_fork: false
+      activate_sigint unless CONFIG[:no_sigint_hook]
+    end
+
+    def deactivate
+      deactivate_sigint
+      @console.deactivate
+    end
+
+    def width
+      if (w = IO.console_size[1]) == 0 # for tests PTY
+        80
+      else
+        w
+      end
+    end
+
+    def quit n
+      yield
+      exit n
+    end
+
+    def ask prompt
+      setup_interrupt do
+        print prompt
+        ($stdin.gets || '').strip
+      end
+    end
+
+    def puts str = nil
+      case str
+      when Array
+        str.each{|line|
+          $stdout.puts line.chomp
+        }
+      when String
+        str.each_line{|line|
+          $stdout.puts line.chomp
+        }
+      when nil
+        $stdout.puts
+      end
+    end
+
+    def readline prompt = '(rdbg)'
+      setup_interrupt do
+        (@console.readline(prompt) || 'quit').strip
+      end
+    end
+
+    def setup_interrupt
+      SESSION.intercept_trap_sigint false do
+        current_thread = Thread.current # should be session_server thread
+
+        prev_handler = trap(:INT){
+          current_thread.raise Interrupt
+        }
+
+        yield
+      ensure
+        trap(:INT, prev_handler)
+      end
+    end
+
+    def after_fork_parent
+      parent_pid = Process.pid
+
+      at_exit{
+        SESSION.intercept_trap_sigint_end
+        trap(:SIGINT, :IGNORE)
+
+        if Process.pid == parent_pid
+          # only check child process from its parent
+          begin
+            # wait for all child processes to keep terminal
+            Process.waitpid
+          rescue Errno::ESRCH, Errno::ECHILD
+          end
+        end
+      }
+    end
+  end
+end
+

data/lib/debug/open.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+#
+# Open the door for the debugger to connect.
+# Users can connect to debuggee program with "rdbg --attach" option.
+#
+# If RUBY_DEBUG_PORT envval is provided (digits), open TCP/IP port.
+# Otherwise, UNIX domain socket is used.
+#
+
+require_relative 'session'
+return unless defined?(DEBUGGER__)
+
+DEBUGGER__.open

data/lib/debug/open_nonstop.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+#
+# Open the door for the debugger to connect.
+# Unlike debug/open, it does not stop at the beginning of the program.
+# Users can connect to debuggee program with "rdbg --attach" option or
+# VSCode attach type.
+#
+# If RUBY_DEBUG_PORT envval is provided (digits), open TCP/IP port.
+# Otherwise, UNIX domain socket is used.
+#
+
+require_relative 'session'
+return unless defined?(DEBUGGER__)
+
+DEBUGGER__.open(nonstop: true)

data/lib/debug/prelude.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+return if ENV['RUBY_DEBUG_ENABLE'] == '0'
+return if defined?(::DEBUGGER__::Session)
+
+# Put the following line in your login script (e.g. ~/.bash_profile) with modified path:
+#
+#   export RUBYOPT="-r /path/to/debug/prelude ${RUBYOPT}"
+#
+module Kernel
+  def debugger(*a, up_level: 0, **kw)
+    begin
+      require_relative 'version'
+      cur_version = ::DEBUGGER__::VERSION
+      require_relative 'frame_info'
+
+      if !defined?(::DEBUGGER__::SO_VERSION) || ::DEBUGGER__::VERSION != ::DEBUGGER__::SO_VERSION
+        ::Object.send(:remove_const, :DEBUGGER__)
+        raise LoadError
+      end
+      require_relative 'session'
+      up_level += 1
+    rescue LoadError
+      $LOADED_FEATURES.delete_if{|e|
+        e.start_with?(__dir__) || e.end_with?('debug/debug.so')
+      }
+      require 'debug/session'
+      require 'debug/version'
+      ::DEBUGGER__.info "Can not activate debug #{cur_version} specified by debug/prelude.rb. Activate debug #{DEBUGGER__::VERSION} instead."
+      up_level += 1
+    end
+
+    ::DEBUGGER__::start no_sigint_hook: true, nonstop: true
+
+    begin
+      debugger(*a, up_level: up_level, **kw)
+      self
+    rescue ArgumentError # for 1.2.4 and earlier
+      debugger(*a, **kw)
+      self
+    end
+  end
+
+  alias bb debugger if ENV['RUBY_DEBUG_BB']
+end
+
+class Binding
+  alias break debugger
+  alias b debugger
+end