use knotra_ui::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 dark_theme: bool,
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,
}
impl Default for AppConfig {
fn default() -> Self {
AppConfig {
locale: Locale::En,
dark_theme: true,
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,
}
}
}
#[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"),
}
}
}
pub fn load_config(paths: &AppPaths) -> (AppConfig, Option<String>) {
match std::fs::read_to_string(&paths.config_file) {
Ok(text) => match toml::from_str::<AppConfig>(&text) {
Ok(cfg) => (cfg, None),
Err(e) => {
let msg = format!(
"config.toml parse error (using defaults): {e}\nPath: {}",
paths.config_file.display()
);
(AppConfig::default(), Some(msg))
}
},
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.dark_theme, AppConfig::default().dark_theme);
}
#[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.dark_theme, AppConfig::default().dark_theme);
}
}