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

68.92

/src/lua/servers.rs

use crate::io::SaveData;
use crate::model::{Connection, Servers as MServers};
use mlua::{IntoLua, UserData, UserDataMethods};

#[cfg(test)]
use mockall::automock;

pub struct Server {
    name: String,
    connection: Connection,
}

impl UserData for Server {
    fn add_methods<'lua, T: UserDataMethods<'lua, Self>>(methods: &mut T) {
        methods.add_meta_method(
            mlua::MetaMethod::Index,
            |ctx, this, key: String| -> mlua::Result<mlua::Value> {
                match key.as_str() {
                    "name" => Ok(this.name.clone().into_lua(ctx)?),
                    "host" => Ok(this.connection.host.clone().into_lua(ctx)?),
                    "port" => Ok(this.connection.port.into_lua(ctx)?),
                    "tls" => Ok(this.connection.tls.into_lua(ctx)?),
                    "verify_cert" => Ok(this.connection.verify_cert.into_lua(ctx)?),
                    _ => Err(mlua::Error::external(format!("Invalid index: {key}"))),
                }
            },
        );
    }
}

pub struct Servers {}

struct ServerLoader {}

#[cfg_attr(test, automock)]
impl ServerLoader {
    fn get() -> mlua::Result<MServers> {
        if let Ok(servers) = MServers::try_load() {
            Ok(servers)
        } else {
            Err(mlua::Error::external(
                "Unable to read servers.ron from disk".to_string(),
            ))
        }
    }
}

impl UserData for Servers {
    fn add_methods<'lua, T: UserDataMethods<'lua, Self>>(methods: &mut T) {
        methods.add_function(
            "add",
            |_,
             (name, host, port, tls, verify): (String, String, u16, bool, Option<bool>)|
             -> mlua::Result<()> {
                let mut servers = ServerLoader::get()?;

                #[allow(clippy::map_entry)]
                if servers.contains_key(&name) {
                    Err(mlua::Error::external(format!(
                        "Saved server already exists for {name}"
                    )))
                } else {
                    let connection = Connection {
                        host,
                        port,
                        tls,
                        verify_cert: verify.unwrap_or(false),
                    };
                    servers.insert(name, connection);
                    servers.save();
                    Ok(())
                }
            },
        );
        methods.add_function("remove", |_, name: String| -> mlua::Result<()> {
            let mut servers = ServerLoader::get()?;
            if servers.remove(&name).is_some() {
                servers.save();
                Ok(())
            } else {
                Err(mlua::Error::external(format!(
                    "Saved server does not exist: {name}"
                )))
            }
        });
        methods.add_function("get", |_, name: String| -> mlua::Result<Server> {
            let servers = ServerLoader::get()?;
            if servers.contains_key(&name) {
                if let Some(connection) = servers.get(&name) {
                    Ok(Server {
                        name,
                        connection: connection.clone(),
                    })
                } else {
                    Err(mlua::Error::external(format!(
                        "Failed to read server: {name}"
                    )))
                }
            } else {
                Err(mlua::Error::external(format!(
                    "Saved server does not exist: {name}"
                )))
            }
        });
        methods.add_function("get_all", |_, ()| -> mlua::Result<Vec<Server>> {
            let servers = ServerLoader::get()?;
            Ok(servers
                .iter()
                .map(|(name, conn)| Server {
                    name: name.to_string(),
                    connection: conn.clone(),
                })
                .collect())
        });
    }
}

