From d50028d6b92909a39139007f0f3bcd7c90a88420 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sat, 13 Aug 2022 06:08:22 +0200
Subject: Add Tags To Content Listings

Adds bot tags to the content page, as well as a model to go along with
it.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/utils.py | 125 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 120 insertions(+), 5 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index d3f270ff..a4252284 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -1,14 +1,26 @@
+import datetime
+import functools
+import tarfile
+import tempfile
+from io import BytesIO
 from pathlib import Path
-from typing import Dict, Tuple
 
 import frontmatter
+import httpx
 import markdown
 import yaml
 from django.http import Http404
+from django.utils import timezone
 from markdown.extensions.toc import TocExtension
 
+from pydis_site import settings
+from .models.tag import Tag
 
-def get_category(path: Path) -> Dict[str, str]:
+TAG_URL_BASE = "https://github.com/python-discord/bot/tree/main/bot/resources/tags"
+TAG_CACHE_TTL = datetime.timedelta(hours=1)
+
+
+def get_category(path: Path) -> dict[str, str]:
     """Load category information by name from _info.yml."""
     if not path.is_dir():
         raise Http404("Category not found.")
@@ -16,7 +28,7 @@ def get_category(path: Path) -> Dict[str, str]:
     return yaml.safe_load(path.joinpath("_info.yml").read_text(encoding="utf-8"))
 
 
-def get_categories(path: Path) -> Dict[str, Dict]:
+def get_categories(path: Path) -> dict[str, dict]:
     """Get information for all categories."""
     categories = {}
 
@@ -27,8 +39,111 @@ def get_categories(path: Path) -> Dict[str, Dict]:
     return categories
 
 
-def get_category_pages(path: Path) -> Dict[str, Dict]:
+@functools.cache
+def get_tags_static() -> list[Tag]:
+    """
+    Fetch tag information in static builds.
+
+    This will return a cached value, so it should only be used for static builds.
+    """
+    return fetch_tags()
+
+
+def fetch_tags() -> list[Tag]:
+    """
+    Fetch tag data from the GitHub API.
+
+    The entire repository is downloaded and extracted locally because
+    getting file content would require one request per file, and can get rate-limited.
+    """
+    if settings.GITHUB_TOKEN:
+        headers = {"Authorization": f"token {settings.GITHUB_TOKEN}"}
+    else:
+        headers = {}
+
+    tar_file = httpx.get(
+        f"{settings.GITHUB_API}/repos/python-discord/bot/tarball",
+        follow_redirects=True,
+        timeout=settings.TIMEOUT_PERIOD,
+        headers=headers,
+    )
+    tar_file.raise_for_status()
+
+    tags = []
+    with tempfile.TemporaryDirectory() as folder:
+        with tarfile.open(fileobj=BytesIO(tar_file.content)) as repo:
+            included = []
+            for file in repo.getmembers():
+                if "/bot/resources/tags" in file.path:
+                    included.append(file)
+            repo.extractall(folder, included)
+
+        for tag_file in Path(folder).rglob("*.md"):
+            tags.append(Tag(
+                name=tag_file.name.removesuffix(".md"),
+                body=tag_file.read_text(encoding="utf-8"),
+                url=f"{TAG_URL_BASE}/{tag_file.name}"
+            ))
+
+    return tags
+
+
+def get_tags() -> list[Tag]:
+    """Return a list of all tags visible to the application, from the cache or API."""
+    if settings.STATIC_BUILD:
+        last_update = None
+    else:
+        last_update = (
+            Tag.objects.values_list("last_updated", flat=True)
+            .order_by("last_updated").first()
+        )
+
+    if last_update is None or timezone.now() >= (last_update + TAG_CACHE_TTL):
+        # Stale or empty cache
+        if settings.STATIC_BUILD:
+            tags = get_tags_static()
+        else:
+            tags = fetch_tags()
+            Tag.objects.exclude(name__in=[tag.name for tag in tags]).delete()
+            for tag in tags:
+                tag.save()
+
+        return tags
+    else:
+        # Get tags from database
+        return Tag.objects.all()
+
+
+def get_tag(name: str) -> Tag:
+    """Return a tag by name."""
+    tags = get_tags()
+    for tag in tags:
+        if tag.name == name:
+            return tag
+
+    raise Tag.DoesNotExist()
+
+
+def get_category_pages(path: Path) -> dict[str, dict]:
     """Get all page names and their metadata at a category path."""
+    # Special handling for tags
+    if path == Path(__file__).parent / "resources/tags":
+        tags = {}
+        for tag in get_tags():
+            content = frontmatter.parse(tag.body)[1]
+            if len(content) > 100:
+                # Trim the preview to a maximum of 100 visible characters
+                # This causes some markdown to break, but we ignore that
+                content = content[:100] + "..."
+
+            tags[tag.name] = {
+                "title": tag.name,
+                "description": markdown.markdown(content),
+                "icon": "fas fa-tag"
+            }
+
+        return {name: tags[name] for name in sorted(tags)}
+
     pages = {}
 
     for item in path.glob("*.md"):
@@ -39,7 +154,7 @@ def get_category_pages(path: Path) -> Dict[str, Dict]:
     return pages
 
 
-def get_page(path: Path) -> Tuple[str, Dict]:
+def get_page(path: Path) -> tuple[str, dict]:
     """Get one specific page."""
     if not path.is_file():
         raise Http404("Page not found.")
-- 
cgit v1.2.3


From 733d5c084b1cba91a76f495b37ef0a391e5f9900 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sat, 13 Aug 2022 06:43:05 +0200
Subject: Export Tag Model As Top Level Model Object

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/models/__init__.py | 3 +++
 pydis_site/apps/content/utils.py           | 2 +-
 pydis_site/apps/content/views/tags.py      | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/models/__init__.py b/pydis_site/apps/content/models/__init__.py
index e69de29b..2718ce94 100644
--- a/pydis_site/apps/content/models/__init__.py
+++ b/pydis_site/apps/content/models/__init__.py
@@ -0,0 +1,3 @@
+from .tag import Tag
+
+__all__ = ["Tag"]
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index a4252284..de609596 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -14,7 +14,7 @@ from django.utils import timezone
 from markdown.extensions.toc import TocExtension
 
 from pydis_site import settings
-from .models.tag import Tag
+from .models import Tag
 
 TAG_URL_BASE = "https://github.com/python-discord/bot/tree/main/bot/resources/tags"
 TAG_CACHE_TTL = datetime.timedelta(hours=1)
diff --git a/pydis_site/apps/content/views/tags.py b/pydis_site/apps/content/views/tags.py
index 12e311dc..e2cfb488 100644
--- a/pydis_site/apps/content/views/tags.py
+++ b/pydis_site/apps/content/views/tags.py
@@ -8,7 +8,7 @@ from django.urls import reverse
 from django.views.generic import TemplateView
 
 from pydis_site.apps.content import utils
-from pydis_site.apps.content.models.tag import Tag
+from pydis_site.apps.content.models import Tag
 
 COMMAND_REGEX = re.compile(r"`*!tags? (?P<name>[\w\d-]+)`*")
 
-- 
cgit v1.2.3


From a8fd8b823748ced96bb8ea34e8dcd8bd0dd57671 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sat, 13 Aug 2022 08:47:29 +0200
Subject: Add Tag View Tests

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/tests/test_utils.py | 103 +++++++++++++++++++++-
 pydis_site/apps/content/tests/test_views.py | 128 ++++++++++++++++++++++++++++
 pydis_site/apps/content/utils.py            |   6 +-
 3 files changed, 233 insertions(+), 4 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index be5ea897..89ef81c4 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -1,8 +1,16 @@
+import tarfile
+import tempfile
+import textwrap
 from pathlib import Path
+from unittest import mock
 
+import httpx
+import markdown
 from django.http import Http404
+from django.test import TestCase
 
-from pydis_site.apps.content import utils
+from pydis_site import settings
+from pydis_site.apps.content import models, utils
 from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
@@ -96,3 +104,96 @@ class GetPageTests(MockPagesTestCase):
     def test_get_nonexistent_page_returns_404(self):
         with self.assertRaises(Http404):
             utils.get_page(Path(BASE_PATH, "invalid"))
+
+
+class TagUtilsTests(TestCase):
+    """Tests for the tag-related utilities."""
+
+    @mock.patch.object(utils, "fetch_tags")
+    def test_static_fetch(self, fetch_mock: mock.Mock):
+        """Test that the static fetch function is only called at most once during static builds."""
+        tags = [models.Tag(name="Name", body="body", url="url")]
+        fetch_mock.return_value = tags
+        result = utils.get_tags_static()
+        second_result = utils.get_tags_static()
+
+        fetch_mock.assert_called_once()
+        self.assertEqual(tags, result)
+        self.assertEqual(tags, second_result)
+
+    @mock.patch("httpx.get")
+    def test_mocked_fetch(self, get_mock: mock.Mock):
+        """Test that proper data is returned from fetch, but with a mocked API response."""
+        bodies = (
+            "This is the first tag!",
+            textwrap.dedent("""
+                ---
+                frontmatter: empty
+                ---
+                This tag has frontmatter!
+            """),
+        )
+
+        # Generate a tar archive with a few tags
+        with tempfile.TemporaryDirectory() as tar_folder:
+            tar_folder = Path(tar_folder)
+            with tempfile.TemporaryDirectory() as folder:
+                folder = Path(folder)
+                (folder / "ignored_file.md").write_text("This is an ignored file.")
+                tags_folder = folder / "bot/resources/tags"
+                tags_folder.mkdir(parents=True)
+
+                (tags_folder / "first_tag.md").write_text(bodies[0])
+                (tags_folder / "second_tag.md").write_text(bodies[1])
+
+                with tarfile.open(tar_folder / "temp.tar", "w") as file:
+                    file.add(folder, recursive=True)
+
+                body = (tar_folder / "temp.tar").read_bytes()
+
+        get_mock.return_value = httpx.Response(
+            status_code=200,
+            content=body,
+            request=httpx.Request("GET", "https://google.com"),
+        )
+
+        result = utils.fetch_tags()
+        self.assertEqual([
+            models.Tag(name="first_tag", body=bodies[0], url=f"{utils.TAG_URL_BASE}/first_tag.md"),
+            models.Tag(name="second_tag", body=bodies[1], url=f"{utils.TAG_URL_BASE}/first_tag.md"),
+        ], sorted(result, key=lambda tag: tag.name))
+
+    def test_get_real_tag(self):
+        """Test that a single tag is returned if it exists."""
+        tag = models.Tag.objects.create(name="real-tag")
+        result = utils.get_tag("real-tag")
+
+        self.assertEqual(tag, result)
+
+    def test_get_tag_404(self):
+        """Test that an error is raised when we fetch a non-existing tag."""
+        models.Tag.objects.create(name="real-tag")
+        with self.assertRaises(models.Tag.DoesNotExist):
+            utils.get_tag("fake")
+
+    def test_category_pages(self):
+        """Test that the category pages function returns the correct records for tags."""
+        models.Tag.objects.create(name="second-tag", body="Normal body")
+        models.Tag.objects.create(name="first-tag", body="Normal body")
+        tag_body = {"description": markdown.markdown("Normal body"), "icon": "fas fa-tag"}
+
+        result = utils.get_category_pages(settings.CONTENT_PAGES_PATH / "tags")
+        self.assertDictEqual({
+            "first-tag": {**tag_body, "title": "first-tag"},
+            "second-tag": {**tag_body, "title": "second-tag"},
+        }, result)
+
+    def test_trimmed_tag_content(self):
+        """Test a tag with a long body that requires trimming."""
+        tag = models.Tag.objects.create(name="long-tag", body="E" * 300)
+        result = utils.get_category_pages(settings.CONTENT_PAGES_PATH / "tags")
+        self.assertDictEqual({"long-tag": {
+            "title": "long-tag",
+            "description": markdown.markdown(tag.body[:100] + "..."),
+            "icon": "fas fa-tag",
+        }}, result)
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index eadad7e3..a5867260 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -1,9 +1,14 @@
+import textwrap
 from pathlib import Path
 from unittest import TestCase
 
