courses 0.9.4

A publishing system for interactive content
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use anyhow::anyhow;
use blake3::Hash;
use cdoc::config::Format;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct Cache {
    content_files: HashMap<String, FileInfo>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
struct FileInfo {
    hash: Hash,
    build_succeeded: BTreeMap<String, bool>,
}

impl FileInfo {
    pub fn build_status_all(&self) -> bool {
        self.build_succeeded.values().all(|v| *v)
    }

    pub fn build_status_format<F: Format>(&self, format: F) -> Option<&bool> {
        self.build_succeeded.get(format.name())
    }

    pub fn set_status(&mut self, format: &str, build_succeeded: bool) -> Option<bool> {
        self.build_succeeded
            .insert(format.to_string(), build_succeeded)
    }
}

impl Cache {
    pub fn exists(&self, path: &str) -> bool {
        self.content_files.contains_key(path)
    }

    pub fn matches(&self, path: &str, hash: Hash) -> bool {
        self.content_files
            .get(path)
            .map(|h| h.hash == hash)
            .unwrap_or_default()
    }

    pub fn should_rebuild_all(&self, path: &str, hash: Hash) -> bool {
        self.content_files
            .get(path)
            .map(|h| h.build_status_all() && h.hash == hash)
            .unwrap_or_default()
    }

    pub fn should_rebuild_format<F: Format>(&self, path: &str, format: F) -> bool {
        self.content_files
            .get(path)
            .map(|h| *h.build_status_format(format).unwrap_or(&false))
            .unwrap_or_default()
    }

    pub fn reset_entry(&mut self, path: String, hash: Hash) {
        self.content_files.insert(
            path,
            FileInfo {
                hash,
                build_succeeded: Default::default(),
            },
        );
    }

    pub fn update_build_status(
        &mut self,
        path: String,
        format: &str,
        build_succeeded: bool,
    ) -> anyhow::Result<()> {
        self.content_files
            .get_mut(&path)
            .ok_or_else(|| anyhow!("path not found in cache"))?
            .set_status(format, build_succeeded);
        Ok(())
    }
}