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

6.21

/src/lua/tts.rs

use mlua::{AnyUserData, MetaMethod, UserData, UserDataMethods};

use crate::{event::Event, tts::TTSEvent};

use super::{backend::Backend, constants::BACKEND};

pub struct Tts {
    pub enabled: bool,
}

impl Tts {
    pub fn new(enabled: bool) -> Self {
        Self { enabled }
    }
}

impl UserData for Tts {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_function("is_available", |_, _: ()| Ok(cfg!(feature = "tts")));
        if cfg!(feature = "tts") {
            methods.add_function("speak", |ctx, (msg, interupt): (String, Option<bool>)| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::Speak(msg, interupt.unwrap_or_default()))
                    .unwrap();
                Ok(())
            });
            methods.add_function("speak_direct", |ctx, msg: String| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::SpeakDirect(msg)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("stop", |ctx, _: ()| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend.writer.send(Event::SpeakStop).unwrap();
                Ok(())
            });
            methods.add_function("enable", |ctx, enabled: bool| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend.writer.send(Event::TTSEnabled(enabled)).unwrap();
                Ok(())
            });
            methods.add_function("is_enabled", |ctx, ()| {
                let tts_aud: AnyUserData = ctx.globals().get("tts")?;
                let tts = tts_aud.borrow::<Tts>()?;
                Ok(tts.enabled)
            });
            methods.add_function("set_rate", |ctx, rate: f64| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::SetRate(rate as f32)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("change_rate", |ctx, rate: f64| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::ChangeRate(rate as f32)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("echo_keypresses", |ctx, enabled: bool| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::EchoKeys(enabled)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("step_back", |ctx, step: usize| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::Prev(step)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("step_forward", |ctx, step: usize| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::Next(step)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("scan_back", |ctx, step: usize| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::ScanBack(step)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("scan_forward", |ctx, step: usize| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::ScanForward(step)))
                    .unwrap();
                Ok(())
            });
            methods.add_function("scan_input_back", |ctx, _: ()| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::ScanBackToInput))
                    .unwrap();
                Ok(())
            });
            methods.add_function("scan_input_forward", |ctx, _: ()| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::ScanForwardToInput))
                    .unwrap();
                Ok(())
            });
            methods.add_function("step_begin", |ctx, _: ()| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::TTSEvent(TTSEvent::Begin))
                    .unwrap();
                Ok(())
            });
            methods.add_function("step_end", |ctx, _: ()| {
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend.writer.send(Event::TTSEvent(TTSEvent::End)).unwrap();
                Ok(())
            });
        } else {
            methods.add_meta_function(MetaMethod::Index, |ctx, _: ()| {
                let func: mlua::Function = ctx.load("function () end").eval()?;
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::Error(
                        "Blightmud was not compiled with text-to-speech enabled".to_string(),
                    ))
                    .unwrap();
                Ok(func)
            });
            methods.add_meta_function_mut(MetaMethod::Index, |ctx, _: ()| {
                let func: mlua::Function = ctx.load("function () end").eval()?;
                let backend: Backend = ctx.named_registry_value(BACKEND)?;
                backend
                    .writer
                    .send(Event::Error(
                        "Blightmud was not compiled with text-to-speech enabled".to_string(),
                    ))
                    .unwrap();
                Ok(func)
            });
        }
    }
}

