jampack 1.0.0

Lightweight, asynchronous and extensible asset framework made for use in games and apps.
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

use crate::fs;
use crate::util;
use std::collections::HashMap;
use sha1::{Sha1, Digest};

/// Utility for handling JamPack.lock files
pub(crate) struct Lock {
    files: HashMap<String, String>,
}

impl Lock {
    pub async fn load() -> Self {
        match fs::exists("./JamPack.lock").await {
            false => Self::create_with_defaults().await,
            true => Self::load_from_file(
                String::from_utf8(fs::read_to_bytes("./JamPack.lock").await.unwrap()).unwrap()
            ).await,
        }
    }

    pub async fn save(self) {
        let mut file = DEFAULT_LOCK.to_owned();

        for (path, hash) in self.files {
            file += "\n";
            file += path.as_str();
            file += "\n";
            file += hash.as_str();
        }

        fs::save("./JamPack.lock", file.as_bytes().to_vec()).await
    }

    async fn load_from_file(file: impl Into<String>) -> Self {
        let file = file.into();
        let lines: Vec<&str> = file.split("\n").collect();

        let mut files: HashMap<String, String> = HashMap::new();
        let mut cur_path: Option<String> = None;
        for line in lines {
            if line.starts_with("#") { continue; }
            match cur_path {
                // Add file to list
                Some(p) => {
                    let _ = files.insert(p, line.to_owned());
                    cur_path = None;
                },
                // Set current path to line
                None => cur_path = Some(line.to_owned()),
            }
        }

        Self {
            files,
        }
    }

    async fn create_with_defaults() -> Self {
        fs::save(
            "./JamPack.lock",
            DEFAULT_LOCK.as_bytes().to_vec(),
        ).await;

        Self {
            files: HashMap::new(),
        }
    }

    pub fn set_file(&mut self, path: impl Into<String>, hash: String) {
        let path = path.into();
        let _ = self.files.insert(path, hash);
    }
    pub fn remove_file(&mut self, path: impl Into<String>) {
        let path = path.into();
        let _ = self.files.remove(&path);
    }
    pub fn get_file(&self, path: impl Into<String>) -> Option<String> {
        let path = path.into();
        match self.files.get(&path) {
            Some(f) => Some(f.clone()),
            None => None,
        }
    }
    pub fn files(&self) -> Vec<String> {
        let mut files: Vec<String> = Vec::new();
        for file in self.files.keys() {
            files.push(file.clone());
        }
        files
    }

    pub fn gen_hash(data: &Vec<u8>) -> String {
        let mut hasher = Sha1::new();
        hasher.update(data);
        
        let mut hash = String::new();
        for n in hasher.finalize().iter() {
            hash += util::u8_to_string(*n).as_str();
        }
        hash
    }
}

const DEFAULT_LOCK: &str = include_str!("./Default.lock");