nvrs 0.1.0

new version checker for software releases 🦀
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

use serde::{Deserialize, Serialize};
use std::{collections::HashMap, fs, io::Write, path::Path};

use crate::config::ConfigTable;

const TEMPLATE: &str = r#"{
  "version": 2,
  "data": {
  }
}
"#;

const CONFIG_NONE_M: &str = "__config__ not specified\nexample:";
const XVER_NONE_M: &str = "oldver & newver not specified\nexample:";
const CONFIG_NONE_E: &str = "\n[__config__]
oldver = \"oldver.json\"
newver = \"newver.json\"";

#[derive(Clone, Serialize, Deserialize)]
pub struct Package {
    pub version: String,
    pub gitref: String,
    pub url: String,
}

#[derive(Clone, Serialize, Deserialize)]
pub struct Data {
    pub data: HashMap<String, Package>,
}

#[derive(Clone, Serialize, Deserialize)]
pub struct Verfile {
    version: u8,
    #[serde(flatten)]
    pub data: Data,
}

pub fn load(config_table: Option<ConfigTable>) -> Option<(Verfile, Verfile)> {
    if config_table.is_none() {
        crate::custom_error(CONFIG_NONE_M, CONFIG_NONE_E.to_string());
    }
    let config_table = config_table.unwrap();

    if config_table.oldver.is_some() && config_table.newver.is_some() {
        let oldver_path = Path::new(config_table.oldver.as_ref().unwrap());
        let newver_path = Path::new(config_table.newver.as_ref().unwrap());
        let oldver = load_file(oldver_path);
        let newver = load_file(newver_path);

        if oldver.version != 2 || newver.version != 2 {
            crate::custom_error(
                "unsupported verfile version",
                "\nplease update your verfiles".to_string(),
            );
        }

        Some((oldver, newver))
    } else {
        crate::custom_error(XVER_NONE_M, CONFIG_NONE_E.to_string());
        None
    }
}

pub fn save(
    verfile: Verfile,
    oldver: bool,
    config_table: Option<ConfigTable>,
) -> Result<(), std::io::Error> {
    let config_table = config_table.unwrap();
    let path = if oldver {
        Path::new(config_table.oldver.as_ref().unwrap())
    } else {
        Path::new(config_table.newver.as_ref().unwrap())
    };

    let mut file = fs::File::create(path).unwrap();
    let content = format!("{}\n", serde_json::to_string_pretty(&verfile).unwrap());
    file.write_all(content.as_bytes())
}

fn load_file(path: &Path) -> Verfile {
    if !path.exists() {
        let mut file = fs::File::create(path).unwrap();
        file.write_all(TEMPLATE.as_bytes()).unwrap();
    }
    let content = fs::read_to_string(path).unwrap();

    serde_json::from_str(&content).expect("failed to read oldver")
}