Rope Refactoring: comparison RefactoringRope/RefactoringServer.py

-:cb044ec27c24
+:4f53795beff0
 class RefactoringServer(EricJsonServer):
 """
 Class implementing the refactoring interface to rope.
 """
 def __init__(self, plugin, parent=None):
 """
 Constructor
 @param plugin reference to the plugin object
 @type RefactoringRopePlugin
 @param parent parent
 @type QObject
 """
-super().__init__(
+super().__init__("RefactoringServer", parent=parent)
-"RefactoringServer", parent=parent)
 self.__plugin = plugin
 self.__ui = parent
 self.__vm = ericApp().getObject("ViewManager")
 self.__ericProject = ericApp().getObject("Project")
-self.__projectpath = ''
+self.__projectpath = ""
 self.__projectLanguage = ""
 self.__projectopen = False
 self.__ropeConfig = {}
 self.__mainMenu = None
 self.__mainAct = None
 self.__separatorAct = None
 self.__progressDialog = None
 self.__helpDialog = None
 self.__historyDialog = None
 self.__refactoringDialogs = {}
 from .FileSystemCommands import EricFileSystemCommands
 self.__fsCommands = EricFileSystemCommands(self.__ericProject)
 self.__methodMapping = {
 "Config": self.__setConfig,
 "Progress": self.__processProgress,
 "QueryReferencesResult": self.__queryReferencesResult,
 "QueryDefinitionResult": self.__queryDefinitionResult,
 "QueryImplementationsResult": self.__queryImplementationsResult,
 "SoaFinished": self.__soaFinished,
 "FileSystemCommand": self.__fsCommands.processFileSystemCommand,
 "ClientException": self.__processClientException,
 "HistoryResult": self.__processHistoryResult,
 "Changes": self.__processChanges,
 }
 @pyqtSlot()
 def handleNewConnection(self):
 """
 Public slot for new incoming connections from a client.
 """
 super().handleNewConnection()
 self.sendJson("GetConfig", {})
 def activate(self):
 """
 Public method to activate the refactoring server.
 This is performed when the rope plug-in is activated.
 """
 self.__initActions()
 ericApp().registerPluginObject("RefactoringRope", self)
 readShortcuts(pluginName="RefactoringRope")
 self.__mainMenu = self.__initMenu()
 projectToolsMenu = self.__ui.getMenu("project_tools")
 if projectToolsMenu is not None:
 insertBeforeAct = projectToolsMenu.actions()[0]
 self.__mainAct = projectToolsMenu.insertMenu(
-insertBeforeAct, self.__mainMenu)
+insertBeforeAct, self.__mainMenu
-self.__separatorAct = projectToolsMenu.insertSeparator(
+)
-insertBeforeAct)
+self.__separatorAct = projectToolsMenu.insertSeparator(insertBeforeAct)
 else:
 projectAct = self.__ui.getMenuBarAction("project")
 actions = self.__ui.menuBar().actions()
 insertBeforeAct = actions[actions.index(projectAct) + 1]
 self.__mainAct = self.__ui.menuBar().insertMenu(
-insertBeforeAct, self.__mainMenu)
+insertBeforeAct, self.__mainMenu
+)
 self.__mainAct.setEnabled(False)
 if ericApp().getObject("Project").isOpen():
 self.projectOpened()
-ericApp().getObject("Project").projectOpened.connect(
+ericApp().getObject("Project").projectOpened.connect(self.projectOpened)
-self.projectOpened)
 ericApp().getObject("Project").projectPropertiesChanged.connect(
-self.projectOpened)
+self.projectOpened
-ericApp().getObject("Project").projectClosed.connect(
+)
-self.projectClosed)
+ericApp().getObject("Project").projectClosed.connect(self.projectClosed)
-ericApp().getObject("Project").newProject.connect(
+ericApp().getObject("Project").newProject.connect(self.projectOpened)
-self.projectOpened)
 def deactivate(self):
 """
 Public method to deactivate the refactoring server.
 """
 ericApp().unregisterPluginObject("RefactoringRope")
