eric: comparison Debugger/DebuggerInterfaceRuby.py

-:9986ec0e559a
+:10516539f238
 self.qsock = None
 self.queue = []
 # set default values for capabilities of clients
 self.clientCapabilities = ClientDefaultCapabilities
-self.codec = QTextCodec.codecForName(str(Preferences.getSystem("StringEncoding")))
+self.codec = QTextCodec.codecForName(
+str(Preferences.getSystem("StringEncoding")))
 if passive:
 # set translation function
 if Preferences.getDebugger("PathTranslation"):
 self.translateRemote = \
 """
 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)
-@param environment dictionary of environment settings to pass (dict of string)
+@param environment dictionary of environment settings to pass
+(dict of string)
 @return the process object (QProcess) or None
 """
 proc = QProcess()
 if environment is not None:
 env = []
 process = self.__startProcess(args[0], args[1:])
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<p>The debugger backend could not be"""
+""" started.</p>"""))
 # set translation function
 if Preferences.getDebugger("PathTranslation"):
 self.translateRemote = \
 Preferences.getDebugger("PathTranslationRemote")
 process = self.__startProcess(args[0], args[1:], clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<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>"""))
+self.trUtf8(
+"""<p>The debugger backend could not be started.</p>"""))
 return process, self.__isNetworked
 def startRemoteForProject(self, port, runInConsole):
 """
 Public method to start a remote Ruby interpreter for a project.
 process = self.__startProcess(args[0], args[1:])
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<p>The debugger backend could not be"""
+""" started.</p>"""))
 # set translation function
 if project.getDebugProperty("PATHTRANSLATION"):
-self.translateRemote = project.getDebugProperty("REMOTEPATH")
+self.translateRemote = \
-self.translateLocal = project.getDebugProperty("LOCALPATH")
+project.getDebugProperty("REMOTEPATH")
+self.translateLocal = \
+project.getDebugProperty("LOCALPATH")
 self.translate = self.__remoteTranslation
 else:
 self.translate = self.__identityTranslation
 return process, self.__isNetworked
 process = self.__startProcess(args[0], args[1:], clientEnv)
 if process is None:
 E5MessageBox.critical(None,
 self.trUtf8("Start Debugger"),
 self.trUtf8(
-"""<p>The debugger backend could not be started.</p>"""))
+"""<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>"""))
+self.trUtf8(
+"""<p>The debugger backend could not be started.</p>"""))
 return process, self.__isNetworked
 def getClientCapabilities(self):
 """
 Public method to retrieve the debug clients capabilities.
 """
 Public method to set the environment for a program to debug, run, ...
 @param env environment settings (dictionary)
 """
-self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEnv, str(env)))
+self.__sendCommand('{0}{1}\n'.format(
+DebugProtocol.RequestEnv, str(env)))
-def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
-autoFork=False, forkChild=False):
+def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
+autoContinue=True, 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)
 @param wd the working directory for the program (string)
-@keyparam traceInterpreter flag indicating if the interpreter library should be
+@keyparam traceInterpreter flag indicating if the interpreter library
-traced as well (boolean)
+should be traced as well (boolean)
-@keyparam autoContinue flag indicating, that the debugger should not stop
+@keyparam autoContinue flag indicating, that the debugger should not
-at the first executable line (boolean)
+stop at the first executable line (boolean)
-@keyparam autoFork flag indicating the automatic fork mode (boolean) (ignored)
+@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(
-DebugProtocol.RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
+DebugProtocol.RequestLoad, wd, fn,
-traceInterpreter))
+str(Utilities.parseOptionString(argv)),
+traceInterpreter))
 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 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(
-DebugProtocol.RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
+DebugProtocol.RequestRun, wd, fn,
+str(Utilities.parseOptionString(argv))))
 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)
+@exception NotImplementedError raised to indicate that this interface
+is not supported
 """
 raise NotImplementedError("Interface not available.")
 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)
 @param wd the working directory for the program (string)
-@keyparam erase flag indicating that timing info should be cleared first (boolean)
+@keyparam erase flag indicating that timing info should be cleared
+first (boolean)
+@exception NotImplementedError raised to indicate that this interface
+is not supported
 """
 raise NotImplementedError("Interface not available.")
 def remoteStatement(self, stmt):
 """
 """
 Public method to continue the debugged program.
 @param special flag indicating a special continue operation (boolean)
 """
-self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestContinue, special))
+self.__sendCommand('{0}{1:d}\n'.format(
+DebugProtocol.RequestContinue, special))
 def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
 """
 Public method to set or clear a breakpoint.
 @param cond condition of the breakpoint (string)
 @param temp flag indicating a temporary breakpoint (boolean)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
 DebugProtocol.RequestBreak, fn, line, temp, set, cond))
 def remoteBreakpointEnable(self, fn, line, enable):
 """
 Public method to enable or disable a breakpoint.
 @param fn filename the breakpoint belongs to (string)
 @param line linenumber of the breakpoint (int)