+import django.test
+import markdown
 from django.http import Http404
 from django.test import RequestFactory, SimpleTestCase, override_settings
+from django.urls import reverse
 
+from pydis_site.apps.content.models import Tag
 from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
@@ -180,3 +185,126 @@ class PageOrCategoryViewTests(MockPagesTestCase, SimpleTestCase, TestCase):
                 {"name": PARSED_CATEGORY_INFO["title"], "path": Path("category/subcategory")},
             ]
         )
+
+
+class TagViewTests(django.test.TestCase):
+    """Tests for the TagView class."""
+
+    def setUp(self):
+        """Set test helpers, then set up fake filesystem."""
+        super().setUp()
+
+    def test_valid_tag_returns_200(self):
+        """Test that a page is returned for a valid tag."""
+        Tag.objects.create(name="example", body="This is the tag body.", url="URL")
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(200, response.status_code)
+        self.assertIn("This is the tag body", response.content.decode("utf-8"))
+        self.assertTemplateUsed(response, "content/tag.html")
+
+    def test_invalid_tag_404(self):
+        """Test that a tag which doesn't exist raises a 404."""
+        response = self.client.get("/pages/tags/non-existent/")
+        self.assertEqual(404, response.status_code)
+
+    def test_context(self):
+        """Check that the context contains all the necessary data."""
+        body = textwrap.dedent("""
+        ---
+        unused: frontmatter
+        ----
+        Tag content here.
+        """)
+
+        tag = Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        expected = {
+            "page_title": "example",
+            "page": markdown.markdown("Tag content here."),
+            "tag": tag,
+        }
+        for key in expected:
+            self.assertEqual(
+                expected[key], response.context.get(key), f"context.{key} did not match"
+            )
+
+    def test_markdown(self):
+        """Test that markdown content is rendered properly."""
+        body = textwrap.dedent("""
+        ```py
+        Hello world!
+        ```
+
+        **This text is in bold**
+        """)
+
+        Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        content = response.content.decode("utf-8")
+
+        self.assertInHTML('<code class="language-py">Hello world!</code>', content)
+        self.assertInHTML("<strong>This text is in bold</strong>", content)
+
+    def test_embed(self):
+        """Test that an embed from the frontmatter is treated correctly."""
+        body = textwrap.dedent("""
+        ---
+        embed:
+            title: Embed title
+            image:
+                url: https://google.com
+        ---
+        Tag body.
+        """)
+
+        Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        content = response.content.decode("utf-8")
+
+        self.assertInHTML('<img alt="Embed title" src="https://google.com"/>', content)
+        self.assertInHTML("<p>Tag body.</p>", content)
+
+    def test_embed_title(self):
+        """Test that the page title gets set to the embed title."""
+        body = textwrap.dedent("""
+        ---
+        embed:
+            title: Embed title
+        ---
+        """)
+
+        Tag.objects.create(name="example", body=body, url="URL")
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            "Embed title",
+            response.context.get("page_title"),
+            "The page title must match the embed title."
+        )
+
+    def test_hyperlinked_item(self):
+        """Test hyperlinking of tags works as intended."""
+        filler_before, filler_after = "empty filler text\n\n", "more\nfiller"
+        body = filler_before + "`!tags return`" + filler_after
+        Tag.objects.create(name="example", body=body, url="URL")
+
+        other_url = reverse("content:tag", kwargs={"name": "return"})
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            markdown.markdown(filler_before + f"[`!tags return`]({other_url})" + filler_after),
+            response.context.get("page")
+        )
+
+    def test_tag_root_page(self):
+        """Test the root tag page which lists all tags."""
+        Tag.objects.create(name="tag-1")
+        Tag.objects.create(name="tag-2")
+        Tag.objects.create(name="tag-3")
+
+        response = self.client.get("/pages/tags/")
+        content = response.content.decode("utf-8")
+
+        self.assertTemplateUsed(response, "content/listing.html")
+        self.assertInHTML('<h1 class="title">Tags</h1>', content)
+
+        for tag_number in range(1, 4):
+            self.assertIn(f"tag-{tag_number}</span>", content)
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index de609596..76437593 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -56,7 +56,7 @@ def fetch_tags() -> list[Tag]:
     The entire repository is downloaded and extracted locally because
     getting file content would require one request per file, and can get rate-limited.
     """
-    if settings.GITHUB_TOKEN:
+    if settings.GITHUB_TOKEN:  # pragma: no cover
         headers = {"Authorization": f"token {settings.GITHUB_TOKEN}"}
     else:
         headers = {}
@@ -90,7 +90,7 @@ def fetch_tags() -> list[Tag]:
 
 def get_tags() -> list[Tag]:
     """Return a list of all tags visible to the application, from the cache or API."""
-    if settings.STATIC_BUILD:
+    if settings.STATIC_BUILD:  # pragma: no cover
         last_update = None
     else:
         last_update = (
@@ -100,7 +100,7 @@ def get_tags() -> list[Tag]:
 
     if last_update is None or timezone.now() >= (last_update + TAG_CACHE_TTL):
         # Stale or empty cache
-        if settings.STATIC_BUILD:
+        if settings.STATIC_BUILD:  # pragma: no cover
             tags = get_tags_static()
         else:
             tags = fetch_tags()
-- 
cgit v1.2.3


From f2ad3eed8ef8872713666f69ec783f59006d3d81 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sat, 13 Aug 2022 22:53:50 +0200
Subject: Improve Tag Cropping

Move the tag cropping logic to the frontend, which makes it easier to
crop without crossing boundaries such as link or code block boundaries.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/utils.py          |  6 +-----
 pydis_site/static/js/content/listing.js   | 36 +++++++++++++++++++++++++++++++
 pydis_site/templates/content/listing.html |  4 +++-
 3 files changed, 40 insertions(+), 6 deletions(-)
 create mode 100644 pydis_site/static/js/content/listing.js

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 76437593..cc08f81f 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -131,14 +131,10 @@ def get_category_pages(path: Path) -> dict[str, dict]:
         tags = {}
         for tag in get_tags():
             content = frontmatter.parse(tag.body)[1]
-            if len(content) > 100:
-                # Trim the preview to a maximum of 100 visible characters
-                # This causes some markdown to break, but we ignore that
-                content = content[:100] + "..."
 
             tags[tag.name] = {
                 "title": tag.name,
-                "description": markdown.markdown(content),
+                "description": markdown.markdown(content, extensions=["pymdownx.superfences"]),
                 "icon": "fas fa-tag"
             }
 
diff --git a/pydis_site/static/js/content/listing.js b/pydis_site/static/js/content/listing.js
new file mode 100644
index 00000000..3502cb2a
--- /dev/null
+++ b/pydis_site/static/js/content/listing.js
@@ -0,0 +1,36 @@
+/**
+ * Trim a tag listing to only show a few lines of content.
+ */
+function trimTag() {
+    const containers = document.getElementsByClassName("tag-container");
+    for (const container of containers) {
+        // Remove every element after the first two paragraphs
+        while (container.children.length > 2) {
+            container.removeChild(container.lastChild);
+        }
+
+        // Trim down the elements if they are too long
+        const containerLength = container.textContent.length;
+        if (containerLength > 300) {
+            if (containerLength - container.firstChild.textContent.length > 300) {
+                // The first element alone takes up more than 300 characters
+                container.removeChild(container.lastChild);
+            }
+
+            let last = container.lastChild.lastChild;
+            while (container.textContent.length > 300 && container.lastChild.childNodes.length > 0) {
+                last = container.lastChild.lastChild;
+                last.remove();
+            }
+
+            if (container.textContent.length > 300 && (last instanceof HTMLElement && last.tagName !== "CODE")) {
+                // Add back the final element (up to a period if possible)
+                const stop = last.textContent.indexOf(".");
+                last.textContent = last.textContent.slice(0, stop > 0 ? stop + 1: null);
+                container.lastChild.appendChild(last);
+            }
+        }
+    }
+}
+
+trimTag();
diff --git a/pydis_site/templates/content/listing.html b/pydis_site/templates/content/listing.html
index eeb6b5e2..098f4237 100644
--- a/pydis_site/templates/content/listing.html
+++ b/pydis_site/templates/content/listing.html
@@ -1,5 +1,6 @@
 {# Base navigation screen for resources #}
 {% extends 'content/base.html' %}
+{% load static %}
 
 {% block page_content %}
     {# Nested Categories #}
@@ -26,10 +27,11 @@
                 <span class="is-size-4 has-text-weight-bold">{{ data.title }}</span>
             </a>
             {% if "tags" in location %}
-                <p class="is-italic">{{ data.description | safe }}</p>
+                <div class="tag-container">{{ data.description | safe }}</div>
             {% else %}
                 <p class="is-italic">{{ data.description }}</p>
             {% endif %}
         </div>
     {% endfor %}
+    <script src="{% static 'js/content/listing.js' %}"></script>
 {% endblock %}
-- 
cgit v1.2.3


From 45cdb27a82297ede18d7bd908213dde54fef06a9 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sun, 14 Aug 2022 05:34:27 +0200
Subject: Add Tag Group Support

Adds support for tag groups in content. This involves some modification
to the routing, and templating.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/urls.py                |  12 ++-
 pydis_site/apps/content/utils.py               | 101 ++++++++++++++++++++-----
 pydis_site/apps/content/views/page_category.py |   5 +-
 pydis_site/apps/content/views/tags.py          |  79 +++++++++++++++----
 pydis_site/static/css/content/color.css        |   7 ++
 pydis_site/static/css/content/tag.css          |   8 --
 pydis_site/static/js/content/listing.js        |   5 ++
 pydis_site/templates/content/listing.html      |  17 ++++-
 pydis_site/templates/content/tag.html          |   5 +-
 9 files changed, 187 insertions(+), 52 deletions(-)
 create mode 100644 pydis_site/static/css/content/color.css

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/urls.py b/pydis_site/apps/content/urls.py
index b4ffc07d..03c0015a 100644
--- a/pydis_site/apps/content/urls.py
+++ b/pydis_site/apps/content/urls.py
@@ -39,15 +39,21 @@ def get_all_pages() -> DISTILL_RETURN:
 
 
 def get_all_tags() -> DISTILL_RETURN:
-    """Return all tag names in the repository in static builds."""
+    """Return all tag names and groups in static builds."""
+    groups = {None}
     for tag in utils.get_tags_static():
-        yield {"name": tag.name}
+        groups.add(tag.group)
+        yield {"location": (f"{tag.group}/" if tag.group else "") + tag.name}
+
+    groups.remove(None)
+    for group in groups:
+        yield {"location": group}
 
 
 urlpatterns = [
     distill_path("", views.PageOrCategoryView.as_view(), name='pages'),
     distill_path(
-        "tags/<str:name>/",
+        "tags/<path:location>/",
         views.TagView.as_view(),
         name="tag",
         distill_func=get_all_tags
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index cc08f81f..da6a024d 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -2,6 +2,7 @@ import datetime
 import functools
 import tarfile
 import tempfile
+import typing
 from io import BytesIO
 from pathlib import Path
 
@@ -16,7 +17,6 @@ from markdown.extensions.toc import TocExtension
 from pydis_site import settings
 from .models import Tag
 
-TAG_URL_BASE = "https://github.com/python-discord/bot/tree/main/bot/resources/tags"
 TAG_CACHE_TTL = datetime.timedelta(hours=1)
 
 
@@ -44,9 +44,13 @@ def get_tags_static() -> list[Tag]:
     """
     Fetch tag information in static builds.
 
