Rope Refactoring: comparison PluginRefactoringRope.py

-:a1b9b4975806
+:2af42804bca2
 from __future__ import unicode_literals
 import os
-from PyQt5.QtCore import Qt, QObject, QTranslator, QCoreApplication, QTimer
+from PyQt5.QtCore import Qt, QObject, QTranslator, QCoreApplication
 from E5Gui.E5Application import e5App
 import Preferences
 import Utilities
-from Preferences.Shortcuts import readShortcuts
 # Start-Of-Header
 name = "Refactoring Rope Plugin"
 author = "Detlev Offenbach <detlev@die-offenbachs.de>"
 autoactivate = True
 "ropeCallTipsPage": [
 QCoreApplication.translate("RefactoringRopePlugin", "Rope"),
 os.path.join("RefactoringRope", "ConfigurationPage",
 "preferences-refactoring.png"),
 createCallTipsPage, "editorCalltipsPage", None],
-}
+"ropeMouseClickHandlerPage": [
-ui = e5App().getObject("UserInterface")
-if ui.versionIsNewer("6.0.99", "20150627") or ui.versionIsNewer("16.10"):
-data["ropeMouseClickHandlerPage"] = [
 QCoreApplication.translate("RefactoringRopePlugin", "Rope"),
 os.path.join("RefactoringRope", "ConfigurationPage",
 "preferences-refactoring.png"),
-createMouseClickHandlerPage, "1editorMouseClickHandlers", None]
+createMouseClickHandlerPage, "1editorMouseClickHandlers", None],
+}
 return data
 def prepareUninstall():
 self.__initialize()
 self.__defaults = {
 "CodeAssistEnabled": False,
 "MaxFixes": 10,
-"CodeAssistTimeout": 100,
 "CodeAssistCalltipsEnabled": False,
 "CalltipsMaxFixes": 10,
 "MouseClickEnabled": True,
 "MouseClickGotoButton": int(Qt.LeftButton),
 }
 self.__translator = None
 self.__loadTranslator()
-self.__acTimer = QTimer(self)
-self.__acTimer.setSingleShot(True)
-self.__acTimer.setInterval(self.getPreferences("CodeAssistTimeout"))
-self.__acTimer.timeout.connect(self.__codeAssist)
 def __initialize(self):
 """
 Private slot to (re)initialize the plugin.
 """
-self.__object = None
+self.__refactoringServer = None
-self.__caObject = None
+self.__codeAssist = None
-self.__mainAct = None
-self.__mainMenu = None
 self.__editors = []
 self.__currentEditor = None
 self.__savedEditorName = None
 """
 Public method to activate this plugin.
 @return tuple of None and activation status (boolean)
 """
-global error
-error = ""     # clear previous error
 global refactoringRopePluginObject
 refactoringRopePluginObject = self
+from RefactoringRope.CodeAssist import CodeAssist
+self.__codeAssist = CodeAssist(self, self)
 from RefactoringRope.RefactoringServer import RefactoringServer
-from RefactoringRope.CodeAssist import CodeAssist
+self.__refactoringServer = RefactoringServer(self, self.__ui)
+self.__refactoringServer.activate()
-self.__caObject = CodeAssist(self, self)
-self.__object = RefactoringServer(self, self.__ui)
-self.__object.initActions()
-e5App().registerPluginObject("RefactoringRope", self.__object)
-try:
-readShortcuts(pluginName="RefactoringRope")
-except TypeError:
-# backwards comaytibility, ignore
-pass
-self.__mainMenu = self.__object.initMenu()
-extrasAct = self.__ui.getMenuBarAction("extras")
-self.__mainAct = self.__ui.menuBar().insertMenu(
-extrasAct, self.__mainMenu)
-self.__mainAct.setEnabled(False)
-if e5App().getObject("Project").isOpen():
-self.__object.projectOpened()
 e5App().getObject("ViewManager").editorOpenedEd.connect(
 self.__editorOpened)
 e5App().getObject("ViewManager").editorClosedEd.connect(
 self.__editorClosed)