-@param enable flag indicating enabling or disabling a breakpoint (boolean)
+@param enable flag indicating enabling or disabling a breakpoint
+(boolean)
 """
 fn = self.translate(fn, False)
 self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
 DebugProtocol.RequestBreakEnable, fn, line, enable))
 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 set flag indicating setting or resetting a watch expression
+(boolean)
 @param temp flag indicating a temporary watch expression (boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 self.__sendCommand('{0}{1}@@{2:d}@@{3:d}\n'.format(
 DebugProtocol.RequestWatch, cond, temp, set))
 def remoteWatchpointEnable(self, cond, enable):
 """
 Public method to enable or disable a watch expression.
 @param cond expression of the watch expression (string)
-@param enable flag indicating enabling or disabling a watch expression (boolean)
+@param enable flag indicating enabling or disabling a watch expression
+(boolean)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 self.__sendCommand('{0}{1},{2:d}\n'.format(
 DebugProtocol.RequestWatchEnable, cond, enable))
 def remoteWatchpointIgnore(self, cond, count):
 """
-Public method to ignore a watch expression the next couple of occurrences.
+Public method to ignore a watch expression the next couple of
+occurrences.
 @param cond expression of the watch expression (string)
 @param count number of occurrences to ignore (int)
 """
 # cond is combination of cond and special (s. watch expression viewer)
 @param filter list of variable types to filter out (list of int)
 @param var list encoded name of variable to retrieve (string)
 @param framenr framenumber of the variables to retrieve (int)
 """
 self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-DebugProtocol.RequestVariable, str(var), framenr, scope, str(filter)))
+DebugProtocol.RequestVariable, str(var), framenr, scope,
+str(filter)))
 def remoteClientSetFilter(self, scope, filter):
 """
 Public method to set a variables filter list.
 """
 return
 def remoteEval(self, arg):
 """
-Public method to evaluate arg in the current context of the debugged program.
+Public method to evaluate arg in the current context of the debugged
+program.
 @param arg the arguments to evaluate (string)
 """
 self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEval, arg))
 def remoteExec(self, stmt):
 """
-Public method to execute stmt in the current context of the debugged program.
+Public method to execute stmt in the current context of the debugged
+program.
 @param stmt statement to execute (string)
 """
 self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestExec, stmt))
 Public slot to get the a list of possible commandline completions
 from the remote client.
 @param text the text to be completed (string)
 """
-self.__sendCommand("{0}{1}\n".format(DebugProtocol.RequestCompletion, text))
+self.__sendCommand("{0}{1}\n".format(
+DebugProtocol.RequestCompletion, text))
 def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
 """
 Public method to prepare a new unittest run.
 @param fn the filename to load (string)
 @param tn the testname to load (string)
 @param tfn the test function name to load tests from (string)
 @param failed list of failed test, if only failed test should be run
 (list of strings)
-@param cov flag indicating collection of coverage data is requested (boolean)
+@param cov flag indicating collection of coverage data is requested
+(boolean)
 @param covname filename to be used to assemble the coverage caches
 filename (string)
-@param coverase flag indicating erasure of coverage data is requested (boolean)
+@param coverase flag indicating erasure of coverage data is requested
+(boolean)
+@exception NotImplementedError raised to indicate that this interface
+is not supported
 """
 raise NotImplementedError("Interface not available.")
 def remoteUTRun(self):
 """
 Public method to start a unittest run.
+@exception NotImplementedError raised to indicate that this interface
+is not supported
 """
 raise NotImplementedError("Interface not available.")
 def remoteUTStop(self):
 """
-public method to stop a unittest run.
+Public method to stop a unittest run.
+@exception NotImplementedError raised to indicate that this interface
+is not supported
 """
 raise NotImplementedError("Interface not available.")
 def __parseClientLine(self):
 """
 stack = exclist[2:]
 except (IndexError, ValueError, SyntaxError):
 exctype = None
 excmessage = ''
 stack = []
-self.debugServer.signalClientException(exctype, excmessage, stack)
+self.debugServer.signalClientException(
+exctype, excmessage, stack)
 continue
 if resp == DebugProtocol.ResponseSyntax:
 exc = line[eoc:-1]
 exc = self.translate(exc, True)
 except (IndexError, ValueError):
 message = None
 fn = ''
 ln = 0
 cn = 0
-self.debugServer.signalClientSyntaxError(message, fn, ln, cn)
+self.debugServer.signalClientSyntaxError(
+message, fn, ln, cn)
 continue
 if resp == DebugProtocol.ResponseExit:
 self.debugServer.signalClientExit(line[eoc:-1])
 continue
 self.debugServer.signalClientClearWatch(cond)
 continue
 if resp == DebugProtocol.ResponseBanner:
 version, platform, dbgclient = eval(line[eoc:-1])
-self.debugServer.signalClientBanner(version, platform, dbgclient)
+self.debugServer.signalClientBanner(
+version, platform, dbgclient)
 continue
 if resp == DebugProtocol.ResponseCapabilities:
 cap, clType = eval(line[eoc:-1])
 self.clientCapabilities = cap

Mercurial Repositories > eric / file comparison

comparison: Debugger/DebuggerInterfaceRuby.py

Debugger/DebuggerInterfaceRuby.py