ebg 0.7.0

Eric's Blog Generator, a simple static site generator.
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::{
    path::{Path, PathBuf},
    sync::Mutex,
    time::{Duration, Instant},
};

use ebg::{
    generator::{self, GeneratorContext, Observer},
    index::{PageMetadata, SiteIndex, SiteMetadata},
};
use indicatif::{MultiProgress, ProgressBar};
use miette::{Context, IntoDiagnostic};
use tokio::runtime::Runtime;
use tracing::info;

enum ProgressState {
    NotStarted,
    LoadingSite(ProgressBar),
    BuildingSite {
        header: ProgressBar,
        pages: ProgressBar,
    },
    Complete,
}

struct BuildStatusViewer {
    progress: MultiProgress,
    state: Mutex<ProgressState>,
}

impl BuildStatusViewer {
    fn new() -> Self {
        Self {
            progress: MultiProgress::new(),
            state: Mutex::new(ProgressState::NotStarted),
        }
    }
}

impl Observer for BuildStatusViewer {
    fn begin_load_site(&self) {
        let progress = self.progress.add(ProgressBar::new_spinner());
        progress.set_message("Loading site directory");
        progress.enable_steady_tick(Duration::from_millis(250));
        *self.state.lock().unwrap() = ProgressState::LoadingSite(progress);
    }

    fn end_load_site(&self, site: &dyn SiteMetadata) {
        let mut state = self.state.lock().unwrap();

        // cleanup the old state
        if let ProgressState::LoadingSite(progress) = &*state {
            progress.finish();
            // self.progress.remove(progress);
        }

        // set up the new state
        let header = self.progress.add(ProgressBar::new_spinner());
        header.set_message("Building pages");
        let pages = self.progress.add(ProgressBar::new(site.num_pages() as u64));
        *state = ProgressState::BuildingSite { header, pages };
    }

    fn end_page(&self, _page: &dyn PageMetadata) {
        let state = self.state.lock().unwrap();
        if let ProgressState::BuildingSite { header, pages } = &*state {
            pages.inc(1);
            header.tick();
        }
    }

    fn site_complete(&self, _site: &dyn SiteMetadata) {
        let mut state = self.state.lock().unwrap();
        if let ProgressState::BuildingSite { header, pages } = &*state {
            pages.finish();
            header.finish();
            self.progress.remove(pages);
            self.progress.remove(header);
            *state = ProgressState::Complete;
        }
    }
}

impl super::Command for generator::Options {
    fn run(self) -> miette::Result<()> {
        let path = find_site_root(self.path.as_deref()).context("finding Site.toml")?;
        info!("building blog from {}", path.display());

        let start_time = Instant::now();
        let progress = BuildStatusViewer::new();

        Runtime::new().into_diagnostic()?.block_on(async move {
            progress.begin_load_site();
            let site = SiteIndex::from_directory(&path, self.unpublished).await?;
            progress.end_load_site(&site);

            let site = site.render()?;

            let gcx = GeneratorContext::new(&site, &self)?;

            gcx.generate_site(&site).await?;
            progress.site_complete(&site);

            let elapsed = start_time.elapsed();

            println!("Built site in {:.2?}", elapsed);

            Ok(())
        })
    }
}

pub(crate) fn find_site_root(path: Option<&Path>) -> miette::Result<PathBuf> {
    let mut path = path.unwrap_or(Path::new(".")).to_path_buf();
    loop {
        if path.join("Site.toml").exists() {
            return Ok(path.clone());
        }

        path = match path.parent() {
            Some(parent) => parent.to_path_buf(),
            None => miette::bail!("could not find Site.toml in any parent directory"),
        };
    }
}