+    This also includes some fake tags to preview the tag groups feature.
     This will return a cached value, so it should only be used for static builds.
     """
-    return fetch_tags()
+    tags = fetch_tags()
+    for tag in tags[3:5]:
+        tag.group = "very-cool-group"
+    return tags
 
 
 def fetch_tags() -> list[Tag]:
@@ -79,10 +83,15 @@ def fetch_tags() -> list[Tag]:
             repo.extractall(folder, included)
 
         for tag_file in Path(folder).rglob("*.md"):
+            group = None
+            if tag_file.parent.name != "tags":
+                # Tags in sub-folders are considered part of a group
+                group = tag_file.parent.name
+
             tags.append(Tag(
                 name=tag_file.name.removesuffix(".md"),
+                group=group,
                 body=tag_file.read_text(encoding="utf-8"),
-                url=f"{TAG_URL_BASE}/{tag_file.name}"
             ))
 
     return tags
@@ -114,31 +123,85 @@ def get_tags() -> list[Tag]:
         return Tag.objects.all()
 
 
-def get_tag(name: str) -> Tag:
-    """Return a tag by name."""
-    tags = get_tags()
-    for tag in tags:
-        if tag.name == name:
+def get_tag(path: str) -> typing.Union[Tag, list[Tag]]:
+    """
+    Return a tag based on the search location.
+
+    The tag name and group must match. If only one argument is provided in the path,
+    it's assumed to either be a group name, or a no-group tag name.
+
+    If it's a group name, a list of tags which belong to it is returned.
+    """
+    path = path.split("/")
+    if len(path) == 2:
+        group, name = path[0], path[1]
+    else:
+        name = path[0]
+        group = None
+
+    matches = []
+    for tag in get_tags():
+        if tag.name == name and tag.group == group:
             return tag
+        elif tag.group == name and group is None:
+            matches.append(tag)
+
+    if matches:
+        return matches
 
     raise Tag.DoesNotExist()
 
 
-def get_category_pages(path: Path) -> dict[str, dict]:
-    """Get all page names and their metadata at a category path."""
-    # Special handling for tags
-    if path == Path(__file__).parent / "resources/tags":
-        tags = {}
-        for tag in get_tags():
-            content = frontmatter.parse(tag.body)[1]
+def get_tag_category(
+    tags: typing.Optional[list[Tag]] = None, *, collapse_groups: bool
+) -> dict[str, dict]:
+    """
+    Generate context data for `tags`, or all tags if None.
+
+    If `tags` is None, `get_tag` is used to populate the data.
+    If `collapse_groups` is True, tags with parent groups are not included in the list,
+    and instead the parent itself is included as a single entry with it's sub-tags
+    in the description.
+    """
+    if not tags:
+        tags = get_tags()
+
+    data = []
+    groups = {}
 
-            tags[tag.name] = {
+    # Create all the metadata for the tags
+    for tag in tags:
+        if tag.group is None or not collapse_groups:
+            content = frontmatter.parse(tag.body)[1]
+            data.append({
                 "title": tag.name,
                 "description": markdown.markdown(content, extensions=["pymdownx.superfences"]),
-                "icon": "fas fa-tag"
-            }
+                "icon": "fas fa-tag",
+            })
+        else:
+            if tag.group not in groups:
+                groups[tag.group] = {
+                    "title": tag.group,
+                    "description": [tag.name],
+                    "icon": "fas fa-tags",
+                }
+            else:
+                groups[tag.group]["description"].append(tag.name)
 
-        return {name: tags[name] for name in sorted(tags)}
+    # Flatten group description into a single string
+    for group in groups.values():
+        group["description"] = "Contains the following tags: " + ", ".join(group["description"])
+        data.append(group)
+
+    # Sort the tags, and return them in the proper format
+    return {tag["title"]: tag for tag in sorted(data, key=lambda tag: tag["title"].lower())}
+
+
+def get_category_pages(path: Path) -> dict[str, dict]:
+    """Get all page names and their metadata at a category path."""
+    # Special handling for tags
+    if path == Path(__file__).parent / "resources/tags":
+        return get_tag_category(collapse_groups=True)
 
     pages = {}
 
diff --git a/pydis_site/apps/content/views/page_category.py b/pydis_site/apps/content/views/page_category.py
index 01ce8402..062c2bc1 100644
--- a/pydis_site/apps/content/views/page_category.py
+++ b/pydis_site/apps/content/views/page_category.py
@@ -5,7 +5,7 @@ from django.conf import settings
 from django.http import Http404, HttpRequest, HttpResponse
 from django.views.generic import TemplateView
 
-from pydis_site.apps.content import utils
+from pydis_site.apps.content import models, utils
 
 
 class PageOrCategoryView(TemplateView):
@@ -91,4 +91,7 @@ class PageOrCategoryView(TemplateView):
             "page_title": category["title"],
             "page_description": category["description"],
             "icon": category.get("icon"),
+            "app_name": "content:page_category",
+            "is_tag_listing": "/resources/tags" in path.as_posix(),
+            "tag_url": models.Tag.URL_BASE,
         }
diff --git a/pydis_site/apps/content/views/tags.py b/pydis_site/apps/content/views/tags.py
index 5295537d..a8df65db 100644
--- a/pydis_site/apps/content/views/tags.py
+++ b/pydis_site/apps/content/views/tags.py
@@ -1,4 +1,5 @@
 import re
+import typing
 
 import frontmatter
 import markdown
@@ -16,23 +17,65 @@ COMMAND_REGEX = re.compile(r"`*!tags? (?P<name>[\w\d-]+)`*")
 class TagView(TemplateView):
     """Handles tag pages."""
 
-    template_name = "content/tag.html"
+    tag: typing.Union[Tag, list[Tag]]
+    is_group: bool
+
+    def setup(self, *args, **kwargs) -> None:
+        """Look for a tag, and configure the view."""
+        super().setup(*args, **kwargs)
 
-    def get_context_data(self, **kwargs) -> dict:
-        """Get the relevant context for this tag page."""
         try:
-            tag = utils.get_tag(kwargs.get("name"))
+            self.tag = utils.get_tag(kwargs.get("location"))
+            self.is_group = isinstance(self.tag, list)
         except Tag.DoesNotExist:
             raise Http404
 
+    def get_template_names(self) -> list[str]:
+        """Either return the tag page template, or the listing."""
+        if self.is_group:
+            template_name = "content/listing.html"
+        else:
+            template_name = "content/tag.html"
+
+        return [template_name]
+
+    def get_context_data(self, **kwargs) -> dict:
+        """Get the relevant context for this tag page or group."""
         context = super().get_context_data(**kwargs)
-        context["page_title"] = tag.name
+        context["breadcrumb_items"] = [{
+            "name": utils.get_category(settings.CONTENT_PAGES_PATH / location)["title"],
+            "path": location,
+        } for location in (".", "tags")]
+
+        if self.is_group:
+            self._set_group_context(context, self.tag)
+        else:
+            self._set_tag_context(context, self.tag)
+
+        return context
+
+    @staticmethod
+    def _set_tag_context(context: dict[str, any], tag: Tag) -> None:
+        """Update the context with the information for a tag page."""
+        context.update({
+            "page_title": tag.name,
+            "tag": tag,
+        })
+
+        if tag.group:
+            # Add group names to the breadcrumbs
+            context["breadcrumb_items"].append({
+                "name": tag.group,
+                "path": f"tags/{tag.group}",
+            })
+
+        # Clean up tag body
         body = frontmatter.parse(tag.body)
         content = body[1]
 
         # Check for tags which can be hyperlinked
         def sub(match: re.Match) -> str:
-            link = reverse("content:tag", kwargs={"name": match.group("name")})
+            link = reverse("content:tag", kwargs={"location": match.group("name")})
             return f"[{match.group()}]({link})"
         content = COMMAND_REGEX.sub(sub, content)
 
@@ -42,14 +85,20 @@ class TagView(TemplateView):
             if image := embed.get("image"):
                 content = f"![{embed['title']}]({image['url']})\n\n" + content
 
+        # Insert the content
+        context["page"] = markdown.markdown(content, extensions=["pymdownx.superfences"])
+
+    @staticmethod
+    def _set_group_context(context: dict[str, any], tags: list[Tag]) -> None:
+        """Update the context with the information for a group of tags."""
+        group = tags[0].group
         context.update({
-            "page": markdown.markdown(content, extensions=["pymdownx.superfences"]),
-            "tag": tag,
+            "categories": {},
+            "pages": utils.get_tag_category(tags, collapse_groups=False),
+            "page_title": group,
+            "icon": "fab fa-tags",
+            "is_tag_listing": True,
+            "app_name": "content:tag",
+            "path": f"{group}/",
+            "tag_url": f"{tags[0].URL_BASE}/{group}"
         })
-
-        context["breadcrumb_items"] = [{
-            "name": utils.get_category(settings.CONTENT_PAGES_PATH / location)["title"],
-            "path": str(location)
-        } for location in [".", "tags"]]
-
-        return context
diff --git a/pydis_site/static/css/content/color.css b/pydis_site/static/css/content/color.css
new file mode 100644
index 00000000..f4801c28
--- /dev/null
+++ b/pydis_site/static/css/content/color.css
@@ -0,0 +1,7 @@
+.content .fa-github {
+    color: black;
+}
+
+.content .fa-github:hover {
+    color: #7289DA;
+}
diff --git a/pydis_site/static/css/content/tag.css b/pydis_site/static/css/content/tag.css
index a3db046c..ec45bfc7 100644
--- a/pydis_site/static/css/content/tag.css
+++ b/pydis_site/static/css/content/tag.css
@@ -1,11 +1,3 @@
-h1.title a {
-    color: black;
-}
-
-h1.title a:hover {
-    color: #7289DA;
-}
-
 .content a * {
     /* This is the original color, but propagated down the chain */
     /* which allows for elements inside links, such as codeblocks */
diff --git a/pydis_site/static/js/content/listing.js b/pydis_site/static/js/content/listing.js
index 3502cb2a..4b722632 100644
--- a/pydis_site/static/js/content/listing.js
+++ b/pydis_site/static/js/content/listing.js
@@ -4,6 +4,11 @@
 function trimTag() {
     const containers = document.getElementsByClassName("tag-container");
     for (const container of containers) {
+        if (container.textContent.startsWith("Contains the following tags:")) {
+            // Tag group, no need to trim
+            continue;
+        }
+
         // Remove every element after the first two paragraphs
         while (container.children.length > 2) {
             container.removeChild(container.lastChild);
diff --git a/pydis_site/templates/content/listing.html b/pydis_site/templates/content/listing.html
index 098f4237..934b95f6 100644
--- a/pydis_site/templates/content/listing.html
+++ b/pydis_site/templates/content/listing.html
@@ -2,6 +2,19 @@
 {% extends 'content/base.html' %}
 {% load static %}
 
+{# Show a GitHub button on tag pages #}
+{% block title_element %}
+{% if is_tag_listing %}
+    <link rel="stylesheet" href="{% static "css/content/color.css" %}">
+    <div class="level">
+        <div class="level-left">{{ block.super }}</div>
+        <div class="level-right">
+            <a class="level-item fab fa-github" href="{{ tag_url }}"></a>
+        </div>
+    </div>
+{% endif %}
+{% endblock %}
+
 {% block page_content %}
     {# Nested Categories #}
     {% for category, data in categories.items %}
@@ -23,10 +36,10 @@
             <span class="icon is-size-4 is-medium">
                 <i class="{{ data.icon|default:"fab fa-python" }} is-size-3 is-black has-icon-padding" aria-hidden="true"></i>
             </span>
-            <a href="{% url "content:page_category" location=path|add:page %}">
+            <a href="{% url app_name location=path|add:page %}">
                 <span class="is-size-4 has-text-weight-bold">{{ data.title }}</span>
             </a>
-            {% if "tags" in location %}
+            {% if is_tag_listing %}
                 <div class="tag-container">{{ data.description | safe }}</div>
             {% else %}
                 <p class="is-italic">{{ data.description }}</p>
diff --git a/pydis_site/templates/content/tag.html b/pydis_site/templates/content/tag.html
index 264f63d0..9bd65744 100644
--- a/pydis_site/templates/content/tag.html
+++ b/pydis_site/templates/content/tag.html
@@ -3,6 +3,7 @@
 
 {% block head %}
     {{ block.super }}
+    <link rel="stylesheet" href="{% static 'css/content/color.css' %}"/>
     <link rel="stylesheet" href="{% static 'css/content/tag.css' %}"/>
     <title>{{ tag.name }}</title>
 {% endblock %}
@@ -15,7 +16,3 @@
         </div>
     </div>
 {% endblock %}
-
-{% block page_content %}
-    {{ block.super }}
-{% endblock %}
-- 
cgit v1.2.3


From 5aeffa5ab4dd8b251d2ae742d1a1e2bf3ba461c7 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Sun, 14 Aug 2022 07:14:50 +0200
Subject: Update Tests For Tag Groups

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/tests/test_utils.py | 110 +++++++++++++++++++++++-----
 pydis_site/apps/content/tests/test_views.py |  68 ++++++++++++++++-
 pydis_site/apps/content/utils.py            |   3 +-
 3 files changed, 157 insertions(+), 24 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index a5d5dcb4..556f633c 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -132,6 +132,7 @@ class TagUtilsTests(TestCase):
                 ---
                 This tag has frontmatter!
             """),
