Rope Refactoring: comparison RefactoringRope/RefactoringClient.py

-:cb044ec27c24
+:4f53795beff0
 import sys
 import os
 import contextlib
-modulePath = sys.argv[-1]   # it is always the last parameter
+modulePath = sys.argv[-1]  # it is always the last parameter
 sys.path.append(modulePath)
 try:
 import rope.base.project
 import rope.base.libutils
 class RefactoringClient(EricJsonClient):
 """
 Class implementing the refactoring client interface to rope.
 """
 def __init__(self, host, port, projectPath):
 """
 Constructor
 @param host ip address the background service is listening
 @type str
 @param port port of the background service
 @type int
 @param projectPath path to the project
 @type str
 """
 super().__init__(host, port)
 self.__methodMapping = {
 "AbortAction": self.__abortAction,
 "CloseProject": self.__closeProject,
 "Validate": self.__validate,
 "QueryReferences": self.__queryReferences,
 "History": self.__processHistory,
 "PreviewChanges": self.__previewChanges,
 "ApplyChanges": self.__applyChanges,
 "ClearChanges": self.__clearChanges,
 "CalculateRenameChanges": self.__calculateRenameChanges,
-"CalculateChangeOccurrencesChanges":
+"CalculateChangeOccurrencesChanges": (
-self.__calculateChangeOccurrencesChanges,
+self.__calculateChangeOccurrencesChanges
+),
 "CalculateExtractChanges": self.__calculateExtractChanges,
 "RequestInlineType": self.__requestInlineType,
 "CalculateInlineChanges": self.__calculateInlineChanges,
 "RequestMoveType": self.__requestMoveType,
 "CalculateMoveChanges": self.__calculateMoveChanges,
 "RequestUseFunction": self.__requestUseFunction,
 "CalculateUseFunctionChanges": self.__calculateUseFunctionChanges,
-"CalculateIntroduceFactoryChanges":
+"CalculateIntroduceFactoryChanges": self.__calculateIntroduceFactoryChanges,
-self.__calculateIntroduceFactoryChanges,
+"CalculateIntroduceParameterChanges": (
-"CalculateIntroduceParameterChanges":
+self.__calculateIntroduceParameterChanges
-self.__calculateIntroduceParameterChanges,
+),
 "CalculateImportsChanges": self.__calculateImportsChanges,
 "CalculateRestructureChanges": self.__calculateRestructureChanges,
 "RequestSignature": self.__requestSignature,
 "CalculateSignatureChanges": self.__calculateSignatureChanges,
-"CalculateInlineArgumentDefaultChanges":
+"CalculateInlineArgumentDefaultChanges": (
-self.__calculateInlineArgumentDefaultChanges,
+self.__calculateInlineArgumentDefaultChanges
-"CalculateModuleToPackageChanges":
+),
-self.__calculateModuleToPackageChanges,
+"CalculateModuleToPackageChanges": self.__calculateModuleToPackageChanges,
 "RequestFieldName": self.__requestFieldName,
-"CalculateEncapsulateFieldChanges":
+"CalculateEncapsulateFieldChanges": self.__calculateEncapsulateFieldChanges,
-self.__calculateEncapsulateFieldChanges,
+"CalculateLocalToAttributeChanges": self.__calculateLocalToAttributeChanges,
-"CalculateLocalToAttributeChanges":
+"CalculateMethodObjectChanges": self.__calculateMethodObjectChanges,
-self.__calculateLocalToAttributeChanges,
+}
-"CalculateMethodObjectChanges":
-self.__calculateMethodObjectChanges,
-}
 from FileSystemCommands import RefactoringClientFileSystemCommands
 self.__fsCommands = RefactoringClientFileSystemCommands(self)
 self.__projectpath = projectPath
 self.__project = rope.base.project.Project(
-self.__projectpath, fscommands=self.__fsCommands)
+self.__projectpath, fscommands=self.__fsCommands
+)
 self.__progressHandle = None
 self.__changes = {}
 # dict storing the retrieved changes for various refactorings
 def handleCall(self, method, params):
 """
 Public method to handle a method call from the server.
 @param method requested method name
 @type str
 @param params dictionary with method specific parameters
 @type dict
 """
 self.__methodMapping[method](params)
 def __handleRopeError(self, err):
 """
 Private method to process a rope error.
 @param err rope exception object
 @type Exception
 @return dictionary containing the error information
 @rtype dict
 """
 import traceback
 tb = traceback.format_tb(sys.exc_info()[2])
 ropeError = str(type(err)).split()[-1]
