feat(alerts): add unused glossary alert

Warn users that there is a unused language in the glossary.

See #20088

Author: nijel

docs/devel/alerts.rst

@@ -25,6 +25,7 @@ Currently the following is covered:
 * Duplicate file mask used for linked components
 * Conflicting merge request repository setup
 * Component seems unused (configurable by :setting:`UNUSED_ALERT_DAYS`)
+* Unused glossary languages
 
 The alerts are updated daily, or on related change (for example when
 :ref:`component` is changed or when repository is updated).

weblate/glossary/tasks.py

@@ -4,6 +4,8 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from django.db import transaction
 
 from weblate.auth.models import get_anonymous
@@ -13,6 +15,9 @@
 from weblate.utils.lock import WeblateLockTimeoutError
 from weblate.utils.stats import prefetch_stats
 
+if TYPE_CHECKING:
+    from weblate.trans.models.translation import TranslationQuerySet
+
 
 @app.task(
     trail=False,
@@ -49,6 +54,36 @@ def sync_glossary_languages(pk: int, component: Component | None = None) -> None
             component.create_translations_immediate(force_scan=True)
 
 
+def get_stale_glossary_translations(
+    project: Project, component: Component | None = None
+) -> TranslationQuerySet:
+    """
+    Return glossary translations for languages unused by regular components.
+
+    The source translation is excluded because it is expected to exist even if
+    there are no matching regular component translations.
+    """
+    languages_in_non_glossary_components: set[int] = set(
+        Translation.objects.filter(
+            component__project=project, component__is_glossary=False
+        ).values_list("language_id", flat=True)
+    )
+    if not languages_in_non_glossary_components:
+        return Translation.objects.none()
+
+    stale_glossaries = Translation.objects.filter(
+        component__project=project, component__is_glossary=True
+    )
+    if component is not None:
+        stale_glossaries = stale_glossaries.filter(component=component)
+
+    return (
+        stale_glossaries.prefetch()
+        .exclude(language__id__in=languages_in_non_glossary_components)
+        .exclude_source()
+    )
+
+
 @app.task(trail=False, autoretry_for=(Project.DoesNotExist, WeblateLockTimeoutError))
 def cleanup_stale_glossaries(project: int | Project) -> None:
     """
@@ -66,20 +101,7 @@ def cleanup_stale_glossaries(project: int | Project) -> None:
     if isinstance(project, int):
         project = Project.objects.get(pk=project)
 
-    languages_in_non_glossary_components: set[int] = set(
-        Translation.objects.filter(
-            component__project=project, component__is_glossary=False
-        ).values_list("language_id", flat=True)
-    )
-
-    glossary_translations = prefetch_stats(
-        Translation.objects.filter(
-            component__project=project, component__is_glossary=True
-        )
-        .prefetch()
-        .exclude(language__id__in=languages_in_non_glossary_components)
-        .exclude_source()
-    )
+    glossary_translations = prefetch_stats(get_stale_glossary_translations(project))
 
     component_to_check = []
 

weblate/glossary/tests.py

@@ -19,9 +19,11 @@
 from weblate.glossary.models import get_glossary_terms, get_glossary_tsv
 from weblate.glossary.tasks import (
     cleanup_stale_glossaries,
+    get_stale_glossary_translations,
     sync_terminology,
 )
 from weblate.lang.models import Language
+from weblate.trans.alerts.registry import update_alerts
 from weblate.trans.models import PendingUnitChange, Unit
 from weblate.trans.tests.test_views import ViewTestCase
 from weblate.trans.tests.utils import get_test_file
@@ -136,6 +138,35 @@ def add_term(self, source, target, context="") -> None:
         )
         self.glossary.invalidate_cache()
 
+    def make_glossary_language_stale(
+        self, language_code: str, source: str | None = None
+    ) -> Translation:
+        language = Language.objects.get(code=language_code)
+        self.component.translation_set.filter(language=language).delete()
+        glossary = self.glossary_component.translation_set.get(language=language)
+        if source is not None:
+            with self.captureOnCommitCallbacks(execute=True):
+                glossary.add_unit(None, "", source, source, author=self.user)
+        return glossary
+
+    def assert_unused_glossary_language_alert(self, *language_codes: str) -> None:
+        if not language_codes:
+            self.assertFalse(
+                self.glossary_component.alert_set.filter(
+                    name="UnusedGlossaryLanguage"
+                ).exists()
+            )
+            return
+
+        alert = self.glossary_component.alert_set.get(name="UnusedGlossaryLanguage")
+        self.assertEqual(
+            {
+                occurrence["language_code"]
+                for occurrence in alert.details["occurrences"]
+            },
+            set(language_codes),
+        )
+
     def test_import(self) -> None:
         """Test for importing of TBX into glossary."""
 
@@ -651,6 +682,83 @@ def test_stale_glossaries_cleanup(self) -> None:
             self.glossary_component.translation_set.count(), initial_count - 1
         )
 
+    def test_stale_glossary_translations(self) -> None:
+        self.assertFalse(get_stale_glossary_translations(self.project).exists())
+
+        self.make_glossary_language_stale("de")
+
+        self.assertEqual(
+            list(
+                get_stale_glossary_translations(self.project).values_list(
+                    "language_code", flat=True
+                )
+            ),
+            ["de"],
+        )
+
+        self.component.delete()
+
+        self.assertFalse(get_stale_glossary_translations(self.project).exists())
+
+    def test_unused_glossary_language_alert(self) -> None:
+        glossary = self.make_glossary_language_stale("de", "unused de")
+
+        cleanup_stale_glossaries(self.project.id)
+
+        self.assertTrue(
+            self.glossary_component.translation_set.filter(pk=glossary.pk).exists()
+        )
+        self.assert_unused_glossary_language_alert()
+
+        update_alerts(self.glossary_component, {"UnusedGlossaryLanguage"})
+
+        self.assert_unused_glossary_language_alert("de")
+        alert = self.glossary_component.alert_set.get(name="UnusedGlossaryLanguage")
+        removal_url = f"{glossary.get_absolute_url()}#organize"
+
+        self.assertFalse(self.user.has_perm("translation.delete", glossary))
+        self.assertNotIn(removal_url, alert.render(self.user))
+
+        self.make_manager()
+        self.user.clear_cache()
+        self.assertTrue(self.user.has_perm("translation.delete", glossary))
+        self.assertIn(removal_url, alert.render(self.user))
+
+    def test_unused_glossary_language_alert_ignores_blank_local_glossary(self) -> None:
+        self.make_glossary_language_stale("de")
+
+        update_alerts(self.glossary_component, {"UnusedGlossaryLanguage"})
+
+        self.assert_unused_glossary_language_alert()
+
+    def test_unused_glossary_language_alert_ignores_matching_language(self) -> None:
+        update_alerts(self.glossary_component, {"UnusedGlossaryLanguage"})
+
+        self.assert_unused_glossary_language_alert()
+
+    def test_unused_glossary_language_alert_ignores_glossary_only_project(self) -> None:
+        self.component.delete()
+
+        update_alerts(self.glossary_component, {"UnusedGlossaryLanguage"})
+
+        self.assert_unused_glossary_language_alert()
+
+    def test_unused_glossary_language_alert_updates_on_removal(self) -> None:
+        czech_glossary = self.make_glossary_language_stale("cs", "unused cs")
+        german_glossary = self.make_glossary_language_stale("de", "unused de")
+        update_alerts(self.glossary_component, {"UnusedGlossaryLanguage"})
+        self.assert_unused_glossary_language_alert("cs", "de")
+
+        with self.captureOnCommitCallbacks(execute=True):
+            german_glossary.remove(self.user)
+
+        self.assert_unused_glossary_language_alert("cs")
+
+        with self.captureOnCommitCallbacks(execute=True):
+            czech_glossary.remove(self.user)
+
+        self.assert_unused_glossary_language_alert()
+
     def test_prohibited_initial_character(self) -> None:
         """Test that a prohibited initial character in views."""
         self.make_manager()

weblate/templates/trans/alert/unusedglossarylanguage.html

@@ -0,0 +1,33 @@
+{% load i18n permissions %}
+
+<p>{% translate "The glossary contains languages not used by any regular component in this project." %}</p>
+
+<p>{% translate "Remove the glossary language if it is no longer needed, or add matching translations to regular components if the glossary should be used." %}</p>
+
+<p>{% translate "The following occurrences were found:" %}</p>
+
+<table class="table table-sm">
+  <thead>
+    <tr>
+      <th>{% translate "Language" %}</th>
+      <th>{% translate "Language code" %}</th>
+      <th></th>
+    </tr>
+  </thead>
+  <tbody>
+    {% for occurrence in occurrences %}
+      <tr>
+        <td>{{ occurrence.language }}</td>
+        <td>{{ occurrence.language_code }}</td>
+        <td>
+          {% perm "translation.delete" occurrence.translation as user_can_delete_translation %}
+          {% if user_can_delete_translation %}
+            <a href="{{ occurrence.translation.get_absolute_url }}#organize">{% translate "Remove" %}</a>
+          {% endif %}
+        </td>
+      </tr>
+    {% endfor %}
+  </tbody>
+</table>
+
+{% include "trans/alert/occurrences-limit.html" %}

weblate/trans/alerts/config.py

@@ -16,7 +16,7 @@
 from weblate_language_data.ambiguous import AMBIGUOUS
 
 from weblate.formats.models import FILE_FORMATS
-from weblate.trans.alerts.base import AlertSeverity, BaseAlert
+from weblate.trans.alerts.base import AlertSeverity, BaseAlert, MultiAlert
 from weblate.trans.alerts.registry import register
 from weblate.utils.requests import (
     format_validation_error,
@@ -341,3 +341,56 @@ class MonolingualGlossary(BaseAlert):
     @staticmethod
     def check_component(component: Component) -> bool | dict | None:
         return component.is_glossary and bool(component.template)
+
+
+@register
+class UnusedGlossaryLanguage(MultiAlert):
+    verbose = gettext_lazy("Unused glossary language.")
+    doc_page = "user/glossary"
+
+    def process_occurrences(
+        self, occurrences: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        result = super().process_occurrences(occurrences)
+        updates: dict[int, list[dict[str, Any]]] = {}
+        for occurrence in result:
+            if "translation_pk" not in occurrence:
+                continue
+            updates.setdefault(occurrence["translation_pk"], []).append(occurrence)
+        if not updates:
+            return result
+
+        # ruff: ignore[import-outside-top-level]
+        from weblate.trans.models import Translation
+
+        for translation in Translation.objects.filter(pk__in=updates).select_related(
+            "component", "language"
+        ):
+            for occurrence in updates[translation.pk]:
+                occurrence["translation"] = translation
+        return result
+
+    @staticmethod
+    def check_component(component: Component) -> bool | dict | None:
+        if not component.is_glossary:
+            return False
+
+        # ruff: ignore[import-outside-top-level]
+        from weblate.glossary.tasks import get_stale_glossary_translations
+
+        # ruff: ignore[import-outside-top-level]
+        from weblate.utils.stats import prefetch_stats
+
+        occurrences = [
+            {
+                "language_code": translation.language_code,
+                "translation_pk": translation.pk,
+            }
+            for translation in prefetch_stats(
+                get_stale_glossary_translations(component.project, component)
+            )
+            if not translation.can_be_deleted()
+        ]
+        if occurrences:
+            return {"occurrences": occurrences}
+        return False

weblate/trans/models/translation.py

@@ -2066,7 +2066,11 @@ def remove(self, user: User) -> None:
             cleanup_stale_glossaries,
         )
 
+        # ruff: ignore[import-outside-top-level]
+        from weblate.trans.alerts.registry import update_alerts
+
         author = user.get_author_name()
+        component = self.component
         # Log
         self.log_info("removing %s as %s", self.filenames, author)
 
@@ -2079,22 +2083,26 @@ def remove(self, user: User) -> None:
         # to ensure add-ons operate on the updated translation set
         self.delete()
         transaction.on_commit(self.stats.update_parents)
-        transaction.on_commit(self.component.schedule_update_checks)
+        transaction.on_commit(component.schedule_update_checks)
+        if component.is_glossary:
+            transaction.on_commit(
+                lambda: update_alerts(component, {"UnusedGlossaryLanguage"})
+            )
 
         # Remove file from VCS
         if any(os.path.exists(name) for name in self.filenames):
-            with self.component.track_local_head_change():
+            with component.track_local_head_change():
                 # Notify add-ons (they may update LINGUAS, configure, etc.)
                 translation_post_remove.send(sender=self.__class__, translation=self)
 
                 # Remove files and commit together with add-on changes
-                self.component.repository.remove(
+                component.repository.remove(
                     self.filenames,
                     commit_message,
                     author,
                     extra_commit_files=self.addon_commit_files or None,
                 )
-                self.component.push_if_needed()
+                component.push_if_needed()
 
         # Remove blank directory if still present (appstore)
         filename = Path(self.get_filename())
@@ -2103,14 +2111,14 @@ def remove(self, user: User) -> None:
                 filename.rmdir()
 
         # Record change
-        self.component.change_set.create(
+        component.change_set.create(
             action=ActionEvents.REMOVE_TRANSLATION,
             target=self.filename,
             user=user,
             author=user,
         )
-        if not self.component.is_glossary:
-            cleanup_stale_glossaries.delay_on_commit(self.component.project.id)
+        if not component.is_glossary:
+            cleanup_stale_glossaries.delay_on_commit(component.project.id)
 
     def handle_store_change(
         self,