PluginPrintRemover.py

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

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

"""
Module implementing the Print Remover plug-in.
"""

from __future__ import unicode_literals    # __IGNORE_WARNING__

import os

from PyQt5.QtCore import QObject, QTranslator, QCoreApplication
from PyQt5.QtWidgets import QAction, QMenu

from E5Gui.E5Application import e5App

import Preferences

# Start-Of-Header
name = "Print Remover Plug-in"
author = "Detlev Offenbach <detlev@die-offenbachs.de>"
autoactivate = True
deactivateable = True
version = "2.2.0"
className = "PrintRemoverPlugin"
packageName = "PrintRemover"
shortDescription = "Remove print() like debug statements."
longDescription = \
    """This plug-in implements a tool to remove lines starting with""" \
    """ a configurable string. This is mostly used to remove print()""" \
    """ like debug statements. The match is done after stripping all""" \
    """ whitespace from the beginning of a line. Lines containing the""" \
    """ string '__NO_REMOVE__' are preserved."""
needsRestart = False
pyqtApi = 2
python2Compatible = True
# End-Of-Header

error = ""

printRemoverPluginObject = None
    

def createPrintRemoverPage(configDlg):
    """
    Module function to create the Print Remover configuration page.
    
    @param configDlg reference to the configuration dialog
    @return reference to the configuration page
    """
    global printRemoverPluginObject
    from PrintRemover.ConfigurationPage.PrintRemoverPage import \
        PrintRemoverPage
    page = PrintRemoverPage(printRemoverPluginObject)
    return page
    

def getConfigData():
    """
    Module function returning data as required by the configuration dialog.
    
    @return dictionary containing the relevant data
    """
    try:
        usesDarkPalette = e5App().usesDarkPalette()
    except AttributeError:
        from PyQt5.QtGui import QPalette
        palette = e5App().palette()
        lightness = palette.color(QPalette.Window).lightness()
        usesDarkPalette = lightness <= 128
    if usesDarkPalette:
       iconSuffix = "dark"
    else:
        iconSuffix = "light"
    
    return {
        "printRemoverPage": [
            QCoreApplication.translate("PrintRemoverPlugin",
                                       "Print Remover"),
            os.path.join("PrintRemover", "icons",
                         "printRemover-{0}".format(iconSuffix)),
            createPrintRemoverPage, None, None],
    }


def prepareUninstall():
    """
    Module function to prepare for an uninstallation.
    """
    Preferences.Prefs.settings.remove(PrintRemoverPlugin.PreferencesKey)