-ericApp().getObject("Project").projectOpened.disconnect(
+ericApp().getObject("Project").projectOpened.disconnect(self.projectOpened)
-self.projectOpened)
 ericApp().getObject("Project").projectPropertiesChanged.disconnect(
-self.projectOpened)
+self.projectOpened
-ericApp().getObject("Project").projectClosed.disconnect(
+)
-self.projectClosed)
+ericApp().getObject("Project").projectClosed.disconnect(self.projectClosed)
-ericApp().getObject("Project").newProject.disconnect(
+ericApp().getObject("Project").newProject.disconnect(self.projectOpened)
-self.projectOpened)
 projectToolsMenu = self.__ui.getMenu("project_tools")
 if projectToolsMenu is not None:
 projectToolsMenu.removeAction(self.__separatorAct)
 projectToolsMenu.removeAction(self.__mainAct)
 else:
 self.__ui.menuBar().removeAction(self.__mainAct)
 self.projectClosed()
 def getMainWindow(self):
 """
 Public method to get a reference to the IDE main window.
 @return reference to the IDE main window
 @rtype UserInterface
 """
 return self.__ui
 def __initActions(self):
 """
 Private method to define the refactoring actions.
 """
 self.actions = []
 #####################################################
 ## Rename refactoring actions
 #####################################################
 self.refactoringRenameAct = EricAction(
-self.tr('Rename'),
+self.tr("Rename"), self.tr("&Rename"), 0, 0, self, "refactoring_rename"
-self.tr('&Rename'),
+)
-0, 0,
+self.refactoringRenameAct.setStatusTip(self.tr("Rename the highlighted object"))
-self, 'refactoring_rename')
+self.refactoringRenameAct.setWhatsThis(
-self.refactoringRenameAct.setStatusTip(self.tr(
+self.tr(
-'Rename the highlighted object'))
+"""<b>Rename</b>""" """<p>Rename the highlighted Python object.</p>"""
-self.refactoringRenameAct.setWhatsThis(self.tr(
+)
-"""<b>Rename</b>"""
+)
-"""<p>Rename the highlighted Python object.</p>"""
+self.refactoringRenameAct.triggered.connect(self.__rename)
-))
-self.refactoringRenameAct.triggered.connect(
-self.__rename)
 self.actions.append(self.refactoringRenameAct)
 self.refactoringRenameLocalAct = EricAction(
-self.tr('Local Rename'),
+self.tr("Local Rename"),
-self.tr('&Local Rename'),
+self.tr("&Local Rename"),
-0, 0,
+0,
-self, 'refactoring_rename_local')
+0,
-self.refactoringRenameLocalAct.setStatusTip(self.tr(
+self,
-'Rename the highlighted object in the current module only'))
+"refactoring_rename_local",
-self.refactoringRenameLocalAct.setWhatsThis(self.tr(
+)
-"""<b>Local Rename</b>"""
+self.refactoringRenameLocalAct.setStatusTip(
-"""<p>Rename the highlighted Python object in the current"""
+self.tr("Rename the highlighted object in the current module only")
-""" module only.</p>"""
+)
-))
+self.refactoringRenameLocalAct.setWhatsThis(
-self.refactoringRenameLocalAct.triggered.connect(
+self.tr(
-self.__renameLocal)
+"""<b>Local Rename</b>"""
+"""<p>Rename the highlighted Python object in the current"""
+""" module only.</p>"""
+)
+)
+self.refactoringRenameLocalAct.triggered.connect(self.__renameLocal)
 self.actions.append(self.refactoringRenameLocalAct)
 self.refactoringRenameModuleAct = EricAction(
-self.tr('Rename Current Module'),
+self.tr("Rename Current Module"),
-self.tr('Rename Current Module'),
+self.tr("Rename Current Module"),
-0, 0,
+0,
-self, 'refactoring_rename_module')
+0,
-self.refactoringRenameModuleAct.setStatusTip(self.tr(
+self,
-'Rename the current module'))
+"refactoring_rename_module",
-self.refactoringRenameModuleAct.setWhatsThis(self.tr(
+)
-"""<b>Rename Current Module</b>"""
+self.refactoringRenameModuleAct.setStatusTip(
-"""<p>Rename the current module.</p>"""
+self.tr("Rename the current module")
-))
+)
-self.refactoringRenameModuleAct.triggered.connect(
+self.refactoringRenameModuleAct.setWhatsThis(
-self.__renameModule)
+self.tr(
+"""<b>Rename Current Module</b>"""
+"""<p>Rename the current module.</p>"""
+)
+)
+self.refactoringRenameModuleAct.triggered.connect(self.__renameModule)
 self.actions.append(self.refactoringRenameModuleAct)
 self.refactoringChangeOccurrencesAct = EricAction(
-self.tr('Change Occurrences'),
+self.tr("Change Occurrences"),
-self.tr('Change &Occurrences'),
+self.tr("Change &Occurrences"),
-0, 0,
+0,
-self, 'refactoring_change_occurrences')
+0,
-self.refactoringChangeOccurrencesAct.setStatusTip(self.tr(
+self,
-'Change all occurrences in the local scope'))
+"refactoring_change_occurrences",
-self.refactoringChangeOccurrencesAct.setWhatsThis(self.tr(
+)
-"""<b>Change Occurrences</b>"""
+self.refactoringChangeOccurrencesAct.setStatusTip(
-"""<p>Change all occurrences in the local scope.</p>"""
+self.tr("Change all occurrences in the local scope")
-))
+)
-self.refactoringChangeOccurrencesAct.triggered.connect(
+self.refactoringChangeOccurrencesAct.setWhatsThis(
-self.__changeOccurrences)
+self.tr(
+"""<b>Change Occurrences</b>"""
+"""<p>Change all occurrences in the local scope.</p>"""
+)
+)
+self.refactoringChangeOccurrencesAct.triggered.connect(self.__changeOccurrences)
 self.actions.append(self.refactoringChangeOccurrencesAct)
 #####################################################
 ## Extract refactoring actions
 #####################################################
 self.refactoringExtractMethodAct = EricAction(
-self.tr('Extract method'),
+self.tr("Extract method"),
-self.tr('Extract &Method'),
+self.tr("Extract &Method"),
-0, 0,
+0,
-self, 'refactoring_extract_method')
+0,
-self.refactoringExtractMethodAct.setStatusTip(self.tr(
+self,
-'Extract the highlighted area as a method'))
+"refactoring_extract_method",
-self.refactoringExtractMethodAct.setWhatsThis(self.tr(
+)
-"""<b>Extract method</b>"""
+self.refactoringExtractMethodAct.setStatusTip(
-"""<p>Extract the highlighted area as a method or function.</p>"""
+self.tr("Extract the highlighted area as a method")
-))
+)
-self.refactoringExtractMethodAct.triggered.connect(
+self.refactoringExtractMethodAct.setWhatsThis(
-self.__extractMethod)
+self.tr(
+"""<b>Extract method</b>"""
+"""<p>Extract the highlighted area as a method or function.</p>"""
+)
+)
+self.refactoringExtractMethodAct.triggered.connect(self.__extractMethod)
 self.actions.append(self.refactoringExtractMethodAct)
 self.refactoringExtractLocalVariableAct = EricAction(
-self.tr('Extract local variable'),
+self.tr("Extract local variable"),
-self.tr('&Extract Local Variable'),
+self.tr("&Extract Local Variable"),
-0, 0,
+0,
-self, 'refactoring_extract_variable')
+0,
-self.refactoringExtractLocalVariableAct.setStatusTip(self.tr(
+self,
-'Extract the highlighted area as a local variable'))
+"refactoring_extract_variable",
-self.refactoringExtractLocalVariableAct.setWhatsThis(self.tr(
+)
-"""<b>Extract local variable</b>"""
+self.refactoringExtractLocalVariableAct.setStatusTip(
-"""<p>Extract the highlighted area as a local variable.</p>"""
+self.tr("Extract the highlighted area as a local variable")
-))
+)
+self.refactoringExtractLocalVariableAct.setWhatsThis(
+self.tr(
+"""<b>Extract local variable</b>"""
+"""<p>Extract the highlighted area as a local variable.</p>"""
+)
+)
 self.refactoringExtractLocalVariableAct.triggered.connect(
-self.__extractLocalVariable)
+self.__extractLocalVariable
+)
 self.actions.append(self.refactoringExtractLocalVariableAct)
 #####################################################
 ## Inline refactoring actions
 #####################################################
 self.refactoringInlineAct = EricAction(
-self.tr('Inline'),
+self.tr("Inline"), self.tr("&Inline"), 0, 0, self, "refactoring_inline"
-self.tr('&Inline'),
+)
-0, 0,
+self.refactoringInlineAct.setStatusTip(
-self, 'refactoring_inline')
+self.tr("Inlines the selected local variable or method")
-self.refactoringInlineAct.setStatusTip(self.tr(
+)
-'Inlines the selected local variable or method'))
+self.refactoringInlineAct.setWhatsThis(
-self.refactoringInlineAct.setWhatsThis(self.tr(
+self.tr(
 """<b>Inline</b>"""
 """<p>Inlines the selected local variable or method.</p>"""
-))
+)
-self.refactoringInlineAct.triggered.connect(
+)
-self.__inline)
+self.refactoringInlineAct.triggered.connect(self.__inline)
 self.actions.append(self.refactoringInlineAct)
 #####################################################
 ## Move refactoring actions
 #####################################################
 self.refactoringMoveMethodAct = EricAction(
-self.tr('Move method'),
+self.tr("Move method"),
-self.tr('Mo&ve Method'),
+self.tr("Mo&ve Method"),
-0, 0,
+0,
-self, 'refactoring_move_method')
+0,
-self.refactoringMoveMethodAct.setStatusTip(self.tr(
+self,
-'Move the highlighted method to another class'))
+"refactoring_move_method",
-self.refactoringMoveMethodAct.setWhatsThis(self.tr(
+)
-"""<b>Move method</b>"""
+self.refactoringMoveMethodAct.setStatusTip(
-"""<p>Move the highlighted method to another class.</p>"""
+self.tr("Move the highlighted method to another class")
-))
+)
+self.refactoringMoveMethodAct.setWhatsThis(
+self.tr(
+"""<b>Move method</b>"""
+"""<p>Move the highlighted method to another class.</p>"""
+)
+)
 self.refactoringMoveMethodAct.triggered.connect(
-lambda: self.__move("move_method"))
+lambda: self.__move("move_method")
+)
 self.actions.append(self.refactoringMoveMethodAct)
 self.refactoringMoveModuleAct = EricAction(
-self.tr('Move current module'),
+self.tr("Move current module"),
-self.tr('Move Current Module'),
+self.tr("Move Current Module"),
-0, 0,
+0,
-self, 'refactoring_move_module')
+0,
-self.refactoringMoveModuleAct.setStatusTip(self.tr(
+self,
-'Move the current module to another package'))
+"refactoring_move_module",
-self.refactoringMoveModuleAct.setWhatsThis(self.tr(
+)
-"""<b>Move current module</b>"""
+self.refactoringMoveModuleAct.setStatusTip(
-"""<p>Move the current module to another package.</p>"""
+self.tr("Move the current module to another package")
-))
+)
+self.refactoringMoveModuleAct.setWhatsThis(
+self.tr(
+"""<b>Move current module</b>"""
+"""<p>Move the current module to another package.</p>"""
+)
+)
 self.refactoringMoveModuleAct.triggered.connect(
-lambda: self.__move("move_module"))
+lambda: self.__move("move_module")
+)
 self.actions.append(self.refactoringMoveModuleAct)
 #####################################################
 ## Use function refactoring action
 #####################################################
 self.refactoringUseFunctionAct = EricAction(
-self.tr('Use Function'),
+self.tr("Use Function"),
-self.tr('Use Function'),
+self.tr("Use Function"),
-0, 0,
+0,
-self, 'refactoring_use_function')
+0,
-self.refactoringUseFunctionAct.setStatusTip(self.tr(
+self,
-'Use a function wherever possible.'))
+"refactoring_use_function",
-self.refactoringUseFunctionAct.setWhatsThis(self.tr(
+)
-"""<b>Use function</b>"""
+self.refactoringUseFunctionAct.setStatusTip(
-"""<p>Tries to use a function wherever possible.</p>"""
+self.tr("Use a function wherever possible.")
-))
+)
-self.refactoringUseFunctionAct.triggered.connect(
+self.refactoringUseFunctionAct.setWhatsThis(
-self.__useFunction)
+self.tr(
+"""<b>Use function</b>"""
+"""<p>Tries to use a function wherever possible.</p>"""
+)
+)
+self.refactoringUseFunctionAct.triggered.connect(self.__useFunction)
 self.actions.append(self.refactoringUseFunctionAct)
 #####################################################
 ## Introduce refactorings actions
 #####################################################
 self.refactoringIntroduceFactoryAct = EricAction(
-self.tr('Introduce Factory Method'),
+self.tr("Introduce Factory Method"),
-self.tr('Introduce &Factory Method'),
+self.tr("Introduce &Factory Method"),
-0, 0,
+0,
-self, 'refactoring_introduce_factory_method')
+0,
-self.refactoringIntroduceFactoryAct.setStatusTip(self.tr(
+self,
-'Introduce a factory method or function'))
+"refactoring_introduce_factory_method",
-self.refactoringIntroduceFactoryAct.setWhatsThis(self.tr(
+)
-"""<b>Introduce Factory Method</b>"""
+self.refactoringIntroduceFactoryAct.setStatusTip(
-"""<p>Introduce a factory method or function.</p>"""
+self.tr("Introduce a factory method or function")
-))
+)
+self.refactoringIntroduceFactoryAct.setWhatsThis(
+self.tr(
+"""<b>Introduce Factory Method</b>"""
+"""<p>Introduce a factory method or function.</p>"""
+)
+)
 self.refactoringIntroduceFactoryAct.triggered.connect(
-self.__introduceFactoryMethod)
+self.__introduceFactoryMethod
+)
 self.actions.append(self.refactoringIntroduceFactoryAct)
 self.refactoringIntroduceParameterAct = EricAction(
-self.tr('Introduce Parameter'),
+self.tr("Introduce Parameter"),
-self.tr('Introduce &Parameter'),
+self.tr("Introduce &Parameter"),
-0, 0,
+0,
-self, 'refactoring_introduce_parameter_method')
+0,
-self.refactoringIntroduceParameterAct.setStatusTip(self.tr(
+self,
-'Introduce a parameter in a function'))
+"refactoring_introduce_parameter_method",
-self.refactoringIntroduceParameterAct.setWhatsThis(self.tr(
+)
-"""<b>Introduce Parameter</b>"""
+self.refactoringIntroduceParameterAct.setStatusTip(
-"""<p>Introduce a parameter in a function.</p>"""
+self.tr("Introduce a parameter in a function")
-))
+)
+self.refactoringIntroduceParameterAct.setWhatsThis(
+self.tr(
+"""<b>Introduce Parameter</b>"""
+"""<p>Introduce a parameter in a function.</p>"""
+)
+)
 self.refactoringIntroduceParameterAct.triggered.connect(
-self.__introduceParameter)
+self.__introduceParameter
+)
 self.actions.append(self.refactoringIntroduceParameterAct)
 #####################################################
 ## Import refactorings actions
 #####################################################
 self.refactoringImportsOrganizeAct = EricAction(
-self.tr('Organize Imports'),
+self.tr("Organize Imports"),
-self.tr('&Organize Imports'),
+self.tr("&Organize Imports"),
-0, 0,
+0,
-self, 'refactoring_organize_imports')
+0,
-self.refactoringImportsOrganizeAct.setStatusTip(self.tr(
+self,
-'Sort imports according to PEP-8'))
+"refactoring_organize_imports",
-self.refactoringImportsOrganizeAct.setWhatsThis(self.tr(
+)
-"""<b>Organize Imports</b>"""
+self.refactoringImportsOrganizeAct.setStatusTip(
-"""<p>Sort imports according to PEP-8.</p>"""
+self.tr("Sort imports according to PEP-8")
-))
+)
-self.refactoringImportsOrganizeAct.triggered.connect(
+self.refactoringImportsOrganizeAct.setWhatsThis(
-self.__importsOrganize)
+self.tr(
+"""<b>Organize Imports</b>"""
+"""<p>Sort imports according to PEP-8.</p>"""
+)
+)
+self.refactoringImportsOrganizeAct.triggered.connect(self.__importsOrganize)
 self.actions.append(self.refactoringImportsOrganizeAct)
 self.refactoringImportsStarExpandAct = EricAction(
-self.tr('Expand Star Imports'),
+self.tr("Expand Star Imports"),
-self.tr('E&xpand Star Imports'),
+self.tr("E&xpand Star Imports"),
-0, 0,
+0,
-self, 'refactoring_expand_star_imports')
+0,
-self.refactoringImportsStarExpandAct.setStatusTip(self.tr(
+self,
-'Expand imports like "from xxx import *"'))
+"refactoring_expand_star_imports",
-self.refactoringImportsStarExpandAct.setWhatsThis(self.tr(
+)
-"""<b>Expand Star Imports</b>"""
+self.refactoringImportsStarExpandAct.setStatusTip(
-"""<p>Expand imports like "from xxx import *".</p>"""
+self.tr('Expand imports like "from xxx import *"')
-"""<p>Select the import to act on or none to do all."""
+)
-""" Unused imports are deleted.</p>"""
+self.refactoringImportsStarExpandAct.setWhatsThis(
-))
+self.tr(
-self.refactoringImportsStarExpandAct.triggered.connect(
+"""<b>Expand Star Imports</b>"""
-self.__importsExpandStar)
+"""<p>Expand imports like "from xxx import *".</p>"""
+"""<p>Select the import to act on or none to do all."""
+""" Unused imports are deleted.</p>"""
+)
+)
+self.refactoringImportsStarExpandAct.triggered.connect(self.__importsExpandStar)
 self.actions.append(self.refactoringImportsStarExpandAct)
 self.refactoringImportsRelativeToAbsoluteAct = EricAction(
-self.tr('Relative to Absolute'),
+self.tr("Relative to Absolute"),
-self.tr('Relative to &Absolute'),
+self.tr("Relative to &Absolute"),
-0, 0,
+0,
-self, 'refactoring_relative_to_absolute_imports')
+0,
-self.refactoringImportsRelativeToAbsoluteAct.setStatusTip(self.tr(
+self,
-'Transform relative imports to absolute ones'))
+"refactoring_relative_to_absolute_imports",
-self.refactoringImportsRelativeToAbsoluteAct.setWhatsThis(self.tr(
+)
-"""<b>Relative to Absolute</b>"""
+self.refactoringImportsRelativeToAbsoluteAct.setStatusTip(
-"""<p>Transform relative imports to absolute ones.</p>"""
+self.tr("Transform relative imports to absolute ones")
-"""<p>Select the import to act on or none to do all."""
+)
-""" Unused imports are deleted.</p>"""
+self.refactoringImportsRelativeToAbsoluteAct.setWhatsThis(
-))
+self.tr(
+"""<b>Relative to Absolute</b>"""
+"""<p>Transform relative imports to absolute ones.</p>"""
+"""<p>Select the import to act on or none to do all."""
+""" Unused imports are deleted.</p>"""
+)
+)
 self.refactoringImportsRelativeToAbsoluteAct.triggered.connect(
-self.__importsRelativeToAbsolute)
+self.__importsRelativeToAbsolute
+)
 self.actions.append(self.refactoringImportsRelativeToAbsoluteAct)
 self.refactoringImportsFromsToImportsAct = EricAction(
-self.tr('Froms to Imports'),
+self.tr("Froms to Imports"),
-self.tr('Froms to &Imports'),
+self.tr("Froms to &Imports"),
-0, 0,
+0,
-self, 'refactoring_froms_to_imports')
+0,
-self.refactoringImportsFromsToImportsAct.setStatusTip(self.tr(
+self,
-'Transform From imports to plain imports'))
+"refactoring_froms_to_imports",
-self.refactoringImportsFromsToImportsAct.setWhatsThis(self.tr(
+)
-"""<b>Froms to Imports</b>"""
+self.refactoringImportsFromsToImportsAct.setStatusTip(
-"""<p>Transform From imports to plain imports.</p>"""
+self.tr("Transform From imports to plain imports")
-"""<p>Select the import to act on or none to do all."""
+)
-""" Unused imports are deleted.</p>"""
+self.refactoringImportsFromsToImportsAct.setWhatsThis(
-))
+self.tr(
+"""<b>Froms to Imports</b>"""
+"""<p>Transform From imports to plain imports.</p>"""
+"""<p>Select the import to act on or none to do all."""
+""" Unused imports are deleted.</p>"""
+)
+)
 self.refactoringImportsFromsToImportsAct.triggered.connect(
-self.__importsFromToImport)
+self.__importsFromToImport
+)
 self.actions.append(self.refactoringImportsFromsToImportsAct)
 self.refactoringImportsHandleLongAct = EricAction(
-self.tr('Handle Long Imports'),
+self.tr("Handle Long Imports"),
-self.tr('Handle &Long Imports'),
+self.tr("Handle &Long Imports"),
-0, 0,
+0,
-self, 'refactoring_organize_imports')
+0,
-self.refactoringImportsHandleLongAct.setStatusTip(self.tr(
+self,
-'Transform long import statements to look better'))
+"refactoring_organize_imports",
-self.refactoringImportsHandleLongAct.setWhatsThis(self.tr(
+)
-"""<b>Handle Long Imports</b>"""
+self.refactoringImportsHandleLongAct.setStatusTip(
-"""<p>Transform long import statements to look better.</p>"""
+self.tr("Transform long import statements to look better")
-"""<p>Select the import to act on or none to do all."""
+)
-""" Unused imports are deleted.</p>"""
+self.refactoringImportsHandleLongAct.setWhatsThis(
-))
+self.tr(
-self.refactoringImportsHandleLongAct.triggered.connect(
+"""<b>Handle Long Imports</b>"""
-self.__importsHandleLong)
+"""<p>Transform long import statements to look better.</p>"""
+"""<p>Select the import to act on or none to do all."""
+""" Unused imports are deleted.</p>"""
+)
+)
+self.refactoringImportsHandleLongAct.triggered.connect(self.__importsHandleLong)
 self.actions.append(self.refactoringImportsHandleLongAct)
 #####################################################
 ## Various refactorings actions
 #####################################################
 self.refactoringRestructureAct = EricAction(
-self.tr('Restructure'),
+self.tr("Restructure"),
-self.tr('Res&tructure'),
+self.tr("Res&tructure"),
-0, 0,
+0,
-self, 'refactoring_restructure')
+0,
-self.refactoringRestructureAct.setStatusTip(self.tr(
+self,
-'Restructure code'))
+"refactoring_restructure",
-self.refactoringRestructureAct.setWhatsThis(self.tr(
+)
-"""<b>Restructure</b>"""
+self.refactoringRestructureAct.setStatusTip(self.tr("Restructure code"))
-"""<p>Restructure code. See "Rope Help" for examples.</p>"""
+self.refactoringRestructureAct.setWhatsThis(
-))
+self.tr(
-self.refactoringRestructureAct.triggered.connect(
+"""<b>Restructure</b>"""
-self.__restructure)
+"""<p>Restructure code. See "Rope Help" for examples.</p>"""
+)
+)
+self.refactoringRestructureAct.triggered.connect(self.__restructure)
 self.actions.append(self.refactoringRestructureAct)
 self.refactoringChangeSignatureAct = EricAction(
-self.tr('Change Method Signature'),
+self.tr("Change Method Signature"),
-self.tr('&Change Method Signature'),
+self.tr("&Change Method Signature"),
-0, 0,
+0,
-self, 'refactoring_change_method_signature')
+0,
-self.refactoringChangeSignatureAct.setStatusTip(self.tr(
+self,
-'Change the signature of the selected method or function'))
+"refactoring_change_method_signature",
-self.refactoringChangeSignatureAct.setWhatsThis(self.tr(
+)
-"""<b>Change Method Signature</b>"""
+self.refactoringChangeSignatureAct.setStatusTip(
-"""<p>Change the signature of the selected method"""
+self.tr("Change the signature of the selected method or function")
-""" or function.</p>"""
+)
-))
+self.refactoringChangeSignatureAct.setWhatsThis(
-self.refactoringChangeSignatureAct.triggered.connect(
+self.tr(
-self.__changeSignature)
+"""<b>Change Method Signature</b>"""
+"""<p>Change the signature of the selected method"""
+""" or function.</p>"""
+)
+)
+self.refactoringChangeSignatureAct.triggered.connect(self.__changeSignature)
 self.actions.append(self.refactoringChangeSignatureAct)
 self.refactoringInlineArgumentDefaultAct = EricAction(
-self.tr('Inline Argument Default'),
+self.tr("Inline Argument Default"),
-self.tr('Inline &Argument Default'),
+self.tr("Inline &Argument Default"),
-0, 0,
+0,
-self, 'refactoring_inline_argument_default')
+0,
-self.refactoringInlineArgumentDefaultAct.setStatusTip(self.tr(
+self,
-'Inline a parameters default value'))
+"refactoring_inline_argument_default",
-self.refactoringInlineArgumentDefaultAct.setWhatsThis(self.tr(
+)
-"""<b>Inline Argument Default</b>"""
+self.refactoringInlineArgumentDefaultAct.setStatusTip(
-"""<p>Inline a parameters default value.</p>"""
+self.tr("Inline a parameters default value")
-))
+)
+self.refactoringInlineArgumentDefaultAct.setWhatsThis(
+self.tr(
+"""<b>Inline Argument Default</b>"""
+"""<p>Inline a parameters default value.</p>"""
+)
+)
 self.refactoringInlineArgumentDefaultAct.triggered.connect(
-self.__inlineArgumentDefault)
+self.__inlineArgumentDefault
+)
 self.actions.append(self.refactoringInlineArgumentDefaultAct)
 self.refactoringTransformModuleAct = EricAction(
-self.tr('Transform Module to Package'),
+self.tr("Transform Module to Package"),
-self.tr('Transform Module to Package'),
+self.tr("Transform Module to Package"),
-0, 0,
+0,
-self, 'refactoring_transform_module_to_package')
+0,
-self.refactoringTransformModuleAct.setStatusTip(self.tr(
+self,
-'Transform the current module to a package'))
+"refactoring_transform_module_to_package",
-self.refactoringTransformModuleAct.setWhatsThis(self.tr(
+)
-"""<b>Transform Module to Package</b>"""
+self.refactoringTransformModuleAct.setStatusTip(
-"""<p>Transform the current module to a package.</p>"""
+self.tr("Transform the current module to a package")
-))
+)
+self.refactoringTransformModuleAct.setWhatsThis(
+self.tr(
+"""<b>Transform Module to Package</b>"""
+"""<p>Transform the current module to a package.</p>"""
+)
+)
 self.refactoringTransformModuleAct.triggered.connect(
-self.__transformModuleToPackage)
+self.__transformModuleToPackage
+)
 self.actions.append(self.refactoringTransformModuleAct)
 self.refactoringEncapsulateAttributeAct = EricAction(
-self.tr('Encapsulate Attribute'),
+self.tr("Encapsulate Attribute"),
-self.tr('Encap&sulate Attribute'),
+self.tr("Encap&sulate Attribute"),
-0, 0,
+0,
-self, 'refactoring_encapsulate_attribute')
+0,
-self.refactoringEncapsulateAttributeAct.setStatusTip(self.tr(
+self,
-'Generate a getter/setter for an attribute'))
+"refactoring_encapsulate_attribute",
-self.refactoringEncapsulateAttributeAct.setWhatsThis(self.tr(
+)
-"""<b>Encapsulate Attribute</b>"""
+self.refactoringEncapsulateAttributeAct.setStatusTip(
-"""<p>Generate a getter/setter for an attribute and changes"""
+self.tr("Generate a getter/setter for an attribute")
-""" its occurrences to use them.</p>"""
+)
-))
+self.refactoringEncapsulateAttributeAct.setWhatsThis(
+self.tr(
+"""<b>Encapsulate Attribute</b>"""
+"""<p>Generate a getter/setter for an attribute and changes"""
+""" its occurrences to use them.</p>"""
+)
+)
 self.refactoringEncapsulateAttributeAct.triggered.connect(
-self.__encapsulateAttribute)
+self.__encapsulateAttribute
+)
 self.actions.append(self.refactoringEncapsulateAttributeAct)
 self.refactoringLocalVariableToAttributeAct = EricAction(
-self.tr('Local Variable to Attribute'),
+self.tr("Local Variable to Attribute"),
-self.tr('Local Varia&ble to Attribute'),
+self.tr("Local Varia&ble to Attribute"),
-0, 0,
+0,
-self, 'refactoring_local_variable_to_attribute')
+0,
-self.refactoringLocalVariableToAttributeAct.setStatusTip(self.tr(
+self,
-'Change a local variable to an attribute'))
+"refactoring_local_variable_to_attribute",
-self.refactoringLocalVariableToAttributeAct.setWhatsThis(self.tr(
+)
-"""<b>Local Variable to Attribute</b>"""
+self.refactoringLocalVariableToAttributeAct.setStatusTip(
-"""<p>Change a local variable to an attribute.</p>"""
+self.tr("Change a local variable to an attribute")
-))
+)
+self.refactoringLocalVariableToAttributeAct.setWhatsThis(
+self.tr(
+"""<b>Local Variable to Attribute</b>"""
+"""<p>Change a local variable to an attribute.</p>"""
+)
+)
 self.refactoringLocalVariableToAttributeAct.triggered.connect(
-self.__convertLocalToAttribute)
+self.__convertLocalToAttribute
+)
 self.actions.append(self.refactoringLocalVariableToAttributeAct)
 self.refactoringMethodToMethodObjectAct = EricAction(
-self.tr('Method To Method Object'),
+self.tr("Method To Method Object"),
-self.tr('Method To Method Ob&ject'),
+self.tr("Method To Method Ob&ject"),
-0, 0,
+0,
-self, 'refactoring_method_to_methodobject')
+0,
-self.refactoringMethodToMethodObjectAct.setStatusTip(self.tr(
+self,
-'Transform a function or a method to a method object'))
+"refactoring_method_to_methodobject",
-self.refactoringMethodToMethodObjectAct.setWhatsThis(self.tr(
+)
-"""<b>Method To Method Object</b>"""
+self.refactoringMethodToMethodObjectAct.setStatusTip(
-"""<p>Transform a function or a method to a method object.</p>"""
+self.tr("Transform a function or a method to a method object")
-))
+)
+self.refactoringMethodToMethodObjectAct.setWhatsThis(
+self.tr(
+"""<b>Method To Method Object</b>"""
+"""<p>Transform a function or a method to a method object.</p>"""
+)
+)
 self.refactoringMethodToMethodObjectAct.triggered.connect(
-self.__methodToMethodObject)
+self.__methodToMethodObject
+)
 self.actions.append(self.refactoringMethodToMethodObjectAct)
 #####################################################
 ## History actions
 #####################################################
 self.refactoringProjectHistoryAct = EricAction(
-self.tr('Show Project History'),
+self.tr("Show Project History"),
-self.tr('Show Project History...'),
+self.tr("Show Project History..."),
-0, 0,
+0,
-self, 'refactoring_show_project_history')
+0,
-self.refactoringProjectHistoryAct.setStatusTip(self.tr(
+self,
-'Show the refactoring history of the project'))
+"refactoring_show_project_history",
-self.refactoringProjectHistoryAct.setWhatsThis(self.tr(
+)
-"""<b>Show Project History</b>"""
+self.refactoringProjectHistoryAct.setStatusTip(
-"""<p>This opens a dialog to show the refactoring history of"""
+self.tr("Show the refactoring history of the project")
-""" the project.</p>"""
+)
-))
+self.refactoringProjectHistoryAct.setWhatsThis(
-self.refactoringProjectHistoryAct.triggered.connect(
+self.tr(
-self.__showProjectHistory)
+"""<b>Show Project History</b>"""
+"""<p>This opens a dialog to show the refactoring history of"""
+""" the project.</p>"""
+)
+)
+self.refactoringProjectHistoryAct.triggered.connect(self.__showProjectHistory)
 self.actions.append(self.refactoringProjectHistoryAct)
 self.refactoringFileHistoryAct = EricAction(
-self.tr('Show Current File History'),
+self.tr("Show Current File History"),
-self.tr('Show Current File History...'),
+self.tr("Show Current File History..."),
-0, 0,
+0,
-self, 'refactoring_show_file_history')
+0,
-self.refactoringFileHistoryAct.setStatusTip(self.tr(
+self,
-'Show the refactoring history of the current file'))
+"refactoring_show_file_history",
-self.refactoringFileHistoryAct.setWhatsThis(self.tr(
+)
-"""<b>Show Current File History</b>"""
+self.refactoringFileHistoryAct.setStatusTip(
-"""<p>This opens a dialog to show the refactoring history of"""
+self.tr("Show the refactoring history of the current file")
-""" the current file.</p>"""
+)
-))
+self.refactoringFileHistoryAct.setWhatsThis(
-self.refactoringFileHistoryAct.triggered.connect(
+self.tr(
-self.__showFileHistory)
+"""<b>Show Current File History</b>"""
+"""<p>This opens a dialog to show the refactoring history of"""
+""" the current file.</p>"""
+)
+)
+self.refactoringFileHistoryAct.triggered.connect(self.__showFileHistory)
 self.actions.append(self.refactoringFileHistoryAct)
 self.refactoringClearHistoryAct = EricAction(
-self.tr('Clear History'),
+self.tr("Clear History"),
-self.tr('Clear History'),
+self.tr("Clear History"),
-0, 0,
+0,
-self, 'refactoring_clear_history')
+0,
-self.refactoringClearHistoryAct.setStatusTip(self.tr(
+self,
-'Clear the refactoring history'))
+"refactoring_clear_history",
-self.refactoringClearHistoryAct.setWhatsThis(self.tr(
+)
-"""<b>Clear History</b>"""
+self.refactoringClearHistoryAct.setStatusTip(
-"""<p>Clears the refactoring history.</p>"""
+self.tr("Clear the refactoring history")
-))
+)
-self.refactoringClearHistoryAct.triggered.connect(
+self.refactoringClearHistoryAct.setWhatsThis(
-self.__clearHistory)
+self.tr(
+"""<b>Clear History</b>""" """<p>Clears the refactoring history.</p>"""
+)
+)
+self.refactoringClearHistoryAct.triggered.connect(self.__clearHistory)
 self.actions.append(self.refactoringClearHistoryAct)
 #####################################################
 ## Query actions
 #####################################################
 self.queryReferencesAct = EricAction(
-self.tr('Find occurrences'),
+self.tr("Find occurrences"),
-self.tr('Find &Occurrences'),
+self.tr("Find &Occurrences"),
-0, 0,
+0,
-self, 'refactoring_find_occurrences')
+0,
-self.queryReferencesAct.setStatusTip(self.tr(
+self,
-'Find occurrences of the highlighted object'))
+"refactoring_find_occurrences",
-self.queryReferencesAct.setWhatsThis(self.tr(
+)
-"""<b>Find occurrences</b>"""
+self.queryReferencesAct.setStatusTip(
-"""<p>Find occurrences of the highlighted class, method,"""
+self.tr("Find occurrences of the highlighted object")
-""" function or variable.</p>"""
+)
-))
+self.queryReferencesAct.setWhatsThis(
-self.queryReferencesAct.triggered.connect(
+self.tr(
-self.__queryReferences)
+"""<b>Find occurrences</b>"""
+"""<p>Find occurrences of the highlighted class, method,"""
+""" function or variable.</p>"""
+)
+)
+self.queryReferencesAct.triggered.connect(self.__queryReferences)
 self.actions.append(self.queryReferencesAct)
 self.queryDefinitionAct = EricAction(
-self.tr('Find definition'),
+self.tr("Find definition"),
-self.tr('Find &Definition'),
+self.tr("Find &Definition"),
-0, 0,
+0,
-self, 'refactoring_find_definition')
+0,
-self.queryDefinitionAct.setStatusTip(self.tr(
+self,
-'Find definition of the highlighted item'))
+"refactoring_find_definition",
-self.queryDefinitionAct.setWhatsThis(self.tr(
+)
-"""<b>Find definition</b>"""
+self.queryDefinitionAct.setStatusTip(
-"""<p>Find the definition of the highlighted class, method,"""
+self.tr("Find definition of the highlighted item")
-""" function or variable.</p>"""
+)
-))
+self.queryDefinitionAct.setWhatsThis(
-self.queryDefinitionAct.triggered.connect(
+self.tr(
-self.__queryDefinition)
+"""<b>Find definition</b>"""
+"""<p>Find the definition of the highlighted class, method,"""
+""" function or variable.</p>"""
+)
+)
+self.queryDefinitionAct.triggered.connect(self.__queryDefinition)
 self.actions.append(self.queryDefinitionAct)
 self.queryImplementationsAct = EricAction(
-self.tr('Find implementations'),
+self.tr("Find implementations"),
-self.tr('Find &Implementations'),
+self.tr("Find &Implementations"),
-0, 0,
+0,
-self, 'refactoring_find_implementations')
+0,
-self.queryImplementationsAct.setStatusTip(self.tr(
+self,
-'Find places where the selected method is overridden'))
+"refactoring_find_implementations",
-self.queryImplementationsAct.setWhatsThis(self.tr(
+)
-"""<b>Find implementations</b>"""
+self.queryImplementationsAct.setStatusTip(
-"""<p>Find places where the selected method is overridden.</p>"""
+self.tr("Find places where the selected method is overridden")
-))
+)
-self.queryImplementationsAct.triggered.connect(
+self.queryImplementationsAct.setWhatsThis(
-self.__queryImplementations)
+self.tr(
+"""<b>Find implementations</b>"""
+"""<p>Find places where the selected method is overridden.</p>"""
+)
+)
+self.queryImplementationsAct.triggered.connect(self.__queryImplementations)
 self.actions.append(self.queryImplementationsAct)
 #####################################################
 ## Various actions
 #####################################################
 self.refactoringEditConfigAct = EricAction(
-self.tr('Configure Rope'),
+self.tr("Configure Rope"),
-self.tr('&Configure Rope'),
+self.tr("&Configure Rope"),
-0, 0,
+0,
-self, 'refactoring_edit_config')
+0,
-self.refactoringEditConfigAct.setStatusTip(self.tr(
+self,
-'Open the rope configuration file'))
+"refactoring_edit_config",
-self.refactoringEditConfigAct.setWhatsThis(self.tr(
+)
-"""<b>Configure Rope</b>"""
+self.refactoringEditConfigAct.setStatusTip(
-"""<p>Opens the rope configuration file in an editor.</p>"""
+self.tr("Open the rope configuration file")
-))
+)
-self.refactoringEditConfigAct.triggered.connect(
+self.refactoringEditConfigAct.setWhatsThis(
-self.__editConfig)
+self.tr(
+"""<b>Configure Rope</b>"""
+"""<p>Opens the rope configuration file in an editor.</p>"""
+)
+)
+self.refactoringEditConfigAct.triggered.connect(self.__editConfig)
 self.refactoringEditConfigAct.setMenuRole(QAction.MenuRole.NoRole)
 self.actions.append(self.refactoringEditConfigAct)
 self.refactoringHelpAct = EricAction(
-self.tr('Rope Help'),
+self.tr("Rope Help"), self.tr("Rope &Help"), 0, 0, self, "refactoring_help"
-self.tr('Rope &Help'),
+)
-0, 0,
+self.refactoringHelpAct.setStatusTip(
-self, 'refactoring_help')
+self.tr("Show help about the rope refactorings")
-self.refactoringHelpAct.setStatusTip(self.tr(
+)
-'Show help about the rope refactorings'))
+self.refactoringHelpAct.setWhatsThis(
-self.refactoringHelpAct.setWhatsThis(self.tr(
+self.tr(
 """<b>Rope help</b>"""
 """<p>Show some help text about the rope refactorings.</p>"""
-))
+)
-self.refactoringHelpAct.triggered.connect(
+)
-self.__showRopeHelp)
+self.refactoringHelpAct.triggered.connect(self.__showRopeHelp)
 self.actions.append(self.refactoringHelpAct)
 self.refactoringAllSoaAct = EricAction(
-self.tr('Analyse all modules'),
+self.tr("Analyse all modules"),
-self.tr('&Analyse all modules'),
+self.tr("&Analyse all modules"),
-0, 0,
+0,
-self, 'refactoring_analyze_all')
+0,
-self.refactoringAllSoaAct.setStatusTip(self.tr(
+self,
-'Perform static object analysis on all modules'))
+"refactoring_analyze_all",
-self.refactoringAllSoaAct.setWhatsThis(self.tr(
+)
-"""<b>Analyse all modules</b>"""
+self.refactoringAllSoaAct.setStatusTip(
-"""<p>Perform static object analysis (SOA) on all modules. """
+self.tr("Perform static object analysis on all modules")
-"""This might be time consuming. Analysis of all modules """
+)
-"""should only be neccessary, if the project was created """
+self.refactoringAllSoaAct.setWhatsThis(
-"""with the rope plugin disabled or if files were added.</p>"""
+self.tr(
-))
+"""<b>Analyse all modules</b>"""
-self.refactoringAllSoaAct.triggered.connect(
+"""<p>Perform static object analysis (SOA) on all modules. """
-self.__performSOA)
+"""This might be time consuming. Analysis of all modules """
+"""should only be neccessary, if the project was created """
+"""with the rope plugin disabled or if files were added.</p>"""
+)
+)
+self.refactoringAllSoaAct.triggered.connect(self.__performSOA)
 self.actions.append(self.refactoringAllSoaAct)
 self.updateConfigAct = EricAction(
-self.tr('Update Configuration'),
+self.tr("Update Configuration"),
-self.tr('&Update Configuration'),
+self.tr("&Update Configuration"),
-0, 0,
+0,
-self, 'refactoring_update_configuration')
+0,
-self.updateConfigAct.setStatusTip(self.tr(
+self,
-'Generates a new configuration file overwriting the current one.'))
+"refactoring_update_configuration",
-self.updateConfigAct.setWhatsThis(self.tr(
+)
-"""<b>Update Configuration</b>"""
+self.updateConfigAct.setStatusTip(
-"""<p>Generates a new configuration file overwriting"""
+self.tr("Generates a new configuration file overwriting the current one.")
-""" the current one.</p>"""
+)
-))
+self.updateConfigAct.setWhatsThis(
-self.updateConfigAct.triggered.connect(
+self.tr(
-self.__updateConfig)
+"""<b>Update Configuration</b>"""
+"""<p>Generates a new configuration file overwriting"""
+""" the current one.</p>"""
+)
+)
+self.updateConfigAct.triggered.connect(self.__updateConfig)
 self.actions.append(self.updateConfigAct)
 for act in self.actions:
 act.setEnabled(False)
 def __initMenu(self):
 """
 Private slot to initialize the refactoring menu.
 @return the menu generated
 @rtype QMenu
 """