-e5App().getObject("Project").projectOpened.connect(
-self.__object.projectOpened)
-e5App().getObject("Project").projectPropertiesChanged.connect(
-self.__object.projectOpened)
-e5App().getObject("Project").projectClosed.connect(
-self.__object.projectClosed)
-e5App().getObject("Project").newProject.connect(
-self.__object.projectOpened)
 if e5App().getObject("Project").isOpen():
 for editor in e5App().getObject("ViewManager").getOpenEditors():
 self.__editorOpened(editor)
 return None, True
 def deactivate(self):
 """
 Public method to deactivate this plugin.
 """
-e5App().unregisterPluginObject("RefactoringRope")
+self.__refactoringServer.deactivate()
 e5App().getObject("ViewManager").editorOpenedEd.disconnect(
 self.__editorOpened)
 e5App().getObject("ViewManager").editorClosedEd.disconnect(
 self.__editorClosed)
-e5App().getObject("Project").projectOpened.disconnect(
-self.__object.projectOpened)
-e5App().getObject("Project").projectPropertiesChanged.disconnect(
-self.__object.projectOpened)
-e5App().getObject("Project").projectClosed.disconnect(
-self.__object.projectClosed)
-e5App().getObject("Project").newProject.disconnect(
-self.__object.projectOpened)
-self.__ui.menuBar().removeAction(self.__mainAct)
 for editor in self.__editors[:]:
 self.__editorClosed(editor)
 self.__initialize()
 self.__editorClosed(editor)
 elif key in ["MouseClickGotoModifiers", "MouseClickGotoButton"]:
 for editor in self.__editors:
 self.__disconnectMouseClickHandler(editor)
 self.__connectMouseClickHandler(editor)
-elif key == "CodeAssistTimeout":
-self.__acTimer.setInterval(value)
+# TODO: get this info from CodeAssistClient or Server
 def __determineLanguages(self):
 """
 Private method to determine the valid language strings.
 @return list of valid language strings (list of string)
 if interpreter and Utilities.isinpath(interpreter):
 langs.extend(["Python3", "Pygments|Python 3"])
 return langs
+# TODO: move this to CodeAssist
 def __editorOpened(self, editor):
 """
 Private slot called, when a new editor was opened.
 @param editor reference to the new editor (QScintilla.Editor)
 self.__connectEditor(editor)
 editor.languageChanged.connect(self.__editorLanguageChanged)
 self.__editors.append(editor)
+# TODO: move this to CodeAssist
 def __editorClosed(self, editor):
 """
 Private slot called, when an editor was closed.
 @param editor reference to the editor (QScintilla.Editor)
 if editor in self.__editors:
 editor.languageChanged.disconnect(self.__editorLanguageChanged)
 self.__disconnectEditor(editor)
 self.__editors.remove(editor)
+# TODO: move this to CodeAssist
 def __editorLanguageChanged(self, language):
 """
 Private slot to handle the language change of an editor.
 @param language programming language of the editor (string)
 """
 editor = self.sender()
 langs = self.__determineLanguages()
 if language in langs:
-try:
+if editor.getCompletionListHook("rope") is None or \
-if editor.getCompletionListHook("rope") is None or \
+editor.getCallTipHook("rope") is None:
-editor.getCallTipHook("rope") is None:
+self.__connectEditor(editor)
-self.__connectEditor(editor)
-except AttributeError:
-# old interface (before 6.1.0)
-if editor.autoCompletionHook() != self.codeAssist or \
-editor.callTipHook() != self.codeAssistCallTip:
-self.__connectEditor(editor)
 else:
 self.__disconnectEditor(editor)
 def __connectEditor(self, editor):
 """
 @param editor reference to the editor (QScintilla.Editor)
 """
 editor.editorAboutToBeSaved.connect(self.__editorAboutToBeSaved)
 editor.editorSaved.connect(self.__editorSaved)
+# TODO: move this to CodeAssist
 if self.getPreferences("CodeAssistEnabled"):
 self.__setAutoCompletionHook(editor)
 if self.getPreferences("CodeAssistCalltipsEnabled"):
 self.__setCalltipsHook(editor)
 Private method to connect the mouse click handler to an editor.
 @param editor reference to the editor (QScintilla.Editor)
 """
 if self.getPreferences("MouseClickGotoButton"):