+            "This is a grouped tag!",
         )
 
         # Generate a tar archive with a few tags
@@ -146,6 +147,10 @@ class TagUtilsTests(TestCase):
                 (tags_folder / "first_tag.md").write_text(bodies[0])
                 (tags_folder / "second_tag.md").write_text(bodies[1])
 
+                group_folder = tags_folder / "some_group"
+                group_folder.mkdir()
+                (group_folder / "grouped_tag.md").write_text(bodies[2])
+
                 with tarfile.open(tar_folder / "temp.tar", "w") as file:
                     file.add(folder, recursive=True)
 
@@ -158,10 +163,15 @@ class TagUtilsTests(TestCase):
         )
 
         result = utils.fetch_tags()
-        self.assertEqual([
+
+        def sort(_tag: models.Tag) -> str:
+            return _tag.name
+
+        self.assertEqual(sorted([
             models.Tag(name="first_tag", body=bodies[0]),
             models.Tag(name="second_tag", body=bodies[1]),
-        ], sorted(result, key=lambda tag: tag.name))
+            models.Tag(name="grouped_tag", body=bodies[2], group=group_folder.name),
+        ], key=sort), sorted(result, key=sort))
 
     def test_get_real_tag(self):
         """Test that a single tag is returned if it exists."""
@@ -170,30 +180,92 @@ class TagUtilsTests(TestCase):
 
         self.assertEqual(tag, result)
 
+    def test_get_grouped_tag(self):
+        """Test fetching a tag from a group."""
+        tag = models.Tag.objects.create(name="real-tag", group="real-group")
+        result = utils.get_tag("real-group/real-tag")
+
+        self.assertEqual(tag, result)
+
+    def test_get_group(self):
+        """Test fetching a group of tags."""
+        included = [
+            models.Tag.objects.create(name="tag-1", group="real-group"),
+            models.Tag.objects.create(name="tag-2", group="real-group"),
+            models.Tag.objects.create(name="tag-3", group="real-group"),
+        ]
+
+        models.Tag.objects.create(name="not-included-1")
+        models.Tag.objects.create(name="not-included-2", group="other-group")
+
+        result = utils.get_tag("real-group")
+        self.assertListEqual(included, result)
+
     def test_get_tag_404(self):
         """Test that an error is raised when we fetch a non-existing tag."""
         models.Tag.objects.create(name="real-tag")
         with self.assertRaises(models.Tag.DoesNotExist):
             utils.get_tag("fake")
 
-    def test_category_pages(self):
-        """Test that the category pages function returns the correct records for tags."""
-        models.Tag.objects.create(name="second-tag", body="Normal body")
-        models.Tag.objects.create(name="first-tag", body="Normal body")
-        tag_body = {"description": markdown.markdown("Normal body"), "icon": "fas fa-tag"}
-
+    @mock.patch.object(utils, "get_tag_category")
+    def test_category_pages(self, get_mock: mock.Mock):
+        """Test that the category pages function calls the correct method for tags."""
+        tag = models.Tag.objects.create(name="tag")
+        get_mock.return_value = tag
         result = utils.get_category_pages(settings.CONTENT_PAGES_PATH / "tags")
+        self.assertEqual(tag, result)
+        get_mock.assert_called_once_with(collapse_groups=True)
+
+    def test_get_category_root(self):
+        """Test that all tags are returned and formatted properly for the tag root page."""
+        body = "normal body"
+        base = {"description": markdown.markdown(body), "icon": "fas fa-tag"}
+
+        models.Tag.objects.create(name="tag-1", body=body),
+        models.Tag.objects.create(name="tag-2", body=body),
+        models.Tag.objects.create(name="tag-3", body=body),
+
+        models.Tag.objects.create(name="tag-4", body=body, group="tag-group")
+        models.Tag.objects.create(name="tag-5", body=body, group="tag-group")
+
+        result = utils.get_tag_category(collapse_groups=True)
+
         self.assertDictEqual({
-            "first-tag": {**tag_body, "title": "first-tag"},
-            "second-tag": {**tag_body, "title": "second-tag"},
+            "tag-1": {**base, "title": "tag-1"},
+            "tag-2": {**base, "title": "tag-2"},
+            "tag-3": {**base, "title": "tag-3"},
+            "tag-group": {
+                "title": "tag-group",
+                "description": "Contains the following tags: tag-4, tag-5",
+                "icon": "fas fa-tags"
+            }
         }, result)
 
-    def test_trimmed_tag_content(self):
-        """Test a tag with a long body that requires trimming."""
-        tag = models.Tag.objects.create(name="long-tag", body="E" * 300)
-        result = utils.get_category_pages(settings.CONTENT_PAGES_PATH / "tags")
-        self.assertDictEqual({"long-tag": {
-            "title": "long-tag",
-            "description": markdown.markdown(tag.body[:100] + "..."),
-            "icon": "fas fa-tag",
-        }}, result)
+    def test_get_category_group(self):
+        """Test the function for a group root page."""
+        body = "normal body"
+        base = {"description": markdown.markdown(body), "icon": "fas fa-tag"}
+
+        included = [
+            models.Tag.objects.create(name="tag-1", body=body, group="group"),
+            models.Tag.objects.create(name="tag-2", body=body, group="group"),
+        ]
+        models.Tag.objects.create(name="not-included", body=body)
+
+        result = utils.get_tag_category(included, collapse_groups=False)
+        self.assertDictEqual({
+            "tag-1": {**base, "title": "tag-1"},
+            "tag-2": {**base, "title": "tag-2"},
+        }, result)
+
+    def test_tag_url(self):
+        """Test that tag URLs are generated correctly."""
+        cases = [
+            ({"name": "tag"}, f"{models.Tag.URL_BASE}/tag.md"),
+            ({"name": "grouped", "group": "abc"}, f"{models.Tag.URL_BASE}/abc/grouped.md"),
+        ]
+
+        for options, url in cases:
+            tag = models.Tag(**options)
+            with self.subTest(tag=tag):
+                self.assertEqual(url, tag.url)
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index c4d3474e..c5c25be4 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -194,6 +194,23 @@ class TagViewTests(django.test.TestCase):
         """Set test helpers, then set up fake filesystem."""
         super().setUp()
 
+    def test_routing(self):
+        """Test that the correct template is returned for each route."""
+        Tag.objects.create(name="example")
+        Tag.objects.create(name="grouped-tag", group="group-name")
+
+        cases = [
+            ("/pages/tags/example/", "content/tag.html"),
+            ("/pages/tags/group-name/", "content/listing.html"),
+            ("/pages/tags/group-name/grouped-tag/", "content/tag.html"),
+        ]
+
+        for url, template in cases:
+            with self.subTest(url=url):
+                response = self.client.get(url)
+                self.assertEqual(200, response.status_code)
+                self.assertTemplateUsed(response, template)
+
     def test_valid_tag_returns_200(self):
         """Test that a page is returned for a valid tag."""
         Tag.objects.create(name="example", body="This is the tag body.")
@@ -207,8 +224,8 @@ class TagViewTests(django.test.TestCase):
         response = self.client.get("/pages/tags/non-existent/")
         self.assertEqual(404, response.status_code)
 
