use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, Default)]
pub struct Config {
pub flags: BTreeMap<String, FlagValue>,
pub unicode: bool,
}
#[derive(Debug, Clone)]
pub enum FlagValue {
Bool(bool),
Raw(String),
}
pub const FLAG_KEYS: &[&str] = &[
"parse_tags",
"parse_categories",
"parse_references",
"parse_file_references",
"parse_resources",
"parse_todos",
"parse_urls",
"parse_bookmarks",
"parse_hashtags_as_tags",
"emit_loc",
];
const ENV_MAP: &[(&str, &str)] = &[
("JOTS_PARSE_TAGS", "parse_tags"),
("JOTS_PARSE_CATEGORIES", "parse_categories"),
("JOTS_PARSE_REFERENCES", "parse_references"),
("JOTS_PARSE_FILE_REFERENCES", "parse_file_references"),
("JOTS_PARSE_RESOURCES", "parse_resources"),
("JOTS_PARSE_TODOS", "parse_todos"),
("JOTS_PARSE_URLS", "parse_urls"),
("JOTS_PARSE_BOOKMARKS", "parse_bookmarks"),
("JOTS_PARSE_HASHTAGS_AS_TAGS", "parse_hashtags_as_tags"),
("JOTS_EMIT_LOC", "emit_loc"),
("JOTS_CATEGORY_ROOT", "category_root"),
];
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CategoryRoot {
Unset,
Root(String),
Invalid(String),
}
impl Config {
pub fn new() -> Self {
Self::default()
}
pub fn set(&mut self, key: &str, value: FlagValue) {
self.flags.insert(key.to_string(), value);
}
pub fn set_bool(&mut self, key: &str, value: bool) {
self.flags.insert(key.to_string(), FlagValue::Bool(value));
}
pub fn category_root(&self) -> CategoryRoot {
let Some(v) = self.flags.get("category_root") else {
return CategoryRoot::Unset;
};
let s = match v {
FlagValue::Raw(s) => s.as_str(),
FlagValue::Bool(b) => return CategoryRoot::Invalid(b.to_string()),
};
if s.is_empty() {
return CategoryRoot::Unset;
}
let g = crate::grammar::grammar(self.unicode);
if g.word_full.is_match(s).unwrap_or(false) {
CategoryRoot::Root(s.to_lowercase())
} else {
CategoryRoot::Invalid(s.to_string())
}
}
pub fn enabled(&self, key: &str, default: bool) -> bool {
let Some(v) = self.flags.get(key) else {
return default;
};
match v {
FlagValue::Bool(b) => *b,
FlagValue::Raw(s) => {
let lower = s.to_ascii_lowercase();
match lower.as_str() {
"true" | "1" => true,
"false" | "0" | "" => false,
_ => true,
}
}
}
}
}
pub fn load() -> Config {
let mut cfg = Config::new();
if let Some(home) = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")) {
let path = Path::new(&home).join(".jot.toml");
merge_toml(&mut cfg, &path);
}
let cwd = std::env::current_dir().ok();
if let Some(cwd) = cwd {
let mut chain: Vec<PathBuf> = Vec::new();
let mut cur = Some(cwd.as_path());
while let Some(d) = cur {
chain.push(d.to_path_buf());
cur = d.parent();
}
for d in chain.iter().rev() {
merge_toml(&mut cfg, &d.join(".jot.toml"));
}
}
for (env_key, cfg_key) in ENV_MAP {
if let Ok(val) = std::env::var(env_key) {
cfg.set(cfg_key, FlagValue::Raw(val));
}
}
cfg
}
fn merge_toml(cfg: &mut Config, path: &Path) {
let Ok(text) = std::fs::read_to_string(path) else {
return;
};
let Ok(parsed) = text.parse::<toml::Value>() else {
return;
};
let toml::Value::Table(table) = parsed else {
return;
};
for (k, v) in table {
let val = match v {
toml::Value::Boolean(b) => FlagValue::Bool(b),
toml::Value::String(s) => FlagValue::Raw(s),
toml::Value::Integer(i) => FlagValue::Raw(i.to_string()),
other => FlagValue::Raw(other.to_string()),
};
cfg.flags.insert(k, val);
}
}
pub fn is_valid_flag_value(v: &FlagValue) -> bool {
match v {
FlagValue::Bool(_) => true,
FlagValue::Raw(s) => {
let lower = s.to_ascii_lowercase();
matches!(lower.as_str(), "true" | "false" | "1" | "0" | "")
}
}
}