use anyhow::{Context, Result};
use redb::{Database, ReadableDatabase, ReadableTable, TableDefinition};
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::{Path, PathBuf};
use crate::checksum::file_checksum;
const RSBUILD_DIR: &str = ".rsconstruct";
const DEPS_DB_FILE: &str = "deps.redb";
const DEPS_TABLE: TableDefinition<&str, &[u8]> = TableDefinition::new("deps");
#[derive(Debug, Serialize, Deserialize)]
struct DepsEntry {
source_checksum: String,
dependencies: Vec<String>,
#[serde(default)]
analyzer: String,
}
#[derive(Debug, Default, Clone)]
pub struct DepsCacheStats {
pub hits: usize,
pub misses: usize,
}
pub struct DepsCache {
db: Database,
stats: DepsCacheStats,
}
impl DepsCache {
pub fn open() -> Result<Self> {
let rsconstruct_dir = PathBuf::from(RSBUILD_DIR);
let db_path = rsconstruct_dir.join(DEPS_DB_FILE);
fs::create_dir_all(&rsconstruct_dir)
.context("Failed to create .rsconstruct directory")?;
let db = crate::db::open_or_recreate(&db_path, "Dependency cache")?;
Ok(Self { db, stats: DepsCacheStats::default() })
}
pub fn get(&mut self, source: &Path) -> Option<Vec<PathBuf>> {
let key = path_to_key(source);
let read_txn = self.db.begin_read().ok()?;
let table = read_txn.open_table(DEPS_TABLE).ok()?;
let data = match table.get(key.as_str()).ok()? {
Some(d) => d,
None => {
self.stats.misses += 1;
return None;
}
};
let entry: DepsEntry = match serde_json::from_slice(data.value()) {
Ok(e) => e,
Err(_) => {
self.stats.misses += 1;
return None;
}
};
let current_checksum = match file_checksum(source) {
Ok(c) => c,
Err(_) => {
self.stats.misses += 1;
return None;
}
};
if entry.source_checksum != current_checksum {
self.stats.misses += 1;
return None;
}
let deps: Vec<PathBuf> = entry.dependencies.iter()
.map(PathBuf::from)
.collect();
for dep in &deps {
if !dep.exists() {
self.stats.misses += 1;
return None;
}
}
self.stats.hits += 1;
Some(deps)
}
pub fn set(&self, source: &Path, dependencies: &[PathBuf], analyzer: &str) -> Result<()> {
let key = path_to_key(source);
let source_checksum = file_checksum(source)?;
let entry = DepsEntry {
source_checksum,
dependencies: dependencies.iter()
.map(|p| p.display().to_string())
.collect(),
analyzer: analyzer.to_string(),
};
let data = serde_json::to_vec(&entry)
.context("Failed to serialize dependency entry")?;
let write_txn = self.db.begin_write()
.context("Failed to begin write transaction")?;
{
let mut table = write_txn.open_table(DEPS_TABLE)
.context("Failed to open deps table")?;
table.insert(key.as_str(), data.as_slice())
.context("Failed to write to dependency cache")?;
}
write_txn.commit()
.context("Failed to commit dependency cache write")?;
Ok(())
}
pub fn stats(&self) -> &DepsCacheStats {
&self.stats
}
fn collect_entries(&self) -> Vec<(String, DepsEntry)> {
let read_txn = match self.db.begin_read() {
Ok(t) => t,
Err(_) => return Vec::new(),
};
let table = match read_txn.open_table(DEPS_TABLE) {
Ok(t) => t,
Err(_) => return Vec::new(),
};
let iter = match table.iter() {
Ok(i) => i,
Err(_) => return Vec::new(),
};
iter.filter_map(|item| {
let (key, value) = item.ok()?;
let entry: DepsEntry = serde_json::from_slice(value.value()).ok()?;
Some((key.value().to_string(), entry))
})
.collect()
}
pub fn get_raw(&self, source: &Path) -> Option<(Vec<PathBuf>, String)> {
let key = path_to_key(source);
let read_txn = self.db.begin_read().ok()?;
let table = read_txn.open_table(DEPS_TABLE).ok()?;
let data = table.get(key.as_str()).ok()??;
let entry: DepsEntry = serde_json::from_slice(data.value()).ok()?;
Some((
entry.dependencies.iter().map(PathBuf::from).collect(),
entry.analyzer,
))
}
pub fn list_all(&self) -> Vec<(PathBuf, Vec<PathBuf>, String)> {
self.collect_entries()
.into_iter()
.map(|(key, entry)| {
let source = PathBuf::from(key);
let deps: Vec<PathBuf> = entry.dependencies.iter().map(PathBuf::from).collect();
(source, deps, entry.analyzer)
})
.collect()
}
pub fn stats_by_analyzer(&self) -> std::collections::HashMap<String, (usize, usize)> {
let mut stats: std::collections::HashMap<String, (usize, usize)> = std::collections::HashMap::new();
for (_key, entry) in self.collect_entries() {
let analyzer = if entry.analyzer.is_empty() { "unknown".to_string() } else { entry.analyzer };
let (files, deps) = stats.entry(analyzer).or_insert((0, 0));
*files += 1;
*deps += entry.dependencies.len();
}
stats
}
pub fn list_by_analyzers(&self, analyzers: &[String]) -> Vec<(PathBuf, Vec<PathBuf>, String)> {
self.collect_entries()
.into_iter()
.filter_map(|(key, entry)| {
if !analyzers.contains(&entry.analyzer) {
return None;
}
let source = PathBuf::from(key);
let deps: Vec<PathBuf> = entry.dependencies.iter().map(PathBuf::from).collect();
Some((source, deps, entry.analyzer))
})
.collect()
}
pub fn remove_by_analyzer(&self, analyzer: &str) -> Result<usize> {
let keys_to_remove: Vec<String> = self.collect_entries()
.into_iter()
.filter_map(|(key, entry)| {
if entry.analyzer == analyzer {
Some(key)
} else {
None
}
})
.collect();
let mut removed = 0;
if !keys_to_remove.is_empty() {
let write_txn = self.db.begin_write()
.context("Failed to begin write transaction")?;
{
let mut table = write_txn.open_table(DEPS_TABLE)
.context("Failed to open deps table")?;
for key in &keys_to_remove {
if table.remove(key.as_str()).is_ok() {
removed += 1;
}
}
}
write_txn.commit()
.context("Failed to commit dependency cache removal")?;
}
Ok(removed)
}
}
fn path_to_key(path: &Path) -> String {
path.display().to_string()
}