hauchiwa 0.4.0

Incredibly flexible static site generator library with incremental rebuilds and cached image optimization
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
129
130
131
132
133
134
135
136
137
138
139
140
141

use camino::Utf8PathBuf;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum HauchiwaError {
    #[error(transparent)]
    Loader(#[from] LoaderError),

    #[error("Encountered an error while clearing the dist directory:\n{0}")]
    Clear(#[from] ClearError),

    #[error("Error while cloning static content: {0}")]
    CloneStatic(std::io::Error),

    #[error("Error while building sitemap {0}")]
    Sitemap(#[from] SitemapError),

    #[error("Failed to compile stylesheets: {0}")]
    Stylesheet(#[from] StylesheetError),

    #[error("Error while watching {0}")]
    Watch(#[from] WatchError),

    #[error("Invalid glob pattern: {0}")]
    Glob(#[from] glob::PatternError),

    #[error("Asset not found: {0}")]
    AssetNotFound(String),

    #[error("Frontmatter has wrong shape: {0}")]
    Frontmatter(String),

    #[error("Failed to acquire read lock")]
    LockRead,

    #[error("Failed to acquire write lock")]
    LockWrite,

    #[error("Failed to build asset {0}")]
    Builder(#[from] BuilderError),

    #[error("Error while executing a hook:\n{0}")]
    Hook(#[from] HookError),
}

#[derive(Debug, Error)]
#[error(transparent)]
pub struct LoaderFileCallbackError(pub anyhow::Error);

#[derive(Debug, Error)]
pub enum LoaderFileError {
    #[error(transparent)]
    Callback(#[from] LoaderFileCallbackError),

    #[error(transparent)]
    FileSystem(#[from] std::io::Error),

    #[error("Error while reading frontmatter - {0}")]
    Frontmatter(String),
}

#[derive(Debug, Error)]
pub enum LoaderError {
    #[error("Encountered an error while loading file {0}:\n{1}")]
    LoaderGlobFile(Utf8PathBuf, LoaderFileError),

    #[error(transparent)]
    GlobPattern(#[from] glob::PatternError),

    #[error(transparent)]
    Glob(#[from] glob::GlobError),

    #[error(transparent)]
    PathFormat(#[from] camino::FromPathBufError),
}

#[derive(Debug, Error)]
pub enum ClearError {
    #[error(transparent)]
    RemoveError(std::io::Error),

    #[error(transparent)]
    CreateError(std::io::Error),
}

#[derive(Debug, Error)]
pub enum SitemapError {
    #[error("Failed to write output to file {0}")]
    FileWrite(#[from] std::io::Error),
}

#[derive(Debug, Error)]
pub enum StylesheetError {
    #[error("Glob pattern error: {0}")]
    GlobPattern(#[from] glob::PatternError),

    #[error("Glob error: {0}")]
    Glob(#[from] glob::GlobError),

    #[error("Invalid file name, only UTF-8 filenames are supported. {0}")]
    InvalidFileName(String),

    #[error("CSS compile error: {0}")]
    Compiler(String),
}

#[derive(Debug, Error)]
pub enum WatchError {
    #[error("Failed to bind to address {0}")]
    Bind(std::io::Error),

    #[error(transparent)]
    Loader(#[from] LoaderError),
}

#[derive(Debug, Error)]
pub enum BuilderError {
    #[error("Userland error: {0}")]
    Userland(#[from] anyhow::Error),

    #[error("Failed to read file `{0}`: {1}")]
    FileReadError(Utf8PathBuf, std::io::Error),

    #[error("Failed to create directory `{0}`: {1}")]
    CreateDirError(Utf8PathBuf, std::io::Error),

    #[error("Failed to write file `{0}`: {1}")]
    FileWriteError(Utf8PathBuf, std::io::Error),

    #[error("Failed to copy file from `{0}` to `{1}`: {2}")]
    FileCopyError(Utf8PathBuf, Utf8PathBuf, std::io::Error),

    #[error("Failed to optimize image")]
    OptimizationError,
}

#[derive(Debug, Error)]
pub enum HookError {
    #[error(transparent)]
    Userland(#[from] anyhow::Error),
}