use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ItemKind {
Standard,
Separator,
Checkmark,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MenuItem {
pub id: i32,
pub label: String,
pub enabled: bool,
pub visible: bool,
pub kind: ItemKind,
pub toggle: Option<bool>,
pub action: Option<String>,
pub children: Vec<MenuItem>,
}
impl MenuItem {
pub fn standard(label: impl Into<String>, action: impl Into<String>) -> Self {
MenuItem {
id: 0,
label: label.into(),
enabled: true,
visible: true,
kind: ItemKind::Standard,
toggle: None,
action: Some(action.into()),
children: Vec::new(),
}
}
pub fn checkmark(label: impl Into<String>, on: bool, action: impl Into<String>) -> Self {
MenuItem {
toggle: Some(on),
kind: ItemKind::Checkmark,
..MenuItem::standard(label, action)
}
}
pub fn separator() -> Self {
MenuItem {
id: 0,
label: String::new(),
enabled: false,
visible: true,
kind: ItemKind::Separator,
toggle: None,
action: None,
children: Vec::new(),
}
}
pub fn disabled(label: impl Into<String>) -> Self {
MenuItem {
enabled: false,
action: None,
..MenuItem::standard(label, "")
}
}
pub fn disabled_checkmark(label: impl Into<String>, on: bool) -> Self {
MenuItem {
kind: ItemKind::Checkmark,
toggle: Some(on),
..MenuItem::disabled(label)
}
}
}
pub fn radio_menu(top: Vec<MenuItem>, content: Vec<MenuItem>, settings: MenuItem) -> Menu {
let mut items = top;
if !content.is_empty() {
items.push(MenuItem::separator());
items.extend(content);
}
items.push(MenuItem::separator());
items.push(settings);
Menu::new(items)
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct Menu {
pub items: Vec<MenuItem>,
}
impl Menu {
pub fn new(items: Vec<MenuItem>) -> Self {
let mut menu = Menu { items };
let mut next = 1;
assign_ids(&mut menu.items, &mut next);
menu
}
pub fn action_for(&self, id: i32) -> Option<&str> {
find(&self.items, id).and_then(|item| item.action.as_deref())
}
pub fn find(&self, id: i32) -> Option<&MenuItem> {
find(&self.items, id)
}
pub fn flatten(&self) -> Vec<&MenuItem> {
let mut out = Vec::new();
collect(&self.items, &mut out);
out
}
}
fn assign_ids(items: &mut [MenuItem], next: &mut i32) {
for item in items {
item.id = *next;
*next += 1;
assign_ids(&mut item.children, next);
}
}
fn find(items: &[MenuItem], id: i32) -> Option<&MenuItem> {
for item in items {
if item.id == id {
return Some(item);
}
if let Some(found) = find(&item.children, id) {
return Some(found);
}
}
None
}
fn collect<'a>(items: &'a [MenuItem], out: &mut Vec<&'a MenuItem>) {
for item in items {
out.push(item);
collect(&item.children, out);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sample() -> Menu {
Menu::new(vec![
MenuItem::checkmark("Wi-Fi", true, "radio:toggle"),
MenuItem::separator(),
MenuItem::standard("home", "connect:home"),
MenuItem::disabled("guest (enterprise)"),
MenuItem::separator(),
MenuItem::standard("Network settings…", "settings"),
])
}
#[test]
fn rows_are_numbered_from_one_because_zero_is_the_root() {
let menu = sample();
assert!(menu.items.iter().all(|i| i.id > 0));
assert_eq!(menu.items[0].id, 1);
}
#[test]
fn every_row_has_its_own_id_including_nested_ones() {
let menu = Menu::new(vec![
MenuItem::standard("a", "a"),
MenuItem {
children: vec![MenuItem::standard("c", "c"), MenuItem::standard("d", "d")],
..MenuItem::standard("b", "b")
},
]);
let ids: Vec<i32> = menu.flatten().iter().map(|i| i.id).collect();
let mut unique = ids.clone();
unique.sort_unstable();
unique.dedup();
assert_eq!(ids.len(), unique.len(), "ids collide: {ids:?}");
assert_eq!(ids.len(), 4);
}
#[test]
fn a_click_id_resolves_to_the_action_that_row_stood_for() {
let menu = sample();
let home = menu.flatten().iter().find(|i| i.label == "home").unwrap().id;
assert_eq!(menu.action_for(home), Some("connect:home"));
}
#[test]
fn a_row_that_does_nothing_resolves_to_no_action_rather_than_the_next_one() {
let menu = sample();
let sep = menu.flatten().iter().find(|i| i.kind == ItemKind::Separator).unwrap().id;
assert_eq!(menu.action_for(sep), None);
let disabled = menu
.flatten()
.iter()
.find(|i| i.label.contains("enterprise"))
.unwrap()
.id;
assert_eq!(menu.action_for(disabled), None);
}
#[test]
fn an_unknown_id_resolves_to_nothing_rather_than_panicking() {
assert_eq!(sample().action_for(9999), None);
assert!(sample().find(9999).is_none());
}
#[test]
fn only_a_checkmark_carries_a_toggle_state() {
let menu = sample();
for item in menu.flatten() {
match item.kind {
ItemKind::Checkmark => assert!(item.toggle.is_some()),
_ => assert!(item.toggle.is_none(), "{} carries a toggle", item.label),
}
}
}
#[test]
fn a_disabled_checkmark_still_reports_its_state_but_cannot_be_clicked() {
let row = MenuItem::disabled_checkmark("Wi-Fi (blocked by hardware switch)", false);
assert_eq!(row.kind, ItemKind::Checkmark);
assert_eq!(row.toggle, Some(false));
assert!(!row.enabled);
assert!(row.action.is_none());
}
#[test]
fn radio_menu_with_content_is_toggle_then_content_then_settings_with_separators_between() {
let menu = radio_menu(
vec![MenuItem::checkmark("Wi-Fi", true, "wifi:radio:off")],
vec![MenuItem::standard("home", "wifi:connect:home")],
MenuItem::standard("Wi-Fi settings…", "wifi:settings"),
);
let kinds: Vec<ItemKind> = menu.items.iter().map(|i| i.kind).collect();
assert_eq!(
kinds,
vec![
ItemKind::Checkmark,
ItemKind::Separator,
ItemKind::Standard,
ItemKind::Separator,
ItemKind::Standard,
]
);
assert_eq!(menu.items[0].label, "Wi-Fi");
assert_eq!(menu.items[2].label, "home");
assert_eq!(menu.items[4].label, "Wi-Fi settings…");
}
#[test]
fn radio_menu_with_no_content_has_exactly_one_separator() {
let menu = radio_menu(
vec![MenuItem::checkmark("Keep awake", false, "keepawake:on")],
Vec::new(),
MenuItem::standard("Keep awake settings…", "keepawake:settings"),
);
let kinds: Vec<ItemKind> = menu.items.iter().map(|i| i.kind).collect();
assert_eq!(kinds, vec![ItemKind::Checkmark, ItemKind::Separator, ItemKind::Standard]);
}
#[test]
fn radio_menu_unavailable_still_offers_the_settings_row() {
let menu = radio_menu(
vec![MenuItem::disabled("Wi-Fi unavailable")],
Vec::new(),
MenuItem::standard("Wi-Fi settings…", "wifi:settings"),
);
assert!(!menu.items[0].enabled);
assert_eq!(menu.items.last().unwrap().label, "Wi-Fi settings…");
assert!(menu.items.last().unwrap().enabled);
}
#[test]
fn rows_before_the_settings_row_keep_their_ids_whether_or_not_content_is_present() {
let toggle = || MenuItem::checkmark("Wi-Fi", true, "wifi:radio:off");
let settings = || MenuItem::standard("Wi-Fi settings…", "wifi:settings");
let short = radio_menu(vec![toggle()], Vec::new(), settings());
let long = radio_menu(
vec![toggle()],
vec![MenuItem::standard("home", "wifi:connect:home")],
settings(),
);
assert_eq!(short.items[0].id, long.items[0].id, "the toggle is row 1 in both");
}
#[test]
fn a_menu_built_for_an_icon_is_never_empty_even_with_nothing_to_toggle() {
let menu = radio_menu(vec![MenuItem::disabled("Unavailable")], Vec::new(), MenuItem::standard("Settings…", "settings"));
assert!(!menu.items.is_empty());
assert_eq!(menu.items.last().map(|i| i.label.as_str()), Some("Settings…"));
}
#[test]
fn a_menu_round_trips_through_json_including_a_nested_child() {
let menu = radio_menu(
vec![MenuItem::checkmark("Wi-Fi", true, "wifi:radio:off")],
vec![MenuItem {
children: vec![MenuItem::standard("child", "wifi:connect:686f6d65")],
..MenuItem::standard("home", "wifi:connect:686f6d65")
}],
MenuItem::standard("Wi-Fi settings…", "wifi:settings"),
);
let json = serde_json::to_string(&menu).expect("a menu always serialises");
let restored: Menu = serde_json::from_str(&json).expect("what was serialised must deserialise");
assert_eq!(menu, restored);
}
#[test]
fn the_action_string_survives_the_round_trip() {
let menu = sample();
let json = serde_json::to_string(&menu).unwrap();
let restored: Menu = serde_json::from_str(&json).unwrap();
let home = restored.flatten().into_iter().find(|i| i.label == "home").unwrap();
assert_eq!(home.action.as_deref(), Some("connect:home"));
let sep = restored.flatten().into_iter().find(|i| i.kind == ItemKind::Separator).unwrap();
assert_eq!(sep.action, None);
}
}