-menu = QMenu(self.tr('&Refactoring'), self.__ui)
+menu = QMenu(self.tr("&Refactoring"), self.__ui)
 menu.setTearOffEnabled(True)
-act = menu.addAction('rope', self.__ropeInfo)
+act = menu.addAction("rope", self.__ropeInfo)
 font = act.font()
 font.setBold(True)
 act.setFont(font)
 menu.addSeparator()
 smenu = menu.addMenu(self.tr("&Query"))
 smenu.addAction(self.queryReferencesAct)
 smenu.addAction(self.queryDefinitionAct)
 smenu.addAction(self.queryImplementationsAct)
 smenu = menu.addMenu(self.tr("&Refactoring"))
 smenu.addAction(self.refactoringRenameAct)
 smenu.addAction(self.refactoringRenameLocalAct)
 smenu.addAction(self.refactoringChangeOccurrencesAct)
 smenu.addSeparator()
 smenu.addSeparator()
 smenu.addAction(self.refactoringRenameModuleAct)
 smenu.addAction(self.refactoringMoveModuleAct)
 smenu.addAction(self.refactoringTransformModuleAct)
 smenu.addSeparator()
 imenu = smenu.addMenu(self.tr("Im&ports"))
 imenu.addAction(self.refactoringImportsOrganizeAct)
 imenu.addAction(self.refactoringImportsStarExpandAct)
 imenu.addAction(self.refactoringImportsRelativeToAbsoluteAct)
 imenu.addAction(self.refactoringImportsFromsToImportsAct)
 imenu.addAction(self.refactoringImportsHandleLongAct)
 smenu.addSeparator()
 hmenu = smenu.addMenu(self.tr("History"))
 hmenu.aboutToShow.connect(self.__showRefactoringHistoryMenu)
 hmenu.addAction(self.refactoringProjectHistoryAct)
 hmenu.addAction(self.refactoringFileHistoryAct)
 hmenu.addSeparator()
 hmenu.addAction(self.refactoringClearHistoryAct)
 smenu = menu.addMenu(self.tr("&Utilities"))
 smenu.addAction(self.refactoringAllSoaAct)
 smenu.addSeparator()
 smenu.addAction(self.updateConfigAct)
 menu.addSeparator()
 menu.addAction(self.refactoringEditConfigAct)
 menu.addAction(self.refactoringHelpAct)
 return menu
 ##################################################################
 ## slots below implement general functionality
 ##################################################################
 def __ropeInfo(self):
 """
 Private slot to show some info about rope.
 """
 if self.__ropeConfig:
 EricMessageBox.about(
 self.__ui,
 self.tr("About rope"),
-self.tr("{0}\nVersion {1}\n\n{2}".format(
+self.tr(
-self.__ropeConfig["RopeInfo"],
+"{0}\nVersion {1}\n\n{2}".format(
-self.__ropeConfig["RopeVersion"],
+self.__ropeConfig["RopeInfo"],
-self.__ropeConfig["RopeCopyright"])))
+self.__ropeConfig["RopeVersion"],
+self.__ropeConfig["RopeCopyright"],
+)
+),
+)
 def __showRefactoringHistoryMenu(self):
 """
 Private slot called before the refactoring history menu is shown.
 """
 aw = self.__vm.activeWindow()
 enable = aw is not None and bool(aw.getFileName())
 self.refactoringFileHistoryAct.setEnabled(enable)
 def handleRopeError(self, result):
 """
 Public method to handle a rope error.
 @param result dictionary containing the error information
 @type dict
 @return flag indicating, that the error is to be ignored
 @rtype bool
 """
 if "Error" not in result:
 return True
 title = result.get("Title", self.tr("Rope Error"))
