byebug 11.0.1

data/lib/byebug/processors/control_processor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "byebug/processors/command_processor"
+
+module Byebug
+  #
+  # Processes commands when there's not program running
+  #
+  class ControlProcessor < CommandProcessor
+    #
+    # Available commands
+    #
+    def commands
+      super.select(&:allow_in_control)
+    end
+
+    #
+    # Prompt shown before reading a command.
+    #
+    def prompt
+      "(byebug:ctrl) "
+    end
+  end
+end

data/lib/byebug/processors/post_mortem_processor.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "byebug/processors/command_processor"
+
+module Byebug
+  #
+  # Processes commands in post_mortem mode
+  #
+  class PostMortemProcessor < CommandProcessor
+    def commands
+      super.select(&:allow_in_post_mortem)
+    end
+
+    def prompt
+      "(byebug:post_mortem) "
+    end
+  end
+end

data/lib/byebug/processors/script_processor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "byebug/processors/command_processor"
+
+module Byebug
+  #
+  # Processes commands from a file
+  #
+  class ScriptProcessor < CommandProcessor
+    #
+    # Available commands
+    #
+    def commands
+      super.select(&:allow_in_control)
+    end
+
+    def repl
+      while (input = interface.read_command(prompt))
+        safely do
+          command = command_list.match(input)
+          raise CommandNotFound.new(input) unless command
+
+          command.new(self, input).execute
+        end
+      end
+    end
+
+    def after_repl
+      super
+
+      interface.close
+    end
+
+    #
+    # Prompt shown before reading a command.
+    #
+    def prompt
+      "(byebug:ctrl) "
+    end
+
+    private
+
+    def without_exceptions
+      yield
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/byebug/remote.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "socket"
+require "byebug/processors/control_processor"
+require "byebug/remote/server"
+require "byebug/remote/client"
+
+#
+# Remote debugging functionality.
+#
+module Byebug
+  # Port number used for remote debugging
+  PORT = 8989 unless defined?(PORT)
+
+  class << self
+    # If in remote mode, wait for the remote connection
+    attr_accessor :wait_connection
+
+    # The actual port that the server is started at
+    def actual_port
+      server.actual_port
+    end
+
+    # The actual port that the control server is started at
+    def actual_control_port
+      control.actual_port
+    end
+
+    #
+    # Interrupts the current thread
+    #
+    def interrupt
+      current_context.interrupt
+    end
+
+    #
+    # Starts the remote server main thread
+    #
+    def start_server(host = nil, port = PORT)
+      start_control(host, port.zero? ? 0 : port + 1)
+
+      server.start(host, port)
+    end
+
+    #
+    # Starts the remote server control thread
+    #
+    def start_control(host = nil, port = PORT + 1)
+      control.start(host, port)
+    end
+
+    #
+    # Connects to the remote byebug
+    #
+    def start_client(host = "localhost", port = PORT)
+      client.start(host, port)
+    end
+
+    def parse_host_and_port(host_port_spec)
+      location = host_port_spec.split(":")
+      location[1] ? [location[0], location[1].to_i] : ["localhost", location[0]]
+    end
+
+    private
+
+    def client
+      @client ||= Remote::Client.new(Context.interface)
+    end
+
+    def server
+      @server ||= Remote::Server.new(wait_connection: wait_connection) do |s|
+        Context.interface = RemoteInterface.new(s)
+      end
+    end
+
+    def control
+      @control ||= Remote::Server.new(wait_connection: false) do |s|
+        context = Byebug.current_context
+        interface = RemoteInterface.new(s)
+
+        ControlProcessor.new(context, interface).process_commands
+      end
+    end
+  end
+end

data/lib/byebug/remote/client.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Byebug
+  module Remote
+    #
+    # Client for remote debugging
+    #
+    class Client
+      attr_reader :interface, :socket
+
+      def initialize(interface)
+        @interface = interface
+        @socket = nil
+      end
+
+      #
+      # Connects to the remote byebug
+      #
+      def start(host = "localhost", port = PORT)
+        connect_at(host, port)
+
+        while (line = socket.gets)
+          case line
+          when /^PROMPT (.*)$/
+            input = interface.read_command(Regexp.last_match[1])
+            break unless input
+
+            socket.puts input
+          when /^CONFIRM (.*)$/
+            input = interface.readline(Regexp.last_match[1])
+            break unless input
+
+            socket.puts input
+          else
+            interface.puts line
+          end
+        end
+
+        socket.close
+      end
+
+      def started?
+        !socket.nil?
+      end
+
+      private
+
+      def connect_at(host, port)
+        interface.puts "Connecting to byebug server at #{host}:#{port}..."
+        @socket = TCPSocket.new(host, port)
+        interface.puts "Connected."
+      end
+    end
+  end
+end