class PrintRemoverPlugin(QObject):
    """
    Class implementing the Print Remover plugin.
    """
    PreferencesKey = "PrintRemover"
    
    def __init__(self, ui):
        """
        Constructor
        
        @param ui reference to the user interface object (UI.UserInterface)
        """
        QObject.__init__(self, ui)
        self.__ui = ui
        
        self.__defaults = {
            "StartswithStrings": [
                "print(", "print ", "console.log"],
        }
        
        self.__translator = None
        self.__loadTranslator()
        
        self.__initMenu()
        
        self.__editors = {}
        self.__mainActions = []
    
    def activate(self):
        """
        Public method to activate this plugin.
        
        @return tuple of None and activation status (boolean)
        """
        global error
        error = ""     # clear previous error
        
        global printRemoverPluginObject
        printRemoverPluginObject = self
        
        self.__ui.showMenu.connect(self.__populateMenu)
        
        menu = self.__ui.getMenu("plugin_tools")
        if menu is not None:
            if not menu.isEmpty():
                act = menu.addSeparator()
                self.__mainActions.append(act)
            act = menu.addMenu(self.__menu)
            self.__mainActions.append(act)
        
        e5App().getObject("ViewManager").editorOpenedEd.connect(
            self.__editorOpened)
        e5App().getObject("ViewManager").editorClosedEd.connect(
            self.__editorClosed)
        
        for editor in e5App().getObject("ViewManager").getOpenEditors():
            self.__editorOpened(editor)
        
        return None, True
    
    def deactivate(self):
        """
        Public method to deactivate this plugin.
        """
        self.__ui.showMenu.disconnect(self.__populateMenu)
        
        menu = self.__ui.getMenu("plugin_tools")
        if menu is not None:
            for act in self.__mainActions:
                menu.removeAction(act)
        self.__mainActions = []

        e5App().getObject("ViewManager").editorOpenedEd.disconnect(
            self.__editorOpened)
        e5App().getObject("ViewManager").editorClosedEd.disconnect(
            self.__editorClosed)
        
        for editor, acts in self.__editors.items():
            editor.showMenu.disconnect(self.__editorShowMenu)
            menu = editor.getMenu("Tools")
            if menu is not None:
                for act in acts:
                    menu.removeAction(act)
        self.__editors = {}
    
    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__), "PrintRemover", "i18n")
                translation = "printremover_{0}".format(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 getPreferences(self, key):
        """
        Public method to retrieve the various settings.
        
        @param key the key of the value to get (string)
        @return the requested setting
        """
        if key in ["StartswithStrings"]:
            return Preferences.toList(
                Preferences.Prefs.settings.value(
                    self.PreferencesKey + "/" + key, self.__defaults[key]))
        else:
            return Preferences.Prefs.settings.value(
                self.PreferencesKey + "/" + key, self.__defaults[key])
    
    def setPreferences(self, key, value):
        """
        Public method to store the various settings.
        
        @param key the key of the setting to be set (string)
        @param value the value to be set
        """
        Preferences.Prefs.settings.setValue(
            self.PreferencesKey + "/" + key, value)
    
    def __initMenu(self):
        """
        Private method to initialize the menu.
        """
        self.__menu = QMenu("Remove Outputs")
        self.__menu.setEnabled(False)
        self.__menu.aboutToShow.connect(self.__showMenu)
    
    def __populateMenu(self, name, menu):
        """
        Private slot to populate the tools menu with our entries.
        
        @param name name of the menu (string)
        @param menu reference to the menu to be populated (QMenu)
        """
        if name not in ["Tools", "PluginTools"]:
            return
        
        editor = e5App().getObject("ViewManager").activeWindow()
        
        if name == "Tools":
            if not menu.isEmpty():
                menu.addSeparator()
            
            act = menu.addMenu(self.__menu)
            act.setEnabled(editor is not None)
        elif name == "PluginTools" and self.__mainActions:
            self.__mainActions[-1].setEnabled(editor is not None)
    
    def __editorOpened(self, editor):
        """
        Private slot called, when a new editor was opened.
        
        @param editor reference to the new editor (QScintilla.Editor)
        """
        menu = editor.getMenu("Tools")
        if menu is not None:
            self.__editors[editor] = []
            if not menu.isEmpty():
                act = menu.addSeparator()
                self.__editors[editor].append(act)
            act = menu.addMenu(self.__menu)
            self.__menu.setEnabled(True)
            self.__editors[editor].append(act)
            editor.showMenu.connect(self.__editorShowMenu)
    
    def __editorClosed(self, editor):
        """
        Private slot called, when an editor was closed.
        
        @param editor reference to the editor (QScintilla.Editor)
        """
        try:
            del self.__editors[editor]
            if not self.__editors:
                self.__menu.setEnabled(False)
        except KeyError:
            pass
    
    def __editorShowMenu(self, menuName, menu, editor):
        """
        Private slot called, when the the editor context menu or a submenu is
        about to be shown.
        
        @param menuName name of the menu to be shown (string)
        @param menu reference to the menu (QMenu)
        @param editor reference to the editor
        """
        if menuName == "Tools":
            if self.__menu.menuAction() not in menu.actions():
                # Re-add our menu
                self.__editors[editor] = []
                if not menu.isEmpty():
                    act = menu.addSeparator()
                    self.__editors[editor].append(act)
                act = menu.addMenu(self.__menu)
                self.__editors[editor].append(act)
    
    def __showMenu(self):
        """
        Private slot to build the menu hierarchy.
        """
        self.__menu.clear()
        for string in self.getPreferences("StartswithStrings"):
            if string == '--Separator--':
                self.__menu.addSeparator()
            else:
                act = self.__menu.addAction(
                    self.tr("Remove '{0}'").format(string),
                    self.__removeLine)
                act.setData(string)
    
    def __removeLine(self):
        """
        Private slot to remove lines starting with the selected pattern.
        """
        act = self.sender()
        if act is None or not isinstance(act, QAction):
            return
        
        editor = e5App().getObject("ViewManager").activeWindow()
        if editor is None:
            return
        
        pattern = act.data()
        if not pattern:
            return
        
        text = editor.text()
        newText = "".join([
            line for line in text.splitlines(True)
            if not line.lstrip().startswith(pattern) or
            "__NO_REMOVE__" in line
        ])
        if newText != text:
            editor.beginUndoAction()
            editor.selectAll()
            editor.replaceSelectedText(newText)
            editor.endUndoAction()

#
# eflag: noqa = M801