-if result["Error"] == 'ModuleSyntaxError':
+if result["Error"] == "ModuleSyntaxError":
 res = EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Rope error: {0}").format(
+title,
-result["ErrorString"]),
+self.tr("Rope error: {0}").format(result["ErrorString"]),
-EricMessageBox.Ok | EricMessageBox.Open)
+EricMessageBox.Ok | EricMessageBox.Open,
+)
 if res == EricMessageBox.Open:
 self.__vm.openSourceFile(
-os.path.join(self.__ericProject.getProjectPath(),
+os.path.join(
-result["ErrorFile"]),
+self.__ericProject.getProjectPath(), result["ErrorFile"]
-result["ErrorLine"])
+),
+result["ErrorLine"],
+)
 elif result["Error"] == "InterruptedTaskError":
 return True
 else:
 from .ErrorDialog import ErrorDialog
 ErrorDialog(
 title,
 self.tr("Rope error: {0}").format(result["ErrorString"]),
 traceback=result["Traceback"],
-parent=self.__ui
+parent=self.__ui,
 ).exec()
 return False
 def __getOffset(self, editor, line, index):
 r"""
 Private method to get the offset into the text treating CRLF as ONE
 character.
 Note: rope seems to convert all EOL styles to just \n.
 @param editor reference to the editor
 @type Editor
 @param line line for the offset
 @type int
 @param index index into line for the offset
 return offset
 ##################################################################
 ## slots below implement the various refactorings
 ##################################################################
 def __processChanges(self, result):
 """
 Private method to process the changes data sent by the refactoring
 client.
 @param result dictionary containing the changes data
 @type dict
 """
 if self.handleRopeError(result):
 changeGroup = result["ChangeGroup"]
 with contextlib.suppress(KeyError):
-self.__refactoringDialogs[changeGroup].processChangeData(
+self.__refactoringDialogs[changeGroup].processChangeData(result)
-result)
 def __refactoringDialogClosed(self, changeGroup):
 """
 Private slot handling the closing of a refactoring dialog.
 @param changeGroup name of the refactoring change group the dialog
 belonged to
 @type str
 """
 with contextlib.suppress(KeyError):
 del self.__refactoringDialogs[changeGroup]
 #####################################################
 ## Rename refactorings
 #####################################################
 def __rename(self):
 """
 Private slot to handle the Rename action.
 """
-self.__doRename(self.tr('Rename'))
+self.__doRename(self.tr("Rename"))
 def __renameLocal(self):
 """
 Private slot to handle the Local Rename action.
 """
-self.__doRename(self.tr('Local Rename'), isLocal=True)
+self.__doRename(self.tr("Local Rename"), isLocal=True)
 def __renameModule(self):
 """
 Private slot to handle the Rename Current Module action.
 """
-self.__doRename(self.tr('Rename Current Module'),
+self.__doRename(self.tr("Rename Current Module"), renameModule=True)
-renameModule=True)
 def __doRename(self, title, isLocal=False, renameModule=False):
 """
 Private method to perform the various renaming refactorings.
 @param title title of the refactoring
 @type str
 @param isLocal flag indicating to restrict refactoring to
 the local file
 @type bool
 @param renameModule flag indicating a module rename refactoring
 @type bool
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 if not renameModule and not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the declaration you want to rename"
+title,
-" and try again."))
+self.tr(
-return
+"Highlight the declaration you want to rename" " and try again."
+),
+)
+return
 if isLocal:
 if not self.confirmBufferIsSaved(aw):
 return
 else:
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 if renameModule:
 offset = None
 if os.path.basename(filename) == "__init__.py":
 filename = os.path.dirname(filename)
 else:
 line, index, line1, index1 = aw.getSelection()
 if line != line1:
 # selection span more than one line
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("The selection must not extend beyond"
+title,
-" one line."))
+self.tr("The selection must not extend beyond" " one line."),
+)
 return
 index = int(index + (index1 - index) / 2)
 # keep it inside the object
 offset = self.__getOffset(aw, line, index)
 selectedText = aw.selectedText()
 from .RenameDialog import RenameDialog
