Struct DepGraph 

pub struct DepGraph { /* private fields */ }

Dependency graph mapping consumers to their dependencies.

Persisted to target/ssg-cache/depgraph.json. Loaders are poisoning-resistant: a missing, truncated, or version-mismatched file yields an empty graph — caller falls back to a full rebuild without crashing or producing stale output (AC6).

Implementations

impl DepGraph

pub fn new() -> Self

Creates an empty dependency graph at the current schema version.

Examples

use ssg::depgraph::DepGraph;

let g = DepGraph::new();
assert_eq!(g.page_count(), 0);

pub fn load(cache_root: &Path) -> Self

Loads the graph from <cache_root>/depgraph.json.

Returns an empty graph if the file is missing, unreadable, malformed, or written by an incompatible schema version. The poisoning-resistant return matches AC6.

Examples

use ssg::depgraph::DepGraph;
use tempfile::tempdir;

let dir = tempdir().unwrap();
// Missing cache file ⇒ empty graph (no panic, no error).
let g = DepGraph::load(dir.path());
assert_eq!(g.page_count(), 0);

pub fn save(&self, cache_root: &Path) -> Result<(), SsgError>

Persists the graph atomically: writes <file>.tmp then renames. POSIX rename is atomic on the same filesystem.

Examples

use ssg::depgraph::DepGraph;
use tempfile::tempdir;

let dir = tempdir().unwrap();
let g = DepGraph::new();
g.save(dir.path()).unwrap();
assert!(dir.path().join("depgraph.json").exists());

Errors

Returns the underlying I/O failure if the cache root can’t be created or the temp file can’t be written / renamed.

pub fn add_dep(&mut self, consumer: &Path, dep: &Path)

Records that consumer depends on dep.

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
g.add_dep(Path::new("page.md"), Path::new("layout.html"));
assert!(g.deps_for(Path::new("page.md")).is_some());

pub fn add_output(&mut self, source: &Path, output: &Path)

Records that source produces output. Used by the AC5 delete-sweep to remove orphaned outputs when a source is removed.

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
g.add_output(Path::new("a.md"), Path::new("a.html"));
assert!(g.outputs_for(Path::new("a.md")).is_some());

pub fn record_hash(&mut self, path: &Path, content: &[u8])

Records the SHA-256 freshness key for path from a byte slice.

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;
use std::collections::HashMap;

let mut g = DepGraph::new();
g.record_hash(Path::new("a.md"), b"hello");
// Same content ⇒ no diff.
let mut current = HashMap::new();
current.insert(Path::new("a.md").to_path_buf(), DepGraph::sha256_hex(b"hello"));
assert!(g.diff(&current).is_empty());

pub fn record_hash_from_disk(&mut self, path: &Path)

Records the SHA-256 of path by reading it from disk. Silently ignores missing files (the caller will catch the absence elsewhere — typically a delete that we want to record).

Examples

use ssg::depgraph::DepGraph;
use tempfile::tempdir;
use std::fs;

let dir = tempdir().unwrap();
let p = dir.path().join("a.md");
fs::write(&p, "hi").unwrap();
let mut g = DepGraph::new();
g.record_hash_from_disk(&p);
// Missing files are silently ignored.
g.record_hash_from_disk(&dir.path().join("missing.md"));

pub fn sha256_hex(bytes: &[u8]) -> String

Returns the SHA-256 hex string for bytes. Exposed so the populate helpers can hash files exactly once.

Examples

use ssg::depgraph::DepGraph;

