sitdown 0.2.1

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

use std::{fs, path::PathBuf};

use minijinja::Environment;
use pulldown_cmark::Options;

use crate::{
    config::{Config, ConfigDefaults, ConfigStructure},
    error::Result,
    templates,
    tree::{load_contents, Dir},
};

/// The app represents the state of the site to generate
pub struct App<'a> {
    structure: &'a ConfigStructure,
    options: Options,
    defaults: &'a ConfigDefaults,
    templates: Environment<'a>,
    content: Dir<PathBuf, PathBuf>,
    assets: Dir<PathBuf, PathBuf>,
}

impl<'a> App<'a> {
    pub fn new(config: &'a Config) -> Self {
        let structure = &config.structure;
        let options = config.options.options();
        let defaults = &config.defaults;

        let templates = templates::get_env(&structure.template).unwrap();
        let content = load_contents(&structure.content).unwrap();
        let assets = load_contents(&structure.assets).unwrap();

        App {
            structure,
            options,
            defaults,
            templates,
            content,
            assets,
        }
    }

    fn clear_dirs(&self) -> Result<()> {
        let _ = fs::remove_dir_all(&self.structure.site)
            .and_then(|_| fs::remove_dir_all(&self.structure.work));
        Ok(())
    }

    fn copy_assets(&self) -> Result<()> {
        let res = self.assets.copy_to(&self.structure.site)?;
        Ok(res)
    }

    fn create_pages(&self) -> Result<()> {
        let parsed_tree = self.content.annotate(&self.defaults, &self.options)?;
        let meta_tree = parsed_tree.write_metadata(&self.structure.work)?;
        meta_tree.create(&self.structure.site, &self.templates)?;
        Ok(())
    }

    fn create_dirs(&self) -> Result<()> {
        fs::create_dir_all(&self.structure.work)?;
        fs::create_dir_all(&self.structure.site)?;
        Ok(())
    }

    pub fn create(&self) -> Result<()> {
        self.clear_dirs()
            .and_then(|_| self.create_dirs())
            .and_then(|_| self.copy_assets().and_then(|_| self.create_pages()))
    }
}