eric: comparison Debugger/DebuggerInterfaceRuby.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 DebugClientCapabilities.HasInterpreter | \
 DebugClientCapabilities.HasCompleter
 ClientTypeAssociations = [".rb"]
 def getRegistryData():
 """
 Module function to get characterising data for the debugger interface.
 @return list of the following data. Client type (string), client
 capabilities (integer), client type association (list of strings)
 """
 return ["Ruby", ClientDefaultCapabilities, ClientTypeAssociations]
 class DebuggerInterfaceRuby(QObject):
 """
 Class implementing the Ruby debugger interface for the debug server.
 """
 Preferences.getDebugger("PathTranslationLocal")
 self.translate = self.__remoteTranslation
 else:
 self.translate = self.__identityTranslation
-def __identityTranslation(self, fn, remote2local = True):
+def __identityTranslation(self, fn, remote2local=True):
 """
 Private method to perform the identity path translation.
 @param fn filename to be translated (string)
 @param remote2local flag indicating the direction of translation
 (False = local to remote, True = remote to local [default])
 @return translated filename (string)
 """
 return fn
-def __remoteTranslation(self, fn, remote2local = True):
+def __remoteTranslation(self, fn, remote2local=True):
 """
 Private method to perform the path translation.
 @param fn filename to be translated (string)
 @param remote2local flag indicating the direction of translation
 if remote2local:
 return fn.replace(self.translateRemote, self.translateLocal)
 else:
 return fn.replace(self.translateLocal, self.translateRemote)
-def __startProcess(self, program, arguments, environment = None):
+def __startProcess(self, program, arguments, environment=None):
 """
 Private method to start the debugger client process.
 @param program name of the executable to start (string)
 @param arguments arguments to be passed to the program (list of string)
 def startRemote(self, port, runInConsole):
 """
 Public method to start a remote Ruby interpreter.
 @param port portnumber the debug server is listening on (integer)
 @param runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @return client process object (QProcess) and a flag to indicate
 a network connection (boolean)
 """
 interpreter = Preferences.getDebugger("RubyInterpreter")
 if interpreter == "":
 interpreter = "/usr/bin/ruby"
 debugClient = os.path.join(getConfig('ericDir'),
 "DebugClients", "Ruby", "DebugClient.rb")
 redirect = str(Preferences.getDebugger("RubyRedirect"))
 if Preferences.getDebugger("RemoteDbgEnabled"):
 self.trUtf8("Start Debugger"),
 self.trUtf8(
 """<p>The debugger backend could not be started.</p>"""))
 return process, self.__isNetworked
 process = self.__startProcess(interpreter,
 [debugClient, str(port), redirect, ipaddr],
 clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
 def startRemoteForProject(self, port, runInConsole):
 """
 Public method to start a remote Ruby interpreter for a project.
 @param port portnumber the debug server is listening on (integer)
 @param runInConsole flag indicating to start the debugger in a
 console window (boolean)
 @return pid of the client process (integer) and a flag to indicate
 a network connection (boolean)
 """
 project = e5App().getObject("Project")
 self.trUtf8("Start Debugger"),
 self.trUtf8(
 """<p>The debugger backend could not be started.</p>"""))
 return process, self.__isNetworked
 process = self.__startProcess(interpreter,
 [debugClient, str(port), redirect, ipaddr],
 clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
 @param env environment settings (dictionary)
 """
 self.__sendCommand('{0}{1}\n'.format(RequestEnv, str(env)))
-def remoteLoad(self, fn, argv, wd, traceInterpreter = False, autoContinue = True,
+def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
-autoFork = False, forkChild = False):
+autoFork=False, forkChild=False):
 """
 Public method to load a new program to debug.
 @param fn the filename to debug (string)
 @param argv the commandline arguments to pass to the program (string)
 @keyparam traceInterpreter flag indicating if the interpreter library should be
 traced as well (boolean)
 @keyparam autoContinue flag indicating, that the debugger should not stop
 at the first executable line (boolean)
 @keyparam autoFork flag indicating the automatic fork mode (boolean) (ignored)
 @keyparam forkChild flag indicating to debug the child after forking
 (boolean) (ignored)
 """
 self.__autoContinue = autoContinue
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
 RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
 traceInterpreter))
-def remoteRun(self, fn, argv, wd, autoFork = False, forkChild = False):
+def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
 """
 Public method to load a new program to run.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 @param wd the working directory for the program (string)
 @keyparam autoFork flag indicating the automatic fork mode (boolean) (ignored)
 @keyparam forkChild flag indicating to debug the child after forking
 (boolean) (ignored)
 """
 wd = self.translate(wd, False)
 fn = self.translate(os.path.abspath(fn), False)
 self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
 RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
-def remoteCoverage(self, fn, argv, wd, erase = False):
+def remoteCoverage(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect coverage data.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 @param wd the working directory for the program (string)
 @keyparam erase flag indicating that coverage info should be
 cleared first (boolean)
 """
 raise NotImplementedError("Interface not available.")
-def remoteProfile(self, fn, argv, wd, erase = False):
+def remoteProfile(self, fn, argv, wd, erase=False):
 """
 Public method to load a new program to collect profiling data.
 @param fn the filename to run (string)
 @param argv the commandline arguments to pass to the program (string)
 """
 raise NotImplementedError("Interface not available.")
 def remoteStatement(self, stmt):
 """
 Public method to execute a Ruby statement.
 @param stmt the Ruby statement to execute (string). It
 should not have a trailing newline.
 """
 self.__sendCommand('{0}\n'.format(stmt))
 """
 Public method to stop the debugged program.
 """
 self.__sendCommand(RequestStepQuit + '\n')
-def remoteContinue(self, special = False):
+def remoteContinue(self, special=False):
 """
 Public method to continue the debugged program.
 @param special flag indicating a special continue operation (boolean)
 """
 self.__sendCommand('{0}{1:d}\n'.format(RequestContinue, special))
-def remoteBreakpoint(self, fn, line, set, cond = None, temp = False):
+def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
 """
 Public method to set or clear a breakpoint.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
 RequestBreakIgnore, fn, line, count))
-def remoteWatchpoint(self, cond, set, temp = False):
+def remoteWatchpoint(self, cond, set, temp=False):
 """
 Public method to set or clear a watch expression.
 @param cond expression of the watch expression (string)
 @param set flag indicating setting or resetting a watch expression (boolean)
 @param count number of occurrences to ignore (int)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 self.__sendCommand('{0}{1},{2:d}\n'.format(RequestWatchIgnore, cond, count))
-def remoteRawInput(self,s):
+def remoteRawInput(self, s):
 """
 Public method to send the raw input to the debugged program.
 @param s the raw input (string)
 """
 @param tid id of the thread (integer)
 """
 return
-def remoteClientVariables(self, scope, filter, framenr = 0):
+def remoteClientVariables(self, scope, filter, framenr=0):
 """
 Public method to request the variables of the debugged program.
 @param scope the scope of the variables (0 = local, 1 = global)
 @param filter list of variable types to filter out (list of int)
 @param framenr framenumber of the variables to retrieve (int)
 """
 self.__sendCommand('{0}{1:d}, {2:d}, {3}\n'.format(
 RequestVariables, framenr, scope, str(filter)))
-def remoteClientVariable(self, scope, filter, var, framenr = 0):
+def remoteClientVariable(self, scope, filter, var, framenr=0):
 """
 Public method to request the variables of the debugged program.
 @param scope the scope of the variables (0 = local, 1 = global)
 @param filter list of variable types to filter out (list of int)

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebuggerInterfaceRuby.py

Debugger/DebuggerInterfaceRuby.py