cobalt-bin 0.20.4

Static site generator written in Rust
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

use crate::args;
use crate::error::Result;
#[cfg(feature = "syntax-highlight")]
use std::path::PathBuf;

/// Print site debug information
#[derive(Clone, Debug, PartialEq, Eq, clap::Subcommand)]
pub(crate) enum DebugCommands {
    /// Prints post-processed config
    Config {
        #[command(flatten, next_help_heading = "Config")]
        config: args::ConfigArgs,
    },

    /// Print syntax-highlight information
    #[command(subcommand)]
    Highlight(HighlightCommands),

    /// Print files associated with a collection
    Files {
        /// Collection name
        collection: Option<String>,

        #[command(flatten, next_help_heading = "Config")]
        config: args::ConfigArgs,
    },
}

#[derive(Clone, Debug, PartialEq, Eq, clap::Subcommand)]
pub(crate) enum HighlightCommands {
    Themes {
        #[command(flatten, next_help_heading = "Config")]
        config: args::ConfigArgs,
    },
    Syntaxes {
        #[command(flatten, next_help_heading = "Config")]
        config: args::ConfigArgs,
    },

    /// Save the css file for a theme
    #[cfg(feature = "syntax-highlight")]
    SaveThemeCss {
        #[command(flatten, next_help_heading = "Config")]
        config: args::ConfigArgs,

        /// Name of the theme to generate a css file for
        name: String,

        /// Path of the css file
        path: PathBuf,
    },
}

impl DebugCommands {
    pub(crate) fn run(&self) -> Result<()> {
        match self {
            Self::Config { config } => {
                let config = config.load_config()?;
                let config = cobalt::cobalt_model::Config::from_config(config)?;
                println!("{config}");
            }
            Self::Highlight(HighlightCommands::Themes { config }) => {
                let config = config.load_config()?;
                let config = cobalt::cobalt_model::Config::from_config(config)?;
                for name in config.syntax.themes() {
                    println!("{name}");
                }
            }
            Self::Highlight(HighlightCommands::Syntaxes { config }) => {
                let config = config.load_config()?;
                let config = cobalt::cobalt_model::Config::from_config(config)?;
                for name in config.syntax.syntaxes() {
                    println!("{name}");
                }
            }
            #[cfg(feature = "syntax-highlight")]
            Self::Highlight(HighlightCommands::SaveThemeCss { config, name, path }) => {
                let config = config.load_config()?;
                let config = cobalt::cobalt_model::Config::from_config(config)?;
                if name == engarde::Syntax::css_theme_name() || !config.syntax.has_theme(name) {
                    return Err(anyhow::anyhow!("Unknown theme: {name}"));
                }

                let css = config.syntax.css_for_theme(name);

                std::fs::write(path, css)?;

                println!(
                    "CSS theme '{name}' successfully saved to: {}",
                    path.display()
                );
            }
            Self::Files { collection, config } => {
                let config = config.load_config()?;
                let config = cobalt::cobalt_model::Config::from_config(config)?;

                match collection.as_deref() {
                    Some("assets") => {
                        anyhow::bail!("TODO Re-implement");
                    }
                    Some("pages") => {
                        anyhow::bail!("TODO Re-implement");
                    }
                    Some("posts") => {
                        anyhow::bail!("TODO Re-implement");
                    }
                    None => {
                        let source_files = cobalt_core::Source::new(
                            &config.source,
                            config.ignore.iter().map(|s| s.as_str()),
                        )?;
                        for path in source_files.iter() {
                            println!("{}", path.rel_path);
                        }
                    }
                    _ => {
                        anyhow::bail!("Collection is not yet supported");
                    }
                }
            }
        }

        Ok(())
    }
}