-ropeError = ropeError[1:-2].split('.')[-1]
+ropeError = ropeError[1:-2].split(".")[-1]
 errorDict = {
 "Error": ropeError,
 "ErrorString": str(err),
 "Traceback": tb,
 }
-if ropeError == 'ModuleSyntaxError':
+if ropeError == "ModuleSyntaxError":
 errorDict["ErrorFile"] = err.filename
 errorDict["ErrorLine"] = err.lineno
 return errorDict
 def __abortAction(self, params):
 """
 Private method to abort the current action.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
-if (
+if self.__progressHandle is not None and not self.__progressHandle.is_stopped():
-self.__progressHandle is not None and
-not self.__progressHandle.is_stopped()
-):
 self.__progressHandle.stop()
 def __validate(self, params):
 """
 Private slot to validate the project.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 self.__project.validate(self.__project.root)
 def __closeProject(self, params):
 """
 Private slot to validate the project.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 self.__project.close()
 def __getConfig(self, params):
 """
 Private method to send some configuration data to the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 result = {
 "RopeFolderName": self.__project.ropefolder.real_path,
 "RopeHelpFile": os.path.join(
-os.path.dirname(__file__), "Documentation", "rope",
+os.path.dirname(__file__), "Documentation", "rope", "overview.rst"
-"overview.rst"),
+),
 "RopeInfo": rope.INFO,
 "RopeVersion": rope.VERSION,
 "RopeCopyright": rope.COPYRIGHT,
 "PythonVersion": "Python{0}".format(sys.version_info[0]),
 }
 # read our own copy of default_config derived from the default
 # settings in rope.base.prefs.Prefs
 with open(
 os.path.join(os.path.dirname(__file__), "default_config.py"),
 "r",
-encoding="utf-8"
+encoding="utf-8",
 ) as f:
 result["DefaultConfig"] = f.read()
 self.sendJson("Config", result)
 def __configChanged(self, params):
 """
 Private method to handle a change of the configuration file.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 self.__project.close()
 self.__project = rope.base.project.Project(
-self.__projectpath, fscommands=self.__fsCommands)
+self.__projectpath, fscommands=self.__fsCommands
+)
 def __queryReferences(self, params):
 """
 Private method to handle the Find References action.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 occurrences = []
 import rope.contrib.findit
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 occurrences = rope.contrib.findit.find_occurrences(
-self.__project, resource, offset,
+self.__project,
-unsure=True, in_hierarchy=True,
+resource,
-task_handle=self.__progressHandle)
+offset,
+unsure=True,
+in_hierarchy=True,
+task_handle=self.__progressHandle,
+)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 result = {
 "Title": title,
 "EntriesCount": len(occurrences),
 "Entries": [
-[occurrence.resource.real_path, occurrence.lineno,
+[occurrence.resource.real_path, occurrence.lineno, occurrence.unsure]
-occurrence.unsure] for occurrence in occurrences
+for occurrence in occurrences
 ],
 }
 result.update(errorDict)
 self.sendJson("QueryReferencesResult", result)
 def __queryDefinition(self, params):
 """
 Private method to handle the Find Definition action.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 source = params["Source"]
 errorDict = {}
 location = None
 import rope.contrib.findit
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 location = rope.contrib.findit.find_definition(
-self.__project, source, offset, resource)
+self.__project, source, offset, resource
-except Exception as err:
+)
-errorDict = self.__handleRopeError(err)
+except Exception as err:
+errorDict = self.__handleRopeError(err)
 result = {
 "Title": title,
 }
 if location is not None:
-result["Location"] = [
+result["Location"] = [location.resource.real_path, location.lineno]
-location.resource.real_path, location.lineno
+result.update(errorDict)
-]
-result.update(errorDict)
 self.sendJson("QueryDefinitionResult", result)
 def __queryImplementations(self, params):
 """
 Private method to handle the Find Implementations action.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 occurrences = []
 import rope.contrib.findit
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 occurrences = rope.contrib.findit.find_implementations(
-self.__project, resource, offset,
+self.__project, resource, offset, task_handle=self.__progressHandle
-task_handle=self.__progressHandle)
+)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 result = {
 "Title": title,
 "EntriesCount": len(occurrences),
 "Entries": [
-[occurrence.resource.real_path, occurrence.lineno,
+[occurrence.resource.real_path, occurrence.lineno, occurrence.unsure]
-occurrence.unsure] for occurrence in occurrences
+for occurrence in occurrences
 ],
 }
 result.update(errorDict)
 self.sendJson("QueryImplementationsResult", result)
 def __performSOA(self, params):
 """
 Private method to perform SOA on all modules.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 title = params["Title"]
 errorDict = {}
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 rope.base.libutils.analyze_modules(
-self.__project, task_handle=self.__progressHandle)
+self.__project, task_handle=self.__progressHandle
+)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 result = {
 "Title": title,
 }
 result.update(errorDict)
 self.sendJson("SoaFinished", result)
 def __reportChanged(self, params):
 """
 Private method to register some changed sources.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 filename = params["FileName"]
 oldSource = params["OldSource"]
 with contextlib.suppress(Exception):
