byebug 3.5.1 → 4.0.0

data/lib/byebug/processors/command_processor.rb

@@ -1,105 +1,55 @@
+require 'byebug/states/regular_state'
+
 module Byebug
   #
   # Processes commands in regular mode
   #
   class CommandProcessor < Processor
-    attr_reader :display
+    attr_reader :display, :state
 
     def initialize(interface = LocalInterface.new)
       super(interface)
 
       @display = []
-      @mutex = Mutex.new
-      @last_cmd         = nil   # To allow empty (just <RET>) commands
-      @last_file        = nil   # Filename the last time we stopped
-      @last_line        = nil   # Line number the last time we stopped
+      @last_cmd = nil # To allow empty (just <RET>) commands
       @context_was_dead = false # Assume we haven't started.
     end
 
     def interface=(interface)
-      @mutex.synchronize do
-        @interface.close if @interface
-        @interface = interface
-      end
-    end
-
-    require 'pathname'  # For cleanpath
-
-    #
-    # Regularize file name.
-    #
-    # This is also used as a common funnel place if basename is desired or if we
-    # are working remotely and want to change the basename. Or we are eliding
-    # filenames.
-    def self.canonic_file(filename)
-      return filename if ['(irb)', '-e'].include?(filename)
-
-      # For now we want resolved filenames
-      if Setting[:basename]
-        File.basename(filename)
-      else
-        Pathname.new(filename).cleanpath.to_s
-      end
+      @interface.close if @interface
+      @interface = interface
     end
 
-    def self.protect(mname)
-      alias_method "__#{mname}", mname
-      module_eval <<-END, __FILE__, __LINE__ + 1
-        def #{mname}(*args)
-          @mutex.synchronize do
-            return unless @interface
-            __#{mname}(*args)
-          end
-        rescue IOError, SystemCallError
-          @interface.close
-        rescue SignalException
-          raise
-        rescue
-          without_exceptions do
-            puts "INTERNAL ERROR!!! #\{$!\}"
-            puts $!.backtrace.map{|l| "\t#\{l\}"}.join("\n")
-          end
-        end
-      END
-    end
+    include FileFunctions
 
     def at_breakpoint(_context, breakpoint)
       n = Byebug.breakpoints.index(breakpoint) + 1
-      file = self.class.canonic_file(breakpoint.source)
+      file = normalize(breakpoint.source)
       line = breakpoint.pos
+
       puts "Stopped by breakpoint #{n} at #{file}:#{line}"
     end
-    protect :at_breakpoint
 
     def at_catchpoint(context, excpt)
-      file = self.class.canonic_file(context.frame_file(0))
+      file = normalize(context.frame_file(0))
       line = context.frame_line(0)
+
       puts "Catchpoint at #{file}:#{line}: `#{excpt}' (#{excpt.class})"
     end
-    protect :at_catchpoint
-
-    include ParseFunctions
 
     def at_tracing(context, file, line)
-      if file != @last_file || line != @last_line || Setting[:tracing_plus]
-        path = self.class.canonic_file(file)
-        @last_file, @last_line = file, line
-        puts "Tracing: #{path}:#{line} #{get_line(file, line)}"
-      end
+      puts "Tracing: #{normalize(file)}:#{line} #{get_line(file, line)}"
+
       always_run(context, file, line, 2)
     end
-    protect :at_tracing
 
     def at_line(context, file, line)
-      Byebug.source_reload if Setting[:autoreload]
       process_commands(context, file, line)
     end
-    protect :at_line
 
     def at_return(context, file, line)
       process_commands(context, file, line)
     end
-    protect :at_return
 
     private
 
@@ -107,51 +57,26 @@ module Byebug
     # Prompt shown before reading a command.
     #
     def prompt(context)
-      "(byebug#{context.dead?  ? ':post-mortem' : ''}) "
+      "(byebug#{context.dead? ? ':post-mortem' : ''}) "
     end
 
     #
     # Run commands everytime.
     #
-    # For example display commands or possibly the list or irb in an
-    # "autolist" or "autoirb".
+    # For example display commands or possibly the list or irb in an "autolist"
+    # or "autoirb".
     #
     # @return List of commands acceptable to run bound to the current state
     #
     def always_run(context, file, line, run_level)
-      cmds = Command.commands
-
-      state = State.new(cmds, context, @display, file, @interface, line)
+      @state = RegularState.new(context, @display, file, @interface, line)
 
       # Change default when in irb or code included in command line
       Setting[:autolist] = false if ['(irb)', '-e'].include?(file)
 
       # Bind commands to the current state.
