22147789116

Committed 09 Feb 2026 04:20PM UTC coverage: 77.303% (+4.8%) from 72.482%

Build # 22147789116

Build Type

push

github

Committed by

hasezoey

Commit Message

refactor(table): switch to use "CommonProps"

Coverage Stats

18 of 90 new or added lines in 1 file covered. (20.0%)

405 existing lines in 20 files now uncovered.

3944 of 5102 relevant lines covered (77.3%)

4.92 hits per line

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

61.11

/src/components/span.rs

use tuirealm::command::{Cmd, CmdResult};
use tuirealm::props::{
    AttrValue, Attribute, Color, HorizontalAlignment, PropPayload, PropValue, Props, SpanStatic,
    Style, TextModifiers,
};
use tuirealm::ratatui::{
    layout::Rect,
    text::{Line, Span as RSpan, Text},
    widgets::Paragraph,
};
use tuirealm::{Frame, MockComponent, State};

use crate::prop_ext::CommonProps;
use crate::utils;

/// A Span represents single-line, multi-style text, without any container support.
///
/// If single-style text is wanted, use [`Label`](super::Label).
/// If multi-style, mutli-line, with container support is wanted, use [`Paragraph`](super::Paragraph).
#[derive(Default)]
#[must_use]
pub struct Span {
    common: CommonProps,
    props: Props,
}

impl Span {
    /// Set the main foreground color. This may get overwritten by individual text styles.
    pub fn foreground(mut self, fg: Color) -> Self {
        self.attr(Attribute::Foreground, AttrValue::Color(fg));
        self
    }

    /// Set the main background color. This may get overwritten by individual text styles.
    pub fn background(mut self, bg: Color) -> Self {
        self.attr(Attribute::Background, AttrValue::Color(bg));
        self
    }

    /// Set the main text modifiers. This may get overwritten by individual text styles.
    pub fn modifiers(mut self, m: TextModifiers) -> Self {
        self.attr(Attribute::TextProps, AttrValue::TextModifiers(m));
        self
    }

    /// Set the main style. This may get overwritten by individual text styles.
    ///
    /// This option will overwrite any previous [`foreground`](Self::foreground), [`background`](Self::background) and [`modifiers`](Self::modifiers)!
    pub fn style(mut self, style: Style) -> Self {
        self.attr(Attribute::Style, AttrValue::Style(style));
        self
    }

    /// Set the horizontal text alignment.
    pub fn alignment_horizontal(mut self, a: HorizontalAlignment) -> Self {
        self.attr(
            Attribute::AlignmentHorizontal,
            AttrValue::AlignmentHorizontal(a),
        );
        self
    }

    /// Set the Text content.
    pub fn spans<T>(mut self, s: impl IntoIterator<Item = T>) -> Self
    where
        T: Into<SpanStatic>,
    {
        self.attr(
            Attribute::Text,
            AttrValue::Payload(PropPayload::Vec(
                s.into_iter()
                    .map(Into::into)
                    .map(PropValue::TextSpan)
                    .collect(),
            )),
        );
        self
    }
}

impl MockComponent for Span {
    fn view(&mut self, render: &mut Frame, area: Rect) {
        if !self.common.display {
            return;
        }

        // Make text
        // binding required as "spans" is a reference and otherwise would not live long enough
        let payload = self
            .props
            .get_ref(Attribute::Text)
            .and_then(|x| x.as_payload());
        let text = match payload {
            Some(PropPayload::Vec(lines)) => {
                let lines: Vec<RSpan> = lines
                    .iter()
                    // this will skip any "PropValue" that is not a "TextSpan", instead of panicing
                    .filter_map(|x| x.as_textspan())
                    .map(utils::borrow_clone_span)
                    .collect();
                Text::from(Line::from(lines))
            }
            _ => Text::default(),
        };
        // Text properties
        let alignment: HorizontalAlignment = self
            .props
            .get_or(
                Attribute::AlignmentHorizontal,
                AttrValue::AlignmentHorizontal(HorizontalAlignment::Left),
            )
            .unwrap_alignment_horizontal();
        render.render_widget(
            Paragraph::new(text)
                .alignment(alignment)
                .style(self.common.style),
            area,
        );
    }

    fn query(&self, attr: Attribute) -> Option<AttrValue> {
        if let Some(value) = self.common.get(attr) {
            return Some(value);
        }

        self.props.get(attr)
    }