let hex = DepGraph::sha256_hex(b"");
// Empty string has a well-known SHA-256.
assert_eq!(hex, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");

pub fn deps_for(&self, consumer: &Path) -> Option<&HashSet<PathBuf>>

Returns the direct dependencies recorded for consumer.

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
g.add_dep(Path::new("p.md"), Path::new("layout.html"));
assert_eq!(g.deps_for(Path::new("p.md")).map(|s| s.len()), Some(1));
assert!(g.deps_for(Path::new("none")).is_none());

pub fn outputs_for(&self, source: &Path) -> Option<&HashSet<PathBuf>>

Returns the recorded outputs for source.

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
g.add_output(Path::new("a.md"), Path::new("a.html"));
assert_eq!(g.outputs_for(Path::new("a.md")).map(|s| s.len()), Some(1));

pub fn tracked_sources(&self) -> Vec<PathBuf>

Returns every tracked source path (the keys of the output map).

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
g.add_output(Path::new("a.md"), Path::new("a.html"));
assert_eq!(g.tracked_sources(), vec![Path::new("a.md").to_path_buf()]);

pub fn page_count(&self) -> usize

Returns the count of edge consumers (pages + intermediate deps).

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
assert_eq!(g.page_count(), 0);
g.add_dep(Path::new("p.md"), Path::new("l.html"));
assert_eq!(g.page_count(), 1);

pub fn forget(&mut self, path: &Path)

Removes every entry that references path as either a consumer or a dependency. Called by Self::diff when a source is deleted.

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
g.add_dep(Path::new("p.md"), Path::new("l.html"));
g.forget(Path::new("p.md"));
assert!(g.deps_for(Path::new("p.md")).is_none());

pub fn clear(&mut self)

Clears the entire graph.

Examples

use ssg::depgraph::DepGraph;
use std::path::Path;

let mut g = DepGraph::new();
g.add_dep(Path::new("p.md"), Path::new("l.html"));
g.clear();
assert_eq!(g.page_count(), 0);

pub fn invalidated(&self, changed: &[PathBuf]) -> Vec<PathBuf>

Returns every consumer reachable from any of changed via the reverse edge map (transitive closure, AC3). Sources whose own content changed are always included.

Examples

use ssg::depgraph::DepGraph;
use std::path::{Path, PathBuf};

let mut g = DepGraph::new();
g.add_dep(Path::new("p.md"), Path::new("l.html"));
let changed = vec![PathBuf::from("l.html")];
// Changing the layout invalidates the page that consumes it.
assert!(g.invalidated(&changed).contains(&PathBuf::from("p.md")));

pub fn invalidated_outputs(&self, changed: &[PathBuf]) -> Vec<PathBuf>

Returns the union of output paths for every invalidated source. Sources that don’t appear in the output map (templates, partials, data files) contribute nothing.

Examples

use ssg::depgraph::DepGraph;
use std::path::{Path, PathBuf};

let mut g = DepGraph::new();
g.add_dep(Path::new("p.md"), Path::new("l.html"));
g.add_output(Path::new("p.md"), Path::new("p.html"));
let outs = g.invalidated_outputs(&[PathBuf::from("l.html")]);
assert_eq!(outs, vec![PathBuf::from("p.html")]);

pub fn diff(&self, current: &HashMap<PathBuf, String>) -> Diff

Compares current (path → sha256) against the cached hashes and returns (changed, deleted).

• changed — paths whose current hash differs from cache, or paths that weren’t in the cache (new files).
• deleted — paths the cache knew about that are absent from current.

Examples

use ssg::depgraph::DepGraph;
use std::collections::HashMap;
use std::path::PathBuf;

let g = DepGraph::new();
let mut current = HashMap::new();
current.insert(PathBuf::from("a.md"), DepGraph::sha256_hex(b"x"));
// Empty graph ⇒ everything in `current` looks new.
let d = g.diff(&current);
assert_eq!(d.changed, vec![PathBuf::from("a.md")]);
assert!(d.deleted.is_empty());

Trait Implementations

impl Clone for DepGraph

fn clone(&self) -> DepGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DepGraph

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

Formats the value using the given formatter.

impl Default for DepGraph

fn default() -> DepGraph

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DepGraph

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DepGraph

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

where __S: Serializer,

Serialize this value into the given Serde serializer.