-      commands = cmds.map do |cmd_class|
-        cmd = cmd_class.new(state)
-        cmd.execute if cmd.class.always_run >= run_level
-        cmd
-      end
-
-      [state, commands]
-    end
-
-    #
-    # Splits a command line of the form "cmd1 ; cmd2 ; ... ; cmdN" into an
-    # array of commands: [cmd1, cmd2, ..., cmdN]
-    #
-    def split_commands(cmd_line)
-      cmd_line.split(/;/).each_with_object([]) do |v, m|
-        if m.empty?
-          m << v
-        else
-          if m.last[-1] == '\\'
-            m.last[-1, 1] = ''
-            m.last << ';' << v
-          else
-            m << v
-          end
-        end
+      Command.commands.each do |cmd|
+        cmd.new(state).execute if cmd.always_run >= run_level
       end
     end
 
@@ -159,55 +84,55 @@ module Byebug
     # Handle byebug commands.
     #
     def process_commands(context, file, line)
-      state, commands = preloop(context, file, line)
+      always_run(context, file, line, 1)
+
+      puts 'The program finished.' if program_just_finished?(context)
+      puts(state.location) if Setting[:autolist] == 0
 
-      repl(state, commands, context)
+      @interface.autorestore
 
-      postloop
+      repl(context)
+    ensure
+      @interface.autosave
     end
 
     #
     # Main byebug's REPL
     #
-    def repl(state, commands, context)
+    def repl(context)
       until state.proceed?
-        input = if @interface.command_queue.empty?
-                  @interface.read_command(prompt(context))
-                else
-                  @interface.command_queue.shift
-                end
-        return unless input
-
-        if input == ''
-          next unless @last_cmd
-          input = @last_cmd
-        else
-          @last_cmd = input
-        end
-
-        split_commands(input).each do |cmd|
-          one_cmd(commands, context, cmd)
-        end
+        cmd = @interface.read_command(prompt(context))
+        return unless cmd
+
+        next if cmd == '' && @last_cmd.nil?
+
+        cmd.empty? ? cmd = @last_cmd : @last_cmd = cmd
+
+        one_cmd(context, cmd)
       end
     end
 
     #
     # Autoevals a single command
     #
-    def one_unknown_cmd(commands, input)
+    def one_unknown_cmd(input)
       unless Setting[:autoeval]
         return errmsg("Unknown command: \"#{input}\". Try \"help\"")
       end
 
-      commands.find { |c| c.is_a?(EvalCommand) }.execute
+      eval_cmd = EvalCommand.new(state)
+      eval_cmd.match(input)
+      eval_cmd.execute
     end
 
+    #
     #
     # Executes a single byebug command
     #
-    def one_cmd(commands, context, input)
-      cmd = commands.find { |c| c.match(input) }
-      return one_unknown_cmd(commands, input) unless cmd
+    def one_cmd(context, input)
+      cmd = match_cmd(input)
+
+      return one_unknown_cmd(input) unless cmd
 
       if context.dead? && !cmd.class.allow_in_post_mortem
         return errmsg('Command unavailable in post mortem mode.')
@@ -217,65 +142,25 @@ module Byebug
     end
 
     #
-    # Tasks to do before processor loop.
+    # Finds a matches the command matching the input
     #
-    def preloop(context, file, line)
-      state, commands = always_run(context, file, line, 1)
-
-      if Setting[:testing]
-        Thread.current.thread_variable_set('state', state)
-      else
-        Thread.current.thread_variable_set('state', nil)
+    def match_cmd(input)
+      Command.commands.each do |c|
+        cmd = c.new(state)
+        return cmd if cmd.match(input)
       end
 
-      @context_was_dead = true if context.dead? && !@context_was_dead
-      if @context_was_dead
-        puts 'The program finished.'
-        @context_was_dead = false
-      end
-
-      puts(state.location) if Setting[:autolist] == 0
-
-      @interface.history.restore if Setting[:autosave]
-
-      [state, commands]
+      nil
     end
 
     #
-    # Tasks to do after processor loop.
+    # Returns true first time control is given to the user after program
+    # termination.
     #
-    def postloop
-      Setting[:autosave] ? @interface.history.save : @interface.history.clear
-    end
-
-    class State
-      attr_accessor :commands, :context, :display, :file, :frame_pos,
-                    :interface, :line, :prev_line
-
-      def initialize(commands, context, display, file, interface, line)
-        @commands, @context, @display = commands, context, display
-        @file, @frame_pos, @interface = file, 0, interface
-        @line, @prev_line, @proceed = line, nil, false
-      end
-
-      extend Forwardable
-      def_delegators :@interface, :errmsg, :puts, :confirm
-
-      def proceed?
-        @proceed
-      end
-
-      def proceed
-        @proceed = true
-      end
-
-      def location
-        path = self.class.canonic_file(@file)
-        loc = "#{path} @ #{@line}\n"
-        loc += "#{get_line(@file, @line)}\n" unless
-          ['(irb)', '-e'].include? @file
-        loc
-      end
+    def program_just_finished?(context)
+      result = context.dead? && !@context_was_dead
+      @context_was_dead = false if result == true
+      result
     end
   end
 end