1	use mlua::{AnyUserData, MetaMethod, UserData, UserDataMethods};
2
3	use crate::{event::Event, tts::TTSEvent};
4
5	use super::{backend::Backend, constants::BACKEND};
6
7	pub struct Tts {
8	pub enabled: bool,
9	}
10
11	impl Tts {
12	pub fn new(enabled: bool) -> Self {	165✔
13	Self { enabled }	165✔
14	}	165✔
15	}
16
17	impl UserData for Tts {
18	fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {	165✔
19	methods.add_function("is_available", \|_, _: ()\| Ok(cfg!(feature = "tts")));	165✔
20	if cfg!(feature = "tts") {	165✔
21	methods.add_function("speak", \|ctx, (msg, interupt): (String, Option<bool>)\| {	×
22	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
23	backend	×
24	.writer	×
25	.send(Event::Speak(msg, interupt.unwrap_or_default()))	×
26	.unwrap();	×
27	Ok(())	×
28	});	×
29	methods.add_function("speak_direct", \|ctx, msg: String\| {	×
30	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
31	backend	×
32	.writer	×
33	.send(Event::TTSEvent(TTSEvent::SpeakDirect(msg)))	×
34	.unwrap();	×
35	Ok(())	×
36	});	×
37	methods.add_function("stop", \|ctx, _: ()\| {	×
38	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
39	backend.writer.send(Event::SpeakStop).unwrap();	×
40	Ok(())	×
41	});	×
42	methods.add_function("enable", \|ctx, enabled: bool\| {	×
43	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
44	backend.writer.send(Event::TTSEnabled(enabled)).unwrap();	×
45	Ok(())	×
46	});	×
47	methods.add_function("is_enabled", \|ctx, ()\| {	×
48	let tts_aud: AnyUserData = ctx.globals().get("tts")?;	×
49	let tts = tts_aud.borrow::<Tts>()?;	×
50	Ok(tts.enabled)	×
51	});	×
52	methods.add_function("set_rate", \|ctx, rate: f64\| {	×
53	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
54	backend	×
55	.writer	×
56	.send(Event::TTSEvent(TTSEvent::SetRate(rate as f32)))	×
57	.unwrap();	×
58	Ok(())	×
59	});	×
60	methods.add_function("change_rate", \|ctx, rate: f64\| {	×
61	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
62	backend	×
63	.writer	×
64	.send(Event::TTSEvent(TTSEvent::ChangeRate(rate as f32)))	×
65	.unwrap();	×
66	Ok(())	×
67	});	×
68	methods.add_function("echo_keypresses", \|ctx, enabled: bool\| {	×
69	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
70	backend	×
71	.writer	×
72	.send(Event::TTSEvent(TTSEvent::EchoKeys(enabled)))	×
73	.unwrap();	×
74	Ok(())	×
75	});	×
76	methods.add_function("step_back", \|ctx, step: usize\| {	×
77	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
78	backend	×
79	.writer	×
80	.send(Event::TTSEvent(TTSEvent::Prev(step)))	×
81	.unwrap();	×
82	Ok(())	×
83	});	×
84	methods.add_function("step_forward", \|ctx, step: usize\| {	×
85	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
86	backend	×
87	.writer	×
88	.send(Event::TTSEvent(TTSEvent::Next(step)))	×
89	.unwrap();	×
90	Ok(())	×
91	});	×
92	methods.add_function("scan_back", \|ctx, step: usize\| {	×
93	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
94	backend	×
95	.writer	×
96	.send(Event::TTSEvent(TTSEvent::ScanBack(step)))	×
97	.unwrap();	×
98	Ok(())	×
99	});	×
100	methods.add_function("scan_forward", \|ctx, step: usize\| {	×
101	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
102	backend	×
103	.writer	×
104	.send(Event::TTSEvent(TTSEvent::ScanForward(step)))	×
105	.unwrap();	×
106	Ok(())	×
107	});	×
108	methods.add_function("scan_input_back", \|ctx, _: ()\| {	×
109	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
110	backend	×
111	.writer	×
112	.send(Event::TTSEvent(TTSEvent::ScanBackToInput))	×
113	.unwrap();	×
114	Ok(())	×
115	});	×
116	methods.add_function("scan_input_forward", \|ctx, _: ()\| {	×
117	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
118	backend	×
119	.writer	×
120	.send(Event::TTSEvent(TTSEvent::ScanForwardToInput))	×
121	.unwrap();	×
122	Ok(())	×
123	});	×
124	methods.add_function("step_begin", \|ctx, _: ()\| {	×
125	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
126	backend	×
127	.writer	×
128	.send(Event::TTSEvent(TTSEvent::Begin))	×
129	.unwrap();	×
130	Ok(())	×
131	});	×
132	methods.add_function("step_end", \|ctx, _: ()\| {	×
133	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
134	backend.writer.send(Event::TTSEvent(TTSEvent::End)).unwrap();	×
135	Ok(())	×
136	});	×
137	} else {
138	methods.add_meta_function(MetaMethod::Index, \|ctx, _: ()\| {	165✔
139	let func: mlua::Function = ctx.load("function () end").eval()?;	×
140	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
141	backend	×
142	.writer	×
143	.send(Event::Error(	×
144	"Blightmud was not compiled with text-to-speech enabled".to_string(),	×
145	))	×
146	.unwrap();	×
147	Ok(func)	×
148	});	×
149	methods.add_meta_function_mut(MetaMethod::Index, \|ctx, _: ()\| {	165✔
150	let func: mlua::Function = ctx.load("function () end").eval()?;	×
151	let backend: Backend = ctx.named_registry_value(BACKEND)?;	×
152	backend	×
153	.writer	×
154	.send(Event::Error(	×
155	"Blightmud was not compiled with text-to-speech enabled".to_string(),	×
156	))	×
157	.unwrap();	×
158	Ok(func)	×
159	});	×
160	}
161	}	165✔
162	}

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