Add ViewLines struct to replace Vec<ViewLine>

src/components/choice.rs

@@ -7,7 +7,7 @@ use crate::{
 	display::DisplayColor,
 	input::{Event, InputOptions, KeyCode},
 	util::handle_view_data_scroll,
-	view::{LineSegment, ViewData, ViewLine},
+	view::{LineSegment, ViewData, ViewLine, ViewLines},
 };
 
 pub(crate) static INPUT_OPTIONS: LazyLock<InputOptions> =
@@ -44,7 +44,7 @@ where T: Clone
 		}
 	}
 
-	pub(crate) fn set_prompt(&mut self, prompt_lines: Vec<ViewLine>) {
+	pub(crate) fn set_prompt(&mut self, prompt_lines: ViewLines) {
 		self.view_data.update_view_data(|updater| {
 			updater.clear();
 			for line in prompt_lines {

src/components/choice/tests.rs

@@ -36,7 +36,7 @@ fn render_options_no_prompt() {
 #[test]
 fn render_options_prompt() {
 	let mut module = Choice::new(create_choices());
-	module.set_prompt(vec![ViewLine::from("Prompt")]);
+	module.set_prompt(ViewLines::from([ViewLine::from("Prompt")]));
 	assert_rendered_output!(
 		Style module.get_view_data(),
 		"{TITLE}",

src/modules/external_editor.rs

@@ -17,7 +17,7 @@ use crate::{
 	module::{ExitStatus, Module, State},
 	process::Results,
 	todo_file::{Line, TodoFile},
-	view::{RenderContext, ViewData, ViewLine},
+	view::{RenderContext, ViewData, ViewLine, ViewLines},
 };
 
 static INPUT_OPTIONS: LazyLock<InputOptions> = LazyLock::new(|| InputOptions::RESIZE);
@@ -181,7 +181,7 @@ impl ExternalEditor {
 				String::from("Undo modifications and edit rebase file"),
 			),
 		]);
-		empty_choice.set_prompt(vec![ViewLine::from("The rebase file is empty.")]);
+		empty_choice.set_prompt(ViewLines::from([ViewLine::from("The rebase file is empty.")]));
 
 		let error_choice = Choice::new(vec![
 			(Action::AbortRebase, '1', String::from("Abort rebase")),

src/modules/insert.rs

@@ -19,7 +19,7 @@ use crate::{
 	module::{Module, State},
 	process::Results,
 	todo_file::{Line, TodoFile},
-	view::{LineSegment, RenderContext, ViewData, ViewDataUpdater, ViewLine},
+	view::{LineSegment, RenderContext, ViewData, ViewDataUpdater, ViewLine, ViewLines},
 };
 
 pub(crate) struct Insert {
@@ -122,7 +122,7 @@ impl Insert {
 			(LineType::UpdateRef, 'u', String::from("update-ref <reference>")),
 			(LineType::Cancel, 'q', String::from("Cancel add line")),
 		]);
-		action_choices.set_prompt(vec![ViewLine::from("Select the type of line to insert:")]);
+		action_choices.set_prompt(ViewLines::from([ViewLine::from("Select the type of line to insert:")]));
 
 		Self {
 			action_choices,

src/test_helpers/assertions/assert_rendered_output/render_view_data.rs

@@ -20,30 +20,30 @@ pub(crate) fn render_view_data(view_data: &ViewData, options: AssertRenderOption
 	}
 
 	if !body_only {
-		let leading_lines = view_data.get_leading_lines();
+		let leading_lines = view_data.leading_lines();
 		if !leading_lines.is_empty() {
 			lines.push(String::from("{LEADING}"));
-			for line in leading_lines {
+			for line in leading_lines.iter() {
 				lines.push(render_view_line(line, Some(options)));
 			}
 		}
 	}
 
-	let body_lines = view_data.get_lines();
+	let body_lines = view_data.lines();
 	if !body_lines.is_empty() {
 		if !body_only {
 			lines.push(String::from("{BODY}"));
 		}
-		for line in body_lines {
+		for line in body_lines.iter() {
 			lines.push(render_view_line(line, Some(options)));
 		}
 	}
 
 	if !body_only {
-		let trailing_lines = view_data.get_trailing_lines();
+		let trailing_lines = view_data.trailing_lines();
 		if !trailing_lines.is_empty() {
 			lines.push(String::from("{TRAILING}"));
-			for line in trailing_lines {
+			for line in trailing_lines.iter() {
 				lines.push(render_view_line(line, Some(options)));
 			}
 		}

src/view.rs

@@ -18,6 +18,7 @@ mod thread;
 mod view_data;
 mod view_data_updater;
 mod view_line;
+mod view_lines;
 
 #[cfg(test)]
 mod tests;
@@ -35,6 +36,7 @@ pub(crate) use self::{
 	view_data::ViewData,
 	view_data_updater::ViewDataUpdater,
 	view_line::ViewLine,
+	view_lines::ViewLines,
 };
 use crate::display::{Display, DisplayColor, Tui};
 
@@ -101,17 +103,17 @@ impl<C: Tui> View<C> {
 			self.display.next_line()?;
 		}
 
-		let lines = render_slice.get_lines();
+		let view_lines = render_slice.view_lines();
 		let leading_line_count = render_slice.get_leading_lines_count();
 		let trailing_line_count = render_slice.get_trailing_lines_count();
-		let lines_count = lines.len() - leading_line_count - trailing_line_count;
+		let lines_count = view_lines.count() as usize - leading_line_count - trailing_line_count;
 		let show_scroll_bar = render_slice.should_show_scroll_bar();
 		let scroll_indicator_index = render_slice.get_scroll_index();
 		let view_height = window_height - leading_line_count - trailing_line_count;
 
-		let leading_lines_iter = lines.iter().take(leading_line_count);
-		let lines_iter = lines.iter().skip(leading_line_count).take(lines_count);
-		let trailing_lines_iter = lines.iter().skip(leading_line_count + lines_count);
+		let leading_lines_iter = view_lines.iter().take(leading_line_count);
+		let lines_iter = view_lines.iter().skip(leading_line_count).take(lines_count);
+		let trailing_lines_iter = view_lines.iter().skip(leading_line_count + lines_count);
 
 		for line in leading_lines_iter {
 			self.display.ensure_at_line_start()?;

src/view/render_slice.rs

@@ -9,13 +9,13 @@ use std::{
 };
 
 pub(crate) use self::render_action::RenderAction;
-use crate::view::{LineSegment, ScrollPosition, ViewData, ViewLine};
+use crate::view::{LineSegment, ScrollPosition, ViewData, ViewLine, ViewLines};
 
 #[derive(Debug)]
 pub(crate) struct RenderSlice {
 	actions: VecDeque<RenderAction>,
 	height: usize,
-	lines: Vec<ViewLine>,
+	lines: ViewLines,
 	lines_count: usize,
 	lines_leading_count: usize,
 	lines_trailing_count: usize,
@@ -36,7 +36,7 @@ impl RenderSlice {
 		Self {
 			actions: VecDeque::new(),
 			height: 0,
-			lines: vec![],
+			lines: ViewLines::new(),
 			lines_count: 0,
 			lines_leading_count: 0,
 			lines_trailing_count: 0,
@@ -187,7 +187,7 @@ impl RenderSlice {
 		self.lines_trailing_count
 	}
 
-	pub(crate) const fn get_lines(&self) -> &Vec<ViewLine> {
+	pub(crate) const fn view_lines(&self) -> &ViewLines {
 		&self.lines
 	}
 
@@ -214,8 +214,8 @@ impl RenderSlice {
 
 	fn set_padding_height(&mut self, view_data: &ViewData) {
 		let padding_height = if view_data.show_title() { 1 } else { 0 }
-			+ view_data.get_leading_lines().len()
-			+ view_data.get_trailing_lines().len();
+			+ view_data.leading_lines().count() as usize
+			+ view_data.trailing_lines().count() as usize;
 
 		if self.padding_height != padding_height {
 			self.padding_height = padding_height;
@@ -261,11 +261,10 @@ impl RenderSlice {
 		);
 	}
 
-	#[expect(clippy::too_many_lines, reason = "Legacy, needs refactor")]
 	fn rebuild(&mut self, view_data: &ViewData) {
-		let leading_lines_length = view_data.get_leading_lines().len();
-		let trailing_lines_length = view_data.get_trailing_lines().len();
-		let lines_length = view_data.get_lines().len();
+		let leading_lines_length = view_data.leading_lines().count() as usize;
+		let trailing_lines_length = view_data.trailing_lines().count() as usize;
+		let lines_length = view_data.lines().count() as usize;
 
 		self.version += 1;
 		self.view_data_name = String::from(view_data.get_name());
@@ -301,7 +300,7 @@ impl RenderSlice {
 
 			(
 				leading_lines_end,
-				Self::calculate_max_line_length(view_data.get_leading_lines(), 0, leading_lines_end),
+				Self::calculate_max_line_length(view_data.leading_lines(), 0, leading_lines_end),
 			)
 		};
 
@@ -327,7 +326,7 @@ impl RenderSlice {
 
 			(
 				trailing_lines_end,
-				Self::calculate_max_line_length(view_data.get_trailing_lines(), 0, trailing_lines_end),
+				Self::calculate_max_line_length(view_data.trailing_lines(), 0, trailing_lines_end),
 			)
 		};
 
@@ -352,7 +351,7 @@ impl RenderSlice {
 				available_height
 			};
 
-			let max_line_length = Self::calculate_max_line_length(view_data.get_lines(), lines_start, lines_end);
+			let max_line_length = Self::calculate_max_line_length(view_data.lines(), lines_start, lines_end);
 			(
 				lines_start,
 				lines_end,
@@ -373,17 +372,12 @@ impl RenderSlice {
 		}
 
 		self.lines.clear();
-		self.push_lines(view_data.get_leading_lines(), 0, leading_lines_end, false);
-		self.push_lines(
-			view_data.get_lines(),
-			lines_start,
-			lines_end,
-			self.should_show_scrollbar,
-		);
-		self.push_lines(view_data.get_trailing_lines(), 0, trailing_lines_end, false);
+		self.push_lines(view_data.leading_lines(), 0, leading_lines_end, false);
+		self.push_lines(view_data.lines(), lines_start, lines_end, self.should_show_scrollbar);
+		self.push_lines(view_data.trailing_lines(), 0, trailing_lines_end, false);
 	}
 
-	fn calculate_max_line_length(view_lines: &[ViewLine], start: usize, length: usize) -> usize {
+	fn calculate_max_line_length(view_lines: &ViewLines, start: usize, length: usize) -> usize {
 		view_lines
 			.iter()
 			.skip(start)
@@ -400,7 +394,7 @@ impl RenderSlice {
 			})
 	}
 
-	fn push_lines(&mut self, view_lines: &[ViewLine], start: usize, end: usize, scroll_bar: bool) {
+	fn push_lines(&mut self, view_lines: &ViewLines, start: usize, end: usize, scroll_bar: bool) {
 		let window_width = if scroll_bar && self.width > 0 {
 			self.width - 1
 		}

src/view/render_slice/tests.rs

@@ -23,17 +23,17 @@ fn assert_rendered(render_slice: &RenderSlice, expected: &[&str]) {
 		}
 	}
 
-	let lines = render_slice.get_lines();
-	if lines.is_empty() {
+	let view_lines = render_slice.view_lines();
+	if view_lines.is_empty() {
 		output.push(String::from("{EMPTY}"));
 	}
 	else {
 		let leading_line_count = render_slice.get_leading_lines_count();
 		let trailing_line_count = render_slice.get_trailing_lines_count();
-		let lines_count = lines.len() - leading_line_count - trailing_line_count;
-		let leading_lines = lines.iter().take(leading_line_count);
-		let body_lines = lines.iter().skip(leading_line_count).take(lines_count);
-		let trailing_lines = lines.iter().skip(leading_line_count + lines_count);
+		let lines_count = view_lines.count() as usize - leading_line_count - trailing_line_count;
+		let leading_lines = view_lines.iter().take(leading_line_count);
+		let body_lines = view_lines.iter().skip(leading_line_count).take(lines_count);
+		let trailing_lines = view_lines.iter().skip(leading_line_count + lines_count);
 
 		if leading_line_count > 0 {
 			output.push(String::from("{LEADING}"));
@@ -1237,40 +1237,40 @@ fn scroll_horizontal_with_segments() {
 
 #[test]
 fn calculate_max_line_length_max_first() {
-	let view_lines = [
+	let view_lines = ViewLines::from([
 		ViewLine::from(vec![LineSegment::new("0123456789"), LineSegment::new("012345")]),
 		ViewLine::from("012345"),
-	];
+	]);
 	assert_eq!(RenderSlice::calculate_max_line_length(&view_lines, 0, 1), 16);
 }
 
 #[test]
 fn calculate_max_line_length_max_last() {
-	let view_lines = [
+	let view_lines = ViewLines::from([
 		ViewLine::from("012345"),
 		ViewLine::from(vec![LineSegment::new("0123456789"), LineSegment::new("012345")]),
-	];
+	]);
 	assert_eq!(RenderSlice::calculate_max_line_length(&view_lines, 0, 2), 16);
 }
 
 #[test]
 fn calculate_max_line_length_with_slice() {
-	let view_lines = [
+	let view_lines = ViewLines::from([
 		ViewLine::from("012345"),
 		ViewLine::from("012345"),
 		ViewLine::from(vec![LineSegment::new("0123456789"), LineSegment::new("012345")]),
 		ViewLine::from(vec![LineSegment::new("0123456789"), LineSegment::new("01234567")]),
-	];
+	]);
 	assert_eq!(RenderSlice::calculate_max_line_length(&view_lines, 1, 2), 16);
 }
 
 #[test]
 fn calculate_max_line_length_ignore_pinned() {
-	let view_lines = [
+	let view_lines = ViewLines::from([
 		ViewLine::from("012345"),
 		ViewLine::from("012345"),
 		ViewLine::from(vec![LineSegment::new("0123456789"), LineSegment::new("012345")]),
 		ViewLine::new_pinned(vec![LineSegment::new("0123456789"), LineSegment::new("01234567")]),
-	];
+	]);
 	assert_eq!(RenderSlice::calculate_max_line_length(&view_lines, 0, 4), 16);
 }

src/view/thread/state.rs

@@ -276,8 +276,10 @@ mod tests {
 					.state
 					.render_slice()
 					.lock()
-					.get_lines()
-					.first()
+					.view_lines()
+					.iter()
+					.take(1)
+					.next()
 					.unwrap()
 					.get_segments()
 					.first()