rename signals that get emitted from the connection object

Author: robertbasic

pugdebug/debugger.py

@@ -74,48 +74,48 @@ def connect_connection_signals(self, connection):
         """
 
         # Stop/detach signals
-        connection.server_stopped_signal.connect(
-            self.handle_server_stopped
+        connection.stopped_signal.connect(
+            self.handle_stopped
         )
-        connection.server_detached_signal.connect(
-            self.handle_server_stopped
+        connection.detached_signal.connect(
+            self.handle_stopped
         )
 
         # Step command signals
-        connection.server_stepped_signal.connect(
-            self.handle_server_stepped
+        connection.stepped_signal.connect(
+            self.handle_stepped
         )
 
         # Variables signals
-        connection.server_got_variables_signal.connect(
-            self.handle_server_got_variables
+        connection.got_variables_signal.connect(
+            self.handle_got_variables
         )
 
         # Stacktraces signals
-        connection.server_got_stacktraces_signal.connect(
-            self.handle_server_got_stacktraces
+        connection.got_stacktraces_signal.connect(
+            self.handle_got_stacktraces
         )
 
         # Breakpoints signals
-        connection.server_set_init_breakpoints_signal.connect(
-            self.handle_server_set_breakpoint
+        connection.set_init_breakpoints_signal.connect(
+            self.handle_set_breakpoint
         )
-        connection.server_set_breakpoint_signal.connect(
-            self.handle_server_set_breakpoint
+        connection.set_breakpoint_signal.connect(
+            self.handle_set_breakpoint
         )
-        connection.server_removed_breakpoint_signal.connect(
-            self.handle_server_removed_breakpoint
+        connection.removed_breakpoint_signal.connect(
+            self.handle_removed_breakpoint
         )
-        connection.server_listed_breakpoints_signal.connect(
-            self.handle_server_listed_breakpoints
+        connection.listed_breakpoints_signal.connect(
+            self.handle_listed_breakpoints
         )
 
         # Expressions signals
-        connection.server_expression_evaluated_signal.connect(
-            self.handle_server_expression_evaluated
+        connection.expression_evaluated_signal.connect(
+            self.handle_expression_evaluated
         )
-        connection.server_expressions_evaluated_signal.connect(
-            self.handle_server_expressions_evaluated
+        connection.expressions_evaluated_signal.connect(
+            self.handle_expressions_evaluated
         )
 
     def cleanup(self):
@@ -202,7 +202,7 @@ def detach_debug(self):
         if self.is_connected():
             self.current_connection.detach()
 
-    def handle_server_stopped(self):
+    def handle_stopped(self):
         """Handle when a server stopped signal is received
 
         If there are pending connections, start a new one.
@@ -228,7 +228,7 @@ def step_into(self):
     def step_out(self):
         self.current_connection.step_out()
 
-    def handle_server_stepped(self, step_result):
+    def handle_stepped(self, step_result):
         """Handle when server executes a step command
 
         Save the result of the step command and emit
@@ -240,14 +240,14 @@ def handle_server_stepped(self, step_result):
     def post_step_command(self, post_step_data):
         self.current_connection.post_step_command(post_step_data)
 
-    def handle_server_got_variables(self, variables):
+    def handle_got_variables(self, variables):
         """Handle when server recieves all variables
 
         Emit a signal with all variables received.
         """
         self.got_all_variables_signal.emit(variables)
 
-    def handle_server_got_stacktraces(self, stacktraces):
+    def handle_got_stacktraces(self, stacktraces):
         """Handle when server receives stacktraces
 
         Emit a signal with the stacktraces.
@@ -260,20 +260,20 @@ def set_init_breakpoints(self, breakpoints):
     def set_breakpoint(self, breakpoint):
         self.current_connection.set_breakpoint(breakpoint)
 
-    def handle_server_set_breakpoint(self, successful):
+    def handle_set_breakpoint(self, successful):
         if successful:
             self.list_breakpoints()
 
     def remove_breakpoint(self, breakpoint_id):
         self.current_connection.remove_breakpoint(breakpoint_id)
 
-    def handle_server_removed_breakpoint(self, breakpoint_id):
+    def handle_removed_breakpoint(self, breakpoint_id):
         self.breakpoint_removed_signal.emit(breakpoint_id)
 
     def list_breakpoints(self):
         self.current_connection.list_breakpoints()
 