data/lib/byebug/processors/control_command_processor.rb

@@ -1,41 +1,41 @@
+require 'byebug/states/control_state'
+
 module Byebug
   #
   # Processes commands in 'control' mode, when there's no program running
   #
   class ControlCommandProcessor < Processor
+    attr_reader :state
+
     def initialize(interface = LocalInterface.new)
       super(interface)
-      @context_was_dead = false # Assume we haven't started.
     end
 
-    def process_commands(verbose = false)
-      control_cmds = Command.commands.select do |cmd|
-        cmd.allow_in_control
-      end
-      state = State.new(@interface, control_cmds)
-      commands = control_cmds.map { |cmd| cmd.new(state) }
+    def commands
+      Command.commands.select(&:allow_in_control).map { |cmd| cmd.new(state) }
+    end
 
-      if @context_was_dead
-        puts 'The program finished.'
-        @context_was_dead = false
-      end
+    def process_commands
+      @state = ControlState.new(interface)
 
       while (input = @interface.read_command(prompt(nil)))
-        puts("+#{input}") if verbose
-
         cmd = commands.find { |c| c.match(input) }
-        return errmsg('Unknown command') unless cmd
+        unless cmd
+          errmsg('Unknown command')
+          next
+        end
 
         cmd.execute
       end
+
+      @interface.close
     rescue IOError, SystemCallError
+      @interface.close
     rescue
       without_exceptions do
         puts "INTERNAL ERROR!!! #{$ERROR_INFO}"
         puts $ERROR_INFO.backtrace.map { |l| "\t#{l}" }.join("\n")
       end
-    ensure
-      @interface.close
     end
 
     #
@@ -44,32 +44,5 @@ module Byebug
     def prompt(_context)
       '(byebug:ctrl) '
     end
-
-    class State
-      attr_reader :commands, :interface
-
-      def initialize(interface, commands)
-        @interface = interface
-        @commands = commands
-      end
-
-      def proceed
-      end
-
-      extend Forwardable
-      def_delegators :@interface, :errmsg, :puts
-
-      def confirm(*_args)
-        'y'
-      end
-
-      def context
-        nil
-      end
-
-      def file
-        errmsg 'No filename given.'
-      end
-    end
   end
 end

data/lib/byebug/remote.rb

@@ -25,7 +25,7 @@ module Byebug
     def start_server(host = nil, port = PORT)
       return if @thread
 
-      self.interface = nil
+      handler.interface = nil
       start
 
       start_control(host, port == 0 ? 0 : port + 1)
@@ -39,7 +39,7 @@ module Byebug
       self.actual_port = server.addr[1]
       @thread = DebugThread.new do
         while (session = server.accept)
-          self.interface = RemoteInterface.new(session)
+          handler.interface = RemoteInterface.new(session)
           mutex.synchronize { proceed.signal } if wait_connection
         end
       end
@@ -53,8 +53,8 @@ module Byebug
       @actual_control_port = server.addr[1]
       @control_thread = DebugThread.new do
         while (session = server.accept)
-          interface = RemoteInterface.new(session)
-          ControlCommandProcessor.new(interface).process_commands
+          handler.interface = RemoteInterface.new(session)
+          ControlCommandProcessor.new(handler.interface).process_commands
         end
       end
       @actual_control_port
@@ -64,7 +64,8 @@ module Byebug
     # Connects to the remote byebug
     #
     def start_client(host = 'localhost', port = PORT)
-      interface = LocalInterface.new
+      handler.interface = LocalInterface.new
+      puts 'Connecting to byebug server...'
       socket = TCPSocket.new(host, port)
       puts 'Connected.'
 
@@ -72,11 +73,11 @@ module Byebug
         while (line = socket.gets)
           case line
           when /^PROMPT (.*)$/
-            input = interface.read_command(Regexp.last_match[1])
+            input = handler.interface.read_command(Regexp.last_match[1])
             throw :exit unless input
             socket.puts input
           when /^CONFIRM (.*)$/
-            input = interface.confirm(Regexp.last_match[1])
+            input = handler.interface.confirm(Regexp.last_match[1])
             throw :exit unless input
             socket.puts input
           else
@@ -86,5 +87,10 @@ module Byebug
       end
       socket.close
     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
   end
 end