#![forbid(unsafe_code)]
use crate::block::{Alignment, Block};
use crate::measurable::{MeasurableWidget, SizeConstraints};
use crate::{Widget, clear_text_area, draw_text_span_scrolled, draw_text_span_with_link};
use ahash::AHashMap;
use ftui_core::geometry::{Rect, Size};
use ftui_render::frame::Frame;
use ftui_style::Style;
use ftui_text::{Line, Span, Text as FtuiText, WrapMode, display_width, graphemes};
use std::cell::RefCell;
use std::collections::VecDeque;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::sync::Arc;
type Text = FtuiText<'static>;
const PARAGRAPH_METRICS_CACHE_CAPACITY: usize = 256;
const PARAGRAPH_WRAP_CACHE_CAPACITY: usize = 256;
#[derive(Debug, Clone)]
struct CachedParagraphMetrics {
text_width: usize,
text_height: usize,
min_width: usize,
widest_grapheme: usize,
min_width_computed: bool,
line_widths: Arc<[usize]>,
}
#[derive(Debug, Clone)]
struct CachedWrappedParagraph {
lines: Arc<[Line<'static>]>,
line_widths: Arc<[usize]>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct ParagraphWrapCacheKey {
text_hash: u64,
wrap_mode: WrapMode,
width: usize,
}
#[derive(Debug, Default)]
struct ParagraphCacheState {
metrics: AHashMap<u64, CachedParagraphMetrics>,
metrics_fifo: VecDeque<u64>,
wrapped: AHashMap<ParagraphWrapCacheKey, CachedWrappedParagraph>,
wrapped_fifo: VecDeque<ParagraphWrapCacheKey>,
}
impl ParagraphCacheState {
fn insert_metrics(&mut self, key: u64, value: CachedParagraphMetrics) {
cache_insert(
&mut self.metrics,
&mut self.metrics_fifo,
PARAGRAPH_METRICS_CACHE_CAPACITY,
key,
value,
);
}
fn insert_wrapped(&mut self, key: ParagraphWrapCacheKey, value: CachedWrappedParagraph) {
cache_insert(
&mut self.wrapped,
&mut self.wrapped_fifo,
PARAGRAPH_WRAP_CACHE_CAPACITY,
key,
value,
);
}
}
thread_local! {
static PARAGRAPH_CACHE: RefCell<ParagraphCacheState> = RefCell::new(ParagraphCacheState::default());
}
fn cache_insert<K, V>(
map: &mut AHashMap<K, V>,
fifo: &mut VecDeque<K>,
capacity: usize,
key: K,
value: V,
) where
K: Copy + Eq + Hash,
{
if !map.contains_key(&key) {
if map.len() >= capacity
&& let Some(oldest) = fifo.pop_front()
{
map.remove(&oldest);
}
fifo.push_back(key);
}
map.insert(key, value);
}
fn text_into_owned(text: FtuiText<'_>) -> FtuiText<'static> {
FtuiText::from_lines(
text.into_iter()
.map(|line| Line::from_spans(line.into_iter().map(Span::into_owned))),
)
}
#[derive(Debug, Clone, Default)]
pub struct Paragraph<'a> {
text: Text,
block: Option<Block<'a>>,
style: Style,
wrap: Option<WrapMode>,
alignment: Option<Alignment>,
scroll: (u16, u16),
}
fn hash_value<T: Hash>(value: &T) -> u64 {
let mut hasher = DefaultHasher::new();
value.hash(&mut hasher);
hasher.finish()
}
fn line_min_width(line: &Line<'_>) -> usize {
let mut max_word_width = 0;
let mut current_word_width = 0;
for span in line.spans() {
for grapheme in graphemes(span.content.as_ref()) {
let grapheme_width = display_width(grapheme);
if grapheme.chars().all(char::is_whitespace) {
max_word_width = max_word_width.max(current_word_width);
current_word_width = 0;
} else {
current_word_width += grapheme_width;
}
}
}
max_word_width.max(current_word_width)
}
fn line_widest_grapheme(line: &Line<'_>) -> usize {
line.spans()
.iter()
.flat_map(|span| graphemes(span.content.as_ref()))
.filter(|grapheme| !grapheme.chars().all(char::is_whitespace))
.map(display_width)
.max()
.unwrap_or(0)
}
impl<'a> Paragraph<'a> {
fn with_static_text(text: FtuiText<'static>) -> Self {
Self {
text,
block: None,
style: Style::default(),
wrap: None,
alignment: None,
scroll: (0, 0),
}
}
#[must_use]
pub fn new<'t>(text: impl Into<FtuiText<'t>>) -> Self {
Self::with_static_text(text_into_owned(text.into()))
}
#[must_use]
pub fn from_static_text(text: FtuiText<'static>) -> Self {
Self::with_static_text(text)
}
#[must_use]
pub fn from_static_str(text: &'static str) -> Self {
Self::from_static_text(FtuiText::raw(text))
}
#[must_use]
pub fn block(mut self, block: Block<'a>) -> Self {
self.block = Some(block);
self
}
#[must_use]
pub fn style(mut self, style: Style) -> Self {
self.style = style;
self
}
#[must_use]
pub fn wrap(mut self, wrap: WrapMode) -> Self {
self.wrap = Some(wrap);
self
}
#[must_use]
pub fn alignment(mut self, alignment: Alignment) -> Self {
self.alignment = Some(alignment);
self
}
#[must_use]
pub fn scroll(mut self, offset: (u16, u16)) -> Self {
self.scroll = offset;
self
}
fn text_hash(&self) -> u64 {
hash_value(&self.text)
}
fn cached_metrics(&self, include_min_width: bool) -> CachedParagraphMetrics {
let text_hash = self.text_hash();
PARAGRAPH_CACHE.with(|cache| {
let mut cache = cache.borrow_mut();
if let Some(metrics) = cache.metrics.get_mut(&text_hash) {
if include_min_width && !metrics.min_width_computed {
let min_width = self
.text
.lines()
.iter()
.map(line_min_width)
.max()
.unwrap_or(0);
metrics.min_width = if min_width == 0 {
metrics.text_width
} else {
min_width
};
metrics.widest_grapheme = self
.text
.lines()
.iter()
.map(line_widest_grapheme)
.max()
.unwrap_or(0);
metrics.min_width_computed = true;
}
return metrics.clone();
}
let mut text_width = 0usize;
let mut min_width = 0usize;
let mut widest_grapheme = 0usize;
let mut line_widths = Vec::with_capacity(self.text.lines().len());
for line in self.text.lines() {
let width = line.width();
text_width = text_width.max(width);
if include_min_width {
min_width = min_width.max(line_min_width(line));
widest_grapheme = widest_grapheme.max(line_widest_grapheme(line));
}
line_widths.push(width);
}
let metrics = CachedParagraphMetrics {
text_width,
text_height: self.text.height(),
min_width: if min_width == 0 {
text_width
} else {
min_width
},
widest_grapheme,
min_width_computed: include_min_width,
line_widths: Arc::from(line_widths),
};
cache.insert_metrics(text_hash, metrics.clone());
metrics
})
}
fn cached_wrapped_lines(&self, width: usize, wrap_mode: WrapMode) -> CachedWrappedParagraph {
let key = ParagraphWrapCacheKey {
text_hash: self.text_hash(),
wrap_mode,
width,
};
PARAGRAPH_CACHE.with(|cache| {
let mut cache = cache.borrow_mut();
if let Some(wrapped) = cache.wrapped.get(&key) {
return wrapped.clone();
}
let mut lines = Vec::new();
let mut line_widths = Vec::new();
for line in self.text.lines() {
let line_width = line.width();
if wrap_mode == WrapMode::None || line_width <= width {
lines.push(line.clone());
line_widths.push(line_width);
continue;
}
let wrapped_lines = line.wrap(width, wrap_mode);
if wrapped_lines.is_empty() {
lines.push(Line::new());
line_widths.push(0);
continue;
}
for wrapped_line in wrapped_lines {
line_widths.push(wrapped_line.width());
lines.push(wrapped_line);
}
}
let wrapped = CachedWrappedParagraph {
lines: Arc::from(lines),
line_widths: Arc::from(line_widths),
};
cache.insert_wrapped(key, wrapped.clone());
wrapped
})
}
}
impl Widget for Paragraph<'_> {
fn render(&self, area: Rect, frame: &mut Frame) {
if frame.a11y_enabled() && !area.is_empty() {
frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
}
#[cfg(feature = "tracing")]
let _span = tracing::debug_span!(
"widget_render",
widget = "Paragraph",
x = area.x,
y = area.y,
w = area.width,
h = area.height
)
.entered();
let deg = frame.buffer.degradation;
if !deg.render_content() {
clear_text_area(frame, area, Style::default());
return;
}
let style = if deg.apply_styling() {
self.style
} else {
Style::default()
};
if self.block.is_none() && self.text.is_empty() {
clear_text_area(frame, area, style);
return;
}
clear_text_area(frame, area, style);
let text_area = match self.block {
Some(ref b) => {
crate::render_block_without_a11y(b, area, frame);
b.inner(area)
}
None => area,
};
if text_area.is_empty() {
return;
}
let mut text_style = style;
text_style.bg = None;
let mut y = text_area.y;
let mut current_visual_line = 0;
let scroll_offset = self.scroll.0 as usize;
let text_direction = frame.text_direction;
let effective_alignment = self.alignment.unwrap_or_else(|| {
if text_direction.is_rtl() {
Alignment::Right
} else {
Alignment::Left
}
});
let arena = frame.arena();
let mut render_spans = |spans: &[ftui_text::Span], line_width: usize, y: u16| {
let scroll_x = usize::from(self.scroll.1);
let start_x = align_x(text_area, line_width, effective_alignment);
let mut span_visual_offset: usize = 0;
let alignment_offset = usize::from(start_x.saturating_sub(text_area.x));
let visible_width = usize::from(text_area.right().saturating_sub(text_area.x));
for span in spans {
let span_width = span.width();
let line_rel_start = alignment_offset.saturating_add(span_visual_offset);
if line_rel_start.saturating_add(span_width) <= scroll_x {
span_visual_offset = span_visual_offset.saturating_add(span_width);
continue;
}
let draw_offset = line_rel_start.saturating_sub(scroll_x);
if draw_offset >= visible_width {
break;
}
let draw_x = text_area.x
+ u16::try_from(draw_offset).expect("visible paragraph offset fits u16");
let local_scroll = u16::try_from(scroll_x.saturating_sub(line_rel_start))
.expect("local paragraph scroll is bounded by u16 scroll");
let span_style = if deg.apply_styling() {
match span.style {
Some(s) => s.merge(&text_style),
None => text_style,
}
} else {
text_style };
if local_scroll > 0 {
draw_text_span_scrolled(
frame,
draw_x,
y,
span.content.as_ref(),
span_style,
text_area.right(),
local_scroll,
span.link.as_deref(),
);
} else {
draw_text_span_with_link(
frame,
draw_x,
y,
span.content.as_ref(),
span_style,
text_area.right(),
span.link.as_deref(),
);
}
span_visual_offset = span_visual_offset.saturating_add(span_width);
}
};
#[cfg(feature = "bidi")]
let para_dir = match text_direction {
ftui_render::TextDirection::Rtl => ftui_text::bidi::ParagraphDirection::Rtl,
ftui_render::TextDirection::Ltr => ftui_text::bidi::ParagraphDirection::Ltr,
};
let width = text_area.width as usize;
if let Some(wrap_mode) = self.wrap {
let can_use_arena_wrap = arena.is_some()
&& self.text.lines().iter().all(|line| {
line.spans().len() <= 1
&& line
.spans()
.first()
.is_none_or(|s| !s.as_str().starts_with(char::is_whitespace))
});
if let Some(arena) = arena.filter(|_| can_use_arena_wrap) {
let effective_mode = match wrap_mode {
WrapMode::Optimal => WrapMode::Word,
other => other,
};
for line in self.text.lines() {
let line_width = line.width();
if wrap_mode == WrapMode::None || line_width <= width {
if current_visual_line < scroll_offset {
current_visual_line += 1;
continue;
}
if y >= text_area.bottom() {
break;
}
#[cfg(feature = "bidi")]
if line_has_rtl(line.spans()) {
let (reordered_line, reordered_width) =
reorder_line_bidi(line, para_dir);
render_spans(reordered_line.spans(), reordered_width, y);
} else {
render_spans(line.spans(), line_width, y);
}
#[cfg(not(feature = "bidi"))]
render_spans(line.spans(), line_width, y);
y = y.saturating_add(1);
current_visual_line += 1;
continue;
}
let Some(span) = line.spans().first() else {
if current_visual_line < scroll_offset {
current_visual_line += 1;
continue;
}
if y >= text_area.bottom() {
break;
}
render_spans(&[], 0, y);
y = y.saturating_add(1);
current_visual_line += 1;
continue;
};
let wrapped_slices =
ftui_text::wrap::wrap_text_in(arena, span.as_str(), width, effective_mode);
if wrapped_slices.is_empty() {
if current_visual_line < scroll_offset {
current_visual_line += 1;
continue;
}
if y >= text_area.bottom() {
break;
}
render_spans(&[], 0, y);
y = y.saturating_add(1);
current_visual_line += 1;
continue;
}
for &slice in wrapped_slices {
if current_visual_line < scroll_offset {
current_visual_line += 1;
continue;
}
if y >= text_area.bottom() {
break;
}
let w_span = ftui_text::Span {
content: std::borrow::Cow::Borrowed(slice),
style: span.style,
link: span.link.clone(),
};
let w_width = w_span.width();
#[cfg(feature = "bidi")]
if ftui_text::bidi::has_rtl(slice) {
let tmp_line = ftui_text::Line::from_spans([w_span]);
let (reordered_line, reordered_width) =
reorder_line_bidi(&tmp_line, para_dir);
render_spans(reordered_line.spans(), reordered_width, y);
} else {
render_spans(std::slice::from_ref(&w_span), w_width, y);
}
#[cfg(not(feature = "bidi"))]
render_spans(std::slice::from_ref(&w_span), w_width, y);
y = y.saturating_add(1);
current_visual_line += 1;
}
}
} else {
let wrapped = self.cached_wrapped_lines(width, wrap_mode);
for (line, _line_width) in wrapped.lines.iter().zip(wrapped.line_widths.iter()) {
if current_visual_line < scroll_offset {
current_visual_line += 1;
continue;
}
if y >= text_area.bottom() {
break;
}
#[cfg(feature = "bidi")]
if line_has_rtl(line.spans()) {
let (reordered_line, reordered_width) = reorder_line_bidi(line, para_dir);
render_spans(reordered_line.spans(), reordered_width, y);
} else {
render_spans(line.spans(), *_line_width, y);
}
#[cfg(not(feature = "bidi"))]
render_spans(line.spans(), *_line_width, y);
y = y.saturating_add(1);
current_visual_line += 1;
}
}
} else if arena.is_some() {
for line in self.text.lines() {
if current_visual_line < scroll_offset {
current_visual_line += 1;
continue;
}
if y >= text_area.bottom() {
break;
}
let line_width = line.width();
#[cfg(feature = "bidi")]
if line_has_rtl(line.spans()) {
let (reordered_line, reordered_width) = reorder_line_bidi(line, para_dir);
render_spans(reordered_line.spans(), reordered_width, y);
} else {
render_spans(line.spans(), line_width, y);
}
#[cfg(not(feature = "bidi"))]
render_spans(line.spans(), line_width, y);
y = y.saturating_add(1);
current_visual_line += 1;
}
} else {
let metrics = self.cached_metrics(false);
for (line, _line_width) in self.text.lines().iter().zip(metrics.line_widths.iter()) {
if current_visual_line < scroll_offset {
current_visual_line += 1;
continue;
}
if y >= text_area.bottom() {
break;
}
#[cfg(feature = "bidi")]
if line_has_rtl(line.spans()) {
let (reordered_line, reordered_width) = reorder_line_bidi(line, para_dir);
render_spans(reordered_line.spans(), reordered_width, y);
} else {
render_spans(line.spans(), *_line_width, y);
}
#[cfg(not(feature = "bidi"))]
render_spans(line.spans(), *_line_width, y);
y = y.saturating_add(1);
current_visual_line += 1;
}
}
}
}
#[cfg(feature = "bidi")]
#[inline]
fn line_has_rtl(spans: &[ftui_text::Span]) -> bool {
spans
.iter()
.any(|s| ftui_text::bidi::has_rtl(s.content.as_ref()))
}
#[cfg(feature = "bidi")]
fn reorder_line_bidi(
line: &ftui_text::Line,
para_dir: ftui_text::bidi::ParagraphDirection,
) -> (ftui_text::Line<'static>, usize) {
let full_text: String = line.spans().iter().map(|s| s.content.as_ref()).collect();
if full_text.is_empty() || !ftui_text::bidi::has_rtl(&full_text) {
let width = line.width();
let spans: Vec<ftui_text::Span<'static>> = line
.spans()
.iter()
.cloned()
.map(ftui_text::Span::into_owned)
.collect();
return (ftui_text::Line::from_spans(spans), width);
}
let level = match para_dir {
ftui_text::bidi::ParagraphDirection::Ltr => Some(unicode_bidi::Level::ltr()),
ftui_text::bidi::ParagraphDirection::Rtl => Some(unicode_bidi::Level::rtl()),
ftui_text::bidi::ParagraphDirection::Auto => None,
};
let bidi_info = unicode_bidi::BidiInfo::new(&full_text, level);
let mut byte_styles: Vec<Option<Style>> = Vec::with_capacity(full_text.len());
for span in line.spans() {
byte_styles.extend(std::iter::repeat_n(span.style, span.content.len()));
}
let mut new_spans: Vec<ftui_text::Span<'static>> = Vec::new();
let mut current_str = String::new();
let mut current_style: Option<Style> = None;
let mut push_cluster = |cluster: &str, style: Option<Style>| {
if !current_str.is_empty() && current_style != style {
let text = std::mem::take(&mut current_str);
new_spans.push(match current_style {
Some(st) => ftui_text::Span::styled(text, st),
None => ftui_text::Span::raw(text),
});
}
current_style = style;
current_str.push_str(cluster);
};
for para in &bidi_info.paragraphs {
let (levels, runs) = bidi_info.visual_runs(para, para.range.clone());
for run in runs {
let run_text = &full_text[run.clone()];
let clusters: Vec<(usize, &str)> =
unicode_segmentation::UnicodeSegmentation::grapheme_indices(run_text, true)
.collect();
let rtl = levels.get(run.start).is_some_and(|l| l.is_rtl());
let style_at = |off: usize| byte_styles.get(run.start + off).copied().flatten();
if rtl {
for &(off, g) in clusters.iter().rev() {
push_cluster(g, style_at(off));
}
} else {
for &(off, g) in &clusters {
push_cluster(g, style_at(off));
}
}
}
}
if !current_str.is_empty() {
new_spans.push(match current_style {
Some(st) => ftui_text::Span::styled(current_str, st),
None => ftui_text::Span::raw(current_str),
});
}
let line = ftui_text::Line::from_spans(new_spans);
let width = line.width();
(line, width)
}
impl MeasurableWidget for Paragraph<'_> {
fn measure(&self, available: Size) -> SizeConstraints {
let metrics = self.cached_metrics(true);
let text_width = metrics.text_width;
let text_height = metrics.text_height;
let min_width = match self.wrap {
Some(WrapMode::Char | WrapMode::WordChar) => metrics.widest_grapheme,
_ => metrics.min_width,
};
let (chrome_width, chrome_height) = self
.block
.as_ref()
.map(|b| b.chrome_size())
.unwrap_or((0, 0));
let (preferred_width, preferred_height) =
if self.wrap.is_some_and(|mode| mode != WrapMode::None) {
let wrap_width = if available.width > chrome_width {
(available.width - chrome_width) as usize
} else {
1
};
let wrapped_height = self
.wrap
.map(|wrap_mode| self.cached_wrapped_lines(wrap_width, wrap_mode).lines.len())
.unwrap_or(text_height);
let pref_w = text_width.min(wrap_width);
(pref_w, wrapped_height)
} else {
(text_width, text_height)
};
let min_w = u16::try_from(min_width)
.unwrap_or(u16::MAX)
.saturating_add(chrome_width);
let min_h = if preferred_height > 0 {
(1u16).saturating_add(chrome_height)
} else {
chrome_height
};
let pref_w = u16::try_from(preferred_width)
.unwrap_or(u16::MAX)
.saturating_add(chrome_width)
.max(min_w);
let pref_h = u16::try_from(preferred_height)
.unwrap_or(u16::MAX)
.saturating_add(chrome_height);
SizeConstraints {
min: Size::new(min_w, min_h),
preferred: Size::new(pref_w, pref_h),
max: None, }
}
fn has_intrinsic_size(&self) -> bool {
true
}
}
impl Paragraph<'_> {
#[cfg_attr(not(test), allow(dead_code))]
fn calculate_min_width(&self) -> usize {
self.cached_metrics(true).min_width
}
#[cfg_attr(not(test), allow(dead_code))]
fn estimate_wrapped_height(&self, wrap_width: usize) -> usize {
if wrap_width == 0 {
return self.cached_metrics(false).text_height;
}
self.wrap
.map(|wrap_mode| self.cached_wrapped_lines(wrap_width, wrap_mode).lines.len())
.unwrap_or_else(|| self.cached_metrics(false).text_height)
.max(1)
}
}
fn align_x(area: Rect, line_width: usize, alignment: Alignment) -> u16 {
let line_width_u16 = u16::try_from(line_width).unwrap_or(u16::MAX);
match alignment {
Alignment::Left => area.x,
Alignment::Center => area
.x
.saturating_add(area.width.saturating_sub(line_width_u16) / 2),
Alignment::Right => area
.x
.saturating_add(area.width.saturating_sub(line_width_u16)),
}
}
fn truncate_accessible_text(text: &str) -> String {
const ACCESSIBLE_TEXT_LIMIT: usize = 200;
const ACCESSIBLE_TEXT_PREFIX_LIMIT: usize = 197;
if text.chars().count() <= ACCESSIBLE_TEXT_LIMIT {
text.to_owned()
} else {
let mut prefix = String::new();
let mut prefix_chars = 0usize;
for grapheme in graphemes(text) {
let grapheme_chars = grapheme.chars().count();
if prefix_chars + grapheme_chars > ACCESSIBLE_TEXT_PREFIX_LIMIT {
break;
}
prefix.push_str(grapheme);
prefix_chars += grapheme_chars;
}
format!("{prefix}...")
}
}
impl ftui_a11y::Accessible for Paragraph<'_> {
fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
use ftui_a11y::node::{A11yNodeInfo, A11yRole};
let id = crate::a11y_node_id(area);
let name: String = self
.text
.lines()
.iter()
.map(|line| {
line.spans()
.iter()
.map(|span| span.content.as_ref())
.collect::<Vec<_>>()
.join("")
})
.collect::<Vec<_>>()
.join(" ");
let block_title = self.block.as_ref().and_then(|b| b.title_text());
let truncated_name = truncate_accessible_text(&name);
let mut node = A11yNodeInfo::new(id, A11yRole::Label, area);
if let Some(title) = block_title {
node = node.with_name(title);
if !name.is_empty() {
node = node.with_description(truncated_name);
}
} else if !name.is_empty() {
node = node.with_name(truncated_name);
}
vec![node]
}
}
#[cfg(test)]
mod tests {
use super::*;
use ftui_render::grapheme_pool::GraphemePool;
fn raw_row_text(frame: &Frame, y: u16) -> String {
let width = frame.buffer.width();
let mut actual = String::new();
for x in 0..width {
let cell = match frame.buffer.get(x, y) {
Some(c) => c,
None => {
actual.push(' ');
continue;
}
};
if cell.content.is_empty() {
actual.push(' ');
} else if let Some(ch) = cell.content.as_char() {
actual.push(ch);
} else if let Some(gid) = cell.content.grapheme_id() {
if let Some(s) = frame.pool.get(gid) {
actual.push_str(s);
} else {
actual.push(' ');
}
} else {
actual.push(' ');
}
}
actual
}
#[test]
fn render_simple_text() {
let para = Paragraph::new(Text::raw("Hello"));
let area = Rect::new(0, 0, 10, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 1, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('H'));
assert_eq!(frame.buffer.get(4, 0).unwrap().content.as_char(), Some('o'));
}
#[test]
fn from_static_str_preserves_rendering_without_owning_static_spans() {
let area = Rect::new(0, 0, 8, 2);
let fast = Paragraph::from_static_str("Hi\nthere").style(Style::new().bold());
let slow = Paragraph::new("Hi\nthere").style(Style::new().bold());
let mut fast_pool = GraphemePool::new();
let mut fast_frame = Frame::new(8, 2, &mut fast_pool);
fast.render(area, &mut fast_frame);
let mut slow_pool = GraphemePool::new();
let mut slow_frame = Frame::new(8, 2, &mut slow_pool);
slow.render(area, &mut slow_frame);
assert_eq!(raw_row_text(&fast_frame, 0), raw_row_text(&slow_frame, 0));
assert_eq!(raw_row_text(&fast_frame, 1), raw_row_text(&slow_frame, 1));
let first_span = &fast.text.lines()[0].spans()[0];
match &first_span.content {
std::borrow::Cow::Borrowed(text) => assert_eq!(*text, "Hi"),
std::borrow::Cow::Owned(_) => panic!("static paragraph text should stay borrowed"),
}
}
#[test]
fn render_multiline_text() {
let para = Paragraph::new(Text::raw("AB\nCD"));
let area = Rect::new(0, 0, 5, 3);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(5, 3, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('A'));
assert_eq!(frame.buffer.get(1, 0).unwrap().content.as_char(), Some('B'));
assert_eq!(frame.buffer.get(0, 1).unwrap().content.as_char(), Some('C'));
assert_eq!(frame.buffer.get(1, 1).unwrap().content.as_char(), Some('D'));
}
#[test]
fn render_centered_text() {
let para = Paragraph::new(Text::raw("Hi")).alignment(Alignment::Center);
let area = Rect::new(0, 0, 10, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 1, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(4, 0).unwrap().content.as_char(), Some('H'));
assert_eq!(frame.buffer.get(5, 0).unwrap().content.as_char(), Some('i'));
}
#[test]
fn render_with_scroll() {
let para = Paragraph::new(Text::raw("Line1\nLine2\nLine3")).scroll((1, 0));
let area = Rect::new(0, 0, 10, 2);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 2, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('L'));
assert_eq!(frame.buffer.get(4, 0).unwrap().content.as_char(), Some('2'));
}
#[test]
fn render_long_span_visible_prefix_at_u16_boundaries() {
for width in [65_535, 65_536, 65_537, 131_072] {
let content = format!("ABCDE{}", "x".repeat(width - 5));
let paragraph = Paragraph::new(content);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(7, 1, &mut pool);
paragraph.render(Rect::new(1, 0, 5, 1), &mut frame);
assert_eq!(raw_row_text(&frame, 0), " ABCDE ", "width {width}");
}
}
#[test]
fn render_long_span_at_max_horizontal_scroll() {
for (tail, expected) in [
("", " "),
("A", "A "),
("ABCDE", "ABCDE "),
("ABCDEFGH", "ABCDEF"),
] {
let content = format!("{}{tail}", "x".repeat(65_535));
let paragraph = Paragraph::new(content).scroll((0, u16::MAX));
let mut pool = GraphemePool::new();
let mut frame = Frame::new(6, 1, &mut pool);
paragraph.render(Rect::new(0, 0, 6, 1), &mut frame);
assert_eq!(raw_row_text(&frame, 0), expected, "tail {tail:?}");
}
}
#[test]
fn render_max_horizontal_scroll_preserves_span_positions_and_styles() {
use ftui_render::cell::PackedRgba;
for (prefix_width, expected, red_start, green_start) in [
(65_534, " BCD ", 1, 2),
(65_535, " ABCD ", 1, 3),
(65_536, " xABCD ", 2, 4),
] {
let paragraph = Paragraph::new(Text::from(Line::from_spans([
Span::raw("x".repeat(prefix_width)),
Span::styled("AB", Style::new().fg(PackedRgba::RED)),
Span::styled("CD", Style::new().fg(PackedRgba::GREEN)),
])))
.scroll((0, u16::MAX));
let mut pool = GraphemePool::new();
let mut frame = Frame::new(7, 1, &mut pool);
paragraph.render(Rect::new(1, 0, 5, 1), &mut frame);
assert_eq!(raw_row_text(&frame, 0), expected, "prefix {prefix_width}");
for x in red_start..green_start {
assert_eq!(frame.buffer.get(x, 0).unwrap().fg, PackedRgba::RED);
}
for x in green_start..green_start + 2 {
assert_eq!(frame.buffer.get(x, 0).unwrap().fg, PackedRgba::GREEN);
}
}
}
#[test]
fn render_long_wide_span_clips_at_viewport_edge() {
let paragraph = Paragraph::new("界".repeat(32_768));
let mut pool = GraphemePool::new();
let mut frame = Frame::new(5, 1, &mut pool);
paragraph.render(Rect::new(1, 0, 3, 1), &mut frame);
let wide = frame
.buffer
.get(1, 0)
.unwrap()
.content
.grapheme_id()
.expect("the visible whole wide grapheme must be rendered");
assert_eq!(frame.pool.get(wide), Some("界"));
assert!(frame.buffer.get(2, 0).unwrap().is_continuation());
assert_eq!(frame.buffer.get(3, 0).unwrap().content.as_char(), Some(' '));
for x in [0, 4] {
assert_eq!(
*frame.buffer.get(x, 0).unwrap(),
ftui_render::cell::Cell::default()
);
}
}
#[test]
fn render_max_horizontal_scroll_clips_whole_wide_graphemes() {
let content = format!("{}界A界B", "x".repeat(65_535));
let paragraph = Paragraph::new(content).scroll((0, u16::MAX));
let mut pool = GraphemePool::new();
let mut frame = Frame::new(4, 1, &mut pool);
paragraph.render(Rect::new(0, 0, 4, 1), &mut frame);
let wide = frame
.buffer
.get(0, 0)
.unwrap()
.content
.grapheme_id()
.expect("a wide grapheme beginning at the scroll offset must remain visible");
assert_eq!(frame.pool.get(wide), Some("界"));
assert!(frame.buffer.get(1, 0).unwrap().is_continuation());
assert_eq!(frame.buffer.get(2, 0).unwrap().content.as_char(), Some('A'));
assert_eq!(frame.buffer.get(3, 0).unwrap().content.as_char(), Some(' '));
let content = format!("{}界AB", "x".repeat(65_534));
let paragraph = Paragraph::new(content).scroll((0, u16::MAX));
let mut pool = GraphemePool::new();
let mut frame = Frame::new(4, 1, &mut pool);
paragraph.render(Rect::new(0, 0, 4, 1), &mut frame);
assert_eq!(raw_row_text(&frame, 0), "AB ");
}
#[test]
fn render_empty_area() {
let para = Paragraph::new(Text::raw("Hello"));
let area = Rect::new(0, 0, 0, 0);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(1, 1, &mut pool);
para.render(area, &mut frame);
}
#[test]
fn line_min_width_tracks_words_across_spans() {
let line = Line::from_spans([
Span::raw("alpha"),
Span::styled(" ", Style::new().bold()),
Span::raw("beta"),
Span::raw(" "),
Span::raw("gamma"),
]);
assert_eq!(line_min_width(&line), 5);
}
#[test]
fn intrinsic_minimum_preserves_whitespace_unicode_and_span_boundaries() {
let cases = [
(Text::raw(""), 0),
(Text::raw(" "), 3),
(Text::raw(" \na"), 1),
(Text::raw("e\u{301} x"), 1),
(Text::raw("ab\tc"), 2),
(Text::raw("a\0b\x7fc"), 3),
(
Text::from(Line::from_spans([
Span::raw("hel"),
Span::styled("lo", Style::new().bold()),
])),
5,
),
(
Text::from(Line::from_spans([Span::raw("ab"), Span::raw("界")])),
4,
),
];
let area = Rect::new(0, 0, 16, 3);
for (text, expected_minimum) in cases {
let paragraph = Paragraph::new(text);
for render_first in [true, false] {
PARAGRAPH_CACHE.with(|cache| *cache.borrow_mut() = ParagraphCacheState::default());
let mut pool = GraphemePool::new();
let mut frame = Frame::new(area.width, area.height, &mut pool);
if render_first {
paragraph.render(area, &mut frame);
}
let measured = paragraph.measure(Size::new(area.width, area.height));
assert_eq!(measured.min.width, expected_minimum, "{paragraph:?}");
paragraph.render(area, &mut frame);
assert_eq!(paragraph.measure(Size::new(1, 1)), measured);
}
}
}
#[test]
fn intrinsic_measurement_is_independent_of_render_order_and_chrome() {
let paragraph = Paragraph::new("hello world").wrap(WrapMode::Word);
let area = Rect::new(0, 0, 6, 2);
for render_first in [true, false] {
PARAGRAPH_CACHE.with(|cache| *cache.borrow_mut() = ParagraphCacheState::default());
let mut pool = GraphemePool::new();
let mut frame = Frame::new(6, 2, &mut pool);
if render_first {
paragraph.render(area, &mut frame);
}
let measured = paragraph.measure(Size::new(6, 2));
assert_eq!(measured.min, Size::new(5, 1));
assert_eq!(measured.preferred, Size::new(6, 2));
paragraph.render(area, &mut frame);
assert_eq!(raw_row_text(&frame, 0), "hello ");
assert_eq!(raw_row_text(&frame, 1), "world ");
let bordered = paragraph.clone().block(Block::bordered());
let measured = bordered.measure(Size::new(10, 6));
assert_eq!(measured.min, Size::new(9, 5));
assert_eq!(measured.preferred, Size::new(10, 6));
let unwrapped = paragraph.clone().wrap(WrapMode::None);
assert_eq!(
unwrapped.measure(Size::new(6, 2)).preferred,
Size::new(11, 1)
);
}
}
#[test]
fn intrinsic_minimum_survives_actual_metrics_eviction() {
let original = Paragraph::new("hello world");
let available = Size::new(16, 2);
let area = Rect::new(0, 0, 16, 2);
for measure_first in [true, false] {
PARAGRAPH_CACHE.with(|cache| *cache.borrow_mut() = ParagraphCacheState::default());
let mut pool = GraphemePool::new();
let mut frame = Frame::new(16, 2, &mut pool);
original.render(area, &mut frame);
if measure_first {
assert_eq!(original.measure(available).min.width, 5);
}
for index in 0..PARAGRAPH_METRICS_CACHE_CAPACITY {
Paragraph::new(format!("entry{index} xxxx")).render(area, &mut frame);
}
PARAGRAPH_CACHE.with(|cache| {
let cache = cache.borrow();
assert_eq!(cache.metrics.len(), PARAGRAPH_METRICS_CACHE_CAPACITY);
assert!(!cache.metrics.contains_key(&original.text_hash()));
});
let measured = original.measure(available);
assert_eq!(measured.min, Size::new(5, 1));
assert_eq!(measured.preferred, Size::new(11, 1));
original.render(area, &mut frame);
assert_eq!(raw_row_text(&frame, 0), "hello world ");
}
}
#[test]
fn render_skips_min_width_scan_until_intrinsic_measure_requests_it() {
let paragraph = Paragraph::new("alpha beta supercalifragilistic");
let area = Rect::new(0, 0, 20, 2);
PARAGRAPH_CACHE.with(|cache| *cache.borrow_mut() = ParagraphCacheState::default());
let mut pool = GraphemePool::new();
let mut frame = Frame::new(20, 2, &mut pool);
paragraph.render(area, &mut frame);
PARAGRAPH_CACHE.with(|cache| {
let cache = cache.borrow();
let entry = cache
.metrics
.get(¶graph.text_hash())
.expect("render should populate line-width metrics");
assert!(
!entry.min_width_computed,
"render must not compute min_width/widest_grapheme eagerly"
);
assert_eq!(entry.text_width, 31);
});
let measured = paragraph.measure(Size::new(20, 2));
assert_eq!(measured.min, Size::new(20, 1));
assert_eq!(measured.preferred, Size::new(31, 1));
PARAGRAPH_CACHE.with(|cache| {
let cache = cache.borrow();
let entry = cache
.metrics
.get(¶graph.text_hash())
.expect("metrics entry should remain cached");
assert!(
entry.min_width_computed,
"measure() must lazily populate min_width on the cached entry"
);
assert_eq!(entry.min_width, 20);
assert_eq!(entry.widest_grapheme, 1);
});
}
#[test]
fn intrinsic_measurement_preserves_resolved_unicode_rendering() {
let paragraph = Paragraph::new("e\u{301} 界");
for render_first in [true, false] {
PARAGRAPH_CACHE.with(|cache| *cache.borrow_mut() = ParagraphCacheState::default());
let mut pool = GraphemePool::new();
let mut frame = Frame::new(4, 1, &mut pool);
if render_first {
paragraph.render(Rect::new(0, 0, 4, 1), &mut frame);
}
let measured = paragraph.measure(Size::new(4, 1));
assert_eq!(measured.min, Size::new(2, 1));
assert_eq!(measured.preferred, Size::new(4, 1));
paragraph.render(Rect::new(0, 0, 4, 1), &mut frame);
let accent = frame
.buffer
.get(0, 0)
.unwrap()
.content
.grapheme_id()
.unwrap();
assert_eq!(frame.pool.get(accent), Some("e\u{301}"));
assert_eq!(frame.buffer.get(1, 0).unwrap().content.as_char(), Some(' '));
let wide = frame
.buffer
.get(2, 0)
.unwrap()
.content
.grapheme_id()
.unwrap();
assert_eq!(frame.pool.get(wide), Some("界"));
assert!(frame.buffer.get(3, 0).unwrap().content.is_continuation());
}
}
#[test]
fn intrinsic_width_saturates_before_adding_chrome() {
for (width, expected_plain, expected_bordered) in [
(65_534, 65_534, 65_535),
(65_535, 65_535, 65_535),
(65_536, 65_535, 65_535),
(131_071, 65_535, 65_535),
] {
let paragraph = Paragraph::new("x".repeat(width));
let measured = paragraph.measure(Size::new(80, 24));
assert_eq!(measured.min, Size::new(expected_plain, 1));
assert_eq!(measured.preferred, Size::new(expected_plain, 1));
let bordered = paragraph.block(Block::bordered());
let measured = bordered.measure(Size::new(80, 24));
assert_eq!(measured.min, Size::new(expected_bordered, 5));
assert_eq!(measured.preferred, Size::new(expected_bordered, 5));
}
}
#[test]
fn intrinsic_height_saturates_before_adding_chrome() {
for (height, expected_plain) in [(65_534, 65_534), (65_535, 65_535), (65_536, 65_535)] {
let paragraph = Paragraph::new(Text::from_lines(vec![Line::raw("x"); height]));
let measured = paragraph.measure(Size::new(80, 24));
assert_eq!(measured.min, Size::new(1, 1));
assert_eq!(measured.preferred, Size::new(1, expected_plain));
let bordered = paragraph.block(Block::bordered());
let measured = bordered.measure(Size::new(80, 24));
assert_eq!(measured.min, Size::new(5, 5));
assert_eq!(measured.preferred, Size::new(5, u16::MAX));
}
}
#[test]
fn intrinsic_wrapped_height_saturates_at_terminal_dimension_limit() {
let paragraph = Paragraph::new("x".repeat(65_536)).wrap(WrapMode::Char);
let measured = paragraph.measure(Size::new(1, 24));
assert_eq!(measured.min, Size::new(1, 1));
assert_eq!(measured.preferred, Size::new(1, u16::MAX));
let bordered = paragraph.block(Block::bordered());
let measured = bordered.measure(Size::new(5, 24));
assert_eq!(measured.min, Size::new(5, 5));
assert_eq!(measured.preferred, Size::new(5, u16::MAX));
}
#[test]
fn measure_wrap_counts_cached_visual_lines() {
let para = Paragraph::new(Text::raw("hello world from cache")).wrap(WrapMode::Word);
let constraints = para.measure(Size::new(8, 10));
assert_eq!(constraints.preferred.height, 4);
assert_eq!(constraints.min.width, 5);
}
#[test]
fn measure_wrap_none_preserves_natural_width() {
let para = Paragraph::new(Text::raw("abcdef")).wrap(WrapMode::None);
let constraints = para.measure(Size::new(3, 10));
assert_eq!(constraints.preferred.width, 6);
assert_eq!(constraints.preferred.height, 1);
}
#[test]
fn render_empty_text_clears_content() {
let para = Paragraph::new("");
let area = Rect::new(0, 0, 3, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(3, 1, &mut pool);
frame
.buffer
.fill(area, ftui_render::cell::Cell::from_char('X'));
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some(' '));
assert_eq!(frame.buffer.get(2, 0).unwrap().content.as_char(), Some(' '));
}
#[test]
fn render_right_aligned() {
let para = Paragraph::new(Text::raw("Hi")).alignment(Alignment::Right);
let area = Rect::new(0, 0, 10, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 1, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(8, 0).unwrap().content.as_char(), Some('H'));
assert_eq!(frame.buffer.get(9, 0).unwrap().content.as_char(), Some('i'));
}
#[test]
fn render_with_word_wrap() {
let para = Paragraph::new(Text::raw("hello world")).wrap(WrapMode::Word);
let area = Rect::new(0, 0, 6, 3);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(6, 3, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('h'));
assert_eq!(frame.buffer.get(0, 1).unwrap().content.as_char(), Some('w'));
}
#[test]
fn render_with_char_wrap() {
let para = Paragraph::new(Text::raw("abcdefgh")).wrap(WrapMode::Char);
let area = Rect::new(0, 0, 4, 3);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(4, 3, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('a'));
assert_eq!(frame.buffer.get(3, 0).unwrap().content.as_char(), Some('d'));
assert_eq!(frame.buffer.get(0, 1).unwrap().content.as_char(), Some('e'));
}
#[test]
fn scroll_past_all_lines() {
let para = Paragraph::new(Text::raw("AB")).scroll((5, 0));
let area = Rect::new(0, 0, 5, 2);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(5, 2, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some(' '));
}
#[test]
fn render_shorter_text_clears_stale_suffix_and_extra_lines() {
let area = Rect::new(0, 0, 8, 2);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(8, 2, &mut pool);
Paragraph::new(Text::raw("Hello\nWorld")).render(area, &mut frame);
Paragraph::new(Text::raw("Hi")).render(area, &mut frame);
assert_eq!(raw_row_text(&frame, 0), "Hi ");
assert_eq!(raw_row_text(&frame, 1), " ");
}
#[test]
fn render_clipped_at_area_height() {
let para = Paragraph::new(Text::raw("A\nB\nC\nD\nE"));
let area = Rect::new(0, 0, 5, 2);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(5, 2, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('A'));
assert_eq!(frame.buffer.get(0, 1).unwrap().content.as_char(), Some('B'));
}
#[test]
fn render_clipped_at_area_width() {
let para = Paragraph::new(Text::raw("ABCDEF"));
let area = Rect::new(0, 0, 3, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(3, 1, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('A'));
assert_eq!(frame.buffer.get(2, 0).unwrap().content.as_char(), Some('C'));
}
#[test]
fn align_x_left() {
let area = Rect::new(5, 0, 20, 1);
assert_eq!(align_x(area, 10, Alignment::Left), 5);
}
#[test]
fn align_x_center() {
let area = Rect::new(0, 0, 20, 1);
assert_eq!(align_x(area, 6, Alignment::Center), 7);
}
#[test]
fn align_x_right() {
let area = Rect::new(0, 0, 20, 1);
assert_eq!(align_x(area, 5, Alignment::Right), 15);
}
#[test]
fn align_x_wide_line_saturates() {
let area = Rect::new(0, 0, 10, 1);
assert_eq!(align_x(area, 20, Alignment::Right), 0);
assert_eq!(align_x(area, 20, Alignment::Center), 0);
}
#[test]
fn builder_methods_chain() {
let para = Paragraph::new(Text::raw("test"))
.style(Style::default())
.wrap(WrapMode::Word)
.alignment(Alignment::Center)
.scroll((1, 2));
let area = Rect::new(0, 0, 10, 5);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 5, &mut pool);
para.render(area, &mut frame);
}
#[test]
fn render_at_offset_area() {
let para = Paragraph::new(Text::raw("X"));
let area = Rect::new(3, 4, 5, 2);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 10, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(3, 4).unwrap().content.as_char(), Some('X'));
assert!(frame.buffer.get(0, 0).unwrap().is_empty());
}
#[test]
fn wrap_clipped_at_area_bottom() {
let para = Paragraph::new(Text::raw("abcdefghijklmnop")).wrap(WrapMode::Char);
let area = Rect::new(0, 0, 4, 2);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(4, 2, &mut pool);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('a'));
assert_eq!(frame.buffer.get(0, 1).unwrap().content.as_char(), Some('e'));
}
#[test]
fn degradation_skeleton_skips_content() {
use ftui_render::budget::DegradationLevel;
let para = Paragraph::new(Text::raw("Hello"));
let area = Rect::new(0, 0, 10, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 1, &mut pool);
Paragraph::new(Text::raw("Stale")).render(area, &mut frame);
frame.set_degradation(DegradationLevel::Skeleton);
para.render(area, &mut frame);
assert_eq!(raw_row_text(&frame, 0), " ");
}
#[test]
fn degradation_full_renders_content() {
use ftui_render::budget::DegradationLevel;
let para = Paragraph::new(Text::raw("Hello"));
let area = Rect::new(0, 0, 10, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 1, &mut pool);
frame.set_degradation(DegradationLevel::Full);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('H'));
}
#[test]
fn degradation_essential_only_still_renders_text() {
use ftui_render::budget::DegradationLevel;
let para = Paragraph::new(Text::raw("Hello"));
let area = Rect::new(0, 0, 10, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 1, &mut pool);
frame.set_degradation(DegradationLevel::EssentialOnly);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('H'));
}
#[test]
fn degradation_no_styling_ignores_span_styles() {
use ftui_render::budget::DegradationLevel;
use ftui_render::cell::PackedRgba;
use ftui_text::{Line, Span};
let styled_span = Span::styled("Hello", Style::new().fg(PackedRgba::RED));
let line = Line::from_spans([styled_span]);
let text = Text::from(line);
let para = Paragraph::new(text);
let area = Rect::new(0, 0, 10, 1);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(10, 1, &mut pool);
frame.set_degradation(DegradationLevel::NoStyling);
para.render(area, &mut frame);
assert_eq!(frame.buffer.get(0, 0).unwrap().content.as_char(), Some('H'));
assert_ne!(
frame.buffer.get(0, 0).unwrap().fg,
PackedRgba::RED,
"Span fg color should be ignored at NoStyling"
);
}
use crate::MeasurableWidget;
use ftui_core::geometry::Size;
#[test]
fn measure_simple_text() {
let para = Paragraph::new(Text::raw("Hello"));
let constraints = para.measure(Size::MAX);
assert_eq!(constraints.preferred, Size::new(5, 1));
assert_eq!(constraints.min.height, 1);
assert_eq!(constraints.min.width, 5);
}
#[test]
fn measure_multiline_text() {
let para = Paragraph::new(Text::raw("Line1\nLine22\nL3"));
let constraints = para.measure(Size::MAX);
assert_eq!(constraints.preferred, Size::new(6, 3));
assert_eq!(constraints.min.height, 1);
assert_eq!(constraints.min.width, 6);
}
#[test]
fn measure_with_block() {
let block = crate::block::Block::bordered();
let para = Paragraph::new(Text::raw("Hi")).block(block);
let constraints = para.measure(Size::MAX);
assert_eq!(constraints.preferred, Size::new(6, 5));
assert_eq!(constraints.min.width, 6);
assert_eq!(constraints.min.height, 5);
}
#[test]
fn measure_with_word_wrap() {
let para = Paragraph::new(Text::raw("hello world")).wrap(WrapMode::Word);
let constraints = para.measure(Size::new(6, 10));
assert_eq!(constraints.preferred.height, 2);
assert_eq!(constraints.min.width, 5);
}
#[test]
fn measure_empty_text() {
let para = Paragraph::new(Text::raw(""));
let constraints = para.measure(Size::MAX);
assert_eq!(constraints.preferred.width, 0);
assert_eq!(constraints.preferred.height, 0);
assert_eq!(constraints.min.height, 0);
}
#[test]
fn calculate_min_width_single_long_word() {
let para = Paragraph::new(Text::raw("supercalifragilistic"));
assert_eq!(para.calculate_min_width(), 20);
}
#[test]
fn calculate_min_width_multiple_words() {
let para = Paragraph::new(Text::raw("the quick brown fox"));
assert_eq!(para.calculate_min_width(), 5);
}
#[test]
fn calculate_min_width_multiline() {
let para = Paragraph::new(Text::raw("short\nlongword\na"));
assert_eq!(para.calculate_min_width(), 8);
}
#[test]
fn estimate_wrapped_height_no_wrap_needed() {
let para = Paragraph::new(Text::raw("short")).wrap(WrapMode::Word);
assert_eq!(para.estimate_wrapped_height(10), 1);
}
#[test]
fn estimate_wrapped_height_needs_wrap() {
let para = Paragraph::new(Text::raw("hello world")).wrap(WrapMode::Word);
assert_eq!(para.estimate_wrapped_height(6), 2);
}
#[test]
fn has_intrinsic_size() {
let para = Paragraph::new(Text::raw("test"));
assert!(para.has_intrinsic_size());
}
#[test]
fn measure_is_pure() {
let para = Paragraph::new(Text::raw("Hello World"));
let a = para.measure(Size::new(100, 50));
let b = para.measure(Size::new(100, 50));
assert_eq!(a, b);
}
#[test]
fn a_blocks_group_does_not_overwrite_the_paragraph_node() {
use ftui_a11y::tree::A11yTreeBuilder;
let mut builder = A11yTreeBuilder::new();
let area = Rect::new(0, 0, 40, 6);
{
let mut pool = GraphemePool::new();
let mut frame = Frame::new(40, 6, &mut pool);
frame.set_a11y(&mut builder);
Paragraph::new("hello world")
.block(Block::bordered().title("Notes"))
.render(area, &mut frame);
frame.finish_a11y();
}
let tree = builder.build();
let inventory: Vec<_> = tree
.nodes()
.map(|n| (n.role, n.name.clone(), n.description.clone()))
.collect();
assert_eq!(tree.node_count(), 1, "tree was {inventory:#?}");
let node = tree.nodes().next().expect("one node");
assert_ne!(
node.role,
ftui_a11y::node::A11yRole::Group,
"the block's Group must not be what survived: {inventory:#?}"
);
assert_eq!(node.name.as_deref(), Some("Notes"));
assert_eq!(
node.description.as_deref(),
Some("hello world"),
"the paragraph's text must reach the tree: {inventory:#?}"
);
}
#[test]
fn accessibility_truncates_long_unicode_without_panicking() {
use ftui_a11y::Accessible;
let para = Paragraph::new(Text::raw("界".repeat(210)));
let nodes = para.accessibility_nodes(Rect::new(0, 0, 10, 1));
let name = nodes[0]
.name
.as_deref()
.expect("paragraph should have a name");
assert!(name.ends_with("..."));
assert_eq!(name.chars().count(), 200);
}
#[test]
fn accessibility_truncates_description_when_block_title_present() {
use ftui_a11y::Accessible;
let para =
Paragraph::new(Text::raw("界".repeat(210))).block(Block::bordered().title("Body"));
let nodes = para.accessibility_nodes(Rect::new(0, 0, 10, 1));
let node = &nodes[0];
assert_eq!(node.name.as_deref(), Some("Body"));
let description = node
.description
.as_deref()
.expect("paragraph should have a description");
assert!(description.ends_with("..."));
assert_eq!(description.chars().count(), 200);
}
#[test]
fn accessibility_preserves_exactly_200_chars_without_ellipsis() {
use ftui_a11y::Accessible;
let para = Paragraph::new(Text::raw("界".repeat(200)));
let nodes = para.accessibility_nodes(Rect::new(0, 0, 10, 1));
let name = nodes[0]
.name
.as_deref()
.expect("paragraph should have a name");
assert!(!name.ends_with("..."));
assert_eq!(name.chars().count(), 200);
}
#[test]
fn accessibility_truncates_on_grapheme_boundaries() {
use ftui_a11y::Accessible;
let para = Paragraph::new(Text::raw("e\u{301}".repeat(210)));
let nodes = para.accessibility_nodes(Rect::new(0, 0, 10, 1));
let name = nodes[0]
.name
.as_deref()
.expect("paragraph should have a name");
let prefix = name
.strip_suffix("...")
.expect("paragraph should be truncated");
assert!(name.chars().count() <= 200);
assert_eq!(ftui_text::graphemes(prefix).count(), 98);
assert!(prefix.ends_with("e\u{301}"));
}
#[test]
fn paragraph_rtl_default_alignment_right() {
let sample = "مرحبا بالعالم";
let para = Paragraph::new(sample);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(40, 3, &mut pool);
frame.set_text_direction(ftui_render::TextDirection::Rtl);
let area = Rect::new(0, 0, 40, 3);
para.render(area, &mut frame);
let row = raw_row_text(&frame, 0);
assert!(
!row.ends_with(' '),
"RTL frame paragraph should right-align by default: {:?}",
row
);
let para_left = Paragraph::new(sample).alignment(Alignment::Left);
let mut frame_left = Frame::new(40, 3, &mut pool);
frame_left.set_text_direction(ftui_render::TextDirection::Rtl);
para_left.render(area, &mut frame_left);
let row_left = raw_row_text(&frame_left, 0);
assert!(
!row_left.starts_with(' '),
"Explicit Alignment::Left should left-align: {:?}",
row_left
);
}
#[cfg(feature = "bidi")]
#[test]
fn paragraph_rtl_visual_order_matches_unicode_bidi() {
let corpus = [
"مرحبا بكم",
"السلام عليكم",
"اللغة العربية جميلة",
"صباح الخير",
"استخدم Rust للبرمجة",
"مرحبا بكم في FrankenTUI",
"جرب Linux اليوم",
"تطبيق Terminal جديد",
"العدد هو 12345",
"سعر المنتج 50 دولار",
"عام 2026 الحالي",
"رقم 42 هو الجواب",
"هل أنت بخير؟",
"نعم، بالتأكيد!",
"واحد، اثنان، ثلاثة.",
"مرحبا يا عالم",
"שלום עולם",
"עברית ו-Rust",
"בוקר טוב ישראל",
"מספר 100 כאן",
];
for sample in corpus {
let para = Paragraph::new(sample).alignment(Alignment::Left);
let width = 60;
let mut pool = GraphemePool::new();
let mut frame = Frame::new(width, 1, &mut pool);
frame.set_text_direction(ftui_render::TextDirection::Rtl);
let area = Rect::new(0, 0, width, 1);
para.render(area, &mut frame);
let bidi_info = unicode_bidi::BidiInfo::new(sample, Some(unicode_bidi::Level::rtl()));
let oracle_reordered =
bidi_info.reorder_line(&bidi_info.paragraphs[0], 0..sample.len());
let row = raw_row_text(&frame, 0);
let rendered_trimmed = row.trim_end();
assert_eq!(
rendered_trimmed,
oracle_reordered.as_ref(),
"Mismatch for sample {:?}: got {:?}, expected oracle {:?}",
sample,
rendered_trimmed,
oracle_reordered
);
}
}
#[cfg(feature = "bidi")]
#[test]
fn paragraph_rtl_reorder_keeps_grapheme_clusters_whole() {
let cases = [
(
"\u{05E9}\u{05B8}\u{05C1}\u{05DC}\u{05D5}\u{05B9}\u{05DD}",
"\u{05DD}\u{05D5}\u{05B9}\u{05DC}\u{05E9}\u{05B8}\u{05C1}",
),
(
"\u{0628}\u{0650}\u{0633}\u{0652}\u{0645}\u{0650}",
"\u{0645}\u{0650}\u{0633}\u{0652}\u{0628}\u{0650}",
),
("a\u{0301} \u{05D0}\u{05D1}", "a\u{0301} \u{05D1}\u{05D0}"),
];
for (logical, visual) in cases {
for styled in [false, true] {
let text = if styled {
let mid = logical.char_indices().nth(1).unwrap().0;
FtuiText::from_spans([
Span::styled(&logical[..mid], Style::new().bold()),
Span::raw(&logical[mid..]),
])
} else {
FtuiText::raw(logical)
};
let (line, width) =
reorder_line_bidi(&text.lines()[0], ftui_text::bidi::ParagraphDirection::Auto);
let got: String = line.spans().iter().map(|s| s.content.as_ref()).collect();
assert_eq!(got, visual, "logical={logical:?} styled={styled}");
assert_eq!(width, display_width(logical), "logical={logical:?}");
}
}
}
#[cfg(feature = "bidi")]
#[test]
fn paragraph_wrap_then_reorder_per_line() {
let text = "هذا نص عربي طويل جدا لتجربة تقسيم الأسطر وإعادة الترتيب بشكل مستقل لكل سطر";
let width = 25;
let para = Paragraph::new(text)
.wrap(WrapMode::Word)
.alignment(Alignment::Left);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(width, 5, &mut pool);
frame.set_text_direction(ftui_render::TextDirection::Rtl);
let area = Rect::new(0, 0, width, 5);
para.render(area, &mut frame);
let cached = para.cached_wrapped_lines(width as usize, WrapMode::Word);
for (y, wrapped_line) in cached.lines.iter().take(3).enumerate() {
let logical_text: String = wrapped_line
.spans()
.iter()
.map(|s| s.content.as_ref())
.collect();
let expected =
ftui_text::bidi::reorder(&logical_text, ftui_text::bidi::ParagraphDirection::Rtl);
let row = raw_row_text(&frame, y as u16);
assert_eq!(
row.trim_end(),
expected.as_str(),
"Line {} mismatch against independently reordered wrapped line",
y
);
}
}
#[cfg(feature = "bidi")]
proptest::proptest! {
#[test]
fn paragraph_ltr_text_is_unchanged_by_direction_rtl(s in "[a-zA-Z0-9 _-]{1,30}") {
let area = Rect::new(0, 0, 40, 1);
let mut pool = GraphemePool::new();
let mut ltr_frame = Frame::new(40, 1, &mut pool);
ltr_frame.set_text_direction(ftui_render::TextDirection::Ltr);
Paragraph::new(s.as_str()).alignment(Alignment::Left).render(area, &mut ltr_frame);
let ltr_row = raw_row_text(<r_frame, 0);
let mut rtl_frame = Frame::new(40, 1, &mut pool);
rtl_frame.set_text_direction(ftui_render::TextDirection::Rtl);
Paragraph::new(s.as_str()).alignment(Alignment::Left).render(area, &mut rtl_frame);
let rtl_row = raw_row_text(&rtl_frame, 0);
proptest::prop_assert_eq!(ltr_row.trim_end(), rtl_row.trim_end());
}
}
#[cfg(not(feature = "bidi"))]
#[test]
fn paragraph_rtl_without_bidi_only_aligns_right() {
let sample = "مرحبا بالعالم";
let para = Paragraph::new(sample);
let mut pool = GraphemePool::new();
let mut frame = Frame::new(40, 1, &mut pool);
frame.set_text_direction(ftui_render::TextDirection::Rtl);
let area = Rect::new(0, 0, 40, 1);
para.render(area, &mut frame);
let row = raw_row_text(&frame, 0);
assert!(
!row.ends_with(' '),
"RTL frame paragraph should right-align even without bidi feature"
);
assert!(row.trim().starts_with("مرحبا"));
}
#[test]
fn paragraph_uses_arena_when_present() {
let text = "FrankenTUI deterministic buffer diffing and per-frame bump arena wrapping across multiple wrapped lines in an 80x24 viewport.";
let para = Paragraph::new(text).wrap(WrapMode::Word);
let area = Rect::new(0, 0, 28, 6);
let mut pool_no_arena = GraphemePool::new();
let mut frame_no_arena = Frame::new(28, 6, &mut pool_no_arena);
para.render(area, &mut frame_no_arena);
let arena = ftui_render::arena::FrameArena::new(0);
let mut pool_arena = GraphemePool::new();
let mut frame_arena = Frame::new(28, 6, &mut pool_arena);
frame_arena.set_arena(&arena);
para.render(area, &mut frame_arena);
assert!(
arena.allocated_bytes() > 0,
"Paragraph::render with WrapMode::Word must allocate in FrameArena when present"
);
for y in 0..6 {
assert_eq!(
raw_row_text(&frame_arena, y),
raw_row_text(&frame_no_arena, y),
"row {y} must match between arena and non-arena paragraph paths"
);
}
}
}