mdbook-plotly 0.3.0-alpha

A mdbook preprocessor that renders plot code blocks (e.g., ```plot) into interactive or static charts during book build.
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

use clap::{Arg, Command, command, error::ErrorKind};

#[derive(Debug)]
pub enum CommandKind {
    Supports {
        renderer: String,
    },
    ProcessBook,
    #[cfg(feature = "tui")]
    Tui {
        dry_run: bool,
        refresh: bool,
        no_effects: bool,
    },
    /// The binary was built without the `tui` feature; the subcommand is
    /// recognized but not implemented.
    #[cfg(not(feature = "tui"))]
    TuiNotAvailable,
}

#[derive(Debug)]
pub(crate) struct ReceivedArgs {
    pub command: CommandKind,
}

impl ReceivedArgs {
    pub(crate) fn receive() -> Result<Self, clap::Error> {
        let matches = make_app().get_matches();

        let command = match matches.subcommand() {
            Some(("supports", sub_m)) => {
                let renderer = sub_m
                    .get_one::<String>("renderer")
                    .unwrap_or_else(|| {
                        // SAFETY: `renderer` is required and thus always present
                        unreachable!()
                    })
                    .to_string();
                CommandKind::Supports { renderer }
            }
            #[cfg(feature = "tui")]
            Some(("tui", sub_m)) => CommandKind::Tui {
                dry_run: sub_m.get_flag("dry-run"),
                refresh: sub_m.get_flag("refresh"),
                no_effects: sub_m.get_flag("no-effects"),
            },
            #[cfg(not(feature = "tui"))]
            Some(("tui", _)) => CommandKind::TuiNotAvailable,
            None => CommandKind::ProcessBook,
            _ => {
                return Err(clap::Error::raw(
                    ErrorKind::InvalidSubcommand,
                    "Unknown subcommand",
                ));
            }
        };

        Ok(ReceivedArgs { command })
    }
}

fn make_app() -> Command {
    let tui = Command::new("tui")
        .about("Interactive tools: self-update, book.toml editor, plot cheat-sheet");
    #[cfg(feature = "tui")]
    let tui = tui
        .arg(
            Arg::new("dry-run")
                .long("dry-run")
                .action(clap::ArgAction::SetTrue)
                .help("Check for updates without downloading or replacing anything"),
        )
        .arg(
            Arg::new("refresh")
                .long("refresh")
                .action(clap::ArgAction::SetTrue)
                .help("Force a refresh of the cached cheat-sheet document"),
        )
        .arg(
            Arg::new("no-effects")
                .long("no-effects")
                .action(clap::ArgAction::SetTrue)
                .help("Disable transition animations"),
        );

    command!()
        .subcommand(
            Command::new("supports")
                .arg(
                    Arg::new("renderer")
                        .required(true)
                        .help("The renderer to check support for"),
                )
                .about("Check whether a renderer is supported by this preprocessor"),
        )
        .subcommand(tui)
}