-    def test_context(self):
-        """Check that the context contains all the necessary data."""
+    def test_context_tag(self):
+        """Test that the context contains the required data for a tag."""
         body = textwrap.dedent("""
         ---
         unused: frontmatter
@@ -222,12 +239,55 @@ class TagViewTests(django.test.TestCase):
             "page_title": "example",
             "page": markdown.markdown("Tag content here."),
             "tag": tag,
+            "breadcrumb_items": [
+                {"name": "Pages", "path": "."},
+                {"name": "Tags", "path": "tags"},
+            ]
         }
         for key in expected:
             self.assertEqual(
                 expected[key], response.context.get(key), f"context.{key} did not match"
             )
 
+    def test_context_grouped_tag(self):
+        """
+        Test the context for a tag in a group.
+
+        The only difference between this and a regular tag are the breadcrumbs,
+        so only those are checked.
+        """
+        Tag.objects.create(name="example", body="Body text", group="group-name")
+        response = self.client.get("/pages/tags/group-name/example/")
+        self.assertListEqual([
+            {"name": "Pages", "path": "."},
+            {"name": "Tags", "path": "tags"},
+            {"name": "group-name", "path": "tags/group-name"},
+        ], response.context.get("breadcrumb_items"))
+
+    def test_group_page(self):
+        """Test rendering of a group's root page."""
+        Tag.objects.create(name="tag-1", body="Body 1", group="group-name")
+        Tag.objects.create(name="tag-2", body="Body 2", group="group-name")
+        Tag.objects.create(name="not-included")
+
+        response = self.client.get("/pages/tags/group-name/")
+        content = response.content.decode("utf-8")
+
+        self.assertInHTML("<div class='level-left'>group-name</div>", content)
+        self.assertInHTML(
+            f"<a class='level-item fab fa-github' href='{Tag.URL_BASE}/group-name'>",
+            content
+        )
+        self.assertIn(">tag-1</span>", content)
+        self.assertIn(">tag-2</span>", content)
+        self.assertNotIn(
+            ">not-included</span>",
+            content,
+            "Tags not in this group shouldn't be rendered."
+        )
+
+        self.assertInHTML("<p>Body 1</p>", content)
+
     def test_markdown(self):
         """Test that markdown content is rendered properly."""
         body = textwrap.dedent("""
@@ -287,7 +347,7 @@ class TagViewTests(django.test.TestCase):
         body = filler_before + "`!tags return`" + filler_after
         Tag.objects.create(name="example", body=body)
 
-        other_url = reverse("content:tag", kwargs={"name": "return"})
+        other_url = reverse("content:tag", kwargs={"location": "return"})
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(
             markdown.markdown(filler_before + f"[`!tags return`]({other_url})" + filler_after),
@@ -304,7 +364,7 @@ class TagViewTests(django.test.TestCase):
         content = response.content.decode("utf-8")
 
         self.assertTemplateUsed(response, "content/listing.html")
-        self.assertInHTML('<h1 class="title">Tags</h1>', content)
+        self.assertInHTML('<div class="level-left">Tags</div>', content)
 
         for tag_number in range(1, 4):
             self.assertIn(f"tag-{tag_number}</span>", content)
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index da6a024d..11100ba5 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -48,7 +48,7 @@ def get_tags_static() -> list[Tag]:
     This will return a cached value, so it should only be used for static builds.
     """
     tags = fetch_tags()
-    for tag in tags[3:5]:
+    for tag in tags[3:5]:  # pragma: no cover
         tag.group = "very-cool-group"
     return tags
 
@@ -190,6 +190,7 @@ def get_tag_category(
 
     # Flatten group description into a single string
     for group in groups.values():
+        # If the following string is updated, make sure to update it in the frontend JS as well
         group["description"] = "Contains the following tags: " + ", ".join(group["description"])
         data.append(group)
 
-- 
cgit v1.2.3


From 04babac2f281487adcddbf1e92d9d028896e086e Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 16 Aug 2022 21:21:59 +0400
Subject: Add Tag Metadata

Uses the commit API to obtain tag metadata such as when it was last
edited, and by whom.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 .../apps/content/migrations/0001_add_tags.py       |   5 +-
 pydis_site/apps/content/models/tag.py              |  14 ++-
 pydis_site/apps/content/utils.py                   | 124 ++++++++++++++++++---
 pydis_site/static/css/content/tag.css              |   6 +-
 pydis_site/templates/content/tag.html              |  22 +++-
 5 files changed, 146 insertions(+), 25 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/migrations/0001_add_tags.py b/pydis_site/apps/content/migrations/0001_add_tags.py
index 2e9d8c45..73525243 100644
--- a/pydis_site/apps/content/migrations/0001_add_tags.py
+++ b/pydis_site/apps/content/migrations/0001_add_tags.py
@@ -1,4 +1,4 @@
-# Generated by Django 4.0.6 on 2022-08-16 16:17
+# Generated by Django 4.0.6 on 2022-08-16 17:38
 
 import django.db.models.deletion
 from django.db import migrations, models
@@ -25,10 +25,11 @@ class Migration(migrations.Migration):
             name='Tag',
             fields=[
                 ('last_updated', models.DateTimeField(auto_now=True, help_text='The date and time this data was last fetched.')),
+                ('sha', models.CharField(help_text="The tag's hash, as calculated by GitHub.", max_length=40)),
                 ('name', models.CharField(help_text="The tag's name.", max_length=50, primary_key=True, serialize=False)),
                 ('group', models.CharField(help_text='The group the tag belongs to.', max_length=50, null=True)),
                 ('body', models.TextField(help_text='The content of the tag.')),
-                ('last_commit', models.OneToOneField(help_text='The commit this file was last touched in.', null=True, on_delete=django.db.models.deletion.CASCADE, to='content.commit')),
+                ('last_commit', models.ForeignKey(help_text='The commit this file was last touched in.', null=True, on_delete=django.db.models.deletion.CASCADE, to='content.commit')),
             ],
         ),
     ]
diff --git a/pydis_site/apps/content/models/tag.py b/pydis_site/apps/content/models/tag.py
index 1c89fe1e..3c729768 100644
--- a/pydis_site/apps/content/models/tag.py
+++ b/pydis_site/apps/content/models/tag.py
@@ -1,3 +1,4 @@
+import collections.abc
 import json
 
 from django.db import models
@@ -22,13 +23,10 @@ class Commit(models.Model):
         """The URL to the commit on GitHub."""
         return self.URL_BASE + self.sha
 
-    @property
-    def format_users(self) -> str:
+    def format_users(self) -> collections.abc.Iterable[str]:
         """Return a nice representation of the user(s)' name and email."""
-        authors = []
         for author in json.loads(self.author):
-            authors.append(f"{author['name']} <{author['email']}>")
-        return ", ".join(authors)
+            yield f"{author['name']} <{author['email']}>"
 
 
 class Tag(models.Model):
@@ -40,7 +38,11 @@ class Tag(models.Model):
         help_text="The date and time this data was last fetched.",
         auto_now=True,
     )
-    last_commit = models.OneToOneField(
+    sha = models.CharField(
+        help_text="The tag's hash, as calculated by GitHub.",
+        max_length=40,
+    )
+    last_commit = models.ForeignKey(
         Commit,
         help_text="The commit this file was last touched in.",
         null=True,
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 11100ba5..7b078de6 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -1,5 +1,6 @@
 import datetime
 import functools
+import json
 import tarfile
 import tempfile
 import typing
@@ -15,11 +16,26 @@ from django.utils import timezone
 from markdown.extensions.toc import TocExtension
 
 from pydis_site import settings
-from .models import Tag
+from .models import Commit, Tag
 
 TAG_CACHE_TTL = datetime.timedelta(hours=1)
 
 
+def github_client(**kwargs) -> httpx.Client:
+    """Get a client to access the GitHub API with important settings pre-configured."""
+    client = httpx.Client(
+        base_url=settings.GITHUB_API,
+        follow_redirects=True,
+        timeout=settings.TIMEOUT_PERIOD,
+        **kwargs
+    )
+    if settings.GITHUB_TOKEN:  # pragma: no cover
+        if not client.headers.get("Authorization"):
+            client.headers = {"Authorization": f"token {settings.GITHUB_TOKEN}"}
+
+    return client
+
+
 def get_category(path: Path) -> dict[str, str]:
     """Load category information by name from _info.yml."""
     if not path.is_dir():
@@ -60,19 +76,31 @@ def fetch_tags() -> list[Tag]:
     The entire repository is downloaded and extracted locally because
     getting file content would require one request per file, and can get rate-limited.
     """
-    if settings.GITHUB_TOKEN:  # pragma: no cover
-        headers = {"Authorization": f"token {settings.GITHUB_TOKEN}"}
-    else:
-        headers = {}
+    client = github_client()
+
+    # Grab metadata
+    metadata = client.get("/repos/python-discord/bot/contents/bot/resources")
+    metadata.raise_for_status()
+
+    hashes = {}
+    for entry in metadata.json():
+        if entry["type"] == "dir":
+            # Tag group
+            files = client.get(entry["url"])
+            files.raise_for_status()
+            files = files.json()
+        else:
+            files = [entry]
 
-    tar_file = httpx.get(
-        f"{settings.GITHUB_API}/repos/python-discord/bot/tarball",
-        follow_redirects=True,
-        timeout=settings.TIMEOUT_PERIOD,
-        headers=headers,
-    )
+        for file in files:
+            hashes[file["name"]] = file["sha"]
+
+    # Download the files
+    tar_file = client.get("/repos/python-discord/bot/tarball")
     tar_file.raise_for_status()
 
+    client.close()
+
     tags = []
     with tempfile.TemporaryDirectory() as folder:
         with tarfile.open(fileobj=BytesIO(tar_file.content)) as repo:
@@ -83,20 +111,83 @@ def fetch_tags() -> list[Tag]:
             repo.extractall(folder, included)
 
         for tag_file in Path(folder).rglob("*.md"):
+            name = tag_file.name
             group = None
             if tag_file.parent.name != "tags":
                 # Tags in sub-folders are considered part of a group
                 group = tag_file.parent.name
 
             tags.append(Tag(
-                name=tag_file.name.removesuffix(".md"),
+                name=name.removesuffix(".md"),
+                sha=hashes[name],
                 group=group,
                 body=tag_file.read_text(encoding="utf-8"),
+                last_commit=None,
             ))
 
     return tags
 
 
+def set_tag_commit(tag: Tag) -> Tag:
+    """Fetch commit information from the API, and save it for the tag."""
+    path = "/bot/resources/tags"
+    if tag.group:
+        path += f"/{tag.group}"
+    path += f"/{tag.name}.md"
+
+    # Fetch and set the commit
+    with github_client() as client:
+        data = client.get("/repos/python-discord/bot/commits", params={"path": path})
+        data.raise_for_status()
+        data = data.json()[0]
+
+    commit = data["commit"]
+    author, committer = commit["author"], commit["committer"]
+
+    date = datetime.datetime.strptime(committer["date"], settings.GITHUB_TIMESTAMP_FORMAT)
+    date = date.replace(tzinfo=datetime.timezone.utc)
+
+    if author["email"] == committer["email"]:
+        commit_author = [author]
+    else:
+        commit_author = [author, committer]
+
+    commit_obj, _ = Commit.objects.get_or_create(
+        sha=data["sha"],
+        message=commit["message"],
+        date=date,
+        author=json.dumps(commit_author),
+    )
+    tag.last_commit = commit_obj
+    tag.save()
+
+    return tag
+
+
+def record_tags(tags: list[Tag]) -> None:
+    """Sync the database with an updated set of tags."""
+    # Remove entries which no longer exist
+    Tag.objects.exclude(name__in=[tag.name for tag in tags]).delete()
+
+    # Insert/update the tags
+    for tag in tags:
+        try:
+            old_tag = Tag.objects.get(name=tag.name)
+        except Tag.DoesNotExist:
+            # The tag is not in the database yet,
+            # pretend it's previous state is the current state
+            old_tag = tag
+
+        if old_tag.sha == tag.sha and old_tag.last_commit is not None:
+            # We still have an up-to-date commit entry
+            tag.last_commit = old_tag.last_commit
+
+        tag.save()
+
+    # Drop old, unused commits
+    Commit.objects.filter(tag__isnull=True).delete()
+
+
 def get_tags() -> list[Tag]:
     """Return a list of all tags visible to the application, from the cache or API."""
     if settings.STATIC_BUILD:  # pragma: no cover
@@ -113,9 +204,7 @@ def get_tags() -> list[Tag]:
             tags = get_tags_static()
         else:
             tags = fetch_tags()
-            Tag.objects.exclude(name__in=[tag.name for tag in tags]).delete()
-            for tag in tags:
-                tag.save()
+            record_tags(tags)
 
         return tags
     else:
@@ -127,6 +216,9 @@ def get_tag(path: str) -> typing.Union[Tag, list[Tag]]:
     """
     Return a tag based on the search location.
 
+    If certain tag data is out of sync (for instance a commit date is missing),
+    an extra request will be made to sync the information.
+
     The tag name and group must match. If only one argument is provided in the path,
     it's assumed to either be a group name, or a no-group tag name.
 
@@ -142,6 +234,8 @@ def get_tag(path: str) -> typing.Union[Tag, list[Tag]]:
     matches = []
     for tag in get_tags():
         if tag.name == name and tag.group == group:
+            if tag.last_commit is None:
+                set_tag_commit(tag)
             return tag
         elif tag.group == name and group is None:
             matches.append(tag)
diff --git a/pydis_site/static/css/content/tag.css b/pydis_site/static/css/content/tag.css
index 32a605a8..79795f9e 100644
--- a/pydis_site/static/css/content/tag.css
+++ b/pydis_site/static/css/content/tag.css
@@ -5,5 +5,9 @@
 }
 
 .content a *:hover {
-    color: black;
+    color: dimgray;
+}
+
+span.update-time {
+    text-decoration: black underline dotted;
 }
diff --git a/pydis_site/templates/content/tag.html b/pydis_site/templates/content/tag.html
index 9bd65744..513009da 100644
--- a/pydis_site/templates/content/tag.html
+++ b/pydis_site/templates/content/tag.html
@@ -9,10 +9,30 @@
 {% endblock %}
 
 {% block title_element %}
-    <div class="level">
+    <div class="level mb-2">
         <div class="level-left">{{ block.super }}</div>
         <div class="level-right">
             <a class="level-item fab fa-github" href="{{ tag.url }}"></a>
         </div>
     </div>
+
+    <div class="dropdown is-size-6 is-hoverable">
+        <div class="dropdown-trigger ">
+            <a aria-haspopup="menu" href="{{ tag.last_commit.url }}">
+                <span class="update-time">
+                    Last Updated: {{ tag.last_commit.date | date:"F j, Y g:i A e" }}
+                </span>
+            </a>
+        </div>
+        <div class="dropdown-menu">
+            <div class="dropdown-content">
+                <div class="dropdown-item">Last edited by:</div>
+                {% for user in tag.last_commit.format_users %}
+                    <div class="dropdown-item">{{ user }}</div>
+                {% endfor %}
+                <div class="dropdown-divider"></div>
+                <div class="dropdown-item">{{ tag.last_commit.message }}</div>
+            </div>
+        </div>
+    </div>
 {% endblock %}
-- 
cgit v1.2.3


From 89b0853245fdf5ba7f1f386d7ea7ab1548b538da Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 16 Aug 2022 22:09:14 +0400
Subject: Fix Tag Metadata For Static Builds

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/utils.py | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 7b078de6..e4a24a73 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -128,8 +128,19 @@ def fetch_tags() -> list[Tag]:
     return tags
 
 
-def set_tag_commit(tag: Tag) -> Tag:
+def set_tag_commit(tag: Tag) -> None:
     """Fetch commit information from the API, and save it for the tag."""
+    if settings.STATIC_BUILD:
+        # Static builds request every page during build, which can ratelimit it.
+        # Instead, we return some fake data.
+        tag.last_commit = Commit(
+            sha="68da80efc00d9932a209d5cccd8d344cec0f09ea",
+            message="Initial Commit\n\nTHIS IS FAKE DEMO DATA",
+            date=datetime.datetime(2018, 2, 3, 12, 20, 26, tzinfo=datetime.timezone.utc),
+            author=json.dumps([{"name": "Joseph", "email": "joseph@josephbanks.me"}]),
+        )
+        return
+
     path = "/bot/resources/tags"
     if tag.group:
         path += f"/{tag.group}"
@@ -161,8 +172,6 @@ def set_tag_commit(tag: Tag) -> Tag:
     tag.last_commit = commit_obj
     tag.save()
 
-    return tag
-
 
 def record_tags(tags: list[Tag]) -> None:
     """Sync the database with an updated set of tags."""
-- 
cgit v1.2.3


From 92a42694b6ad1a29e5a21e0b3e57639528837113 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 16 Aug 2022 23:45:25 +0400
Subject: Fix Tests For Tag Metadata

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/api/tests/test_github_utils.py |   7 +-
 pydis_site/apps/content/tests/test_utils.py    | 132 +++++++++++++++++++++++--
 pydis_site/apps/content/tests/test_views.py    |  36 ++++---
 pydis_site/apps/content/utils.py               |   2 +-
 4 files changed, 148 insertions(+), 29 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/api/tests/test_github_utils.py b/pydis_site/apps/api/tests/test_github_utils.py
index f642f689..6e25bc80 100644
--- a/pydis_site/apps/api/tests/test_github_utils.py
+++ b/pydis_site/apps/api/tests/test_github_utils.py
@@ -11,6 +11,7 @@ import rest_framework.response
 import rest_framework.test
 from django.urls import reverse
 
+from pydis_site import settings
 from .. import github_utils
 
 
@@ -49,7 +50,7 @@ class CheckRunTests(unittest.TestCase):
         "head_sha": "sha",
         "status": "completed",
         "conclusion": "success",
-        "created_at": datetime.datetime.utcnow().strftime(github_utils.ISO_FORMAT_STRING),
+        "created_at": datetime.datetime.utcnow().strftime(settings.GITHUB_TIMESTAMP_FORMAT),
         "artifacts_url": "url",
     }
 
