Story 2305: Implement Version Dropdown On V3 Nav Bar (boostorg#2349)

Author: julhoang

config/settings.py

@@ -179,6 +179,7 @@
                 "django.contrib.auth.context_processors.auth",
                 "django.contrib.messages.context_processors.messages",
                 "core.context_processors.current_version",
+                "core.context_processors.selected_version",
                 "core.context_processors.active_nav_item",
                 "core.context_processors.header_context",
                 "core.context_processors.debug",

config/urls.py

@@ -101,6 +101,7 @@
     VersionDetail,
     ReportPreviewView,
     ReportPreviewGenerateView,
+    set_version,
 )
 
 djdt_urls = []
@@ -114,7 +115,7 @@
         "DEBUG_TOOLBAR enabled but Django Debug Toolbar not installed. Run `just build`"
     )
 
-register_converter(BoostVersionSlugConverter, "boostversionslug")
+register_converter(BoostVersionSlugConverter, BoostVersionSlugConverter.URL_TYPE_NAME)
 
 router = routers.SimpleRouter()
 
@@ -218,6 +219,7 @@
             name="boost-development",
         ),
         # Boost versions views
+        path("set-version/", set_version, name="set-version"),
         path("releases/", VersionDetail.as_view(), name="releases-most-recent"),
         path(
             "releases/boost-in-progress/",

core/context_processors.py

@@ -2,14 +2,171 @@
 from enum import StrEnum
 
 from django.conf import settings
-from django.urls import reverse
+from django.urls import NoReverseMatch, reverse
 
+from libraries.constants import LATEST_RELEASE_URL_PATH_STR
+from libraries.utils import get_version_from_cookie
+from versions.converters import BoostVersionSlugConverter
 from versions.models import Version
 
 
+_BOOST_VERSION_SLUG_ROUTE_TOKEN = (
+    f"<{BoostVersionSlugConverter.URL_TYPE_NAME}:version_slug>"
+)
+
+
+def _get_header_version_data(request):
+    """Per-request shared accessor so `current_version` and `selected_version`
+    share one DB fetch within a single request."""
+    cached = getattr(request, "_header_version_data", None)
+    if cached is not None:
+        return cached
+    data = Version.objects.get_header_dropdown_data()
+    request._header_version_data = data
+    return data
+
+
+def _is_non_latest_version(url_version_slug, cookie_slug):
+    """Whether the user's active version is a specific, non-latest one.
+
+    Drives the dropdown button label: non-latest → show version number,
+    otherwise → show "Latest". URL wins over cookie.
+    """
+    if url_version_slug:
+        return url_version_slug != LATEST_RELEASE_URL_PATH_STR
+    if cookie_slug:
+        return cookie_slug != LATEST_RELEASE_URL_PATH_STR
+    return False
+
+
 def current_version(request):
     """Custom context processor that adds the current release to the context"""
-    return {"current_version": Version.objects.most_recent()}
+    return {"current_version": _get_header_version_data(request).most_recent}
+
+
+def selected_version(request):
+    """User's active Boost version + data to render the navbar version dropdown.
+
+    Resolution priority for `selected_version`:
+    1. URL `version_slug` kwarg (on `/releases/`, `/libraries/`, `/library/` routes)
+    2. `boost_version` cookie
+    3. Most recent release (fallback)
+
+    When the version comes from the URL, the dropdown renders anchor links that
+    swap the version segment of the current path — shareable. Otherwise it
+    renders POST forms that write the cookie without navigating.
+
+    Examples
+    --------
+    GET /releases/1.88.0/  (no cookie)
+        selected_version               -> Version(slug="boost-1-88-0")
+        selected_version_is_url_driven -> True       (URL mode: render <a>s)
+        selected_version_is_non_latest -> True       (button reads "1.88.0")
+        selected_version_label         -> "1.88.0"
+        version_dropdown_options[i]    -> Version with `.href` attached,
+                                          e.g. "/releases/1.89.0/"
+        latest_href                    -> "/releases/latest/"
+
+    GET /  (cookie boost_version="boost-1-87-0")
+        selected_version               -> Version(slug="boost-1-87-0")
+        selected_version_is_url_driven -> False      (cookie mode: render <form>s)
+        selected_version_is_non_latest -> True       (button reads "1.87.0")
+        selected_version_label         -> "1.87.0"
+        version_dropdown_options[i]    -> Version (no `.href` needed)
+        latest_href                    -> ""
+
+    GET /  (no cookie)
+        selected_version               -> Version.objects.most_recent()
+        selected_version_is_url_driven -> False
+        selected_version_is_non_latest -> False      (button reads "Latest")
+        selected_version_label         -> "Latest"
+
+    GET /library/1.88.0/foo/  (target version "boost-1-70-0" predates "foo")
+        version_dropdown_options[…].href for that version
+                                       -> "/library/1.70.0/foo/"
+                                          (plain version swap; target view
+                                          renders the missing-version state)
+    """
+    url_version_slug = None
+    resolver_match = getattr(request, "resolver_match", None)
+    if resolver_match and _BOOST_VERSION_SLUG_ROUTE_TOKEN in (
+        resolver_match.route or ""
+    ):
+        url_version_slug = resolver_match.kwargs.get("version_slug")
+
+    is_url_driven = bool(url_version_slug)
+    cookie_slug = get_version_from_cookie(request)
+
+    header_data = _get_header_version_data(request)
+    options = list(header_data.options)
+
+    resolved_slug = url_version_slug or cookie_slug
+    version = None
+    if resolved_slug and resolved_slug != LATEST_RELEASE_URL_PATH_STR:
+        version = next((v for v in options if v.slug == resolved_slug), None)
+        if version is None:
+            version = Version.objects.filter(slug=resolved_slug).first()
+    if version is None:
+        version = header_data.most_recent
+
+    is_non_latest = _is_non_latest_version(url_version_slug, cookie_slug)
+    label = version.display_name if (is_non_latest and version) else "Latest"
+
+    latest_href = ""
+    if is_url_driven and resolver_match and resolver_match.view_name:
+        latest_href = _annotate_option_hrefs(
+            view_name=resolver_match.view_name,
+            url_kwargs=dict(resolver_match.kwargs),
+            options=options,
+        )
+
+    return {
+        "selected_version": version,
+        "selected_version_is_url_driven": is_url_driven,
+        "selected_version_is_non_latest": is_non_latest,
+        "selected_version_label": label,
+        "version_dropdown_options": options,
+        "latest_href": latest_href,
+    }
+
+
+def _annotate_option_hrefs(*, view_name, url_kwargs, options):
+    """Attach `.href` to each option for the current page; return the latest's.
+
+    The swap is a plain `reverse()` with the option's version substituted in —
+    on a library detail page at `/library/1.88.0/foo/`, picking 1.70.0 yields
+    `/library/1.70.0/foo/` even if that library didn't exist in 1.70.0. The
+    target view is responsible for rendering the empty / "not available" state.
+
+    Examples
+    --------
+    Current URL /releases/1.88.0/
+        view_name  = "release-detail"
+        url_kwargs = {"version_slug": "boost-1-88-0"}
+        → each option gets .href = "/releases/<that version>/"
+        → returns "/releases/latest/"
+
+    Current URL /libraries/1.88.0/grid/containers/
+        view_name  = "libraries-list"
+        url_kwargs = {"version_slug": "boost-1-88-0",
+                      "library_view_str": "grid",
+                      "category_slug": "containers"}
+        → each option gets .href = "/libraries/<that version>/grid/containers/"
+        → returns "/libraries/latest/grid/containers/"
+    """
+    for v in options:
+        try:
+            v.href = reverse(view_name, kwargs={**url_kwargs, "version_slug": v.slug})
+        except NoReverseMatch:
+            v.href = ""
+
+    try:
+        return reverse(
+            view_name,
+            kwargs={**url_kwargs, "version_slug": LATEST_RELEASE_URL_PATH_STR},
+        )
+    except NoReverseMatch:
+        return ""
 
 
 class NavItem(StrEnum):

core/tests/test_context_processors.py

@@ -1,7 +1,16 @@
+from types import SimpleNamespace
+
 import pytest
 from django.test import RequestFactory
+from django.urls import ResolverMatch
 
-from core.context_processors import current_version, active_nav_item
+from core.context_processors import (
+    active_nav_item,
+    current_version,
+    selected_version,
+)
+from libraries.constants import SELECTED_BOOST_VERSION_COOKIE_NAME
+from versions.managers import HeaderVersionData
 
 
 def test_current_version_context(
@@ -42,3 +51,99 @@ def test_active_nav_item(path, expected_nav_item):
     request = RequestFactory().get(path)
     context = active_nav_item(request)
     assert context["active_nav_item"] == expected_nav_item
+
+
+def _stub_header_data(request):
+    most_recent = SimpleNamespace(slug="boost-1-88-0", display_name="1.88.0")
+    older = SimpleNamespace(slug="boost-1-87-0", display_name="1.87.0")
+    request._header_version_data = HeaderVersionData(
+        options=[most_recent, older],
+        most_recent=most_recent,
+        most_recent_beta=None,
+    )
+    return most_recent, older
+
+
+def _attach_resolver(request, *, route, kwargs, view_name=""):
+    request.resolver_match = ResolverMatch(
+        func=lambda r: None,
+        args=(),
+        kwargs=kwargs,
+        url_name=view_name or None,
+        route=route,
+    )
+
+
+def test_selected_version_url_driven_for_boost_route(rf):
+    request = rf.get("/releases/1.88.0/")
+    most_recent, older = _stub_header_data(request)
+    _attach_resolver(
+        request,
+        route="releases/<boostversionslug:version_slug>/",
+        kwargs={"version_slug": "boost-1-88-0"},
+        view_name="release-detail",
+    )
+    ctx = selected_version(request)
+    assert ctx["selected_version_is_url_driven"] is True
+    assert ctx["selected_version_is_non_latest"] is True
+    assert ctx["selected_version_label"] == "1.88.0"
+    assert ctx["selected_version"] is most_recent
+    assert ctx["latest_href"] == "/releases/latest/"
+    assert most_recent.href == "/releases/1.88.0/"
+    assert older.href == "/releases/1.87.0/"
+
+
+def test_selected_version_url_driven_with_latest_slug(rf):
+    """`/releases/latest/` is URL-driven but the label should still read
+    'Latest' and the version should fall back to most_recent."""
+    request = rf.get("/releases/latest/")
+    most_recent, _ = _stub_header_data(request)
+    _attach_resolver(
+        request,
+        route="releases/<boostversionslug:version_slug>/",
+        kwargs={"version_slug": "latest"},
+        view_name="release-detail",
+    )
+    ctx = selected_version(request)
+    assert ctx["selected_version_is_url_driven"] is True
+    assert ctx["selected_version_is_non_latest"] is False
+    assert ctx["selected_version_label"] == "Latest"
+    assert ctx["selected_version"] is most_recent
+
+
+def test_selected_version_cookie_driven(rf):
+    """Cookie mode: no URL slug, cookie picks the version, dropdown renders
+    POST forms (no `latest_href`, no per-option `.href`)."""
+    request = rf.get("/")
+    request.COOKIES[SELECTED_BOOST_VERSION_COOKIE_NAME] = "boost-1-87-0"
+    _, older = _stub_header_data(request)
+    ctx = selected_version(request)
+    assert ctx["selected_version_is_url_driven"] is False
+    assert ctx["selected_version_is_non_latest"] is True
+    assert ctx["selected_version_label"] == "1.87.0"
+    assert ctx["selected_version"] is older
+    assert ctx["latest_href"] == ""
+
+
+def test_selected_version_ignores_foreign_route_with_same_kwarg(rf):
+    """A route declaring `version_slug` via a different converter must NOT be
+    treated as URL-driven — the guard against silent coupling."""
+    request = rf.get("/elsewhere/anything/")
+    _stub_header_data(request)
+    _attach_resolver(
+        request,
+        route="elsewhere/<str:version_slug>/",
+        kwargs={"version_slug": "anything"},
+        view_name="some-other-view",
+    )
+    ctx = selected_version(request)
+    assert ctx["selected_version_is_url_driven"] is False
+    assert ctx["selected_version_label"] == "Latest"
+
+
+def test_selected_version_no_resolver_match(rf):
+    request = rf.get("/")
+    _stub_header_data(request)
+    ctx = selected_version(request)
+    assert ctx["selected_version_is_url_driven"] is False
+    assert ctx["selected_version_label"] == "Latest"

news/tests/test_views.py

@@ -419,7 +419,7 @@ def test_news_create_get(tp, regular_user, url_name, form_class):
         # assertGoodView expects a resolved URL
         # see https://github.com/revsys/django-test-plus/issues/202
         url = tp.reverse(url_name)
-        tp.assertGoodView(url, test_query_count=4, verbose=True)
+        tp.assertGoodView(url, test_query_count=5, verbose=True)
 
     form = tp.get_context("form")
     assert isinstance(form, form_class)