src/eric7/JediInterface/AssistantJedi.py

branch
eric7
changeset 9221
bf71ee032bb4
parent 9214
bd28e56047d7
child 9387
ce743c468d09
equal deleted inserted replaced
9220:e9e7eca7efee 9221:bf71ee032bb4
17 17
18 class AssistantJedi(QObject): 18 class AssistantJedi(QObject):
19 """ 19 """
20 Class implementing the Jedi assistant interface. 20 Class implementing the Jedi assistant interface.
21 """ 21 """
22
22 def __init__(self, ui, viewManager, project): 23 def __init__(self, ui, viewManager, project):
23 """ 24 """
24 Constructor 25 Constructor
25 26
26 @param ui reference to the user interface object 27 @param ui reference to the user interface object
27 @type UserInterface 28 @type UserInterface
28 @param viewManager reference to the viewmanager object 29 @param viewManager reference to the viewmanager object
29 @type ViewManager 30 @type ViewManager
30 @param project reference to the project object 31 @param project reference to the project object
31 @type Project 32 @type Project
32 """ 33 """
33 super().__init__(ui) 34 super().__init__(ui)
34 self.__ui = ui 35 self.__ui = ui
35 self.__vm = viewManager 36 self.__vm = viewManager
36 37
37 self.__jediServer = None 38 self.__jediServer = None
38 self.__editors = [] 39 self.__editors = []
39 self.__menuActions = {} 40 self.__menuActions = {}
40 41
41 from .JediServer import JediServer 42 from .JediServer import JediServer
43
42 self.__jediServer = JediServer(self.__vm, project, self.__ui) 44 self.__jediServer = JediServer(self.__vm, project, self.__ui)
43 self.__jediServer.activate() 45 self.__jediServer.activate()
44 46
45 self.__ui.preferencesChanged.connect(self.__preferencesChanged) 47 self.__ui.preferencesChanged.connect(self.__preferencesChanged)
46 48
47 self.__initRefactoringMenu() 49 self.__initRefactoringMenu()
48 50
49 self.__vm.editorOpenedEd.connect(self.__editorOpened) 51 self.__vm.editorOpenedEd.connect(self.__editorOpened)
50 self.__vm.editorClosedEd.connect(self.__editorClosed) 52 self.__vm.editorClosedEd.connect(self.__editorClosed)
51 53
52 @pyqtSlot() 54 @pyqtSlot()
53 def __preferencesChanged(self): 55 def __preferencesChanged(self):
54 """ 56 """
55 Private slot handling changes of the Disassembly viewer settings. 57 Private slot handling changes of the Disassembly viewer settings.
56 """ 58 """
57 for editor in self.__editors: 59 for editor in self.__editors:
58 self.__disconnectMouseClickHandler(editor) 60 self.__disconnectMouseClickHandler(editor)
59 self.__connectMouseClickHandler(editor) 61 self.__connectMouseClickHandler(editor)
60 62
61 def __determineLanguage(self): 63 def __determineLanguage(self):
62 """ 64 """
63 Private method to determine the valid language strings. 65 Private method to determine the valid language strings.
64 66
65 @return list of valid language strings 67 @return list of valid language strings
66 @rtype list of str 68 @rtype list of str
67 """ 69 """
68 return ["Python3", "MicroPython", 70 return [
69 "Pygments|Python", "Pygments|Python 2.x", 71 "Python3",
70 "Cython"] 72 "MicroPython",
71 73 "Pygments|Python",
74 "Pygments|Python 2.x",
75 "Cython",
76 ]
77
72 def __editorOpened(self, editor): 78 def __editorOpened(self, editor):
73 """ 79 """
74 Private slot called, when a new editor was opened. 80 Private slot called, when a new editor was opened.
75 81
76 @param editor reference to the new editor 82 @param editor reference to the new editor
77 @type Editor 83 @type Editor
78 """ 84 """
79 languages = self.__determineLanguage() 85 languages = self.__determineLanguage()
80 86
81 if editor.getLanguage() in languages: 87 if editor.getLanguage() in languages:
82 self.__connectEditor(editor) 88 self.__connectEditor(editor)
83 89
84 editor.languageChanged.connect(self.__editorLanguageChanged) 90 editor.languageChanged.connect(self.__editorLanguageChanged)
85 self.__editors.append(editor) 91 self.__editors.append(editor)
86 92
87 def __editorClosed(self, editor): 93 def __editorClosed(self, editor):
88 """ 94 """
89 Private slot called, when an editor was closed. 95 Private slot called, when an editor was closed.
90 96
91 @param editor reference to the editor 97 @param editor reference to the editor
92 @type Editor 98 @type Editor
93 """ 99 """
94 if editor in self.__editors: 100 if editor in self.__editors:
95 editor.languageChanged.disconnect(self.__editorLanguageChanged) 101 editor.languageChanged.disconnect(self.__editorLanguageChanged)
96 self.__disconnectEditor(editor) 102 self.__disconnectEditor(editor)
97 self.__editors.remove(editor) 103 self.__editors.remove(editor)
98 104
99 def __editorLanguageChanged(self, language): 105 def __editorLanguageChanged(self, language):
100 """ 106 """
101 Private slot to handle the language change of an editor. 107 Private slot to handle the language change of an editor.
102 108
103 @param language programming language of the editor 109 @param language programming language of the editor
104 @type str 110 @type str
105 """ 111 """
106 editor = self.sender() 112 editor = self.sender()
107 languages = self.__determineLanguage() 113 languages = self.__determineLanguage()
108 114
109 self.__disconnectEditor(editor) 115 self.__disconnectEditor(editor)
110 if language in languages: 116 if language in languages:
111 self.__connectEditor(editor) 117 self.__connectEditor(editor)
112 118
113 def __connectEditor(self, editor): 119 def __connectEditor(self, editor):
114 """ 120 """
115 Private method to connect an editor. 121 Private method to connect an editor.
116 122
117 @param editor reference to the editor 123 @param editor reference to the editor
118 @type Editor 124 @type Editor
119 """ 125 """
120 self.__setAutoCompletionHook(editor) 126 self.__setAutoCompletionHook(editor)
121 self.__setCalltipsHook(editor) 127 self.__setCalltipsHook(editor)
122 128
123 self.__connectMouseClickHandler(editor) 129 self.__connectMouseClickHandler(editor)
124 130
125 editor.registerMouseHoverHelpFunction( 131 editor.registerMouseHoverHelpFunction(self.__jediServer.hoverHelp)
126 self.__jediServer.hoverHelp) 132
127
128 menu = editor.getMenu("Main") 133 menu = editor.getMenu("Main")
129 if menu is not None: 134 if menu is not None:
130 checkAction = editor.getMenu("Checks").menuAction() 135 checkAction = editor.getMenu("Checks").menuAction()
131 act = menu.insertMenu(checkAction, self.__menu) 136 act = menu.insertMenu(checkAction, self.__menu)
132 self.__menuActions[editor] = [act] 137 self.__menuActions[editor] = [act]
133 editor.showMenu.connect(self.__editorShowMenu) 138 editor.showMenu.connect(self.__editorShowMenu)
134 139
135 def __disconnectEditor(self, editor): 140 def __disconnectEditor(self, editor):
136 """ 141 """
137 Private method to disconnect an editor. 142 Private method to disconnect an editor.
138 143
139 @param editor reference to the editor 144 @param editor reference to the editor
140 @type Editor 145 @type Editor
141 """ 146 """
142 self.__unsetAutoCompletionHook(editor) 147 self.__unsetAutoCompletionHook(editor)
143 self.__unsetCalltipsHook(editor) 148 self.__unsetCalltipsHook(editor)
144 149
145 self.__disconnectMouseClickHandler(editor) 150 self.__disconnectMouseClickHandler(editor)
146 151
147 editor.unregisterMouseHoverHelpFunction( 152 editor.unregisterMouseHoverHelpFunction(self.__jediServer.hoverHelp)
148 self.__jediServer.hoverHelp) 153
149
150 with contextlib.suppress(TypeError): 154 with contextlib.suppress(TypeError):
151 editor.showMenu.disconnect(self.__editorShowMenu) 155 editor.showMenu.disconnect(self.__editorShowMenu)
152 menu = editor.getMenu("Main") 156 menu = editor.getMenu("Main")
153 if menu is not None and editor in self.__menuActions: 157 if menu is not None and editor in self.__menuActions:
154 for act in self.__menuActions[editor]: 158 for act in self.__menuActions[editor]:
155 with contextlib.suppress(RuntimeError): 159 with contextlib.suppress(RuntimeError):
156 menu.removeAction(act) 160 menu.removeAction(act)
157 del self.__menuActions[editor] 161 del self.__menuActions[editor]
158 162
159 def __connectMouseClickHandler(self, editor): 163 def __connectMouseClickHandler(self, editor):
160 """ 164 """
161 Private method to connect the mouse click handler to an editor. 165 Private method to connect the mouse click handler to an editor.
162 166
163 @param editor reference to the editor 167 @param editor reference to the editor
164 @type Editor 168 @type Editor
165 """ 169 """
166 if Preferences.getJedi("MouseClickGotoButton"): 170 if Preferences.getJedi("MouseClickGotoButton"):
167 editor.setMouseClickHandler( 171 editor.setMouseClickHandler(
168 "jedi", 172 "jedi",
169 Preferences.getJedi("MouseClickGotoModifiers"), 173 Preferences.getJedi("MouseClickGotoModifiers"),
170 Preferences.getJedi("MouseClickGotoButton"), 174 Preferences.getJedi("MouseClickGotoButton"),
171 self.__jediServer.gotoDefinition 175 self.__jediServer.gotoDefinition,
172 ) 176 )
173 177
174 def __disconnectMouseClickHandler(self, editor): 178 def __disconnectMouseClickHandler(self, editor):
175 """ 179 """
176 Private method to disconnect the mouse click handler from an editor. 180 Private method to disconnect the mouse click handler from an editor.
177 181
178 @param editor reference to the editor 182 @param editor reference to the editor
179 @type Editor 183 @type Editor
180 """ 184 """
181 editor.removeMouseClickHandlers("jedi") 185 editor.removeMouseClickHandlers("jedi")
182 186
183 def __setAutoCompletionHook(self, editor): 187 def __setAutoCompletionHook(self, editor):
184 """ 188 """
185 Private method to set the autocompletion hook. 189 Private method to set the autocompletion hook.
186 190
187 @param editor reference to the editor 191 @param editor reference to the editor
188 @type Editor 192 @type Editor
189 """ 193 """
190 editor.addCompletionListHook( 194 editor.addCompletionListHook("jedi", self.__jediServer.requestCompletions, True)
191 "jedi", self.__jediServer.requestCompletions, True) 195
192
193 def __unsetAutoCompletionHook(self, editor): 196 def __unsetAutoCompletionHook(self, editor):
194 """ 197 """
195 Private method to unset the autocompletion hook. 198 Private method to unset the autocompletion hook.
196 199
197 @param editor reference to the editor 200 @param editor reference to the editor
198 @type Editor 201 @type Editor
199 """ 202 """
200 editor.removeCompletionListHook("jedi") 203 editor.removeCompletionListHook("jedi")
201 204
202 def __setCalltipsHook(self, editor): 205 def __setCalltipsHook(self, editor):
203 """ 206 """
204 Private method to set the calltip hook. 207 Private method to set the calltip hook.
205 208
206 @param editor reference to the editor 209 @param editor reference to the editor
207 @type Editor 210 @type Editor
208 """ 211 """
209 editor.addCallTipHook("jedi", self.__jediServer.getCallTips) 212 editor.addCallTipHook("jedi", self.__jediServer.getCallTips)
210 213
211 def __unsetCalltipsHook(self, editor): 214 def __unsetCalltipsHook(self, editor):
212 """ 215 """
213 Private method to unset the calltip hook. 216 Private method to unset the calltip hook.
214 217
215 @param editor reference to the editor 218 @param editor reference to the editor
216 @type Editor 219 @type Editor
217 """ 220 """
218 editor.removeCallTipHook("jedi") 221 editor.removeCallTipHook("jedi")
219 222
220 def __initRefactoringMenu(self): 223 def __initRefactoringMenu(self):
221 """ 224 """
222 Private method to initialize the Refactoring menu. 225 Private method to initialize the Refactoring menu.
223 """ 226 """
224 self.__menu = QMenu(self.tr("Refactoring")) 227 self.__menu = QMenu(self.tr("Refactoring"))
225 self.__menu.addAction( 228 self.__menu.addAction(
226 self.tr("Rename Variable"), 229 self.tr("Rename Variable"), self.__jediServer.refactoringRenameVariable
227 self.__jediServer.refactoringRenameVariable) 230 )
228 self.__menu.addAction( 231 self.__menu.addAction(
229 self.tr("Extract Variable"), 232 self.tr("Extract Variable"), self.__jediServer.refactoringExtractNewVariable
230 self.__jediServer.refactoringExtractNewVariable) 233 )
231 self.__menu.addAction( 234 self.__menu.addAction(
232 self.tr("Inline Variable"), 235 self.tr("Inline Variable"), self.__jediServer.refactoringInlineVariable
233 self.__jediServer.refactoringInlineVariable) 236 )
234 self.__menu.addSeparator() 237 self.__menu.addSeparator()
235 self.__menu.addAction( 238 self.__menu.addAction(
236 self.tr("Extract Function"), 239 self.tr("Extract Function"), self.__jediServer.refactoringExtractFunction
237 self.__jediServer.refactoringExtractFunction) 240 )
238 241
239 def __editorShowMenu(self, menuName, menu, editor): 242 def __editorShowMenu(self, menuName, menu, editor):
240 """ 243 """
241 Private slot called, when the the editor context menu or a submenu is 244 Private slot called, when the the editor context menu or a submenu is
242 about to be shown. 245 about to be shown.
243 246
244 @param menuName name of the menu to be shown 247 @param menuName name of the menu to be shown
245 @type str 248 @type str
246 @param menu reference to the menu 249 @param menu reference to the menu
247 @type QMenu 250 @type QMenu
248 @param editor reference to the editor 251 @param editor reference to the editor

eric ide

mercurial