@@ -74,7 +75,7 @@ class CheckRunTests(unittest.TestCase):
         # to guarantee the right conclusion
         kwargs["created_at"] = (
             datetime.datetime.utcnow() - github_utils.MAX_RUN_TIME - datetime.timedelta(minutes=10)
-        ).strftime(github_utils.ISO_FORMAT_STRING)
+        ).strftime(settings.GITHUB_TIMESTAMP_FORMAT)
 
         with self.assertRaises(github_utils.RunTimeoutError):
             github_utils.check_run_status(github_utils.WorkflowRun(**kwargs))
@@ -178,7 +179,7 @@ class ArtifactFetcherTests(unittest.TestCase):
                 run = github_utils.WorkflowRun(
                     name="action_name",
                     head_sha="action_sha",
-                    created_at=datetime.datetime.now().strftime(github_utils.ISO_FORMAT_STRING),
+                    created_at=datetime.datetime.now().strftime(settings.GITHUB_TIMESTAMP_FORMAT),
                     status="completed",
                     conclusion="success",
                     artifacts_url="artifacts_url"
diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index 556f633c..2ef033e4 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -1,3 +1,5 @@
+import datetime
+import json
 import tarfile
 import tempfile
 import textwrap
@@ -15,6 +17,18 @@ from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
 
+_time = datetime.datetime(2022, 10, 10, 10, 10, 10, tzinfo=datetime.timezone.utc)
+_time_str = _time.strftime(settings.GITHUB_TIMESTAMP_FORMAT)
+TEST_COMMIT_KWARGS = {
+    "sha": "123",
+    "message": "Hello world\n\nThis is a commit message",
+    "date": _time,
+    "author": json.dumps([
+        {"name": "Author 1", "email": "mail1@example.com", "date": _time_str},
+        {"name": "Author 2", "email": "mail2@example.com", "date": _time_str},
+    ]),
+}
+
 
 class GetCategoryTests(MockPagesTestCase):
     """Tests for the get_category function."""
@@ -109,6 +123,10 @@ class GetPageTests(MockPagesTestCase):
 class TagUtilsTests(TestCase):
     """Tests for the tag-related utilities."""
 
+    def setUp(self) -> None:
+        super().setUp()
+        self.commit = models.Commit.objects.create(**TEST_COMMIT_KWARGS)
+
     @mock.patch.object(utils, "fetch_tags")
     def test_static_fetch(self, fetch_mock: mock.Mock):
         """Test that the static fetch function is only called at most once during static builds."""
@@ -121,9 +139,27 @@ class TagUtilsTests(TestCase):
         self.assertEqual(tags, result)
         self.assertEqual(tags, second_result)
 
-    @mock.patch("httpx.get")
+    @mock.patch("httpx.Client.get")
     def test_mocked_fetch(self, get_mock: mock.Mock):
         """Test that proper data is returned from fetch, but with a mocked API response."""
+        fake_request = httpx.Request("GET", "https://google.com")
+
+        # Metadata requests
+        returns = [httpx.Response(
+            request=fake_request,
+            status_code=200,
+            json=[
+                {"type": "file", "name": "first_tag.md", "sha": "123"},
+                {"type": "file", "name": "second_tag.md", "sha": "456"},
+                {"type": "dir", "name": "some_group", "sha": "789", "url": "/some_group"},
+            ]
+        ), httpx.Response(
+            request=fake_request,
+            status_code=200,
+            json=[{"type": "file", "name": "grouped_tag.md", "sha": "789123"}]
+        )]
+
+        # Main content request
         bodies = (
             "This is the first tag!",
             textwrap.dedent("""
@@ -156,33 +192,36 @@ class TagUtilsTests(TestCase):
 
                 body = (tar_folder / "temp.tar").read_bytes()
 
-        get_mock.return_value = httpx.Response(
+        returns.append(httpx.Response(
             status_code=200,
             content=body,
-            request=httpx.Request("GET", "https://google.com"),
-        )
+            request=fake_request,
+        ))
 
+        get_mock.side_effect = returns
         result = utils.fetch_tags()
 
         def sort(_tag: models.Tag) -> str:
             return _tag.name
 
         self.assertEqual(sorted([
-            models.Tag(name="first_tag", body=bodies[0]),
-            models.Tag(name="second_tag", body=bodies[1]),
-            models.Tag(name="grouped_tag", body=bodies[2], group=group_folder.name),
+            models.Tag(name="first_tag", body=bodies[0], sha="123"),
+            models.Tag(name="second_tag", body=bodies[1], sha="245"),
+            models.Tag(name="grouped_tag", body=bodies[2], group=group_folder.name, sha="789123"),
         ], key=sort), sorted(result, key=sort))
 
     def test_get_real_tag(self):
         """Test that a single tag is returned if it exists."""
-        tag = models.Tag.objects.create(name="real-tag")
+        tag = models.Tag.objects.create(name="real-tag", last_commit=self.commit)
         result = utils.get_tag("real-tag")
 
         self.assertEqual(tag, result)
 
     def test_get_grouped_tag(self):
         """Test fetching a tag from a group."""
-        tag = models.Tag.objects.create(name="real-tag", group="real-group")
+        tag = models.Tag.objects.create(
+            name="real-tag", group="real-group", last_commit=self.commit
+        )
         result = utils.get_tag("real-group/real-tag")
 
         self.assertEqual(tag, result)
@@ -269,3 +308,78 @@ class TagUtilsTests(TestCase):
             tag = models.Tag(**options)
             with self.subTest(tag=tag):
                 self.assertEqual(url, tag.url)
+
+    @mock.patch("httpx.Client.get")
+    def test_get_tag_commit(self, get_mock: mock.Mock):
+        """Test the get commit function with a normal tag."""
+        tag = models.Tag.objects.create(name="example")
+
+        authors = json.loads(self.commit.author)
+
+        get_mock.return_value = httpx.Response(
+            request=httpx.Request("GET", "https://google.com"),
+            status_code=200,
+            json=[{
+                "sha": self.commit.sha,
+                "commit": {
+                    "message": self.commit.message,
+                    "author": authors[0],
+                    "committer": authors[1],
+                }
+            }]
+        )
+
+        result = utils.get_tag(tag.name)
+        self.assertEqual(tag, result)
+
+        get_mock.assert_called_once()
+        call_params = get_mock.call_args[1]["params"]
+
+        self.assertEqual({"path": "/bot/resources/tags/example.md"}, call_params)
+        self.assertEqual(self.commit, models.Tag.objects.get(name=tag.name).last_commit)
+
+    @mock.patch("httpx.Client.get")
+    def test_get_group_tag_commit(self, get_mock: mock.Mock):
+        """Test the get commit function with a group tag."""
+        tag = models.Tag.objects.create(name="example", group="group-name")
+
+        authors = json.loads(self.commit.author)
+        authors.pop()
+        self.commit.author = json.dumps(authors)
+        self.commit.save()
+
+        get_mock.return_value = httpx.Response(
+            request=httpx.Request("GET", "https://google.com"),
+            status_code=200,
+            json=[{
+                "sha": self.commit.sha,
+                "commit": {
+                    "message": self.commit.message,
+                    "author": authors[0],
+                    "committer": authors[0],
+                }
+            }]
+        )
+
+        utils.set_tag_commit(tag)
+
+        get_mock.assert_called_once()
+        call_params = get_mock.call_args[1]["params"]
+
+        self.assertEqual({"path": "/bot/resources/tags/group-name/example.md"}, call_params)
+        self.assertEqual(self.commit, models.Tag.objects.get(name=tag.name).last_commit)
+
+    @mock.patch.object(utils, "set_tag_commit")
+    def test_exiting_commit(self, set_commit_mock: mock.Mock):
+        """Test that a commit is saved when the data has not changed."""
+        tag = models.Tag.objects.create(name="tag-name", body="old body", last_commit=self.commit)
+
+        # This is only applied to the object, not to the database
+        tag.last_commit = None
+
+        utils.record_tags([tag])
+        self.assertEqual(self.commit, tag.last_commit)
+
+        result = utils.get_tag("tag-name")
+        self.assertEqual(tag, result)
+        set_commit_mock.assert_not_called()
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index c5c25be4..658ac2cc 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -8,10 +8,11 @@ from django.http import Http404
 from django.test import RequestFactory, SimpleTestCase, override_settings
 from django.urls import reverse
 
-from pydis_site.apps.content.models import Tag
+from pydis_site.apps.content.models import Commit, Tag
 from pydis_site.apps.content.tests.helpers import (
     BASE_PATH, MockPagesTestCase, PARSED_CATEGORY_INFO, PARSED_HTML, PARSED_METADATA
 )
+from pydis_site.apps.content.tests.test_utils import TEST_COMMIT_KWARGS
 from pydis_site.apps.content.views import PageOrCategoryView
 
 
@@ -193,11 +194,12 @@ class TagViewTests(django.test.TestCase):
     def setUp(self):
         """Set test helpers, then set up fake filesystem."""
         super().setUp()
+        self.commit = Commit.objects.create(**TEST_COMMIT_KWARGS)
 
     def test_routing(self):
         """Test that the correct template is returned for each route."""
-        Tag.objects.create(name="example")
-        Tag.objects.create(name="grouped-tag", group="group-name")
+        Tag.objects.create(name="example", last_commit=self.commit)
+        Tag.objects.create(name="grouped-tag", group="group-name", last_commit=self.commit)
 
         cases = [
             ("/pages/tags/example/", "content/tag.html"),
@@ -213,7 +215,7 @@ class TagViewTests(django.test.TestCase):
 
     def test_valid_tag_returns_200(self):
         """Test that a page is returned for a valid tag."""
-        Tag.objects.create(name="example", body="This is the tag body.")
+        Tag.objects.create(name="example", body="This is the tag body.", last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(200, response.status_code)
         self.assertIn("This is the tag body", response.content.decode("utf-8"))
@@ -233,7 +235,7 @@ class TagViewTests(django.test.TestCase):
         Tag content here.
         """)
 
-        tag = Tag.objects.create(name="example", body=body)
+        tag = Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         expected = {
             "page_title": "example",
@@ -256,7 +258,9 @@ class TagViewTests(django.test.TestCase):
         The only difference between this and a regular tag are the breadcrumbs,
         so only those are checked.
         """
-        Tag.objects.create(name="example", body="Body text", group="group-name")
+        Tag.objects.create(
+            name="example", body="Body text", group="group-name", last_commit=self.commit
+        )
         response = self.client.get("/pages/tags/group-name/example/")
         self.assertListEqual([
             {"name": "Pages", "path": "."},
@@ -266,9 +270,9 @@ class TagViewTests(django.test.TestCase):
 
     def test_group_page(self):
         """Test rendering of a group's root page."""
-        Tag.objects.create(name="tag-1", body="Body 1", group="group-name")
-        Tag.objects.create(name="tag-2", body="Body 2", group="group-name")
-        Tag.objects.create(name="not-included")
+        Tag.objects.create(name="tag-1", body="Body 1", group="group-name", last_commit=self.commit)
+        Tag.objects.create(name="tag-2", body="Body 2", group="group-name", last_commit=self.commit)
+        Tag.objects.create(name="not-included", last_commit=self.commit)
 
         response = self.client.get("/pages/tags/group-name/")
         content = response.content.decode("utf-8")
@@ -298,7 +302,7 @@ class TagViewTests(django.test.TestCase):
         **This text is in bold**
         """)
 
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         content = response.content.decode("utf-8")
 
@@ -317,7 +321,7 @@ class TagViewTests(django.test.TestCase):
         Tag body.
         """)
 
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         content = response.content.decode("utf-8")
 
@@ -333,7 +337,7 @@ class TagViewTests(django.test.TestCase):
         ---
         """)
 
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
         response = self.client.get("/pages/tags/example/")
         self.assertEqual(
             "Embed title",
@@ -345,7 +349,7 @@ class TagViewTests(django.test.TestCase):
         """Test hyperlinking of tags works as intended."""
         filler_before, filler_after = "empty filler text\n\n", "more\nfiller"
         body = filler_before + "`!tags return`" + filler_after
-        Tag.objects.create(name="example", body=body)
+        Tag.objects.create(name="example", body=body, last_commit=self.commit)
 
         other_url = reverse("content:tag", kwargs={"location": "return"})
         response = self.client.get("/pages/tags/example/")
@@ -356,9 +360,9 @@ class TagViewTests(django.test.TestCase):
 
     def test_tag_root_page(self):
         """Test the root tag page which lists all tags."""
-        Tag.objects.create(name="tag-1")
-        Tag.objects.create(name="tag-2")
-        Tag.objects.create(name="tag-3")
+        Tag.objects.create(name="tag-1", last_commit=self.commit)
+        Tag.objects.create(name="tag-2", last_commit=self.commit)
+        Tag.objects.create(name="tag-3", last_commit=self.commit)
 
         response = self.client.get("/pages/tags/")
         content = response.content.decode("utf-8")
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index e4a24a73..63f1c41c 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -130,7 +130,7 @@ def fetch_tags() -> list[Tag]:
 
 def set_tag_commit(tag: Tag) -> None:
     """Fetch commit information from the API, and save it for the tag."""
-    if settings.STATIC_BUILD:
+    if settings.STATIC_BUILD:  # pragma: no cover
         # Static builds request every page during build, which can ratelimit it.
         # Instead, we return some fake data.
         tag.last_commit = Commit(
-- 
cgit v1.2.3


From efe784fe8a6c23248c6698aefab8bf54c5c85900 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 23 Aug 2022 12:54:16 +0400
Subject: Support Hyperlinked Tag Group Replacement

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/tests/test_views.py | 28 ++++++++++++++++++++++++++++
 pydis_site/apps/content/utils.py            |  4 ++--
 pydis_site/apps/content/views/tags.py       | 26 +++++++++++++++++++++++---
 3 files changed, 53 insertions(+), 5 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index 658ac2cc..da06fc80 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -358,6 +358,34 @@ class TagViewTests(django.test.TestCase):
             response.context.get("page")
         )
 
+    def test_hyperlinked_group(self):
+        """Test hyperlinking with a group works as intended."""
+        Tag.objects.create(
+            name="example", body="!tags group-name grouped-tag", last_commit=self.commit
+        )
+        Tag.objects.create(name="grouped-tag", group="group-name")
+
+        other_url = reverse("content:tag", kwargs={"location": "group-name/grouped-tag"})
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            markdown.markdown(f"[!tags group-name grouped-tag]({other_url})"),
+            response.context.get("page")
+        )
+
+    def test_hyperlinked_extra_text(self):
+        """Test hyperlinking when a tag is followed by extra, unrelated text."""
+        Tag.objects.create(
+            name="example", body="!tags other unrelated text", last_commit=self.commit
+        )
+        Tag.objects.create(name="other")
+
+        other_url = reverse("content:tag", kwargs={"location": "other"})
+        response = self.client.get("/pages/tags/example/")
+        self.assertEqual(
+            markdown.markdown(f"[!tags other]({other_url}) unrelated text"),
+            response.context.get("page")
+        )
+
     def test_tag_root_page(self):
         """Test the root tag page which lists all tags."""
         Tag.objects.create(name="tag-1", last_commit=self.commit)
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 63f1c41c..32d3d638 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -221,7 +221,7 @@ def get_tags() -> list[Tag]:
         return Tag.objects.all()
 
 
-def get_tag(path: str) -> typing.Union[Tag, list[Tag]]:
+def get_tag(path: str, *, skip_sync: bool = False) -> typing.Union[Tag, list[Tag]]:
     """
     Return a tag based on the search location.
 
@@ -243,7 +243,7 @@ def get_tag(path: str) -> typing.Union[Tag, list[Tag]]:
     matches = []
     for tag in get_tags():
         if tag.name == name and tag.group == group:
-            if tag.last_commit is None:
+            if tag.last_commit is None and not skip_sync:
                 set_tag_commit(tag)
             return tag
         elif tag.group == name and group is None:
diff --git a/pydis_site/apps/content/views/tags.py b/pydis_site/apps/content/views/tags.py
index a8df65db..4f4bb5a2 100644
--- a/pydis_site/apps/content/views/tags.py
+++ b/pydis_site/apps/content/views/tags.py
@@ -11,7 +11,12 @@ from django.views.generic import TemplateView
 from pydis_site.apps.content import utils
 from pydis_site.apps.content.models import Tag
 
-COMMAND_REGEX = re.compile(r"`*!tags? (?P<name>[\w\d-]+)`*")
+# The following regex tries to parse a tag command
+# It'll read up to two words seperated by spaces
+# If the command does not include a group, the tag name will be in the `first` group
+# If there's a second word after the command, or if there's a tag group, extra logic
+# is necessary to determine whether it's a tag with a group, or a tag with text after it
+COMMAND_REGEX = re.compile(r"`*!tags? (?P<first>[\w-]+)(?P<second> [\w-]+)?`*")
 
 
 class TagView(TemplateView):
@@ -75,8 +80,23 @@ class TagView(TemplateView):
 
         # Check for tags which can be hyperlinked
         def sub(match: re.Match) -> str:
-            link = reverse("content:tag", kwargs={"location": match.group("name")})
-            return f"[{match.group()}]({link})"
+            first, second = match.groups()
+            location = first
+            text, extra = match.group(), ""
+
+            if second is not None:
+                # Possibly a tag group
+                try:
+                    new_location = f"{first}/{second.strip()}"
+                    utils.get_tag(new_location, skip_sync=True)
+                    location = new_location
+                except Tag.DoesNotExist:
+                    # Not a group, remove the second argument from the link
+                    extra = text[text.find(second):]
+                    text = text[:text.find(second)]
+
+            link = reverse("content:tag", kwargs={"location": location})
+            return f"[{text}]({link}){extra}"
         content = COMMAND_REGEX.sub(sub, content)
 
         # Add support for some embed elements
-- 
cgit v1.2.3


From 2343f7ab5c738b5b28554c766e78eb6a663bd064 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Tue, 23 Aug 2022 13:11:35 +0400
Subject: Rename Tag Model Author Field

Renames the tag model `author` field to `authors` to better indicate
what's contained in the field, and updates the documentation.

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/migrations/0001_add_tags.py | 4 ++--
 pydis_site/apps/content/models/tag.py               | 9 +++++++--
 pydis_site/apps/content/tests/test_utils.py         | 8 ++++----
 pydis_site/apps/content/utils.py                    | 8 ++++----
 4 files changed, 17 insertions(+), 12 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/migrations/0001_add_tags.py b/pydis_site/apps/content/migrations/0001_add_tags.py
index 73525243..2c31e4c1 100644
--- a/pydis_site/apps/content/migrations/0001_add_tags.py
+++ b/pydis_site/apps/content/migrations/0001_add_tags.py
@@ -1,4 +1,4 @@
-# Generated by Django 4.0.6 on 2022-08-16 17:38
+# Generated by Django 4.0.6 on 2022-08-23 09:06
 
 import django.db.models.deletion
 from django.db import migrations, models
@@ -18,7 +18,7 @@ class Migration(migrations.Migration):
                 ('sha', models.CharField(help_text='The SHA hash of this commit.', max_length=40, primary_key=True, serialize=False)),
                 ('message', models.TextField(help_text='The commit message.')),
                 ('date', models.DateTimeField(help_text='The date and time the commit was created.')),
-                ('author', models.TextField(help_text='The person(s) who created the commit.')),
+                ('authors', models.TextField(help_text='The person(s) who created the commit. This is a serialized JSON object. Refer to the GitHub documentation on the commit endpoint (schema/commit.author & schema/commit.committer) for more info. https://docs.github.com/en/rest/commits/commits#get-a-commit')),
             ],
         ),
         migrations.CreateModel(
diff --git a/pydis_site/apps/content/models/tag.py b/pydis_site/apps/content/models/tag.py
index e06ce067..1a20d775 100644
--- a/pydis_site/apps/content/models/tag.py
+++ b/pydis_site/apps/content/models/tag.py
@@ -16,7 +16,12 @@ class Commit(models.Model):
     )
     message = models.TextField(help_text="The commit message.")
     date = models.DateTimeField(help_text="The date and time the commit was created.")
