eighty 0.2.0

Static website generator, mainly for the Core Paper project.
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
126
127
128

// SPDX-License-Identifier: GPL-3.0-or-later
// This file is part of Eighty.
//
// Copyright (c) 2021 Wei Tang.
//
// Eighty is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Eighty is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Eighty. If not, see <http://www.gnu.org/licenses/>.

use crate::{
    Error,
    document::RenderedDocument,
    file::FileMetadata,
    site::{SiteMetadata, SiteName},
    workspace::{MetadatadSite, MetadatadWorkspace, WorkspacePath},
};
use rayon::prelude::*;
use std::{collections::HashMap, path::PathBuf, sync::Arc};

#[derive(Eq, Clone, PartialEq, Debug)]
pub struct RenderedWorkspace {
    pub path: WorkspacePath,
    pub sites: HashMap<SiteName, RenderedSite>,
}

impl RenderedWorkspace {
    pub fn new(metadata: &MetadatadWorkspace) -> Result<RenderedWorkspace, Error> {
        let sites = metadata
            .sites
            .par_iter()
            .map(|(name, site)| Ok((name.clone(), RenderedSite::new(&site)?)))
            .collect::<Result<_, Error>>()?;

        Ok(Self {
            sites,
            path: metadata.path.clone(),
        })
    }

    pub fn new_with_old(
        metadata: &MetadatadWorkspace,
        old: &RenderedWorkspace,
    ) -> Result<RenderedWorkspace, Error> {
        let sites = metadata
            .sites
            .par_iter()
            .map(|(name, site)| {
                if let Some(old_site) = old.sites.get(&name) {
                    Ok((name.clone(), RenderedSite::new_with_old(&site, old_site)?))
                } else {
                    Ok((name.clone(), RenderedSite::new(&site)?))
                }
            })
            .collect::<Result<_, Error>>()?;

        Ok(Self {
            sites,
            path: metadata.path.clone(),
        })
    }
}

#[derive(Eq, Clone, PartialEq, Debug)]
pub struct RenderedSite {
    pub site: Arc<SiteMetadata>,
    pub documents: HashMap<PathBuf, RenderedDocument>,
    pub files: Arc<HashMap<PathBuf, FileMetadata>>,
}

impl RenderedSite {
    pub fn new(metadata: &MetadatadSite) -> Result<RenderedSite, Error> {
        let documents = metadata
            .documents
            .par_iter()
            .map(|document| {
                Ok((
                    document.rel_source_path.clone(),
                    RenderedDocument::new(metadata.site.clone(), document.clone())?,
                ))
            })
            .collect::<Result<_, Error>>()?;

        Ok(Self {
            site: metadata.site.clone(),
            files: metadata.files.clone(),
            documents,
        })
    }

    pub fn new_with_old(
        metadata: &MetadatadSite,
        old: &RenderedSite,
    ) -> Result<RenderedSite, Error> {
        let documents = metadata
            .documents
            .par_iter()
            .map(|document| {
                if let Some(old_document) = old.documents.get(&document.rel_source_path) {
                    if old_document.site_metadata == metadata.site
                        && old_document.metadata == *document
                    {
                        return Ok((document.rel_source_path.clone(), old_document.clone()));
                    }
                }

                Ok((
                    document.rel_source_path.clone(),
                    RenderedDocument::new(metadata.site.clone(), document.clone())?,
                ))
            })
            .collect::<Result<_, Error>>()?;

        Ok(Self {
            site: metadata.site.clone(),
            files: metadata.files.clone(),
            documents,
        })
    }
}