1	use crate::io::SaveData;
2	use crate::model::{Connection, Servers as MServers};
3	use mlua::{IntoLua, UserData, UserDataMethods};
4
5	#[cfg(test)]
6	use mockall::automock;
7
8	pub struct Server {
9	name: String,
10	connection: Connection,
11	}
12
13	impl UserData for Server {
14	fn add_methods<'lua, T: UserDataMethods<'lua, Self>>(methods: &mut T) {	14✔
15	methods.add_meta_method(	14✔
16	mlua::MetaMethod::Index,	14✔
17	\|ctx, this, key: String\| -> mlua::Result<mlua::Value> {	49✔
18	match key.as_str() {	49✔
19	"name" => Ok(this.name.clone().into_lua(ctx)?),	49✔
20	"host" => Ok(this.connection.host.clone().into_lua(ctx)?),	42✔
21	"port" => Ok(this.connection.port.into_lua(ctx)?),	28✔
22	"tls" => Ok(this.connection.tls.into_lua(ctx)?),	14✔
23	"verify_cert" => Ok(this.connection.verify_cert.into_lua(ctx)?),	7✔
24	_ => Err(mlua::Error::external(format!("Invalid index: {key}"))),	×
25	}
26	},	49✔
27	);
28	}	14✔
29	}
30
31	pub struct Servers {}
32
33	struct ServerLoader {}
34
35	#[cfg_attr(test, automock)]	×
36	impl ServerLoader {
37	fn get() -> mlua::Result<MServers> {	63✔
38	if let Ok(servers) = MServers::try_load() {	63✔
39	Ok(servers)	63✔
40	} else {
41	Err(mlua::Error::external(	×
42	"Unable to read servers.ron from disk".to_string(),	×
43	))	×
44	}
45	}	63✔
46	}
47
48	impl UserData for Servers {
49	fn add_methods<'lua, T: UserDataMethods<'lua, Self>>(methods: &mut T) {	165✔
50	methods.add_function(	165✔
51	"add",
52	\|_,
53	(name, host, port, tls, verify): (String, String, u16, bool, Option<bool>)\|
54	-> mlua::Result<()> {	14✔
55	let mut servers = ServerLoader::get()?;	14✔
56
57	#[allow(clippy::map_entry)]
58	if servers.contains_key(&name) {	14✔
59	Err(mlua::Error::external(format!(	×
60	"Saved server already exists for {name}"	×
61	)))	×
62	} else {
63	let connection = Connection {	14✔
64	host,	14✔
65	port,	14✔
66	tls,	14✔
67	verify_cert: verify.unwrap_or(false),	14✔
68	};	14✔
69	servers.insert(name, connection);	14✔
70	servers.save();	14✔
71	Ok(())	14✔
72	}
73	},	14✔
74	);
75	methods.add_function("remove", \|_, name: String\| -> mlua::Result<()> {	165✔
76	let mut servers = ServerLoader::get()?;	14✔
77	if servers.remove(&name).is_some() {	14✔
78	servers.save();	14✔
79	Ok(())	14✔
80	} else {
81	Err(mlua::Error::external(format!(	×
82	"Saved server does not exist: {name}"	×
83	)))	×
84	}
85	});	14✔
86	methods.add_function("get", \|_, name: String\| -> mlua::Result<Server> {	165✔
87	let servers = ServerLoader::get()?;	35✔
88	if servers.contains_key(&name) {	35✔
89	if let Some(connection) = servers.get(&name) {	14✔
90	Ok(Server {	14✔
91	name,	14✔
92	connection: connection.clone(),	14✔
93	})	14✔
94	} else {
95	Err(mlua::Error::external(format!(	×
96	"Failed to read server: {name}"	×
97	)))	×
98	}
99	} else {
100	Err(mlua::Error::external(format!(	21✔
101	"Saved server does not exist: {name}"	21✔
102	)))	21✔
103	}
104	});	35✔
105	methods.add_function("get_all", \|_, ()\| -> mlua::Result<Vec<Server>> {	165✔
106	let servers = ServerLoader::get()?;	×
107	Ok(servers	×
108	.iter()	×
109	.map(\|(name, conn)\| Server {	×
110	name: name.to_string(),	×
111	connection: conn.clone(),	×
112	})	×
113	.collect())	×
114	});	×
115	}	165✔
116	}

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