use crate::atomic;
use crate::error::{Error, Result};
use crate::port::{Addr, Item, Repr};
use serde_json::{Map, Value};
use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};
const VERSION: u64 = 1;
#[derive(Debug, Clone)]
pub struct Store {
path: PathBuf,
targets: BTreeMap<String, BTreeMap<String, String>>,
}
impl Store {
pub fn default_path() -> PathBuf {
let base = std::env::var_os("XDG_STATE_HOME")
.map(PathBuf::from)
.or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".local/state")))
.unwrap_or_else(|| PathBuf::from(".local/state"));
base.join("cfggraft").join("priors.json")
}
pub fn open(path: impl Into<PathBuf>) -> Self {
let path = path.into();
let targets = fs::read_to_string(&path)
.ok()
.and_then(|t| serde_json::from_str::<Value>(&t).ok())
.map(|v| parse(&v))
.unwrap_or_default();
Store { path, targets }
}
pub fn empty(path: impl Into<PathBuf>) -> Self {
Store {
path: path.into(),
targets: BTreeMap::new(),
}
}
pub fn path(&self) -> &Path {
&self.path
}
pub fn items(&self, target: &Path) -> Vec<Item> {
let Some(map) = self.targets.get(&key(target)) else {
return Vec::new();
};
map.iter()
.map(|(a, r)| Item::new(Addr::new(a.clone()), Repr::new(r.clone())))
.collect()
}
pub fn set(&mut self, target: &Path, items: &[Item]) {
let key = key(target);
if items.is_empty() {
self.targets.remove(&key);
return;
}
let map = items
.iter()
.map(|i| (i.addr.as_str().to_string(), i.repr.as_str().to_string()))
.collect();
self.targets.insert(key, map);
}
pub fn save(&self) -> Result<()> {
let mut targets = Map::new();
for (target, items) in &self.targets {
let mut m = Map::new();
for (addr, repr) in items {
m.insert(addr.clone(), Value::String(repr.clone()));
}
targets.insert(target.clone(), Value::Object(m));
}
let mut root = Map::new();
root.insert("version".into(), Value::from(VERSION));
root.insert("targets".into(), Value::Object(targets));
let mut text = serde_json::to_string_pretty(&Value::Object(root))
.map_err(|e| Error::parse(&self.path, e))?;
text.push('\n');
atomic::write(&self.path, &text)
}
}
fn key(target: &Path) -> String {
std::fs::canonicalize(target)
.or_else(|_| {
std::env::current_dir().map(|cwd| cwd.join(target))
})
.unwrap_or_else(|_| target.to_path_buf())
.to_string_lossy()
.into_owned()
}
fn parse(v: &Value) -> BTreeMap<String, BTreeMap<String, String>> {
let Some(targets) = v.get("targets").and_then(Value::as_object) else {
return BTreeMap::new();
};
targets
.iter()
.filter_map(|(target, items)| {
let items = items.as_object()?;
let map = items
.iter()
.filter_map(|(a, r)| Some((a.clone(), r.as_str()?.to_string())))
.collect();
Some((target.clone(), map))
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use std::env;
fn scratch(name: &str) -> PathBuf {
let dir = env::temp_dir().join(format!("cfggraft-prior-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
dir.join(name)
}
fn item(addr: &str, repr: &str) -> Item {
Item::new(Addr::new(addr), Repr::new(repr))
}
#[test]
fn round_trips_through_the_file() {
let p = scratch("round-trip.json");
let target = Path::new("/some/target.json");
let mut s = Store::empty(&p);
s.set(target, &[item("env.A", "\"1\""), item("env.B", "\"2\"")]);
s.save().unwrap();
let reopened = Store::open(&p);
let mut got = reopened.items(target);
got.sort_by(|a, b| a.addr.cmp(&b.addr));
assert_eq!(got, vec![item("env.A", "\"1\""), item("env.B", "\"2\"")]);
let _ = fs::remove_file(&p);
}
#[test]
fn an_unknown_target_has_nothing_recorded() {
let s = Store::empty(scratch("unused.json"));
assert!(s.items(Path::new("/never/written.json")).is_empty());
}
#[test]
fn a_missing_file_opens_empty_rather_than_failing() {
let s = Store::open(scratch("does-not-exist.json"));
assert!(s.items(Path::new("/x")).is_empty());
}
#[test]
fn malformed_content_degrades_to_empty() {
let p = scratch("malformed.json");
fs::write(&p, "{ not json").unwrap();
let s = Store::open(&p);
assert!(s.items(Path::new("/x")).is_empty());
let _ = fs::remove_file(&p);
}
#[test]
fn clearing_a_target_drops_its_row() {
let p = scratch("cleared.json");
let target = Path::new("/some/target.json");
let mut s = Store::empty(&p);
s.set(target, &[item("a", "1")]);
s.set(target, &[]);
s.save().unwrap();
let text = fs::read_to_string(&p).unwrap();
assert!(!text.contains("/some/target.json"), "got: {text}");
let _ = fs::remove_file(&p);
}
#[test]
fn the_file_is_written_in_sorted_order() {
let p = scratch("sorted.json");
let mut s = Store::empty(&p);
s.set(Path::new("/t.json"), &[item("z", "1"), item("a", "2")]);
s.save().unwrap();
let text = fs::read_to_string(&p).unwrap();
assert!(
text.find("\"a\"").unwrap() < text.find("\"z\"").unwrap(),
"addresses should be sorted: {text}"
);
let _ = fs::remove_file(&p);
}
#[test]
fn default_path_sits_under_the_state_directory() {
let p = Store::default_path();
assert!(p.ends_with("cfggraft/priors.json"), "got: {}", p.display());
}
}