Files
Marcos Paulo 15d7f5e873 feat: editor blocks and lint, vault knowledge, calendar plugin, macOS menu
- notescraft-lint (rules, safe fixes, learned style) and notescraft-blocks (block model and edits); engine lint.* and block.* commands with CLI and MCP parity
- Lint tab, underlines, slash menu with preview in Source and Visual, block grip and menu, Settings > Editor and lint, Vim block keys
- Visual view: tables, note embeds, %% comments, wrapping property chips
- Vault knowledge (Related tab, assistant sources, Settings) and calendar plugin
- Sidebar top padding fixed, dot grid follows PaperCraft spacing, right-card tabs no longer cover the collapse button

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-18 12:36:00 -03:00

451 lines
19 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#![allow(clippy::assert_is_empty)]
//! Public-surface tests of the calendar view: every mode draws, long titles are cut with an
//! ellipsis, clicks report what to open, and the view asks for the data it lacks.
use std::time::Instant;
use egui::{Event, PointerButton, Pos2, Rect, Vec2};
use notescraft_calendar::{Item, Kind};
use notescraft_templates::{Date, Weekday};
use notescraft_themes::builtin;
use notescraft_ui_egui::calendar_view::{CalendarData, CalendarResponse, CalendarView, Mode, show_calendar};
use notescraft_ui_egui::theme::Tokens;
fn tokens() -> Tokens {
Tokens::new(builtin("catppuccin-mocha").expect("theme"))
}
fn date(text: &str) -> Date {
text.parse::<notescraft_calendar::EventTime>().expect("date").date()
}
fn item(id: &str, title: &str, start: &str, end: Option<&str>) -> Item {
Item {
id: id.to_owned(),
kind: Kind::Event,
title: title.to_owned(),
start: start.parse().expect("start"),
end: end.map(|e| e.parse().expect("end")),
calendar: Some("Work".to_owned()),
tags: vec![],
priority: None,
status: None,
has_reminder: false,
reminders: vec![],
note: None,
created: None,
done: false,
repeats: false,
source: None,
tz: None,
}
}
fn sample() -> Vec<Item> {
vec![
item("Calendar/standup.md", "Standup", "2026-10-19T09:30", Some("2026-10-19T09:45")),
item("Calendar/lunch.md", "Lunch", "2026-10-20T12:00", Some("2026-10-20T13:00")),
item("Calendar/clash.md", "Dentist", "2026-10-20T12:30", Some("2026-10-20T13:30")),
item("Calendar/trip.md", "Trip to the mountains with the whole family and friends", "2026-10-21", Some("2026-10-23")),
]
}
fn view(mode: Mode) -> CalendarView {
let mut view = CalendarView::new(date("2026-10-20"), Weekday::Monday);
view.mode = mode;
view
}
fn data_for(view: &CalendarView, items: Vec<Item>) -> CalendarData {
CalendarData {
items,
window: view.window(),
saved: vec![],
feed_errors: vec![],
inbox: notescraft_calendar::Inbox::default(),
snooze_minutes: vec![5, 15],
review: None,
}
}
struct Frame {
response: CalendarResponse,
texts: Vec<(Pos2, String)>,
shapes: usize,
}
fn collect(shape: &egui::Shape, out: &mut Vec<(Pos2, String)>) {
match shape {
egui::Shape::Text(text) => out.push((text.pos, text.galley.rows.iter().map(|row| row.text()).collect::<String>())),
egui::Shape::Vec(shapes) => shapes.iter().for_each(|inner| collect(inner, out)),
_ => {}
}
}
fn run(ctx: &egui::Context, view: &mut CalendarView, data: &CalendarData, events: Vec<Event>) -> Frame {
run_with(ctx, view, data, events, egui::Modifiers::NONE)
}
fn run_with(ctx: &egui::Context, view: &mut CalendarView, data: &CalendarData, mut events: Vec<Event>, modifiers: egui::Modifiers) -> Frame {
events.insert(0, Event::ModifiersChanged(modifiers));
let tokens = tokens();
let input = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(1200.0, 800.0))), events, ..Default::default() };
let mut response = CalendarResponse::default();
let mut out = ctx.run_ui(input, |ui| {
response = show_calendar(ui, &tokens, view, data);
});
out.textures_delta.clear();
let mut texts = Vec::new();
out.shapes.iter().for_each(|clipped| collect(&clipped.shape, &mut texts));
Frame { response, shapes: out.shapes.len(), texts }
}
/// A fresh context warmed up with one frame, which only installs the fonts.
fn warm(view: &mut CalendarView, data: &CalendarData) -> egui::Context {
let ctx = egui::Context::default();
notescraft_ui_egui::fonts::install(&ctx);
run(&ctx, view, data, vec![]);
ctx
}
fn has(frame: &Frame, needle: &str) -> bool {
frame.texts.iter().any(|(_, text)| text.contains(needle))
}
#[test]
fn every_mode_draws_what_it_promises() {
for (mode, expected) in [
(Mode::Month, vec!["October 2026", "Mon", "09:30 Standup", "12:00 Lunch"]),
(Mode::Week, vec!["19 Oct – 25 Oct 2026", "Mon", "09:30 Standup", "12:30 Den", "All day"]),
(Mode::Day, vec!["Tuesday 20 October 2026", "12:00 Lunch", "12:30 Dentist"]),
(Mode::Agenda, vec!["Tuesday 20 October", "12:00", "Lunch", "Today"]),
(Mode::Year, vec!["2026", "January", "December"]),
] {
let mut view = view(mode);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
let frame = run(&ctx, &mut view, &data, vec![]);
assert!(frame.shapes > 0, "{mode:?} paints");
for needle in expected {
assert!(has(&frame, needle), "{mode:?} should show `{needle}`; shown: {:?}", frame.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
}
assert!(frame.response.reload.is_none(), "{mode:?} has the data it needs");
}
}
#[test]
fn long_titles_end_in_an_ellipsis() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
let frame = run(&ctx, &mut view, &data, vec![]);
let cut: Vec<&str> = frame.texts.iter().map(|(_, t)| t.as_str()).filter(|t| t.contains("Trip")).collect();
assert!(!cut.is_empty(), "the trip is drawn on its days");
assert!(cut.iter().all(|t| t.ends_with('…') && t.len() < "Trip to the mountains with the whole family and friends".len()), "{cut:?}");
}
#[test]
fn an_empty_agenda_says_so() {
let mut view = view(Mode::Agenda);
let data = data_for(&view, vec![]);
let ctx = warm(&mut view, &data);
assert!(has(&run(&ctx, &mut view, &data, vec![]), "Nothing scheduled"));
}
#[test]
fn clicking_a_chip_opens_its_file() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
let frame = run(&ctx, &mut view, &data, vec![]);
let (at, _) = frame.texts.iter().find(|(_, t)| t.contains("Lunch")).expect("lunch chip").clone();
let target = at + Vec2::new(6.0, 4.0);
run(&ctx, &mut view, &data, vec![Event::PointerMoved(target)]);
run(&ctx, &mut view, &data, vec![Event::PointerButton { pos: target, button: PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }]);
let released = run(
&ctx,
&mut view,
&data,
vec![Event::PointerButton { pos: target, button: PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }],
);
assert_eq!(released.response.open.as_deref(), Some("Calendar/lunch.md"));
}
#[test]
fn the_view_asks_for_the_data_it_lacks() {
let mut view = view(Mode::Month);
let stale = CalendarData::empty((date("2026-01-01"), date("2026-01-31")));
let ctx = warm(&mut view, &stale);
assert_eq!(run(&ctx, &mut view, &stale, vec![]).response.reload, Some(view.window()));
view.mode = Mode::Week;
let loaded = data_for(&view, vec![]);
assert!(run(&ctx, &mut view, &loaded, vec![]).response.reload.is_none());
}
#[test]
fn stepping_moves_the_window() {
let mut view = view(Mode::Month);
let before = view.window();
view.step(1);
assert_ne!(view.window(), before);
assert_eq!(view.cursor, date("2026-11-20"));
view.go_today();
assert_eq!(view.cursor, date("2026-10-20"));
}
#[test]
#[ignore = "benchmark: run with --release --ignored"]
fn a_month_of_ten_thousand_events_draws_fast() {
let mut view = view(Mode::Month);
let items: Vec<Item> =
(0..10_000_u32).map(|n| item(&format!("e{n}.md"), &format!("Event {n}"), &format!("2026-10-{:02}T{:02}:00", 1 + n % 28, n % 24), None)).collect();
let data = data_for(&view, items);
let ctx = warm(&mut view, &data);
let started = Instant::now();
run(&ctx, &mut view, &data, vec![]);
let took = started.elapsed();
assert!(took.as_millis() < 16, "took {took:?}");
}
#[test]
fn typed_keys_move_the_cursor_unless_a_prompt_owns_the_keyboard() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
run(&ctx, &mut view, &data, vec![Event::Text("l".to_owned())]);
assert_eq!(view.cursor, date("2026-10-21"), "l moves one day");
run(&ctx, &mut view, &data, vec![Event::Text("gw".to_owned())]);
assert_eq!(view.mode, Mode::Week, "g then w switches to the week view");
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::GoTo);
let before = view.cursor;
run(&ctx, &mut view, &data, vec![Event::Text("l".to_owned())]);
assert_eq!(view.cursor, before, "an open prompt keeps the keys to itself");
}
fn key(key: egui::Key) -> Event {
Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }
}
/// Moves, presses and releases the pointer at `at`; returns the frame of the release.
fn click(ctx: &egui::Context, view: &mut CalendarView, data: &CalendarData, at: Pos2) -> Frame {
run(ctx, view, data, vec![Event::PointerMoved(at)]);
run(ctx, view, data, vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }]);
run(ctx, view, data, vec![Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }])
}
fn centre_of(frame: &Frame, text: &str) -> Pos2 {
let exact = frame.texts.iter().find(|(_, shown)| shown.as_str() == text);
let found = exact.or_else(|| frame.texts.iter().find(|(_, shown)| shown.contains(text)));
let (at, _) = found.unwrap_or_else(|| panic!("no `{text}` in {:?}", frame.texts.iter().map(|(_, shown)| shown.as_str()).collect::<Vec<_>>()));
*at + Vec2::new(8.0, 6.0)
}
#[test]
fn quick_add_previews_what_it_understood_and_saves_only_on_enter() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::QuickAdd);
view.prompt_text = "Lunch tomorrow at 12:30 for 1h".to_owned();
run(&ctx, &mut view, &data, vec![]);
let shown = run(&ctx, &mut view, &data, vec![]);
assert!(has(&shown, "Lunch · 2026-10-21 12:30"), "{:?}", shown.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
assert!(shown.response.commands.is_empty(), "typing saves nothing");
let entered = run(&ctx, &mut view, &data, vec![key(egui::Key::Enter)]);
assert_eq!(entered.response.commands.len(), 1);
assert_eq!(entered.response.commands[0].0, "calendar.add");
assert_eq!(entered.response.commands[0].1["text"], "Lunch tomorrow at 12:30 for 1h");
assert!(view.prompt.is_none(), "the prompt closes after saving");
assert_eq!(view.cursor, date("2026-10-21"), "the view moves to the new event");
}
#[test]
fn escape_closes_the_prompt_and_saves_nothing() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::QuickAdd);
view.prompt_text = "Lunch tomorrow".to_owned();
run(&ctx, &mut view, &data, vec![]);
let closed = run(&ctx, &mut view, &data, vec![key(egui::Key::Escape)]);
assert!(view.prompt.is_none() && view.prompt_text.is_empty());
assert!(closed.response.commands.is_empty());
}
#[test]
fn a_phrase_that_cannot_be_read_names_the_bad_part_and_stays_open() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::QuickAdd);
view.prompt_text = "Lunch at 25:00".to_owned();
run(&ctx, &mut view, &data, vec![]);
let shown = run(&ctx, &mut view, &data, vec![]);
assert!(has(&shown, "Cannot read `25:00`"), "{:?}", shown.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
let entered = run(&ctx, &mut view, &data, vec![key(egui::Key::Enter)]);
assert!(entered.response.commands.is_empty());
assert!(view.prompt.is_some(), "the prompt stays open so the phrase can be fixed");
}
#[test]
fn go_to_a_date_moves_the_cursor() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
view.prompt = Some(notescraft_ui_egui::calendar_view::Prompt::GoTo);
view.prompt_text = "2026-12-25".to_owned();
run(&ctx, &mut view, &data, vec![]);
run(&ctx, &mut view, &data, vec![key(egui::Key::Enter)]);
assert_eq!(view.cursor, date("2026-12-25"));
assert!(view.prompt.is_none());
}
#[test]
fn the_bulk_bar_counts_before_it_applies() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
view.bulk = Some(vec!["Calendar/lunch.md".to_owned(), "Calendar/clash.md".to_owned()]);
view.bulk_text = "2".to_owned();
run(&ctx, &mut view, &data, vec![]);
let shown = run(&ctx, &mut view, &data, vec![]);
assert!(has(&shown, "2 events selected"), "the count shows before anything is applied");
assert!(shown.response.commands.is_empty());
let applied = click(&ctx, &mut view, &data, centre_of(&shown, "Apply to 2"));
assert_eq!(applied.response.commands.len(), 1);
let (id, params) = &applied.response.commands[0];
assert_eq!(id, "calendar.bulk");
assert_eq!((params["action"].as_str(), params["days"].as_i64(), params["confirm"].as_bool()), (Some("move"), Some(2), Some(true)));
assert!(view.bulk.is_none(), "the bar closes after applying");
}
#[test]
fn the_filter_popover_filters_and_saves() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
view.filter_open = true;
run(&ctx, &mut view, &data, vec![]);
let shown = run(&ctx, &mut view, &data, vec![]);
assert!(has(&shown, "Calendars") && has(&shown, "Saved filters"));
click(&ctx, &mut view, &data, centre_of(&shown, "Work"));
assert_eq!(view.query.filter.calendars, ["Work"]);
view.save_name = "Mine".to_owned();
let after = run(&ctx, &mut view, &data, vec![]);
let saved = click(&ctx, &mut view, &data, centre_of(&after, "Save"));
let (id, params) = saved.response.commands.first().expect("a save command");
assert_eq!(id, "calendar.filter_save");
assert_eq!(params["name"], "Mine");
assert_eq!(params["query"]["filter"]["calendars"][0], "Work");
}
#[test]
fn the_review_panel_lists_the_week() {
let mut view = view(Mode::Month);
let items = sample();
let mut data = data_for(&view, items.clone());
data.review = Some(notescraft_calendar::week_review(&items, date("2026-10-19")));
let ctx = warm(&mut view, &data);
view.review = Some(date("2026-10-20"));
run(&ctx, &mut view, &data, vec![]);
let shown = run(&ctx, &mut view, &data, vec![]);
assert!(has(&shown, "Week of 2026-10-19") && has(&shown, "Standup"), "{:?}", shown.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
run(&ctx, &mut view, &data, vec![key(egui::Key::Escape)]);
assert!(view.review.is_none(), "Esc closes the panel");
}
#[test]
fn the_inbox_lists_due_missed_and_snoozed_alerts_with_actions() {
use notescraft_calendar::{Alert, Inbox};
let alert = |title: &str, key: &str| Alert {
key: key.to_owned(),
item_id: format!("Calendar/{title}.md"),
title: title.to_owned(),
start: "2026-10-20T09:30".parse().unwrap(),
minutes_before: 10,
fire_at: 0,
};
let mut view = view(Mode::Month);
let mut data = data_for(&view, sample());
data.inbox = Inbox {
due: vec![alert("Standup", "a|1|10")],
upcoming: vec![alert("Lunch", "b|2|10")],
snoozed: vec![(alert("Dentist", "c|3|10"), 600)],
missed: vec![alert("Review", "d|4|10")],
};
let ctx = warm(&mut view, &data);
let closed = run(&ctx, &mut view, &data, vec![]);
assert!(has(&closed, "Reminders (2)"), "the button counts what needs attention: {:?}", closed.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
view.inbox_open = true;
run(&ctx, &mut view, &data, vec![]);
let shown = run(&ctx, &mut view, &data, vec![]);
for needle in ["Due now", "Missed", "Snoozed", "Upcoming", "back at 10:00", "Snooze 5 min", "Dismiss"] {
assert!(has(&shown, needle), "{needle}");
}
let snoozed = click(&ctx, &mut view, &data, centre_of(&shown, "Snooze 5 min"));
let (id, params) = snoozed.response.commands.first().expect("a snooze command");
assert_eq!((id.as_str(), params["minutes"].as_i64()), ("calendar.reminder_snooze", Some(5)));
assert!(params["key"].as_str().is_some_and(|key| key.ends_with("|10")));
run(&ctx, &mut view, &data, vec![key(egui::Key::Escape)]);
assert!(!view.inbox_open, "Esc closes the inbox");
}
#[test]
fn offline_feeds_are_flagged_and_imported_events_are_read_only() {
let mut view = view(Mode::Month);
let mut imported = item("feed:team:a@x", "Board meeting", "2026-10-20T09:30", None);
imported.source = Some("team".to_owned());
let mut data = data_for(&view, vec![imported]);
data.feed_errors = vec!["Team".to_owned()];
let ctx = warm(&mut view, &data);
let frame = run(&ctx, &mut view, &data, vec![]);
assert!(has(&frame, "Offline: showing saved events of Team"));
assert!(has(&frame, "Board meeting"), "cached events still show");
let clicked = click(&ctx, &mut view, &data, centre_of(&frame, "Board meeting"));
assert_eq!(clicked.response.open, None, "an imported event has no file to open");
}
#[test]
fn shift_click_selects_a_range_of_days_for_the_bulk_bar() {
let mut view = view(Mode::Month);
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
let shown = run(&ctx, &mut view, &data, vec![]);
let (first, _) = shown.texts.iter().find(|(_, t)| t == "22").expect("the 22nd").clone();
let target = first + Vec2::new(40.0, 40.0);
let shift = egui::Modifiers::SHIFT;
let press = |pressed| Event::PointerButton { pos: target, button: PointerButton::Primary, pressed, modifiers: shift };
run_with(&ctx, &mut view, &data, vec![Event::PointerMoved(target)], shift);
run_with(&ctx, &mut view, &data, vec![press(true)], shift);
run_with(&ctx, &mut view, &data, vec![press(false)], shift);
assert_eq!(view.cursor, date("2026-10-22"));
assert_eq!(view.keys.range(view.cursor).map(|(from, to)| (from.day(), to.day())), Some((20, 22)), "the range runs from the day the cursor was on");
run(&ctx, &mut view, &data, vec![Event::Text("x".to_owned())]);
assert!(view.bulk.as_ref().is_some_and(|ids| ids.contains(&"Calendar/lunch.md".to_owned())), "x opens the bulk bar on the events in the range");
}
#[test]
fn twelve_hour_clocks_and_week_numbers_follow_the_settings() {
let mut view = view(Mode::Month);
view.time_24h = false;
view.week_numbers = true;
let data = data_for(&view, sample());
let ctx = warm(&mut view, &data);
let month = run(&ctx, &mut view, &data, vec![]);
assert!(has(&month, "9:30 AM Standup") && has(&month, "12:00 PM Lunch"), "{:?}", month.texts.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>());
assert!(month.texts.iter().any(|(_, text)| text == "43"), "ISO week 43 holds 19 to 25 October");
view.mode = Mode::Week;
let data = data_for(&view, sample());
run(&ctx, &mut view, &data, vec![]);
let week = run(&ctx, &mut view, &data, vec![]);
assert!(has(&week, "1:00 PM"), "the hour labels follow the clock style");
view.time_24h = true;
view.week_numbers = false;
view.mode = Mode::Month;
let data = data_for(&view, sample());
run(&ctx, &mut view, &data, vec![]);
let plain = run(&ctx, &mut view, &data, vec![]);
assert!(has(&plain, "09:30 Standup") && !plain.texts.iter().any(|(_, text)| text == "43"));
}