-rope.base.libutils.report_change(
+rope.base.libutils.report_change(self.__project, filename, oldSource)
-self.__project, filename, oldSource)
 def __processHistory(self, params):
 """
 Private method to process the various history related requests.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 subcommand = params["Subcommand"]
 if subcommand == "Get":
 changes = {}
 if params["Filename"]:
 # file history
 resource = rope.base.libutils.path_to_resource(
-self.__project, params["Filename"])
+self.__project, params["Filename"]
+)
 undoList = []
 for change in reversed(self.__project.history.undo_list):
 if resource in change.get_changed_resources():
 undoList.append(change)
 redoList = []
 redoList.append(change)
 else:
 # project history
 undoList = list(reversed(self.__project.history.undo_list))
 redoList = self.__project.history.redo_list
-result = {"Subcommand": "Histories"}
+result = {
-result["Undo"] = []
+"Subcommand": "Histories",
+"Undo": [],
+}
 for change in undoList:
 changes[id(change)] = change
 result["Undo"].append([str(change), id(change)])
 result["Redo"] = []
 for change in redoList:
 changes[id(change)] = change
 result["Redo"].append([str(change), id(change)])
 self.__changes["History"] = changes
 self.sendJson("HistoryResult", result)
 elif subcommand == "GetChange":
 result = {
 "Subcommand": "ChangeDescription",
-"Description":
+"Description": self.__changes["History"][
-self.__changes["History"][params["Id"]].get_description()
+params["Id"]
+].get_description(),
 }
 self.sendJson("HistoryResult", result)
 elif subcommand in ["Undo", "Redo"]:
 change = self.__changes["History"][params["Id"]]
-self.__progressHandle = ProgressHandle(self, change.description,
+self.__progressHandle = ProgressHandle(self, change.description, False)
-False)
 if subcommand == "Undo":
-self.__project.history.undo(
+self.__project.history.undo(change, task_handle=self.__progressHandle)
-change, task_handle=self.__progressHandle)
 else:
-self.__project.history.redo(
+self.__project.history.redo(change, task_handle=self.__progressHandle)
-change, task_handle=self.__progressHandle)
 self.__progressHandle.reset()
 self.__progressHandle = None
 result = {
 "Subcommand": subcommand,
 "ChangedFiles": [
 res.real_path for res in change.get_changed_resources()
 ],
 }
 self.sendJson("HistoryResult", result)
 elif subcommand == "Clear":
 self.__project.history.clear()
 elif subcommand == "ClearChanges":
 with contextlib.suppress(KeyError):
 del self.__changes["History"]
 def __clearChanges(self, params):
 """
 Private method to clear the changes cache of a given change group.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 with contextlib.suppress(KeyError):
 del self.__changes[params["ChangeGroup"]]
 def __applyChanges(self, params):
 """
 Private method to apply the changes of a given change group.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 errorDict = {}
 self.__progressHandle = ProgressHandle(self, params["Title"], False)
 try:
 changes = self.__changes[params["ChangeGroup"]]
 if changes is not None:
 self.__project.do(changes, self.__progressHandle)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 result = {
 "Subcommand": "ChangesApplied",
 "ChangeGroup": params["ChangeGroup"],
 "Title": params["Title"],
-"ChangedFiles": [
+"ChangedFiles": [res.real_path for res in changes.get_changed_resources()],
-res.real_path for res in changes.get_changed_resources()
+}
-],
+result.update(errorDict)
-}
-result.update(errorDict)
+self.sendJson("Changes", result)
-self.sendJson("Changes", result)
 def __previewChanges(self, params):
 """
 Private method to determine the changes data for a preview.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 try:
 changes = self.__changes[params["ChangeGroup"]]
 description = changes.description
 except KeyError:
 changes = None
 description = ""
 changesData = []
 if changes is not None:
 for change in changes.changes:
 changeTitle = str(change)
 try:
 changeText = change.get_description()
 except AttributeError:
 changeText = None
 changesData.append([changeTitle, changeText])
 result = {
 "Subcommand": "PreviewChanges",
 "ChangeGroup": params["ChangeGroup"],
 "Description": description,
 "Changes": changesData,
 }
 self.sendJson("Changes", result)
 def __calculateRenameChanges(self, params):
 """
 Private method to calculate the rename changes based on the parameters
 sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 offset = params["Offset"]
 isLocal = params["LocalRename"]
 newName = params["NewName"]
 renameHierarchy = params["RenameHierarchy"]
 renameInStrings = params["RenameInStrings"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.rename
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 resources = [resource] if isLocal else None
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
-renamer = rope.refactor.rename.Rename(
+renamer = rope.refactor.rename.Rename(self.__project, resource, offset)
-self.__project, resource, offset)
 changes = renamer.get_changes(
 newName,
 resources=resources,
 in_hierarchy=renameHierarchy,
 unsure=lambda o: self.__confirmUnsure(o, changeGroup),
 docs=renameInStrings,
-task_handle=self.__progressHandle)
+task_handle=self.__progressHandle,
+)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __confirmUnsure(self, occurrence, changeGroup):
 """
 Private method to confirm unsure occurrences.
 @param occurrence reference to the occurrence object
 @type rope.refactor.occurrences.Occurrence
 @param changeGroup name of the change group
 @type str
 @return flag indicating an occurrence
 @rtype bool
 """
 filename = occurrence.resource.real_path
 start, end = occurrence.get_primary_range()
-self.sendJson("Changes", {
+self.sendJson(
-"Subcommand": "ConfirmUnsure",
+"Changes",
-"ChangeGroup": changeGroup,
+{
-"FileName": filename,
+"Subcommand": "ConfirmUnsure",
-"StartOffset": start,
+"ChangeGroup": changeGroup,
-"EndOffset": end,
+"FileName": filename,
-})
+"StartOffset": start,
+"EndOffset": end,
+},
+)
 answer = self.poll(waitMethod="ConfirmUnsure")
 return answer["Answer"]
 def __calculateChangeOccurrencesChanges(self, params):
 """
 Private method to calculate the 'Change Occurrences' changes based on
 the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 offset = params["Offset"]
 newName = params["NewName"]
 onlyCalls = params["OnlyCalls"]
 reads = params["Reads"]
 writes = params["Writes"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.rename
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 renamer = rope.refactor.rename.ChangeOccurrences(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 changes = renamer.get_changes(
-newName, only_calls=onlyCalls, reads=reads, writes=writes)
+newName, only_calls=onlyCalls, reads=reads, writes=writes
-except Exception as err:
+)
-errorDict = self.__handleRopeError(err)
+except Exception as err:
+errorDict = self.__handleRopeError(err)
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateExtractChanges(self, params):
 """
 Private method to calculate the 'Extract' changes based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 @exception Exception raised to indicate an invalid extraction type
 """
 endOffset = params["EndOffset"]
 kind = params["Kind"]
 newName = params["NewName"]
 similar = params["Similar"]
 global_ = params["Global"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.extract
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 if kind not in ("variable", "method"):
 raise Exception("Invalid extraction kind <{0}>.".format(kind))
 elif kind == "variable":
 extractor = rope.refactor.extract.ExtractVariable(
-self.__project, resource, startOffset, endOffset)
+self.__project, resource, startOffset, endOffset
+)
 elif kind == "method":
 extractor = rope.refactor.extract.ExtractMethod(
-self.__project, resource, startOffset, endOffset)
+self.__project, resource, startOffset, endOffset
-changes = extractor.get_changes(
+)
-newName, similar=similar, global_=global_)
+changes = extractor.get_changes(newName, similar=similar, global_=global_)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __requestInlineType(self, params):
 """
 Private method to determine the 'Inline' changes type based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 result = {
 "Subcommand": "InlineType",
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.inline
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 inliner = rope.refactor.inline.create_inline(
-self.__project, resource, offset)
+self.__project, resource, offset
-result.update({
+)
-"Name": inliner.name,
+result.update(
-"Kind": inliner.get_kind(),
+{
-})
+"Name": inliner.name,
-except Exception as err:
+"Kind": inliner.get_kind(),
-errorDict = self.__handleRopeError(err)
+}
+)
-result.update(errorDict)
+except Exception as err:
+errorDict = self.__handleRopeError(err)
-self.sendJson("Changes", result)
+result.update(errorDict)
+self.sendJson("Changes", result)
 def __calculateInlineChanges(self, params):
 """
 Private method to calculate the 'Inline' changes based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 kind = params["Kind"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.extract
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 inliner = rope.refactor.inline.create_inline(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 opts = (
-{"in_hierarchy": params["Hierarchy"], }
+{
-if kind == "parameter" else
+"in_hierarchy": params["Hierarchy"],
-{"remove": params["Remove"],
+}
-"only_current": params["OnlyCurrent"], }
+if kind == "parameter"
-)
+else {
-changes = inliner.get_changes(
+"remove": params["Remove"],
-task_handle=self.__progressHandle, **opts)
+"only_current": params["OnlyCurrent"],
+}
+)
+changes = inliner.get_changes(task_handle=self.__progressHandle, **opts)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __requestMoveType(self, params):
 """
 Private method to determine the 'Move Method' changes type based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 result = {
 "Subcommand": "MoveType",
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.move
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
-mover = rope.refactor.move.create_move(
+mover = rope.refactor.move.create_move(self.__project, resource, offset)
-self.__project, resource, offset)
 if isinstance(mover, rope.refactor.move.MoveGlobal):
-result.update({
+result.update(
-"Kind": "move_global_method",
+{
-"Method": "",
+"Kind": "move_global_method",
-})
+"Method": "",
+}
+)
 else:
-result.update({
+result.update(
-"Kind": "move_method",
+{
-"Method": mover.get_method_name(),
+"Kind": "move_method",
-})
+"Method": mover.get_method_name(),
-except Exception as err:
+}
-errorDict = self.__handleRopeError(err)
+)
+except Exception as err:
-result.update(errorDict)
+errorDict = self.__handleRopeError(err)
-self.sendJson("Changes", result)
+result.update(errorDict)
+self.sendJson("Changes", result)
 def __calculateMoveChanges(self, params):
 """
 Private method to calculate the 'Move ...' changes based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 offset = params["Offset"]
 kind = params["Kind"]
 newName = params["NewName"]
 attribute = params["Attribute"]
 destination = params["DestinationModule"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.move
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
-mover = rope.refactor.move.create_move(
+mover = rope.refactor.move.create_move(self.__project, resource, offset)
-self.__project, resource, offset)
 if kind == "move_method":
 changes = mover.get_changes(
-attribute, newName, task_handle=self.__progressHandle)
+attribute, newName, task_handle=self.__progressHandle
+)
 else:
 if kind == "move_global_method":
 dest = self.__project.get_pycore().find_module(
-os.path.splitext(destination)[0])
+os.path.splitext(destination)[0]
+)
 else:
 # move_module
 if destination.endswith(os.sep):
 destination = destination[:-1]
