RefactoringRope/RefactoringClient.py

# -*- coding: utf-8 -*-

# Copyright (c) 2017 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing the refactoring client interface to rope.
"""

from __future__ import unicode_literals

import sys
import os

sys.path.insert(0, os.path.dirname(__file__))
if sys.version_info[0] >= 3:
    rope_path = os.path.join(os.path.dirname(__file__), 'rope_py3')
else:
    rope_path = os.path.join(os.path.dirname(__file__), 'rope_py2')
    str = unicode   # __IGNORE_WARNING__
sys.path.insert(0, rope_path)

import rope
import rope.base.project
import rope.base.libutils

from JsonClient import JsonClient


class RefactoringClient(JsonClient):
    """
    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(RefactoringClient, self).__init__(host, port)
        
        self.__methodMapping = {
            "AbortAction": self.__abortAction,
            "CloseProject": self.__closeProject,
            "Validate": self.__validate,
            "QueryReferences": self.__queryReferences,
            "QueryDefinition": self.__queryDefinition,
            "QueryImplementations": self.__queryImplementations,
            "GetConfig": self.__getConfig,
            "ConfigChanged": self.__configChanged,
            "PerformSoa": self.__performSOA,
            "ReportChanged": self.__reportChanged,
            "History": self.__processHistory,
            "PreviewChanges": self.__previewChanges,
            "ApplyChanges": self.__applyChanges,
            "ClearChanges": self.__clearChanges,
            "CalculateRenameChanges": self.__calculateRenameChanges,
        }
        
        from FileSystemCommands import RefactoringClientFileSystemCommands
        self.__fsCommands = RefactoringClientFileSystemCommands(self)
        
        self.__projectpath = projectPath
        self.__project = rope.base.project.Project(
            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
        """
##        if "filename" in params and sys.version_info[0] == 2:
##            params["filename"] = params["filename"].encode(
##                sys.getfilesystemencoding())
        
        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
        """
        ropeError = str(type(err)).split()[-1]
        ropeError = ropeError[1:-2].split('.')[-1]
        errorDict = {
            "Error": ropeError,
            "ErrorString": str(err),
        }
        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 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,
            "DefaultConfig": self.__project._default_config(),
            "RopeHelpFile": os.path.join(
                rope_path, "rope", "docs", "overview.txt"),
            "RopeInfo": rope.INFO,
            "RopeVersion": rope.VERSION,
            "RopeCopyright": rope.COPYRIGHT,
        }
        
        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)
    
    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
        from ProgressHandle import ProgressHandle
        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,
                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.unsure] 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"]
        subcommand = params["Subcommand"]
        
        errorDict = {}
        location = None
        
        import rope.contrib.findit
        resource = rope.base.libutils.path_to_resource(
            self.__project, filename)
        try:
            location = rope.contrib.findit.find_definition(
                self.__project, source, offset, resource)
        except Exception as err:
            errorDict = self.__handleRopeError(err)
        
        result = {
            "Title": title,
            "Subcommand": subcommand,
        }
        if location is not None:
            result["Location"] = [
                location.resource.real_path, location.lineno
            ]
        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
        from ProgressHandle import ProgressHandle
        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,
                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.unsure] 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 = {}
        
        from ProgressHandle import ProgressHandle
        self.__progressHandle = ProgressHandle(self, title, True)
        try:
            rope.base.libutils.analyze_modules(
                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"]
        
        try:
            rope.base.libutils.report_change(
                self.__project, filename, oldSource)
        except Exception:
            # simply ignore it
            pass
    
    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"])
                undoList = []
                for change in reversed(self.__project.history.undo_list):
                    if resource in change.get_changed_resources():
                        undoList.append(change)
                redoList = []
                for change in self.__project.history.redo_list:
                    if resource in change.get_changed_resources():
                        redoList.append(change)
            else:
                # project history
                undoList = list(reversed(self.__project.history.undo_list))
                redoList = self.__project.history.redo_list
            
            result = {"Subcommand": "Histories"}
            result["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": self.__changes["History"][params["Id"]]\
                    .get_description()
            }
            
            self.sendJson("HistoryResult", result)
        
        elif subcommand in ["Undo", "Redo"]:
            change = self.__changes["History"][params["Id"]]
            from ProgressHandle import ProgressHandle
            self.__progressHandle = ProgressHandle(self, change.description,
                                                   False)
            if subcommand == "Undo":
                self.__project.history.undo(
                    change, task_handle=self.__progressHandle)
            else:
                self.__project.history.redo(
                    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":
            try:
                del self.__changes["History"]
            except KeyError:
                pass
    
    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
        """
        try:
            del self.__changes[params["ChangeGroup"]]
        except KeyError:
            pass
    
    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 = {}
        
        from ProgressHandle import ProgressHandle
        self.__progressHandle = ProgressHandle(self, params["Title"], False)
        try:
            changes = self.__changes[params["ChangeGroup"]]
            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"],
            "ChangedFiles": [
                res.real_path for res in changes.get_changed_resources()
            ],
        }
        result.update(errorDict)
        
        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
        """
        changes = self.__changes[params["ChangeGroup"]]
        
        changesData = []
        for change in changes:
            changeTitle = str(change)
            try:
                changeText = change.get_description()
            except AttributeError:
                changeText = None
            changesData.append([changeTitle, changeText])
        
        result = {
            "Subcommand": "PreviewChanges",
            "ChangeGroup": params["ChangeGroup"],
            "Description": changes.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
        """
        title = params["Title"]
        filename = params["FileName"]
        offset = params["Offset"]
        isLocal = params["LocalRename"]
        newName = params["NewName"]
        renameHierarchy = params["RenameHierarchy"]
        renameInStrings = params["RenameInStrings"]
        
        errorDict = {}
        changes = []
        result = {
            "ChangeGroup": params["ChangeGroup"],
        }
        
        import rope.refactor.rename
        resource = rope.base.libutils.path_to_resource(
            self.__project, filename)
        
        try:
            renamer = rope.refactor.rename.Rename(
                self.__project, resource, offset)
        except Exception as err:
            errorDict = self.__handleRopeError(err)
            result.update(errorDict)
            self.sendJson("Changes", result)
            return
        
        if isLocal:
            resources = [resource]
        else:
            resources = None
        
        from ProgressHandle import ProgressHandle
        self.__progressHandle = ProgressHandle(self, title, True)
        try:
            changes = renamer.get_changes(
                newName,
                resources=resources,
                in_hierarchy=renameHierarchy,
                unsure=self.__confirmUnsure,
                docs=renameInStrings,
                task_handle=self.__progressHandle)
        except Exception as err:
            errorDict = self.__handleRopeError(err)
        self.__progressHandle.reset()
        self.__progressHandle = None
        
        if changes:
            self.__changes[params["ChangeGroup"]] = changes
        
        result["Subcommand"] = "ChangesCalculated"
        result.update(errorDict)
        
        self.sendJson("Changes", result)
    
    def __confirmUnsure(self, occurrence):
        """
        Private method to confirm unsure occurrences.
        
        @parameter occurrence reference to the occurrence object
        @type rope.refactor.occurrences.Occurrence
        @return flag indicating an occurrence
        @rtype bool
        """
        # TODO: implement this method; synchronous poll

if __name__ == '__main__':
    if len(sys.argv) != 4:
        print('Host, port and project path parameters are missing. Abort.')
        sys.exit(1)
    
    host, port, projectPath = sys.argv[1:]
    client = RefactoringClient(host, int(port), projectPath)
    # Start the main loop
    client.run()
    
    sys.exit(0)

#
# eflag: noqa = M801