use std::hash::{Hash, Hasher};
use std::path::{Path, PathBuf};
use rkyv::{Archive, Deserialize as RkyvDe, Serialize as RkyvSer};
use crate::ast::Command;
const SCHEMA: u64 = 3;
#[derive(Archive, RkyvSer, RkyvDe, Default)]
#[archive(check_bytes)]
struct Shard {
stamp: u64,
entries: Vec<Entry>,
}
#[derive(Archive, RkyvSer, RkyvDe)]
#[archive(check_bytes)]
struct Entry {
key: u64,
blob: Vec<u8>,
}
pub fn key_for(src: &str) -> u64 {
let mut h = rustc_hash::FxHasher::default();
SCHEMA.hash(&mut h);
env!("CARGO_PKG_VERSION").hash(&mut h);
src.hash(&mut h);
h.finish()
}
fn build_stamp() -> u64 {
static STAMP: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
*STAMP.get_or_init(|| {
let mut h = rustc_hash::FxHasher::default();
if let Ok(md) = std::env::current_exe().and_then(std::fs::metadata) {
md.len().hash(&mut h);
if let Ok(nanos) = md
.modified()
.and_then(|t| {
t.duration_since(std::time::UNIX_EPOCH)
.map_err(|e| std::io::Error::other(e.to_string()))
})
.map(|d| d.as_nanos())
{
nanos.hash(&mut h);
}
}
h.finish()
})
}
fn shard_path() -> Option<PathBuf> {
if let Some(p) = std::env::var_os("ARB_CACHE") {
let p = PathBuf::from(p);
if let Some(parent) = p.parent() {
let _ = std::fs::create_dir_all(parent);
}
return Some(p);
}
let dir = std::env::var_os("HOME").map(|h| Path::new(&h).join(".arb"))?;
let _ = std::fs::create_dir_all(&dir);
Some(dir.join("scripts.rkyv"))
}
fn load_shard() -> Shard {
let Some(path) = shard_path() else {
return Shard::default();
};
let Ok(bytes) = std::fs::read(&path) else {
return Shard::default();
};
let shard = rkyv::from_bytes::<Shard>(&bytes).unwrap_or_default();
if shard.stamp == build_stamp() {
shard
} else {
Shard::default()
}
}
fn write_shard(shard: &mut Shard) -> Result<(), String> {
shard.stamp = build_stamp();
let path = shard_path().ok_or("no home dir for cache")?;
let bytes = rkyv::to_bytes::<_, 4096>(shard).map_err(|e| format!("cache serialize: {e}"))?;
std::fs::write(&path, &bytes).map_err(|e| format!("cache write: {e}"))
}
fn encode(ast: &[Command]) -> Result<Vec<u8>, String> {
bincode::serialize(ast).map_err(|e| format!("cache encode: {e}"))
}
fn decode(blob: &[u8]) -> Option<Vec<Command>> {
bincode::deserialize(blob).ok()
}
fn shard_get(shard: &Shard, key: u64) -> Option<&[u8]> {
shard
.entries
.iter()
.find(|e| e.key == key)
.map(|e| e.blob.as_slice())
}
const MAX_ENTRIES: usize = 1024;
fn shard_put(shard: &mut Shard, key: u64, blob: Vec<u8>) {
shard.entries.retain(|e| e.key != key);
if shard.entries.len() >= MAX_ENTRIES {
let overflow = shard.entries.len() + 1 - MAX_ENTRIES;
shard.entries.drain(..overflow);
}
shard.entries.push(Entry { key, blob });
}
pub fn load(src: &str) -> Option<Vec<Command>> {
let shard = load_shard();
decode(shard_get(&shard, key_for(src))?)
}
pub fn store(src: &str, ast: &[Command]) -> Result<(), String> {
let blob = encode(ast)?;
let mut shard = load_shard();
shard_put(&mut shard, key_for(src), blob);
write_shard(&mut shard)
}
pub fn parse_cached(src: &str) -> Result<Vec<Command>, crate::err::SpecError> {
if let Some(ast) = load(src) {
return Ok(ast);
}
let ast = crate::parser::parse(src)?;
let _ = store(src, &ast);
Ok(ast)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::Arg;
static FS_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
#[test]
fn key_is_stable_and_schema_salted() {
assert_eq!(key_for("text .t <- in"), key_for("text .t <- in"));
assert_ne!(key_for("text .t <- in"), key_for("tail .t <- in"));
}
#[test]
fn encode_decode_round_trips_the_ast() {
let ast = vec![Command {
name: "gauge".into(),
args: vec![
Arg::Word(".cpu".into()),
Arg::Block(vec![Command {
name: "in".into(),
args: vec![],
pos: 12,
}]),
],
pos: 0,
}];
let blob = encode(&ast).unwrap();
let back = decode(&blob).unwrap();
assert_eq!(back.len(), 1);
assert_eq!(back[0].name, "gauge");
match &back[0].args[1] {
Arg::Block(inner) => assert_eq!(inner[0].name, "in"),
_ => panic!("nested block lost"),
}
}
#[test]
fn shard_get_put_replaces_by_key() {
let mut s = Shard::default();
shard_put(&mut s, 7, vec![1, 2, 3]);
shard_put(&mut s, 9, vec![4]);
assert_eq!(shard_get(&s, 7), Some(&[1, 2, 3][..]));
shard_put(&mut s, 7, vec![8, 8]);
assert_eq!(s.entries.len(), 2);
assert_eq!(shard_get(&s, 7), Some(&[8, 8][..]));
assert_eq!(shard_get(&s, 1), None);
}
#[test]
fn shard_put_evicts_oldest_at_capacity() {
let mut s = Shard::default();
for k in 0..(MAX_ENTRIES as u64 + 50) {
shard_put(&mut s, k, vec![k as u8]);
}
assert_eq!(s.entries.len(), MAX_ENTRIES, "shard is capped");
assert_eq!(shard_get(&s, 0), None);
assert_eq!(shard_get(&s, 49), None);
assert!(shard_get(&s, 50).is_some());
assert!(shard_get(&s, MAX_ENTRIES as u64 + 49).is_some());
}
#[test]
fn shard_from_another_build_is_not_read() {
let _guard = FS_LOCK
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let tmp = std::env::temp_dir().join(format!("arb_cache_stamp_{}.rkyv", std::process::id()));
std::env::set_var("ARB_CACHE", &tmp);
let _ = std::fs::remove_file(&tmp);
let src = "text .t <- in";
store(src, &crate::parser::parse(src).unwrap()).unwrap();
assert!(load(src).is_some(), "same build reads its own shard");
let mut shard = rkyv::from_bytes::<Shard>(&std::fs::read(&tmp).unwrap()).unwrap();
shard.stamp = build_stamp().wrapping_add(1);
let bytes = rkyv::to_bytes::<_, 4096>(&shard).unwrap();
std::fs::write(&tmp, &bytes).unwrap();
assert!(
load(src).is_none(),
"a shard from another build must be dropped, not replayed"
);
let _ = std::fs::remove_file(&tmp);
std::env::remove_var("ARB_CACHE");
}
#[test]
fn parse_cached_matches_direct_parse_via_fs_round_trip() {
let _guard = FS_LOCK
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let tmp = std::env::temp_dir().join(format!("arb_cache_test_{}.rkyv", std::process::id()));
std::env::set_var("ARB_CACHE", &tmp);
let _ = std::fs::remove_file(&tmp);
let src = "text .t <- in";
let a = parse_cached(src).unwrap();
let b = parse_cached(src).unwrap();
let direct = crate::parser::parse(src).unwrap();
assert_eq!(a.len(), direct.len());
assert_eq!(b.len(), direct.len());
assert_eq!(b[0].name, direct[0].name);
assert!(tmp.exists(), "shard should have been written");
let _ = std::fs::remove_file(&tmp);
std::env::remove_var("ARB_CACHE");
}
}