orestaty 1.0.0

HTML-centered handlebars-based 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
126
127

use clap::{Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Cli {
    /// Project path, current directory by default
    #[arg(short, long)]
    path: Option<PathBuf>,

    /// Output path, defaults to <path>/dist
    #[arg(short, long)]
    output: Option<PathBuf>,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Subcommand)]
enum Commands {
    /// Init a new website in the current directory (override using -p/--path)
    Init,
    /// Build the website
    #[default]
    Build,
    /// Generate .css file from a colorscheme
    ThemeToCSS {
        /// Theme name or path to .tmTheme
        theme: String,
        /// Output path, defaults to <theme-name>.css
        #[arg(long, short)]
        output: Option<PathBuf>,
    },
}

fn parse_config(path: &std::path::Path) -> Result<orestaty::Config, ()> {
    if path.exists() {
        let config = std::fs::read_to_string(path).map_err(|err| {
            eprintln!("Failed to read config file: {}", err);
        })?;
        toml::from_str(&config).map_err(|err| {
            eprintln!("Failed to parse config file: {}", err);
        })
    } else {
        Err(())
    }
}

fn main() {
    let cli = Cli::parse();
    let path = cli.path.unwrap_or(std::env::current_dir().unwrap());
    let dst = cli.output.unwrap_or(path.join("dist"));

    if cli.command == Commands::Init {
        if let Err(err) = std::fs::create_dir_all(path.join("src")) {
            eprintln!("Failed to create src directory: {}", err);
        }
        if let Err(err) = std::fs::write(
            path.join("src").join("index.md"),
            include_str!("templates/index.md"),
        ) {
            eprintln!("Failed to create index.md: {}", err);
        }
        return;
    }
    if let Commands::ThemeToCSS { theme, output } = cli.command {
        if let Some(syntax_highlighting) =
            orestaty::plugins::syntax_highlighting::SyntaxHighlighting::new(&theme, "".as_ref())
        {
            if let Some(css) = syntax_highlighting.export_theme() {
                let path = output.unwrap_or_else(|| {
                    if theme.ends_with(".light") || theme.ends_with(".dark") {
                        std::path::PathBuf::from(format!("{theme}.css"))
                    } else {
                        std::path::Path::new(&theme).with_extension("css")
                    }
                });
                if let Err(err) = std::fs::write(path, css) {
                    eprintln!("Failed to write theme to a file: {}", err);
                }
            }
        }
        return;
    }

    let config = parse_config(&path.join("config.toml")).unwrap_or_default();
    let mut generator = orestaty::OreStaty::new(config, &path);

    generator.handlebars.set_strict_mode(true);
    generator.register_default_markdown_template();
    generator.register_builtin_plugins();

    let plugin_path = path.join("plugins");
    if plugin_path.exists() {
        generator.sass_options = generator.sass_options.load_path(&plugin_path);
        generator.load_plugins(&plugin_path, "").ok();
    }

    match cli.command {
        Commands::Build => {
            generator.build(&path.join("src"), &dst);
            if path.join("static").exists() {
                generator
                    .unwrap_or_error(
                        orestaty::files::copy_recursively(path.join("static"), &dst),
                        "Failed to copy static files",
                    )
                    .ok();
            }
        }
        _ => unreachable!(),
    }

    // * Check for errors and finish
    if generator.errors() > 0 {
        eprintln!(
            "Build completed with {} {}",
            generator.errors(),
            if generator.errors() == 1 {
                "error"
            } else {
                "errors"
            }
        );
        std::process::exit(1);
    }
}