module Byebug

def self.settings


exception
:stack_on_error - shows full stack trace if eval command results in an
:fullpath - displays full paths when showing frame stack
:forcestep - stepping command always move to the new line
:frame_class_names - displays method's class name when showing frame stack
code
:autoreload - makes 'list' command always display up-to-date source
:autolist - automatically calls 'list' command on breakpoint
:autoirb - automatically calls 'irb' command on breakpoint
recognized as a byebug command
:autoeval - evaluates input in the current binding if it's not

byebug settings. These settings are available:
Use Byebug.settings[] and Byebug.settings[]= methods to query and set
Returns ths settings object.
# 
def self.settings
  Command.settings
end

def add_breakpoint(file, line, expr=nil)

Parameters:
  • expr (String) --
  • line (Fixnum) --
  • file (String) -- 
def add_breakpoint(file, line, expr=nil)
  breakpoint = Breakpoint.new(file, line, expr)
  breakpoints << breakpoint
  breakpoint
end

def handle_post_mortem(exp) 

def handle_post_mortem(exp)
  return if !exp
  Byebug.last_exception = exp
  return if !exp.__bb_context || !exp.__bb_context.calced_stack_size
  orig_tracing = Byebug.tracing?
  Byebug.tracing = false
  handler.at_line(exp.__bb_context, exp.__bb_file, exp.__bb_line)
ensure
  Byebug.tracing = orig_tracing
end

def interface=(value) 

def interface=(value)
  handler.interface = value
end

def interrupt


Interrupts the current thread
def interrupt
  current_context.interrupt
end

def line_at(filename, line_number)


@return "\n" if there was a problem. Leaking blanks are stripped off.

Get line +line_number+ from file named +filename+.
def line_at(filename, line_number)
  source_reload
  return "\n" unless File.exist?(filename)
  line = Tracer::Single.get_line(filename, line_number)
  return "#{line.gsub(/^\s+/, '').chomp}"
end

def post_mortem


post-mortem mode.
intercepts any exception not handled by your script and enables
By calling Byebug.post_mortem method, you install an at_exit hook that

Activates the post-mortem mode.
def post_mortem
  return if self.post_mortem?
  at_exit { handle_post_mortem($!) if post_mortem? }
  self.post_mortem = true
end

def remove_breakpoint(id)

Parameters:
  • breakpoint (integer) -- number 
def remove_breakpoint(id)
  breakpoints.reject! { |b| b.id == id }
end

def run_init_script(out = handler.interface)


program you are debugging, in the directory where you invoke byebug.
file, one generic in your home directory, and another, specific to the
different from your home directory. Thus, you can have more than one init
working directory. This is only done if the current directory is
Reads and executes the commands from init file (if any) in the current

Runs normal byebug initialization scripts.
def run_init_script(out = handler.interface)
  cwd_script  = File.expand_path(File.join(".", INITFILE))
  run_script(cwd_script, out) if File.exist?(cwd_script)
  home_script = File.expand_path(File.join(ENV['HOME'].to_s, INITFILE))
  if File.exist?(home_script) and cwd_script != home_script
     run_script(home_script, out)
  end
end

def run_script(file, out = handler.interface, verbose=false)


Runs a script file
def run_script(file, out = handler.interface, verbose=false)
  interface = ScriptInterface.new(File.expand_path(file), out)
  processor = ControlCommandProcessor.new(interface)
  processor.process_commands(verbose)
end

def source_reload 

def source_reload
  Object.send(:remove_const, 'SCRIPT_LINES__') if
    Object.const_defined?('SCRIPT_LINES__')
  Object.const_set('SCRIPT_LINES__', {})
end

def start(options={}, &block)


can't be unset.
uncaught exception. Once post-mortem debugging is set, it
:post_mortem - true if you want to enter post-mortem debugging on an
the (first) call.
saved, you should make sure it hasn't been changed before
is set to true the values will get set. Since ARGV is
make a byebug restart possible. Only the first time :init
:init - true if you want to save ARGV and some other variables to
+options+ is a hash used to set various debugging options.

many times as you called Byebug.start method.
Note that if you want to stop byebug, you must call Byebug.stop as

Byebug.start's have no effect and you can't use this inside byebug itself.
Also, byebug only allows one invocation of byebug at a time; nested

Byebug.start { byebug; foo } # Stop inside of foo

will probably want to have a call to Byebug.byebug. For example:
executed it stops byebug with Byebug.stop method. Inside the block you
If a block is given, it starts byebug and yields block. After the block is

already started.
If it's called without a block, it returns +true+ unless byebug was

Byebug.start(options) { ... } -> obj
Byebug.start(options) -> bool
def start(options={}, &block)
  options = Byebug::DEFAULT_START_SETTINGS.merge(options)
  if options[:init]
    Byebug.const_set('ARGV', ARGV.clone) unless defined? Byebug::ARGV
    Byebug.const_set('PROG_SCRIPT', $0) unless defined? Byebug::PROG_SCRIPT
    Byebug.const_set('INITIAL_DIR', Dir.pwd) unless defined? Byebug::INITIAL_DIR
  end
  Byebug.tracing = options[:tracing] unless options[:tracing].nil?
  retval = Byebug._start(&block)
  post_mortem if options[:post_mortem]
  return retval
end

def start_client(host = 'localhost', port = PORT)


Connects to the remote byebug
def start_client(host = 'localhost', port = PORT)
  interface = Byebug::LocalInterface.new
  socket = TCPSocket.new(host, port)
  puts "Connected."
  catch(:exit) do
    while (line = socket.gets)
      case line
      when /^PROMPT (.*)$/
        input = interface.read_command($1)
        throw :exit unless input
        socket.puts input
      when /^CONFIRM (.*)$/
        input = interface.confirm($1)
        throw :exit unless input
        socket.puts input
      else
        print line
      end
    end
  end
  socket.close
end

def start_control(host = nil, ctrl_port = PORT + 1) 

def start_control(host = nil, ctrl_port = PORT + 1)
   return @actual_control_port if @control_thread
   server = TCPServer.new(host, ctrl_port)
   @actual_control_port = server.addr[1]
   @control_thread = Thread.new do
     while (session = server.accept)
       interface = RemoteInterface.new(session)
       ControlCommandProcessor.new(interface).process_commands
     end
   end
   @actual_control_port
end

def start_server(host = nil, port = PORT)


Starts a remote byebug
def start_server(host = nil, port = PORT)
  return if @thread
  self.interface = nil
  start
  start_control(host, port == 0 ? 0 : port + 1)
  yield if block_given?
  mutex = Mutex.new
  proceed = ConditionVariable.new
  server = TCPServer.new(host, port)
  self.actual_port = server.addr[1]
  @thread = DebugThread.new do
    while (session = server.accept)
      self.interface = RemoteInterface.new(session)
      if wait_connection
        mutex.synchronize do
          proceed.signal
        end
      end
    end
  end
  if wait_connection
    mutex.synchronize do
      proceed.wait(mutex)
    end
  end
end