Merge pull request #121 from robertbasic/feature/do-not-open-index-file-if-not-needed

Feature/do not open index file if not needed. Resolves #116

Author: robertbasic

pugdebug/debugger.py

@@ -29,11 +29,11 @@ class PugdebugDebugger(QObject):
     current_line = 0
 
     debugging_started_signal = pyqtSignal()
+    debugging_post_start_signal = pyqtSignal()
     debugging_stopped_signal = pyqtSignal()
     step_command_signal = pyqtSignal()
     got_all_variables_signal = pyqtSignal(object)
     got_stacktraces_signal = pyqtSignal(object)
-    init_breakpoints_set = pyqtSignal()
     breakpoint_removed_signal = pyqtSignal(int)
     breakpoints_listed_signal = pyqtSignal(list)
     expression_evaluated_signal = pyqtSignal(int, dict)
@@ -78,6 +78,9 @@ def connect_connection_signals(self, connection):
         """
 
         # Stop/detach signals
+        connection.post_start_signal.connect(
+            self.handle_post_start
+        )
         connection.stopped_signal.connect(
             self.handle_stopped
         )
@@ -101,9 +104,6 @@ def connect_connection_signals(self, connection):
         )
 
         # Breakpoints signals
-        connection.set_init_breakpoints_signal.connect(
-            self.handle_set_init_breakpoint
-        )
         connection.set_breakpoint_signal.connect(
             self.handle_set_breakpoint
         )
@@ -194,6 +194,12 @@ def start_new_connection(self):
 
         self.debugging_started_signal.emit()
 
+    def post_start_command(self, post_start_data):
+        self.current_connection.post_start_command(post_start_data)
+
+    def handle_post_start(self):
+        self.debugging_post_start_signal.emit()
+
     def handle_server_stopped(self):
         if not self.is_connected():
             self.cleanup()
@@ -268,21 +274,13 @@ def handle_got_stacktraces(self, stacktraces):
         """
         self.got_stacktraces_signal.emit(stacktraces)
 
-    def set_init_breakpoints(self, breakpoints):
-        self.current_connection.set_init_breakpoints(breakpoints)
-
     def set_breakpoint(self, breakpoint):
         self.current_connection.set_breakpoint(breakpoint)
 
     def handle_set_breakpoint(self, successful):
         if successful:
             self.list_breakpoints()
 
-    def handle_set_init_breakpoint(self, successful):
-        if successful:
-            self.list_breakpoints()
-            self.init_breakpoints_set.emit()
-
     def remove_breakpoint(self, breakpoint_id):
         self.current_connection.remove_breakpoint(breakpoint_id)
 

pugdebug/pugdebug.py

@@ -169,6 +169,9 @@ def connect_debugger_signals(self):
         self.debugger.debugging_started_signal.connect(
             self.handle_debugging_started
         )
+        self.debugger.debugging_post_start_signal.connect(
+            self.handle_debugging_post_start
+        )
         self.debugger.debugging_stopped_signal.connect(
             self.handle_debugging_stopped
         )
@@ -187,9 +190,6 @@ def connect_debugger_signals(self):
         )
 
         # Breakpoints signals
-        self.debugger.init_breakpoints_set.connect(
-            self.handle_init_breakpoints_set
-        )
         self.debugger.breakpoint_removed_signal.connect(
             self.handle_breakpoint_removed
         )
@@ -454,9 +454,21 @@ def handle_debugging_started(self):
 
         self.main_window.toggle_actions(True)
 
-        self.set_init_breakpoints(self.init_breakpoints)
+        post_start_data = {
+            'init_breakpoints': self.init_breakpoints
+        }
+        self.debugger.post_start_command(post_start_data)
+
+    def handle_debugging_post_start(self):
+        """Handle post start debugging
 
-        self.open_document(self.debugger.get_index_file())
+        If the code should not break at first line, run the debugger.
+        """
+        break_at_first_line = int(get_setting('debugger/break_at_first_line'))
+        if break_at_first_line == 0:
+            self.run_debug()
+        else:
+            self.step_into()
 
     def stop_debug(self):
         """Stop a debugging session
@@ -572,17 +584,6 @@ def handle_got_stacktraces(self, stacktraces):
         """
         self.stacktrace_viewer.set_stacktraces(stacktraces)
 
