use chrono::{DateTime, Utc};
use rustango::sql::Auto;
use rustango::Model;
use serde::{Deserialize, Serialize};
#[derive(Model, Debug, Clone, Serialize, Deserialize)]
#[rustango(
table = "cms_menu",
app = "cms",
display = "name",
admin(list_display = "slug, name, created_at", ordering = "name",)
)]
pub struct Menu {
#[rustango(primary_key)]
pub id: Auto<i64>,
#[rustango(max_length = 64, unique)]
pub slug: String,
#[rustango(max_length = 100)]
pub name: String,
#[rustango(auto_now_add)]
pub created_at: Auto<DateTime<Utc>>,
}
#[derive(Model, Debug, Clone, Serialize, Deserialize)]
#[rustango(
table = "cms_menu_item",
app = "cms",
display = "label",
admin(
list_display = "menu_id, label, parent_id, sort_order",
ordering = "menu_id, parent_id, sort_order",
)
)]
pub struct MenuItem {
#[rustango(primary_key)]
pub id: Auto<i64>,
#[rustango(fk = "cms_menu", on = "id", index)]
pub menu_id: i64,
#[rustango(fk = "cms_menu_item", on = "id", index)]
pub parent_id: Option<i64>,
pub sort_order: i32,
#[rustango(max_length = 200)]
pub label: String,
#[rustango(fk = "cms_page", on = "id")]
pub page_id: Option<i64>,
#[rustango(max_length = 500)]
pub external_url: Option<String>,
pub open_in_new_tab: bool,
}
#[derive(Debug, Clone, Serialize)]
pub struct ResolvedMenuItem {
pub id: Option<i64>,
pub label: String,
pub url: Option<String>,
pub is_page: bool,
pub page_id: Option<i64>,
pub open_in_new_tab: bool,
pub is_active: bool,
pub in_active_trail: bool,
pub children: Vec<ResolvedMenuItem>,
}
#[derive(Debug, Clone, Serialize)]
pub struct ResolvedMenu {
pub slug: String,
pub name: String,
pub items: Vec<ResolvedMenuItem>,
}
#[derive(Debug, Clone, Copy, Default)]
pub struct MenuOptions<'a> {
pub viewer: Option<&'a rustango::tenancy::auth::User>,
pub locale: Option<&'a crate::locale::Locale>,
pub current: Option<&'a crate::page::Page>,
}
pub async fn resolve_menu(
pool: &rustango::sql::Pool,
slug: &str,
) -> Result<Option<ResolvedMenu>, rustango::sql::ExecError> {
resolve_menu_with(pool, slug, MenuOptions::default()).await
}
pub async fn resolve_menu_for_viewer(
pool: &rustango::sql::Pool,
slug: &str,
viewer: Option<&rustango::tenancy::auth::User>,
) -> Result<Option<ResolvedMenu>, rustango::sql::ExecError> {
resolve_menu_with(
pool,
slug,
MenuOptions {
viewer,
..Default::default()
},
)
.await
}
pub async fn resolve_menu_with(
pool: &rustango::sql::Pool,
slug: &str,
opts: MenuOptions<'_>,
) -> Result<Option<ResolvedMenu>, rustango::sql::ExecError> {
let mut all = resolve_menus_with(pool, Some(&[slug.to_owned()]), opts).await?;
Ok(all.remove(slug))
}
pub async fn resolve_all_menus(
pool: &rustango::sql::Pool,
) -> Result<std::collections::HashMap<String, ResolvedMenu>, rustango::sql::ExecError> {
resolve_menus_with(pool, None, MenuOptions::default()).await
}
pub async fn resolve_menus_with(
pool: &rustango::sql::Pool,
slugs: Option<&[String]>,
opts: MenuOptions<'_>,
) -> Result<std::collections::HashMap<String, ResolvedMenu>, rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let mut menu_q = Menu::objects();
if let Some(list) = slugs {
if list.is_empty() {
return Ok(std::collections::HashMap::new());
}
menu_q = menu_q.where_(Menu::slug.is_in(list.iter().cloned()));
}
let menus: Vec<Menu> = menu_q.fetch(pool).await?;
if menus.is_empty() {
return Ok(std::collections::HashMap::new());
}
let menu_ids: Vec<i64> = menus.iter().filter_map(|m| m.id.get().copied()).collect();
let items: Vec<MenuItem> = MenuItem::objects()
.where_(MenuItem::menu_id.is_in(menu_ids.iter().copied()))
.order_by(&[("sort_order", false), ("id", false)])
.fetch(pool)
.await?;
let referenced_page_ids: std::collections::BTreeSet<i64> =
items.iter().filter_map(|i| i.page_id).collect();
let pages: Vec<crate::page::Page> = if referenced_page_ids.is_empty() {
Vec::new()
} else {
crate::page::Page::objects()
.where_(crate::page::Page::id.is_in(referenced_page_ids.iter().copied()))
.where_(crate::page::Page::status.is_in(crate::page::PageStatus::public_strings()))
.fetch(pool)
.await?
};
let pages_by_id: std::collections::HashMap<i64, &crate::page::Page> = pages
.iter()
.filter_map(|p| p.id.get().copied().map(|id| (id, p)))
.collect();
let page_triples: Vec<(i64, String, i64)> = pages
.iter()
.filter_map(|p| {
p.id.get()
.copied()
.map(|id| (id, p.path.clone(), p.page_type_id))
})
.collect();
let denied = crate::view_restriction::denied_page_ids(pool, opts.viewer, &page_triples).await;
let (item_tr, page_tr) = match opts.locale.filter(|l| !l.is_default) {
Some(loc) => {
let lid = loc.id.get().copied().unwrap_or_default();
let item_ids: Vec<i64> = items.iter().filter_map(|i| i.id.get().copied()).collect();
let page_ids: Vec<i64> = referenced_page_ids.iter().copied().collect();
(
crate::menu_item_translation::fetch_for_items(pool, &item_ids, lid)
.await
.unwrap_or_default(),
crate::translation::fetch_for_pages(pool, &page_ids, lid)
.await
.unwrap_or_default(),
)
}
None => Default::default(),
};
let ctx = ResolveCtx {
pages_by_id: &pages_by_id,
denied: &denied,
item_tr: &item_tr,
page_tr: &page_tr,
current: opts.current,
};
let mut out = std::collections::HashMap::new();
for menu in menus {
let menu_id = menu.id.get().copied().unwrap_or_default();
let mut children_of: std::collections::HashMap<Option<i64>, Vec<&MenuItem>> =
std::collections::HashMap::new();
for item in items.iter().filter(|i| i.menu_id == menu_id) {
children_of.entry(item.parent_id).or_default().push(item);
}
let tree = build(None, &children_of, &ctx);
let rendered = count_nodes(&tree);
let droppable = items
.iter()
.filter(|i| i.menu_id == menu_id)
.filter(|i| {
i.page_id
.is_some_and(|pid| denied.contains(&pid) || !pages_by_id.contains_key(&pid))
})
.count();
let expected = items.iter().filter(|i| i.menu_id == menu_id).count() - droppable;
if rendered < expected {
tracing::warn!(
target: "rustango_cms::navigation",
menu = %menu.slug,
rendered,
expected,
"menu items unreachable from the root — a parent_id cycle, \
or a parent belonging to another menu",
);
}
out.insert(
menu.slug.clone(),
ResolvedMenu {
slug: menu.slug,
name: menu.name,
items: tree,
},
);
}
Ok(out)
}
fn count_nodes(items: &[ResolvedMenuItem]) -> usize {
items.len() + items.iter().map(|i| count_nodes(&i.children)).sum::<usize>()
}
struct ResolveCtx<'a> {
pages_by_id: &'a std::collections::HashMap<i64, &'a crate::page::Page>,
denied: &'a std::collections::HashSet<i64>,
item_tr: &'a std::collections::HashMap<i64, std::collections::HashMap<String, String>>,
page_tr: &'a std::collections::HashMap<i64, std::collections::HashMap<String, String>>,
current: Option<&'a crate::page::Page>,
}
impl ResolveCtx<'_> {
fn item_override(&self, item_id: Option<i64>, field: &str) -> Option<String> {
self.item_tr
.get(&item_id?)?
.get(field)
.filter(|s| !s.is_empty())
.cloned()
}
fn page_title(&self, page_id: i64, page: &crate::page::Page) -> String {
self.page_tr
.get(&page_id)
.and_then(|m| m.get("title"))
.filter(|s| !s.is_empty())
.cloned()
.unwrap_or_else(|| page.title.clone())
}
fn is_ancestor_of_current(&self, target: &crate::page::Page) -> bool {
let Some(cur) = self.current else {
return false;
};
cur.path.starts_with(&target.path) && cur.path != target.path
}
fn is_current_page(&self, page_id: i64) -> bool {
let Some(cur) = self.current else {
return false;
};
cur.id.get().copied() == Some(page_id) || cur.alias_of == Some(page_id)
}
fn external_matches_current(&self, url: &str) -> bool {
let Some(cur) = self.current else {
return false;
};
if !url.starts_with('/') {
return false;
}
let trim = |s: &str| s.trim_end_matches('/').to_owned();
!cur.url_path.is_empty() && trim(url) == trim(&cur.url_path)
}
}
fn build(
parent: Option<i64>,
children_of: &std::collections::HashMap<Option<i64>, Vec<&MenuItem>>,
ctx: &ResolveCtx<'_>,
) -> Vec<ResolvedMenuItem> {
children_of
.get(&parent)
.map(|group| {
group
.iter()
.filter_map(|it| {
let id = it.id.get().copied();
let mut is_active = false;
let mut in_active_trail = false;
let (url, resolved_label, is_page) = if let Some(pid) = it.page_id {
if ctx.denied.contains(&pid) {
return None;
}
let p = ctx.pages_by_id.get(&pid)?;
let url = if p.url_path.is_empty() {
"/".to_owned()
} else {
p.url_path.clone()
};
let label = match ctx.item_override(id, "label") {
Some(t) => t,
None if !it.label.trim().is_empty() => it.label.clone(),
None => ctx.page_title(pid, p),
};
is_active = ctx.is_current_page(pid);
in_active_trail = ctx.is_ancestor_of_current(p);
(url, label, true)
} else if let Some(ext) = it.external_url.clone() {
let url = ctx.item_override(id, "external_url").unwrap_or(ext);
is_active = ctx.external_matches_current(&url);
(
url,
ctx.item_override(id, "label").unwrap_or_else(|| it.label.clone()),
false,
)
} else {
(
String::new(),
ctx.item_override(id, "label").unwrap_or_else(|| it.label.clone()),
false,
)
};
let children = build(id, children_of, ctx);
in_active_trail |= children.iter().any(|c| c.is_active || c.in_active_trail);
Some(ResolvedMenuItem {
id,
label: resolved_label,
url: (!url.is_empty()).then_some(url),
is_page,
page_id: it.page_id,
open_in_new_tab: it.open_in_new_tab,
is_active,
in_active_trail,
children,
})
})
.collect()
})
.unwrap_or_default()
}
#[must_use]
pub fn order_deepest_first(items: Vec<MenuItem>) -> Vec<MenuItem> {
let mut remaining = items;
let mut out = Vec::with_capacity(remaining.len());
while !remaining.is_empty() {
let claimed: std::collections::HashSet<i64> =
remaining.iter().filter_map(|it| it.parent_id).collect();
let (leaves, rest): (Vec<MenuItem>, Vec<MenuItem>) = remaining
.into_iter()
.partition(|it| !it.id.get().copied().is_some_and(|id| claimed.contains(&id)));
if leaves.is_empty() {
out.extend(rest);
return out;
}
out.extend(leaves);
remaining = rest;
}
out
}
pub fn rebase_page_urls(items: &mut [ResolvedMenuItem], site_prefix: &str) {
for item in items {
if item.is_page {
if let Some(url) = item.url.as_mut() {
*url = crate::site::to_public_path(site_prefix, url);
}
}
rebase_page_urls(&mut item.children, site_prefix);
}
}
thread_local! {
static CURRENT_MENUS: std::cell::RefCell<Option<std::collections::HashMap<String, ResolvedMenu>>> =
const { std::cell::RefCell::new(None) };
}
#[must_use = "the guard clears the thread-local on drop; bind it to a local"]
pub struct MenusGuard {
_priv: (),
}
impl Drop for MenusGuard {
fn drop(&mut self) {
CURRENT_MENUS.with(|cell| *cell.borrow_mut() = None);
}
}
pub fn install(menus: std::collections::HashMap<String, ResolvedMenu>) -> MenusGuard {
CURRENT_MENUS.with(|cell| *cell.borrow_mut() = Some(menus));
MenusGuard { _priv: () }
}
pub fn register_tera_function(tera: &mut tera::Tera) {
tera.register_function("menu", MenuFn);
}
struct MenuFn;
impl tera::Function for MenuFn {
fn call(&self, args: &std::collections::HashMap<String, tera::Value>) -> tera::Result<tera::Value> {
let Some(slug) = args.get("slug").and_then(tera::Value::as_str) else {
return Err(tera::Error::msg("menu() needs a `slug` argument"));
};
CURRENT_MENUS.with(|cell| match cell.borrow().as_ref().and_then(|m| m.get(slug)) {
Some(menu) => tera::to_value(menu).map_err(tera::Error::json),
None => Ok(tera::Value::Null),
})
}
}
#[cfg(test)]
mod delete_order_tests {
use super::*;
fn item(id: i64, parent: Option<i64>) -> MenuItem {
MenuItem {
id: rustango::sql::Auto::Set(id),
menu_id: 1,
parent_id: parent,
sort_order: 0,
label: String::new(),
page_id: None,
external_url: None,
open_in_new_tab: false,
}
}
fn ids(items: &[MenuItem]) -> Vec<i64> {
items.iter().filter_map(|i| i.id.get().copied()).collect()
}
fn assert_children_first(ordered: &[MenuItem]) {
let order = ids(ordered);
for it in ordered {
let Some(parent) = it.parent_id else { continue };
let Some(id) = it.id.get().copied() else {
continue;
};
let (Some(ci), Some(pi)) = (
order.iter().position(|&x| x == id),
order.iter().position(|&x| x == parent),
) else {
continue; };
assert!(ci < pi, "child {id} deleted after parent {parent}: {order:?}");
}
}
#[test]
fn a_three_level_subtree_deletes_leaves_first() {
let ordered = order_deepest_first(vec![
item(1, None),
item(2, Some(1)),
item(3, Some(2)),
]);
assert_eq!(ids(&ordered), vec![3, 2, 1]);
assert_children_first(&ordered);
}
#[test]
fn input_order_does_not_matter() {
for input in [
vec![item(1, None), item(2, Some(1)), item(3, Some(2))],
vec![item(3, Some(2)), item(1, None), item(2, Some(1))],
vec![item(2, Some(1)), item(3, Some(2)), item(1, None)],
] {
assert_children_first(&order_deepest_first(input));
}
}
#[test]
fn siblings_and_several_roots_are_all_ordered() {
let ordered = order_deepest_first(vec![
item(1, None),
item(2, Some(1)),
item(3, Some(1)),
item(4, Some(3)),
item(5, None),
]);
assert_eq!(ordered.len(), 5);
assert_children_first(&ordered);
}
#[test]
fn an_item_whose_parent_is_kept_is_a_leaf_here() {
let ordered = order_deepest_first(vec![item(9, Some(7))]);
assert_eq!(ids(&ordered), vec![9]);
}
#[test]
fn a_cycle_terminates_instead_of_hanging() {
let ordered = order_deepest_first(vec![item(1, Some(2)), item(2, Some(1))]);
assert_eq!(ordered.len(), 2);
}
#[test]
fn an_empty_set_is_empty() {
assert!(order_deepest_first(Vec::new()).is_empty());
}
}
#[must_use]
pub fn order_pre_order(items: Vec<MenuItem>) -> Vec<MenuItem> {
use std::collections::{HashMap, HashSet};
let mut children_of: HashMap<Option<i64>, Vec<usize>> = HashMap::new();
for (i, it) in items.iter().enumerate() {
children_of.entry(it.parent_id).or_default().push(i);
}
for group in children_of.values_mut() {
group.sort_by_key(|&i| (items[i].sort_order, items[i].id.get().copied().unwrap_or(0)));
}
let mut out: Vec<usize> = Vec::with_capacity(items.len());
let mut seen: HashSet<usize> = HashSet::new();
let mut stack: Vec<usize> = children_of
.get(&None)
.cloned()
.unwrap_or_default()
.into_iter()
.rev()
.collect();
while let Some(i) = stack.pop() {
if !seen.insert(i) {
continue;
}
out.push(i);
if let Some(kids) = items[i]
.id
.get()
.copied()
.and_then(|id| children_of.get(&Some(id)))
{
for &k in kids.iter().rev() {
stack.push(k);
}
}
}
for i in 0..items.len() {
if !seen.contains(&i) {
out.push(i);
}
}
let mut slots: Vec<Option<MenuItem>> = items.into_iter().map(Some).collect();
out.into_iter()
.filter_map(|i| slots[i].take())
.collect()
}
#[cfg(test)]
mod pre_order_tests {
use super::*;
fn item(id: i64, parent: Option<i64>, sort_order: i32) -> MenuItem {
MenuItem {
id: rustango::sql::Auto::Set(id),
menu_id: 1,
parent_id: parent,
sort_order,
label: format!("item-{id}"),
page_id: None,
external_url: None,
open_in_new_tab: false,
}
}
fn ids(items: &[MenuItem]) -> Vec<i64> {
items.iter().filter_map(|i| i.id.get().copied()).collect()
}
#[test]
fn a_child_immediately_follows_its_parent() {
let ordered = order_pre_order(vec![
item(3, Some(1), 0),
item(1, None, 0),
item(2, None, 10),
]);
assert_eq!(ids(&ordered), vec![1, 3, 2]);
}
#[test]
fn siblings_come_back_in_sort_order() {
let ordered = order_pre_order(vec![
item(1, None, 0),
item(2, Some(1), 20),
item(3, Some(1), 10),
]);
assert_eq!(ids(&ordered), vec![1, 3, 2]);
}
#[test]
fn a_deep_subtree_stays_contiguous() {
let ordered = order_pre_order(vec![
item(1, None, 0),
item(2, Some(1), 0),
item(3, Some(2), 0),
item(4, None, 10),
]);
assert_eq!(ids(&ordered), vec![1, 2, 3, 4]);
}
#[test]
fn the_result_never_loses_an_item() {
let input = vec![
item(1, None, 0),
item(2, Some(1), 0),
item(9, Some(404), 0), ];
let ordered = order_pre_order(input);
assert_eq!(ordered.len(), 3);
assert!(ids(&ordered).contains(&9));
}
#[test]
fn a_cycle_terminates_and_keeps_both_items() {
let ordered = order_pre_order(vec![
item(1, None, 0),
item(2, Some(3), 0),
item(3, Some(2), 0),
]);
assert_eq!(ordered.len(), 3);
assert_eq!(ids(&ordered)[0], 1, "the reachable root still comes first");
}
#[test]
fn an_empty_menu_is_empty() {
assert!(order_pre_order(Vec::new()).is_empty());
}
#[test]
fn input_order_does_not_change_the_result() {
let a = order_pre_order(vec![
item(1, None, 0),
item(2, Some(1), 0),
item(3, None, 10),
]);
let b = order_pre_order(vec![
item(2, Some(1), 0),
item(3, None, 10),
item(1, None, 0),
]);
assert_eq!(ids(&a), ids(&b));
}
}
#[cfg(test)]
mod menu_fn_tests {
use super::*;
fn render(src: &str) -> tera::Result<String> {
let mut tera = tera::Tera::default();
register_tera_function(&mut tera);
tera.add_raw_template("t.html", src).unwrap();
tera.render("t.html", &tera::Context::new())
}
#[test]
fn menu_returns_the_installed_menu_or_null() {
let item = ResolvedMenuItem {
id: Some(1),
label: "About".into(),
url: Some("/about".into()),
is_page: true,
page_id: Some(7),
open_in_new_tab: false,
is_active: false,
in_active_trail: false,
children: Vec::new(),
};
let menu = ResolvedMenu {
slug: "main".into(),
name: "Main".into(),
items: vec![item],
};
let _g = install(std::collections::HashMap::from([("main".to_owned(), menu)]));
let out = render(
r#"{% set nav = menu(slug="main") %}{{ nav.name }}:{% for i in nav.items %}{{ i.label }}={{ i.url }}{% endfor %}|{% set gone = menu(slug="nope") %}{% if gone %}x{% else %}none{% endif %}"#,
)
.unwrap();
assert_eq!(out, "Main:About=/about|none", "autoescaped like any .html template");
assert!(render("{{ menu() }}").is_err(), "a missing slug is a template error");
}
#[test]
fn guard_clears_the_menus() {
drop(install(std::collections::HashMap::new()));
CURRENT_MENUS.with(|c| assert!(c.borrow().is_none()));
}
#[test]
fn rebase_rewrites_page_links_at_every_depth() {
let item = |label: &str, url: &str, is_page: bool, children| ResolvedMenuItem {
id: None,
label: label.into(),
url: Some(url.into()),
is_page,
page_id: None,
open_in_new_tab: false,
is_active: false,
in_active_trail: false,
children,
};
let mut items = vec![item(
"Shop",
"/shop",
true,
vec![item("Catalog", "/shop/catalog", true, vec![]), item("Docs", "https://x.test/shop/a", false, vec![])],
)];
rebase_page_urls(&mut items, "/shop");
assert_eq!(items[0].url.as_deref(), Some("/"));
assert_eq!(items[0].children[0].url.as_deref(), Some("/catalog"));
assert_eq!(items[0].children[1].url.as_deref(), Some("https://x.test/shop/a"));
}
}