-    author = models.TextField(help_text="The person(s) who created the commit.")
+    authors = models.TextField(help_text=(
+        "The person(s) who created the commit. This is a serialized JSON object. "
+        "Refer to the GitHub documentation on the commit endpoint "
+        "(schema/commit.author & schema/commit.committer) for more info. "
+        "https://docs.github.com/en/rest/commits/commits#get-a-commit"
+    ))
 
     @property
     def url(self) -> str:
@@ -30,7 +35,7 @@ class Commit(models.Model):
 
     def format_authors(self) -> collections.abc.Iterable[str]:
         """Return a nice representation of the author(s)' name and email."""
-        for author in json.loads(self.author):
+        for author in json.loads(self.authors):
             yield f"{author['name']} <{author['email']}>"
 
 
diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index 2ef033e4..462818b5 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -23,7 +23,7 @@ TEST_COMMIT_KWARGS = {
     "sha": "123",
     "message": "Hello world\n\nThis is a commit message",
     "date": _time,
-    "author": json.dumps([
+    "authors": json.dumps([
         {"name": "Author 1", "email": "mail1@example.com", "date": _time_str},
         {"name": "Author 2", "email": "mail2@example.com", "date": _time_str},
     ]),
@@ -314,7 +314,7 @@ class TagUtilsTests(TestCase):
         """Test the get commit function with a normal tag."""
         tag = models.Tag.objects.create(name="example")
 
-        authors = json.loads(self.commit.author)
+        authors = json.loads(self.commit.authors)
 
         get_mock.return_value = httpx.Response(
             request=httpx.Request("GET", "https://google.com"),
@@ -343,9 +343,9 @@ class TagUtilsTests(TestCase):
         """Test the get commit function with a group tag."""
         tag = models.Tag.objects.create(name="example", group="group-name")
 
-        authors = json.loads(self.commit.author)
+        authors = json.loads(self.commit.authors)
         authors.pop()
-        self.commit.author = json.dumps(authors)
+        self.commit.authors = json.dumps(authors)
         self.commit.save()
 
         get_mock.return_value = httpx.Response(
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 32d3d638..a1171a45 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -137,7 +137,7 @@ def set_tag_commit(tag: Tag) -> None:
             sha="68da80efc00d9932a209d5cccd8d344cec0f09ea",
             message="Initial Commit\n\nTHIS IS FAKE DEMO DATA",
             date=datetime.datetime(2018, 2, 3, 12, 20, 26, tzinfo=datetime.timezone.utc),
-            author=json.dumps([{"name": "Joseph", "email": "joseph@josephbanks.me"}]),
+            authors=json.dumps([{"name": "Joseph", "email": "joseph@josephbanks.me"}]),
         )
         return
 
@@ -159,15 +159,15 @@ def set_tag_commit(tag: Tag) -> None:
     date = date.replace(tzinfo=datetime.timezone.utc)
 
     if author["email"] == committer["email"]:
-        commit_author = [author]
+        authors = [author]
     else:
-        commit_author = [author, committer]
+        authors = [author, committer]
 
     commit_obj, _ = Commit.objects.get_or_create(
         sha=data["sha"],
         message=commit["message"],
         date=date,
-        author=json.dumps(commit_author),
+        authors=json.dumps(authors),
     )
     tag.last_commit = commit_obj
     tag.save()
-- 
cgit v1.2.3


From 1e538704f5f3518b805720eb38eaa1743b18e2f1 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Fri, 28 Oct 2022 01:23:38 +0300
Subject: Update pydis_site/apps/content/utils.py

Co-authored-by: Johannes Christ <jc@jchri.st>
---
 pydis_site/apps/content/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index a1171a45..d533d95b 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -235,7 +235,7 @@ def get_tag(path: str, *, skip_sync: bool = False) -> typing.Union[Tag, list[Tag
     """
     path = path.split("/")
     if len(path) == 2:
-        group, name = path[0], path[1]
+        group, name = path
     else:
         name = path[0]
         group = None
-- 
cgit v1.2.3


From 153059c051e9b14913c0f6cfba40d8b3ae067555 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Fri, 28 Oct 2022 02:26:10 +0400
Subject: Clean Up Typing

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/utils.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index d533d95b..8e3b0bd7 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -3,7 +3,6 @@ import functools
 import json
 import tarfile
 import tempfile
-import typing
 from io import BytesIO
 from pathlib import Path
 
@@ -218,10 +217,10 @@ def get_tags() -> list[Tag]:
         return tags
     else:
         # Get tags from database
-        return Tag.objects.all()
+        return list(Tag.objects.all())
 
 
-def get_tag(path: str, *, skip_sync: bool = False) -> typing.Union[Tag, list[Tag]]:
+def get_tag(path: str, *, skip_sync: bool = False) -> Tag | list[Tag]:
     """
     Return a tag based on the search location.
 
@@ -255,9 +254,7 @@ def get_tag(path: str, *, skip_sync: bool = False) -> typing.Union[Tag, list[Tag
     raise Tag.DoesNotExist()
 
 
-def get_tag_category(
-    tags: typing.Optional[list[Tag]] = None, *, collapse_groups: bool
-) -> dict[str, dict]:
+def get_tag_category(tags: list[Tag] | None = None, *, collapse_groups: bool) -> dict[str, dict]:
     """
     Generate context data for `tags`, or all tags if None.
 
-- 
cgit v1.2.3


From 426fc71b25e3ba0572d8a294ef98c2302528a661 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Fri, 28 Oct 2022 02:27:26 +0400
Subject: Use `casefold` Instead Of `lower`

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 8e3b0bd7..5fa6353c 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -295,7 +295,7 @@ def get_tag_category(tags: list[Tag] | None = None, *, collapse_groups: bool) ->
         data.append(group)
 
     # Sort the tags, and return them in the proper format
-    return {tag["title"]: tag for tag in sorted(data, key=lambda tag: tag["title"].lower())}
+    return {tag["title"]: tag for tag in sorted(data, key=lambda tag: tag["title"].casefold())}
 
 
 def get_category_pages(path: Path) -> dict[str, dict]:
-- 
cgit v1.2.3


From e8b3745c916ec78f4b7a6232ebb55682a06ef8f0 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Fri, 28 Oct 2022 02:29:56 +0400
Subject: Implicitly Close Client Using `with`

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/utils.py | 41 +++++++++++++++++++---------------------
 1 file changed, 19 insertions(+), 22 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 5fa6353c..8c9ad036 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -75,30 +75,27 @@ def fetch_tags() -> list[Tag]:
     The entire repository is downloaded and extracted locally because
     getting file content would require one request per file, and can get rate-limited.
     """
-    client = github_client()
-
-    # Grab metadata
-    metadata = client.get("/repos/python-discord/bot/contents/bot/resources")
-    metadata.raise_for_status()
-
-    hashes = {}
-    for entry in metadata.json():
-        if entry["type"] == "dir":
-            # Tag group
-            files = client.get(entry["url"])
-            files.raise_for_status()
-            files = files.json()
-        else:
-            files = [entry]
-
-        for file in files:
-            hashes[file["name"]] = file["sha"]
+    with github_client() as client:
+        # Grab metadata
+        metadata = client.get("/repos/python-discord/bot/contents/bot/resources")
+        metadata.raise_for_status()
+
+        hashes = {}
+        for entry in metadata.json():
+            if entry["type"] == "dir":
+                # Tag group
+                files = client.get(entry["url"])
+                files.raise_for_status()
+                files = files.json()
+            else:
+                files = [entry]
 
-    # Download the files
-    tar_file = client.get("/repos/python-discord/bot/tarball")
-    tar_file.raise_for_status()
+            for file in files:
+                hashes[file["name"]] = file["sha"]
 
-    client.close()
+        # Download the files
+        tar_file = client.get("/repos/python-discord/bot/tarball")
+        tar_file.raise_for_status()
 
     tags = []
     with tempfile.TemporaryDirectory() as folder:
-- 
cgit v1.2.3


From 3940e34b89b67f1d45076bb2645f701e40d3357a Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Fri, 28 Oct 2022 02:26:10 +0400
Subject: Clarify Code Intentions

Signed-off-by: Hassan Abouelela <hassan@hassanamr.com>
---
 pydis_site/apps/content/urls.py  |  2 ++
 pydis_site/apps/content/utils.py | 12 ++++++------
 2 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'pydis_site/apps/content/utils.py')

diff --git a/pydis_site/apps/content/urls.py b/pydis_site/apps/content/urls.py
index 163d05bc..a7695a27 100644
--- a/pydis_site/apps/content/urls.py
+++ b/pydis_site/apps/content/urls.py
@@ -40,6 +40,8 @@ def get_all_pages() -> DISTILL_RETURN:
 
 def get_all_tags() -> DISTILL_RETURN:
     """Return all tag names and groups in static builds."""
+    # We instantiate the set with None here to make filtering it out later easier
+    # whether it was added in the loop or not
     groups = {None}
     for tag in utils.get_tags_static():
         groups.add(tag.group)
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 8c9ad036..c12893ef 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -175,19 +175,19 @@ def record_tags(tags: list[Tag]) -> None:
     Tag.objects.exclude(name__in=[tag.name for tag in tags]).delete()
 
     # Insert/update the tags
-    for tag in tags:
+    for new_tag in tags:
         try:
-            old_tag = Tag.objects.get(name=tag.name)
+            old_tag = Tag.objects.get(name=new_tag.name)
         except Tag.DoesNotExist:
             # The tag is not in the database yet,
             # pretend it's previous state is the current state
-            old_tag = tag
+            old_tag = new_tag
 
-        if old_tag.sha == tag.sha and old_tag.last_commit is not None:
+        if old_tag.sha == new_tag.sha and old_tag.last_commit is not None:
             # We still have an up-to-date commit entry
-            tag.last_commit = old_tag.last_commit
+            new_tag.last_commit = old_tag.last_commit
 
-        tag.save()
+        new_tag.save()
 
     # Drop old, unused commits
     Commit.objects.filter(tag__isnull=True).delete()
-- 
cgit v1.2.3