-try:
+editor.setMouseClickHandler(
-editor.setMouseClickHandler(
+"rope",
-"rope",
+self.getPreferences("MouseClickGotoModifiers"),
-self.getPreferences("MouseClickGotoModifiers"),
+self.getPreferences("MouseClickGotoButton"),
-self.getPreferences("MouseClickGotoButton"),
+self.__refactoringServer.gotoDefinition
-self.__object.gotoDefinition
+)
-)
-except AttributeError:
-# eric versions before 6.1.0 don't support this
-pass
 def __disconnectEditor(self, editor):
 """
 Private method to disconnect an editor.
 editor.editorSaved.disconnect(self.__editorSaved)
 except TypeError:
 # just ignore it
 pass
-try:
+# TODO: move this to CodeAssist
 if editor.getCompletionListHook("rope"):
 self.__unsetAutoCompletionHook(editor)
-except AttributeError:
+if editor.getCallTipHook("rope"):
-# old interface (before 6.1.0)
+self.__unsetCalltipsHook(editor)
-if editor.autoCompletionHook() == self.codeAssist:
-self.__unsetAutoCompletionHook(editor)
-try:
-if editor.getCallTipHook("rope"):
-self.__unsetCalltipsHook(editor)
-except AttributeError:
-# old interface (before 6.1.0)
-if editor.callTipHook() == self.codeAssistCallTip:
-self.__unsetCalltipsHook(editor)
 self.__disconnectMouseClickHandler(editor)
+# TODO: move this to CodeAssist
 def __disconnectMouseClickHandler(self, editor):
 """
 Private method to disconnect the mouse click handler from an editor.
 @param editor reference to the editor (QScintilla.Editor)
 """
-try:
+editor.removeMouseClickHandlers("rope")
-editor.removeMouseClickHandlers("rope")
-except AttributeError:
+# TODO: move this to CodeAssist
-# eric versions before 6.1.0 don't support this
-pass
-def __completionListSelected(self, userListId, txt):
-"""
-Private slot to handle the selection from the completion list.
-@param userListId the ID of the user list (should be 1) (integer)
-@param txt the selected text (QString)
-"""
-from QScintilla.Editor import EditorAutoCompletionListID
-editor = self.sender()
-if userListId == EditorAutoCompletionListID:
-lst = txt.split()
-if len(lst) > 1:
-txt = lst[0]
-if Preferences.getEditor("AutoCompletionReplaceWord"):
-editor.selectCurrentWord()
-editor.removeSelectedText()
-line, col = editor.getCursorPosition()
-else:
-line, col = editor.getCursorPosition()
-wLeft = editor.getWordLeft(line, col)
-if not txt.startswith(wLeft):
-editor.selectCurrentWord()
-editor.removeSelectedText()
-line, col = editor.getCursorPosition()
-elif wLeft:
-txt = txt[len(wLeft):]
-editor.insert(txt)
-editor.setCursorPosition(line, col + len(txt))
 def __setAutoCompletionHook(self, editor):
 """
 Private method to set the autocompletion hook.
 @param editor reference to the editor (QScintilla.Editor)
 """
-try:
+editor.addCompletionListHook("rope", self.getCompletionsList)
-editor.addCompletionListHook("rope", self.getCompletionsList)
-except AttributeError:
+# TODO: move this to CodeAssist
-# old interface (before 6.1.0)
-editor.userListActivated.connect(self.__completionListSelected)
-editor.setAutoCompletionHook(self.codeAssist)
 def __unsetAutoCompletionHook(self, editor):
 """
 Private method to unset the autocompletion hook.
 @param editor reference to the editor (QScintilla.Editor)
 """
-try:
+editor.removeCompletionListHook("rope")
-editor.removeCompletionListHook("rope")
-except AttributeError:
+# TODO: move this to CodeAssist
-# old interface (before 6.1.0)
-editor.unsetAutoCompletionHook()
-editor.userListActivated.disconnect(self.__completionListSelected)
-def codeAssist(self, editor, context=False):
-"""
-Public method to determine the autocompletion proposals.
-@param editor reference to the editor object, that called this method
-QScintilla.Editor)
-@param context flag indicating to autocomplete a context (boolean)
-"""
-self.__currentEditor = editor
-if self.getPreferences("CodeAssistTimeout"):
-self.__acTimer.stop()
-self.__acTimer.start()
-else:
-self.__codeAssist()
-def __codeAssist(self):
-"""
-Private slot to show a list with completion proposals.
-"""
-from QScintilla.Editor import EditorAutoCompletionListID
-if self.__currentEditor is not None:
-if self.__currentEditor.isListActive():
-self.__currentEditor.cancelList()
-completions = self.getCompletionsList(self.__currentEditor, False)
-if len(completions) == 0:
-# try QScintilla autocompletion
-self.__currentEditor.autoCompleteQScintilla()
-else:
-completions.sort()
-self.__currentEditor.showUserList(EditorAutoCompletionListID,
-completions)
 def getCompletionsList(self, editor, context):
 """
 Public method to get a list of possible completions.
 @param editor reference to the editor object, that called this method
 (QScintilla.Editor)
 @param context flag indicating to autocomplete a context (boolean)
 @return list of possible completions (list of strings)
 """
-completions = self.__caObject.getCompletions(editor)
+completions = self.__codeAssist.getCompletions(editor)
 return completions
 def __editorAboutToBeSaved(self, filename):
 """
 Private slot to get the old contents of the named file.
 Private slot to activate SOA.
 @param filename name of the file that was saved (string)
 """
 if filename == self.__savedEditorName and self.__oldEditorText:
-self.__object.reportChanged(self.__savedEditorName,
+self.__refactoringServer.reportChanged(self.__savedEditorName,
 self.__oldEditorText)
-self.__caObject.reportChanged(self.__savedEditorName,
+self.__codeAssist.reportChanged(self.__savedEditorName,
 self.__oldEditorText)
 else:
-self.__object.reportChanged(filename, "")
+self.__refactoringServer.reportChanged(filename, "")
-self.__caObject.reportChanged(filename, "")
+self.__codeAssist.reportChanged(filename, "")
+# TODO: move this to CodeAssist
 def __setCalltipsHook(self, editor):
 """
 Private method to set the calltip hook.
 @param editor reference to the editor (QScintilla.Editor)
 """
-try:
+editor.addCallTipHook("rope", self.codeAssistCallTip)
-editor.addCallTipHook("rope", self.codeAssistCallTip)
-except AttributeError:
+# TODO: move this to CodeAssist
-# old interface (before 6.1.0)
-editor.setCallTipHook(self.codeAssistCallTip)
 def __unsetCalltipsHook(self, editor):
 """
 Private method to unset the calltip hook.
 @param editor reference to the editor (QScintilla.Editor)
 """
-try:
+editor.removeCallTipHook("rope")
-editor.removeCallTipHook("rope")
-except AttributeError:
+# TODO: move this to CodeAssist
-# old interface (before 6.1.0)
-editor.unsetCallTipHook()
 def codeAssistCallTip(self, editor, pos, commas):
 """
 Public method to return a list of calltips.
 @param editor reference to the editor (QScintilla.Editor)
 @param pos position in the text for the calltip (integer)
 @param commas minimum number of commas contained in the calltip
 (integer)
 @return list of possible calltips (list of strings)
 """
-cts = self.__caObject.getCallTips(pos, editor)
+cts = self.__codeAssist.getCallTips(pos, editor)
 return cts
 #
 # eflag: noqa = M801

Mercurial Repositories > Rope Refactoring / file comparison

comparison: PluginRefactoringRope.py

PluginRefactoringRope.py