firefly-toml 0.1.0

Rust macro for statically parsing firefly.toml
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

use proc_macro::TokenStream;
use serde::Deserialize;
use std::collections::HashMap;
use std::{fmt::Write as _, str::FromStr as _};

#[derive(Deserialize, Debug)]
pub struct BoardConfig {
    /// Human-readable board name.
    pub name: String,
}

pub fn write_boards(boards: HashMap<String, BoardConfig>, s: &mut String) {
    if boards.is_empty() {
        return;
    }
    writeln!(s, "mod boards {{").unwrap();
    writeln!(s, "use firefly_rust::{{Peer, add_score, Progress, Board}};").unwrap();
    for (id, board) in boards {
        let name = board.name.replace(' ', "_");
        writeln!(
            s,
            "pub fn {name}(peer: Peer, score: i16) -> i16 {{ add_score(peer, Board({id}), score) }}",
        )
        .unwrap();
    }
    s.push('}');
}

pub fn write_cheats(cheats: HashMap<String, i32>, s: &mut String) {
    if cheats.is_empty() {
        return;
    }
    writeln!(s, "enum Cheats {{").unwrap();
    for (name, id) in &cheats {
        let name = name.replace('-', "_");
        writeln!(s, "{name} = {id},",).unwrap();
    }
    s.push('}');
    writeln!(
        s,
        "impl Cheats {{ fn from_id(id: i32) -> Self {{ match id {{"
    )
    .unwrap();
    for (name, id) in cheats {
        let name = name.replace('-', "_");
        writeln!(s, "{id} => Self::{name},",).unwrap();
    }
    writeln!(s, "_ => unreachable!(),").unwrap();
    writeln!(s, "}} }} }}").unwrap();
}

#[derive(Deserialize, Debug)]
pub struct BadgeConfig {
    /// Human-readable achievement name.
    pub name: String,

    /// Human-readable achievement description. Typically, a hint on how to earn it.
    #[serde(default)]
    pub descr: String,

    /// How many steps there are to earn the badge.
    ///
    /// Defaults to 1.
    pub steps: Option<u16>,
}

pub fn write_badges(badges: HashMap<String, BadgeConfig>, s: &mut String) {
    if badges.is_empty() {
        return;
    }
    writeln!(s, "mod badges {{").unwrap();
    writeln!(
        s,
        "use firefly_rust::{{Badge, Peer, add_progress, Progress, Board}};"
    )
    .unwrap();
    for (id, badge) in badges {
        writeln!(s, "/// {}", badge.descr).unwrap();
        let name = badge.name.replace(' ', "_");
        let (arg, n) = match badge.steps {
            Some(1) | None => ("", "1"),
            Some(_) => ("arg: u32", "arg"),
        };
        writeln!(
            s,
            "pub fn {name}(peer: Peer, {arg}) -> Progress {{ add_progress(peer, Badge({id}), {n}) }}",
        )
        .unwrap();
    }
    s.push('}');
}

#[derive(Deserialize, Debug)]
pub struct Config {
    /// Mapping of cheat commands to their integer representation.
    pub cheats: Option<HashMap<String, i32>>,

    /// Mapping of badge IDs to badges.
    pub badges: Option<HashMap<String, BadgeConfig>>,

    /// Mapping of board IDs to boards.
    pub boards: Option<HashMap<String, BoardConfig>>,
}

pub fn load_config() -> Result<Config, TokenStream> {
    let file = std::fs::read("firefly.toml").map_err(|e| {
        TokenStream::from_str(&format!(
            r##"compile_error!(r#"could not load firefly.toml: {e}"#);"##
        ))
        .unwrap()
    })?;
    toml::from_slice(&file).map_err(|e| {
        TokenStream::from_str(&format!(
            r##"compile_error!(r#"firefly.toml is not valid toml: {e}"#);"##
        ))
        .unwrap()
    })
}