-    def handle_server_listed_breakpoints(self, breakpoints):
+    def handle_listed_breakpoints(self, breakpoints):
         self.breakpoints_listed_signal.emit(breakpoints)
 
     def get_index_file(self):
@@ -290,11 +290,11 @@ def evaluate_expressions(self, expressions):
         """Evaluates a list of expressions"""
         self.current_connection.evaluate_expressions(expressions)
 
-    def handle_server_expression_evaluated(self, index, result):
+    def handle_expression_evaluated(self, index, result):
         """Handle when server evaluates an expression"""
         self.expression_evaluated_signal.emit(index, result)
 
-    def handle_server_expressions_evaluated(self, results):
+    def handle_expressions_evaluated(self, results):
         """Handle when server evaluates a list of expressions"""
         self.expressions_evaluated_signal.emit(results)
 

pugdebug/server.py

@@ -107,17 +107,17 @@ class PugdebugServerConnection(QThread):
 
     xdebug_encoding = 'iso-8859-1'
 
-    server_stopped_signal = pyqtSignal()
-    server_detached_signal = pyqtSignal()
-    server_stepped_signal = pyqtSignal(dict)
-    server_got_variables_signal = pyqtSignal(object)
-    server_got_stacktraces_signal = pyqtSignal(object)
-    server_set_init_breakpoints_signal = pyqtSignal(bool)
-    server_set_breakpoint_signal = pyqtSignal(bool)
-    server_removed_breakpoint_signal = pyqtSignal(object)
-    server_listed_breakpoints_signal = pyqtSignal(list)
-    server_expression_evaluated_signal = pyqtSignal(int, dict)
-    server_expressions_evaluated_signal = pyqtSignal(list)
+    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)
+    expression_evaluated_signal = pyqtSignal(int, dict)
+    expressions_evaluated_signal = pyqtSignal(list)
 
     def __init__(self, socket):
         super(PugdebugServerConnection, self).__init__()
@@ -175,46 +175,46 @@ def run(self):
 
         if action == 'stop':
             response = self.__stop()
-            self.server_stopped_signal.emit()
+            self.stopped_signal.emit()
         elif action == 'detach':
             response = self.__detach()
-            self.server_detached_signal.emit()
+            self.detached_signal.emit()
         elif action == 'step_run':
             response = self.__step_run()
-            self.server_stepped_signal.emit(response)
+            self.stepped_signal.emit(response)
         elif action == 'step_into':
             response = self.__step_into()
-            self.server_stepped_signal.emit(response)
+            self.stepped_signal.emit(response)
         elif action == 'step_over':
             response = self.__step_over()
-            self.server_stepped_signal.emit(response)
+            self.stepped_signal.emit(response)
         elif action == 'step_out':
             response = self.__step_out()
-            self.server_stepped_signal.emit(response)
+            self.stepped_signal.emit(response)
         elif action == 'post_step':
             response = self.__post_step(data)
 
-            self.server_got_variables_signal.emit(response['variables'])
-            self.server_got_stacktraces_signal.emit(response['stacktraces'])
-            self.server_expressions_evaluated_signal.emit(
+            self.got_variables_signal.emit(response['variables'])
+            self.got_stacktraces_signal.emit(response['stacktraces'])
+            self.expressions_evaluated_signal.emit(
                 response['expressions']
             )
         elif action == 'init_breakpoint_set':
             response = self.__set_init_breakpoints(data)
-            self.server_set_init_breakpoints_signal.emit(response)
+            self.set_init_breakpoints_signal.emit(response)
         elif action == 'breakpoint_set':
             response = self.__set_breakpoint(data)
-            self.server_set_breakpoint_signal.emit(response)
+            self.set_breakpoint_signal.emit(response)
         elif action == 'breakpoint_remove':
             response = self.__remove_breakpoint(data)
-            self.server_removed_breakpoint_signal.emit(response)
+            self.removed_breakpoint_signal.emit(response)
         elif action == 'breakpoint_list':
             response = self.__list_breakpoints()
-            self.server_listed_breakpoints_signal.emit(response)
+            self.listed_breakpoints_signal.emit(response)
         elif action == 'evaluate_expression':
             (index, expression) = data
             response = self.__evaluate_expression(expression)
-            self.server_expression_evaluated_signal.emit(index, response)
+            self.expression_evaluated_signal.emit(index, response)
 
         self.mutex.unlock()