data/lib/byebug/remote/server.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Byebug
+  module Remote
+    #
+    # Server for remote debugging
+    #
+    class Server
+      attr_reader :actual_port, :wait_connection
+
+      def initialize(wait_connection:, &block)
+        @thread = nil
+        @wait_connection = wait_connection
+        @main_loop = block
+      end
+
+      #
+      # Start the remote debugging server
+      #
+      def start(host, port)
+        return if @thread
+
+        if wait_connection
+          mutex = Mutex.new
+          proceed = ConditionVariable.new
+        end
+
+        server = TCPServer.new(host, port)
+        @actual_port = server.addr[1]
+
+        yield if block_given?
+
+        @thread = DebugThread.new do
+          while (session = server.accept)
+            @main_loop.call(session)
+
+            mutex.synchronize { proceed.signal } if wait_connection
+          end
+        end
+
+        mutex.synchronize { proceed.wait(mutex) } if wait_connection
+      end
+    end
+  end
+end

data/lib/byebug/runner.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "English"
+require "byebug/core"
+require "byebug/version"
+require "byebug/helpers/bin"
+require "byebug/helpers/parse"
+require "byebug/helpers/string"
+require "byebug/option_setter"
+require "byebug/processors/control_processor"
+
+module Byebug
+  #
+  # Responsible for starting the debugger when started from the command line.
+  #
+  class Runner
+    include Helpers::BinHelper
+    include Helpers::ParseHelper
+    include Helpers::StringHelper
+
+    #
+    # Special working modes that don't actually start the debugger.
+    #
+    attr_reader :help, :version, :remote
+
+    #
+    # Signals that we should exit after the debugged program is finished.
+    #
+    attr_accessor :quit
+
+    #
+    # Signals that we should stop before program starts
+    #
+    attr_accessor :stop
+
+    #
+    # Signals that we should run rc scripts before program starts
+    #
+    attr_writer :init_script
+
+    #
+    # @param stop [Boolean] Whether the runner should stop right before
+    # starting the program.
+    #
+    # @param quit [Boolean] Whether the runner should quit right after
+    # finishing the program.
+    #
+    def initialize(stop = true, quit = true)
+      @stop = stop
+      @quit = quit
+    end
+
+    def help=(text)
+      @help ||= text
+
+      interface.puts("#{text}\n")
+    end
+
+    def version=(number)
+      @version ||= number
+
+      interface.puts prettify <<-VERSION
+        Running byebug #{number}
+      VERSION
+    end
+
+    def remote=(host_and_port)
+      @remote ||= Byebug.parse_host_and_port(host_and_port)
+
+      Byebug.start_client(*@remote)
+    end
+
+    def init_script
+      defined?(@init_script) ? @init_script : true
+    end
+
+    #
+    # Usage banner.
+    #
+    def banner
+      prettify <<-BANNER
+        byebug #{Byebug::VERSION}
+
+        Usage: byebug [options] <script.rb> -- <script.rb parameters>
+      BANNER
+    end
+
+    #
+    # Starts byebug to debug a program.
+    #
+    def run
+      Byebug.mode = :standalone
+
+      option_parser.order!($ARGV)
+      return if non_script_option? || error_in_script?
+
+      $PROGRAM_NAME = program
+
+      Byebug.run_init_script if init_script
+
+      loop do
+        debug_program
+
+        break if quit
+
+        ControlProcessor.new(nil, interface).process_commands
+      end
+    end
+
+    def interface
+      @interface ||= Context.interface
+    end
+
+    #
+    # Processes options passed from the command line.
+    #
+    def option_parser
+      @option_parser ||= OptionParser.new(banner, 25) do |opts|
+        opts.banner = banner
+
+        OptionSetter.new(self, opts).setup
+      end
+    end
+
+    def program
+      @program ||= begin
+                     candidate = which($ARGV.shift)
+
+                     if [which("ruby"), RbConfig.ruby].include?(candidate)
+                       which($ARGV.shift)
+                     else
+                       candidate
+                     end
+                   end
+    end
+
+    #
+    # An option that doesn't need a script specified was given
+    #
+    def non_script_option?
+      version || help || remote
+    end
+
+    #
+    # There is an error with the specified script
+    #
+    def error_in_script?
+      no_script? || non_existing_script? || invalid_script?
+    end
+
+    #
+    # No script to debug specified
+    #
+    def no_script?
+      return false unless $ARGV.empty?
+
+      print_error("You must specify a program to debug")
+      true
+    end
+
+    #
+    # Extracts debugged program from command line args.
+    #
+    def non_existing_script?
+      return false if program
+
+      print_error("The script doesn't exist")
+      true
+    end
+
+    #
+    # Checks the debugged script has correct syntax
+    #
+    def invalid_script?
+      return false if syntax_valid?(File.read(program))
+
+      print_error("The script has incorrect syntax")
+      true
+    end
+
+    #
+    # Debugs a script only if syntax checks okay.
+    #
+    def debug_program
+      error = Byebug.debug_load(program, stop)
+      puts "#{error}\n#{error.backtrace}" if error
+    end
+
+    #
+    # Prints an error message and a help string
+    #
+    def print_error(msg)
+      interface.errmsg(msg)
+      interface.puts(option_parser.help)
+    end
+  end
+end