use knotra_ui::{ThemeChoice, i18n::Locale};
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum DashboardGrouping {
#[default]
Attention,
ProjectGroup,
None,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum DashboardSort {
#[default]
Recommended,
NameAscending,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct AppConfig {
pub locale: Locale,
pub theme: ThemeChoice,
pub refresh_interval_secs: u32,
pub max_concurrent_reads: usize,
pub external_editor: Option<String>,
pub external_merge_tool: Option<String>,
pub max_log_entries: usize,
pub fs_watch_enabled: bool,
pub fs_debounce_secs: u32,
pub dashboard_grouping: DashboardGrouping,
pub dashboard_sort: DashboardSort,
pub dashboard_in_progress_collapsed: bool,
pub dashboard_all_set_collapsed: bool,
pub last_project_parent: Option<PathBuf>,
pub zoom_percent: u16,
}
pub const ZOOM_STEPS: [u16; 4] = [100, 115, 130, 150];
fn nearest_zoom_step(value: u16) -> u16 {
let mut best = ZOOM_STEPS[0];
let mut best_diff = (i32::from(best) - i32::from(value)).abs();
for &step in &ZOOM_STEPS[1..] {
let diff = (i32::from(step) - i32::from(value)).abs();
if diff < best_diff {
best = step;
best_diff = diff;
}
}
best
}
#[must_use]
pub fn zoom_step_up(current: u16) -> u16 {
let idx = ZOOM_STEPS
.iter()
.position(|&s| s == current)
.expect("zoom_percent is always one of ZOOM_STEPS once loaded");
ZOOM_STEPS[(idx + 1).min(ZOOM_STEPS.len() - 1)]
}
#[must_use]
pub fn zoom_step_down(current: u16) -> u16 {
let idx = ZOOM_STEPS
.iter()
.position(|&s| s == current)
.expect("zoom_percent is always one of ZOOM_STEPS once loaded");
ZOOM_STEPS[idx.saturating_sub(1)]
}
pub const REFRESH_AUTO_STEPS: [u32; 5] = [0, 30, 60, 300, 900];
pub const SIMULTANEOUS_READS_STEPS: [usize; 4] = [2, 4, 8, 16];
pub const LOG_SIZE_STEPS: [usize; 4] = [100, 200, 500, 1000];
pub const FS_DEBOUNCE_STEPS: [u32; 3] = [1, 2, 5];
fn nearest_step_u32(steps: &[u32], value: u32) -> u32 {
let mut best = steps[0];
let mut best_diff = best.abs_diff(value);
for &step in &steps[1..] {
let diff = step.abs_diff(value);
if diff < best_diff {
best = step;
best_diff = diff;
}
}
best
}
fn nearest_step_usize(steps: &[usize], value: usize) -> usize {
let mut best = steps[0];
let mut best_diff = best.abs_diff(value);
for &step in &steps[1..] {
let diff = step.abs_diff(value);
if diff < best_diff {
best = step;
best_diff = diff;
}
}
best
}
impl Default for AppConfig {
fn default() -> Self {
AppConfig {
locale: Locale::En,
theme: ThemeChoice::default(),
refresh_interval_secs: 60,
max_concurrent_reads: 8,
external_editor: None,
external_merge_tool: None,
max_log_entries: 200,
fs_watch_enabled: false,
fs_debounce_secs: 2,
dashboard_grouping: DashboardGrouping::default(),
dashboard_sort: DashboardSort::default(),
dashboard_in_progress_collapsed: false,
dashboard_all_set_collapsed: true,
last_project_parent: None,
zoom_percent: 100,
}
}
}
#[derive(Debug, Clone)]
pub struct AppPaths {
pub config_file: PathBuf,
pub workspaces_dir: PathBuf,
pub history_dir: PathBuf,
}
impl AppPaths {
pub fn resolve() -> (Self, Option<String>) {
Self::resolve_from(dirs::config_dir(), dirs::data_local_dir())
}
fn resolve_from(
config_root: Option<PathBuf>,
data_root: Option<PathBuf>,
) -> (Self, Option<String>) {
let mut warnings = Vec::new();
let config_root = config_root.unwrap_or_else(|| {
let fallback = PathBuf::from(".");
warnings.push(format!(
"Could not determine the OS config directory; using \"{}\" \
(the current directory) instead. Settings will be written \
to a different place depending on where knotra is launched \
from.",
fallback.display()
));
fallback
});
let config_base = config_root.join("knotra");
let data_root = data_root.unwrap_or_else(|| {
let fallback = PathBuf::from(".");
warnings.push(format!(
"Could not determine the OS data directory; using \"{}\" \
(the current directory) instead for operation history.",
fallback.display()
));
fallback
});
let data_base = data_root.join("knotra");
let paths = AppPaths {
config_file: config_base.join("config.toml"),
workspaces_dir: config_base.join("workspaces"),
history_dir: data_base.join("history"),
};
let warning = (!warnings.is_empty()).then(|| warnings.join("\n"));
(paths, warning)
}
#[cfg(test)]
pub fn under(base: PathBuf) -> Self {
AppPaths {
config_file: base.join("config").join("config.toml"),
workspaces_dir: base.join("config").join("workspaces"),
history_dir: base.join("data").join("history"),
}
}
}
fn resolve_theme_key(
table: &mut toml::value::Table,
config_path: &std::path::Path,
) -> Option<String> {
let raw_theme = table.remove("theme");
let raw_dark_theme = table.remove("dark_theme").and_then(|v| v.as_bool());
let (resolved, warning) = match raw_theme {
Some(value) => {
let shown = value
.as_str()
.map(str::to_owned)
.unwrap_or_else(|| value.to_string());
match value.try_into::<ThemeChoice>() {
Ok(choice) => (choice, None),
Err(_) => (
ThemeChoice::default(),
Some(format!(
"Unknown theme {shown:?} in config.toml (using default); Path: {}",
config_path.display()
)),
),
}
}
None => (
match raw_dark_theme {
Some(true) => ThemeChoice::Dark,
Some(false) => ThemeChoice::Light,
None => ThemeChoice::default(),
},
None,
),
};
table.insert(
"theme".to_owned(),
toml::Value::try_from(resolved).expect("ThemeChoice always serializes to a TOML string"),
);
warning
}
pub fn load_config(paths: &AppPaths) -> (AppConfig, Option<String>) {
let parse_error = |e: &dyn std::fmt::Display| -> (AppConfig, Option<String>) {
let msg = format!(
"config.toml parse error (using defaults): {e}\nPath: {}",
paths.config_file.display()
);
(AppConfig::default(), Some(msg))
};
match std::fs::read_to_string(&paths.config_file) {
Ok(text) => match text.parse::<toml::value::Table>() {
Ok(mut table) => {
let theme_warning = resolve_theme_key(&mut table, &paths.config_file);
match table.try_into::<AppConfig>() {
Ok(mut cfg) => {
cfg.zoom_percent = nearest_zoom_step(cfg.zoom_percent);
cfg.refresh_interval_secs = if cfg.refresh_interval_secs == 0 {
0
} else {
nearest_step_u32(&REFRESH_AUTO_STEPS[1..], cfg.refresh_interval_secs)
};
cfg.max_concurrent_reads =
nearest_step_usize(&SIMULTANEOUS_READS_STEPS, cfg.max_concurrent_reads);
cfg.max_log_entries =
nearest_step_usize(&LOG_SIZE_STEPS, cfg.max_log_entries);
cfg.fs_debounce_secs =
nearest_step_u32(&FS_DEBOUNCE_STEPS, cfg.fs_debounce_secs);
(cfg, theme_warning)
}
Err(e) => parse_error(&e),
}
}
Err(e) => parse_error(&e),
},
Err(e)
if e.kind() == std::io::ErrorKind::NotFound
&& paths
.config_file
.parent()
.is_none_or(crate::persistence::treat_missing_directory_as_absent) =>
{
(AppConfig::default(), None)
}
Err(e) => {
let msg = format!(
"Cannot read config file (using defaults): {e}\nPath: {}",
paths.config_file.display()
);
(AppConfig::default(), Some(msg))
}
}
}
pub fn save_config(config: &AppConfig, paths: &AppPaths) -> Result<(), String> {
if let Some(parent) = paths.config_file.parent() {
std::fs::create_dir_all(parent).map_err(|e| format!("cannot create config dir: {e}"))?;
}
let text = toml::to_string_pretty(config).map_err(|e| format!("serialization error: {e}"))?;
crate::atomic_write::write(&paths.config_file, text)
.map_err(|e| format!("cannot write config.toml: {e}"))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolve_produces_no_warning_on_a_normal_machine() {
let (_paths, warning) = AppPaths::resolve();
assert_eq!(warning, None);
}
#[test]
fn resolve_from_both_present_produces_no_warning() {
let (_paths, warning) =
AppPaths::resolve_from(Some(PathBuf::from("/cfg")), Some(PathBuf::from("/data")));
assert_eq!(warning, None);
}
#[test]
fn resolve_from_missing_config_dir_names_the_config_directory() {
let (paths, warning) = AppPaths::resolve_from(None, Some(PathBuf::from("/data")));
let warning = warning.expect("a warning must be produced");
assert!(
warning.contains("config directory"),
"warning must name which directory failed: {warning:?}"
);
assert!(!warning.contains("data directory"), "{warning:?}");
assert_eq!(paths.config_file, PathBuf::from("./knotra/config.toml"));
}
#[test]
fn resolve_from_missing_data_dir_names_the_data_directory() {
let (paths, warning) = AppPaths::resolve_from(Some(PathBuf::from("/cfg")), None);
let warning = warning.expect("a warning must be produced");
assert!(
warning.contains("data directory"),
"warning must name which directory failed: {warning:?}"
);
assert!(!warning.contains("config directory"), "{warning:?}");
assert_eq!(paths.history_dir, PathBuf::from("./knotra/history"));
}
#[test]
fn resolve_from_both_missing_joins_both_messages_with_a_newline() {
let (_paths, warning) = AppPaths::resolve_from(None, None);
let warning = warning.expect("a warning must be produced");
let lines: Vec<&str> = warning.split('\n').collect();
assert_eq!(
lines.len(),
2,
"both messages must be present, joined by a single newline: {warning:?}"
);
assert!(lines[0].contains("config directory"), "{warning:?}");
assert!(lines[1].contains("data directory"), "{warning:?}");
}
#[test]
fn load_config_with_no_config_directory_uses_defaults_and_no_warning() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None);
assert_eq!(
loaded.refresh_interval_secs,
AppConfig::default().refresh_interval_secs
);
assert_eq!(loaded.theme, AppConfig::default().theme);
}
#[test]
fn load_config_with_no_settings_file_loads_as_light() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None);
assert_eq!(loaded.theme, ThemeChoice::Light);
}
#[test]
fn load_config_with_a_blocked_config_directory_reports_and_uses_defaults() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let blocked = tmp.path().join("config");
std::fs::write(&blocked, "not a directory").expect("blocking file");
let paths = AppPaths {
config_file: blocked.join("config.toml"),
workspaces_dir: blocked.join("workspaces"),
history_dir: tmp.path().join("data").join("history"),
};
let (loaded, warning) = load_config(&paths);
assert!(warning.is_some(), "a blocked directory must be reported");
assert_eq!(
loaded.refresh_interval_secs,
AppConfig::default().refresh_interval_secs
);
assert_eq!(loaded.theme, AppConfig::default().theme);
}
#[test]
fn load_config_without_last_project_parent_key_loads_it_as_none() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(&paths.config_file, "dark_theme = true\n").expect("older config.toml");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None);
assert_eq!(loaded.last_project_parent, None);
assert_eq!(loaded.theme, ThemeChoice::Dark);
}
#[test]
fn load_config_with_only_dark_theme_false_maps_to_light() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(&paths.config_file, "dark_theme = false\n").expect("older config.toml");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None);
assert_eq!(loaded.theme, ThemeChoice::Light);
}
#[test]
fn load_config_prefers_theme_over_a_present_dark_theme() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(
&paths.config_file,
"theme = \"high_contrast_light\"\ndark_theme = true\n",
)
.expect("mixed-key config.toml");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None);
assert_eq!(loaded.theme, ThemeChoice::HighContrastLight);
}
#[test]
fn load_config_with_an_unknown_theme_value_falls_back_with_a_warning() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(
&paths.config_file,
"theme = \"neon\"\nrefresh_interval_secs = 300\n",
)
.expect("config.toml with an unknown theme value");
let (loaded, warning) = load_config(&paths);
let warning = warning.expect("an unknown theme value must be reported");
assert!(warning.contains("neon"), "{warning:?}");
assert_eq!(loaded.theme, AppConfig::default().theme);
assert_eq!(loaded.refresh_interval_secs, 300);
}
#[test]
fn every_theme_choice_round_trips_through_save_and_load() {
for choice in [
ThemeChoice::Light,
ThemeChoice::Dark,
ThemeChoice::HighContrastLight,
ThemeChoice::HighContrastDark,
] {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let config = AppConfig {
theme: choice,
..AppConfig::default()
};
save_config(&config, &paths).expect("save_config");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{choice:?}: {warning:?}");
assert_eq!(loaded.theme, choice);
}
}
#[test]
fn save_config_writes_theme_only_not_dark_theme() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let config = AppConfig {
theme: ThemeChoice::Dark,
..AppConfig::default()
};
save_config(&config, &paths).expect("save_config");
let text = std::fs::read_to_string(&paths.config_file).expect("read saved config.toml");
assert!(text.contains("theme = \"dark\""), "{text:?}");
assert!(!text.contains("dark_theme"), "{text:?}");
}
#[test]
fn zoom_percent_defaults_to_100() {
assert_eq!(AppConfig::default().zoom_percent, 100);
}
#[test]
fn load_config_without_zoom_percent_key_loads_as_100() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(&paths.config_file, "theme = \"dark\"\n").expect("older config.toml");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None);
assert_eq!(loaded.zoom_percent, 100);
}
#[test]
fn load_config_with_an_unknown_zoom_percent_snaps_to_the_nearest_step() {
let cases: &[(u16, u16)] = &[
(0, 100),
(107, 100),
(108, 115),
(140, 130), (999, 150),
];
for &(saved, expected) in cases {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(&paths.config_file, format!("zoom_percent = {saved}\n"))
.expect("config.toml with an out-of-range zoom_percent");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "zoom_percent={saved}: {warning:?}");
assert_eq!(
loaded.zoom_percent, expected,
"zoom_percent={saved} should snap to {expected}"
);
}
}
#[test]
fn every_zoom_step_round_trips_through_save_and_load() {
for &step in &ZOOM_STEPS {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let config = AppConfig {
zoom_percent: step,
..AppConfig::default()
};
save_config(&config, &paths).expect("save_config");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{step}: {warning:?}");
assert_eq!(loaded.zoom_percent, step);
}
}
#[test]
fn zoom_step_up_steps_through_zoom_steps_and_saturates_at_the_top() {
assert_eq!(zoom_step_up(100), 115);
assert_eq!(zoom_step_up(115), 130);
assert_eq!(zoom_step_up(130), 150);
assert_eq!(zoom_step_up(150), 150);
}
#[test]
fn zoom_step_down_steps_through_zoom_steps_and_saturates_at_the_bottom() {
assert_eq!(zoom_step_down(150), 130);
assert_eq!(zoom_step_down(130), 115);
assert_eq!(zoom_step_down(115), 100);
assert_eq!(zoom_step_down(100), 100);
}
#[test]
fn load_config_snaps_every_stepped_setting_to_its_nearest_choice() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(
&paths.config_file,
"refresh_interval_secs = 180\nmax_concurrent_reads = 6\nmax_log_entries = 350\nfs_debounce_secs = 4\n",
)
.expect("config.toml with off-grid values");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{warning:?}");
assert_eq!(loaded.refresh_interval_secs, 60);
assert_eq!(loaded.max_concurrent_reads, 4);
assert_eq!(loaded.max_log_entries, 200);
assert_eq!(loaded.fs_debounce_secs, 5);
}
#[test]
fn a_non_zero_refresh_interval_never_snaps_to_off() {
let cases: [(u32, u32); 7] = [
(0, 0),
(1, 30),
(10, 30),
(15, 30),
(45, 30), (46, 60),
(2000, 900),
];
for (saved, expected) in cases {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
std::fs::create_dir_all(paths.config_file.parent().unwrap()).expect("config dir");
std::fs::write(
&paths.config_file,
format!("refresh_interval_secs = {saved}\n"),
)
.expect("write config.toml");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{saved}: {warning:?}");
assert_eq!(
loaded.refresh_interval_secs, expected,
"saved {saved} must load as {expected}"
);
}
}
#[test]
fn every_refresh_auto_step_round_trips_through_save_and_load() {
for &step in &REFRESH_AUTO_STEPS {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let config = AppConfig {
refresh_interval_secs: step,
..AppConfig::default()
};
save_config(&config, &paths).expect("save_config");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{step}: {warning:?}");
assert_eq!(loaded.refresh_interval_secs, step);
}
}
#[test]
fn every_simultaneous_reads_step_round_trips_through_save_and_load() {
for &step in &SIMULTANEOUS_READS_STEPS {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let config = AppConfig {
max_concurrent_reads: step,
..AppConfig::default()
};
save_config(&config, &paths).expect("save_config");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{step}: {warning:?}");
assert_eq!(loaded.max_concurrent_reads, step);
}
}
#[test]
fn every_log_size_step_round_trips_through_save_and_load() {
for &step in &LOG_SIZE_STEPS {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let config = AppConfig {
max_log_entries: step,
..AppConfig::default()
};
save_config(&config, &paths).expect("save_config");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{step}: {warning:?}");
assert_eq!(loaded.max_log_entries, step);
}
}
#[test]
fn every_fs_debounce_step_round_trips_through_save_and_load() {
for &step in &FS_DEBOUNCE_STEPS {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = AppPaths::under(tmp.path().to_path_buf());
let config = AppConfig {
fs_debounce_secs: step,
..AppConfig::default()
};
save_config(&config, &paths).expect("save_config");
let (loaded, warning) = load_config(&paths);
assert_eq!(warning, None, "{step}: {warning:?}");
assert_eq!(loaded.fs_debounce_secs, step);
}
}
}