-dlg = RenameDialog(self, title, filename, offset, isLocal,
-selectedText=selectedText, parent=self.__ui)
+dlg = RenameDialog(
+self,
+title,
+filename,
+offset,
+isLocal,
+selectedText=selectedText,
+parent=self.__ui,
+)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __changeOccurrences(self):
 """
 Private slot to perform the Change Occurrences refactoring.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Change Occurrences")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight an occurrence to be changed"
+title,
-" and try again."))
+self.tr("Highlight an occurrence to be changed" " and try again."),
-return
+)
+return
 if not self.confirmBufferIsSaved(aw):
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .ChangeOccurrencesDialog import ChangeOccurrencesDialog
-dlg = ChangeOccurrencesDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = ChangeOccurrencesDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Extract refactorings
 #####################################################
 def __extractMethod(self):
 """
 Private slot to handle the Extract Method action.
 """
 self.__doExtract(self.tr("Extract Method"), "method")
 def __extractLocalVariable(self):
 """
 Private slot to handle the Extract Local Variable action.
 """
 self.__doExtract(self.tr("Extract Local Variable"), "variable")
 def __doExtract(self, title, kind):
 """
 Private method to perform the extract refactoring.
 @param title title of the refactoring
 @type str
 @param kind kind of extraction to be done
 @type str ("method" or "variable")
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the region of code you want to extract"
+title,
-" and try again."))
+self.tr(
-return
+"Highlight the region of code you want to extract" " and try again."
+),
+)
+return
 if not self.confirmBufferIsSaved(aw):
 return
 filename = aw.getFileName()
 startline, startcolumn, endline, endcolumn = aw.getSelection()
 startOffset = self.__getOffset(aw, startline, startcolumn)
 endOffset = self.__getOffset(aw, endline, endcolumn)
 from .ExtractDialog import ExtractDialog
