20413729334

Committed 21 Dec 2025 06:03PM UTC coverage: 69.86% (-0.3%) from 70.169%

Build # 20413729334

Build Type

Pull #46

github

Committed by

web-flow

Commit Message

Merge e5d91f732 into 9528c3045

Pull Request Pull Request #46: Apply changes for core `TextSpan` changes

Run Details

221 of 271 new or added lines in 6 files covered. (81.55%)

3 existing lines in 2 files now uncovered.

3187 of 4562 relevant lines covered (69.86%)

2.14 hits per line

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

57.45

/src/components/span.rs

//! ## Span
//!
//! `Span` represents a read-only text component without any container, but with the possibility to define multiple text parts.
//! The main difference with `Label` is that the Span allows different styles inside the same component for the texsts.

use tuirealm::command::{Cmd, CmdResult};
use tuirealm::props::{
    Alignment, AttrValue, Attribute, Color, 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::utils;

// -- Component

/// ## Span
///
/// Represents a read-only, single-line text component without any container, but with multi-style text parts
#[derive(Default)]
#[must_use]
pub struct Span {
    props: Props,
}

impl Span {
    pub fn foreground(mut self, fg: Color) -> Self {
        self.attr(Attribute::Foreground, AttrValue::Color(fg));
        self
    }

    pub fn background(mut self, bg: Color) -> Self {
        self.attr(Attribute::Background, AttrValue::Color(bg));
        self
    }

    pub fn modifiers(mut self, m: TextModifiers) -> Self {
        self.attr(Attribute::TextProps, AttrValue::TextModifiers(m));
        self
    }

    pub fn alignment(mut self, a: Alignment) -> Self {
        self.attr(Attribute::Alignment, AttrValue::Alignment(a));
        self
    }

    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) {
        // Make a Span
        if self.props.get_or(Attribute::Display, AttrValue::Flag(true)) == AttrValue::Flag(true) {
            // Make text
            let foreground = self
                .props
                .get_or(Attribute::Foreground, AttrValue::Color(Color::Reset))
                .unwrap_color();
            let background = self
                .props
                .get_or(Attribute::Background, AttrValue::Color(Color::Reset))
                .unwrap_color();
            // 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: Alignment = self
                .props
                .get_or(Attribute::Alignment, AttrValue::Alignment(Alignment::Left))
                .unwrap_alignment();
            render.render_widget(
                Paragraph::new(text)
                    .alignment(alignment)
                    .style(Style::default().bg(background).fg(foreground)),
                area,
            );
        }
    }

    fn query(&self, attr: Attribute) -> Option<AttrValue> {
        self.props.get(attr)
    }

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

veeso / tui-realm-stdlib / 20413729334

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