Files
Marcos Paulo 5e8020aa38
ci / ci (macos-latest) (push) Has been cancelled
ci / ci (ubuntu-latest) (push) Has been cancelled
ci / ci (windows-latest) (push) Has been cancelled
feat: Obsidian basics, editor previews, graph rework, query blocks, stacked tabs, pop-out windows
Editor previews (colour swatches, arrows, embeds), the 18 obsidian-basics tasks (find and replace
with regex, back/forward, auto-pair, footnotes, folding, search operators, split view, PDF/audio/
video embeds, spelling, drag and drop, pinned tabs, settings) and round 2: ```query blocks, stacked
tabs, pop-out windows, tasks ticked inside embeds, text around an embed, embeds that follow edits,
block menu shortcut. New crates: notescraft-regex (linear-time engine) and notescraft-syntax.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-19 11:21:19 -03:00

343 lines
15 KiB
Rust

//! Shell integration over real temporary vaults and isolated settings.
use egui::{Context, RawInput};
use notescraft_engine::Session;
use notescraft_ui_egui::{
app::NotesApp,
center::ViewMode,
tabs::{GRAPH_PATH, SETTINGS_PATH},
};
use serde_json::json;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};
static NEXT: AtomicU64 = AtomicU64::new(0);
fn app() -> (PathBuf, NotesApp) {
let root = std::env::temp_dir().join(format!("notescraft-wiring-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
std::fs::create_dir_all(&root).expect("root");
for (path, text) in [
("note.md", "# Note\n```mermaid\nflowchart LR\nA-->B\n```\n"),
("board.canvas", r#"{"nodes":[],"edges":[],"vendor":{"keep":true}}"#),
("broken.canvas", "{ broken bytes"),
("draw.excalidraw", r#"{"type":"excalidraw","version":2,"source":"test","elements":[],"appState":{},"files":{},"vendor":42}"#),
("draw.draw", r#"{"type":"excalidraw","version":2,"source":"notescraft","elements":[],"appState":{},"files":{},"vendor":42}"#),
("flow.mmd", "flowchart LR\nA-->B"),
] {
std::fs::write(root.join(path), text).expect("seed");
}
let mut session = Session::open(&root).expect("session");
session.use_settings_dir(root.join("config"));
(root, NotesApp::new(session, notescraft_themes::builtin("catppuccin-mocha").expect("theme")))
}
fn frames(app: &mut NotesApp, ctx: &Context) -> Vec<String> {
let mut labels = Vec::new();
for _ in 0..4 {
let mut out =
ctx.run_ui(RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0))), ..Default::default() }, |ui| {
app.ui(ui.ctx());
});
labels = out
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
egui::Shape::Text(text) => Some(text.galley.text().to_owned()),
_ => None,
})
.collect();
out.textures_delta.clear();
}
labels
}
#[test]
fn every_file_and_virtual_view_draws_and_corrupt_canvas_keeps_bytes() {
let (root, mut app) = app();
let ctx = Context::default();
for path in ["note.md", "board.canvas", "draw.excalidraw", "draw.draw", "flow.mmd", GRAPH_PATH, SETTINGS_PATH, "broken.canvas"] {
app.open_note(path);
let labels = frames(&mut app, &ctx);
assert!(!labels.is_empty(), "{path}");
if path == "broken.canvas" {
assert!(labels.iter().any(|label| label == "Open as text"), "{labels:?}");
}
}
app.save_active();
assert_eq!(std::fs::read_to_string(root.join("broken.canvas")).expect("file"), "{ broken bytes");
assert!(app.session.buffer(GRAPH_PATH).is_none());
assert!(app.session.buffer(SETTINGS_PATH).is_none());
}
#[test]
fn settings_command_changes_tokens_and_ui_state_roundtrips() {
let (root, mut app) = app();
app.open_note("note.md");
app.open_note(GRAPH_PATH);
app.run_command("settings.set", &json!({"key":"session.theme","value":"catppuccin-latte"}));
app.run_command("settings.set", &json!({"key":"ui.sound","value":false}));
assert_eq!(app.tokens.theme.id, "catppuccin-latte");
assert!(!app.state.sound);
app.persist_ui();
let (saved, _) = notescraft_engine::load_at(&root.join("config"));
assert_eq!(saved.ui.get("sound"), Some(&json!(false)));
assert_eq!(saved.ui.get("tabs"), Some(&json!(["note.md", GRAPH_PATH])));
let mut session = Session::open_read_only(&root).expect("session");
session.use_settings_dir(root.join("config"));
let restored = NotesApp::new(session, notescraft_themes::builtin("catppuccin-mocha").expect("theme"));
assert_eq!(restored.tabs.open, app.tabs.open);
assert_eq!(restored.tokens.theme.id, "catppuccin-latte");
}
#[test]
fn graphical_documents_save_source_edits_preserving_unknown_fields() {
let (_root, mut app) = app();
let ctx = Context::default();
for path in ["board.canvas", "draw.excalidraw", "draw.draw"] {
app.open_note(path);
app.editing.set_view(path, ViewMode::Markdown);
frames(&mut app, &ctx);
let text = app.editing.editor_of(path).expect("editor").editor.text.clone();
let mut value: serde_json::Value = serde_json::from_str(&text).expect("json");
value.as_object_mut().expect("object").insert("edited".into(), json!(true));
let next = serde_json::to_string(&value).expect("json");
app.session.buffer_mut(path).expect("buffer").edit(0..text.len(), &next).expect("edit");
app.editing.editor_of(path).expect("editor").editor.text = next;
app.save_active();
let saved: serde_json::Value = serde_json::from_str(&app.session.read_file(path).expect("file")).expect("json");
assert_eq!(saved.get("vendor"), value.get("vendor"));
assert_eq!(saved.get("edited"), Some(&json!(true)));
}
}
#[test]
fn invalid_ui_preference_is_refused_before_persistence() {
let (root, mut app) = app();
app.persist_ui();
let before = std::fs::read(root.join("config/config.toml")).expect("config");
app.run_command("settings.set", &json!({"key":"ui.ui_scale","value":99.0}));
assert_eq!(std::fs::read(root.join("config/config.toml")).expect("config"), before);
assert_eq!(app.state.ui_scale, 1.0);
assert!(app.toast.is_some());
}
#[test]
fn selected_source_diff_still_uses_center_card() {
let (_root, mut app) = app();
app.open_note("note.md");
app.source.diff = Some(notescraft_ui_egui::diff_view::DiffSelection {
path: String::from("note.md"),
revision: None,
staged: false,
review: false,
diff: notescraft_ui_egui::diff_view::compare("before diff", "after diff").expect("diff"),
});
let labels = frames(&mut app, &Context::default());
assert!(labels.iter().any(|label| label.contains("before diff")), "{labels:?}");
}
fn frame(app: &mut NotesApp, ctx: &Context, time: f64, events: Vec<egui::Event>) -> Vec<egui::epaint::ClippedShape> {
let mut out = ctx.run_ui(
RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0))), time: Some(time), events, ..Default::default() },
|ui| app.ui(ui.ctx()),
);
out.textures_delta.clear();
out.shapes
}
fn pointer(position: egui::Pos2, pressed: bool) -> Vec<egui::Event> {
vec![
egui::Event::PointerMoved(position),
egui::Event::PointerButton { pos: position, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE },
]
}
fn key(key: egui::Key, modifiers: egui::Modifiers) -> egui::Event {
egui::Event::Key { key, modifiers, pressed: true, repeat: false, physical_key: None }
}
#[test]
fn canvas_gesture_recovery_and_autosave_preserve_unknown_json() {
let (_root, mut app) = app();
app.state.animations = false;
app.open_note("board.canvas");
let ctx = Context::default();
frames(&mut app, &ctx);
let position = egui::pos2(700.0, 400.0);
for (time, pressed) in [(1.0, true), (1.05, false), (1.1, true), (1.15, false)] {
frame(&mut app, &ctx, time, pointer(position, pressed));
}
assert!(app.session.buffer("board.canvas").expect("buffer").is_dirty());
frame(&mut app, &ctx, 2.2, Vec::new());
assert!(app.session.vault().read(&notescraft_ui_egui::recovery::recovery_rel("board.canvas")).is_ok());
assert_eq!(notescraft_canvas::Canvas::from_str(&app.session.read_file("board.canvas").expect("file")).expect("canvas").nodes.len(), 0);
frame(&mut app, &ctx, 3.2, Vec::new());
let saved = notescraft_canvas::Canvas::from_str(&app.session.read_file("board.canvas").expect("file")).expect("canvas");
assert_eq!(saved.nodes.len(), 1);
assert_eq!(saved.extra.get("vendor"), Some(&json!({"keep":true})));
assert!(!app.has_dirty_buffers());
}
#[test]
fn whiteboard_gesture_and_save_shortcut_preserve_unknown_json() {
let (_root, mut app) = app();
app.state.animations = false;
app.open_note("draw.excalidraw");
let ctx = Context::default();
frames(&mut app, &ctx);
frame(&mut app, &ctx, 1.0, vec![key(egui::Key::R, egui::Modifiers::NONE)]);
frame(&mut app, &ctx, 1.1, pointer(egui::pos2(650.0, 400.0), true));
frame(&mut app, &ctx, 1.2, vec![egui::Event::PointerMoved(egui::pos2(730.0, 460.0))]);
frame(&mut app, &ctx, 1.3, pointer(egui::pos2(730.0, 460.0), false));
assert!(app.has_dirty_buffers());
frame(&mut app, &ctx, 1.4, vec![key(egui::Key::S, egui::Modifiers::COMMAND)]);
let saved = notescraft_whiteboard::Whiteboard::from_str(&app.session.read_file("draw.excalidraw").expect("file")).expect("board");
assert_eq!(saved.elements.len(), 1);
let value: serde_json::Value = serde_json::from_str(&saved.to_string_pretty().expect("json")).expect("json");
assert_eq!(value.get("vendor"), Some(&json!(42)));
assert!(!app.has_dirty_buffers());
}
#[test]
fn whiteboard_controls_stay_inside_center_card() {
let (_root, mut app) = app();
app.open_note("draw.excalidraw");
let ctx = Context::default();
frames(&mut app, &ctx);
// Contextual properties appear only for a drawing tool or selection.
frame(&mut app, &ctx, 0.95, vec![key(egui::Key::R, egui::Modifiers::NONE)]);
let shapes = frame(&mut app, &ctx, 1.0, Vec::new());
let editor = notescraft_ui_egui::layout::compute_rects(ctx.viewport_rect(), notescraft_ui_egui::layout::CardVisibility { sidebar: true, right: true })
.editor
.expect("card");
let styles: Vec<_> = shapes
.iter()
.filter_map(|shape| match &shape.shape {
egui::Shape::Text(text) if text.galley.text().eq_ignore_ascii_case("Stroke") => Some(text.pos),
_ => None,
})
.collect();
assert_ne!(styles.len(), 0);
assert!(styles.iter().all(|position| editor.contains(*position)), "{styles:?}, {editor:?}");
}
#[test]
fn settings_swatch_dispatches_engine_change_and_reapplies_style() {
let (root, mut app) = app();
app.state.animations = false;
app.open_note(SETTINGS_PATH);
let ctx = Context::default();
frames(&mut app, &ctx);
let shapes = frame(&mut app, &ctx, 1.0, Vec::new());
let position = shapes
.iter()
.find_map(|shape| match &shape.shape {
egui::Shape::Text(text) if text.galley.text() == "Catppuccin Latte" => Some(text.pos + egui::vec2(10.0, -12.0)),
_ => None,
})
.expect("swatch");
frame(&mut app, &ctx, 1.1, pointer(position, true));
frame(&mut app, &ctx, 1.2, pointer(position, false));
assert_eq!(app.tokens.theme.id, "catppuccin-latte");
assert!(!ctx.global_style().visuals.dark_mode);
assert_eq!(ctx.global_style().visuals.panel_fill, notescraft_ui_egui::theme::color(app.tokens.theme.colors.surface));
assert_eq!(notescraft_engine::load_at(&root.join("config")).0.session.theme, "catppuccin-latte");
}
#[test]
fn graph_node_double_click_opens_file_tab() {
let (_root, mut app) = app();
app.state.animations = false;
app.open_note(GRAPH_PATH);
let ctx = Context::default();
// The camera follows the layout until it settles; click once it has.
for _ in 0..30 {
frames(&mut app, &ctx);
}
let shapes = frame(&mut app, &ctx, 1.0, Vec::new());
let tint = notescraft_ui_egui::theme::color(app.tokens.theme.graph.node);
let label = shapes
.iter()
.find_map(|shape| match &shape.shape {
egui::Shape::Text(text) if text.galley.text() == "note" && text.pos.x > 276.0 => Some(text.pos + egui::vec2(0.0, text.galley.size().y / 2.0)),
_ => None,
})
.expect("note label");
let position = shapes
.iter()
.find_map(|shape| match &shape.shape {
egui::Shape::Circle(circle) if circle.fill == tint && (circle.center.y - label.y).abs() < 1.0 && circle.center.x < label.x => Some(circle.center),
_ => None,
})
.expect("graph node");
for (time, pressed) in [(1.1, true), (1.15, false), (1.2, true), (1.25, false)] {
frame(&mut app, &ctx, time, pointer(position, pressed));
}
assert_eq!(app.tabs.active_path(), Some("note.md"));
assert!(app.session.buffer(app.tabs.active_path().expect("tab")).is_some());
}
#[test]
fn startup_reports_settings_repairs() {
let (root, app) = app();
drop(app);
std::fs::create_dir_all(root.join("config")).expect("config");
std::fs::write(root.join("config/config.toml"), "broken = [invalid").expect("broken settings");
let mut session = Session::open(&root).expect("session");
session.use_settings_dir(root.join("config"));
let restored = NotesApp::new(session, notescraft_themes::builtin("catppuccin-mocha").expect("theme"));
assert!(restored.toast.is_some(), "damaged settings must produce a repair toast");
}
#[test]
fn ui_state_saves_after_one_second_idle() {
let (root, mut app) = app();
let ctx = Context::default();
frames(&mut app, &ctx);
app.state.sidebar_width = 280.0;
frame(&mut app, &ctx, 1.0, Vec::new());
frame(&mut app, &ctx, 1.9, Vec::new());
assert!(!root.join("config/config.toml").exists());
frame(&mut app, &ctx, 2.1, Vec::new());
assert_eq!(notescraft_engine::load_at(&root.join("config")).0.ui.get("sidebar_width"), Some(&json!(280.0)));
}
#[test]
fn create_commands_pick_unique_names_in_active_folder() {
let (root, mut app) = app();
app.session.create_note("folder/active.md", "note").expect("note");
app.open_note("folder/active.md");
for (id, path) in [
("ui.new_canvas", "folder/Untitled.canvas"),
("ui.new_canvas", "folder/Untitled 1.canvas"),
("ui.new_whiteboard", "folder/Untitled.draw"),
("ui.new_whiteboard", "folder/Untitled 1.draw"),
("ui.new_note", "folder/Untitled.md"),
] {
app.run_command(id, &serde_json::Value::Null);
assert_eq!(app.tabs.active_path(), Some(path));
assert!(root.join(path).is_file());
assert_eq!(app.tabs.active_kind(), Some(notescraft_ui_egui::tabs::TabKind::of(path)));
}
}
#[test]
fn whiteboard_export_writes_svg_next_to_draw_and_refuses_overwrite() {
let (root, mut app) = app();
let svg = notescraft_ui_egui::whiteboard_view::export_svg(
&notescraft_whiteboard::Whiteboard::from_str(&app.session.read_file("draw.draw").expect("file")).expect("board"),
);
let out = root.join("draw.svg");
app.run_command("file.export_whiteboard_svg", &json!({ "out": "draw.svg", "svg": svg.clone() }));
assert!(out.is_file(), "the .svg should sit beside the .draw");
let saved = std::fs::read_to_string(&out).expect("svg");
assert!(saved.starts_with("<svg"), "{saved}");
app.run_command("file.export_whiteboard_svg", &json!({ "out": "draw.svg", "svg": svg }));
assert!(app.toast.is_some(), "a refusal surfaces a toast");
assert_eq!(std::fs::read_to_string(&out).expect("svg"), saved, "the original SVG must not be clobbered");
}
#[test]
fn whiteboard_export_refuses_reserved_vault_paths() {
let (_root, mut app) = app();
let svg = notescraft_ui_egui::whiteboard_view::export_svg(&notescraft_whiteboard::Whiteboard::default());
app.run_command("file.export_whiteboard_svg", &json!({ "out": ".obsidian/draw.svg", "svg": svg.clone() }));
assert!(app.toast.is_some(), ".obsidian/ must be refused");
app.toast = None;
app.run_command("file.export_whiteboard_svg", &json!({ "out": ".notescraft/draw.svg", "svg": svg }));
assert!(app.toast.is_some(), ".notescraft/ must be refused");
}