-dlg = ExtractDialog(self, title, filename, startOffset, endOffset,
-kind, parent=self.__ui)
+dlg = ExtractDialog(
+self, title, filename, startOffset, endOffset, kind, parent=self.__ui
+)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Inline refactorings
 #####################################################
 def __inline(self):
 """
 Private slot to handle the Inline Local Variable action.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Inline")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the local variable, method or parameter"
+title,
-" you want to inline and try again."))
+self.tr(
-return
+"Highlight the local variable, method or parameter"
+" you want to inline and try again."
+),
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .InlineDialog import InlineDialog
 dlg = InlineDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Move refactorings
 #####################################################
 def __move(self, moveKind):
 """
 Private slot to handle the Move Method action.
 @param moveKind kind of move to be performed
 @type str (one of 'move_method' or 'move_module')
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 if moveKind == "move_method":
 title = self.tr("Move Method")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the method to move"
+title,
-" and try again."))
+self.tr("Highlight the method to move" " and try again."),
+)
 return
 else:
 title = self.tr("Move Current Module")
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 if moveKind == "move_method":
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 else:
 offset = None
 from .MoveDialog import MoveDialog
 dlg = MoveDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Use function refactoring
 #####################################################
 def __useFunction(self):
 """
 Private slot to use a function wherever possible.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Use Function")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui, title, self.tr("Highlight a global function and try again.")
-self.tr("Highlight a global function and try again."))
+)
 return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .UseFunctionDialog import UseFunctionDialog
-dlg = UseFunctionDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = UseFunctionDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Introduce refactorings
 #####################################################
 def __introduceFactoryMethod(self):
 """
 Private slot to introduce a factory method or global function.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Introduce Factory Method")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the class to introduce a factory"
+title,
-" method for and try again."))
+self.tr(
-return
+"Highlight the class to introduce a factory"
+" method for and try again."
+),
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .IntroduceFactoryDialog import IntroduceFactoryDialog
-dlg = IntroduceFactoryDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = IntroduceFactoryDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __introduceParameter(self):
 """
 Private slot to introduce a parameter in a function.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Introduce Parameter")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the code for the new parameter"
+title,
-" and try again."))
+self.tr("Highlight the code for the new parameter" " and try again."),
-return
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .IntroduceParameterDialog import IntroduceParameterDialog
-dlg = IntroduceParameterDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = IntroduceParameterDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Import refactorings
 #####################################################
 def __importsOrganize(self):
 """
 Private slot to organize imports.
 """
-self.__doImports(
+self.__doImports(self.tr("Organize Imports"), "organize_imports")
-self.tr("Organize Imports"),
-"organize_imports")
 def __importsExpandStar(self):
 """
 Private slot to expand star imports.
 """
-self.__doImports(
+self.__doImports(self.tr("Expand Star Imports"), "expand_star_imports")
-self.tr("Expand Star Imports"),
-"expand_star_imports")
 def __importsRelativeToAbsolute(self):
 """
 Private slot to transform relative to absolute imports.
 """
-self.__doImports(
+self.__doImports(self.tr("Relative to Absolute"), "relatives_to_absolutes")
-self.tr("Relative to Absolute"),
-"relatives_to_absolutes")
 def __importsFromToImport(self):
 """
 Private slot to transform from imports to plain imports.
 """
-self.__doImports(
+self.__doImports(self.tr("Froms to Imports"), "froms_to_imports")
-self.tr("Froms to Imports"),
-"froms_to_imports")
 def __importsHandleLong(self):
 """
 Private slot to handle long imports.
 """
-self.__doImports(
+self.__doImports(self.tr("Handle Long Imports"), "handle_long_imports")
-self.tr("Handle Long Imports"),
-"handle_long_imports")
 def __doImports(self, title, methodName):
 """
 Private method to perform the various imports refactorings.
 @param title title to be used for the import refactoring
 @type str
 @param methodName name of the method performing the import refactoring
 @type str
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 if not self.confirmBufferIsSaved(aw):
 return
 filename = aw.getFileName()
 if aw.hasSelectedText():
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 else:
 offset = None
 from .ConfirmationDialog import ConfirmationDialog
 dlg = ConfirmationDialog(
-self, title, "Imports", "CalculateImportsChanges", {
+self,
+title,
+"Imports",
+"CalculateImportsChanges",
+{
 "MethodName": methodName,
 "FileName": filename,
 "Offset": offset,
 },
-parent=self.__ui)
+parent=self.__ui,
+)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Various refactorings
 #####################################################
 def __restructure(self):
 """
 Private slot to restructure code.
 """
 from .RestructureDialog import RestructureDialog
 title = self.tr("Restructure")
 dlg = RestructureDialog(self, title, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __changeSignature(self):
 """
 Private slot to change the signature of a method or function.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Change Method Signature")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the method or function to change"
+title,
-" and try again."))
+self.tr("Highlight the method or function to change" " and try again."),
-return
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .ChangeSignatureDialog import ChangeSignatureDialog
-dlg = ChangeSignatureDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = ChangeSignatureDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __inlineArgumentDefault(self):
 """
 Private slot to inline the default value of a parameter of a
 method or function.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Inline Argument Default")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the method or function to inline"
+title,
-" a parameter's default and try again."))
+self.tr(
-return
+"Highlight the method or function to inline"
+" a parameter's default and try again."
+),
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .InlineArgumentDefaultDialog import InlineArgumentDefaultDialog
-dlg = InlineArgumentDefaultDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = InlineArgumentDefaultDialog(
+self, title, filename, offset, parent=self.__ui
+)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __transformModuleToPackage(self):
 """
 Private slot to transform a module to a package.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Transform Module to Package")
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 from .ConfirmationDialog import ConfirmationDialog
 dlg = ConfirmationDialog(
-self, title, "ModuleToPackage", "CalculateModuleToPackageChanges",
+self,
+title,
+"ModuleToPackage",
+"CalculateModuleToPackageChanges",
 {
 "FileName": filename,
 },
-parent=self.__ui)
+parent=self.__ui,
+)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __encapsulateAttribute(self):
 """
 Private slot to encapsulate an attribute.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Encapsulate Attribute")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the attribute to encapsulate"
+title,
-" and try again."))
+self.tr("Highlight the attribute to encapsulate" " and try again."),
-return
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .GetterSetterDialog import GetterSetterDialog
-dlg = GetterSetterDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = GetterSetterDialog(self, title, filename, offset, parent=self.__ui)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __convertLocalToAttribute(self):
 """
 Private slot to convert a local variable to an attribute.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Local Variable to Attribute")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the local variable to make an attribute"
+title,
-" and try again."))
+self.tr(
-return
+"Highlight the local variable to make an attribute"
+" and try again."
+),
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .ConfirmationDialog import ConfirmationDialog
 dlg = ConfirmationDialog(
-self, title, "LocalToAttribute",
+self,
-"CalculateLocalToAttributeChanges", {
+title,
+"LocalToAttribute",
+"CalculateLocalToAttributeChanges",
+{
 "FileName": filename,
 "Offset": offset,
 },
-parent=self.__ui)
+parent=self.__ui,
+)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 def __methodToMethodObject(self):
 """
 Private slot to change the signature of a method or function.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Replace Method With Method Object")
 if not aw.hasSelectedText():
 # no selection available
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui,
-self.tr("Highlight the method or function to convert"
+title,
-" and try again."))
+self.tr(
-return
+"Highlight the method or function to convert" " and try again."
+),
+)
+return
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index, line1, index1 = aw.getSelection()
 offset = self.__getOffset(aw, line, index)
 from .MethodToMethodObjectDialog import MethodToMethodObjectDialog
-dlg = MethodToMethodObjectDialog(self, title, filename, offset,
-parent=self.__ui)
+dlg = MethodToMethodObjectDialog(
+self, title, filename, offset, parent=self.__ui
+)
 changeGroup = dlg.getChangeGroupName()
 self.__refactoringDialogs[changeGroup] = dlg