    fn attr(&mut self, attr: Attribute, value: AttrValue) {
        if let Some(value) = self.common.set(attr, value) {
            self.props.set(attr, value);
        }
    }

    fn state(&self) -> State {
        State::None
    }

    fn perform(&mut self, _cmd: Cmd) -> CmdResult {
        CmdResult::None
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    use pretty_assertions::assert_eq;
    use tuirealm::{props::SpanStatic, ratatui::style::Stylize};

    #[test]
    fn test_components_span() {
        let component = Span::default()
            .background(Color::Blue)
            .foreground(Color::Red)
            .modifiers(TextModifiers::BOLD)
            .alignment_horizontal(HorizontalAlignment::Center)
            .spans([
                SpanStatic::from("Press "),
                SpanStatic::from("<ESC>").fg(Color::Cyan).bold(),
                SpanStatic::from(" to quit"),
            ]);
        // Get value
        assert_eq!(component.state(), State::None);
    }

    #[test]
    fn various_spans_types() {
        // Vec
        let _ = Span::default().spans(vec![SpanStatic::raw("hello")]);
        // static array
        let _ = Span::default().spans([SpanStatic::raw("hello")]);
        // boxed array
        let _ = Span::default().spans(vec![SpanStatic::raw("hello")].into_boxed_slice());
        // already a iterator
        let _ = Span::default().spans(["Hello"].map(SpanStatic::raw));
    }
}

1	use tuirealm::command::{Cmd, CmdResult};
2	use tuirealm::props::{
3	AttrValue, Attribute, Color, HorizontalAlignment, PropPayload, PropValue, Props, SpanStatic,
4	Style, TextModifiers,
5	};
6	use tuirealm::ratatui::{
7	layout::Rect,
8	text::{Line, Span as RSpan, Text},
9	widgets::Paragraph,
10	};
11	use tuirealm::{Frame, MockComponent, State};
12
13	use crate::prop_ext::CommonProps;
14	use crate::utils;
15
16	/// A Span represents single-line, multi-style text, without any container support.
17	///
18	/// If single-style text is wanted, use [`Label`](super::Label).
19	/// If multi-style, mutli-line, with container support is wanted, use [`Paragraph`](super::Paragraph).
20	#[derive(Default)]
21	#[must_use]
22	pub struct Span {
23	common: CommonProps,
24	props: Props,
25	}
26
27	impl Span {
28	/// Set the main foreground color. This may get overwritten by individual text styles.
29	pub fn foreground(mut self, fg: Color) -> Self {	2✔
30	self.attr(Attribute::Foreground, AttrValue::Color(fg));	2✔
31	self	2✔
32	}	2✔
33
34	/// Set the main background color. This may get overwritten by individual text styles.
35	pub fn background(mut self, bg: Color) -> Self {	2✔
36	self.attr(Attribute::Background, AttrValue::Color(bg));	2✔
37	self	2✔
38	}	2✔
39
40	/// Set the main text modifiers. This may get overwritten by individual text styles.
41	pub fn modifiers(mut self, m: TextModifiers) -> Self {	2✔
42	self.attr(Attribute::TextProps, AttrValue::TextModifiers(m));	2✔
43	self	2✔
44	}	2✔
45
46	/// Set the main style. This may get overwritten by individual text styles.
47	///
48	/// This option will overwrite any previous [`foreground`](Self::foreground), [`background`](Self::background) and [`modifiers`](Self::modifiers)!
UNCOV 49	pub fn style(mut self, style: Style) -> Self {	×
UNCOV 50	self.attr(Attribute::Style, AttrValue::Style(style));	×
UNCOV 51	self	×
UNCOV 52	}	×
53
54	/// Set the horizontal text alignment.
55	pub fn alignment_horizontal(mut self, a: HorizontalAlignment) -> Self {	2✔
56	self.attr(	2✔
57	Attribute::AlignmentHorizontal,	2✔
58	AttrValue::AlignmentHorizontal(a),	2✔
59	);	1✔
60	self	2✔
61	}	2✔
62
63	/// Set the Text content.
64	pub fn spans<T>(mut self, s: impl IntoIterator<Item = T>) -> Self	10✔
65	where	10✔
66	T: Into<SpanStatic>,	10✔
67	{	5✔
68	self.attr(	10✔
69	Attribute::Text,	10✔
70	AttrValue::Payload(PropPayload::Vec(	10✔
71	s.into_iter()	10✔
72	.map(Into::into)	10✔
73	.map(PropValue::TextSpan)	10✔
74	.collect(),	10✔
75	)),	10✔
76	);	5✔
77	self	10✔
78	}	10✔
79	}
80
81	impl MockComponent for Span {
82	fn view(&mut self, render: &mut Frame, area: Rect) {	×
83	if !self.common.display {	×
84	return;	×
UNCOV 85	}	×
86
87	// Make text
88	// binding required as "spans" is a reference and otherwise would not live long enough
89	let payload = self	×
90	.props	×
91	.get_ref(Attribute::Text)	×
92	.and_then(\|x\| x.as_payload());	×
93	let text = match payload {	×
UNCOV 94	Some(PropPayload::Vec(lines)) => {	×
95	let lines: Vec<RSpan> = lines	×
96	.iter()	×
97	// this will skip any "PropValue" that is not a "TextSpan", instead of panicing
98	.filter_map(\|x\| x.as_textspan())	×
UNCOV 99	.map(utils::borrow_clone_span)	×
100	.collect();	×
UNCOV 101	Text::from(Line::from(lines))	×
102	}
103	_ => Text::default(),	×
104	};
105	// Text properties
106	let alignment: HorizontalAlignment = self	×
107	.props	×
UNCOV 108	.get_or(	×
109	Attribute::AlignmentHorizontal,	×
110	AttrValue::AlignmentHorizontal(HorizontalAlignment::Left),	×
111	)
112	.unwrap_alignment_horizontal();	×
113	render.render_widget(	×
114	Paragraph::new(text)	×
UNCOV 115	.alignment(alignment)	×
116	.style(self.common.style),	×
117	area,	×
118	);
119	}	×
120
121	fn query(&self, attr: Attribute) -> Option<AttrValue> {	×
UNCOV 122	if let Some(value) = self.common.get(attr) {	×
UNCOV 123	return Some(value);	×
UNCOV 124	}	×
125
UNCOV 126	self.props.get(attr)	×
UNCOV 127	}	×
128
129	fn attr(&mut self, attr: Attribute, value: AttrValue) {	18✔
130	if let Some(value) = self.common.set(attr, value) {	18✔
131	self.props.set(attr, value);	12✔
132	}	12✔
133	}	18✔
134
135	fn state(&self) -> State {	2✔
136	State::None	2✔
137	}	2✔
138
UNCOV 139	fn perform(&mut self, _cmd: Cmd) -> CmdResult {	×
UNCOV 140	CmdResult::None	×
UNCOV 141	}	×
142	}
143
144	#[cfg(test)]
145	mod tests {
146
147	use super::*;
148
149	use pretty_assertions::assert_eq;
150	use tuirealm::{props::SpanStatic, ratatui::style::Stylize};
151
152	#[test]
153	fn test_components_span() {	2✔
154	let component = Span::default()	2✔
155	.background(Color::Blue)	2✔
156	.foreground(Color::Red)	2✔
157	.modifiers(TextModifiers::BOLD)	2✔
158	.alignment_horizontal(HorizontalAlignment::Center)	2✔
159	.spans([	2✔
160	SpanStatic::from("Press "),	2✔
161	SpanStatic::from("<ESC>").fg(Color::Cyan).bold(),	2✔
162	SpanStatic::from(" to quit"),	2✔
163	]);	2✔
164	// Get value	1✔
165	assert_eq!(component.state(), State::None);	2✔
166	}	2✔
167
168	#[test]
169	fn various_spans_types() {	2✔
170	// Vec	1✔
171	let _ = Span::default().spans(vec![SpanStatic::raw("hello")]);	2✔
172	// static array	1✔
173	let _ = Span::default().spans([SpanStatic::raw("hello")]);	2✔
174	// boxed array	1✔
175	let _ = Span::default().spans(vec![SpanStatic::raw("hello")].into_boxed_slice());	2✔
176	// already a iterator	1✔
177	let _ = Span::default().spans(["Hello"].map(SpanStatic::raw));	2✔
178	}	2✔
179	}

veeso / tui-realm-stdlib / 22147789116

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