supreme_fs/game_storage/

local_ops.rs

//! Local-only filesystem helpers: hashing, profile listing, empty-directory
//! cleanup, and JSON report writing. Hook-aware text/byte read-write lives
//! in [`super::hooked_ops`].

use super::GameStorage;
use sha2::{Digest, Sha256};
use std::fs::{self, File};
use std::io::{self, Read};
use std::path::{Path, PathBuf};

impl GameStorage {
    /// Calculate SHA256 hash of a file, for content-addressed storage.
    ///
    /// # Errors
    ///
    /// Returns an error if the file cannot be opened or read.
    pub fn calculate_hash(&self, path: &Path) -> io::Result<String> {
        let mut file = File::open(path)?;
        let mut hasher = Sha256::new();
        let mut buffer = [0; 1024];
        loop {
            let count = file.read(&mut buffer)?;
            if count == 0 {
                break;
            }
            hasher.update(&buffer[..count]);
        }
        Ok(hex::encode(hasher.finalize()))
    }

    /// List all available snapshot profiles: finds and filters .json files.
    ///
    /// # Errors
    ///
    /// Returns an error if the profiles directory cannot be read.
    pub fn list_snapshots_profiles(&self) -> io::Result<Vec<String>> {
        let mut profiles = Vec::new();
        if let Ok(entries) = fs::read_dir(self.profiles_path()) {
            for entry in entries.flatten() {
                let path = entry.path();
                if path.extension().and_then(|s| s.to_str()) == Some("json")
                    && let Some(stem) = path.file_stem().and_then(|s| s.to_str())
                {
                    profiles.push(stem.to_string());
                }
            }
        }
        profiles.sort();
        Ok(profiles)
    }

    /// Clean up empty directories recursively.
    pub fn clean_up_empty_dirs(&self, start_dir: &Path, limit_dir: &Path) {
        let mut current = start_dir;
        while current.starts_with(limit_dir) && current != limit_dir {
            if fs::remove_dir(current).is_ok() {
                if let Some(p) = current.parent() {
                    current = p;
                } else {
                    break;
                }
            } else {
                break;
            }
        }
    }

    /// Write a JSON report to .supreme/{name}.json
    ///
    /// # Errors
    ///
    /// Returns an error if the report directory cannot be created or the file written.
    pub fn write_report<T: serde::Serialize>(&self, name: &str, value: &T) -> io::Result<()> {
        let report_dir = self.root_path.join(".supreme");
        fs::create_dir_all(&report_dir)?;

        let report_path = report_dir.join(format!("{name}.json"));
        let file = File::create(report_path)?;
        serde_json::to_writer_pretty(file, value).map_err(io::Error::other)
    }

    /// Get the path to a report file.
    #[must_use]
    pub fn get_report_path(&self, name: &str) -> PathBuf {
        self.root_path.join(".supreme").join(format!("{name}.json"))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::tempdir;

    fn make_storage() -> (tempfile::TempDir, GameStorage) {
        let dir = tempdir().expect("tempdir");
        let storage = GameStorage::new(dir.path());
        (dir, storage)
    }

    #[test]
    fn calculate_hash_matches_known_sha256() {
        let (dir, storage) = make_storage();
        let file_path = dir.path().join("hello.txt");
        fs::write(&file_path, b"hello world").unwrap();

        let hash = storage.calculate_hash(&file_path).expect("hash");
        // Known SHA256 of "hello world"
        assert_eq!(
            hash,
            "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
        );
    }

    #[test]
    fn calculate_hash_of_empty_file_matches_known_sha256() {
        let (dir, storage) = make_storage();
        let file_path = dir.path().join("empty.txt");
        fs::write(&file_path, b"").unwrap();

        let hash = storage.calculate_hash(&file_path).expect("hash");
        assert_eq!(
            hash,
            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
        );
    }

    #[test]
    fn calculate_hash_errors_on_missing_file() {
        let (dir, storage) = make_storage();
        let result = storage.calculate_hash(&dir.path().join("missing.txt"));
        assert!(result.is_err());
    }

    #[test]
    fn list_snapshots_profiles_returns_sorted_json_stems() {
        let (_dir, storage) = make_storage();
        fs::create_dir_all(storage.profiles_path()).unwrap();
        fs::write(storage.profiles_path().join("zeta.json"), b"{}").unwrap();
        fs::write(storage.profiles_path().join("alpha.json"), b"{}").unwrap();
        // Non-json files should be ignored.
        fs::write(storage.profiles_path().join("notes.txt"), b"ignore me").unwrap();

        let profiles = storage.list_snapshots_profiles().expect("list");
        assert_eq!(profiles, vec!["alpha".to_string(), "zeta".to_string()]);
    }

    #[test]
    fn list_snapshots_profiles_on_missing_dir_returns_empty() {
        let (_dir, storage) = make_storage();
        let profiles = storage.list_snapshots_profiles().expect("list");
        assert!(profiles.is_empty());
    }

    #[test]
    fn clean_up_empty_dirs_removes_empty_chain_but_stops_at_limit() {
        let (dir, storage) = make_storage();
        let nested = dir.path().join("a/b/c");
        fs::create_dir_all(&nested).unwrap();

        storage.clean_up_empty_dirs(&nested, dir.path());

        assert!(!nested.exists());
        assert!(!dir.path().join("a/b").exists());
        assert!(!dir.path().join("a").exists());
        // The limit dir itself must still exist.
        assert!(dir.path().exists());
    }

    #[test]
    fn clean_up_empty_dirs_stops_when_a_directory_is_not_empty() {
        let (dir, storage) = make_storage();
        let nested = dir.path().join("a/b/c");
        fs::create_dir_all(&nested).unwrap();
        // Put a file in "a/b" so cleanup can remove "c" but must stop at "b".
        fs::write(dir.path().join("a/b/keep.txt"), b"keep").unwrap();

        storage.clean_up_empty_dirs(&nested, dir.path());

        assert!(!nested.exists());
        assert!(dir.path().join("a/b").exists());
        assert!(dir.path().join("a/b/keep.txt").exists());
    }

    #[test]
    fn write_report_creates_json_file_readable_back() {
        let (_dir, storage) = make_storage();
        #[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug)]
        struct Report {
            ok: bool,
            count: u32,
        }
        let report = Report { ok: true, count: 3 };

        storage
            .write_report("summary", &report)
            .expect("write_report");

        let path = storage.get_report_path("summary");
        assert!(path.exists());
        let contents = fs::read_to_string(path).unwrap();
        let parsed: Report = serde_json::from_str(&contents).unwrap();
        assert_eq!(parsed, report);
    }

    #[test]
    fn get_report_path_is_under_dot_supreme() {
        let (dir, storage) = make_storage();
        let path = storage.get_report_path("mysummary");
        assert_eq!(path, dir.path().join(".supreme").join("mysummary.json"));
    }
}