-dlg.finished.connect(
+dlg.finished.connect(lambda: self.__refactoringDialogClosed(changeGroup))
-lambda: self.__refactoringDialogClosed(changeGroup))
 dlg.show()
 #####################################################
 ## Refactoring History
 #####################################################
 def __showProjectHistory(self):
 """
 Private method to show the project refactoring history.
 """
 if self.__historyDialog is not None:
 self.__historyDialog.close()
 from .HistoryDialog import HistoryDialog
 self.__historyDialog = HistoryDialog(self, parent=self.__ui)
 self.__historyDialog.finished.connect(self.__historyDialogClosed)
 self.__historyDialog.show()
 def __showFileHistory(self):
 """
 Private method to show the refactoring history of the current file.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 if self.__historyDialog is not None:
 self.__historyDialog.close()
 from .HistoryDialog import HistoryDialog
 filename = aw.getFileName()
 if filename:
 self.__historyDialog = HistoryDialog(
-self, filename=filename, parent=self.__ui)
+self, filename=filename, parent=self.__ui
+)
 self.__historyDialog.show()
 def __clearHistory(self):
 """
 Private slot to clear the redo and undo lists.
 """
 res = EricMessageBox.yesNo(
 None,
 self.tr("Clear History"),
-self.tr("Do you really want to clear the refactoring history?"))
+self.tr("Do you really want to clear the refactoring history?"),
+)
 if res:
-self.sendJson("History", {
+self.sendJson(
-"Subcommand": "Clear",
+"History",
-})
+{
+"Subcommand": "Clear",
+},
+)
 if self.__historyDialog is not None:
 self.__historyDialog.historyCleared()
 def __processHistoryResult(self, result):
 """
 Private method to process the history data sent by the refactoring
 client.
 @param result dictionary containing the history data
 @type dict
 """
 if self.handleRopeError(result) and self.__historyDialog is not None:
 self.__historyDialog.processHistoryCommand(result)
 def __historyDialogClosed(self):
 """
 Private slot handling the closing of the history dialog.
 """
 self.__historyDialog = None
 #####################################################
 ## Find actions including mouse click handler
 #####################################################
 def __queryReferences(self):
 """
 Private slot to handle the Find References action.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Find Occurrences")
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index = aw.getCursorPosition()
 offset = self.__getOffset(aw, line, index)
-self.sendJson("QueryReferences", {
+self.sendJson(
-"Title": title,
+"QueryReferences",
-"FileName": filename,
+{
-"Offset": offset,
+"Title": title,
-})
+"FileName": filename,
+"Offset": offset,
+},
+)
 def __queryReferencesResult(self, result):
 """
 Private method to handle the "Query References" result sent by
 the client.
 @param result dictionary containing the result data
 @type dict
 """
 if self.handleRopeError(result):
 title = result["Title"]
 if result["EntriesCount"] > 0:
 from .MatchesDialog import MatchesDialog
 self.dlg = MatchesDialog(self.__ui, True)
 self.dlg.show()
 for occurrence in result["Entries"]:
 self.dlg.addEntry(
 # file name, lineno, unsure
-occurrence[0], occurrence[1], occurrence[2])
+occurrence[0],
+occurrence[1],
+occurrence[2],
+)
 else:
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui, title, self.tr("No occurrences found.")
-self.tr("No occurrences found."))
+)
 def __queryDefinition(self):
 """
 Private slot to handle the Find Definition action.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Find Definition")
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index = aw.getCursorPosition()
 offset = self.__getOffset(aw, line, index)
-self.sendJson("QueryDefinition", {
+self.sendJson(
-"Title": title,
+"QueryDefinition",
-"FileName": filename,
+{
-"Offset": offset,
+"Title": title,
-"Source": aw.text(),
+"FileName": filename,
-})
+"Offset": offset,
+"Source": aw.text(),
+},
+)
 def __queryDefinitionResult(self, result):
 """
 Private method to handle the "Query Definition" result sent by
 the client.
 @param result dictionary containing the result data
 @type dict
 """
 if self.handleRopeError(result):
 title = result["Title"]
 if "Location" in result:
 location = result["Location"]
 from .MatchesDialog import MatchesDialog
 self.dlg = MatchesDialog(self.__ui, False)
 self.dlg.show()
 self.dlg.addEntry(location[0], location[1])
 # file name, lineno
 else:
 EricMessageBox.warning(
-self.__ui, title,
+self.__ui, title, self.tr("No matching definition found.")
-self.tr("No matching definition found."))
+)
 def __queryImplementations(self):
 """
 Private slot to handle the Find Implementations action.
 """
 aw = self.__vm.activeWindow()
 if aw is None:
 return
 title = self.tr("Find Implementations")
 if not self.confirmAllBuffersSaved():
 return
 filename = aw.getFileName()
 line, index = aw.getCursorPosition()
 offset = self.__getOffset(aw, line, index)
-self.sendJson("QueryImplementations", {
+self.sendJson(
-"Title": title,
+"QueryImplementations",
-"FileName": filename,
+{
-"Offset": offset,
+"Title": title,
-})
+"FileName": filename,
+"Offset": offset,
+},
+)
 def __queryImplementationsResult(self, result):
 """
 Private method to handle the "Query Implementations" result sent by
 the client.
 @param result dictionary containing the result data
 @type dict
 """
 if self.handleRopeError(result):
 title = result["Title"]
 if result["EntriesCount"] > 0:
 from .MatchesDialog import MatchesDialog
 self.dlg = MatchesDialog(self.__ui, True)
 self.dlg.show()
 for occurrence in result["Entries"]:
 self.dlg.addEntry(
 # file name, lineno, unsure
-occurrence[0], occurrence[1], occurrence[2])
+occurrence[0],
+occurrence[1],
+occurrence[2],
+)
 else:
 EricMessageBox.warning(
-self.__ui, title, self.tr("No implementations found."))
+self.__ui, title, self.tr("No implementations found.")
+)
 #####################################################
 ## Various actions
 #####################################################
 def __editConfig(self):
 """
 Private slot to open the rope configuration file in an editor.
 """
 ropedir = self.__ropeConfig["RopeFolderName"]
 configfile = ""
 if ropedir and os.path.exists(ropedir):
 configfile = os.path.join(ropedir, "config.py")
 if os.path.exists(configfile):
 from QScintilla.MiniEditor import MiniEditor
 self.__editor = MiniEditor(configfile)
 self.__editor.show()
 self.__editor.editorSaved.connect(self.__configChanged)
 else:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Configure Rope"),
-self.tr("""The Rope configuration file '{0}' does"""
+self.tr(
-""" not exist.""").format(configfile))
+"""The Rope configuration file '{0}' does""" """ not exist."""
+).format(configfile),
+)
 else:
 EricMessageBox.critical(
 self.__ui,
 self.tr("Configure Rope"),
-self.tr("""The Rope admin directory does not exist."""))
+self.tr("""The Rope admin directory does not exist."""),
+)
 def __updateConfig(self):
 """
 Private slot to update the configuration file.
 """
 res = EricMessageBox.yesNo(
 self.__ui,
 self.tr("Update Configuration"),
-self.tr("""Shall rope's current configuration be replaced """
+self.tr(
-"""by a new default configuration?"""))
+"""Shall rope's current configuration be replaced """
+"""by a new default configuration?"""
+),
+)
 if res:
 src = self.__defaultConfig()
 cname = self.__ropeConfigFile()
 if src != "" and cname is not None:
 try:
 self.__editConfig()
 except OSError as err:
 EricMessageBox.critical(
 None,
 self.tr("Update Configuration"),
-self.tr("""<p>The configuration could not be"""
+self.tr(
-""" updated.</p><p>Reason: {0}</p>""")
+"""<p>The configuration could not be"""
-.format(str(err)))
+""" updated.</p><p>Reason: {0}</p>"""
+).format(str(err)),
+)
 def __showRopeHelp(self):
 """
 Private slot to show help about the refactorings offered by Rope.
 """
 if self.__helpDialog is None:
 from .HelpDialog import HelpDialog
 self.__helpDialog = HelpDialog(
 self.tr("Help about rope refactorings"),
-self.__ropeConfig["RopeHelpFile"]
+self.__ropeConfig["RopeHelpFile"],
 )
 self.__helpDialog.show()
 def __performSOA(self):
 """
 Private slot to perform SOA on all modules.
 """
 title = self.tr("Analyse all modules")
 res = EricMessageBox.yesNo(
 self.__ui,
 title,
-self.tr("""This action might take some time. """
+self.tr(
-"""Do you really want to perform SOA?"""))
+"""This action might take some time. """
+"""Do you really want to perform SOA?"""
+),
+)
 if res:
-self.sendJson("PerformSoa", {
+self.sendJson(
-"Title": title,
+"PerformSoa",
-})
+{
+"Title": title,
+},
+)
 def __soaFinished(self, result):
 """
 Private method to handle the "Soa Finished" result sent by
 the client.
 @param result dictionary containing the result data
 @type dict
 """
 if self.handleRopeError(result):
 title = result["Title"]
 EricMessageBox.information(
 self.__ui,
 title,
-self.tr("""Static object analysis (SOA) done. """
+self.tr(
-"""SOA database updated."""))
+"""Static object analysis (SOA) done. """
+"""SOA database updated."""
+),
+)
 ##################################################################
 ## methods below are private utility methods
 ##################################################################
 def __processProgress(self, params):
 """
 Private method to handle Progress commands.
 @param params dictionary containing the progress data
 @type dict
 """
 subcommand = params["Subcommand"]
 if subcommand == "Init":
 if self.__progressDialog is not None:
 self.__progressDialog.reset()
 progressDialog = RopeProgressDialog(
-self, params["Title"], params["Interruptable"])
+self, params["Title"], params["Interruptable"]
+)
 progressDialog.show()
 progressDialog.raise_()
 self.__progressDialog = progressDialog
 QApplication.processEvents()
 elif subcommand == "Progress" and self.__progressDialog is not None:
 self.__progressDialog.updateProgress(params)
 self.__progressDialog.raise_()
 elif subcommand == "Reset" and self.__progressDialog is not None:
 self.__progressDialog.reset()
 def __setConfig(self, params):
 """
 Private method to set the rope client configuration data.
 @param params dictionary containing the configuration data
 @type dict
 """
 self.__ropeConfig = params
 # keys: RopeFolderName, DefaultConfig, RopeHelpFile,
 #       RopeInfo, RopeVersion, RopeCopyright, PythonVersion
 def __ropeConfigFile(self):
 """
 Private method to get the name of the rope configuration file.
 @return name of the rope configuration file
 @rtype str
 """
 configfile = None
 if self.__ropeConfig:
 if ropedir:
 configfile = os.path.join(ropedir, "config.py")
 if not os.path.exists(configfile):
 configfile = None
 return configfile
 def __configChanged(self):
 """
 Private slot called, when the rope config file has changed.
 """
 self.sendJson("ConfigChanged", {})
 def __defaultConfig(self):
 """
 Private slot to return the contents of rope's default configuration.
 @return string containing the source of rope's default
 configuration
 @rtype str
 """
 if self.__ropeConfig and "DefaultConfig" in self.__ropeConfig:
 return self.__ropeConfig["DefaultConfig"]
 else:
 return ""
 ##################################################################
 ## methods below are public utility methods
 ##################################################################
 def getActions(self):
 """
 Public method to get a list of all actions.
 @return list of all actions
 @rtype list of EricAction
 """
 return self.actions[:]
 def projectOpened(self):
 """
 Public slot to handle the projectOpened signal.
 """
 if self.__projectopen:
 self.projectClosed()
 self.__projectopen = True
 self.__projectpath = self.__ericProject.getProjectPath()
 self.__projectLanguage = self.__ericProject.getProjectLanguage()
 ok = False
 if self.__projectLanguage in ("Python3", "MicroPython", "Cython"):
 clientEnv = os.environ.copy()
 if "PATH" in clientEnv:
 clientEnv["PATH"] = self.__ui.getOriginalPathString()
 venvManager = ericApp().getObject("VirtualEnvManager")
 # get virtual environment from project first
 venvName = self.__ericProject.getDebugProperty("VIRTUALENV")
 if venvName:
 try:
 isRemote = venvManager.isRemoteEnvironment(venvName)
 isRemote = False
 else:
 isRemote = False
 if (not venvName) or isRemote:
 # get it from debugger settings next