-dest = self.__project.get_pycore().find_module(
+dest = self.__project.get_pycore().find_module(destination)
-destination)
+changes = mover.get_changes(dest, task_handle=self.__progressHandle)
-changes = mover.get_changes(
-dest, task_handle=self.__progressHandle)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __requestUseFunction(self, params):
 """
 Private method to determine the 'Use Function' function name based on
 the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 result = {
 "Subcommand": "UseFunctionName",
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.usefunction
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 user = rope.refactor.usefunction.UseFunction(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 result["FunctionName"] = user.get_function_name()
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateUseFunctionChanges(self, params):
 """
 Private method to calculate the 'Use Function' changes based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.usefunction
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 user = rope.refactor.usefunction.UseFunction(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 changes = user.get_changes(task_handle=self.__progressHandle)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateIntroduceFactoryChanges(self, params):
 """
 Private method to calculate the 'Introduce Factory' changes based on
 the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 factoryName = params["Name"]
 globalFactory = params["GlobalFactory"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.introduce_factory
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
-introducer = (
+introducer = rope.refactor.introduce_factory.IntroduceFactoryRefactoring(
-rope.refactor.introduce_factory.IntroduceFactoryRefactoring(
+self.__project, resource, offset
-self.__project, resource, offset)
 )
 changes = introducer.get_changes(
-factoryName, global_factory=globalFactory,
+factoryName,
-task_handle=self.__progressHandle)
+global_factory=globalFactory,
+task_handle=self.__progressHandle,
+)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateIntroduceParameterChanges(self, params):
 """
 Private method to calculate the 'Introduce Parameter' changes based on
 the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 parameterName = params["Name"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.introduce_parameter
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 introducer = rope.refactor.introduce_parameter.IntroduceParameter(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 changes = introducer.get_changes(parameterName)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateImportsChanges(self, params):
 """
 Private method to calculate the 'Import' changes based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 methodName = params["MethodName"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 from rope.refactor.importutils import ImportOrganizer
 method = {
 "organize_imports": ImportOrganizer.organize_imports,
 "expand_star_imports": ImportOrganizer.expand_star_imports,
 "relatives_to_absolutes": ImportOrganizer.relatives_to_absolutes,
 "froms_to_imports": ImportOrganizer.froms_to_imports,
 "handle_long_imports": ImportOrganizer.handle_long_imports,
 }[methodName]
 importOrganizer = ImportOrganizer(self.__project)
-resource = rope.base.libutils.path_to_resource(
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
-self.__project, filename)
 try:
 changes = method(importOrganizer, resource, offset=offset)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__changes[changeGroup] = changes
 # send the change description first
 description = changes.description if changes else ""
-self.sendJson("Changes", {
+self.sendJson(
-"ChangeGroup": changeGroup,
+"Changes",
-"Title": title,
+{
-"Subcommand": "ChangeDescription",
+"ChangeGroup": changeGroup,
-"Description": description,
+"Title": title,
-})
+"Subcommand": "ChangeDescription",
+"Description": description,
+},
+)
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateRestructureChanges(self, params):
 """
 Private method to calculate the 'Restructure' changes based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 pattern = params["Pattern"]
 goal = params["Goal"]
 args = params["Args"]
 imports = params["Imports"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.restructure
 self.__project.validate(self.__project.root)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 restructuring = rope.refactor.restructure.Restructure(
-self.__project, pattern, goal, args=args, imports=imports)
+self.__project, pattern, goal, args=args, imports=imports
-changes = restructuring.get_changes(
+)
-task_handle=self.__progressHandle)
+changes = restructuring.get_changes(task_handle=self.__progressHandle)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __requestSignature(self, params):
 """
 Private method to calculate the 'Signature' based on the parameters
 sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 result = {
 "Subcommand": "Signature",
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.change_signature
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 changer = rope.refactor.change_signature.ChangeSignature(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 result["DefinitionInfo"] = changer.get_args()
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateSignatureChanges(self, params):
 """
 Private method to calculate the 'Signature' changes based on the
 parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 removals = params["Removals"]
 additions = params["Additions"]
 newOrdering = params["Ordering"]
 autodef = params["AutoDef"]
 doHierarchy = params["Hierarchy"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 changers = []
 import rope.refactor.change_signature
 # removals
 for index in removals:
 remover = rope.refactor.change_signature.ArgumentRemover(index)
 changers.append(remover)
 # additions
 for index, name, default, value in additions:
 adder = rope.refactor.change_signature.ArgumentAdder(
-index, name, default, value)
+index, name, default, value
+)
 changers.append(adder)
 # new ordering
-changers.append(rope.refactor.change_signature.ArgumentReorderer(
+changers.append(
-newOrdering, autodef=autodef))
+rope.refactor.change_signature.ArgumentReorderer(
+newOrdering, autodef=autodef
-resource = rope.base.libutils.path_to_resource(
+)
-self.__project, filename)
+)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 changer = rope.refactor.change_signature.ChangeSignature(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 changes = changer.get_changes(
-changers, in_hierarchy=doHierarchy,
+changers, in_hierarchy=doHierarchy, task_handle=self.__progressHandle
-task_handle=self.__progressHandle)
+)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateInlineArgumentDefaultChanges(self, params):
 """
 Private method to calculate the 'Inline Argument Default' changes
 based on the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 argumentIndex = params["Index"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
-resource = rope.base.libutils.path_to_resource(
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
-self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
 changer = rope.refactor.change_signature.ChangeSignature(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 inliner = rope.refactor.change_signature.ArgumentDefaultInliner(
-argumentIndex)
+argumentIndex
-changes = changer.get_changes(
+)
-[inliner], task_handle=self.__progressHandle)
+changes = changer.get_changes([inliner], task_handle=self.__progressHandle)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateModuleToPackageChanges(self, params):
 """
 Private method to calculate the 'Module to Package' changes
 based on the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.topackage
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 changes = rope.refactor.topackage.ModuleToPackage(
-self.__project, resource).get_changes()
+self.__project, resource
-except Exception as err:
+).get_changes()
-errorDict = self.__handleRopeError(err)
+except Exception as err:
+errorDict = self.__handleRopeError(err)
 self.__changes[changeGroup] = changes
 # send the change description first
 description = changes.description if changes else ""
-self.sendJson("Changes", {
+self.sendJson(
-"ChangeGroup": changeGroup,
+"Changes",
-"Title": title,
+{
-"Subcommand": "ChangeDescription",
+"ChangeGroup": changeGroup,
-"Description": description,
+"Title": title,
-})
+"Subcommand": "ChangeDescription",
+"Description": description,
+},
+)
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __requestFieldName(self, params):
 """
 Private method to calculate the 'Field Name' based on the parameters
 sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 result = {
 "Subcommand": "FieldName",
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.encapsulate_field
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
-encapsulateField = (
+encapsulateField = rope.refactor.encapsulate_field.EncapsulateField(
-rope.refactor.encapsulate_field.EncapsulateField(
+self.__project, resource, offset
-self.__project, resource, offset)
 )
 result["Name"] = encapsulateField.get_field_name()
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateEncapsulateFieldChanges(self, params):
 """
 Private method to calculate the 'Encapsulate Field' changes based on
 the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 getter = params["Getter"]
 setter = params["Setter"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.encapsulate_field
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 self.__progressHandle = ProgressHandle(self, title, True)
 try:
-encapsulateField = (
+encapsulateField = rope.refactor.encapsulate_field.EncapsulateField(
-rope.refactor.encapsulate_field.EncapsulateField(
+self.__project, resource, offset
-self.__project, resource, offset)
 )
 changes = encapsulateField.get_changes(
-getter=getter, setter=setter,
+getter=getter, setter=setter, task_handle=self.__progressHandle
-task_handle=self.__progressHandle)
+)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__progressHandle.reset()
 self.__progressHandle = None
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateLocalToAttributeChanges(self, params):
 """
 Private method to calculate the 'Local Variabe to Attribute' changes
 based on the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.localtofield
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 changes = rope.refactor.localtofield.LocalToField(
-self.__project, resource, offset).get_changes()
+self.__project, resource, offset
-except Exception as err:
+).get_changes()
-errorDict = self.__handleRopeError(err)
+except Exception as err:
+errorDict = self.__handleRopeError(err)
 self.__changes[changeGroup] = changes
 # send the change description first
 description = changes.description if changes else ""
-self.sendJson("Changes", {
+self.sendJson(
-"ChangeGroup": changeGroup,
+"Changes",
-"Title": title,
+{
-"Subcommand": "ChangeDescription",
+"ChangeGroup": changeGroup,
-"Description": description,
+"Title": title,
-})
+"Subcommand": "ChangeDescription",
+"Description": description,
+},
+)
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
 def __calculateMethodObjectChanges(self, params):
 """
 Private method to calculate the 'Method to Method Object' changes
 based on the parameters sent by the server.
 @param params dictionary containing the method parameters sent by
 the server
 @type dict
 """
 changeGroup = params["ChangeGroup"]
 title = params["Title"]
 filename = params["FileName"]
 offset = params["Offset"]
 name = params["Name"]
 errorDict = {}
 changes = None
 result = {
 "ChangeGroup": changeGroup,
 "Title": title,
 }
 import rope.refactor.method_object
-resource = rope.base.libutils.path_to_resource(
-self.__project, filename)
+resource = rope.base.libutils.path_to_resource(self.__project, filename)
 try:
 converter = rope.refactor.method_object.MethodObject(
-self.__project, resource, offset)
+self.__project, resource, offset
+)
 changes = converter.get_changes(name)
 except Exception as err:
 errorDict = self.__handleRopeError(err)
 self.__changes[changeGroup] = changes
 result["Subcommand"] = "ChangesCalculated"
 result.update(errorDict)
 self.sendJson("Changes", result)
-if __name__ == '__main__':
+if __name__ == "__main__":
 if len(sys.argv) != 5:
-print('Host, port, project path and module path parameters are'
+print(
-' missing. Abort.')
+"Host, port, project path and module path parameters are" " missing. Abort."
+)
 sys.exit(1)
 host, port, projectPath = sys.argv[1:-1]
 # Create a Qt6 application object in order to allow the processing of
 # modules containing Qt stuff.
 try:
 from PyQt6.QtCore import QCoreApplication
 except (ImportError, RuntimeError):
 QCoreApplication = None
 if QCoreApplication is not None:
 app = QCoreApplication([])
 client = RefactoringClient(host, int(port), projectPath)
 # Start the main loop
 client.run()
 sys.exit(0)
 #
 # eflag: noqa = M801

Mercurial Repositories > Rope Refactoring / file comparison

comparison: RefactoringRope/RefactoringClient.py

RefactoringRope/RefactoringClient.py