-    def set_init_breakpoints(self, breakpoints):
-        """Set initial breakpoints
-
-        Initial breakpoints are the breakpoints that are set before a debugging
-        session has been started.
-
-        Set initial breakpoints on the debugger. This should be called only
-        right after a new debugging session has been started.
-        """
-        self.debugger.set_init_breakpoints(breakpoints)
-
     def set_breakpoint(self, breakpoint):
         """Set a breakpoint
 
@@ -667,17 +668,6 @@ def remove_stale_breakpoints(self, path):
 
         self.breakpoint_viewer.set_breakpoints(breakpoints)
 
-    def handle_init_breakpoints_set(self):
-        """Handle when init breakpoints get set
-
-        If the code should not break at first line, run the debugger.
-        """
-        break_at_first_line = int(get_setting('debugger/break_at_first_line'))
-        if break_at_first_line == 0:
-            self.run_debug()
-        else:
-            self.step_into()
-
     def handle_breakpoint_removed(self, breakpoint_id):
         """Handle when a breakpoint gets removed
 

pugdebug/server.py

@@ -107,12 +107,12 @@ class PugdebugServerConnection(QThread):
 
     xdebug_encoding = 'iso-8859-1'
 
+    post_start_signal = pyqtSignal()
     stopped_signal = pyqtSignal()
     detached_signal = pyqtSignal()
     stepped_signal = pyqtSignal(dict)
     got_variables_signal = pyqtSignal(object)
     got_stacktraces_signal = pyqtSignal(object)
-    set_init_breakpoints_signal = pyqtSignal(bool)
     set_breakpoint_signal = pyqtSignal(bool)
     removed_breakpoint_signal = pyqtSignal(object)
     listed_breakpoints_signal = pyqtSignal(list)
@@ -182,7 +182,14 @@ def run(self):
         action = self.action
 
         try:
-            if action == 'stop':
+            if action == 'post_start':
+                response = self.__post_start(data)
+
+                self.listed_breakpoints_signal.emit(
+                    response['breakpoints']
+                )
+                self.post_start_signal.emit()
+            elif action == 'stop':
                 response = self.__stop()
                 self.stopped_signal.emit()
             elif action == 'detach':
@@ -208,9 +215,6 @@ def run(self):
                 self.expressions_evaluated_signal.emit(
                     response['expressions']
                 )
-            elif action == 'init_breakpoint_set':
-                response = self.__set_init_breakpoints(data)
-                self.set_init_breakpoints_signal.emit(response)
             elif action == 'breakpoint_set':
                 response = self.__set_breakpoint(data)
                 self.set_breakpoint_signal.emit(response)
@@ -234,6 +238,11 @@ def disconnect(self):
         if self.socket is not None:
             self.socket.close()
 
+    def post_start_command(self, post_start_data):
+        self.data = post_start_data
+        self.action = 'post_start'
+        self.start()
+
     def stop(self):
         self.action = 'stop'
         self.start()
@@ -263,11 +272,6 @@ def post_step_command(self, post_step_data):
         self.action = 'post_step'
         self.start()
 
-    def set_init_breakpoints(self, breakpoints):
-        self.action = 'init_breakpoint_set'
-        self.data = breakpoints
-        self.start()
-
     def set_breakpoint(self, breakpoint):
         self.action = 'breakpoint_set'
         self.data = breakpoint
@@ -287,6 +291,16 @@ def evaluate_expression(self, index, expression):
         self.data = (index, expression)
         self.start()
 
+    def __post_start(self, data):
+        post_start_response = {
+            'init_breakpoints': self.__set_init_breakpoints(
+                data['init_breakpoints']
+            ),
+            'breakpoints': self.__list_breakpoints()
+        }
+
+        return post_start_response
+
     def __stop(self):
         command = 'stop -i %d' % self.__get_transaction_id()
         self.__send_command(command)