-if self.__projectLanguage in (
+if self.__projectLanguage in ("Python3", "MicroPython", "Cython"):
-"Python3", "MicroPython", "Cython"
-):
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 if not venvName:
 venvName, _ = venvManager.getDefaultEnvironment()
 else:
 venvName = ""
 if venvName:
-interpreter = venvManager.getVirtualenvInterpreter(
+interpreter = venvManager.getVirtualenvInterpreter(venvName)
-venvName)
 execPath = venvManager.getVirtualenvExecPath(venvName)
 # build a suitable environment
 if execPath:
 if "PATH" in clientEnv:
 clientEnv["PATH"] = os.pathsep.join(
-[execPath, clientEnv["PATH"]])
+[execPath, clientEnv["PATH"]]
+)
 else:
 clientEnv["PATH"] = execPath
 else:
 interpreter = ""
 if interpreter:
 if isRemote:
-self.__ui.appendToStderr(self.tr(
+self.__ui.appendToStderr(
-"The project is configured for remote access."
+self.tr(
-" Using local interpreter instead."
+"The project is configured for remote access."
-))
+" Using local interpreter instead."
+)
+)
 ok = self.__startRefactoringClient(interpreter, clientEnv)
 if not ok:
-self.__ui.appendToStderr(self.tr(
+self.__ui.appendToStderr(
-"Project language '{0}' is not supported because"
+self.tr(
-" the configured interpreter could not be started."
+"Project language '{0}' is not supported because"
-" Refactoring is disabled."
+" the configured interpreter could not be started."
-).format(self.__projectLanguage))
+" Refactoring is disabled."
+).format(self.__projectLanguage)
+)
 else:
 for act in self.actions:
 act.setEnabled(True)
 else:
-self.__ui.appendToStderr(self.tr(
+self.__ui.appendToStderr(
-"Project language '{0}' is not supported because no"
+self.tr(
-" suitable interpreter is configured. Refactoring is"
+"Project language '{0}' is not supported because no"
-" disabled."
+" suitable interpreter is configured. Refactoring is"
-).format(self.__projectLanguage))
+" disabled."
+).format(self.__projectLanguage)
+)
 else:
-self.__ui.appendToStderr(self.tr(
+self.__ui.appendToStderr(
-"Refactoring for project language '{0}' is not supported."
+self.tr(
-).format(self.__projectLanguage))
+"Refactoring for project language '{0}' is not supported."
+).format(self.__projectLanguage)
+)
 self.__mainMenu.menuAction().setEnabled(ok)
 def projectClosed(self):
 """
 Public slot to handle the projectClosed signal.
 """
 for act in self.actions:
 act.setEnabled(False)
 self.__mainMenu.menuAction().setEnabled(False)
 if self.__helpDialog is not None:
 self.__helpDialog.close()
 self.__helpDialog = None
 if self.__historyDialog is not None:
 self.__historyDialog.close()
 self.__historyDialog = None
 for dlg in self.__refactoringDialogs.values():
 dlg.close()
 self.__refactoringDialogs = {}
 self.sendJson("CloseProject", {}, flush=True)
 self.__projectopen = False
-self.__projectpath = ''
+self.__projectpath = ""
 self.__projectLanguage = ""
 self.__ropeConfig = {}
 self.stopClient()
 def confirmBufferIsSaved(self, editor):
 """
 Public method to check, if an editor has unsaved changes.
 @param editor reference to the editor to be checked
 @type Editor
 @return flag indicating, that the editor doesn't contain
 unsaved edits
 @rtype bool
 """
 res = editor.checkDirty()
 self.sendJson("Validate", {})
 return res
 def confirmAllBuffersSaved(self):
 """
 Public method to check, if any editor has unsaved changes.
 @return flag indicating, that no editor contains unsaved edits
 @rtype bool
 """
 res = self.__vm.checkAllDirty()
 self.sendJson("Validate", {})
 return res
 def refreshEditors(self, changedFiles):
 """
 Public method to refresh modified editors.
 @param changedFiles list of changed files
 @type list of str
 """
-openFiles = [Utilities.normcasepath(f)
+openFiles = [Utilities.normcasepath(f) for f in self.__vm.getOpenFilenames()]
-for f in self.__vm.getOpenFilenames()]
 for fileName in changedFiles:
 normfile = Utilities.normcasepath(fileName)
 if normfile in openFiles:
 editor = self.__vm.getEditor(normfile)[1]
 editor.refresh()
 aw = self.__vm.activeWindow()
 if aw is not None:
 filename = aw.getFileName()
 if filename is not None:
-self.__vm.openSourceFile(filename,
+self.__vm.openSourceFile(filename, aw.getCursorPosition()[0] + 1)
-aw.getCursorPosition()[0] + 1)
 def reportChanged(self, filename, oldSource):
 """
 Public slot to report some changed sources.
 @param filename file name of the changed source
 @type str
 @param oldSource source code before the change
 @type str
 """
-if (
+if self.__ericProject.isOpen() and self.__ericProject.isProjectFile(filename):
-self.__ericProject.isOpen() and
-self.__ericProject.isProjectFile(filename)
-):
 editor = self.__vm.getOpenEditor(filename)
 if (
-self.__ropeConfig and
+self.__ropeConfig
-editor is not None and
+and editor is not None
-editor.getLanguage() == self.__ropeConfig["PythonVersion"]
+and editor.getLanguage() == self.__ropeConfig["PythonVersion"]
 ):
-self.sendJson("ReportChanged", {
+self.sendJson(
-"FileName": filename,
+"ReportChanged",
-"OldSource": oldSource,
+{
-})
+"FileName": filename,
+"OldSource": oldSource,
+},
+)
 #######################################################################
 ## Methods below handle the network connection
 #######################################################################
 def handleCall(self, method, params):
 """
 Public method to handle a method call from the client.
 @param method requested method name
 @type str
 @param params dictionary with method specific parameters
 @type dict
 """
 self.__methodMapping[method](params)
 def __processClientException(self, params):
 """
 Private method to handle exceptions of the refactoring client.
 @param params dictionary containing the exception data
 @type dict
 """
 if params["ExceptionType"] == "ProtocolError":
 EricMessageBox.critical(
 None,
 self.tr("Refactoring Protocol Error"),
-self.tr("""<p>The data received from the refactoring"""
+self.tr(
-""" server could not be decoded. Please report"""
+"""<p>The data received from the refactoring"""
-""" this issue with the received data to the"""
+""" server could not be decoded. Please report"""
-""" eric bugs email address.</p>"""
+""" this issue with the received data to the"""
-"""<p>Error: {0}</p>"""
+""" eric bugs email address.</p>"""
-"""<p>Data:<br/>{1}</p>""")
+"""<p>Error: {0}</p>"""
-.format(params["ExceptionValue"],
+"""<p>Data:<br/>{1}</p>"""
-Utilities.html_encode(params["ProtocolData"])),
+).format(
-EricMessageBox.Ok
+params["ExceptionValue"],
+Utilities.html_encode(params["ProtocolData"]),
+),
+EricMessageBox.Ok,
 )
 else:
 EricMessageBox.critical(
 None,
 self.tr("Refactoring Client Error"),
-self.tr("<p>An exception happened in the refactoring"
+self.tr(
-" client. Please report it to the eric bugs"
+"<p>An exception happened in the refactoring"
-" email address.</p>"
+" client. Please report it to the eric bugs"
-"<p>Exception: {0}</p>"
+" email address.</p>"
-"<p>Value: {1}</p>"
+"<p>Exception: {0}</p>"
-"<p>Traceback: {2}</p>")
+"<p>Value: {1}</p>"
-.format(Utilities.html_encode(params["ExceptionType"]),
+"<p>Traceback: {2}</p>"
-params["ExceptionValue"],
+).format(
-params["Traceback"].replace("\r\n", "<br/>")
+Utilities.html_encode(params["ExceptionType"]),
-.replace("\n", "<br/>").replace("\r", "<br/>")),
+params["ExceptionValue"],
-EricMessageBox.Ok
+params["Traceback"]
-)
+.replace("\r\n", "<br/>")
+.replace("\n", "<br/>")
+.replace("\r", "<br/>"),
+),
+EricMessageBox.Ok,
+)
 def __startRefactoringClient(self, interpreter, clientEnv):
 """
 Private method to start the refactoring client.
 @param interpreter interpreter to be used for the refactoring client
 @type str
 @param clientEnv dictionary with environment variables to run the
 interpreter with
 @type dict
 @return flag indicating a successful client start
 @rtype bool
 """
 if interpreter:
-client = os.path.join(os.path.dirname(__file__),
+client = os.path.join(os.path.dirname(__file__), "RefactoringClient.py")
-"RefactoringClient.py")
 ok, exitCode = self.startClient(
-interpreter, client,
+interpreter,
+client,
 [self.__projectpath, Globals.getPythonLibraryDirectory()],
-environment=clientEnv)
+environment=clientEnv,
+)
 if not ok and exitCode == 42:
-self.__ui.appendToStderr("RefactoringServer: " + self.tr(
+self.__ui.appendToStderr(
-"The rope refactoring library is not installed.\n"
+"RefactoringServer: "
-))
++ self.tr("The rope refactoring library is not installed.\n")
+)
 else:
 ok = False
 return ok

Mercurial Repositories > Rope Refactoring / file comparison

comparison: RefactoringRope/RefactoringServer.py

RefactoringRope/RefactoringServer.py