Rope Refactoring: comparison RefactoringRope/Refactoring.py

-:121d426d4ed7
+:ea41742015af
 """
 Private slot to check, if there are changes to be undone.
 @return flag indicating, that undoable changes are available (boolean)
 """
+return False
 return self.__project is not None and \
 len(self.__project.history.undo_list) > 0
 def __canRedo(self):
 """
 Private slot to check, if there are changes to be redone.
 @return flag indicating, that redoable changes are available (boolean)
 """
+return False
 return self.__project is not None and \
 len(self.__project.history.redo_list) > 0
 def __getFileUndoList(self, resource):
 """
 resource is not None and self.__canUndoFile(resource))
 self.refactoringRedoHistoryAct.setEnabled(self.__canRedo())
 self.refactoringRedoFileHistoryAct.setEnabled(
 resource is not None and self.__canRedoFile(resource))
-def handleRopeError(self, err, title, handle=None):
+def __handleRopeError(self, result):
 """
-Public slot to handle a rope error.
+Private method to handle a rope error.
-@param err rope exception object (Exception)
+@param result dictionary containing the error information
-@param title title to be displayed (string)
+@type dict
-@param handle reference to a taskhandle (ProgressHandle)
+"""
-"""
+if result["Error"] == 'ModuleSyntaxError':
-if handle is not None:
-handle.reset()
-ropeError = str(type(err)).split()[-1]
-ropeError = ropeError[1:-2].split('.')[-1]
-if ropeError == 'ModuleSyntaxError':
 res = E5MessageBox.warning(
-self.__ui, title,
+self.__ui, result["Title"],
-self.tr("Rope error: {0}").format(str(err)),
+self.tr("Rope error: {0}").format(
+result["ErrorString"]),
 E5MessageBox.Ok | E5MessageBox.Open)
 if res == E5MessageBox.Open:
 e5App().getObject("ViewManager").openSourceFile(
 os.path.join(self.__e5project.getProjectPath(),
-err.filename),
+result["ErrorFile"]),
-err.lineno)
+result["ErrorLine"])
 else:
 E5MessageBox.warning(
-self.__ui, title,
+self.__ui, result["Title"],
-self.tr("Rope error: {0}").format(str(err)))
+self.tr("Rope error: {0}").format(
+result["ErrorString"])
+)
 def __getOffset(self, editor, line, index):
 r"""
 Private method to get the offset into the text treating CRLF as ONE
 character.
 filename = aw.getFileName()
 line, index = aw.getCursorPosition()
 offset = self.__getOffset(aw, line, index)
-import rope.contrib.findit
+self.sendJson("QueryReferences", {
-from ProgressHandle import ProgressHandle
+"Title": title,
-resource = rope.base.libutils.path_to_resource(
+"FileName": filename,
-self.__project, filename)
+"Offset": offset,
-handle = ProgressHandle(title, True, self.__ui)
+})
-handle.show()
-QApplication.processEvents()
+def __queryReferencesResult(self, result):
-try:
+"""
-occurrences = rope.contrib.findit.find_occurrences(
+Private method to handle the "Query References" result sent by
-self.__project, resource, offset,
+the client.
-unsure=True, in_hierarchy=True, task_handle=handle)
-except Exception as err:
+@param result dictionary containing the result data
-self.handleRopeError(err, title, handle)
+@type dict
-return
+"""
-handle.reset()
+if "Error" in result:
+self.__handleRopeError(result)
-if occurrences:
-from MatchesDialog import MatchesDialog
-self.dlg = MatchesDialog(self.__ui, True)
-self.dlg.show()
-for occurrence in occurrences:
-self.dlg.addEntry(
-occurrence.resource, occurrence.lineno, occurrence.unsure)
 else:
-E5MessageBox.warning(
+title = result["Title"]
-self.__ui, title,
+if result["EntriesCount"] > 0:
-self.tr("No occurrences found."))
+from MatchesDialog import MatchesDialog
+self.dlg = MatchesDialog(self.__ui, True)
+self.dlg.show()
+for occurrence in result["Entries"]:
+self.dlg.addEntry(
+# resource, lineno, unsure
+occurrence[0], occurrence[1], occurrence[2])
+else:
+E5MessageBox.warning(
+self.__ui, title,
+self.tr("No occurrences found."))
 def __queryDefinition(self):
 """
 Private slot to handle the Find Definition action.
 """
 self.__projectopen = False
 self.__projectpath = ''
 self.__projectLanguage = ""
 # TODO: delete this or move to client
-def getProject(self):
+##    def getProject(self):
-"""
+##        """
-Public method to get a reference to the rope project object.
+##        Public method to get a reference to the rope project object.
+##
-@return reference to the rope project object (RopeProject)
+##        @return reference to the rope project object (RopeProject)
-"""
+##        """
-return self.__project
+##        return self.__project
+##
 def confirmBufferIsSaved(self, editor):
 """
 Public method to check, if an editor has unsaved changes.
 @param editor reference to the editor to be checked
 @return flag indicating, that the editor doesn't contain
 unsaved edits (boolean)
 """
 res = editor.checkDirty()
-self.__project.validate(self.__project.root)
+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
 (boolean)
 """
 res = e5App().getObject("ViewManager").checkAllDirty()
-self.__project.validate(self.__project.root)
+self.sendJson("Validate", {})
 return res
 def refreshEditors(self, changes):
 """
 Public method to refresh modified editors.
 self.__progressDialog.updateProgress(params)
 elif method == "ProgressReset":
 if self.__progressDialog is not None:
 self.__progressDialog.reset()
+elif method == "QueryReferencesResult":
+self.__queryReferencesResult(params)
 def __startRefactoringClient(self, interpreter):
 """
 Private method to start the refactoring client.

Mercurial Repositories > Rope Refactoring / file comparison

comparison: RefactoringRope/Refactoring.py

RefactoringRope/Refactoring.py