14316676040

Committed 07 Apr 2025 06:27PM UTC coverage: 74.417% (-0.9%) from 75.283%

Build # 14316676040

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1202 from Blightmud/dependabot/cargo/rustls-0.23.25

build(deps): bump rustls from 0.23.23 to 0.23.25

Run Details

7089 of 9526 relevant lines covered (74.42%)

431.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.15

/src/lua/store.rs

use crate::io::SaveData;
use log::debug;
use mlua::{AnyUserData, FromLua, Result, UserData, UserDataMethods};
use std::{collections::HashMap, path::PathBuf};

impl SaveData for HashMap<String, String> {
    fn relative_path() -> PathBuf {
        PathBuf::from("store/data.ron")
    }
}

#[derive(Clone, FromLua)]
pub struct Store {
    pub memory_storage: HashMap<String, String>,
}

impl Store {
    pub const LUA_GLOBAL_NAME: &'static str = "store";

    pub fn new() -> Self {
        Self {
            memory_storage: HashMap::new(),
        }
    }
}

impl UserData for Store {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_function("session_write", |ctx, (key, val): (String, String)| {
            let store_aud: AnyUserData = ctx.globals().get(Store::LUA_GLOBAL_NAME)?;
            let mut store = store_aud.borrow_mut::<Store>()?;
            store.memory_storage.insert(key, val);
            Ok(())
        });
        methods.add_function(
            "session_read",
            |ctx, key: String| -> Result<Option<String>> {
                let store_aud: AnyUserData = ctx.globals().get(Store::LUA_GLOBAL_NAME)?;
                let store = store_aud.borrow::<Store>()?;
                match store.memory_storage.get(key.as_str()) {
                    Some(val) => Ok(Some(val.to_string())),
                    _ => Ok(None),
                }
            },
        );
        methods.add_function("disk_write", |_ctx, (key, val): (String, String)| {
            debug!("Writing to disk: {} -> {}", key, val);
            let mut persistent_data = HashMap::load();
            persistent_data.insert(key, val);
            persistent_data.save();
            Ok(())
        });
        methods.add_function("disk_read", |_ctx, key: String| -> Result<Option<String>> {
            let persistent_data: HashMap<String, String> = HashMap::load();
            let val = persistent_data.get(key.as_str()).map(|val| val.to_string());
            debug!("Reading from disk: {} -> {:?}", key, val);
            Ok(val)
        });
    }
}

#[cfg(test)]
mod test_store {
    use super::Store;
    use mlua::Lua;

    #[test]
    fn test_memory_storage() {
        let lua = Lua::new();
        let store = Store::new();
        lua.globals().set(Store::LUA_GLOBAL_NAME, store).unwrap();

        lua.load("store.session_write(\"abc\",\"def\")")
            .exec()
            .unwrap();
        let value: String = lua
            .load("return store.session_read(\"abc\")")
            .call(())
            .unwrap();
        assert_eq!("def", value);
    }
}

1	use crate::io::SaveData;
2	use log::debug;
3	use mlua::{AnyUserData, FromLua, Result, UserData, UserDataMethods};
4	use std::{collections::HashMap, path::PathBuf};
5
6	impl SaveData for HashMap<String, String> {
7	fn relative_path() -> PathBuf {	×
8	PathBuf::from("store/data.ron")	×
9	}	×
10	}
11
12	#[derive(Clone, FromLua)]	×
13	pub struct Store {
14	pub memory_storage: HashMap<String, String>,
15	}
16
17	impl Store {
18	pub const LUA_GLOBAL_NAME: &'static str = "store";
19
20	pub fn new() -> Self {	150✔
21	Self {	150✔
22	memory_storage: HashMap::new(),	150✔
23	}	150✔
24	}	150✔
25	}
26
27	impl UserData for Store {
28	fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {	166✔
29	methods.add_function("session_write", \|ctx, (key, val): (String, String)\| {	355✔
30	let store_aud: AnyUserData = ctx.globals().get(Store::LUA_GLOBAL_NAME)?;	299✔
31	let mut store = store_aud.borrow_mut::<Store>()?;	299✔
32	store.memory_storage.insert(key, val);	299✔
33	Ok(())	299✔
34	});	299✔
35	methods.add_function(	166✔
36	"session_read",
37	\|ctx, key: String\| -> Result<Option<String>> {	994✔
38	let store_aud: AnyUserData = ctx.globals().get(Store::LUA_GLOBAL_NAME)?;	994✔
39	let store = store_aud.borrow::<Store>()?;	994✔
40	match store.memory_storage.get(key.as_str()) {	994✔
41	Some(val) => Ok(Some(val.to_string())),	5✔
42	_ => Ok(None),	989✔
43	}
44	},	994✔
45	);
46	methods.add_function("disk_write", \|_ctx, (key, val): (String, String)\| {	166✔
47	debug!("Writing to disk: {} -> {}", key, val);	×
48	let mut persistent_data = HashMap::load();	×
49	persistent_data.insert(key, val);	×
50	persistent_data.save();	×
51	Ok(())	×
52	});	×
53	methods.add_function("disk_read", \|_ctx, key: String\| -> Result<Option<String>> {	166✔
54	let persistent_data: HashMap<String, String> = HashMap::load();	×
55	let val = persistent_data.get(key.as_str()).map(\|val\| val.to_string());	×
56	debug!("Reading from disk: {} -> {:?}", key, val);	×
57	Ok(val)	×
58	});	×
59	}	166✔
60	}
61
62	#[cfg(test)]
63	mod test_store {
64	use super::Store;
65	use mlua::Lua;
66
67	#[test]
68	fn test_memory_storage() {	1✔
69	let lua = Lua::new();	1✔
70	let store = Store::new();	1✔
71	lua.globals().set(Store::LUA_GLOBAL_NAME, store).unwrap();	1✔
72		1✔
73	lua.load("store.session_write(\"abc\",\"def\")")	1✔
74	.exec()	1✔
75	.unwrap();	1✔
76	let value: String = lua	1✔
77	.load("return store.session_read(\"abc\")")	1✔
78	.call(())	1✔
79	.unwrap();	1✔
80	assert_eq!("def", value);	1✔
81	}	1✔
82	}

Blightmud / Blightmud / 14316676040

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous