PluginRefactoringRope.py

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

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

"""
Module implementing the Rope refactoring plugin.
"""

from __future__ import unicode_literals    # __IGNORE_WARNING__

import os
import sys

from PyQt4.QtCore import QObject, QTranslator

from E5Gui.E5Application import e5App

from Preferences.Shortcuts import readShortcuts

# Start-Of-Header
name = "Refactoring Rope Plugin"
author = "Detlev Offenbach <detlev@die-offenbachs.de>"
autoactivate = True
deactivateable = True
version = "2.4.0"
className = "RefactoringRopePlugin"
packageName = "RefactoringRope"
internalPackages = "rope"
shortDescription = "Refactoring using the Rope library."
longDescription = """This plugin implements refactoring functionality""" \
    """ using the Rope refactoring library. Only refactoring in the same""" \
    """ Python version as Eric is running is allowed."""
pyqtApi = 2
doNotCompile = True
# End-Of-Header

error = ""


class RefactoringRopePlugin(QObject):
    """
    Class implementing the Rope refactoring plugin.
    """
    def __init__(self, ui):
        """
        Constructor
        
        @param ui reference to the user interface object (UI.UserInterface)
        """
        QObject.__init__(self, ui)
        self.__ui = ui
        self.__initialize()
        
        self.__translator = None
        self.__loadTranslator()
    
    def __initialize(self):
        """
        Private slot to (re)initialize the plugin.
        """
        self.__object = None
        
        self.__mainAct = None
        self.__mainMenu = None
        self.__projectIsOpen = False
    
    def __checkUiVersion(self):
        """
        Private method to check, if the IDE has a suitable version.
        
        @return flag indicating a suitable version (boolean)
        """
        global error
        
        suitable = self.__ui.versionIsNewer("5.0.99", "20100811")
        if not suitable:
            error = self.trUtf8("Your version of eric5 is not supported.")
        return suitable
    
    def activate(self):
        """
        Public method to activate this plugin.
        
        @return tuple of None and activation status (boolean)
        """
        global error
        error = ""     # clear previous error
        
        if not self.__checkUiVersion():
            return None, False
        
        from RefactoringRope.Refactoring import Refactoring
        
        self.__object = Refactoring(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)
        
        if e5App().getObject("Project").isOpen():
            self.__mainAct.setEnabled(True)
            self.__object.projectOpened()
        else:
            self.__mainAct.setEnabled(False)
        
        e5App().getObject("Project").projectOpened.connect(
            self.__object.projectOpened)
        e5App().getObject("Project").projectClosed.connect(
            self.__object.projectClosed)
        e5App().getObject("Project").newProject.connect(
            self.__object.projectOpened)
        
        e5App().getObject("Project").projectOpened.connect(
            self.__projectOpened)
        e5App().getObject("Project").projectClosed.connect(
            self.__projectClosed)
        e5App().getObject("Project").newProject.connect(
            self.__projectOpened)
        
        return None, True
    
    def deactivate(self):
        """
        Public method to deactivate this plugin.
        """
        e5App().unregisterPluginObject("RefactoringRope")
        
        e5App().getObject("Project").projectOpened.disconnect(
            self.__object.projectOpened)
        e5App().getObject("Project").projectClosed.disconnect(
            self.__object.projectClosed)
        e5App().getObject("Project").newProject.disconnect(
            self.__object.projectOpened)
        
        e5App().getObject("Project").projectOpened.disconnect(
            self.__projectOpened)
        e5App().getObject("Project").projectClosed.disconnect(
            self.__projectClosed)
        e5App().getObject("Project").newProject.disconnect(
            self.__projectOpened)
        
        self.__ui.menuBar().removeAction(self.__mainAct)
        
        self.__initialize()
    
    def __loadTranslator(self):
        """
        Private method to load the translation file.
        """
        if self.__ui is not None:
            loc = self.__ui.getLocale()
            if loc and loc != "C":
                locale_dir = \
                    os.path.join(os.path.dirname(__file__),
                                 "RefactoringRope", "i18n")
                translation = "rope_%s" % loc
                translator = QTranslator(None)
                loaded = translator.load(translation, locale_dir)
                if loaded:
                    self.__translator = translator
                    e5App().installTranslator(self.__translator)
                else:
                    print("Warning: translation file '{0}' could not"
                          " be loaded.".format(translation))
                    print("Using default.")
    
    def __projectOpened(self):
        """
        Public slot to handle the projectOpened signal.
        """
        if sys.version_info[0] == 3:
            lang = ["Python3"]
        elif sys.version_info[0] == 2:
            lang = ["Python", "Python2"]
        else:
            lang = []
            
        if e5App().getObject("Project").getProjectLanguage() in lang:
                self.__mainAct.setEnabled(True)
                self.__projectIsOpen = True
    
    def __projectClosed(self):
        """
        Public slot to handle the projectClosed signal.
        """
        self.__mainAct.setEnabled(False)
        self.__projectIsOpen = False