Struct BuildCache 

pub struct BuildCache { /* private fields */ }

Persisted fingerprint map used for incremental builds.

Each entry maps a file path (relative to the content directory) to a hex-encoded hash of that file’s contents. Comparing the stored hash against the current hash tells us whether the file has changed.

Implementations

impl BuildCache

pub fn load(cache_path: &Path) -> Result<Self>

Load a previously saved cache from cache_path.

If the file does not exist a fresh, empty cache is returned. Any other I/O or parse error is propagated.

Examples

use ssg::cache::BuildCache;
use tempfile::tempdir;

let dir = tempdir().unwrap();
let cache_path = dir.path().join(".ssg-cache.json");
// Loading a missing path returns a fresh, empty cache.
let cache = BuildCache::load(&cache_path).unwrap();
assert!(cache.is_empty());

Errors

Returns an error if the file exists but cannot be read or contains invalid JSON.

pub fn new(cache_path: &Path) -> Self

Create a new empty cache that will be written to cache_path.

Examples

use ssg::cache::BuildCache;
use std::path::Path;

let cache = BuildCache::new(Path::new(".ssg-cache.json"));
assert_eq!(cache.len(), 0);

pub fn save(&self) -> Result<()>

Persist the current fingerprint map to the cache file.

Examples

use ssg::cache::BuildCache;
use tempfile::tempdir;

let dir = tempdir().unwrap();
let cache = BuildCache::new(&dir.path().join("cache.json"));
cache.save().unwrap();
assert!(dir.path().join("cache.json").exists());

Errors

Returns an error if the file cannot be written.

pub fn changed_files(&self, content_dir: &Path) -> Result<Vec<PathBuf>>

Return the set of files in content_dir that have changed since the fingerprints were last recorded, plus any newly added files.

Deleted files (present in cache but absent on disk) are not included in the returned list, but they will be removed from the internal map on the next update call.

The returned paths are absolute.

Examples

use ssg::cache::BuildCache;
use tempfile::tempdir;
use std::fs;

let dir = tempdir().unwrap();
let content = dir.path().join("content");
fs::create_dir(&content).unwrap();
fs::write(content.join("a.md"), "hello").unwrap();
let cache = BuildCache::new(&dir.path().join("cache.json"));
// Every file is "changed" against an empty cache.
let changed = cache.changed_files(&content).unwrap();
assert_eq!(changed.len(), 1);

Errors

Returns an error if content_dir cannot be read or individual files cannot be hashed.

pub fn update(&mut self, content_dir: &Path) -> Result<()>

Re-scan content_dir and replace the entire fingerprint map with fresh hashes.

Call this after a successful build so the next invocation of changed_files reflects the new state.

Examples

use ssg::cache::BuildCache;
use tempfile::tempdir;
use std::fs;

let dir = tempdir().unwrap();
let content = dir.path().join("content");
fs::create_dir(&content).unwrap();
fs::write(content.join("a.md"), "hi").unwrap();
let mut cache = BuildCache::new(&dir.path().join("cache.json"));
cache.update(&content).unwrap();
assert_eq!(cache.len(), 1);

Errors

Returns an error if files cannot be read.

pub fn len(&self) -> usize

Return the number of entries currently in the fingerprint map.

Examples

use ssg::cache::BuildCache;
use std::path::Path;

let cache = BuildCache::new(Path::new("cache.json"));
assert_eq!(cache.len(), 0);

pub fn is_empty(&self) -> bool

Return true if the fingerprint map is empty.

Examples

use ssg::cache::BuildCache;
use std::path::Path;

let cache = BuildCache::new(Path::new("cache.json"));
assert!(cache.is_empty());

pub const fn default_path() -> &'static str

Return the path to the default cache file relative to the project root.

Examples

use ssg::cache::BuildCache;

assert_eq!(BuildCache::default_path(), ".ssg-cache.json");

Trait Implementations

impl Clone for BuildCache

fn clone(&self) -> BuildCache

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BuildCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BuildCache

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BuildCache

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.