razorbill 0.1.0

A toolkit for bespoke static site generators.
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

use std::collections::HashMap;
use std::fs::{self, File};
use std::io::{self, Write};
use std::path::PathBuf;
use std::str::FromStr;
use std::sync::{Arc, RwLock};

use thiserror::Error;

use crate::content::{Page, Section};

pub trait Store {
    type Error: std::error::Error;

    fn store_rendered_section(
        &self,
        section: &Section,
        rendered_html: String,
    ) -> Result<(), Self::Error>;

    fn store_rendered_page(&self, page: &Page, rendered_html: String) -> Result<(), Self::Error>;
}

pub struct DiskStorage {
    output_path: PathBuf,
}

impl DiskStorage {
    pub fn new(output_path: PathBuf) -> Self {
        Self { output_path }
    }
}

impl Store for DiskStorage {
    type Error = io::Error;

    fn store_rendered_section(
        &self,
        section: &Section,
        rendered_html: String,
    ) -> Result<(), Self::Error> {
        let output_dir = self.output_path.join(
            PathBuf::from_str(
                &section
                    .path
                    .0
                    .trim_end_matches("/_index")
                    .trim_start_matches("/"),
            )
            .unwrap(),
        );

        fs::create_dir_all(&output_dir)?;

        let output_path = output_dir.join("index.html");
        let mut output_file = File::create(&output_path)?;

        output_file.write_all(rendered_html.as_bytes())?;

        Ok(())
    }

    fn store_rendered_page(&self, page: &Page, rendered_html: String) -> Result<(), Self::Error> {
        let output_dir = self
            .output_path
            .join(PathBuf::from_str(&page.path.0.trim_start_matches("/")).unwrap());

        fs::create_dir_all(&output_dir)?;

        let output_path = output_dir.join("index.html");
        let mut output_file = File::create(&output_path)?;

        output_file.write_all(rendered_html.as_bytes())?;

        Ok(())
    }
}

pub struct InMemoryStorage {
    storage: Arc<RwLock<HashMap<String, String>>>,
}

impl InMemoryStorage {
    pub fn new(storage: Arc<RwLock<HashMap<String, String>>>) -> Self {
        Self { storage }
    }
}

#[derive(Error, Debug)]
pub enum InMemoryStorageError {
    #[error("poisoned")]
    Poisoned,
}

impl Store for InMemoryStorage {
    type Error = InMemoryStorageError;

    fn store_rendered_section(
        &self,
        section: &Section,
        rendered_html: String,
    ) -> Result<(), Self::Error> {
        self.storage
            .write()
            .map_err(|_| InMemoryStorageError::Poisoned)?
            .insert(section.path.0.replace("/_index", "/"), rendered_html);

        Ok(())
    }

    fn store_rendered_page(&self, page: &Page, rendered_html: String) -> Result<(), Self::Error> {
        self.storage
            .write()
            .map_err(|_| InMemoryStorageError::Poisoned)?
            .insert(page.path.0.clone(), rendered_html);

        Ok(())
    }
}