ProjectFlask/FlaskBabelExtension/PyBabelProjectExtension.py

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

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

"""
Module implementing the project support for flask-babel.
"""

import contextlib
import os
import re

from PyQt6.QtCore import pyqtSlot, QObject, QProcess
from PyQt6.QtWidgets import QDialog, QMenu

from eric7 import Utilities
from eric7.EricGui.EricAction import EricAction
from eric7.EricWidgets import EricMessageBox
from eric7.EricWidgets.EricApplication import ericApp

from .PyBabelCommandDialog import PyBabelCommandDialog


class PyBabelProject(QObject):
    """
    Class implementing the flask-babel project support.
    """

    def __init__(self, plugin, project, parent=None):
        """
        Constructor

        @param plugin reference to the plugin object
        @type ProjectFlaskPlugin
        @param project reference to the project object
        @type Project
        @param parent parent
        @type QObject
        """
        super().__init__(parent)

        self.__plugin = plugin
        self.__project = project

        self.__ericProject = ericApp().getObject("Project")

        self.__hooksInstalled = False

    def initActions(self):
        """
        Public method to define the flask-babel actions.
        """
        self.actions = []

        self.pybabelConfigAct = EricAction(
            self.tr("Configure flask-babel"),
            self.tr("&Configure flask-babel"),
            0,
            0,
            self,
            "flask_config_pybabel",
        )
        self.pybabelConfigAct.setStatusTip(
            self.tr("Shows a dialog to edit the configuration for flask-babel")
        )
        self.pybabelConfigAct.setWhatsThis(
            self.tr(
                """<b>Configure flask-babel</b>"""
                """<p>Shows a dialog to edit the configuration for """
                """flask-babel.</p>"""
            )
        )
        self.pybabelConfigAct.triggered.connect(self.__configurePyBabel)
        self.actions.append(self.pybabelConfigAct)

        self.pybabelInstallAct = EricAction(
            self.tr("Install flask-babel"),
            self.tr("&Install flask-babel"),
            0,
            0,
            self,
            "flask_install_pybabel",
        )
        self.pybabelInstallAct.setStatusTip(
            self.tr(
                "Installs the flask-babel extension into the configured" " environment"
            )
        )
        self.pybabelInstallAct.setWhatsThis(
            self.tr(
                """<b>Install flask-babel</b>"""
                """<p>Installs the flask-babel extension into the configured"""
                """ environment using the pip interface.</p>"""
            )
        )
        self.pybabelInstallAct.triggered.connect(self.__installFlaskBabel)
        self.actions.append(self.pybabelInstallAct)

        self.pybabelAvailabilityAct = EricAction(
            self.tr("Check flask-babel Availability"),
            self.tr("Check flask-babel &Availability"),
            0,
            0,
            self,
            "flask_check_pybabel",
        )
        self.pybabelAvailabilityAct.setStatusTip(
            self.tr("Check the availability of the flask-babel extension")
        )
        self.pybabelAvailabilityAct.setWhatsThis(
            self.tr(
                """<b>Check flask-babel Availability</b>"""
                """<p>Check the availability of the flask-babel extension.</p>"""
            )
        )
        self.pybabelAvailabilityAct.triggered.connect(self.__checkAvailability)
        self.actions.append(self.pybabelAvailabilityAct)

    def initMenu(self):
        """
        Public method to initialize the flask-babel menu.

        @return the menu generated
        @rtype QMenu
        """
        menu = QMenu(self.tr("Translations"))
        menu.setTearOffEnabled(True)

        menu.addAction(self.pybabelConfigAct)
        menu.addSeparator()
        menu.addAction(self.pybabelAvailabilityAct)
        menu.addAction(self.pybabelInstallAct)

        return menu

    def registerOpenHook(self):
        """
        Public method to register the open hook to open a translations file
        in a translations editor.
        """
        if self.__hooksInstalled:
            editor = self.__plugin.getPreferences("TranslationsEditor")
            if editor:
                self.__translationsBrowser.addHookMethodAndMenuEntry(
                    "open",
                    self.openPOEditor,
                    self.tr("Open with {0}").format(os.path.basename(editor)),
                )
            else:
                self.__translationsBrowser.removeHookMethod("open")

    def projectOpenedHooks(self):
        """
        Public method to add our hook methods.
        """
        if self.__project.hasCapability("flask-babel"):
            self.__ericProject.projectLanguageAddedByCode.connect(
                self.__projectLanguageAdded
            )
            self.__translationsBrowser = (
                ericApp().getObject("ProjectBrowser").getProjectBrowser("translations")
            )
            self.__translationsBrowser.addHookMethodAndMenuEntry(
                "extractMessages", self.extractMessages, self.tr("Extract Messages")
            )
            self.__translationsBrowser.addHookMethodAndMenuEntry(
                "releaseAll", self.compileCatalogs, self.tr("Compile All Catalogs")
            )
            self.__translationsBrowser.addHookMethodAndMenuEntry(
                "releaseSelected",
                self.compileSelectedCatalogs,
                self.tr("Compile Selected Catalogs"),
            )
            self.__translationsBrowser.addHookMethodAndMenuEntry(
                "generateAll", self.updateCatalogs, self.tr("Update All Catalogs")
            )
            self.__translationsBrowser.addHookMethodAndMenuEntry(
                "generateAllWithObsolete",
                self.updateCatalogsObsolete,
                self.tr("Update All Catalogs (with obsolete)"),
            )
            self.__translationsBrowser.addHookMethodAndMenuEntry(
                "generateSelected",
                self.updateSelectedCatalogs,
                self.tr("Update Selected Catalogs"),
            )
            self.__translationsBrowser.addHookMethodAndMenuEntry(
                "generateSelectedWithObsolete",
                self.updateSelectedCatalogsObsolete,
                self.tr("Update Selected Catalogs (with obsolete)"),
            )

            self.__hooksInstalled = True

            self.registerOpenHook()

    def projectClosedHooks(self):
        """
        Public method to remove our hook methods.
        """
        if self.__hooksInstalled:
            self.__ericProject.projectLanguageAddedByCode.disconnect(
                self.__projectLanguageAdded
            )
            self.__translationsBrowser.removeHookMethod("extractMessages")
            self.__translationsBrowser.removeHookMethod("releaseAll")
            self.__translationsBrowser.removeHookMethod("releaseSelected")
            self.__translationsBrowser.removeHookMethod("generateAll")
            self.__translationsBrowser.removeHookMethod("generateAllWithObsolete")
            self.__translationsBrowser.removeHookMethod("generateSelected")
            self.__translationsBrowser.removeHookMethod("generateSelectedWithObsolete")
            self.__translationsBrowser.removeHookMethod("open")
            self.__translationsBrowser = None

        self.__hooksInstalled = False

    def determineCapability(self):
        """
        Public method to determine the availability of flask-babel.
        """
        available = (
            self.__project.getData("flask", "flask_babel_available")
            if self.__project.getData("flask", "flask_babel_override")
            else self.__flaskBabelAvailable()
        )
        self.__project.setCapability("flask-babel", available)

        self.pybabelConfigAct.setEnabled(available)
        self.pybabelInstallAct.setEnabled(not available)

    ##################################################################
    ## slots and methods below implement general functionality
    ##################################################################

    def getBabelCommand(self):
        """
        Public method to build the Babel command.

        @return full pybabel command
        @rtype str
        """
        return self.__project.getFullCommand("pybabel")

    ##################################################################
    ## slots and methods below implement i18n and l10n support
    ##################################################################

    def __flaskBabelAvailable(self):
        """
        Private method to check, if the 'flask-babel' package is available.

        @return flag indicating the availability of 'flask-babel'
        @rtype bool
        """
        interpreter = self.__project.getVirtualenvInterpreter()
        if interpreter and Utilities.isinpath(interpreter):
            detector = os.path.join(os.path.dirname(__file__), "FlaskBabelDetector.py")
            proc = QProcess()
            proc.setProcessChannelMode(QProcess.ProcessChannelMode.MergedChannels)
            proc.start(interpreter, [detector])
            finished = proc.waitForFinished(30000)
            if finished and proc.exitCode() == 0:
                return True

        return False

    @pyqtSlot()
    def __configurePyBabel(self):
        """
        Private slot to show a dialog to edit the pybabel configuration.
        """
        from .PyBabelConfigDialog import PyBabelConfigDialog

        config = self.__project.getData("flask-babel", "")
        dlg = PyBabelConfigDialog(config)
        if dlg.exec() == QDialog.DialogCode.Accepted:
            config = dlg.getConfiguration()
            self.__project.setData("flask-babel", "", config)

            self.__ericProject.setTranslationPattern(
                os.path.join(
                    config["translationsDirectory"],
                    "%language%",
                    "LC_MESSAGES",
                    "{0}.po".format(config["domain"]),
                )
            )
            self.__ericProject.setDirty(True)

            cfgFileName = self.__ericProject.getAbsoluteUniversalPath(
                config["configFile"]
            )
            if not os.path.exists(cfgFileName):
                self.__createBabelCfg(cfgFileName)

    def __ensurePybabelConfigured(self):
        """
        Private method to ensure, that PyBabel has been configured.

        @return flag indicating successful configuration
        @rtype bool
        """
        config = self.__project.getData("flask-babel", "")
        if not config:
            self.__configurePybabel()
            return True

        configFileName = self.__project.getData("flask-babel", "configFile")
        if configFileName:
            cfgFileName = self.__ericProject.getAbsoluteUniversalPath(configFileName)
            if os.path.exists(cfgFileName):
                return True
            else:
                return self.__createBabelCfg(cfgFileName)

        return False

    def __createBabelCfg(self, configFile):
        """
        Private method to create a template pybabel configuration file.

        @param configFile name of the configuration file to be created
        @type str
        @return flag indicating successful configuration file creation
        @rtype bool
        """
        _, app = self.__project.getApplication()
        template = (
            (
                "[python: {0}]\n"
                "[jinja2: templates/**.html]\n"
                "extensions=jinja2.ext.autoescape,jinja2.ext.with_\n"
            )
            if app.endswith(".py")
            else (
                "[python: {0}/**.py]\n"
                "[jinja2: {0}/templates/**.html]\n"
                "extensions=jinja2.ext.autoescape,jinja2.ext.with_\n"
            )
        )
        try:
            with open(configFile, "w") as f:
                f.write(template.format(app))
            self.__ericProject.appendFile(configFile)
            EricMessageBox.information(
                None,
                self.tr("Generate PyBabel Configuration File"),
                self.tr(
                    """The PyBabel configuration file was created."""
                    """ Please edit it to adjust the entries as"""
                    """ required."""
                ),
            )
            return True
        except OSError as err:
            EricMessageBox.warning(
                None,
                self.tr("Generate PyBabel Configuration File"),
                self.tr(
                    """<p>The PyBabel Configuration File could not be"""
                    """ generated.</p><p>Reason: {0}</p>"""
                ).format(str(err)),
            )
            return False

    @pyqtSlot()
    def __installFlaskBabel(self):
        """
        Private slot to install the flask-babel extension into the configured
        environment.
        """
        venvName = self.__project.getVirtualEnvironment()
        if venvName:
            interpreter = self.__project.getFullCommand("python")
            pip = ericApp().getObject("Pip")
            pip.installPackages(["flask-babel"], interpreter=interpreter)
            self.determineCapability()
        else:
            EricMessageBox.critical(
                None,
                self.tr("Install flask-babel"),
                self.tr(
                    "The 'flask-babel' extension could not be installed"
                    " because no virtual environment has been"
                    " configured."
                ),
            )

    @pyqtSlot()
    def __checkAvailability(self):
        """
        Private slot to check the availability of the 'flask-babel' extension.
        """
        self.determineCapability()
        msg = (
            self.tr("The 'flask-babel' extension is installed.")
            if self.__project.hasCapability("flask-babel")
            else self.tr("The 'flask-babel' extension is not installed.")
        )
        EricMessageBox.information(None, self.tr("flask-babel Availability"), msg)

    def __getLocale(self, filename):
        """
        Private method to extract the locale out of a file name.

        @param filename name of the file used for extraction
        @type str
        @return extracted locale
        @rtype str or None
        """
        if self.__ericProject.getTranslationPattern():
            filename = os.path.splitext(filename)[0] + ".po"

            # On Windows, path typically contains backslashes. This leads
            # to an invalid search pattern '...\(' because the opening bracket
            # will be escaped.
            pattern = self.__ericProject.getTranslationPattern()
            pattern = os.path.normpath(pattern)
            pattern = pattern.replace("%language%", "(.*?)")
            pattern = pattern.replace("\\", "\\\\")
            match = re.search(pattern, filename)
            if match is not None:
                return match.group(1)

        return None

    def openPOEditor(self, poFile):
        """
        Public method to edit the given file in an external .po editor.

        @param poFile name of the .po file
        @type str
        """
        editor = self.__plugin.getPreferences("TranslationsEditor")
        if poFile.endswith(".po") and editor:
            workdir = self.__project.getApplication()[0]
            started, pid = QProcess.startDetached(editor, [poFile], workdir)
            if not started:
                EricMessageBox.critical(
                    None,
                    self.tr("Process Generation Error"),
                    self.tr(
                        "The translations editor process ({0}) could" " not be started."
                    ).format(os.path.basename(editor)),
                )

    def extractMessages(self):
        """
        Public method to extract the messages catalog template file.
        """
        title = self.tr("Extract messages")
        if self.__ensurePybabelConfigured():
            workdir = self.__project.getApplication()[0]
            potFile = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "catalogFile")
            )

            with contextlib.suppress(OSError):
                potFilePath = os.path.dirname(potFile)
                os.makedirs(potFilePath)

            args = [
                "-F",
                os.path.relpath(
                    self.__ericProject.getAbsoluteUniversalPath(
                        self.__project.getData("flask-babel", "configFile")
                    ),
                    workdir,
                ),
            ]
            if self.__project.getData("flask-babel", "markersList"):
                for marker in self.__project.getData("flask-babel", "markersList"):
                    args += ["-k", marker]
            args += ["-o", os.path.relpath(potFile, workdir), "."]

            dlg = PyBabelCommandDialog(
                self, title, msgSuccess=self.tr("\nMessages extracted successfully.")
            )
            res = dlg.startCommand("extract", args, workdir)
            if res:
                dlg.exec()
                self.__ericProject.appendFile(potFile)

    def __projectLanguageAdded(self, code):
        """
        Private slot handling the addition of a new language.

        @param code language code of the new language
        @type str
        """
        title = self.tr("Initializing message catalog for '{0}'").format(code)

        if self.__ensurePybabelConfigured():
            workdir = self.__project.getApplication()[0]
            langFile = self.__ericProject.getAbsoluteUniversalPath(
                self.__ericProject.getTranslationPattern().replace("%language%", code)
            )
            potFile = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "catalogFile")
            )

            args = [
                "--domain={0}".format(self.__project.getData("flask-babel", "domain")),
                "--input-file={0}".format(os.path.relpath(potFile, workdir)),
                "--output-file={0}".format(os.path.relpath(langFile, workdir)),
                "--locale={0}".format(code),
            ]

            dlg = PyBabelCommandDialog(
                self,
                title,
                msgSuccess=self.tr("\nMessage catalog initialized successfully."),
            )
            res = dlg.startCommand("init", args, workdir)
            if res:
                dlg.exec()

                self.__ericProject.appendFile(langFile)

    def compileCatalogs(self, filenames):
        """
        Public method to compile the message catalogs.

        @param filenames list of filenames (not used)
        @type list of str
        """
        title = self.tr("Compiling message catalogs")

        if self.__ensurePybabelConfigured():
            workdir = self.__project.getApplication()[0]
            translationsDirectory = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "translationsDirectory")
            )

            args = [
                "--domain={0}".format(self.__project.getData("flask-babel", "domain")),
                "--directory={0}".format(
                    os.path.relpath(translationsDirectory, workdir)
                ),
                "--use-fuzzy",
                "--statistics",
            ]

            dlg = PyBabelCommandDialog(
                self,
                title,
                msgSuccess=self.tr("\nMessage catalogs compiled successfully."),
            )
            res = dlg.startCommand("compile", args, workdir)
            if res:
                dlg.exec()

                for entry in os.walk(translationsDirectory):
                    for fileName in entry[2]:
                        fullName = os.path.join(entry[0], fileName)
                        if fullName.endswith(".mo"):
                            self.__ericProject.appendFile(fullName)

    def compileSelectedCatalogs(self, filenames):
        """
        Public method to update the message catalogs.

        @param filenames list of file names
        @type list of str
        """
        title = self.tr("Compiling message catalogs")

        locales = {self.__getLocale(f) for f in filenames}

        if len(locales) == 0:
            EricMessageBox.warning(
                self.__ui, title, self.tr("No locales detected. Aborting...")
            )
            return

        if self.__ensurePybabelConfigured():
            workdir = self.__project.getApplication()[0]
            translationsDirectory = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "translationsDirectory")
            )

            argsList = []
            for loc in locales:
                argsList.append(
                    [
                        "compile",
                        "--domain={0}".format(
                            self.__project.getData("flask-babel", "domain")
                        ),
                        "--directory={0}".format(
                            os.path.relpath(translationsDirectory, workdir)
                        ),
                        "--use-fuzzy",
                        "--statistics",
                        "--locale={0}".format(loc),
                    ]
                )

            dlg = PyBabelCommandDialog(
                self,
                title=title,
                msgSuccess=self.tr("\nMessage catalogs compiled successfully."),
            )
            res = dlg.startBatchCommand(argsList, workdir)
            if res:
                dlg.exec()

                for entry in os.walk(translationsDirectory):
                    for fileName in entry[2]:
                        fullName = os.path.join(entry[0], fileName)
                        if fullName.endswith(".mo"):
                            self.__ericProject.appendFile(fullName)

    def updateCatalogs(self, filenames, withObsolete=False):
        """
        Public method to update the message catalogs.

        @param filenames list of filenames (not used)
        @type list of str
        @param withObsolete flag indicating to keep obsolete translations
        @type bool
        """
        title = self.tr("Updating message catalogs")

        if self.__ensurePybabelConfigured():
            workdir = self.__project.getApplication()[0]
            translationsDirectory = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "translationsDirectory")
            )
            potFile = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "catalogFile")
            )

            args = [
                "--domain={0}".format(self.__project.getData("flask-babel", "domain")),
                "--input-file={0}".format(os.path.relpath(potFile, workdir)),
                "--output-dir={0}".format(
                    os.path.relpath(translationsDirectory, workdir)
                ),
            ]
            if not withObsolete:
                args.append("--ignore-obsolete")

            dlg = PyBabelCommandDialog(
                self,
                title,
                msgSuccess=self.tr("\nMessage catalogs updated successfully."),
            )
            res = dlg.startCommand("update", args, workdir)
            if res:
                dlg.exec()

    def updateCatalogsObsolete(self, filenames):
        """
        Public method to update the message catalogs keeping obsolete
        translations.

        @param filenames list of filenames (not used)
        @type list of str
        """
        self.updateCatalogs(filenames, withObsolete=True)

    def updateSelectedCatalogs(self, filenames, withObsolete=False):
        """
        Public method to update the selected message catalogs.

        @param filenames list of filenames
        @type list of str
        @param withObsolete flag indicating to keep obsolete translations
        @type bool
        """
        title = self.tr("Updating message catalogs")

        locales = {self.__getLocale(f) for f in filenames}

        if len(locales) == 0:
            EricMessageBox.warning(
                self.__ui, title, self.tr("No locales detected. Aborting...")
            )
            return

        if self.__ensurePybabelConfigured():
            workdir = self.__project.getApplication()[0]
            translationsDirectory = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "translationsDirectory")
            )
            potFile = self.__ericProject.getAbsoluteUniversalPath(
                self.__project.getData("flask-babel", "catalogFile")
            )
            argsList = []
            for loc in locales:
                args = [
                    "update",
                    "--domain={0}".format(
                        self.__project.getData("flask-babel", "domain")
                    ),
                    "--input-file={0}".format(os.path.relpath(potFile, workdir)),
                    "--output-dir={0}".format(
                        os.path.relpath(translationsDirectory, workdir)
                    ),
                    "--locale={0}".format(loc),
                ]
                if not withObsolete:
                    args.append("--ignore-obsolete")
                argsList.append(args)

            dlg = PyBabelCommandDialog(
                self,
                title=title,
                msgSuccess=self.tr("\nMessage catalogs updated successfully."),
            )
            res = dlg.startBatchCommand(argsList, workdir)
            if res:
                dlg.exec()

    def updateSelectedCatalogsObsolete(self, filenames):
        """
        Public method to update the message catalogs keeping obsolete
        translations.

        @param filenames list of filenames (not used)
        @type list of str
        """
        self.updateSelectedCatalogs(filenames, withObsolete=True)