kuma-client 1.0.0

Rust wrapper for the Uptime Kuma Socket.IO API
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

use serde::{Deserialize, Serialize};
use std::{env, fs::File, io::Write, path::Path};

#[derive(Serialize, Deserialize)]
struct TimeZoneInfo {
    #[serde(rename = "tzCode")]
    pub tz_code: String,
    pub label: String,
    pub name: String,
    pub utc: String,
}

fn generate_timezones() {
    let out_dir = env::var_os("OUT_DIR").unwrap();
    let dest_path = Path::new(&out_dir).join("timezones.rs");

    let timezones: Vec<TimeZoneInfo> =
        serde_json::from_reader(std::fs::File::open("timezones.json").unwrap()).unwrap();

    let mut file = File::create(&dest_path).unwrap();

    writeln!(file, "#[derive(Clone, Debug, PartialEq, Eq)]").unwrap();
    writeln!(file, "#[allow(non_camel_case_types)]").unwrap();
    writeln!(file, "pub enum TimeZone {{").unwrap();

    for tz in &timezones {
        writeln!(
            file,
            "  {},",
            tz.tz_code.replace("/", "_").replace("-", "_")
        )
        .unwrap();
    }

    writeln!(file, "}}").unwrap();

    writeln!(file, "impl TimeZone {{").unwrap();

    let props: &[(&str, Box<dyn Fn(&TimeZoneInfo) -> String>)] = &[
        (
            "identifier",
            Box::new(|tz: &TimeZoneInfo| tz.tz_code.to_owned()),
        ),
        ("name", Box::new(|tz: &TimeZoneInfo| tz.name.to_owned())),
        ("label", Box::new(|tz: &TimeZoneInfo| tz.label.to_owned())),
        (
            "utc_offset",
            Box::new(|tz: &TimeZoneInfo| tz.utc.to_owned()),
        ),
    ];

    for prop in props {
        writeln!(file, "  pub fn {}(&self) -> &str {{", prop.0).unwrap();
        writeln!(file, "    match self {{").unwrap();

        for tz in &timezones {
            writeln!(
                file,
                "      TimeZone::{} => r#\"{}\"#,",
                tz.tz_code.replace("/", "_").replace("-", "_"),
                prop.1(tz)
            )
            .unwrap();
        }

        writeln!(file, "    }}").unwrap();
        writeln!(file, "  }}").unwrap();
    }

    writeln!(
        file,
        "  pub fn from_str(identifier: impl AsRef<str>) -> Option<Self> {{"
    )
    .unwrap();
    writeln!(file, "    match identifier.as_ref() {{").unwrap();

    for tz in &timezones {
        writeln!(
            file,
            "      r#\"{}\"# => Some(TimeZone::{}),",
            tz.tz_code,
            tz.tz_code.replace("/", "_").replace("-", "_"),
        )
        .unwrap();
    }
    writeln!(file, "      _ => None,",).unwrap();

    writeln!(file, "    }}").unwrap();
    writeln!(file, "  }}").unwrap();

    writeln!(file, "}}").unwrap();
    println!("cargo:rerun-if-changed=timezones.rs");
}

fn main() {
    println!("cargo:rerun-if-changed=build.rs");

    generate_timezones();

    shadow_rs::ShadowBuilder::builder().build().unwrap();
}