', part, re.IGNORECASE):
+ in_link = False
+ elif not in_link:
+ parts[i] = DATE_RE.sub(lambda match: _link(match, context), part)
+
+ return mark_safe(''.join(parts))
diff --git a/calendarium/tests/test_commemoration_links.py b/calendarium/tests/test_commemoration_links.py
new file mode 100644
index 00000000..00e94cc0
--- /dev/null
+++ b/calendarium/tests/test_commemoration_links.py
@@ -0,0 +1,150 @@
+from datetime import date
+from types import SimpleNamespace
+
+from django.core.management import call_command
+from django.test import TestCase
+from django.urls import reverse
+
+from commemorations.models import DayCommemoration
+
+from ..datetools import Calendar, Tradition
+from ..templatetags.commemoration_links import link_commemoration_dates, link_date
+
+GREGORIAN, JULIAN = Calendar.Gregorian, Calendar.Julian
+
+
+def readings_url(target, cal='gregorian', tradition='slavic'):
+ return reverse('readings', kwargs={
+ 'tradition': tradition, 'cal': cal,
+ 'year': target.year, 'month': target.month, 'day': target.day,
+ })
+
+
+class LinkDateTestCase(TestCase):
+ def test_links_within_the_church_year(self):
+ """Jan 2, 2026 is in the Church year that began Sep 1, 2025, so a
+ December date links back into 2025 and a July date forward into 2026."""
+ today = date(2026, 1, 2)
+ self.assertEqual(date(2025, 12, 4), link_date(12, 4, today, GREGORIAN))
+ self.assertEqual(date(2026, 7, 19), link_date(7, 19, today, GREGORIAN))
+
+ def test_church_year_turns_on_september_1(self):
+ self.assertEqual(date(2026, 9, 1), link_date(9, 1, date(2027, 8, 31), GREGORIAN))
+ self.assertEqual(date(2028, 8, 31), link_date(8, 31, date(2027, 9, 1), GREGORIAN))
+ self.assertEqual(date(2027, 1, 17), link_date(1, 17, date(2026, 12, 4), GREGORIAN))
+
+ def test_no_link_to_the_day_being_viewed(self):
+ self.assertIsNone(link_date(12, 4, date(2026, 12, 4), GREGORIAN))
+
+ def test_julian_links_to_the_civil_date(self):
+ """Julian Jan 2, 2026 is civil Jan 15. A story's "July 19" is the
+ Julian July 19, which an Old Calendar reader keeps on civil Aug 1."""
+ today = date(2026, 1, 2)
+ self.assertEqual(date(2026, 8, 1), link_date(7, 19, today, JULIAN))
+ self.assertEqual(date(2025, 12, 17), link_date(12, 4, today, JULIAN))
+
+ def test_feb_29_links_to_the_soonest_that_has_not_passed(self):
+ self.assertEqual(date(2028, 2, 29), link_date(2, 29, date(2026, 3, 1), GREGORIAN))
+ self.assertEqual(date(2028, 2, 29), link_date(2, 29, date(2028, 2, 1), GREGORIAN))
+ self.assertEqual(date(2032, 2, 29), link_date(2, 29, date(2028, 3, 1), GREGORIAN))
+ self.assertIsNone(link_date(2, 29, date(2028, 2, 29), GREGORIAN))
+
+ def test_julian_feb_29(self):
+ # Julian Feb 29, 2028 is civil Mar 13.
+ self.assertEqual(date(2028, 3, 13), link_date(2, 29, date(2026, 3, 1), JULIAN))
+ # 2100 is a Julian leap year but not a Gregorian one. Its Julian Feb 29
+ # can't be a Python date, but the civil date it lands on can.
+ self.assertEqual(date(2100, 3, 14), link_date(2, 29, date(2099, 3, 1), JULIAN))
+
+
+class LinkCommemorationDatesTestCase(TestCase):
+ today = date(2026, 1, 2)
+
+ def render(self, html, cal=GREGORIAN):
+ context = SimpleNamespace(date=self.today, calendar=cal, tradition=Tradition.Slavic)
+ return link_commemoration_dates(html, context)
+
+ def test_links_a_parenthetical_reference(self):
+ html = self.render('Saint Seraphim, Bishop of Phanarion (Dec. 4), was ordained.
')
+ self.assertIn(f'Dec. 4', html)
+
+ def test_links_day_first_dates_and_ordinals(self):
+ html = self.render('Saint Oswald (5 August) is also kept on July 19th.
')
+ self.assertIn(f'5 August', html)
+ self.assertIn(f'July 19th', html)
+
+ def test_leaves_historical_dates_alone(self):
+ for text in ('falling asleep in peace on January 2, 1833, chanting',
+ 'was consecrated on December 25 784.',
+ 'died in peace on 22 September 1323.'):
+ with self.subTest(text):
+ self.assertNotIn('{text}'))
+
+ def test_leaves_date_ranges_alone(self):
+ for text in ('On the night of 21-22 November he had a revelation.',
+ 'From November 21-22 he kept vigil.'):
+ with self.subTest(text):
+ self.assertNotIn('{text}'))
+
+ def test_leaves_calendar_marked_dates_alone(self):
+ html = self.render('His feast is kept on this day (March 5 OC, March 18 NC).
')
+ self.assertNotIn('not February 30, nor April 31'))
+
+ def test_leaves_markup_and_existing_links_alone(self):
+ html = self.render('See March 6 and March 7.
')
+ self.assertIn('', html)
+ self.assertIn('March 6', html)
+ self.assertIn(f'March 7', html)
+
+ def test_links_keep_the_calendar(self):
+ html = self.render('
(see July 19)
', JULIAN)
+ self.assertIn(f'July 19', html)
+
+ def test_passes_empty_stories_through(self):
+ self.assertEqual('', self.render(''))
+ self.assertIsNone(self.render(None))
+
+
+class StoryLinksOnPagesTestCase(TestCase):
+ fixtures = ['calendarium.json', 'commemorations.json']
+
+ # The Jan 2 story of St Seraphim of Sarov mentions the saint he was named
+ # for: "Hieromartyr Seraphim, Bishop of Phanarion (Dec. 4)".
+ SERAPHIM = 5209
+
+ def setUp(self):
+ # Slugs aren't in the fixture; the Dockerfile backfills them after
+ # loading it, and so does this, mirroring commemorations.tests.
+ call_command('backfill_saint_slugs')
+
+ def test_readings_page_links_story_dates(self):
+ response = self.client.get(readings_url(date(2026, 1, 2)))
+ self.assertContains(response, f'Dec. 4')
+
+ def test_julian_readings_page_links_to_the_civil_date(self):
+ # Civil Jan 15, 2026 is Julian Jan 2; Julian Dec 4, 2025 is civil Dec 17.
+ response = self.client.get(readings_url(date(2026, 1, 15), cal='julian'))
+ self.assertContains(response, f'Dec. 4')
+
+ def test_saint_page_links_story_dates(self):
+ saint = DayCommemoration.objects.get(pk=self.SERAPHIM).saints.first()
+ response = self.client.get(reverse('saint-detail', args=[saint.slug]))
+ self.assertContains(response, '/readings/slavic/gregorian/')
+ self.assertContains(response, '>Dec. 4')
+ # The links depend on the reader's remembered calendar, so the page
+ # must not be cached across readers. Reading the session is what
+ # makes Django send this; keep it that way.
+ self.assertIn('Cookie', response['Vary'])
+
+ def test_saint_page_keeps_an_old_calendar_reader_on_the_old_calendar(self):
+ # What a reader does: visiting a Julian page remembers the calendar.
+ # (Editing client.session directly doesn't reach the request with
+ # signed-cookie sessions, since the cookie *is* the session.)
+ self.client.get(readings_url(date(2026, 1, 15), cal='julian'))
+ saint = DayCommemoration.objects.get(pk=self.SERAPHIM).saints.first()
+ response = self.client.get(reverse('saint-detail', args=[saint.slug]))
+ self.assertContains(response, '/readings/slavic/julian/')
+ self.assertNotContains(response, '/readings/slavic/gregorian/')
diff --git a/commemorations/templates/saint_detail.html b/commemorations/templates/saint_detail.html
index 63514042..bf9d331d 100644
--- a/commemorations/templates/saint_detail.html
+++ b/commemorations/templates/saint_detail.html
@@ -1,4 +1,5 @@
{% extends "content_base.html" %}
+{% load commemoration_links %}
{% block title %}{{ saint.display_name }}{% endblock %}
@@ -15,7 +16,7 @@ Commemorations
{{ dc.title }} ({{ dc.date_display }})
{% if dc.has_story %}
- {{ dc.story|safe }}
+ {{ dc.story|link_commemoration_dates:story_links }}
{% endif %}
{% endfor %}
diff --git a/commemorations/views.py b/commemorations/views.py
index 0b03cad5..9b2930fe 100644
--- a/commemorations/views.py
+++ b/commemorations/views.py
@@ -1,5 +1,9 @@
+from types import SimpleNamespace
+
from django.shortcuts import get_object_or_404, redirect, render
+from django.utils import timezone
+from calendarium.datetools import Calendar, Tradition, cal_session_key, gregorian_to_julian
from calendarium.liturgics.day import _has_story
from .models import DayCommemoration, Saint
@@ -21,6 +25,23 @@ def _occasion_date(day):
return f'Moveable (Pascha {day.pdist:+d} days)'
+def _story_link_context(request):
+ """What the dates in a saint's stories link to.
+
+ A saint page has no date of its own, so links resolve against today, on
+ the calendar and tradition the reader last chose. They have to use the
+ remembered calendar rather than a fixed one: the readings page remembers
+ whatever calendar a URL carries, so linking an Old Calendar reader to a
+ `gregorian` URL would quietly switch them to the New Calendar."""
+
+ tradition = request.session.get('tradition', Tradition.Slavic)
+ cal = request.session.get(cal_session_key(tradition), Calendar.Gregorian)
+ today = timezone.localtime().date()
+ if cal == Calendar.Julian:
+ today = gregorian_to_julian(today.year, today.month, today.day)
+ return SimpleNamespace(date=today, calendar=cal, tradition=tradition)
+
+
def _attach_display_name(saint):
"""Saint.name is backfilled from whichever DayCommemoration happened to
be used when the row was created, which is often occasion-specific
@@ -84,4 +105,5 @@ def saint_detail_view(request, slug):
return render(request, 'saint_detail.html', context={
'saint': saint,
'commemorations': commemorations,
+ 'story_links': _story_link_context(request),
})
diff --git a/orthocal/static/main.css b/orthocal/static/main.css
index 89e2f138..19773822 100644
--- a/orthocal/static/main.css
+++ b/orthocal/static/main.css
@@ -821,6 +821,25 @@ section.readings h2 {
color: var(--color-text-faint);
cursor: help;
}
+/* Dates in a commemoration's story that link to that day (see
+ calendarium/templatetags/commemoration_links.py). A solid accent-red link
+ in running prose reads like a rubric heading, and on the readings page --
+ which sits outside #content -- these were getting browser-default blue.
+ So the date keeps the paragraph's own colour and borrows the nav's accent
+ underline instead: findable as a cross-reference without shouting.
+ Scoped under #orthocal-content, which wraps both the readings and saint
+ pages, so it outranks the generic `#content a` rule on the saint page. */
+#orthocal-content a.commemoration-date {
+ color: inherit;
+ text-decoration: underline;
+ text-decoration-color: var(--color-accent);
+ text-decoration-thickness: 1px;
+ text-underline-offset: 0.2em;
+}
+#orthocal-content a.commemoration-date:hover {
+ color: var(--color-accent);
+ text-decoration-thickness: 2px;
+}
.day>p {
text-align: center;
}
diff --git a/orthocal/static/print.css b/orthocal/static/print.css
index 0ea57947..a181cb49 100644
--- a/orthocal/static/print.css
+++ b/orthocal/static/print.css
@@ -94,3 +94,12 @@ table.month tr:first-child th {
h1, h2, h3, h4 {
page-break-after: avoid;
}
+/* A commemoration story's dates are links on screen (see main.css), but a
+ link goes nowhere on paper -- print them exactly as the surrounding text,
+ with none of the screen treatment. Same selector as the screen rule, and
+ this sheet loads after main.css, so it wins; it also has to outrank the
+ saint page's generic `#content a` red, which main.css applies in print. */
+#orthocal-content a.commemoration-date {
+ color: inherit;
+ text-decoration: none;
+}