fix(widgets)!: rename StatefulWidgetRef::render_ref to render_stateful_ref

This commit renames the `StatefulWidgetRef::render_ref` method to
`render_stateful_ref`. This helps avoid collisions with the `WidgetRef`
trait's `render_ref` method. This change is breaking and requires
updating all implementations of `StatefulWidgetRef`.

BREAKING CHANGE: `StatefulWidgetRef::render_ref` has been renamed to
`StatefulWidgetRef::render_stateful_ref`.

```diff
 trait StatefulWidgetRef {
     type State;
-    fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) { }
+    fn render_stateful_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) { }
 }
```

Partially addresses <https://github.com/ratatui-org/ratatui/issues/996>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,7 +2,7 @@
 name: Bug report
 about: Create an issue about a bug you encountered
 title: ''
-labels: 'Type: Bug'
+labels: bug
 assignees: ''
 ---
 
@@ -17,22 +17,26 @@ A detailed and complete issue is more likely to be processed quickly.
 A clear and concise description of what the bug is.
 -->
 
+
 ## To Reproduce
 <!--
 Try to reduce the issue to a simple code sample exhibiting the problem.
 Ideally, fork the project and add a test or an example.
 -->
 
+
 ## Expected behavior
 <!--
 A clear and concise description of what you expected to happen.
 -->
 
+
 ## Screenshots
 <!--
 If applicable, add screenshots, gifs or videos to help explain your problem.
 -->
 
+
 ## Environment
 <!--
 Add a description of the systems where you are observing the issue. For example:

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Frequently Asked Questions
-    url: https://ratatui.rs/faq/
-    about: Check the website FAQ section to see if your question has already been answered
-  - name: Ratatui Forum
-    url: https://forum.ratatui.rs
-    about: Ask questions about ratatui on our Forum
   - name: Discord Chat
     url: https://discord.gg/pMCEU9hNEj
     about: Ask questions about ratatui on Discord

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,7 +2,7 @@
 name: Feature request
 about: Suggest an idea for this project
 title: ''
-labels: 'Type: Enhancement'
+labels: enhancement
 assignees: ''
 
 ---

.github/workflows/check-pr.yml

@@ -71,7 +71,7 @@ jobs:
             issue_number: context.issue.number,
             owner: context.repo.owner,
             repo: context.repo.repo,
-            labels: ['Type: Breaking Change']
+            labels: ['breaking change']
           })
 
   do-not-merge:

BREAKING-CHANGES.md

@@ -10,15 +10,12 @@ GitHub with a [breaking change] label.
 
 This is a quick summary of the sections below:
 
-- [v0.27.0](#v0270)
-  - List no clamps the selected index to list
-  - Prelude items added / removed
+- [Unreleased](#unreleased)
   - 'termion' updated to 4.0
   - `Rect::inner` takes `Margin` directly instead of reference
   - `Buffer::filled` takes `Cell` directly instead of reference
   - `Stylize::bg()` now accepts `Into<Color>`
   - Removed deprecated `List::start_corner`
-  - `LineGauge::gauge_style` is deprecated
 - [v0.26.0](#v0260)
   - `Flex::Start` is the new default flex mode for `Layout`
   - `patch_style` & `reset_style` now consume and return `Self`
@@ -56,17 +53,21 @@ This is a quick summary of the sections below:
   - MSRV is now 1.63.0
   - `List` no longer ignores empty strings
 
-## [v0.27.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.27.0)
+## Unreleased
 
-### List no clamps the selected index to list ([#1159])
+### `StatefulWidgetRef::render_ref` renamed to `render_stateful_ref` [#1184]
 
-[#1149]: https://github.com/ratatui-org/ratatui/pull/1149
+[#1184]: https://github.com/ratatui-org/ratatui/pull/1184
 
-The `List` widget now clamps the selected index to the bounds of the list when navigating with
-`first`, `last`, `previous`, and `next`, as well as when setting the index directly with `select`.
+This change helps avoid collisions with `WidgetRef::render_ref`.
 
-Previously selecting an index past the end of the list would show treat the list as having a
-selection which was not visible. Now the last item in the list will be selected instead.
+```diff
+ trait StatefulWidgetRef {
+     type State;
+-    fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) { }
++    fn render_stateful_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) { }
+ }
+```
 
 ### Prelude items added / removed ([#1149])
 
@@ -113,6 +114,8 @@ To update your app:
 + let position: some_crate::Position = ...;
 ```
 
+[#1149]: https://github.com/ratatui-org/ratatui/pull/1149
+
 ### Termion is updated to 4.0 [#1106]
 
 Changelog: <https://gitlab.redox-os.org/redox-os/termion/-/blob/master/CHANGELOG.md>
@@ -178,19 +181,6 @@ flexible types from calling scopes, though it can break some type inference in t
 
 `layout::Corner` was removed entirely.
 
-### `LineGauge::gauge_style` is deprecated ([#565])
-
-[#565]: https://github.com/ratatui-org/ratatui/pull/1148
-
-`LineGauge::gauge_style` is deprecated and replaced with `LineGauge::filled_style` and `LineGauge::unfilled_style`:
-
-```diff
-let gauge = LineGauge::default()
-- .gauge_style(Style::default().fg(Color::Red).bg(Color::Blue)
-+ .filled_style(Style::default().fg(Color::Green))
-+ .unfilled_style(Style::default().fg(Color::White));
-```
-
 ## [v0.26.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.26.0)
 
 ### `Flex::Start` is the new default flex mode for `Layout` ([#881])

CHANGELOG.md

@@ -2,379 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [0.27.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.27.0) - 2024-06-24
-
-In this version, we have focused on enhancing usability and functionality with new features like
-background styles for LineGauge, palette colors, and various other improvements including
-improved performance. Also, we added brand new examples for tracing and creating hyperlinks!
-
-✨ **Release highlights**: <https://ratatui.rs/highlights/v027/>
-
-⚠️ List of breaking changes can be found [here](https://github.com/ratatui-org/ratatui/blob/main/BREAKING-CHANGES.md).
-
-### Features
-
-- [eef1afe](https://github.com/ratatui-org/ratatui/commit/eef1afe9155089dca489a9159c368a5ac07e7585) _(linegauge)_ Allow LineGauge background styles by @nowNick in [#565](https://github.com/ratatui-org/ratatui/pull/565)
-
-  ```text
-  This PR deprecates `gauge_style` in favor of `filled_style` and
-  `unfilled_style` which can have it's foreground and background styled.
-
-  `cargo run --example=line_gauge --features=crossterm`
-  ```
-
-  https://github.com/ratatui-org/ratatui/assets/5149215/5fb2ce65-8607-478f-8be4-092e08612f5b
-
-  Implements:<https://github.com/ratatui-org/ratatui/issues/424>
-
-- [1365620](https://github.com/ratatui-org/ratatui/commit/13656206064b53c7f86f179b570c7769399212a3) _(borders)_ Add FULL and EMPTY border sets by @joshka in [#1182](https://github.com/ratatui-org/ratatui/pull/1182)
-
-  `border::FULL` uses a full block symbol, while `border::EMPTY` uses an
-  empty space. This is useful for when you need to allocate space for the
-  border and apply the border style to a block without actually drawing a
-  border. This makes it possible to style the entire title area or a block
-  rather than just the title content.
-
-```rust
-use ratatui::{symbols::border, widgets::Block};
-let block = Block::bordered().title("Title").border_set(border::FULL);
-let block = Block::bordered().title("Title").border_set(border::EMPTY);
-```
-
-- [7a48c5b](https://github.com/ratatui-org/ratatui/commit/7a48c5b11b3d51b915ccc187d0499b6e0e88b89d) _(cell)_ Add EMPTY and (const) new method by @EdJoPaTo in [#1143](https://github.com/ratatui-org/ratatui/pull/1143)
-
-  ```text
-  This simplifies calls to `Buffer::filled` in tests.
-  ```
-
-- [3f2f2cd](https://github.com/ratatui-org/ratatui/commit/3f2f2cd6abf67a04809ff314025a462a3c2e2446) _(docs)_ Add tracing example by @joshka in [#1192](https://github.com/ratatui-org/ratatui/pull/1192)
-
-  ```text
-  Add an example that demonstrates logging to a file for:
-  ```
-
-  <https://forum.ratatui.rs/t/how-do-you-println-debug-your-tui-programs/66>
-
-```shell
-cargo run --example tracing
-RUST_LOG=trace cargo run --example=tracing
-cat tracing.log
-```
-
-![Made with VHS](https://vhs.charm.sh/vhs-21jgJCedh2YnFDONw0JW7l.gif)
-
-- [1520ed9](https://github.com/ratatui-org/ratatui/commit/1520ed9d106f99580a9e529212e43dac06a2f6d2) _(layout)_ Impl Display for Position and Size by @joshka in [#1162](https://github.com/ratatui-org/ratatui/pull/1162)
-
-- [46977d8](https://github.com/ratatui-org/ratatui/commit/46977d88519d28ccac1c94e171af0c9cca071dbc) _(list)_ Add list navigation methods (first, last, previous, next) by @joshka in [#1159](https://github.com/ratatui-org/ratatui/pull/1159) [**breaking**]
-
-  ```text
-  Also cleans up the list example significantly (see also
-  <https://github.com/ratatui-org/ratatui/issues/1157>)
-  ```
-
-  Fixes:<https://github.com/ratatui-org/ratatui/pull/1159>
-
-  BREAKING CHANGE:The `List` widget now clamps the selected index to the
-  bounds of the list when navigating with `first`, `last`, `previous`, and
-  `next`, as well as when setting the index directly with `select`.
-
-- [10d7788](https://github.com/ratatui-org/ratatui/commit/10d778866edea55207ff3f03d063c9fec619b9c9) _(style)_ Add conversions from the palette crate colors by @joshka in [#1172](https://github.com/ratatui-org/ratatui/pull/1172)
-
-  ````text
-  This is behind the "palette" feature flag.
-
-  ```rust
-  use palette::{LinSrgb, Srgb};
-  use ratatui::style::Color;
-
-  let color = Color::from(Srgb::new(1.0f32, 0.0, 0.0));
-  let color = Color::from(LinSrgb::new(1.0f32, 0.0, 0.0));
-  ```
-  ````
-
-- [7ef2dae](https://github.com/ratatui-org/ratatui/commit/7ef2daee060a7fe964a8de64eafcb6062228e035) _(text)_ support conversion from Display to Span, Line and Text by @orhun in [#1167](https://github.com/ratatui-org/ratatui/pull/1167)
-
-  ````text
-  Now you can create `Line` and `Text` from numbers like so:
-
-  ```rust
-  let line = 42.to_line();
-  let text = 666.to_text();
-  ```
-  ````
-
-- [74a32af](https://github.com/ratatui-org/ratatui/commit/74a32afbaef8851f9462b27094d88d518e56addf) _(uncategorized)_ Re-export backends from the ratatui crate by @joshka in [#1151](https://github.com/ratatui-org/ratatui/pull/1151)
-
-  ```text
-  `crossterm`, `termion`, and `termwiz` can now be accessed as
-  `ratatui::{crossterm, termion, termwiz}` respectively. This makes it
-  possible to just add the Ratatui crate as a dependency and use the
-  backend of choice without having to add the backend crates as
-  dependencies.
-
-  To update existing code, replace all instances of `crossterm::` with
-  `ratatui::crossterm::`, `termion::` with `ratatui::termion::`, and
-  `termwiz::` with `ratatui::termwiz::`.
-  ```
-
-- [3594180](https://github.com/ratatui-org/ratatui/commit/35941809e11ab43309dd83a8f67bb375f5e7ff2b) _(uncategorized)_ Make Stylize's `.bg(color)` generic by @kdheepak in [#1103](https://github.com/ratatui-org/ratatui/pull/1103) [**breaking**]
-
-- [0b5fd6b](https://github.com/ratatui-org/ratatui/commit/0b5fd6bf8eb64662df96900faea3608d4cbb3984) _(uncategorized)_ Add writer() and writer_mut() to termion and crossterm backends by @enricozb in [#991](https://github.com/ratatui-org/ratatui/pull/991)
-
-  ```text
-  It is sometimes useful to obtain access to the writer if we want to see
-  what has been written so far. For example, when using &mut [u8] as a
-  writer.
-  ```
-
-### Bug Fixes
-
-- [efa965e](https://github.com/ratatui-org/ratatui/commit/efa965e1e806c60cb1bdb2d1715f960db0857704) _(line)_ Remove newlines when converting strings to Lines by @joshka in [#1191](https://github.com/ratatui-org/ratatui/pull/1191)
-
-  `Line::from("a\nb")` now returns a line with two `Span`s instead of 1
-
-  Fixes:https://github.com/ratatui-org/ratatui/issues/1111
-
-- [d370aa7](https://github.com/ratatui-org/ratatui/commit/d370aa75af99da3e0c41ceb28e2d02ee81cd2538) _(span)_ Ensure that zero-width characters are rendered correctly by @joshka in [#1165](https://github.com/ratatui-org/ratatui/pull/1165)
-
-- [127d706](https://github.com/ratatui-org/ratatui/commit/127d706ee4876a58230f42f4a730b18671eae167) _(table)_ Ensure render offset without selection properly by @joshka in [#1187](https://github.com/ratatui-org/ratatui/pull/1187)
-
-  Fixes:<https://github.com/ratatui-org/ratatui/issues/1179>
-
-- [4bfdc15](https://github.com/ratatui-org/ratatui/commit/4bfdc15b80ba14489d359ab1f88564c3bd016c19) _(uncategorized)_ Render of &str and String doesn't respect area.width by @thscharler in [#1177](https://github.com/ratatui-org/ratatui/pull/1177)
-
-- [e6871b9](https://github.com/ratatui-org/ratatui/commit/e6871b9e21c25acf1e203f4860198c37aa9429a1) _(uncategorized)_ Avoid unicode-width breaking change in tests by @joshka in [#1171](https://github.com/ratatui-org/ratatui/pull/1171)
-
-  ```text
-  unicode-width 0.1.13 changed the width of \u{1} from 0 to 1.
-  Our tests assumed that \u{1} had a width of 0, so this change replaces
-  the \u{1} character with \u{200B} (zero width space) in the tests.
-
-  Upstream issue (closed as won't fix):
-  https://github.com/unicode-rs/unicode-width/issues/55
-  ```
-
-- [7f3efb0](https://github.com/ratatui-org/ratatui/commit/7f3efb02e6f846fc72079f0921abd2cee09d2d83) _(uncategorized)_ Pin unicode-width crate to 0.1.13 by @joshka in [#1170](https://github.com/ratatui-org/ratatui/pull/1170)
-
-  ```text
-  semver breaking change in 0.1.13
-  <https://github.com/unicode-rs/unicode-width/issues/55>
-
-  <!-- Please read CONTRIBUTING.md before submitting any pull request. -->
-  ```
-
-- [42cda6d](https://github.com/ratatui-org/ratatui/commit/42cda6d28706bf83308787ca784f374f6c286a02) _(uncategorized)_ Prevent panic from string_slice by @EdJoPaTo in [#1140](https://github.com/ratatui-org/ratatui/pull/1140)
-
-  <https://rust-lang.github.io/rust-clippy/master/index.html#string_slice>
-
-### Refactor
-
-- [73fd367](https://github.com/ratatui-org/ratatui/commit/73fd367a740924ce80ef7a0cd13a66b5094f7a54) _(block)_ Group builder pattern methods by @EdJoPaTo in [#1134](https://github.com/ratatui-org/ratatui/pull/1134)
-
-- [257db62](https://github.com/ratatui-org/ratatui/commit/257db6257f392a07ee238b439344d91566beb740) _(cell)_ Must_use and simplify style() by @EdJoPaTo in [#1124](https://github.com/ratatui-org/ratatui/pull/1124)
-
-  ```text
-  <!-- Please read CONTRIBUTING.md before submitting any pull request. -->
-  ```
-
-- [bf20369](https://github.com/ratatui-org/ratatui/commit/bf2036987f04d83f4f2b8338fab1b4fd7f4cc81d) _(cell)_ Reset instead of applying default by @EdJoPaTo in [#1127](https://github.com/ratatui-org/ratatui/pull/1127)
-
-  ```text
-  Using reset is clearer to me what actually happens. On the other case a
-  struct is created to override the old one completely which basically
-  does the same in a less clear way.
-  ```
-
-- [7d175f8](https://github.com/ratatui-org/ratatui/commit/7d175f85c1905c08adf547dd37cc89c63039f480) _(lint)_ Fix new lint warnings by @EdJoPaTo in [#1178](https://github.com/ratatui-org/ratatui/pull/1178)
-
-- [cf67ed9](https://github.com/ratatui-org/ratatui/commit/cf67ed9b884347cef034b09e0e9f9d4aff74ab0a) _(lint)_ Use clippy::or_fun_call by @EdJoPaTo in [#1138](https://github.com/ratatui-org/ratatui/pull/1138)
-
-  <https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call>
-
-- [4770e71](https://github.com/ratatui-org/ratatui/commit/4770e715819475cdca2f2ccdbac00cba203cd6d2) _(list)_ Remove deprecated `start_corner` and `Corner` by @Valentin271 in [#759](https://github.com/ratatui-org/ratatui/pull/759) [**breaking**]
-
-  `List::start_corner` was deprecated in v0.25. Use `List::direction` and
-  `ListDirection` instead.
-
-```diff
-- list.start_corner(Corner::TopLeft);
-- list.start_corner(Corner::TopRight);
-// This is not an error, BottomRight rendered top to bottom previously
-- list.start_corner(Corner::BottomRight);
-// all becomes
-+ list.direction(ListDirection::TopToBottom);
-```
-
-```diff
-- list.start_corner(Corner::BottomLeft);
-// becomes
-+ list.direction(ListDirection::BottomToTop);
-```
-
-`layout::Corner` is removed entirely.
-
-- [4f77910](https://github.com/ratatui-org/ratatui/commit/4f7791079edd16b54dc8cdfc95bb72b282a09576) _(padding)_ Add Padding::ZERO as a constant by @EdJoPaTo in [#1133](https://github.com/ratatui-org/ratatui/pull/1133)
-
-  ```text
-  Deprecate Padding::zero()
-  ```
-
-- [8061813](https://github.com/ratatui-org/ratatui/commit/8061813f324c08e11196e62fca22c2f6b9216b7e) _(uncategorized)_ Expand glob imports by @joshka in [#1152](https://github.com/ratatui-org/ratatui/pull/1152)
-
-  ```text
-  Consensus is that explicit imports make it easier to understand the
-  example code. This commit removes the prelude import from all examples
-  and replaces it with the necessary imports, and expands other glob
-  imports (widget::*, Constraint::*, KeyCode::*, etc.) everywhere else.
-  Prelude glob imports not in examples are not covered by this PR.
-
-  See https://github.com/ratatui-org/ratatui/issues/1150 for more details.
-  ```
-
-- [d929971](https://github.com/ratatui-org/ratatui/commit/d92997105bde15a1fd43829466ec8cc46bffe121) _(uncategorized)_ Dont manually impl Default for defaults by @EdJoPaTo in [#1142](https://github.com/ratatui-org/ratatui/pull/1142)
-
-  ```text
-  Replace `impl Default` by `#[derive(Default)]` when its implementation
-  equals.
-  ```
-
-- [8a60a56](https://github.com/ratatui-org/ratatui/commit/8a60a561c95691912cbf41d55866abafcba0127d) _(uncategorized)_ Needless_pass_by_ref_mut by @EdJoPaTo in [#1137](https://github.com/ratatui-org/ratatui/pull/1137)
-
-  <https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_ref_mut>
-
-- [1de9a82](https://github.com/ratatui-org/ratatui/commit/1de9a82b7a871a83995d224785cae139c6f4787b) _(uncategorized)_ Simplify if let by @EdJoPaTo in [#1135](https://github.com/ratatui-org/ratatui/pull/1135)
-
-  ```text
-  While looking through lints
-  [`clippy::option_if_let_else`](https://rust-lang.github.io/rust-clippy/master/index.html#option_if_let_else)
-  found these. Other findings are more complex so I skipped them.
-  ```
-
-### Documentation
-
-- [1908b06](https://github.com/ratatui-org/ratatui/commit/1908b06b4a497ff1cfb2c8d8c165d2a241ee1864) _(borders)_ Add missing closing code blocks by @orhun in [#1195](https://github.com/ratatui-org/ratatui/pull/1195)
-
-- [38bb196](https://github.com/ratatui-org/ratatui/commit/38bb19640449c7a3eee3a2fba6450071395e5e06) _(breaking-changes)_ Mention `LineGauge::gauge_style` by @orhun in [#1194](https://github.com/ratatui-org/ratatui/pull/1194)
-
-  see #565
-
-- [07efde5](https://github.com/ratatui-org/ratatui/commit/07efde5233752e1bcb7ae94a91b9e36b7fadb01b) _(examples)_ Add hyperlink example by @joshka in [#1063](https://github.com/ratatui-org/ratatui/pull/1063)
-
-- [7fdccaf](https://github.com/ratatui-org/ratatui/commit/7fdccafd52f4ddad1a3c9dda59fada59af21ecfa) _(examples)_ Add vhs tapes for constraint-explorer and minimal examples by @joshka in [#1164](https://github.com/ratatui-org/ratatui/pull/1164)
-
-- [4f307e6](https://github.com/ratatui-org/ratatui/commit/4f307e69db058891675d0f12d75ef49006c511d6) _(examples)_ Simplify paragraph example by @joshka in [#1169](https://github.com/ratatui-org/ratatui/pull/1169)
-
-  Related:https://github.com/ratatui-org/ratatui/issues/1157
-
-- [f429f68](https://github.com/ratatui-org/ratatui/commit/f429f688da536a52266144e63a1a7897ec6b7f26) _(examples)_ Remove lifetimes from the List example by @matta in [#1132](https://github.com/ratatui-org/ratatui/pull/1132)
-
-  ```text
-  Simplify the List example by removing lifetimes not strictly necessary
-  to demonstrate how Ratatui lists work. Instead, the sample strings are
-  copied into each `TodoItem`. To further simplify, I changed the code to
-  use a new TodoItem::new function, rather than an implementation of the
-  `From` trait.
-  ```
-
-- [308c1df](https://github.com/ratatui-org/ratatui/commit/308c1df6495ee4373f808007a1566ca7e9279933) _(readme)_ Add links to forum by @joshka in [#1188](https://github.com/ratatui-org/ratatui/pull/1188)
-
-- [2f8a936](https://github.com/ratatui-org/ratatui/commit/2f8a9363fc6c54fe2b10792c9f57fbb40b06bc0f) _(uncategorized)_ Fix links on docs.rs by @EdJoPaTo in [#1144](https://github.com/ratatui-org/ratatui/pull/1144)
-
-  ```text
-  This also results in a more readable Cargo.toml as the locations of the
-  things are more obvious now.
-
-  Includes rewording of the underline-color feature.
-
-  Logs of the errors: https://docs.rs/crate/ratatui/0.26.3/builds/1224962
-  Also see #989
-  ```
-
-### Performance
-
-- [4ce67fc](https://github.com/ratatui-org/ratatui/commit/4ce67fc84e3bc472e9ae97aece85f8ffae091834) _(buffer)_ Filled moves the cell to be filled by @EdJoPaTo in [#1148](https://github.com/ratatui-org/ratatui/pull/1148) [**breaking**]
-
-- [8b447ec](https://github.com/ratatui-org/ratatui/commit/8b447ec4d6276c3110285e663417487ff18dafc1) _(rect)_ `Rect::inner` takes `Margin` directly instead of reference by @EdJoPaTo in [#1008](https://github.com/ratatui-org/ratatui/pull/1008) [**breaking**]
-
-  BREAKING CHANGE:Margin needs to be passed without reference now.
-
-```diff
--let area = area.inner(&Margin {
-+let area = area.inner(Margin {
-     vertical: 0,
-     horizontal: 2,
- });
-```
-
-### Styling
-
-- [df4b706](https://github.com/ratatui-org/ratatui/commit/df4b706674de806bdf2a1fb8c04d0654b6b0b891) _(uncategorized)_ Enable more rustfmt settings by @EdJoPaTo in [#1125](https://github.com/ratatui-org/ratatui/pull/1125)
-
-### Testing
-
-- [d6587bc](https://github.com/ratatui-org/ratatui/commit/d6587bc6b0db955aeac6af167e1b8ef81a3afcc9) _(style)_ Use rstest by @EdJoPaTo in [#1136](https://github.com/ratatui-org/ratatui/pull/1136)
-
-  ```text
-  <!-- Please read CONTRIBUTING.md before submitting any pull request. -->
-  ```
-
-### Miscellaneous Tasks
-
-- [7b45f74](https://github.com/ratatui-org/ratatui/commit/7b45f74b719ff18329ddbf9f05a9ac53bf06f71d) _(prelude)_ Add / remove items by @joshka in [#1149](https://github.com/ratatui-org/ratatui/pull/1149) [**breaking**]
-
-  ```text
-  his PR removes the items from the prelude that don't form a coherent
-  common vocabulary and adds the missing items that do.
-
-  Based on a comment at
-  <https://www.reddit.com/r/rust/comments/1cle18j/comment/l2uuuh7/>
-  ```
-
-  BREAKING CHANGE:The following items have been removed from the prelude:
-
-- `style::Styled` - this trait is useful for widgets that want to
-  support the Stylize trait, but it adds complexity as widgets have two
-  `style` methods and a `set_style` method.
-- `symbols::Marker` - this item is used by code that needs to draw to
-  the `Canvas` widget, but it's not a common item that would be used by
-  most users of the library.
-- `terminal::{CompletedFrame, TerminalOptions, Viewport}` - these items
-  are rarely used by code that needs to interact with the terminal, and
-  they're generally only ever used once in any app.
-
-The following items have been added to the prelude:
-
-- `layout::{Position, Size}` - these items are used by code that needs
-  to interact with the layout system. These are newer items that were
-  added in the last few releases, which should be used more liberally.
-
-- [cd64367](https://github.com/ratatui-org/ratatui/commit/cd64367e244a1588206f653fd79678ce62a86a2f) _(symbols)_ Add tests for line symbols by @joshka in [#1186](https://github.com/ratatui-org/ratatui/pull/1186)
-
-- [8cfc316](https://github.com/ratatui-org/ratatui/commit/8cfc316bccb48e88660d14cd18c0df2264c4d6ce) _(uncategorized)_ Alphabetize examples in Cargo.toml by @joshka in [#1145](https://github.com/ratatui-org/ratatui/pull/1145)
-
-### Build
-
-- [70df102](https://github.com/ratatui-org/ratatui/commit/70df102de0154cdfbd6508659cf6ed649f820bc8) _(bench)_ Improve benchmark consistency by @EdJoPaTo in [#1126](https://github.com/ratatui-org/ratatui/pull/1126)
-
-  ```text
-  Codegen units are optimized on their own. Per default bench / release
-  have 16 codegen units. What ends up in a codeget unit is rather random
-  and can influence a benchmark result as a code change can move stuff
-  into a different codegen unit → prevent / allow LLVM optimizations
-  unrelated to the actual change.
-
-  More details: https://doc.rust-lang.org/cargo/reference/profiles.html
-  ```
-
-### New Contributors
-
-- @thscharler made their first contribution in [#1177](https://github.com/ratatui-org/ratatui/pull/1177)
-- @matta made their first contribution in [#1132](https://github.com/ratatui-org/ratatui/pull/1132)
-- @nowNick made their first contribution in [#565](https://github.com/ratatui-org/ratatui/pull/565)
-- @enricozb made their first contribution in [#991](https://github.com/ratatui-org/ratatui/pull/991)
-
-**Full Changelog**: https://github.com/ratatui-org/ratatui/compare/v0.26.3...v0.27.0
-
 ## [0.26.3](https://github.com/ratatui-org/ratatui/releases/tag/v0.26.3) - 2024-05-19
 
 We are happy to announce a brand new [**Ratatui Forum**](https://forum.ratatui.rs) 🐭 for Rust & TUI enthusiasts.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ratatui"
-version = "0.27.0" # crate version
+version = "0.26.3" # crate version
 authors = ["Florian Dehau <work@fdehau.com>", "The Ratatui Developers"]
 description = "A library that's all about cooking up terminal user interfaces"
 documentation = "https://docs.rs/ratatui/latest/ratatui/"
@@ -27,15 +27,15 @@ rust-version = "1.74.0"
 [dependencies]
 bitflags = "2.3"
 cassowary = "0.3"
-compact_str = "0.8.0"
+compact_str = "0.7.1"
 crossterm = { version = "0.27", optional = true }
 document-features = { version = "0.2.7", optional = true }
-instability = "0.3.1"
 itertools = "0.13"
 lru = "0.12.0"
 paste = "1.0.2"
 palette = { version = "0.7.6", optional = true }
 serde = { version = "1", optional = true, features = ["derive"] }
+stability = "0.2.0"
 strum = { version = "0.26", features = ["derive"] }
 strum_macros = { version = "0.26.3" }
 termion = { version = "4.0.0", optional = true }
@@ -48,20 +48,19 @@ unicode-width = "0.1.13"
 [dev-dependencies]
 anyhow = "1.0.71"
 argh = "0.1.12"
+better-panic = "0.3.0"
 color-eyre = "0.6.2"
 criterion = { version = "0.5.1", features = ["html_reports"] }
 derive_builder = "0.20.0"
 fakeit = "1.1"
 font8x8 = "0.3.1"
 indoc = "2"
+palette = "0.7.3"
 pretty_assertions = "1.4.0"
 rand = "0.8.5"
 rand_chacha = "0.3.1"
 rstest = "0.21.0"
 serde_json = "1.0.109"
-tracing = "0.1.40"
-tracing-appender = "0.2.3"
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 
 [lints.rust]
 unsafe_code = "forbid"
@@ -78,10 +77,6 @@ missing_panics_doc = "allow"
 module_name_repetitions = "allow"
 must_use_candidate = "allow"
 
-# we often split up a module into multiple files with the main type in a file named after the
-# module, so we want to allow this pattern
-module_inception = "allow"
-
 # nursery or restricted
 as_underscore = "warn"
 deref_by_slicing = "warn"
@@ -233,7 +228,7 @@ doc-scrape-examples = false
 
 [[example]]
 name = "colors_rgb"
-required-features = ["crossterm", "palette"]
+required-features = ["crossterm"]
 doc-scrape-examples = true
 
 [[example]]
@@ -258,7 +253,7 @@ doc-scrape-examples = false
 
 [[example]]
 name = "demo2"
-required-features = ["crossterm", "palette", "widget-calendar"]
+required-features = ["crossterm", "widget-calendar"]
 doc-scrape-examples = true
 
 [[example]]
@@ -296,11 +291,6 @@ name = "line_gauge"
 required-features = ["crossterm"]
 doc-scrape-examples = true
 
-[[example]]
-name = "hyperlink"
-required-features = ["crossterm", "unstable-widget-ref"]
-doc-scrape-examples = true
-
 [[example]]
 name = "list"
 required-features = ["crossterm"]
@@ -358,11 +348,6 @@ name = "tabs"
 required-features = ["crossterm"]
 doc-scrape-examples = true
 
-[[example]]
-name = "tracing"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
 [[example]]
 name = "user_input"
 required-features = ["crossterm"]

README.md

@@ -25,10 +25,10 @@
 
 <div align="center">
 
-[![Crate Badge]][Crate] [![Docs Badge]][API Docs] [![CI Badge]][CI Workflow] [![Deps.rs
-Badge]][Deps.rs]<br> [![Codecov Badge]][Codecov] [![License Badge]](./LICENSE) [![Sponsors
-Badge]][GitHub Sponsors]<br> [![Discord Badge]][Discord Server] [![Matrix Badge]][Matrix]
-[![Forum Badge]][Forum]<br>
+[![Crate Badge]][Crate] [![Docs Badge]][API Docs] [![CI Badge]][CI Workflow] [![License
+Badge]](./LICENSE) [![Sponsors Badge]][GitHub Sponsors]<br>
+[![Codecov Badge]][Codecov] [![Deps.rs Badge]][Deps.rs] [![Discord Badge]][Discord Server]
+[![Matrix Badge]][Matrix]<br>
 
 [Ratatui Website] · [API Docs] · [Examples] · [Changelog] · [Breaking Changes]<br>
 [Contributing] · [Report a bug] · [Request a Feature] · [Create a Pull Request]
@@ -67,7 +67,6 @@ terminal user interfaces and showcases the features of Ratatui, along with a hel
 ## Other documentation
 
 - [Ratatui Website] - explains the library's concepts and provides step-by-step tutorials
-- [Ratatui Forum][Forum] - a place to ask questions and discuss the library
 - [API Docs] - the full API documentation for the library on docs.rs.
 - [Examples] - a collection of examples that demonstrate how to use the library.
 - [Contributing] - Please read this if you are interested in contributing to the project.
@@ -340,8 +339,6 @@ Running this example produces the following output:
 [Docs Badge]: https://img.shields.io/docsrs/ratatui?logo=rust&style=flat-square&logoColor=E05D44
 [Matrix Badge]: https://img.shields.io/matrix/ratatui-general%3Amatrix.org?style=flat-square&logo=matrix&label=Matrix&color=C43AC3
 [Matrix]: https://matrix.to/#/#ratatui:matrix.org
-[Forum Badge]: https://img.shields.io/discourse/likes?server=https%3A%2F%2Fforum.ratatui.rs&style=flat-square&logo=discourse&label=forum&color=C43AC3
-[Forum]: https://forum.ratatui.rs
 [Sponsors Badge]: https://img.shields.io/github/sponsors/ratatui-org?logo=github&style=flat-square&color=1370D3
 
 <!-- cargo-rdme end -->
@@ -357,10 +354,9 @@ In order to organize ourselves, we currently use a [Discord server](https://disc
 feel free to join and come chat! There is also a [Matrix](https://matrix.org/) bridge available at
 [#ratatui:matrix.org](https://matrix.to/#/#ratatui:matrix.org).
 
-While we do utilize Discord for coordinating, it's not essential for contributing. We have recently
-launched the [Ratatui Forum][Forum], and our primary open-source workflow is centered around GitHub.
-For bugs and features, we rely on GitHub. Please [Report a bug], [Request a Feature] or [Create a
-Pull Request].
+While we do utilize Discord for coordinating, it's not essential for contributing.
+Our primary open-source workflow is centered around GitHub.
+For significant discussions, we rely on GitHub — please open an issue, a discussion or a PR.
 
 Please make sure you read the updated [contributing](./CONTRIBUTING.md) guidelines, especially if
 you are interested in working on a PR or issue opened in the previous repository.

examples/README.md

@@ -141,30 +141,6 @@ of the VHS tape.
 
 <https://github.com/ratatui-org/ratatui/assets/381361/485e775a-e0b5-4133-899b-1e8aeb56e774>
 
-## Constraint Explorer
-
-Demonstrates the behaviour of each
-[`Constraint`](https://docs.rs/ratatui/latest/ratatui/layout/enum.Constraint.html) option with
-respect to each other across different `Flex` modes.
-
-```shell
-cargo run --example=constraint-explorer --features=crossterm
-```
-
-![Constraint Explorer][constraint-explorer.gif]
-
-## Constraints
-
-Demonstrates how to use
-[`Constraint`](https://docs.rs/ratatui/latest/ratatui/layout/enum.Constraint.html) options for
-defining layout element sizes.
-
-![Constraints][constraints.gif]
-
-```shell
-cargo run --example=constraints --features=crossterm
-```
-
 ## Custom Widget
 
 Demonstrates how to implement the
@@ -188,17 +164,6 @@ cargo run --example=gauge --features=crossterm
 
 ![Gauge][gauge.gif]
 
-## Flex
-
-Demonstrates the different [`Flex`](https://docs.rs/ratatui/latest/ratatui/layout/enum.Flex.html)
-modes for controlling layout space distribution.
-
-```shell
-cargo run --example=flex --features=crossterm
-```
-
-![Flex][flex.gif]
-
 ## Line Gauge
 
 Demonstrates the [`Line
@@ -211,16 +176,6 @@ cargo run --example=line_gauge --features=crossterm
 
 ![LineGauge][line_gauge.gif]
 
-## Hyperlink
-
-Demonstrates how to use OSC 8 to create hyperlinks in the terminal.
-
-```shell
-cargo run --example=hyperlink --features="crossterm unstable-widget-ref"
-```
-
-![Hyperlink][hyperlink.gif]
-
 ## Inline
 
 Demonstrates how to use the
@@ -267,16 +222,6 @@ cargo run --example=modifiers --features=crossterm
 
 ![Modifiers][modifiers.gif]
 
-## Minimal
-
-Demonstrates how to create a minimal `Hello World!` program.
-
-```shell
-cargo run --example=minimal --features=crossterm
-```
-
-![Minimal][minimal.gif]
-
 ## Panic
 
 Demonstrates how to handle panics by ensuring that panic messages are written correctly to the
@@ -368,17 +313,6 @@ cargo run --example=tabs --features=crossterm
 
 ![Tabs][tabs.gif]
 
-## Tracing
-
-Demonstrates how to use the [tracing crate](https://crates.io/crates/tracing) for logging. Creates
-a file named `tracing.log` in the current directory.
-
-```shell
-cargo run --example=tracing --features=crossterm
-```
-
-![Tracing][tracing.gif]
-
 ## User Input
 
 Demonstrates one approach to accepting user input. Source [user_input.rs](./user_input.rs).
@@ -416,20 +350,15 @@ examples/vhs/generate.bash
 [canvas.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/canvas.gif?raw=true
 [chart.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/chart.gif?raw=true
 [colors.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/colors.gif?raw=true
-[constraint-explorer.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/constraint-explorer.gif?raw=true
-[constraints.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/constraints.gif?raw=true
 [custom_widget.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/custom_widget.gif?raw=true
 [demo.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/demo.gif?raw=true
 [demo2.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/demo2.gif?raw=true
-[flex.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/flex.gif?raw=true
 [gauge.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/gauge.gif?raw=true
 [hello_world.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/hello_world.gif?raw=true
-[hyperlink.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/hyperlink.gif?raw=true
 [inline.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/inline.gif?raw=true
 [layout.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/layout.gif?raw=true
 [list.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/list.gif?raw=true
 [line_gauge.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/line_gauge.gif?raw=true
-[minimal.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/minimal.gif?raw=true
 [modifiers.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/modifiers.gif?raw=true
 [panic.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/panic.gif?raw=true
 [paragraph.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/paragraph.gif?raw=true
@@ -439,7 +368,6 @@ examples/vhs/generate.bash
 [sparkline.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/sparkline.gif?raw=true
 [table.gif]:  https://vhs.charm.sh/vhs-6njXBytDf0rwPufUtmSSpI.gif
 [tabs.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/tabs.gif?raw=true
-[tracing.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/tracing.gif?raw=true
 [user_input.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/user_input.gif?raw=true
 
 [alpha version of Ratatui]: https://crates.io/crates/ratatui/versions

examples/chart.rs

@@ -153,18 +153,17 @@ fn run_app<B: Backend>(
 fn ui(frame: &mut Frame, app: &App) {
     let area = frame.size();
 
-    let [top, bottom] = Layout::vertical([Constraint::Fill(1); 2]).areas(area);
-    let [animated_chart, bar_chart] =
-        Layout::horizontal([Constraint::Fill(1), Constraint::Length(29)]).areas(top);
-    let [line_chart, scatter] = Layout::horizontal([Constraint::Fill(1); 2]).areas(bottom);
+    let vertical = Layout::vertical([Constraint::Percentage(40), Constraint::Percentage(60)]);
+    let horizontal = Layout::horizontal([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)]);
+    let [chart1, bottom] = vertical.areas(area);
+    let [line_chart, scatter] = horizontal.areas(bottom);
 
-    render_animated_chart(frame, animated_chart, app);
-    render_barchart(frame, bar_chart);
+    render_chart1(frame, chart1, app);
     render_line_chart(frame, line_chart);
     render_scatter(frame, scatter);
 }
 
-fn render_animated_chart(f: &mut Frame, area: Rect, app: &App) {
+fn render_chart1(f: &mut Frame, area: Rect, app: &App) {
     let x_labels = vec![
         Span::styled(
             format!("{}", app.window[0]),
@@ -190,7 +189,7 @@ fn render_animated_chart(f: &mut Frame, area: Rect, app: &App) {
     ];
 
     let chart = Chart::new(datasets)
-        .block(Block::bordered())
+        .block(Block::bordered().title("Chart 1".cyan().bold()))
         .x_axis(
             Axis::default()
                 .title("X Axis")
@@ -209,51 +208,6 @@ fn render_animated_chart(f: &mut Frame, area: Rect, app: &App) {
     f.render_widget(chart, area);
 }
 
-fn render_barchart(frame: &mut Frame, bar_chart: Rect) {
-    let dataset = Dataset::default()
-        .marker(symbols::Marker::HalfBlock)
-        .style(Style::new().fg(Color::Blue))
-        .graph_type(GraphType::Bar)
-        // a bell curve
-        .data(&[
-            (0., 0.4),
-            (10., 2.9),
-            (20., 13.5),
-            (30., 41.1),
-            (40., 80.1),
-            (50., 100.0),
-            (60., 80.1),
-            (70., 41.1),
-            (80., 13.5),
-            (90., 2.9),
-            (100., 0.4),
-        ]);
-
-    let chart = Chart::new(vec![dataset])
-        .block(
-            Block::bordered().title(
-                Title::default()
-                    .content("Bar chart".cyan().bold())
-                    .alignment(Alignment::Center),
-            ),
-        )
-        .x_axis(
-            Axis::default()
-                .style(Style::default().gray())
-                .bounds([0.0, 100.0])
-                .labels(vec!["0".bold(), "50".into(), "100.0".bold()]),
-        )
-        .y_axis(
-            Axis::default()
-                .style(Style::default().gray())
-                .bounds([0.0, 100.0])
-                .labels(vec!["0".bold(), "50".into(), "100.0".bold()]),
-        )
-        .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
-
-    frame.render_widget(chart, bar_chart);
-}
-
 fn render_line_chart(f: &mut Frame, area: Rect) {
     let datasets = vec![Dataset::default()
         .name("Line from only 2 points".italic())

examples/hyperlink.rs

@@ -1,151 +0,0 @@
-//! # [Ratatui] Hyperlink examplew
-//!
-//! Shows how to use [OSC 8] to create hyperlinks in the terminal.
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [OSC 8]: https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
-
-use std::{
-    io::{self, stdout, Stdout},
-    panic,
-};
-
-use color_eyre::{
-    config::{EyreHook, HookBuilder, PanicHook},
-    eyre, Result,
-};
-use crossterm::{
-    event::{self, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use itertools::Itertools;
-use ratatui::{prelude::*, widgets::WidgetRef};
-
-fn main() -> Result<()> {
-    init_error_handling()?;
-    let mut terminal = init_terminal()?;
-    let app = App::new();
-    app.run(&mut terminal)?;
-    restore_terminal()?;
-    Ok(())
-}
-
-struct App {
-    hyperlink: Hyperlink<'static>,
-}
-
-impl App {
-    fn new() -> Self {
-        let text = Line::from(vec!["Example ".into(), "hyperlink".blue()]);
-        let hyperlink = Hyperlink::new(text, "https://example.com");
-        Self { hyperlink }
-    }
-
-    fn run(self, terminal: &mut Terminal<CrosstermBackend<Stdout>>) -> io::Result<()> {
-        loop {
-            terminal.draw(|frame| frame.render_widget(&self.hyperlink, frame.size()))?;
-            if let Event::Key(key) = event::read()? {
-                if matches!(key.code, KeyCode::Char('q') | KeyCode::Esc) {
-                    break;
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-/// A hyperlink widget that renders a hyperlink in the terminal using [OSC 8].
-///
-/// [OSC 8]: https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
-struct Hyperlink<'content> {
-    text: Text<'content>,
-    url: String,
-}
-
-impl<'content> Hyperlink<'content> {
-    fn new(text: impl Into<Text<'content>>, url: impl Into<String>) -> Self {
-        Self {
-            text: text.into(),
-            url: url.into(),
-        }
-    }
-}
-
-impl WidgetRef for Hyperlink<'_> {
-    fn render_ref(&self, area: Rect, buffer: &mut Buffer) {
-        self.text.render_ref(area, buffer);
-
-        // this is a hacky workaround for https://github.com/ratatui-org/ratatui/issues/902, a bug
-        // in the terminal code that incorrectly calculates the width of ANSI escape sequences. It
-        // works by rendering the hyperlink as a series of 2-character chunks, which is the
-        // calculated width of the hyperlink text.
-        for (i, two_chars) in self
-            .text
-            .to_string()
-            .chars()
-            .chunks(2)
-            .into_iter()
-            .enumerate()
-        {
-            let text = two_chars.collect::<String>();
-            let hyperlink = format!("\x1B]8;;{}\x07{}\x1B]8;;\x07", self.url, text);
-            buffer
-                .get_mut(area.x + i as u16 * 2, area.y)
-                .set_symbol(hyperlink.as_str());
-        }
-    }
-}
-
-/// Initialize the terminal with raw mode and alternate screen.
-fn init_terminal() -> io::Result<Terminal<CrosstermBackend<Stdout>>> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    Terminal::new(CrosstermBackend::new(stdout()))
-}
-
-/// Restore the terminal to its original state.
-fn restore_terminal() -> io::Result<()> {
-    disable_raw_mode()?;
-    execute!(stdout(), LeaveAlternateScreen)?;
-    Ok(())
-}
-
-/// Initialize error handling with color-eyre.
-pub fn init_error_handling() -> Result<()> {
-    let (panic_hook, eyre_hook) = HookBuilder::default().into_hooks();
-    set_panic_hook(panic_hook);
-    set_error_hook(eyre_hook)?;
-    Ok(())
-}
-
-/// Install a panic hook that restores the terminal before printing the panic.
-fn set_panic_hook(panic_hook: PanicHook) {
-    let panic_hook = panic_hook.into_panic_hook();
-    panic::set_hook(Box::new(move |panic_info| {
-        let _ = restore_terminal();
-        panic_hook(panic_info);
-    }));
-}
-
-/// Install an error hook that restores the terminal before printing the error.
-fn set_error_hook(eyre_hook: EyreHook) -> Result<()> {
-    let eyre_hook = eyre_hook.into_eyre_hook();
-    eyre::set_hook(Box::new(move |error| {
-        let _ = restore_terminal();
-        eyre_hook(error)
-    }))?;
-    Ok(())
-}

examples/list.rs

@@ -13,19 +13,19 @@
 //! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
 //! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
 
-use std::{error::Error, io};
+use std::{error::Error, io, io::stdout};
 
-use crossterm::event::KeyEvent;
+use color_eyre::config::HookBuilder;
 use ratatui::{
-    backend::Backend,
+    backend::{Backend, CrosstermBackend},
     buffer::Buffer,
-    crossterm::event::{self, Event, KeyCode, KeyEventKind},
-    layout::{Constraint, Layout, Rect},
-    style::{
-        palette::tailwind::{BLUE, GREEN, SLATE},
-        Color, Modifier, Style, Stylize,
+    crossterm::{
+        event::{self, Event, KeyCode, KeyEventKind},
+        terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+        ExecutableCommand,
     },
-    symbols,
+    layout::{Alignment, Constraint, Layout, Rect},
+    style::{palette::tailwind, Color, Modifier, Style, Stylize},
     terminal::Terminal,
     text::Line,
     widgets::{
@@ -34,302 +34,342 @@ use ratatui::{
     },
 };
 
-const TODO_HEADER_STYLE: Style = Style::new().fg(SLATE.c100).bg(BLUE.c800);
-const NORMAL_ROW_BG: Color = SLATE.c950;
-const ALT_ROW_BG_COLOR: Color = SLATE.c900;
-const SELECTED_STYLE: Style = Style::new().bg(SLATE.c800).add_modifier(Modifier::BOLD);
-const TEXT_FG_COLOR: Color = SLATE.c200;
-const COMPLETED_TEXT_FG_COLOR: Color = GREEN.c500;
+const TODO_HEADER_BG: Color = tailwind::BLUE.c950;
+const NORMAL_ROW_COLOR: Color = tailwind::SLATE.c950;
+const ALT_ROW_COLOR: Color = tailwind::SLATE.c900;
+const SELECTED_STYLE_FG: Color = tailwind::BLUE.c300;
+const TEXT_COLOR: Color = tailwind::SLATE.c200;
+const COMPLETED_TEXT_COLOR: Color = tailwind::GREEN.c500;
 
-fn main() -> Result<(), Box<dyn Error>> {
-    tui::init_error_hooks()?;
-    let terminal = tui::init_terminal()?;
-
-    let mut app = App::default();
-    app.run(terminal)?;
-
-    tui::restore_terminal()?;
-    Ok(())
+#[derive(Copy, Clone)]
+enum Status {
+    Todo,
+    Completed,
 }
 
-/// This struct holds the current state of the app. In particular, it has the `todo_list` field
-/// which is a wrapper around `ListState`. Keeping track of the state lets us render the
-/// associated widget with its state and have access to features such as natural scrolling.
-///
-/// Check the event handling at the bottom to see how to change the state on incoming events. Check
-/// the drawing logic for items on how to specify the highlighting style for selected items.
-struct App {
-    should_exit: bool,
-    todo_list: TodoList,
-}
-
-struct TodoList {
-    items: Vec<TodoItem>,
-    state: ListState,
-}
-
-#[derive(Debug)]
 struct TodoItem {
     todo: String,
     info: String,
     status: Status,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-enum Status {
-    Todo,
-    Completed,
-}
-
-impl Default for App {
-    fn default() -> Self {
-        Self {
-            should_exit: false,
-            todo_list: TodoList::from_iter([
-                (Status::Todo, "Rewrite everything with Rust!", "I can't hold my inner voice. He tells me to rewrite the complete universe with Rust"),
-                (Status::Completed, "Rewrite all of your tui apps with Ratatui", "Yes, you heard that right. Go and replace your tui with Ratatui."),
-                (Status::Todo, "Pet your cat", "Minnak loves to be pet by you! Don't forget to pet and give some treats!"),
-                (Status::Todo, "Walk with your dog", "Max is bored, go walk with him!"),
-                (Status::Completed, "Pay the bills", "Pay the train subscription!!!"),
-                (Status::Completed, "Refactor list example", "If you see this info that means I completed this task!"),
-            ]),
-        }
-    }
-}
-
-impl FromIterator<(Status, &'static str, &'static str)> for TodoList {
-    fn from_iter<I: IntoIterator<Item = (Status, &'static str, &'static str)>>(iter: I) -> Self {
-        let items = iter
-            .into_iter()
-            .map(|(status, todo, info)| TodoItem::new(status, todo, info))
-            .collect();
-        let state = ListState::default();
-        Self { items, state }
-    }
-}
-
 impl TodoItem {
-    fn new(status: Status, todo: &str, info: &str) -> Self {
+    fn new(todo: &str, info: &str, status: Status) -> Self {
         Self {
-            status,
             todo: todo.to_string(),
             info: info.to_string(),
+            status,
         }
     }
 }
 
+struct TodoList {
+    state: ListState,
+    items: Vec<TodoItem>,
+    last_selected: Option<usize>,
+}
+
+/// This struct holds the current state of the app. In particular, it has the `items` field which is
+/// a wrapper around `ListState`. Keeping track of the items state let us render the associated
+/// widget with its state and have access to features such as natural scrolling.
+///
+/// Check the event handling at the bottom to see how to change the state on incoming events.
+/// Check the drawing logic for items on how to specify the highlighting style for selected items.
+struct App {
+    items: TodoList,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // setup terminal
+    init_error_hooks()?;
+    let terminal = init_terminal()?;
+
+    // create app and run it
+    App::new().run(terminal)?;
+
+    restore_terminal()?;
+
+    Ok(())
+}
+
+fn init_error_hooks() -> color_eyre::Result<()> {
+    let (panic, error) = HookBuilder::default().into_hooks();
+    let panic = panic.into_panic_hook();
+    let error = error.into_eyre_hook();
+    color_eyre::eyre::set_hook(Box::new(move |e| {
+        let _ = restore_terminal();
+        error(e)
+    }))?;
+    std::panic::set_hook(Box::new(move |info| {
+        let _ = restore_terminal();
+        panic(info);
+    }));
+    Ok(())
+}
+
+fn init_terminal() -> color_eyre::Result<Terminal<impl Backend>> {
+    enable_raw_mode()?;
+    stdout().execute(EnterAlternateScreen)?;
+    let backend = CrosstermBackend::new(stdout());
+    let terminal = Terminal::new(backend)?;
+    Ok(terminal)
+}
+
+fn restore_terminal() -> color_eyre::Result<()> {
+    disable_raw_mode()?;
+    stdout().execute(LeaveAlternateScreen)?;
+    Ok(())
+}
+
 impl App {
-    fn run(&mut self, mut terminal: Terminal<impl Backend>) -> io::Result<()> {
-        while !self.should_exit {
-            terminal.draw(|f| f.render_widget(&mut *self, f.size()))?;
-            if let Event::Key(key) = event::read()? {
-                self.handle_key(key);
-            };
+    fn new() -> Self {
+        Self {
+            items: TodoList::with_items(&[
+                ("Rewrite everything with Rust!", "I can't hold my inner voice. He tells me to rewrite the complete universe with Rust", Status::Todo),
+                ("Rewrite all of your tui apps with Ratatui", "Yes, you heard that right. Go and replace your tui with Ratatui.", Status::Completed),
+                ("Pet your cat", "Minnak loves to be pet by you! Don't forget to pet and give some treats!", Status::Todo),
+                ("Walk with your dog", "Max is bored, go walk with him!", Status::Todo),
+                ("Pay the bills", "Pay the train subscription!!!", Status::Completed),
+                ("Refactor list example", "If you see this info that means I completed this task!", Status::Completed),
+            ]),
         }
-        Ok(())
-    }
-
-    fn handle_key(&mut self, key: KeyEvent) {
-        if key.kind != KeyEventKind::Press {
-            return;
-        }
-        match key.code {
-            KeyCode::Char('q') | KeyCode::Esc => self.should_exit = true,
-            KeyCode::Char('h') | KeyCode::Left => self.select_none(),
-            KeyCode::Char('j') | KeyCode::Down => self.select_next(),
-            KeyCode::Char('k') | KeyCode::Up => self.select_previous(),
-            KeyCode::Char('g') | KeyCode::Home => self.select_first(),
-            KeyCode::Char('G') | KeyCode::End => self.select_last(),
-            KeyCode::Char('l') | KeyCode::Right | KeyCode::Enter => {
-                self.toggle_status();
-            }
-            _ => {}
-        }
-    }
-
-    fn select_none(&mut self) {
-        self.todo_list.state.select(None);
-    }
-
-    fn select_next(&mut self) {
-        self.todo_list.state.select_next();
-    }
-    fn select_previous(&mut self) {
-        self.todo_list.state.select_previous();
-    }
-
-    fn select_first(&mut self) {
-        self.todo_list.state.select_first();
-    }
-
-    fn select_last(&mut self) {
-        self.todo_list.state.select_last();
     }
 
     /// Changes the status of the selected list item
-    fn toggle_status(&mut self) {
-        if let Some(i) = self.todo_list.state.selected() {
-            self.todo_list.items[i].status = match self.todo_list.items[i].status {
+    fn change_status(&mut self) {
+        if let Some(i) = self.items.state.selected() {
+            self.items.items[i].status = match self.items.items[i].status {
                 Status::Completed => Status::Todo,
                 Status::Todo => Status::Completed,
             }
         }
     }
+
+    fn go_top(&mut self) {
+        self.items.state.select(Some(0));
+    }
+
+    fn go_bottom(&mut self) {
+        self.items.state.select(Some(self.items.items.len() - 1));
+    }
+}
+
+impl App {
+    fn run(&mut self, mut terminal: Terminal<impl Backend>) -> io::Result<()> {
+        loop {
+            self.draw(&mut terminal)?;
+
+            if let Event::Key(key) = event::read()? {
+                if key.kind == KeyEventKind::Press {
+                    match key.code {
+                        KeyCode::Char('q') | KeyCode::Esc => return Ok(()),
+                        KeyCode::Char('h') | KeyCode::Left => self.items.unselect(),
+                        KeyCode::Char('j') | KeyCode::Down => self.items.next(),
+                        KeyCode::Char('k') | KeyCode::Up => self.items.previous(),
+                        KeyCode::Char('l') | KeyCode::Right | KeyCode::Enter => {
+                            self.change_status();
+                        }
+                        KeyCode::Char('g') => self.go_top(),
+                        KeyCode::Char('G') => self.go_bottom(),
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+
+    fn draw(&mut self, terminal: &mut Terminal<impl Backend>) -> io::Result<()> {
+        terminal.draw(|f| f.render_widget(self, f.size()))?;
+        Ok(())
+    }
 }
 
 impl Widget for &mut App {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        let [header_area, main_area, footer_area] = Layout::vertical([
+        // Create a space for header, todo list and the footer.
+        let vertical = Layout::vertical([
             Constraint::Length(2),
-            Constraint::Fill(1),
-            Constraint::Length(1),
-        ])
-        .areas(area);
+            Constraint::Min(0),
+            Constraint::Length(2),
+        ]);
+        let [header_area, rest_area, footer_area] = vertical.areas(area);
 
-        let [list_area, item_area] =
-            Layout::vertical([Constraint::Fill(1), Constraint::Fill(1)]).areas(main_area);
+        // Create two chunks with equal vertical screen space. One for the list and the other for
+        // the info block.
+        let vertical = Layout::vertical([Constraint::Percentage(50), Constraint::Percentage(50)]);
+        let [upper_item_list_area, lower_item_list_area] = vertical.areas(rest_area);
 
-        App::render_header(header_area, buf);
-        App::render_footer(footer_area, buf);
-        self.render_list(list_area, buf);
-        self.render_selected_item(item_area, buf);
+        render_title(header_area, buf);
+        self.render_todo(upper_item_list_area, buf);
+        self.render_info(lower_item_list_area, buf);
+        render_footer(footer_area, buf);
     }
 }
 
-/// Rendering logic for the app
 impl App {
-    fn render_header(area: Rect, buf: &mut Buffer) {
-        Paragraph::new("Ratatui List Example")
-            .bold()
-            .centered()
-            .render(area, buf);
-    }
+    fn render_todo(&mut self, area: Rect, buf: &mut Buffer) {
+        // We create two blocks, one is for the header (outer) and the other is for list (inner).
+        let outer_block = Block::new()
+            .borders(Borders::NONE)
+            .title_alignment(Alignment::Center)
+            .title("TODO List")
+            .fg(TEXT_COLOR)
+            .bg(TODO_HEADER_BG);
+        let inner_block = Block::new()
+            .borders(Borders::NONE)
+            .fg(TEXT_COLOR)
+            .bg(NORMAL_ROW_COLOR);
 
-    fn render_footer(area: Rect, buf: &mut Buffer) {
-        Paragraph::new("Use ↓↑ to move, ← to unselect, → to change status, g/G to go top/bottom.")
-            .centered()
-            .render(area, buf);
-    }
+        // We get the inner area from outer_block. We'll use this area later to render the table.
+        let outer_area = area;
+        let inner_area = outer_block.inner(outer_area);
 
-    fn render_list(&mut self, area: Rect, buf: &mut Buffer) {
-        let block = Block::new()
-            .title(Line::raw("TODO List").centered())
-            .borders(Borders::TOP)
-            .border_set(symbols::border::EMPTY)
-            .border_style(TODO_HEADER_STYLE)
-            .bg(NORMAL_ROW_BG);
+        // We can render the header in outer_area.
+        outer_block.render(outer_area, buf);
 
         // Iterate through all elements in the `items` and stylize them.
         let items: Vec<ListItem> = self
-            .todo_list
+            .items
             .items
             .iter()
             .enumerate()
-            .map(|(i, todo_item)| {
-                let color = alternate_colors(i);
-                ListItem::from(todo_item).bg(color)
-            })
+            .map(|(i, todo_item)| todo_item.to_list_item(i))
             .collect();
 
         // Create a List from all list items and highlight the currently selected one
-        let list = List::new(items)
-            .block(block)
-            .highlight_style(SELECTED_STYLE)
+        let items = List::new(items)
+            .block(inner_block)
+            .highlight_style(
+                Style::default()
+                    .add_modifier(Modifier::BOLD)
+                    .add_modifier(Modifier::REVERSED)
+                    .fg(SELECTED_STYLE_FG),
+            )
             .highlight_symbol(">")
             .highlight_spacing(HighlightSpacing::Always);
 
-        // We need to disambiguate this trait method as both `Widget` and `StatefulWidget` share the
-        // same method name `render`.
-        StatefulWidget::render(list, area, buf, &mut self.todo_list.state);
+        // We can now render the item list
+        // (look careful we are using StatefulWidget's render.)
+        // ratatui::widgets::StatefulWidget::render as stateful_render
+        StatefulWidget::render(items, inner_area, buf, &mut self.items.state);
     }
 
-    fn render_selected_item(&self, area: Rect, buf: &mut Buffer) {
+    fn render_info(&self, area: Rect, buf: &mut Buffer) {
         // We get the info depending on the item's state.
-        let info = if let Some(i) = self.todo_list.state.selected() {
-            match self.todo_list.items[i].status {
-                Status::Completed => format!("✓ DONE: {}", self.todo_list.items[i].info),
-                Status::Todo => format!("☐ TODO: {}", self.todo_list.items[i].info),
+        let info = if let Some(i) = self.items.state.selected() {
+            match self.items.items[i].status {
+                Status::Completed => format!("✓ DONE: {}", self.items.items[i].info),
+                Status::Todo => format!("TODO: {}", self.items.items[i].info),
             }
         } else {
-            "Nothing selected...".to_string()
+            "Nothing to see here...".to_string()
         };
 
         // We show the list item's info under the list in this paragraph
-        let block = Block::new()
-            .title(Line::raw("TODO Info").centered())
-            .borders(Borders::TOP)
-            .border_set(symbols::border::EMPTY)
-            .border_style(TODO_HEADER_STYLE)
-            .bg(NORMAL_ROW_BG)
-            .padding(Padding::horizontal(1));
+        let outer_info_block = Block::new()
+            .borders(Borders::NONE)
+            .title_alignment(Alignment::Center)
+            .title("TODO Info")
+            .fg(TEXT_COLOR)
+            .bg(TODO_HEADER_BG);
+        let inner_info_block = Block::new()
+            .borders(Borders::NONE)
+            .padding(Padding::horizontal(1))
+            .bg(NORMAL_ROW_COLOR);
+
+        // This is a similar process to what we did for list. outer_info_area will be used for
+        // header inner_info_area will be used for the list info.
+        let outer_info_area = area;
+        let inner_info_area = outer_info_block.inner(outer_info_area);
+
+        // We can render the header. Inner info will be rendered later
+        outer_info_block.render(outer_info_area, buf);
+
+        let info_paragraph = Paragraph::new(info)
+            .block(inner_info_block)
+            .fg(TEXT_COLOR)
+            .wrap(Wrap { trim: false });
 
         // We can now render the item info
-        Paragraph::new(info)
-            .block(block)
-            .fg(TEXT_FG_COLOR)
-            .wrap(Wrap { trim: false })
-            .render(area, buf);
+        info_paragraph.render(inner_info_area, buf);
     }
 }
 
-const fn alternate_colors(i: usize) -> Color {
-    if i % 2 == 0 {
-        NORMAL_ROW_BG
-    } else {
-        ALT_ROW_BG_COLOR
-    }
+fn render_title(area: Rect, buf: &mut Buffer) {
+    Paragraph::new("Ratatui List Example")
+        .bold()
+        .centered()
+        .render(area, buf);
 }
 
-impl From<&TodoItem> for ListItem<'_> {
-    fn from(value: &TodoItem) -> Self {
-        let line = match value.status {
-            Status::Todo => Line::styled(format!(" ☐ {}", value.todo), TEXT_FG_COLOR),
-            Status::Completed => {
-                Line::styled(format!(" ✓ {}", value.todo), COMPLETED_TEXT_FG_COLOR)
+fn render_footer(area: Rect, buf: &mut Buffer) {
+    Paragraph::new("\nUse ↓↑ to move, ← to unselect, → to change status, g/G to go top/bottom.")
+        .centered()
+        .render(area, buf);
+}
+
+impl TodoList {
+    fn with_items(items: &[(&str, &str, Status)]) -> Self {
+        Self {
+            state: ListState::default(),
+            items: items
+                .iter()
+                .map(|(todo, info, status)| TodoItem::new(todo, info, *status))
+                .collect(),
+            last_selected: None,
+        }
+    }
+
+    fn next(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i >= self.items.len() - 1 {
+                    0
+                } else {
+                    i + 1
+                }
             }
+            None => self.last_selected.unwrap_or(0),
         };
-        ListItem::new(line)
+        self.state.select(Some(i));
+    }
+
+    fn previous(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i == 0 {
+                    self.items.len() - 1
+                } else {
+                    i - 1
+                }
+            }
+            None => self.last_selected.unwrap_or(0),
+        };
+        self.state.select(Some(i));
+    }
+
+    fn unselect(&mut self) {
+        let offset = self.state.offset();
+        self.last_selected = self.state.selected();
+        self.state.select(None);
+        *self.state.offset_mut() = offset;
     }
 }
 
-mod tui {
-    use std::{io, io::stdout};
+impl TodoItem {
+    fn to_list_item(&self, index: usize) -> ListItem {
+        let bg_color = match index % 2 {
+            0 => NORMAL_ROW_COLOR,
+            _ => ALT_ROW_COLOR,
+        };
+        let line = match self.status {
+            Status::Todo => Line::styled(format!(" ☐ {}", self.todo), TEXT_COLOR),
+            Status::Completed => Line::styled(
+                format!(" ✓ {}", self.todo),
+                (COMPLETED_TEXT_COLOR, bg_color),
+            ),
+        };
 
-    use color_eyre::config::HookBuilder;
-    use ratatui::{
-        backend::{Backend, CrosstermBackend},
-        crossterm::{
-            terminal::{
-                disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
-            },
-            ExecutableCommand,
-        },
-        terminal::Terminal,
-    };
-
-    pub fn init_error_hooks() -> color_eyre::Result<()> {
-        let (panic, error) = HookBuilder::default().into_hooks();
-        let panic = panic.into_panic_hook();
-        let error = error.into_eyre_hook();
-        color_eyre::eyre::set_hook(Box::new(move |e| {
-            let _ = restore_terminal();
-            error(e)
-        }))?;
-        std::panic::set_hook(Box::new(move |info| {
-            let _ = restore_terminal();
-            panic(info);
-        }));
-        Ok(())
-    }
-
-    pub fn init_terminal() -> io::Result<Terminal<impl Backend>> {
-        stdout().execute(EnterAlternateScreen)?;
-        enable_raw_mode()?;
-        Terminal::new(CrosstermBackend::new(stdout()))
-    }
-
-    pub fn restore_terminal() -> io::Result<()> {
-        stdout().execute(LeaveAlternateScreen)?;
-        disable_raw_mode()
+        ListItem::new(line).bg(bg_color)
     }
 }

examples/tracing.rs

@@ -1,154 +0,0 @@
-//! # [Ratatui] Tracing example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
-
-// A simple example demonstrating how to use the [tracing] with Ratatui to log to a file.
-//
-// This example demonstrates how to use the [tracing] crate with Ratatui to log to a file. The
-// example sets up a simple logger that logs to a file named `tracing.log` in the current directory.
-//
-// Run the example with `cargo run --example tracing` and then view the `tracing.log` file to see
-// the logs. To see more logs, you can run the example with `RUST_LOG=tracing=debug cargo run
-// --example`
-//
-// For a helpful widget that handles logging, see the [tui-logger] crate.
-//
-// [tracing]: https://crates.io/crates/tracing
-// [tui-logger]: https://crates.io/crates/tui-logger
-
-use std::{fs::File, io::stdout, panic, time::Duration};
-
-use color_eyre::{
-    config::HookBuilder,
-    eyre::{self, Context},
-    Result,
-};
-use crossterm::{
-    event::{self, Event, KeyCode},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    terminal::Terminal,
-    widgets::{Block, Paragraph},
-};
-use tracing::{debug, info, instrument, trace, Level};
-use tracing_appender::{non_blocking, non_blocking::WorkerGuard};
-use tracing_subscriber::EnvFilter;
-
-fn main() -> Result<()> {
-    init_error_hooks()?;
-    let _guard = init_tracing()?;
-    info!("Starting tracing example");
-
-    let mut terminal = init_terminal()?;
-    let mut events = vec![]; // a buffer to store the recent events to display in the UI
-    while !should_exit(&events) {
-        handle_events(&mut events)?;
-        terminal.draw(|frame| ui(frame, &events))?;
-    }
-    restore_terminal()?;
-    info!("Exiting tracing example");
-    println!("See the tracing.log file for the logs");
-    Ok(())
-}
-
-fn should_exit(events: &[Event]) -> bool {
-    events
-        .iter()
-        .any(|event| matches!(event, Event::Key(key) if key.code == KeyCode::Char('q')))
-}
-
-/// Handle events and insert them into the events vector keeping only the last 10 events
-#[instrument(skip(events))]
-fn handle_events(events: &mut Vec<Event>) -> Result<()> {
-    // Render the UI at least once every 100ms
-    if event::poll(Duration::from_millis(100))? {
-        let event = event::read()?;
-        debug!(?event);
-        events.insert(0, event);
-    }
-    events.truncate(10);
-    Ok(())
-}
-
-#[instrument(skip_all)]
-fn ui(frame: &mut ratatui::Frame, events: &[Event]) {
-    // To view this event, run the example with `RUST_LOG=tracing=debug cargo run --example tracing`
-    trace!(frame_count = frame.count(), event_count = events.len());
-    let area = frame.size();
-    let events = events.iter().map(|e| format!("{e:?}")).collect::<Vec<_>>();
-    let paragraph = Paragraph::new(events.join("\n"))
-        .block(Block::bordered().title("Tracing example. Press 'q' to quit."));
-    frame.render_widget(paragraph, area);
-}
-
-/// Initialize the tracing subscriber to log to a file
-///
-/// This function initializes the tracing subscriber to log to a file named `tracing.log` in the
-/// current directory. The function returns a [`WorkerGuard`] that must be kept alive for the
-/// duration of the program to ensure that logs are flushed to the file on shutdown. The logs are
-/// written in a non-blocking fashion to ensure that the logs do not block the main thread.
-fn init_tracing() -> Result<WorkerGuard> {
-    let file = File::create("tracing.log").wrap_err("failed to create tracing.log")?;
-    let (non_blocking, guard) = non_blocking(file);
-
-    // By default, the subscriber is configured to log all events with a level of `DEBUG` or higher,
-    // but this can be changed by setting the `RUST_LOG` environment variable.
-    let env_filter = EnvFilter::builder()
-        .with_default_directive(Level::DEBUG.into())
-        .from_env_lossy();
-
-    tracing_subscriber::fmt()
-        .with_writer(non_blocking)
-        .with_env_filter(env_filter)
-        .init();
-    Ok(guard)
-}
-
-/// Initialize the error hooks to ensure that the terminal is restored to a sane state before
-/// exiting
-fn init_error_hooks() -> Result<()> {
-    let (panic, error) = HookBuilder::default().into_hooks();
-    let panic = panic.into_panic_hook();
-    let error = error.into_eyre_hook();
-    eyre::set_hook(Box::new(move |e| {
-        let _ = restore_terminal();
-        error(e)
-    }))?;
-    panic::set_hook(Box::new(move |info| {
-        let _ = restore_terminal();
-        panic(info);
-    }));
-    Ok(())
-}
-
-#[instrument]
-fn init_terminal() -> Result<Terminal<impl Backend>> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout());
-    let terminal = Terminal::new(backend)?;
-    debug!("terminal initialized");
-    Ok(terminal)
-}
-
-#[instrument]
-fn restore_terminal() -> Result<()> {
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    debug!("terminal restored");
-    Ok(())
-}

examples/vhs/constraint-explorer.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/constraint-explorer.tape`
+# To run this script, install vhs and run `vhs ./examples/constraints.tape`
 Output "target/constraint-explorer.gif"
 Set Theme "Aardvark Blue"
 Set FontSize 18

examples/vhs/demo2-destroy.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/demo2-destroy.tape`
+# To run this script, install vhs and run `vhs ./examples/demo.tape`
 # NOTE: Requires VHS 0.6.1 or later for Screenshot support
 Output "target/demo2-destroy.gif"
 Set Theme "Aardvark Blue"

examples/vhs/demo2-social.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/demo2-social.tape`
+# To run this script, install vhs and run `vhs ./examples/demo.tape`
 
 Output "target/demo2-social.gif"
 Set Theme "Aardvark Blue"

examples/vhs/demo2.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/demo2.tape`
+# To run this script, install vhs and run `vhs ./examples/demo.tape`
 # NOTE: Requires VHS 0.6.1 or later for Screenshot support
 Output "target/demo2.gif"
 Set Theme "Aardvark Blue"

examples/vhs/docsrs.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/docsrs.tape`
+# To run this script, install vhs and run `vhs ./examples/demo.tape`
 # NOTE: Requires VHS 0.6.1 or later for Screenshot support
 Output "target/docsrs.gif"
 Set Theme "Aardvark Blue"

examples/vhs/flex.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/flex.tape`
+# To run this script, install vhs and run `vhs ./examples/layout.tape`
 Output "target/flex.gif"
 Set Theme "Aardvark Blue"
 Set Width 1200

examples/vhs/hyperlink.tape

@@ -1,15 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/hyperlink.tape`
-Output "target/hyperlink.gif"
-Set Theme "Aardvark Blue"
-Set Width 1200
-Set Height 200
-Hide
-Type "cargo run --example=hyperlink --features=crossterm,unstable-widget-ref"
-Enter
-Sleep 3s
-Show
-Sleep 1s
-Hide
-Type "q"
-

examples/vhs/minimal.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/minimal.tape`
+# To run this script, install vhs and run `vhs ./examples/hello_world.tape`
 Output "target/minimal.gif"
 Set Theme "Aardvark Blue"
 Set Width 1200

examples/vhs/ratatui-logo.tape

@@ -1,5 +1,5 @@
 # This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/ratatui-logo.tape`
+# To run this script, install vhs and run `vhs ./examples/popup.tape`
 Output "target/ratatui-logo.gif"
 Set Theme "Aardvark Blue"
 Set Width 550

examples/vhs/tracing.tape

@@ -1,12 +0,0 @@
-# This is a vhs script. See https://github.com/charmbracelet/vhs for more info.
-# To run this script, install vhs and run `vhs ./examples/tracing.tape`
-Output "target/tracing.gif"
-Set Theme "Aardvark Blue"
-Set Width 1200
-Set Height 800
-Type "RUST_LOG=trace cargo run --example=tracing" Enter
-Sleep 1s
-Type @100ms "jjjjq"
-Sleep 1s
-Type "cat tracing.log" Enter
-Sleep 10s

src/backend/crossterm.rs

@@ -106,7 +106,7 @@ where
     }
 
     /// Gets the writer.
-    #[instability::unstable(
+    #[stability::unstable(
         feature = "backend-writer",
         issue = "https://github.com/ratatui-org/ratatui/pull/991"
     )]
@@ -118,7 +118,7 @@ where
     ///
     /// Note: writing to the writer may cause incorrect output after the write. This is due to the
     /// way that the Terminal implements diffing Buffers.
-    #[instability::unstable(
+    #[stability::unstable(
         feature = "backend-writer",
         issue = "https://github.com/ratatui-org/ratatui/pull/991"
     )]

src/backend/termion.rs

@@ -88,7 +88,7 @@ where
     }
 
     /// Gets the writer.
-    #[instability::unstable(
+    #[stability::unstable(
         feature = "backend-writer",
         issue = "https://github.com/ratatui-org/ratatui/pull/991"
     )]
@@ -99,7 +99,7 @@ where
     /// Gets the writer as a mutable reference.
     /// Note: writing to the writer may cause incorrect output after the write. This is due to the
     /// way that the Terminal implements diffing Buffers.
-    #[instability::unstable(
+    #[stability::unstable(
         feature = "backend-writer",
         issue = "https://github.com/ratatui-org/ratatui/pull/991"
     )]

src/buffer.rs

@@ -2,6 +2,7 @@
 //! A module for the [`Buffer`] and [`Cell`] types.
 
 mod assert;
+#[allow(clippy::module_inception)]
 mod buffer;
 mod cell;
 

src/buffer/buffer.rs

@@ -192,7 +192,7 @@ impl Buffer {
     }
 
     /// Print at most the first n characters of a string if enough space is available
-    /// until the end of the line. Skips zero-width graphemes and control characters.
+    /// until the end of the line.
     ///
     /// Use [`Buffer::set_string`] when the maximum amount of characters can be printed.
     pub fn set_stringn<T, S>(
@@ -210,7 +210,6 @@ impl Buffer {
         let max_width = max_width.try_into().unwrap_or(u16::MAX);
         let mut remaining_width = self.area.right().saturating_sub(x).min(max_width);
         let graphemes = UnicodeSegmentation::graphemes(string.as_ref(), true)
-            .filter(|symbol| !symbol.contains(|char: char| char.is_control()))
             .map(|symbol| (symbol, symbol.width() as u16))
             .filter(|(_symbol, width)| *width > 0)
             .map_while(|(symbol, width)| {
@@ -932,35 +931,4 @@ mod tests {
         buf.set_string(0, 1, "bar", Style::new().blue());
         assert_eq!(buf, Buffer::with_lines(["foo".red(), "bar".blue()]));
     }
-
-    #[test]
-    fn control_sequence_rendered_full() {
-        let text = "I \x1b[0;36mwas\x1b[0m here!";
-
-        let mut buffer = Buffer::filled(Rect::new(0, 0, 25, 3), Cell::new("x"));
-        buffer.set_string(1, 1, text, Style::new());
-
-        let expected = Buffer::with_lines([
-            "xxxxxxxxxxxxxxxxxxxxxxxxx",
-            "xI [0;36mwas[0m here!xxxx",
-            "xxxxxxxxxxxxxxxxxxxxxxxxx",
-        ]);
-        assert_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn control_sequence_rendered_partially() {
-        let text = "I \x1b[0;36mwas\x1b[0m here!";
-
-        let mut buffer = Buffer::filled(Rect::new(0, 0, 11, 3), Cell::new("x"));
-        buffer.set_string(1, 1, text, Style::new());
-
-        #[rustfmt::skip]
-        let expected = Buffer::with_lines([
-            "xxxxxxxxxxx",
-            "xI [0;36mwa",
-            "xxxxxxxxxxx",
-        ]);
-        assert_eq!(buffer, expected);
-    }
 }

src/buffer/cell.rs

@@ -41,11 +41,11 @@ impl Cell {
     ///
     /// This works at compile time and puts the symbol onto the stack. Fails to build when the
     /// symbol doesnt fit onto the stack and requires to be placed on the heap. Use
-    /// `Self::default().set_symbol()` in that case. See [`CompactString::const_new`] for more
+    /// `Self::default().set_symbol()` in that case. See [`CompactString::new_inline`] for more
     /// details on this.
-    pub const fn new(symbol: &'static str) -> Self {
+    pub const fn new(symbol: &str) -> Self {
         Self {
-            symbol: CompactString::const_new(symbol),
+            symbol: CompactString::new_inline(symbol),
             fg: Color::Reset,
             bg: Color::Reset,
             #[cfg(feature = "underline-color")]
@@ -139,7 +139,7 @@ impl Cell {
 
     /// Resets the cell to the empty state.
     pub fn reset(&mut self) {
-        self.symbol = CompactString::const_new(" ");
+        self.symbol = CompactString::new_inline(" ");
         self.fg = Color::Reset;
         self.bg = Color::Reset;
         #[cfg(feature = "underline-color")]
@@ -167,7 +167,7 @@ mod tests {
         assert_eq!(
             cell,
             Cell {
-                symbol: CompactString::const_new("あ"),
+                symbol: CompactString::new_inline("あ"),
                 fg: Color::Reset,
                 bg: Color::Reset,
                 #[cfg(feature = "underline-color")]

src/layout.rs

@@ -4,6 +4,7 @@ mod alignment;
 mod constraint;
 mod direction;
 mod flex;
+#[allow(clippy::module_inception)]
 mod layout;
 mod margin;
 mod position;

src/layout/constraint.rs

@@ -310,7 +310,7 @@ impl Constraint {
     /// ```rust
     /// # use ratatui::prelude::*;
     /// # let area = Rect::default();
-    /// let constraints = Constraint::from_fills([1, 2, 3]);
+    /// let constraints = Constraint::from_mins([1, 2, 3]);
     /// let layout = Layout::default().constraints(constraints).split(area);
     /// ```
     pub fn from_fills<T>(proportional_factors: T) -> Vec<Self>

src/lib.rs

@@ -2,10 +2,10 @@
 //!
 //! <div align="center">
 //!
-//! [![Crate Badge]][Crate] [![Docs Badge]][API Docs] [![CI Badge]][CI Workflow] [![Deps.rs
-//! Badge]][Deps.rs]<br> [![Codecov Badge]][Codecov] [![License Badge]](./LICENSE) [![Sponsors
-//! Badge]][GitHub Sponsors]<br> [![Discord Badge]][Discord Server] [![Matrix Badge]][Matrix]
-//! [![Forum Badge]][Forum]<br>
+//! [![Crate Badge]][Crate] [![Docs Badge]][API Docs] [![CI Badge]][CI Workflow] [![License
+//! Badge]](./LICENSE) [![Sponsors Badge]][GitHub Sponsors]<br>
+//! [![Codecov Badge]][Codecov] [![Deps.rs Badge]][Deps.rs] [![Discord Badge]][Discord Server]
+//! [![Matrix Badge]][Matrix]<br>
 //!
 //! [Ratatui Website] · [API Docs] · [Examples] · [Changelog] · [Breaking Changes]<br>
 //! [Contributing] · [Report a bug] · [Request a Feature] · [Create a Pull Request]
@@ -44,7 +44,6 @@
 //! ## Other documentation
 //!
 //! - [Ratatui Website] - explains the library's concepts and provides step-by-step tutorials
-//! - [Ratatui Forum][Forum] - a place to ask questions and discuss the library
 //! - [API Docs] - the full API documentation for the library on docs.rs.
 //! - [Examples] - a collection of examples that demonstrate how to use the library.
 //! - [Contributing] - Please read this if you are interested in contributing to the project.
@@ -319,8 +318,6 @@
 //! [Docs Badge]: https://img.shields.io/docsrs/ratatui?logo=rust&style=flat-square&logoColor=E05D44
 //! [Matrix Badge]: https://img.shields.io/matrix/ratatui-general%3Amatrix.org?style=flat-square&logo=matrix&label=Matrix&color=C43AC3
 //! [Matrix]: https://matrix.to/#/#ratatui:matrix.org
-//! [Forum Badge]: https://img.shields.io/discourse/likes?server=https%3A%2F%2Fforum.ratatui.rs&style=flat-square&logo=discourse&label=forum&color=C43AC3
-//! [Forum]: https://forum.ratatui.rs
 //! [Sponsors Badge]: https://img.shields.io/github/sponsors/ratatui-org?logo=github&style=flat-square&color=1370D3
 
 // show the feature flags in the generated documentation

src/symbols.rs

@@ -1,8 +1,5 @@
 use strum::{Display, EnumString};
 
-pub mod border;
-pub mod line;
-
 pub mod block {
     pub const FULL: &str = "█";
     pub const SEVEN_EIGHTHS: &str = "▉";
@@ -117,6 +114,364 @@ pub mod bar {
     };
 }
 
+pub mod line {
+    pub const VERTICAL: &str = "│";
+    pub const DOUBLE_VERTICAL: &str = "║";
+    pub const THICK_VERTICAL: &str = "┃";
+
+    pub const HORIZONTAL: &str = "─";
+    pub const DOUBLE_HORIZONTAL: &str = "═";
+    pub const THICK_HORIZONTAL: &str = "━";
+
+    pub const TOP_RIGHT: &str = "┐";
+    pub const ROUNDED_TOP_RIGHT: &str = "╮";
+    pub const DOUBLE_TOP_RIGHT: &str = "╗";
+    pub const THICK_TOP_RIGHT: &str = "┓";
+
+    pub const TOP_LEFT: &str = "┌";
+    pub const ROUNDED_TOP_LEFT: &str = "╭";
+    pub const DOUBLE_TOP_LEFT: &str = "╔";
+    pub const THICK_TOP_LEFT: &str = "┏";
+
+    pub const BOTTOM_RIGHT: &str = "┘";
+    pub const ROUNDED_BOTTOM_RIGHT: &str = "╯";
+    pub const DOUBLE_BOTTOM_RIGHT: &str = "╝";
+    pub const THICK_BOTTOM_RIGHT: &str = "┛";
+
+    pub const BOTTOM_LEFT: &str = "└";
+    pub const ROUNDED_BOTTOM_LEFT: &str = "╰";
+    pub const DOUBLE_BOTTOM_LEFT: &str = "╚";
+    pub const THICK_BOTTOM_LEFT: &str = "┗";
+
+    pub const VERTICAL_LEFT: &str = "┤";
+    pub const DOUBLE_VERTICAL_LEFT: &str = "╣";
+    pub const THICK_VERTICAL_LEFT: &str = "┫";
+
+    pub const VERTICAL_RIGHT: &str = "├";
+    pub const DOUBLE_VERTICAL_RIGHT: &str = "╠";
+    pub const THICK_VERTICAL_RIGHT: &str = "┣";
+
+    pub const HORIZONTAL_DOWN: &str = "┬";
+    pub const DOUBLE_HORIZONTAL_DOWN: &str = "╦";
+    pub const THICK_HORIZONTAL_DOWN: &str = "┳";
+
+    pub const HORIZONTAL_UP: &str = "┴";
+    pub const DOUBLE_HORIZONTAL_UP: &str = "╩";
+    pub const THICK_HORIZONTAL_UP: &str = "┻";
+
+    pub const CROSS: &str = "┼";
+    pub const DOUBLE_CROSS: &str = "╬";
+    pub const THICK_CROSS: &str = "╋";
+
+    #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+    pub struct Set {
+        pub vertical: &'static str,
+        pub horizontal: &'static str,
+        pub top_right: &'static str,
+        pub top_left: &'static str,
+        pub bottom_right: &'static str,
+        pub bottom_left: &'static str,
+        pub vertical_left: &'static str,
+        pub vertical_right: &'static str,
+        pub horizontal_down: &'static str,
+        pub horizontal_up: &'static str,
+        pub cross: &'static str,
+    }
+
+    impl Default for Set {
+        fn default() -> Self {
+            NORMAL
+        }
+    }
+
+    pub const NORMAL: Set = Set {
+        vertical: VERTICAL,
+        horizontal: HORIZONTAL,
+        top_right: TOP_RIGHT,
+        top_left: TOP_LEFT,
+        bottom_right: BOTTOM_RIGHT,
+        bottom_left: BOTTOM_LEFT,
+        vertical_left: VERTICAL_LEFT,
+        vertical_right: VERTICAL_RIGHT,
+        horizontal_down: HORIZONTAL_DOWN,
+        horizontal_up: HORIZONTAL_UP,
+        cross: CROSS,
+    };
+
+    pub const ROUNDED: Set = Set {
+        top_right: ROUNDED_TOP_RIGHT,
+        top_left: ROUNDED_TOP_LEFT,
+        bottom_right: ROUNDED_BOTTOM_RIGHT,
+        bottom_left: ROUNDED_BOTTOM_LEFT,
+        ..NORMAL
+    };
+
+    pub const DOUBLE: Set = Set {
+        vertical: DOUBLE_VERTICAL,
+        horizontal: DOUBLE_HORIZONTAL,
+        top_right: DOUBLE_TOP_RIGHT,
+        top_left: DOUBLE_TOP_LEFT,
+        bottom_right: DOUBLE_BOTTOM_RIGHT,
+        bottom_left: DOUBLE_BOTTOM_LEFT,
+        vertical_left: DOUBLE_VERTICAL_LEFT,
+        vertical_right: DOUBLE_VERTICAL_RIGHT,
+        horizontal_down: DOUBLE_HORIZONTAL_DOWN,
+        horizontal_up: DOUBLE_HORIZONTAL_UP,
+        cross: DOUBLE_CROSS,
+    };
+
+    pub const THICK: Set = Set {
+        vertical: THICK_VERTICAL,
+        horizontal: THICK_HORIZONTAL,
+        top_right: THICK_TOP_RIGHT,
+        top_left: THICK_TOP_LEFT,
+        bottom_right: THICK_BOTTOM_RIGHT,
+        bottom_left: THICK_BOTTOM_LEFT,
+        vertical_left: THICK_VERTICAL_LEFT,
+        vertical_right: THICK_VERTICAL_RIGHT,
+        horizontal_down: THICK_HORIZONTAL_DOWN,
+        horizontal_up: THICK_HORIZONTAL_UP,
+        cross: THICK_CROSS,
+    };
+}
+
+pub mod border {
+    use super::line;
+
+    #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+    pub struct Set {
+        pub top_left: &'static str,
+        pub top_right: &'static str,
+        pub bottom_left: &'static str,
+        pub bottom_right: &'static str,
+        pub vertical_left: &'static str,
+        pub vertical_right: &'static str,
+        pub horizontal_top: &'static str,
+        pub horizontal_bottom: &'static str,
+    }
+
+    impl Default for Set {
+        fn default() -> Self {
+            PLAIN
+        }
+    }
+
+    /// Border Set with a single line width
+    ///
+    /// ```text
+    /// ┌─────┐
+    /// │xxxxx│
+    /// │xxxxx│
+    /// └─────┘
+    pub const PLAIN: Set = Set {
+        top_left: line::NORMAL.top_left,
+        top_right: line::NORMAL.top_right,
+        bottom_left: line::NORMAL.bottom_left,
+        bottom_right: line::NORMAL.bottom_right,
+        vertical_left: line::NORMAL.vertical,
+        vertical_right: line::NORMAL.vertical,
+        horizontal_top: line::NORMAL.horizontal,
+        horizontal_bottom: line::NORMAL.horizontal,
+    };
+
+    /// Border Set with a single line width and rounded corners
+    ///
+    /// ```text
+    /// ╭─────╮
+    /// │xxxxx│
+    /// │xxxxx│
+    /// ╰─────╯
+    pub const ROUNDED: Set = Set {
+        top_left: line::ROUNDED.top_left,
+        top_right: line::ROUNDED.top_right,
+        bottom_left: line::ROUNDED.bottom_left,
+        bottom_right: line::ROUNDED.bottom_right,
+        vertical_left: line::ROUNDED.vertical,
+        vertical_right: line::ROUNDED.vertical,
+        horizontal_top: line::ROUNDED.horizontal,
+        horizontal_bottom: line::ROUNDED.horizontal,
+    };
+
+    /// Border Set with a double line width
+    ///
+    /// ```text
+    /// ╔═════╗
+    /// ║xxxxx║
+    /// ║xxxxx║
+    /// ╚═════╝
+    pub const DOUBLE: Set = Set {
+        top_left: line::DOUBLE.top_left,
+        top_right: line::DOUBLE.top_right,
+        bottom_left: line::DOUBLE.bottom_left,
+        bottom_right: line::DOUBLE.bottom_right,
+        vertical_left: line::DOUBLE.vertical,
+        vertical_right: line::DOUBLE.vertical,
+        horizontal_top: line::DOUBLE.horizontal,
+        horizontal_bottom: line::DOUBLE.horizontal,
+    };
+
+    /// Border Set with a thick line width
+    ///
+    /// ```text
+    /// ┏━━━━━┓
+    /// ┃xxxxx┃
+    /// ┃xxxxx┃
+    /// ┗━━━━━┛
+    pub const THICK: Set = Set {
+        top_left: line::THICK.top_left,
+        top_right: line::THICK.top_right,
+        bottom_left: line::THICK.bottom_left,
+        bottom_right: line::THICK.bottom_right,
+        vertical_left: line::THICK.vertical,
+        vertical_right: line::THICK.vertical,
+        horizontal_top: line::THICK.horizontal,
+        horizontal_bottom: line::THICK.horizontal,
+    };
+
+    pub const QUADRANT_TOP_LEFT: &str = "▘";
+    pub const QUADRANT_TOP_RIGHT: &str = "▝";
+    pub const QUADRANT_BOTTOM_LEFT: &str = "▖";
+    pub const QUADRANT_BOTTOM_RIGHT: &str = "▗";
+    pub const QUADRANT_TOP_HALF: &str = "▀";
+    pub const QUADRANT_BOTTOM_HALF: &str = "▄";
+    pub const QUADRANT_LEFT_HALF: &str = "▌";
+    pub const QUADRANT_RIGHT_HALF: &str = "▐";
+    pub const QUADRANT_TOP_LEFT_BOTTOM_LEFT_BOTTOM_RIGHT: &str = "▙";
+    pub const QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_LEFT: &str = "▛";
+    pub const QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_RIGHT: &str = "▜";
+    pub const QUADRANT_TOP_RIGHT_BOTTOM_LEFT_BOTTOM_RIGHT: &str = "▟";
+    pub const QUADRANT_TOP_LEFT_BOTTOM_RIGHT: &str = "▚";
+    pub const QUADRANT_TOP_RIGHT_BOTTOM_LEFT: &str = "▞";
+    pub const QUADRANT_BLOCK: &str = "█";
+
+    /// Quadrant used for setting a border outside a block by one half cell "pixel".
+    ///
+    /// ```text
+    /// ▛▀▀▀▀▀▜
+    /// ▌xxxxx▐
+    /// ▌xxxxx▐
+    /// ▙▄▄▄▄▄▟
+    /// ```
+    pub const QUADRANT_OUTSIDE: Set = Set {
+        top_left: QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_LEFT,
+        top_right: QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_RIGHT,
+        bottom_left: QUADRANT_TOP_LEFT_BOTTOM_LEFT_BOTTOM_RIGHT,
+        bottom_right: QUADRANT_TOP_RIGHT_BOTTOM_LEFT_BOTTOM_RIGHT,
+        vertical_left: QUADRANT_LEFT_HALF,
+        vertical_right: QUADRANT_RIGHT_HALF,
+        horizontal_top: QUADRANT_TOP_HALF,
+        horizontal_bottom: QUADRANT_BOTTOM_HALF,
+    };
+
+    /// Quadrant used for setting a border inside a block by one half cell "pixel".
+    ///
+    /// ```text
+    /// ▗▄▄▄▄▄▖
+    /// ▐xxxxx▌
+    /// ▐xxxxx▌
+    /// ▝▀▀▀▀▀▘
+    /// ```
+    pub const QUADRANT_INSIDE: Set = Set {
+        top_right: QUADRANT_BOTTOM_LEFT,
+        top_left: QUADRANT_BOTTOM_RIGHT,
+        bottom_right: QUADRANT_TOP_LEFT,
+        bottom_left: QUADRANT_TOP_RIGHT,
+        vertical_left: QUADRANT_RIGHT_HALF,
+        vertical_right: QUADRANT_LEFT_HALF,
+        horizontal_top: QUADRANT_BOTTOM_HALF,
+        horizontal_bottom: QUADRANT_TOP_HALF,
+    };
+
+    pub const ONE_EIGHTH_TOP_EIGHT: &str = "▔";
+    pub const ONE_EIGHTH_BOTTOM_EIGHT: &str = "▁";
+    pub const ONE_EIGHTH_LEFT_EIGHT: &str = "▏";
+    pub const ONE_EIGHTH_RIGHT_EIGHT: &str = "▕";
+
+    /// Wide border set based on McGugan box technique
+    ///
+    /// ```text
+    /// ▁▁▁▁▁▁▁
+    /// ▏xxxxx▕
+    /// ▏xxxxx▕
+    /// ▔▔▔▔▔▔▔
+    /// ```
+    #[allow(clippy::doc_markdown)]
+    pub const ONE_EIGHTH_WIDE: Set = Set {
+        top_right: ONE_EIGHTH_BOTTOM_EIGHT,
+        top_left: ONE_EIGHTH_BOTTOM_EIGHT,
+        bottom_right: ONE_EIGHTH_TOP_EIGHT,
+        bottom_left: ONE_EIGHTH_TOP_EIGHT,
+        vertical_left: ONE_EIGHTH_LEFT_EIGHT,
+        vertical_right: ONE_EIGHTH_RIGHT_EIGHT,
+        horizontal_top: ONE_EIGHTH_BOTTOM_EIGHT,
+        horizontal_bottom: ONE_EIGHTH_TOP_EIGHT,
+    };
+
+    /// Tall border set based on McGugan box technique
+    ///
+    /// ```text
+    /// ▕▔▔▏
+    /// ▕xx▏
+    /// ▕xx▏
+    /// ▕▁▁▏
+    /// ```
+    #[allow(clippy::doc_markdown)]
+    pub const ONE_EIGHTH_TALL: Set = Set {
+        top_right: ONE_EIGHTH_LEFT_EIGHT,
+        top_left: ONE_EIGHTH_RIGHT_EIGHT,
+        bottom_right: ONE_EIGHTH_LEFT_EIGHT,
+        bottom_left: ONE_EIGHTH_RIGHT_EIGHT,
+        vertical_left: ONE_EIGHTH_RIGHT_EIGHT,
+        vertical_right: ONE_EIGHTH_LEFT_EIGHT,
+        horizontal_top: ONE_EIGHTH_TOP_EIGHT,
+        horizontal_bottom: ONE_EIGHTH_BOTTOM_EIGHT,
+    };
+
+    /// Wide proportional (visually equal width and height) border with using set of quadrants.
+    ///
+    /// The border is created by using half blocks for top and bottom, and full
+    /// blocks for right and left sides to make horizontal and vertical borders seem equal.
+    ///
+    /// ```text
+    /// ▄▄▄▄
+    /// █xx█
+    /// █xx█
+    /// ▀▀▀▀
+    /// ```
+    pub const PROPORTIONAL_WIDE: Set = Set {
+        top_right: QUADRANT_BOTTOM_HALF,
+        top_left: QUADRANT_BOTTOM_HALF,
+        bottom_right: QUADRANT_TOP_HALF,
+        bottom_left: QUADRANT_TOP_HALF,
+        vertical_left: QUADRANT_BLOCK,
+        vertical_right: QUADRANT_BLOCK,
+        horizontal_top: QUADRANT_BOTTOM_HALF,
+        horizontal_bottom: QUADRANT_TOP_HALF,
+    };
+
+    /// Tall proportional (visually equal width and height) border with using set of quadrants.
+    ///
+    /// The border is created by using full blocks for all sides, except for the top and bottom,
+    /// which use half blocks to make horizontal and vertical borders seem equal.
+    ///
+    /// ```text
+    /// ▕█▀▀█
+    /// ▕█xx█
+    /// ▕█xx█
+    /// ▕█▄▄█
+    /// ```
+    pub const PROPORTIONAL_TALL: Set = Set {
+        top_right: QUADRANT_BLOCK,
+        top_left: QUADRANT_BLOCK,
+        bottom_right: QUADRANT_BLOCK,
+        bottom_left: QUADRANT_BLOCK,
+        vertical_left: QUADRANT_BLOCK,
+        vertical_right: QUADRANT_BLOCK,
+        horizontal_top: QUADRANT_TOP_HALF,
+        horizontal_bottom: QUADRANT_BOTTOM_HALF,
+    };
+}
+
 pub const DOT: &str = "•";
 
 pub mod braille {

src/symbols/border.rs

@@ -1,509 +0,0 @@
-use super::{block, line};
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub struct Set {
-    pub top_left: &'static str,
-    pub top_right: &'static str,
-    pub bottom_left: &'static str,
-    pub bottom_right: &'static str,
-    pub vertical_left: &'static str,
-    pub vertical_right: &'static str,
-    pub horizontal_top: &'static str,
-    pub horizontal_bottom: &'static str,
-}
-
-impl Default for Set {
-    fn default() -> Self {
-        PLAIN
-    }
-}
-
-/// Border Set with a single line width
-///
-/// ```text
-/// ┌─────┐
-/// │xxxxx│
-/// │xxxxx│
-/// └─────┘
-/// ```
-pub const PLAIN: Set = Set {
-    top_left: line::NORMAL.top_left,
-    top_right: line::NORMAL.top_right,
-    bottom_left: line::NORMAL.bottom_left,
-    bottom_right: line::NORMAL.bottom_right,
-    vertical_left: line::NORMAL.vertical,
-    vertical_right: line::NORMAL.vertical,
-    horizontal_top: line::NORMAL.horizontal,
-    horizontal_bottom: line::NORMAL.horizontal,
-};
-
-/// Border Set with a single line width and rounded corners
-///
-/// ```text
-/// ╭─────╮
-/// │xxxxx│
-/// │xxxxx│
-/// ╰─────╯
-/// ```
-pub const ROUNDED: Set = Set {
-    top_left: line::ROUNDED.top_left,
-    top_right: line::ROUNDED.top_right,
-    bottom_left: line::ROUNDED.bottom_left,
-    bottom_right: line::ROUNDED.bottom_right,
-    vertical_left: line::ROUNDED.vertical,
-    vertical_right: line::ROUNDED.vertical,
-    horizontal_top: line::ROUNDED.horizontal,
-    horizontal_bottom: line::ROUNDED.horizontal,
-};
-
-/// Border Set with a double line width
-///
-/// ```text
-/// ╔═════╗
-/// ║xxxxx║
-/// ║xxxxx║
-/// ╚═════╝
-/// ```
-pub const DOUBLE: Set = Set {
-    top_left: line::DOUBLE.top_left,
-    top_right: line::DOUBLE.top_right,
-    bottom_left: line::DOUBLE.bottom_left,
-    bottom_right: line::DOUBLE.bottom_right,
-    vertical_left: line::DOUBLE.vertical,
-    vertical_right: line::DOUBLE.vertical,
-    horizontal_top: line::DOUBLE.horizontal,
-    horizontal_bottom: line::DOUBLE.horizontal,
-};
-
-/// Border Set with a thick line width
-///
-/// ```text
-/// ┏━━━━━┓
-/// ┃xxxxx┃
-/// ┃xxxxx┃
-/// ┗━━━━━┛
-/// ```
-pub const THICK: Set = Set {
-    top_left: line::THICK.top_left,
-    top_right: line::THICK.top_right,
-    bottom_left: line::THICK.bottom_left,
-    bottom_right: line::THICK.bottom_right,
-    vertical_left: line::THICK.vertical,
-    vertical_right: line::THICK.vertical,
-    horizontal_top: line::THICK.horizontal,
-    horizontal_bottom: line::THICK.horizontal,
-};
-
-pub const QUADRANT_TOP_LEFT: &str = "▘";
-pub const QUADRANT_TOP_RIGHT: &str = "▝";
-pub const QUADRANT_BOTTOM_LEFT: &str = "▖";
-pub const QUADRANT_BOTTOM_RIGHT: &str = "▗";
-pub const QUADRANT_TOP_HALF: &str = "▀";
-pub const QUADRANT_BOTTOM_HALF: &str = "▄";
-pub const QUADRANT_LEFT_HALF: &str = "▌";
-pub const QUADRANT_RIGHT_HALF: &str = "▐";
-pub const QUADRANT_TOP_LEFT_BOTTOM_LEFT_BOTTOM_RIGHT: &str = "▙";
-pub const QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_LEFT: &str = "▛";
-pub const QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_RIGHT: &str = "▜";
-pub const QUADRANT_TOP_RIGHT_BOTTOM_LEFT_BOTTOM_RIGHT: &str = "▟";
-pub const QUADRANT_TOP_LEFT_BOTTOM_RIGHT: &str = "▚";
-pub const QUADRANT_TOP_RIGHT_BOTTOM_LEFT: &str = "▞";
-pub const QUADRANT_BLOCK: &str = "█";
-
-/// Quadrant used for setting a border outside a block by one half cell "pixel".
-///
-/// ```text
-/// ▛▀▀▀▀▀▜
-/// ▌xxxxx▐
-/// ▌xxxxx▐
-/// ▙▄▄▄▄▄▟
-/// ```
-pub const QUADRANT_OUTSIDE: Set = Set {
-    top_left: QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_LEFT,
-    top_right: QUADRANT_TOP_LEFT_TOP_RIGHT_BOTTOM_RIGHT,
-    bottom_left: QUADRANT_TOP_LEFT_BOTTOM_LEFT_BOTTOM_RIGHT,
-    bottom_right: QUADRANT_TOP_RIGHT_BOTTOM_LEFT_BOTTOM_RIGHT,
-    vertical_left: QUADRANT_LEFT_HALF,
-    vertical_right: QUADRANT_RIGHT_HALF,
-    horizontal_top: QUADRANT_TOP_HALF,
-    horizontal_bottom: QUADRANT_BOTTOM_HALF,
-};
-
-/// Quadrant used for setting a border inside a block by one half cell "pixel".
-///
-/// ```text
-/// ▗▄▄▄▄▄▖
-/// ▐xxxxx▌
-/// ▐xxxxx▌
-/// ▝▀▀▀▀▀▘
-/// ```
-pub const QUADRANT_INSIDE: Set = Set {
-    top_right: QUADRANT_BOTTOM_LEFT,
-    top_left: QUADRANT_BOTTOM_RIGHT,
-    bottom_right: QUADRANT_TOP_LEFT,
-    bottom_left: QUADRANT_TOP_RIGHT,
-    vertical_left: QUADRANT_RIGHT_HALF,
-    vertical_right: QUADRANT_LEFT_HALF,
-    horizontal_top: QUADRANT_BOTTOM_HALF,
-    horizontal_bottom: QUADRANT_TOP_HALF,
-};
-
-pub const ONE_EIGHTH_TOP_EIGHT: &str = "▔";
-pub const ONE_EIGHTH_BOTTOM_EIGHT: &str = "▁";
-pub const ONE_EIGHTH_LEFT_EIGHT: &str = "▏";
-pub const ONE_EIGHTH_RIGHT_EIGHT: &str = "▕";
-
-/// Wide border set based on McGugan box technique
-///
-/// ```text
-/// ▁▁▁▁▁▁▁
-/// ▏xxxxx▕
-/// ▏xxxxx▕
-/// ▔▔▔▔▔▔▔
-/// ```
-#[allow(clippy::doc_markdown)]
-pub const ONE_EIGHTH_WIDE: Set = Set {
-    top_right: ONE_EIGHTH_BOTTOM_EIGHT,
-    top_left: ONE_EIGHTH_BOTTOM_EIGHT,
-    bottom_right: ONE_EIGHTH_TOP_EIGHT,
-    bottom_left: ONE_EIGHTH_TOP_EIGHT,
-    vertical_left: ONE_EIGHTH_LEFT_EIGHT,
-    vertical_right: ONE_EIGHTH_RIGHT_EIGHT,
-    horizontal_top: ONE_EIGHTH_BOTTOM_EIGHT,
-    horizontal_bottom: ONE_EIGHTH_TOP_EIGHT,
-};
-
-/// Tall border set based on McGugan box technique
-///
-/// ```text
-/// ▕▔▔▏
-/// ▕xx▏
-/// ▕xx▏
-/// ▕▁▁▏
-/// ```
-#[allow(clippy::doc_markdown)]
-pub const ONE_EIGHTH_TALL: Set = Set {
-    top_right: ONE_EIGHTH_LEFT_EIGHT,
-    top_left: ONE_EIGHTH_RIGHT_EIGHT,
-    bottom_right: ONE_EIGHTH_LEFT_EIGHT,
-    bottom_left: ONE_EIGHTH_RIGHT_EIGHT,
-    vertical_left: ONE_EIGHTH_RIGHT_EIGHT,
-    vertical_right: ONE_EIGHTH_LEFT_EIGHT,
-    horizontal_top: ONE_EIGHTH_TOP_EIGHT,
-    horizontal_bottom: ONE_EIGHTH_BOTTOM_EIGHT,
-};
-
-/// Wide proportional (visually equal width and height) border with using set of quadrants.
-///
-/// The border is created by using half blocks for top and bottom, and full
-/// blocks for right and left sides to make horizontal and vertical borders seem equal.
-///
-/// ```text
-/// ▄▄▄▄
-/// █xx█
-/// █xx█
-/// ▀▀▀▀
-/// ```
-pub const PROPORTIONAL_WIDE: Set = Set {
-    top_right: QUADRANT_BOTTOM_HALF,
-    top_left: QUADRANT_BOTTOM_HALF,
-    bottom_right: QUADRANT_TOP_HALF,
-    bottom_left: QUADRANT_TOP_HALF,
-    vertical_left: QUADRANT_BLOCK,
-    vertical_right: QUADRANT_BLOCK,
-    horizontal_top: QUADRANT_BOTTOM_HALF,
-    horizontal_bottom: QUADRANT_TOP_HALF,
-};
-
-/// Tall proportional (visually equal width and height) border with using set of quadrants.
-///
-/// The border is created by using full blocks for all sides, except for the top and bottom,
-/// which use half blocks to make horizontal and vertical borders seem equal.
-///
-/// ```text
-/// ▕█▀▀█
-/// ▕█xx█
-/// ▕█xx█
-/// ▕█▄▄█
-/// ```
-pub const PROPORTIONAL_TALL: Set = Set {
-    top_right: QUADRANT_BLOCK,
-    top_left: QUADRANT_BLOCK,
-    bottom_right: QUADRANT_BLOCK,
-    bottom_left: QUADRANT_BLOCK,
-    vertical_left: QUADRANT_BLOCK,
-    vertical_right: QUADRANT_BLOCK,
-    horizontal_top: QUADRANT_TOP_HALF,
-    horizontal_bottom: QUADRANT_BOTTOM_HALF,
-};
-
-/// Solid border set
-///
-/// The border is created by using full blocks for all sides.
-///
-/// ```text
-/// ████
-/// █xx█
-/// █xx█
-/// ████
-/// ```
-pub const FULL: Set = Set {
-    top_left: block::FULL,
-    top_right: block::FULL,
-    bottom_left: block::FULL,
-    bottom_right: block::FULL,
-    vertical_left: block::FULL,
-    vertical_right: block::FULL,
-    horizontal_top: block::FULL,
-    horizontal_bottom: block::FULL,
-};
-
-/// Empty border set
-///
-/// The border is created by using empty strings for all sides.
-///
-/// This is useful for ensuring that the border style is applied to a border on a block with a title
-/// without actually drawing a border.
-///
-/// ░ Example
-///
-/// `░` represents the content in the area not covered by the border to make it easier to see the
-/// blank symbols.
-///
-/// ```text
-/// ░░░░░░░░
-/// ░░    ░░
-/// ░░ ░░ ░░
-/// ░░ ░░ ░░
-/// ░░    ░░
-/// ░░░░░░░░
-/// ```
-pub const EMPTY: Set = Set {
-    top_left: " ",
-    top_right: " ",
-    bottom_left: " ",
-    bottom_right: " ",
-    vertical_left: " ",
-    vertical_right: " ",
-    horizontal_top: " ",
-    horizontal_bottom: " ",
-};
-
-#[cfg(test)]
-mod tests {
-    use indoc::{formatdoc, indoc};
-
-    use super::*;
-
-    #[test]
-    fn default() {
-        assert_eq!(Set::default(), PLAIN);
-    }
-
-    /// A helper function to render a border set to a string.
-    ///
-    /// '░' (U+2591 Light Shade) is used as a placeholder for empty space to make it easier to see
-    /// the size of the border symbols.
-    fn render(set: Set) -> String {
-        formatdoc!(
-            "░░░░░░
-             ░{}{}{}{}░
-             ░{}░░{}░
-             ░{}░░{}░
-             ░{}{}{}{}░
-             ░░░░░░",
-            set.top_left,
-            set.horizontal_top,
-            set.horizontal_top,
-            set.top_right,
-            set.vertical_left,
-            set.vertical_right,
-            set.vertical_left,
-            set.vertical_right,
-            set.bottom_left,
-            set.horizontal_bottom,
-            set.horizontal_bottom,
-            set.bottom_right
-        )
-    }
-
-    #[test]
-    fn plain() {
-        assert_eq!(
-            render(PLAIN),
-            indoc!(
-                "░░░░░░
-                 ░┌──┐░
-                 ░│░░│░
-                 ░│░░│░
-                 ░└──┘░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn rounded() {
-        assert_eq!(
-            render(ROUNDED),
-            indoc!(
-                "░░░░░░
-                 ░╭──╮░
-                 ░│░░│░
-                 ░│░░│░
-                 ░╰──╯░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn double() {
-        assert_eq!(
-            render(DOUBLE),
-            indoc!(
-                "░░░░░░
-                 ░╔══╗░
-                 ░║░░║░
-                 ░║░░║░
-                 ░╚══╝░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn thick() {
-        assert_eq!(
-            render(THICK),
-            indoc!(
-                "░░░░░░
-                 ░┏━━┓░
-                 ░┃░░┃░
-                 ░┃░░┃░
-                 ░┗━━┛░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn quadrant_outside() {
-        assert_eq!(
-            render(QUADRANT_OUTSIDE),
-            indoc!(
-                "░░░░░░
-                 ░▛▀▀▜░
-                 ░▌░░▐░
-                 ░▌░░▐░
-                 ░▙▄▄▟░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn quadrant_inside() {
-        assert_eq!(
-            render(QUADRANT_INSIDE),
-            indoc!(
-                "░░░░░░
-                 ░▗▄▄▖░
-                 ░▐░░▌░
-                 ░▐░░▌░
-                 ░▝▀▀▘░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn one_eighth_wide() {
-        assert_eq!(
-            render(ONE_EIGHTH_WIDE),
-            indoc!(
-                "░░░░░░
-                 ░▁▁▁▁░
-                 ░▏░░▕░
-                 ░▏░░▕░
-                 ░▔▔▔▔░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn one_eighth_tall() {
-        assert_eq!(
-            render(ONE_EIGHTH_TALL),
-            indoc!(
-                "░░░░░░
-                 ░▕▔▔▏░
-                 ░▕░░▏░
-                 ░▕░░▏░
-                 ░▕▁▁▏░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn proportional_wide() {
-        assert_eq!(
-            render(PROPORTIONAL_WIDE),
-            indoc!(
-                "░░░░░░
-                 ░▄▄▄▄░
-                 ░█░░█░
-                 ░█░░█░
-                 ░▀▀▀▀░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn proportional_tall() {
-        assert_eq!(
-            render(PROPORTIONAL_TALL),
-            indoc!(
-                "░░░░░░
-                 ░█▀▀█░
-                 ░█░░█░
-                 ░█░░█░
-                 ░█▄▄█░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn full() {
-        assert_eq!(
-            render(FULL),
-            indoc!(
-                "░░░░░░
-                 ░████░
-                 ░█░░█░
-                 ░█░░█░
-                 ░████░
-                 ░░░░░░"
-            )
-        );
-    }
-
-    #[test]
-    fn empty() {
-        assert_eq!(
-            render(EMPTY),
-            indoc!(
-                "░░░░░░
-                 ░    ░
-                 ░ ░░ ░
-                 ░ ░░ ░
-                 ░    ░
-                 ░░░░░░"
-            )
-        );
-    }
-}

src/symbols/line.rs

@@ -1,208 +0,0 @@
-pub const VERTICAL: &str = "│";
-pub const DOUBLE_VERTICAL: &str = "║";
-pub const THICK_VERTICAL: &str = "┃";
-
-pub const HORIZONTAL: &str = "─";
-pub const DOUBLE_HORIZONTAL: &str = "═";
-pub const THICK_HORIZONTAL: &str = "━";
-
-pub const TOP_RIGHT: &str = "┐";
-pub const ROUNDED_TOP_RIGHT: &str = "╮";
-pub const DOUBLE_TOP_RIGHT: &str = "╗";
-pub const THICK_TOP_RIGHT: &str = "┓";
-
-pub const TOP_LEFT: &str = "┌";
-pub const ROUNDED_TOP_LEFT: &str = "╭";
-pub const DOUBLE_TOP_LEFT: &str = "╔";
-pub const THICK_TOP_LEFT: &str = "┏";
-
-pub const BOTTOM_RIGHT: &str = "┘";
-pub const ROUNDED_BOTTOM_RIGHT: &str = "╯";
-pub const DOUBLE_BOTTOM_RIGHT: &str = "╝";
-pub const THICK_BOTTOM_RIGHT: &str = "┛";
-
-pub const BOTTOM_LEFT: &str = "└";
-pub const ROUNDED_BOTTOM_LEFT: &str = "╰";
-pub const DOUBLE_BOTTOM_LEFT: &str = "╚";
-pub const THICK_BOTTOM_LEFT: &str = "┗";
-
-pub const VERTICAL_LEFT: &str = "┤";
-pub const DOUBLE_VERTICAL_LEFT: &str = "╣";
-pub const THICK_VERTICAL_LEFT: &str = "┫";
-
-pub const VERTICAL_RIGHT: &str = "├";
-pub const DOUBLE_VERTICAL_RIGHT: &str = "╠";
-pub const THICK_VERTICAL_RIGHT: &str = "┣";
-
-pub const HORIZONTAL_DOWN: &str = "┬";
-pub const DOUBLE_HORIZONTAL_DOWN: &str = "╦";
-pub const THICK_HORIZONTAL_DOWN: &str = "┳";
-
-pub const HORIZONTAL_UP: &str = "┴";
-pub const DOUBLE_HORIZONTAL_UP: &str = "╩";
-pub const THICK_HORIZONTAL_UP: &str = "┻";
-
-pub const CROSS: &str = "┼";
-pub const DOUBLE_CROSS: &str = "╬";
-pub const THICK_CROSS: &str = "╋";
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub struct Set {
-    pub vertical: &'static str,
-    pub horizontal: &'static str,
-    pub top_right: &'static str,
-    pub top_left: &'static str,
-    pub bottom_right: &'static str,
-    pub bottom_left: &'static str,
-    pub vertical_left: &'static str,
-    pub vertical_right: &'static str,
-    pub horizontal_down: &'static str,
-    pub horizontal_up: &'static str,
-    pub cross: &'static str,
-}
-
-impl Default for Set {
-    fn default() -> Self {
-        NORMAL
-    }
-}
-
-pub const NORMAL: Set = Set {
-    vertical: VERTICAL,
-    horizontal: HORIZONTAL,
-    top_right: TOP_RIGHT,
-    top_left: TOP_LEFT,
-    bottom_right: BOTTOM_RIGHT,
-    bottom_left: BOTTOM_LEFT,
-    vertical_left: VERTICAL_LEFT,
-    vertical_right: VERTICAL_RIGHT,
-    horizontal_down: HORIZONTAL_DOWN,
-    horizontal_up: HORIZONTAL_UP,
-    cross: CROSS,
-};
-
-pub const ROUNDED: Set = Set {
-    top_right: ROUNDED_TOP_RIGHT,
-    top_left: ROUNDED_TOP_LEFT,
-    bottom_right: ROUNDED_BOTTOM_RIGHT,
-    bottom_left: ROUNDED_BOTTOM_LEFT,
-    ..NORMAL
-};
-
-pub const DOUBLE: Set = Set {
-    vertical: DOUBLE_VERTICAL,
-    horizontal: DOUBLE_HORIZONTAL,
-    top_right: DOUBLE_TOP_RIGHT,
-    top_left: DOUBLE_TOP_LEFT,
-    bottom_right: DOUBLE_BOTTOM_RIGHT,
-    bottom_left: DOUBLE_BOTTOM_LEFT,
-    vertical_left: DOUBLE_VERTICAL_LEFT,
-    vertical_right: DOUBLE_VERTICAL_RIGHT,
-    horizontal_down: DOUBLE_HORIZONTAL_DOWN,
-    horizontal_up: DOUBLE_HORIZONTAL_UP,
-    cross: DOUBLE_CROSS,
-};
-
-pub const THICK: Set = Set {
-    vertical: THICK_VERTICAL,
-    horizontal: THICK_HORIZONTAL,
-    top_right: THICK_TOP_RIGHT,
-    top_left: THICK_TOP_LEFT,
-    bottom_right: THICK_BOTTOM_RIGHT,
-    bottom_left: THICK_BOTTOM_LEFT,
-    vertical_left: THICK_VERTICAL_LEFT,
-    vertical_right: THICK_VERTICAL_RIGHT,
-    horizontal_down: THICK_HORIZONTAL_DOWN,
-    horizontal_up: THICK_HORIZONTAL_UP,
-    cross: THICK_CROSS,
-};
-
-#[cfg(test)]
-mod tests {
-    use indoc::{formatdoc, indoc};
-
-    use super::*;
-
-    #[test]
-    fn default() {
-        assert_eq!(Set::default(), NORMAL);
-    }
-
-    /// A helper function to render a set of symbols.
-    fn render(set: Set) -> String {
-        formatdoc!(
-            "{}{}{}{}
-             {}{}{}{}
-             {}{}{}{}
-             {}{}{}{}",
-            set.top_left,
-            set.horizontal,
-            set.horizontal_down,
-            set.top_right,
-            set.vertical,
-            " ",
-            set.vertical,
-            set.vertical,
-            set.vertical_right,
-            set.horizontal,
-            set.cross,
-            set.vertical_left,
-            set.bottom_left,
-            set.horizontal,
-            set.horizontal_up,
-            set.bottom_right
-        )
-    }
-
-    #[test]
-    fn normal() {
-        assert_eq!(
-            render(NORMAL),
-            indoc!(
-                "┌─┬┐
-                 │ ││
-                 ├─┼┤
-                 └─┴┘"
-            )
-        );
-    }
-
-    #[test]
-    fn rounded() {
-        assert_eq!(
-            render(ROUNDED),
-            indoc!(
-                "╭─┬╮
-                 │ ││
-                 ├─┼┤
-                 ╰─┴╯"
-            )
-        );
-    }
-
-    #[test]
-    fn double() {
-        assert_eq!(
-            render(DOUBLE),
-            indoc!(
-                "╔═╦╗
-                 ║ ║║
-                 ╠═╬╣
-                 ╚═╩╝"
-            )
-        );
-    }
-
-    #[test]
-    fn thick() {
-        assert_eq!(
-            render(THICK),
-            indoc!(
-                "┏━┳┓
-                 ┃ ┃┃
-                 ┣━╋┫
-                 ┗━┻┛"
-            )
-        );
-    }
-}

src/terminal.rs

@@ -32,6 +32,7 @@
 //! [`Buffer`]: crate::buffer::Buffer
 
 mod frame;
+#[allow(clippy::module_inception)]
 mod terminal;
 mod viewport;
 

src/terminal/frame.rs

@@ -94,7 +94,7 @@ impl Frame<'_> {
     /// # }
     /// ```
     #[allow(clippy::needless_pass_by_value)]
-    #[instability::unstable(feature = "widget-ref")]
+    #[stability::unstable(feature = "widget-ref")]
     pub fn render_widget_ref<W: WidgetRef>(&mut self, widget: W, area: Rect) {
         widget.render_ref(area, self.buffer);
     }
@@ -129,7 +129,7 @@ impl Frame<'_> {
     }
 
     /// Render a [`StatefulWidgetRef`] to the current buffer using
-    /// [`StatefulWidgetRef::render_ref`].
+    /// [`StatefulWidgetRef::render_stateful_ref`].
     ///
     /// Usually the area argument is the size of the current frame or a sub-area of the current
     /// frame (which can be obtained using [`Layout`] to split the total area).
@@ -152,12 +152,12 @@ impl Frame<'_> {
     /// # }
     /// ```
     #[allow(clippy::needless_pass_by_value)]
-    #[instability::unstable(feature = "widget-ref")]
+    #[stability::unstable(feature = "widget-ref")]
     pub fn render_stateful_widget_ref<W>(&mut self, widget: W, area: Rect, state: &mut W::State)
     where
         W: StatefulWidgetRef,
     {
-        widget.render_ref(area, self.buffer, state);
+        widget.render_stateful_ref(area, self.buffer, state);
     }
 
     /// After drawing this frame, make the cursor visible and put it at the specified (x, y)

src/terminal/terminal.rs

@@ -234,145 +234,39 @@ where
         Ok(())
     }
 
-    /// Draws a single frame to the terminal.
+    /// Synchronizes terminal size, calls the rendering closure, flushes the current internal state
+    /// and prepares for the next draw call.
     ///
-    /// Returns a [`CompletedFrame`] if successful, otherwise a [`std::io::Error`].
+    /// This is the main entry point for drawing to the terminal.
     ///
-    /// If the render callback passed to this method can fail, use [`try_draw`] instead.
-    ///
-    /// Applications should call `draw` or [`try_draw`] in a loop to continuously render the
-    /// terminal. These methods are the main entry points for drawing to the terminal.
-    ///
-    /// [`try_draw`]: Terminal::try_draw
-    ///
-    /// This method will:
-    ///
-    /// - autoresize the terminal if necessary
-    /// - call the render callback, passing it a [`Frame`] reference to render to
-    /// - flush the current internal state by copying the current buffer to the backend
-    /// - move the cursor to the last known position if it was set during the rendering closure
-    /// - return a [`CompletedFrame`] with the current buffer and the area of the terminal
-    ///
-    /// The [`CompletedFrame`] returned by this method can be useful for debugging or testing
-    /// purposes, but it is often not used in regular applicationss.
-    ///
-    /// The render callback should fully render the entire frame when called, including areas that
-    /// are unchanged from the previous frame. This is because each frame is compared to the
-    /// previous frame to determine what has changed, and only the changes are written to the
-    /// terminal. If the render callback does not fully render the frame, the terminal will not be
-    /// in a consistent state.
+    /// The changes drawn to the frame are applied only to the current [`Buffer`]. After the closure
+    /// returns, the current buffer is compared to the previous buffer and only the changes are
+    /// applied to the terminal.
     ///
     /// # Examples
     ///
-    /// ```
-    /// # let backend = ratatui::backend::TestBackend::new(10, 10);
-    /// # let mut terminal = ratatui::Terminal::new(backend)?;
-    /// use std::io;
-    ///
-    /// use ratatui::widgets::Paragraph;
-    ///
-    /// // with a closure
+    /// ```rust,no_run
+    /// # use std::io::stdout;
+    /// # use ratatui::{prelude::*, widgets::Paragraph};
+    /// let backend = CrosstermBackend::new(stdout());
+    /// let mut terminal = Terminal::new(backend)?;
     /// terminal.draw(|frame| {
     ///     let area = frame.size();
     ///     frame.render_widget(Paragraph::new("Hello World!"), area);
     ///     frame.set_cursor(0, 0);
     /// })?;
-    ///
-    /// // or with a function
-    /// terminal.draw(render)?;
-    ///
-    /// fn render(frame: &mut ratatui::Frame) {
-    ///     frame.render_widget(Paragraph::new("Hello World!"), frame.size());
-    /// }
-    /// # io::Result::Ok(())
+    /// # std::io::Result::Ok(())
     /// ```
-    pub fn draw<F>(&mut self, render_callback: F) -> io::Result<CompletedFrame>
+    pub fn draw<F>(&mut self, f: F) -> io::Result<CompletedFrame>
     where
         F: FnOnce(&mut Frame),
-    {
-        self.try_draw(|frame| {
-            render_callback(frame);
-            io::Result::Ok(())
-        })
-    }
-
-    /// Tries to draw a single frame to the terminal.
-    ///
-    /// Returns [`Result::Ok`] containing a [`CompletedFrame`] if successful, otherwise
-    /// [`Result::Err`] containing the [`std::io::Error`] that caused the failure.
-    ///
-    /// This is the equivalent of [`Terminal::draw`] but the render callback is a function or
-    /// closure that returns a `Result` instead of nothing.
-    ///
-    /// Applications should call `try_draw` or [`draw`] in a loop to continuously render the
-    /// terminal. These methods are the main entry points for drawing to the terminal.
-    ///
-    /// [`draw`]: Terminal::draw
-    ///
-    /// This method will:
-    ///
-    /// - autoresize the terminal if necessary
-    /// - call the render callback, passing it a [`Frame`] reference to render to
-    /// - flush the current internal state by copying the current buffer to the backend
-    /// - move the cursor to the last known position if it was set during the rendering closure
-    /// - return a [`CompletedFrame`] with the current buffer and the area of the terminal
-    ///
-    /// The render callback passed to `try_draw` can return any [`Result`] with an error type that
-    /// can be converted into an [`std::io::Error`] using the [`Into`] trait. This makes it possible
-    /// to use the `?` operator to propagate errors that occur during rendering. If the render
-    /// callback returns an error, the error will be returned from `try_draw` as an
-    /// [`std::io::Error`] and the terminal will not be updated.
-    ///
-    /// The [`CompletedFrame`] returned by this method can be useful for debugging or testing
-    /// purposes, but it is often not used in regular applicationss.
-    ///
-    /// The render callback should fully render the entire frame when called, including areas that
-    /// are unchanged from the previous frame. This is because each frame is compared to the
-    /// previous frame to determine what has changed, and only the changes are written to the
-    /// terminal. If the render function does not fully render the frame, the terminal will not be
-    /// in a consistent state.
-    ///
-    /// # Examples
-    ///
-    /// ```should_panic
-    /// # let backend = ratatui::backend::TestBackend::new(10, 10);
-    /// # let mut terminal = ratatui::Terminal::new(backend)?;
-    /// use std::io;
-    ///
-    /// use ratatui::widgets::Paragraph;
-    ///
-    /// // with a closure
-    /// terminal.try_draw(|frame| {
-    ///     let value: u8 = "not a number".parse().map_err(io::Error::other)?;
-    ///     let area = frame.size();
-    ///     frame.render_widget(Paragraph::new("Hello World!"), area);
-    ///     frame.set_cursor(0, 0);
-    ///     io::Result::Ok(())
-    /// })?;
-    ///
-    /// // or with a function
-    /// terminal.try_draw(render)?;
-    ///
-    /// fn render(frame: &mut ratatui::Frame) -> io::Result<()> {
-    ///     let value: u8 = "not a number".parse().map_err(io::Error::other)?;
-    ///     frame.render_widget(Paragraph::new("Hello World!"), frame.size());
-    ///     Ok(())
-    /// }
-    /// # io::Result::Ok(())
-    /// ```
-    pub fn try_draw<F, E>(&mut self, render_callback: F) -> io::Result<CompletedFrame>
-    where
-        F: FnOnce(&mut Frame) -> Result<(), E>,
-        E: Into<io::Error>,
     {
         // Autoresize - otherwise we get glitches if shrinking or potential desync between widgets
         // and the terminal (if growing), which may OOB.
         self.autoresize()?;
 
         let mut frame = self.get_frame();
-
-        render_callback(&mut frame).map_err(Into::into)?;
-
+        f(&mut frame);
         // We can't change the cursor position right away because we have to flush the frame to
         // stdout first. But we also can't keep the frame around, since it holds a &mut to
         // Buffer. Thus, we're taking the important data out of the Frame and dropping it.

src/text.rs

@@ -5,7 +5,7 @@
 //! - A single line string where all graphemes have the same style is represented by a [`Span`].
 //! - A single line string where each grapheme may have its own style is represented by [`Line`].
 //! - A multiple line string where each grapheme may have its own style is represented by a
-//!   [`Text`].
+//! [`Text`].
 //!
 //! These types form a hierarchy: [`Line`] is a collection of [`Span`] and each line of [`Text`]
 //! is a [`Line`].
@@ -48,13 +48,14 @@ mod grapheme;
 pub use grapheme::StyledGrapheme;
 
 mod line;
-pub use line::{Line, ToLine};
+pub use line::Line;
 
 mod masked;
 pub use masked::Masked;
 
 mod span;
-pub use span::{Span, ToSpan};
+pub use span::Span;
 
+#[allow(clippy::module_inception)]
 mod text;
-pub use text::{Text, ToText};
+pub use text::Text;

src/text/grapheme.rs

@@ -1,8 +1,5 @@
 use crate::{prelude::*, style::Styled};
 
-const NBSP: &str = "\u{00a0}";
-const ZWSP: &str = "\u{200b}";
-
 /// A grapheme associated to a style.
 /// Note that, although `StyledGrapheme` is the smallest divisible unit of text,
 /// it actually is not a member of the text type hierarchy (`Text` -> `Line` -> `Span`).
@@ -25,11 +22,6 @@ impl<'a> StyledGrapheme<'a> {
             style: style.into(),
         }
     }
-
-    pub(crate) fn is_whitespace(&self) -> bool {
-        let symbol = self.symbol;
-        symbol == ZWSP || symbol.chars().all(char::is_whitespace) && symbol != NBSP
-    }
 }
 
 impl<'a> Styled for StyledGrapheme<'a> {

src/text/line.rs

@@ -12,9 +12,6 @@ use crate::{prelude::*, style::Styled, text::StyledGrapheme};
 /// text. When a [`Line`] is rendered, it is rendered as a single line of text, with each [`Span`]
 /// being rendered in order (left to right).
 ///
-/// Any newlines in the content are removed when creating a [`Line`] using the constructor or
-/// conversion methods.
-///
 /// # Constructor Methods
 ///
 /// - [`Line::default`] creates a line with empty content and the default style.
@@ -161,13 +158,6 @@ pub struct Line<'a> {
     pub alignment: Option<Alignment>,
 }
 
-fn cow_to_spans<'a>(content: impl Into<Cow<'a, str>>) -> Vec<Span<'a>> {
-    match content.into() {
-        Cow::Borrowed(s) => s.lines().map(Span::raw).collect(),
-        Cow::Owned(s) => s.lines().map(|v| Span::raw(v.to_string())).collect(),
-    }
-}
-
 impl<'a> Line<'a> {
     /// Create a line with the default style.
     ///
@@ -193,14 +183,17 @@ impl<'a> Line<'a> {
         T: Into<Cow<'a, str>>,
     {
         Self {
-            spans: cow_to_spans(content),
+            spans: content
+                .into()
+                .lines()
+                .map(|v| Span::raw(v.to_string()))
+                .collect(),
             ..Default::default()
         }
     }
 
     /// Create a line with the given style.
-    ///
-    /// `content` can be any type that is convertible to [`Cow<str>`] (e.g. [`&str`], [`String`],
+    // `content` can be any type that is convertible to [`Cow<str>`] (e.g. [`&str`], [`String`],
     /// [`Cow<str>`], or your own type that implements [`Into<Cow<str>>`]).
     ///
     /// `style` accepts any type that is convertible to [`Style`] (e.g. [`Style`], [`Color`], or
@@ -224,7 +217,11 @@ impl<'a> Line<'a> {
         S: Into<Style>,
     {
         Self {
-            spans: cow_to_spans(content),
+            spans: content
+                .into()
+                .lines()
+                .map(|v| Span::raw(v.to_string()))
+                .collect(),
             style: style.into(),
             ..Default::default()
         }
@@ -505,13 +502,13 @@ impl<'a> IntoIterator for &'a mut Line<'a> {
 
 impl<'a> From<String> for Line<'a> {
     fn from(s: String) -> Self {
-        Self::raw(s)
+        Self::from(vec![Span::from(s)])
     }
 }
 
 impl<'a> From<&'a str> for Line<'a> {
     fn from(s: &'a str) -> Self {
-        Self::raw(s)
+        Self::from(vec![Span::from(s)])
     }
 }
 
@@ -548,37 +545,6 @@ where
     }
 }
 
-/// Adds a `Span` to a `Line`, returning a new `Line` with the `Span` added.
-impl<'a> std::ops::Add<Span<'a>> for Line<'a> {
-    type Output = Self;
-
-    fn add(mut self, rhs: Span<'a>) -> Self::Output {
-        self.spans.push(rhs);
-        self
-    }
-}
-
-/// Adds two `Line`s together, returning a new `Text` with the contents of the two `Line`s.
-impl<'a> std::ops::Add<Self> for Line<'a> {
-    type Output = Text<'a>;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Text::from(vec![self, rhs])
-    }
-}
-
-impl<'a> std::ops::AddAssign<Span<'a>> for Line<'a> {
-    fn add_assign(&mut self, rhs: Span<'a>) {
-        self.spans.push(rhs);
-    }
-}
-
-impl<'a> Extend<Span<'a>> for Line<'a> {
-    fn extend<T: IntoIterator<Item = Span<'a>>>(&mut self, iter: T) {
-        self.spans.extend(iter);
-    }
-}
-
 impl Widget for Line<'_> {
     fn render(self, area: Rect, buf: &mut Buffer) {
         self.render_ref(area, buf);
@@ -680,29 +646,6 @@ fn spans_after_width<'a>(
         })
 }
 
-/// A trait for converting a value to a [`Line`].
-///
-/// This trait is automatically implemented for any type that implements the [`Display`] trait. As
-/// such, `ToLine` shouln't be implemented directly: [`Display`] should be implemented instead, and
-/// you get the `ToLine` implementation for free.
-///
-/// [`Display`]: std::fmt::Display
-pub trait ToLine {
-    /// Converts the value to a [`Line`].
-    fn to_line(&self) -> Line<'_>;
-}
-
-/// # Panics
-///
-/// In this implementation, the `to_line` method panics if the `Display` implementation returns an
-/// error. This indicates an incorrect `Display` implementation since `fmt::Write for String` never
-/// returns an error itself.
-impl<T: fmt::Display> ToLine for T {
-    fn to_line(&self) -> Line<'_> {
-        Line::from(self.to_string())
-    }
-}
-
 impl fmt::Display for Line<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         for span in &self.spans {
@@ -860,28 +803,14 @@ mod tests {
     fn from_string() {
         let s = String::from("Hello, world!");
         let line = Line::from(s);
-        assert_eq!(line.spans, vec![Span::from("Hello, world!")]);
-
-        let s = String::from("Hello\nworld!");
-        let line = Line::from(s);
-        assert_eq!(line.spans, vec![Span::from("Hello"), Span::from("world!")]);
+        assert_eq!(vec![Span::from("Hello, world!")], line.spans);
     }
 
     #[test]
     fn from_str() {
         let s = "Hello, world!";
         let line = Line::from(s);
-        assert_eq!(line.spans, vec![Span::from("Hello, world!")]);
-
-        let s = "Hello\nworld!";
-        let line = Line::from(s);
-        assert_eq!(line.spans, vec![Span::from("Hello"), Span::from("world!")]);
-    }
-
-    #[test]
-    fn to_line() {
-        let line = 42.to_line();
-        assert_eq!(vec![Span::from("42")], line.spans);
+        assert_eq!(vec![Span::from("Hello, world!")], line.spans);
     }
 
     #[test]
@@ -891,7 +820,7 @@ mod tests {
             Span::styled(" world!", Style::default().fg(Color::Green)),
         ];
         let line = Line::from(spans.clone());
-        assert_eq!(line.spans, spans);
+        assert_eq!(spans, line.spans);
     }
 
     #[test]
@@ -924,63 +853,7 @@ mod tests {
     fn from_span() {
         let span = Span::styled("Hello, world!", Style::default().fg(Color::Yellow));
         let line = Line::from(span.clone());
-        assert_eq!(line.spans, vec![span],);
-    }
-
-    #[test]
-    fn add_span() {
-        assert_eq!(
-            Line::raw("Red").red() + Span::raw("blue").blue(),
-            Line {
-                spans: vec![Span::raw("Red"), Span::raw("blue").blue()],
-                style: Style::new().red(),
-                alignment: None,
-            },
-        );
-    }
-
-    #[test]
-    fn add_line() {
-        assert_eq!(
-            Line::raw("Red").red() + Line::raw("Blue").blue(),
-            Text {
-                lines: vec![Line::raw("Red").red(), Line::raw("Blue").blue()],
-                style: Style::default(),
-                alignment: None,
-            }
-        );
-    }
-
-    #[test]
-    fn add_assign_span() {
-        let mut line = Line::raw("Red").red();
-        line += Span::raw("Blue").blue();
-        assert_eq!(
-            line,
-            Line {
-                spans: vec![Span::raw("Red"), Span::raw("Blue").blue()],
-                style: Style::new().red(),
-                alignment: None,
-            },
-        );
-    }
-
-    #[test]
-    fn extend() {
-        let mut line = Line::from("Hello, ");
-        line.extend(vec![Span::raw("world!")]);
-        assert_eq!(line.spans, vec![Span::raw("Hello, "), Span::raw("world!")]);
-
-        let mut line = Line::from("Hello, ");
-        line.extend(vec![Span::raw("world! "), Span::raw("How are you?")]);
-        assert_eq!(
-            line.spans,
-            vec![
-                Span::raw("Hello, "),
-                Span::raw("world! "),
-                Span::raw("How are you?")
-            ]
-        );
+        assert_eq!(vec![span], line.spans);
     }
 
     #[test]
@@ -990,7 +863,7 @@ mod tests {
             Span::styled(" world!", Style::default().fg(Color::Green)),
         ]);
         let s: String = line.into();
-        assert_eq!(s, "Hello, world!");
+        assert_eq!("Hello, world!", s);
     }
 
     #[test]

src/text/span.rs

@@ -342,14 +342,6 @@ where
     }
 }
 
-impl<'a> std::ops::Add<Self> for Span<'a> {
-    type Output = Line<'a>;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Line::from_iter([self, rhs])
-    }
-}
-
 impl<'a> Styled for Span<'a> {
     type Item = Self;
 
@@ -414,29 +406,6 @@ impl WidgetRef for Span<'_> {
     }
 }
 
-/// A trait for converting a value to a [`Span`].
-///
-/// This trait is automatically implemented for any type that implements the [`Display`] trait. As
-/// such, `ToSpan` shouln't be implemented directly: [`Display`] should be implemented instead, and
-/// you get the `ToSpan` implementation for free.
-///
-/// [`Display`]: std::fmt::Display
-pub trait ToSpan {
-    /// Converts the value to a [`Span`].
-    fn to_span(&self) -> Span<'_>;
-}
-
-/// # Panics
-///
-/// In this implementation, the `to_span` method panics if the `Display` implementation returns an
-/// error. This indicates an incorrect `Display` implementation since `fmt::Write for String` never
-/// returns an error itself.
-impl<T: fmt::Display> ToSpan for T {
-    fn to_span(&self) -> Span<'_> {
-        Span::raw(self.to_string())
-    }
-}
-
 impl fmt::Display for Span<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&self.content, f)
@@ -538,12 +507,6 @@ mod tests {
         assert_eq!(span.style, Style::default());
     }
 
-    #[test]
-    fn to_span() {
-        assert_eq!(42.to_span(), Span::raw("42"));
-        assert_eq!("test".to_span(), Span::raw("test"));
-    }
-
     #[test]
     fn reset_style() {
         let span = Span::styled("test content", Style::new().green()).reset_style();
@@ -781,27 +744,4 @@ mod tests {
             ]
         );
     }
-
-    #[test]
-    fn add() {
-        assert_eq!(
-            Span::default() + Span::default(),
-            Line::from(vec![Span::default(), Span::default()])
-        );
-
-        assert_eq!(
-            Span::default() + Span::raw("test"),
-            Line::from(vec![Span::default(), Span::raw("test")])
-        );
-
-        assert_eq!(
-            Span::raw("test") + Span::default(),
-            Line::from(vec![Span::raw("test"), Span::default()])
-        );
-
-        assert_eq!(
-            Span::raw("test") + Span::raw("content"),
-            Line::from(vec![Span::raw("test"), Span::raw("content")])
-        );
-    }
 }

src/text/text.rs

@@ -570,33 +570,6 @@ where
     }
 }
 
-impl<'a> std::ops::Add<Line<'a>> for Text<'a> {
-    type Output = Self;
-
-    fn add(mut self, line: Line<'a>) -> Self::Output {
-        self.push_line(line);
-        self
-    }
-}
-
-/// Adds two `Text` together.
-///
-/// This ignores the style and alignment of the second `Text`.
-impl<'a> std::ops::Add<Self> for Text<'a> {
-    type Output = Self;
-
-    fn add(mut self, text: Self) -> Self::Output {
-        self.lines.extend(text.lines);
-        self
-    }
-}
-
-impl<'a> std::ops::AddAssign<Line<'a>> for Text<'a> {
-    fn add_assign(&mut self, line: Line<'a>) {
-        self.push_line(line);
-    }
-}
-
 impl<'a, T> Extend<T> for Text<'a>
 where
     T: Into<Line<'a>>,
@@ -607,29 +580,6 @@ where
     }
 }
 
-/// A trait for converting a value to a [`Text`].
-///
-/// This trait is automatically implemented for any type that implements the [`Display`] trait. As
-/// such, `ToText` shouldn't be implemented directly: [`Display`] should be implemented instead, and
-/// you get the `ToText` implementation for free.
-///
-/// [`Display`]: std::fmt::Display
-pub trait ToText {
-    /// Converts the value to a [`Text`].
-    fn to_text(&self) -> Text<'_>;
-}
-
-/// # Panics
-///
-/// In this implementation, the `to_text` method panics if the `Display` implementation returns an
-/// error. This indicates an incorrect `Display` implementation since `fmt::Write for String` never
-/// returns an error itself.
-impl<T: fmt::Display> ToText for T {
-    fn to_text(&self) -> Text {
-        Text::raw(self.to_string())
-    }
-}
-
 impl fmt::Display for Text<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         for (position, line) in self.iter().with_position() {
@@ -797,24 +747,6 @@ mod tests {
         assert_eq!(text.lines, vec![Line::from("The first line")]);
     }
 
-    #[rstest]
-    #[case(42, Text::from("42"))]
-    #[case("just\ntesting", Text::from("just\ntesting"))]
-    #[case(true, Text::from("true"))]
-    #[case(6.66, Text::from("6.66"))]
-    #[case('a', Text::from("a"))]
-    #[case(String::from("hello"), Text::from("hello"))]
-    #[case(-1, Text::from("-1"))]
-    #[case("line1\nline2", Text::from("line1\nline2"))]
-    #[case(
-        "first line\nsecond line\nthird line",
-        Text::from("first line\nsecond line\nthird line")
-    )]
-    #[case("trailing newline\n", Text::from("trailing newline\n"))]
-    fn to_text(#[case] value: impl fmt::Display, #[case] expected: Text) {
-        assert_eq!(value.to_text(), expected);
-    }
-
     #[test]
     fn from_vec_line() {
         let text = Text::from(vec![
@@ -856,44 +788,6 @@ mod tests {
         assert_eq!(iter.next(), None);
     }
 
-    #[test]
-    fn add_line() {
-        assert_eq!(
-            Text::raw("Red").red() + Line::raw("Blue").blue(),
-            Text {
-                lines: vec![Line::raw("Red"), Line::raw("Blue").blue()],
-                style: Style::new().red(),
-                alignment: None,
-            }
-        );
-    }
-
-    #[test]
-    fn add_text() {
-        assert_eq!(
-            Text::raw("Red").red() + Text::raw("Blue").blue(),
-            Text {
-                lines: vec![Line::raw("Red"), Line::raw("Blue")],
-                style: Style::new().red(),
-                alignment: None,
-            }
-        );
-    }
-
-    #[test]
-    fn add_assign_line() {
-        let mut text = Text::raw("Red").red();
-        text += Line::raw("Blue").blue();
-        assert_eq!(
-            text,
-            Text {
-                lines: vec![Line::raw("Red"), Line::raw("Blue").blue()],
-                style: Style::new().red(),
-                alignment: None,
-            }
-        );
-    }
-
     #[test]
     fn extend() {
         let mut text = Text::from("The first line\nThe second line");

src/widgets.rs

@@ -297,7 +297,7 @@ pub trait StatefulWidget {
 /// # }
 /// # }
 /// ```
-#[instability::unstable(feature = "widget-ref")]
+#[stability::unstable(feature = "widget-ref")]
 pub trait WidgetRef {
     /// Draws the current state of the widget in the given buffer. That is the only method required
     /// to implement a custom widget.
@@ -360,14 +360,14 @@ impl<W: WidgetRef> WidgetRef for Option<W> {
 ///
 /// This trait was introduced in Ratatui 0.26.0 and is implemented for all the internal stateful
 /// widgets. Implementors should prefer to implement this over the `StatefulWidget` trait and add an
-/// implementation of `StatefulWidget` that calls `StatefulWidgetRef::render_ref` where backwards
-/// compatibility is required.
+/// implementation of `StatefulWidget` that calls `StatefulWidgetRef::render_stateful_ref` where
+/// backwards compatibility is required.
 ///
 /// A blanket implementation of `StatefulWidget` for `&W` where `W` implements `StatefulWidgetRef`
 /// is provided.
 ///
-/// See the documentation for [`WidgetRef`] for more information on boxed widgets.
-/// See the documentation for [`StatefulWidget`] for more information on stateful widgets.
+/// See the documentation for [`WidgetRef`] for more information on boxed widgets. See the
+/// documentation for [`StatefulWidget`] for more information on stateful widgets.
 ///
 /// # Examples
 ///
@@ -379,7 +379,7 @@ impl<W: WidgetRef> WidgetRef for Option<W> {
 ///
 /// impl StatefulWidgetRef for PersonalGreeting {
 ///     type State = String;
-///     fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+///     fn render_stateful_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
 ///         Line::raw(format!("Hello {}", state)).render(area, buf);
 ///     }
 /// }
@@ -387,7 +387,7 @@ impl<W: WidgetRef> WidgetRef for Option<W> {
 /// impl StatefulWidget for PersonalGreeting {
 ///     type State = String;
 ///     fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-///         (&self).render_ref(area, buf, state);
+///         self.render_stateful_ref(area, buf, state);
 ///     }
 /// }
 ///
@@ -398,7 +398,7 @@ impl<W: WidgetRef> WidgetRef for Option<W> {
 /// }
 /// # }
 /// ```
-#[instability::unstable(feature = "widget-ref")]
+#[stability::unstable(feature = "widget-ref")]
 pub trait StatefulWidgetRef {
     /// State associated with the stateful widget.
     ///
@@ -406,7 +406,7 @@ pub trait StatefulWidgetRef {
     type State;
     /// Draws the current state of the widget in the given buffer. That is the only method required
     /// to implement a custom stateful widget.
-    fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State);
+    fn render_stateful_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State);
 }
 
 // Note: while StatefulWidgetRef is marked as unstable, the blanket implementation of StatefulWidget
@@ -420,7 +420,7 @@ pub trait StatefulWidgetRef {
 // impl<W: StatefulWidgetRef> StatefulWidget for &W {
 //     type State = W::State;
 //     fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-//         StatefulWidgetRef::render_ref(self, area, buf, state);
+//         self.render_stateful_ref(area, buf, state);
 //     }
 // }
 
@@ -583,7 +583,7 @@ mod tests {
 
         impl StatefulWidgetRef for PersonalGreeting {
             type State = String;
-            fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+            fn render_stateful_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
                 Line::from(format!("Hello {state}")).render(area, buf);
             }
         }
@@ -591,7 +591,7 @@ mod tests {
         #[rstest]
         fn render_ref(mut buf: Buffer, mut state: String) {
             let widget = PersonalGreeting;
-            widget.render_ref(buf.area, &mut buf, &mut state);
+            widget.render_stateful_ref(buf.area, &mut buf, &mut state);
             assert_eq!(buf, Buffer::with_lines(["Hello world         "]));
         }
 
@@ -610,7 +610,7 @@ mod tests {
         #[rstest]
         fn box_render_render(mut buf: Buffer, mut state: String) {
             let widget = Box::new(PersonalGreeting);
-            widget.render_ref(buf.area, &mut buf, &mut state);
+            widget.render_stateful_ref(buf.area, &mut buf, &mut state);
             assert_eq!(buf, Buffer::with_lines(["Hello world         "]));
         }
     }

src/widgets/block.rs

@@ -27,42 +27,14 @@ pub use title::{Position, Title};
 /// both centered and non-centered titles are rendered, the centered space is calculated based on
 /// the full width of the block, rather than the leftover width.
 ///
-/// Titles are not rendered in the corners of the block unless there is no border on that edge. If
-/// the block is too small and multiple titles overlap, the border may get cut off at a corner.
+/// Titles are not rendered in the corners of the block unless there is no border on that edge.
+/// If the block is too small and multiple titles overlap, the border may get cut off at a corner.
 ///
 /// ```plain
 /// ┌With at least a left border───
 ///
 /// Without left border───
 /// ```
-/// # Constructor methods
-///
-/// - [`Block::new`] creates a new [`Block`] with no border or paddings.
-/// - [`Block::bordered`] Create a new block with all borders shown.
-///
-/// # Setter methods
-///
-/// These methods are fluent setters. They return a new [`Block`] with the specified property set.
-///
-/// - [`Block::borders`] Defines which borders to display.
-/// - [`Block::border_style`] Defines the style of the borders.
-/// - [`Block::border_type`] Sets the symbols used to display the border (e.g. single line, double
-///   line, thick or rounded borders).
-/// - [`Block::padding`] Defines the padding inside a [`Block`].
-/// - [`Block::style`] Sets the base style of the widget.
-/// - [`Block::title`] Adds a title to the block.
-/// - [`Block::title_alignment`] Sets the default [`Alignment`] for all block titles.
-/// - [`Block::title_style`] Applies the style to all titles.
-/// - [`Block::title_top`] Adds a title to the top of the block.
-/// - [`Block::title_bottom`] Adds a title to the bottom of the block.
-/// - [`Block::title_position`] Adds a title to the block.
-///
-/// # Other Methods
-/// - [`Block::inner`] Compute the inner area of a block based on its border visibility rules.
-///
-/// [`Style`]s are applied first to the entire block, then to the borders, and finally to the
-/// titles. If the block is used as a container for another widget, the inner widget can also be
-/// styled. See [`Style`] for more information on how merging styles works.
 ///
 /// # Examples
 ///
@@ -91,20 +63,6 @@ pub use title::{Position, Title};
 ///     .title("Title 1")
 ///     .title(Title::from("Title 2").position(Position::Bottom));
 /// ```
-///
-/// You can also pass it as parameters of another widget so that the block surrounds them:
-/// ```
-/// use ratatui::{
-///     prelude::*,
-///     widgets::{Block, Borders, List},
-/// };
-///
-/// let surrounding_block = Block::default()
-///     .borders(Borders::ALL)
-///     .title("Here is a list of items");
-/// let items = ["Item 1", "Item 2", "Item 3"];
-/// let list = List::new(items).block(surrounding_block);
-/// ```
 #[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
 pub struct Block<'a> {
     /// List of titles
@@ -256,15 +214,12 @@ impl<'a> Block<'a> {
     /// Note: If the block is too small and multiple titles overlap, the border might get cut off at
     /// a corner.
     ///
-    /// # Examples
-    ///
-    /// See the [Block example] for a visual representation of how the various borders and styles
-    /// look when rendered.
+    /// # Example
     ///
     /// The following example demonstrates:
     /// - Default title alignment
     /// - Multiple titles (notice "Center" is centered according to the full with of the block, not
-    ///   the leftover space)
+    /// the leftover space)
     /// - Two titles with the same alignment (notice the left titles are separated)
     /// ```
     /// use ratatui::{
@@ -287,8 +242,6 @@ impl<'a> Block<'a> {
     /// - [`Block::title_style`]
     /// - [`Block::title_alignment`]
     /// - [`Block::title_position`]
-    ///
-    /// [Block example]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md#block
     #[must_use = "method moves the value of self and returns the modified value"]
     pub fn title<T>(mut self, title: T) -> Self
     where
@@ -356,14 +309,10 @@ impl<'a> Block<'a> {
 
     /// Applies the style to all titles.
     ///
-    /// This style will be applied to all titles of the block. If a title has a style set, it will
-    /// be applied after this style. This style will be applied after any [`Block::style`] or
-    /// [`Block::border_style`] is applied.
-    ///
-    /// See [`Style`] for more information on how merging styles works.
-    ///
     /// `style` accepts any type that is convertible to [`Style`] (e.g. [`Style`], [`Color`], or
     /// your own type that implements [`Into<Style>`]).
+    ///
+    /// If a [`Title`] already has a style, the title's style will add on top of this one.
     #[must_use = "method moves the value of self and returns the modified value"]
     pub fn title_style<S: Into<Style>>(mut self, style: S) -> Self {
         self.titles_style = style.into();
@@ -429,10 +378,7 @@ impl<'a> Block<'a> {
 
     /// Defines the style of the borders.
     ///
-    /// This style is applied only to the areas covered by borders, and is applied to the block
-    /// after any [`Block::style`] is applied.
-    ///
-    /// See [`Style`] for more information on how merging styles works.
+    /// If a [`Block::style`] is defined, `border_style` will be applied on top of it.
     ///
     /// `style` accepts any type that is convertible to [`Style`] (e.g. [`Style`], [`Color`], or
     /// your own type that implements [`Into<Style>`]).
@@ -450,39 +396,16 @@ impl<'a> Block<'a> {
         self
     }
 
-    /// Defines the style of the entire block.
+    /// Defines the block style.
     ///
     /// This is the most generic [`Style`] a block can receive, it will be merged with any other
-    /// more specific styles. Elements can be styled further with [`Block::title_style`] and
-    /// [`Block::border_style`], which will be applied on top of this style. If the block is used as
-    /// a container for another widget (e.g. a [`Paragraph`]), then the style of the widget is
-    /// generally applied before this style.
-    ///
-    /// See [`Style`] for more information on how merging styles works.
+    /// more specific style. Elements can be styled further with [`Block::title_style`] and
+    /// [`Block::border_style`].
     ///
     /// `style` accepts any type that is convertible to [`Style`] (e.g. [`Style`], [`Color`], or
     /// your own type that implements [`Into<Style>`]).
     ///
-    /// # Example
-    ///
-    /// ```
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let block = Block::new().style(Style::new().red().on_black());
-    ///
-    /// // For border and title you can additionally apply styles on top of the block level style.
-    /// let block = Block::new()
-    ///     .style(Style::new().red().bold().italic())
-    ///     .border_style(Style::new().not_italic()) // will be red and bold
-    ///     .title_style(Style::new().not_bold()) // will be red and italic
-    ///     .title("Title");
-    ///
-    /// // To style the inner widget, you can style the widget itself.
-    /// let paragraph = Paragraph::new("Content")
-    ///     .block(block)
-    ///     .style(Style::new().white().not_bold()); // will be white, and italic
-    /// ```
-    ///
-    /// [`Paragraph`]: crate::widgets::Paragraph
+    /// This will also apply to the widget inside that block, unless the inner widget is styled.
     #[must_use = "method moves the value of self and returns the modified value"]
     pub fn style<S: Into<Style>>(mut self, style: S) -> Self {
         self.style = style.into();
@@ -910,35 +833,6 @@ impl Block<'_> {
             height: 1,
         }
     }
-
-    /// Calculate the left, and right space the [`Block`] will take up.
-    ///
-    /// The result takes the [`Block`]'s, [`Borders`], and [`Padding`] into account.
-    pub(crate) fn horizontal_space(&self) -> (u16, u16) {
-        let left = self
-            .padding
-            .left
-            .saturating_add(u16::from(self.borders.contains(Borders::LEFT)));
-        let right = self
-            .padding
-            .right
-            .saturating_add(u16::from(self.borders.contains(Borders::RIGHT)));
-        (left, right)
-    }
-
-    /// Calculate the top, and bottom space that the [`Block`] will take up.
-    ///
-    /// Takes the [`Padding`], [`Title`]'s position, and the [`Borders`] that are selected into
-    /// account when calculating the result.
-    pub(crate) fn vertical_space(&self) -> (u16, u16) {
-        let has_top =
-            self.borders.contains(Borders::TOP) || self.has_title_at_position(Position::Top);
-        let top = self.padding.top + u16::from(has_top);
-        let has_bottom =
-            self.borders.contains(Borders::BOTTOM) || self.has_title_at_position(Position::Bottom);
-        let bottom = self.padding.bottom + u16::from(has_bottom);
-        (top, bottom)
-    }
 }
 
 /// An extension trait for [`Block`] that provides some convenience methods.
@@ -1091,126 +985,6 @@ mod tests {
         assert!(block.has_title_at_position(Position::Bottom));
     }
 
-    #[rstest]
-    #[case::none(Borders::NONE, (0, 0))]
-    #[case::top(Borders::TOP, (1, 0))]
-    #[case::right(Borders::RIGHT, (0, 0))]
-    #[case::bottom(Borders::BOTTOM, (0, 1))]
-    #[case::left(Borders::LEFT, (0, 0))]
-    #[case::top_right(Borders::TOP | Borders::RIGHT, (1, 0))]
-    #[case::top_bottom(Borders::TOP | Borders::BOTTOM, (1, 1))]
-    #[case::top_left(Borders::TOP | Borders::LEFT, (1, 0))]
-    #[case::bottom_right(Borders::BOTTOM | Borders::RIGHT, (0, 1))]
-    #[case::bottom_left(Borders::BOTTOM | Borders::LEFT, (0, 1))]
-    #[case::left_right(Borders::LEFT | Borders::RIGHT, (0, 0))]
-    fn vertical_space_takes_into_account_borders(
-        #[case] borders: Borders,
-        #[case] vertical_space: (u16, u16),
-    ) {
-        let block = Block::new().borders(borders);
-        assert_eq!(block.vertical_space(), vertical_space);
-    }
-
-    #[rstest]
-    #[case::top_border_top_p1(Borders::TOP, Padding::new(0, 0, 1, 0), (2, 0))]
-    #[case::right_border_top_p1(Borders::RIGHT, Padding::new(0, 0, 1, 0), (1, 0))]
-    #[case::bottom_border_top_p1(Borders::BOTTOM, Padding::new(0, 0, 1, 0), (1, 1))]
-    #[case::left_border_top_p1(Borders::LEFT, Padding::new(0, 0, 1, 0), (1, 0))]
-    #[case::top_bottom_border_all_p3(Borders::TOP | Borders::BOTTOM, Padding::new(100, 100, 4, 5), (5, 6))]
-    #[case::no_border(Borders::NONE, Padding::new(100, 100, 10, 13), (10, 13))]
-    #[case::all(Borders::ALL, Padding::new(100, 100, 1, 3), (2, 4))]
-    fn vertical_space_takes_into_account_padding(
-        #[case] borders: Borders,
-        #[case] padding: Padding,
-        #[case] vertical_space: (u16, u16),
-    ) {
-        let block = Block::new().borders(borders).padding(padding);
-        assert_eq!(block.vertical_space(), vertical_space);
-    }
-
-    #[test]
-    fn vertical_space_takes_into_account_titles() {
-        let block = Block::new()
-            .title_position(Position::Top)
-            .title(Title::from("Test"));
-
-        assert_eq!(block.vertical_space(), (1, 0));
-
-        let block = Block::new()
-            .title_position(Position::Bottom)
-            .title(Title::from("Test"));
-
-        assert_eq!(block.vertical_space(), (0, 1));
-    }
-
-    #[rstest]
-    #[case::top_border_top_title(Block::new(), Borders::TOP, Position::Top, (1, 0))]
-    #[case::right_border_top_title(Block::new(), Borders::RIGHT, Position::Top, (1, 0))]
-    #[case::bottom_border_top_title(Block::new(), Borders::BOTTOM, Position::Top, (1, 1))]
-    #[case::left_border_top_title(Block::new(), Borders::LEFT, Position::Top, (1, 0))]
-    #[case::top_border_top_title(Block::new(), Borders::TOP, Position::Bottom, (1, 1))]
-    #[case::right_border_top_title(Block::new(), Borders::RIGHT, Position::Bottom, (0, 1))]
-    #[case::bottom_border_top_title(Block::new(), Borders::BOTTOM, Position::Bottom, (0, 1))]
-    #[case::left_border_top_title(Block::new(), Borders::LEFT, Position::Bottom, (0, 1))]
-    fn vertical_space_takes_into_account_borders_and_title(
-        #[case] block: Block,
-        #[case] borders: Borders,
-        #[case] pos: Position,
-        #[case] vertical_space: (u16, u16),
-    ) {
-        let block = block
-            .borders(borders)
-            .title_position(pos)
-            .title(Title::from("Test"));
-        assert_eq!(block.vertical_space(), vertical_space);
-    }
-
-    #[test]
-    fn horizontal_space_takes_into_account_borders() {
-        let block = Block::bordered();
-        assert_eq!(block.horizontal_space(), (1, 1));
-
-        let block = Block::new().borders(Borders::LEFT);
-        assert_eq!(block.horizontal_space(), (1, 0));
-
-        let block = Block::new().borders(Borders::RIGHT);
-        assert_eq!(block.horizontal_space(), (0, 1));
-    }
-
-    #[test]
-    fn horizontal_space_takes_into_account_padding() {
-        let block = Block::new().padding(Padding::new(1, 1, 100, 100));
-        assert_eq!(block.horizontal_space(), (1, 1));
-
-        let block = Block::new().padding(Padding::new(3, 5, 0, 0));
-        assert_eq!(block.horizontal_space(), (3, 5));
-
-        let block = Block::new().padding(Padding::new(0, 1, 100, 100));
-        assert_eq!(block.horizontal_space(), (0, 1));
-
-        let block = Block::new().padding(Padding::new(1, 0, 100, 100));
-        assert_eq!(block.horizontal_space(), (1, 0));
-    }
-
-    #[rstest]
-    #[case::all_bordered_all_padded(Block::bordered(), Padding::new(1, 1, 1, 1), (2, 2))]
-    #[case::all_bordered_left_padded(Block::bordered(), Padding::new(1, 0, 0, 0), (2, 1))]
-    #[case::all_bordered_right_padded(Block::bordered(), Padding::new(0, 1, 0, 0), (1, 2))]
-    #[case::all_bordered_top_padded(Block::bordered(), Padding::new(0, 0, 1, 0), (1, 1))]
-    #[case::all_bordered_bottom_padded(Block::bordered(), Padding::new(0, 0, 0, 1), (1, 1))]
-    #[case::left_bordered_left_padded(Block::new().borders(Borders::LEFT), Padding::new(1, 0, 0, 0), (2, 0))]
-    #[case::left_bordered_right_padded(Block::new().borders(Borders::LEFT), Padding::new(0, 1, 0, 0), (1, 1))]
-    #[case::right_bordered_right_padded(Block::new().borders(Borders::RIGHT), Padding::new(0, 1, 0, 0), (0, 2))]
-    #[case::right_bordered_left_padded(Block::new().borders(Borders::RIGHT), Padding::new(1, 0, 0, 0), (1, 1))]
-    fn horizontal_space_takes_into_account_borders_and_padding(
-        #[case] block: Block,
-        #[case] padding: Padding,
-        #[case] horizontal_space: (u16, u16),
-    ) {
-        let block = block.padding(padding);
-        assert_eq!(block.horizontal_space(), horizontal_space);
-    }
-
     #[test]
     const fn border_type_can_be_const() {
         const _PLAIN: border::Set = BorderType::border_symbols(BorderType::Plain);

src/widgets/chart.rs

@@ -144,15 +144,11 @@ pub enum GraphType {
     /// Draw each point. This is the default.
     #[default]
     Scatter,
-
     /// Draw a line between each following point.
     ///
     /// The order of the lines will be the same as the order of the points in the dataset, which
     /// allows this widget to draw lines both left-to-right and right-to-left
     Line,
-
-    /// Draw a bar chart. This will draw a bar for each point in the dataset.
-    Bar,
 }
 
 /// Allow users to specify the position of a legend in a [`Chart`]
@@ -366,10 +362,9 @@ impl<'a> Dataset<'a> {
 
     /// Sets how the dataset should be drawn
     ///
-    /// [`Chart`] can draw [scatter](GraphType::Scatter), [line](GraphType::Line) or
-    /// [bar](GraphType::Bar) charts. A scatter chart draws only the points in the dataset, a line
-    /// char draws a line between each point, and a bar chart draws a line from the x axis to the
-    /// point.  See [`GraphType`] for more details
+    /// [`Chart`] can draw either a [scatter](GraphType::Scatter) or [line](GraphType::Line) charts.
+    /// A scatter will draw only the points in the dataset while a line will also draw a line
+    /// between them. See [`GraphType`] for more details
     ///
     /// This is a fluent setter method which must be chained or used as it consumes self
     #[must_use = "method moves the value of self and returns the modified value"]
@@ -1003,30 +998,16 @@ impl WidgetRef for Chart<'_> {
                         coords: dataset.data,
                         color: dataset.style.fg.unwrap_or(Color::Reset),
                     });
-                    match dataset.graph_type {
-                        GraphType::Line => {
-                            for data in dataset.data.windows(2) {
-                                ctx.draw(&CanvasLine {
-                                    x1: data[0].0,
-                                    y1: data[0].1,
-                                    x2: data[1].0,
-                                    y2: data[1].1,
-                                    color: dataset.style.fg.unwrap_or(Color::Reset),
-                                });
-                            }
+                    if dataset.graph_type == GraphType::Line {
+                        for data in dataset.data.windows(2) {
+                            ctx.draw(&CanvasLine {
+                                x1: data[0].0,
+                                y1: data[0].1,
+                                x2: data[1].0,
+                                y2: data[1].1,
+                                color: dataset.style.fg.unwrap_or(Color::Reset),
+                            });
                         }
-                        GraphType::Bar => {
-                            for (x, y) in dataset.data {
-                                ctx.draw(&CanvasLine {
-                                    x1: *x,
-                                    y1: 0.0,
-                                    x2: *x,
-                                    y2: *y,
-                                    color: dataset.style.fg.unwrap_or(Color::Reset),
-                                });
-                            }
-                        }
-                        GraphType::Scatter => {}
                     }
                 })
                 .render(graph_area, buf);
@@ -1213,14 +1194,12 @@ mod tests {
     fn graph_type_to_string() {
         assert_eq!(GraphType::Scatter.to_string(), "Scatter");
         assert_eq!(GraphType::Line.to_string(), "Line");
-        assert_eq!(GraphType::Bar.to_string(), "Bar");
     }
 
     #[test]
     fn graph_type_from_str() {
         assert_eq!("Scatter".parse::<GraphType>(), Ok(GraphType::Scatter));
         assert_eq!("Line".parse::<GraphType>(), Ok(GraphType::Line));
-        assert_eq!("Bar".parse::<GraphType>(), Ok(GraphType::Bar));
         assert_eq!("".parse::<GraphType>(), Err(ParseError::VariantNotFound));
     }
 
@@ -1481,39 +1460,4 @@ mod tests {
         chart.render(buffer.area, &mut buffer);
         assert_eq!(buffer, Buffer::with_lines(expected));
     }
-
-    #[test]
-    fn bar_chart() {
-        let data = [
-            (0.0, 0.0),
-            (2.0, 1.0),
-            (4.0, 4.0),
-            (6.0, 8.0),
-            (8.0, 9.0),
-            (10.0, 10.0),
-        ];
-        let chart = Chart::new(vec![Dataset::default()
-            .data(&data)
-            .marker(symbols::Marker::Dot)
-            .graph_type(GraphType::Bar)])
-        .x_axis(Axis::default().bounds([0.0, 10.0]))
-        .y_axis(Axis::default().bounds([0.0, 10.0]));
-        let area = Rect::new(0, 0, 11, 11);
-        let mut buffer = Buffer::empty(area);
-        chart.render(buffer.area, &mut buffer);
-        let expected = Buffer::with_lines([
-            "          •",
-            "        • •",
-            "      • • •",
-            "      • • •",
-            "      • • •",
-            "      • • •",
-            "    • • • •",
-            "    • • • •",
-            "    • • • •",
-            "  • • • • •",
-            "• • • • • •",
-        ]);
-        assert_eq!(buffer, expected);
-    }
 }

src/widgets/list/item.rs

@@ -1,324 +0,0 @@
-use crate::prelude::*;
-
-/// A single item in a [`List`]
-///
-/// The item's height is defined by the number of lines it contains. This can be queried using
-/// [`ListItem::height`]. Similarly, [`ListItem::width`] will return the maximum width of all
-/// lines.
-///
-/// You can set the style of an item with [`ListItem::style`] or using the [`Stylize`] trait.
-/// This [`Style`] will be combined with the [`Style`] of the inner [`Text`]. The [`Style`]
-/// of the [`Text`] will be added to the [`Style`] of the [`ListItem`].
-///
-/// You can also align a `ListItem` by aligning its underlying [`Text`] and [`Line`]s. For that,
-/// see [`Text::alignment`] and [`Line::alignment`]. On a multiline `Text`, one `Line` can override
-/// the alignment by setting it explicitly.
-///
-/// # Examples
-///
-/// You can create [`ListItem`]s from simple `&str`
-///
-/// ```rust
-/// # use ratatui::{prelude::*, widgets::*};
-/// let item = ListItem::new("Item 1");
-/// ```
-///
-/// Anything that can be converted to [`Text`] can be a [`ListItem`].
-///
-/// ```rust
-/// # use ratatui::{prelude::*, widgets::*};
-/// let item1: ListItem = "Item 1".into();
-/// let item2: ListItem = Line::raw("Item 2").into();
-/// ```
-///
-/// A [`ListItem`] styled with [`Stylize`]
-///
-/// ```rust
-/// # use ratatui::{prelude::*, widgets::*};
-/// let item = ListItem::new("Item 1").red().on_white();
-/// ```
-///
-/// If you need more control over the item's style, you can explicitly style the underlying
-/// [`Text`]
-///
-/// ```rust
-/// # use ratatui::{prelude::*, widgets::*};
-/// let mut text = Text::default();
-/// text.extend(["Item".blue(), Span::raw(" "), "1".bold().red()]);
-/// let item = ListItem::new(text);
-/// ```
-///
-/// A right-aligned `ListItem`
-///
-/// ```rust
-/// # use ratatui::{prelude::*, widgets::*};
-/// ListItem::new(Text::from("foo").alignment(Alignment::Right));
-/// ```
-///
-/// [`List`]: crate::widgets::List
-/// [`Stylize`]: crate::style::Stylize
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ListItem<'a> {
-    pub(crate) content: Text<'a>,
-    pub(crate) style: Style,
-}
-
-impl<'a> ListItem<'a> {
-    /// Creates a new [`ListItem`]
-    ///
-    /// The `content` parameter accepts any value that can be converted into [`Text`].
-    ///
-    /// # Examples
-    ///
-    /// You can create [`ListItem`]s from simple `&str`
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("Item 1");
-    /// ```
-    ///
-    /// Anything that can be converted to [`Text`] can be a [`ListItem`].
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item1: ListItem = "Item 1".into();
-    /// let item2: ListItem = Line::raw("Item 2").into();
-    /// ```
-    ///
-    /// You can also create multilines item
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("Multi-line\nitem");
-    /// ```
-    ///
-    /// # See also
-    ///
-    /// - [`List::new`](crate::widgets::List::new) to create a list of items that can be converted
-    ///   to [`ListItem`]
-    pub fn new<T>(content: T) -> Self
-    where
-        T: Into<Text<'a>>,
-    {
-        Self {
-            content: content.into(),
-            style: Style::default(),
-        }
-    }
-
-    /// Sets the item style
-    ///
-    /// `style` accepts any type that is convertible to [`Style`] (e.g. [`Style`], [`Color`], or
-    /// your own type that implements [`Into<Style>`]).
-    ///
-    /// This [`Style`] can be overridden by the [`Style`] of the [`Text`] content.
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("Item 1").style(Style::new().red().italic());
-    /// ```
-    ///
-    /// `ListItem` also implements the [`Styled`] trait, which means you can use style shorthands
-    /// from the [`Stylize`](crate::style::Stylize) trait to set the style of the widget more
-    /// concisely.
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("Item 1").red().italic();
-    /// ```
-    ///
-    /// [`Styled`]: crate::style::Styled
-    /// [`ListState`]: crate::widgets::list::ListState
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub fn style<S: Into<Style>>(mut self, style: S) -> Self {
-        self.style = style.into();
-        self
-    }
-
-    /// Returns the item height
-    ///
-    /// # Examples
-    ///
-    /// One line item
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("Item 1");
-    /// assert_eq!(item.height(), 1);
-    /// ```
-    ///
-    /// Two lines item (note the `\n`)
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("Multi-line\nitem");
-    /// assert_eq!(item.height(), 2);
-    /// ```
-    pub fn height(&self) -> usize {
-        self.content.height()
-    }
-
-    /// Returns the max width of all the lines
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("12345");
-    /// assert_eq!(item.width(), 5);
-    /// ```
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let item = ListItem::new("12345\n1234567");
-    /// assert_eq!(item.width(), 7);
-    /// ```
-    pub fn width(&self) -> usize {
-        self.content.width()
-    }
-}
-
-impl<'a, T> From<T> for ListItem<'a>
-where
-    T: Into<Text<'a>>,
-{
-    fn from(value: T) -> Self {
-        Self::new(value)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::borrow::Cow;
-
-    use pretty_assertions::assert_eq;
-
-    use super::*;
-
-    #[test]
-    fn new_from_str() {
-        let item = ListItem::new("Test item");
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn new_from_string() {
-        let item = ListItem::new("Test item".to_string());
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn new_from_cow_str() {
-        let item = ListItem::new(Cow::Borrowed("Test item"));
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn new_from_span() {
-        let span = Span::styled("Test item", Style::default().fg(Color::Blue));
-        let item = ListItem::new(span.clone());
-        assert_eq!(item.content, Text::from(span));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn new_from_spans() {
-        let spans = Line::from(vec![
-            Span::styled("Test ", Style::default().fg(Color::Blue)),
-            Span::styled("item", Style::default().fg(Color::Red)),
-        ]);
-        let item = ListItem::new(spans.clone());
-        assert_eq!(item.content, Text::from(spans));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn new_from_vec_spans() {
-        let lines = vec![
-            Line::from(vec![
-                Span::styled("Test ", Style::default().fg(Color::Blue)),
-                Span::styled("item", Style::default().fg(Color::Red)),
-            ]),
-            Line::from(vec![
-                Span::styled("Second ", Style::default().fg(Color::Green)),
-                Span::styled("line", Style::default().fg(Color::Yellow)),
-            ]),
-        ];
-        let item = ListItem::new(lines.clone());
-        assert_eq!(item.content, Text::from(lines));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn str_into_list_item() {
-        let s = "Test item";
-        let item: ListItem = s.into();
-        assert_eq!(item.content, Text::from(s));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn string_into_list_item() {
-        let s = String::from("Test item");
-        let item: ListItem = s.clone().into();
-        assert_eq!(item.content, Text::from(s));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn span_into_list_item() {
-        let s = Span::from("Test item");
-        let item: ListItem = s.clone().into();
-        assert_eq!(item.content, Text::from(s));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn vec_lines_into_list_item() {
-        let lines = vec![Line::raw("l1"), Line::raw("l2")];
-        let item: ListItem = lines.clone().into();
-        assert_eq!(item.content, Text::from(lines));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn style() {
-        let item = ListItem::new("Test item").style(Style::default().bg(Color::Red));
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default().bg(Color::Red));
-    }
-
-    #[test]
-    fn height() {
-        let item = ListItem::new("Test item");
-        assert_eq!(item.height(), 1);
-
-        let item = ListItem::new("Test item\nSecond line");
-        assert_eq!(item.height(), 2);
-    }
-
-    #[test]
-    fn width() {
-        let item = ListItem::new("Test item");
-        assert_eq!(item.width(), 9);
-    }
-
-    #[test]
-    fn can_be_stylized() {
-        assert_eq!(
-            ListItem::new("").black().on_white().bold().not_dim().style,
-            Style::default()
-                .fg(Color::Black)
-                .bg(Color::White)
-                .add_modifier(Modifier::BOLD)
-                .remove_modifier(Modifier::DIM)
-        );
-    }
-}

src/widgets/list/list.rs

@@ -1,450 +0,0 @@
-use strum::{Display, EnumString};
-
-use super::ListItem;
-use crate::{
-    prelude::*,
-    style::Styled,
-    widgets::{Block, HighlightSpacing},
-};
-
-/// A widget to display several items among which one can be selected (optional)
-///
-/// A list is a collection of [`ListItem`]s.
-///
-/// This is different from a [`Table`] because it does not handle columns, headers or footers and
-/// the item's height is automatically determined. A `List` can also be put in reverse order (i.e.
-/// *bottom to top*) whereas a [`Table`] cannot.
-///
-/// [`Table`]: crate::widgets::Table
-///
-/// List items can be aligned using [`Text::alignment`], for more details see [`ListItem`].
-///
-/// [`List`] implements [`Widget`] and so it can be drawn using
-/// [`Frame::render_widget`](crate::terminal::Frame::render_widget).
-///
-/// [`List`] is also a [`StatefulWidget`], which means you can use it with [`ListState`] to allow
-/// the user to [scroll] through items and [select] one of them.
-///
-/// See the list in the [Examples] directory for a more in depth example of the various
-/// configuration options and for how to handle state.
-///
-/// [Examples]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
-///
-/// # Fluent setters
-///
-/// - [`List::highlight_style`] sets the style of the selected item.
-/// - [`List::highlight_symbol`] sets the symbol to be displayed in front of the selected item.
-/// - [`List::repeat_highlight_symbol`] sets whether to repeat the symbol and style over selected
-///   multi-line items
-/// - [`List::direction`] sets the list direction
-///
-/// # Examples
-///
-/// ```
-/// use ratatui::{prelude::*, widgets::*};
-/// # fn ui(frame: &mut Frame) {
-/// # let area = Rect::default();
-/// let items = ["Item 1", "Item 2", "Item 3"];
-/// let list = List::new(items)
-///     .block(Block::bordered().title("List"))
-///     .style(Style::default().fg(Color::White))
-///     .highlight_style(Style::default().add_modifier(Modifier::ITALIC))
-///     .highlight_symbol(">>")
-///     .repeat_highlight_symbol(true)
-///     .direction(ListDirection::BottomToTop);
-///
-/// frame.render_widget(list, area);
-/// # }
-/// ```
-///
-/// # Stateful example
-///
-/// ```rust
-/// # use ratatui::{prelude::*, widgets::*};
-/// # fn ui(frame: &mut Frame) {
-/// # let area = Rect::default();
-/// // This should be stored outside of the function in your application state.
-/// let mut state = ListState::default();
-/// let items = ["Item 1", "Item 2", "Item 3"];
-/// let list = List::new(items)
-///     .block(Block::bordered().title("List"))
-///     .highlight_style(Style::new().add_modifier(Modifier::REVERSED))
-///     .highlight_symbol(">>")
-///     .repeat_highlight_symbol(true);
-///
-/// frame.render_stateful_widget(list, area, &mut state);
-/// # }
-/// ```
-///
-/// In addition to `List::new`, any iterator whose element is convertible to `ListItem` can be
-/// collected into `List`.
-///
-/// ```
-/// use ratatui::widgets::List;
-///
-/// (0..5).map(|i| format!("Item{i}")).collect::<List>();
-/// ```
-///
-/// [`ListState`]: crate::widgets::list::ListState
-/// [scroll]: crate::widgets::list::ListState::offset
-/// [select]: crate::widgets::list::ListState::select
-#[derive(Debug, Clone, Eq, PartialEq, Hash, Default)]
-pub struct List<'a> {
-    /// An optional block to wrap the widget in
-    pub(crate) block: Option<Block<'a>>,
-    /// The items in the list
-    pub(crate) items: Vec<ListItem<'a>>,
-    /// Style used as a base style for the widget
-    pub(crate) style: Style,
-    /// List display direction
-    pub(crate) direction: ListDirection,
-    /// Style used to render selected item
-    pub(crate) highlight_style: Style,
-    /// Symbol in front of the selected item (Shift all items to the right)
-    pub(crate) highlight_symbol: Option<&'a str>,
-    /// Whether to repeat the highlight symbol for each line of the selected item
-    pub(crate) repeat_highlight_symbol: bool,
-    /// Decides when to allocate spacing for the selection symbol
-    pub(crate) highlight_spacing: HighlightSpacing,
-    /// How many items to try to keep visible before and after the selected item
-    pub(crate) scroll_padding: usize,
-}
-
-/// Defines the direction in which the list will be rendered.
-///
-/// If there are too few items to fill the screen, the list will stick to the starting edge.
-///
-/// See [`List::direction`].
-#[derive(Debug, Default, Display, EnumString, Clone, Copy, Eq, PartialEq, Hash)]
-pub enum ListDirection {
-    /// The first value is on the top, going to the bottom
-    #[default]
-    TopToBottom,
-    /// The first value is on the bottom, going to the top.
-    BottomToTop,
-}
-
-impl<'a> List<'a> {
-    /// Creates a new list from [`ListItem`]s
-    ///
-    /// The `items` parameter accepts any value that can be converted into an iterator of
-    /// [`Into<ListItem>`]. This includes arrays of [`&str`] or [`Vec`]s of [`Text`].
-    ///
-    /// # Example
-    ///
-    /// From a slice of [`&str`]
-    ///
-    /// ```
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let list = List::new(["Item 1", "Item 2"]);
-    /// ```
-    ///
-    /// From [`Text`]
-    ///
-    /// ```
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let list = List::new([
-    ///     Text::styled("Item 1", Style::default().red()),
-    ///     Text::styled("Item 2", Style::default().red()),
-    /// ]);
-    /// ```
-    ///
-    /// You can also create an empty list using the [`Default`] implementation and use the
-    /// [`List::items`] fluent setter.
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let empty_list = List::default();
-    /// let filled_list = empty_list.items(["Item 1"]);
-    /// ```
-    pub fn new<T>(items: T) -> Self
-    where
-        T: IntoIterator,
-        T::Item: Into<ListItem<'a>>,
-    {
-        Self {
-            block: None,
-            style: Style::default(),
-            items: items.into_iter().map(Into::into).collect(),
-            direction: ListDirection::default(),
-            ..Self::default()
-        }
-    }
-
-    /// Set the items
-    ///
-    /// The `items` parameter accepts any value that can be converted into an iterator of
-    /// [`Into<ListItem>`]. This includes arrays of [`&str`] or [`Vec`]s of [`Text`].
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let list = List::default().items(["Item 1", "Item 2"]);
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub fn items<T>(mut self, items: T) -> Self
-    where
-        T: IntoIterator,
-        T::Item: Into<ListItem<'a>>,
-    {
-        self.items = items.into_iter().map(Into::into).collect();
-        self
-    }
-
-    /// Wraps the list with a custom [`Block`] widget.
-    ///
-    /// The `block` parameter holds the specified [`Block`] to be created around the [`List`]
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1"];
-    /// let block = Block::bordered().title("List");
-    /// let list = List::new(items).block(block);
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub fn block(mut self, block: Block<'a>) -> Self {
-        self.block = Some(block);
-        self
-    }
-
-    /// Sets the base style of the widget
-    ///
-    /// `style` accepts any type that is convertible to [`Style`] (e.g. [`Style`], [`Color`], or
-    /// your own type that implements [`Into<Style>`]).
-    ///
-    /// All text rendered by the widget will use this style, unless overridden by [`Block::style`],
-    /// [`ListItem::style`], or the styles of the [`ListItem`]'s content.
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1"];
-    /// let list = List::new(items).style(Style::new().red().italic());
-    /// ```
-    ///
-    /// `List` also implements the [`Styled`] trait, which means you can use style shorthands from
-    /// the [`Stylize`] trait to set the style of the widget more concisely.
-    ///
-    /// [`Stylize`]: crate::style::Stylize
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1"];
-    /// let list = List::new(items).red().italic();
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub fn style<S: Into<Style>>(mut self, style: S) -> Self {
-        self.style = style.into();
-        self
-    }
-
-    /// Set the symbol to be displayed in front of the selected item
-    ///
-    /// By default there are no highlight symbol.
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1", "Item 2"];
-    /// let list = List::new(items).highlight_symbol(">>");
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub const fn highlight_symbol(mut self, highlight_symbol: &'a str) -> Self {
-        self.highlight_symbol = Some(highlight_symbol);
-        self
-    }
-
-    /// Set the style of the selected item
-    ///
-    /// `style` accepts any type that is convertible to [`Style`] (e.g. [`Style`], [`Color`], or
-    /// your own type that implements [`Into<Style>`]).
-    ///
-    /// This style will be applied to the entire item, including the
-    /// [highlight symbol](List::highlight_symbol) if it is displayed, and will override any style
-    /// set on the item or on the individual cells.
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1", "Item 2"];
-    /// let list = List::new(items).highlight_style(Style::new().red().italic());
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub fn highlight_style<S: Into<Style>>(mut self, style: S) -> Self {
-        self.highlight_style = style.into();
-        self
-    }
-
-    /// Set whether to repeat the highlight symbol and style over selected multi-line items
-    ///
-    /// This is `false` by default.
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub const fn repeat_highlight_symbol(mut self, repeat: bool) -> Self {
-        self.repeat_highlight_symbol = repeat;
-        self
-    }
-
-    /// Set when to show the highlight spacing
-    ///
-    /// The highlight spacing is the spacing that is allocated for the selection symbol (if enabled)
-    /// and is used to shift the list when an item is selected. This method allows you to configure
-    /// when this spacing is allocated.
-    ///
-    /// - [`HighlightSpacing::Always`] will always allocate the spacing, regardless of whether an
-    ///   item is selected or not. This means that the table will never change size, regardless of
-    ///   if an item is selected or not.
-    /// - [`HighlightSpacing::WhenSelected`] will only allocate the spacing if an item is selected.
-    ///   This means that the table will shift when an item is selected. This is the default setting
-    ///   for backwards compatibility, but it is recommended to use `HighlightSpacing::Always` for a
-    ///   better user experience.
-    /// - [`HighlightSpacing::Never`] will never allocate the spacing, regardless of whether an item
-    ///   is selected or not. This means that the highlight symbol will never be drawn.
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1"];
-    /// let list = List::new(items).highlight_spacing(HighlightSpacing::Always);
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub const fn highlight_spacing(mut self, value: HighlightSpacing) -> Self {
-        self.highlight_spacing = value;
-        self
-    }
-
-    /// Defines the list direction (up or down)
-    ///
-    /// Defines if the `List` is displayed *top to bottom* (default) or *bottom to top*.
-    /// If there is too few items to fill the screen, the list will stick to the starting edge.
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Example
-    ///
-    /// Bottom to top
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1"];
-    /// let list = List::new(items).direction(ListDirection::BottomToTop);
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub const fn direction(mut self, direction: ListDirection) -> Self {
-        self.direction = direction;
-        self
-    }
-
-    /// Sets the number of items around the currently selected item that should be kept visible
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Example
-    ///
-    /// A padding value of 1 will keep 1 item above and 1 item bellow visible if possible
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// # let items = ["Item 1"];
-    /// let list = List::new(items).scroll_padding(1);
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub const fn scroll_padding(mut self, padding: usize) -> Self {
-        self.scroll_padding = padding;
-        self
-    }
-
-    /// Returns the number of [`ListItem`]s in the list
-    pub fn len(&self) -> usize {
-        self.items.len()
-    }
-
-    /// Returns true if the list contains no elements.
-    pub fn is_empty(&self) -> bool {
-        self.items.is_empty()
-    }
-}
-
-impl<'a> Styled for List<'a> {
-    type Item = Self;
-
-    fn style(&self) -> Style {
-        self.style
-    }
-
-    fn set_style<S: Into<Style>>(self, style: S) -> Self::Item {
-        self.style(style)
-    }
-}
-
-impl<'a> Styled for ListItem<'a> {
-    type Item = Self;
-
-    fn style(&self) -> Style {
-        self.style
-    }
-
-    fn set_style<S: Into<Style>>(self, style: S) -> Self::Item {
-        self.style(style)
-    }
-}
-
-impl<'a, Item> FromIterator<Item> for List<'a>
-where
-    Item: Into<ListItem<'a>>,
-{
-    fn from_iter<Iter: IntoIterator<Item = Item>>(iter: Iter) -> Self {
-        Self::new(iter)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use pretty_assertions::assert_eq;
-
-    use super::*;
-
-    #[test]
-    fn collect_list_from_iterator() {
-        let collected: List = (0..3).map(|i| format!("Item{i}")).collect();
-        let expected = List::new(["Item0", "Item1", "Item2"]);
-        assert_eq!(collected, expected);
-    }
-
-    #[test]
-    fn can_be_stylized() {
-        assert_eq!(
-            List::new::<Vec<&str>>(vec![])
-                .black()
-                .on_white()
-                .bold()
-                .not_dim()
-                .style,
-            Style::default()
-                .fg(Color::Black)
-                .bg(Color::White)
-                .add_modifier(Modifier::BOLD)
-                .remove_modifier(Modifier::DIM)
-        );
-    }
-}

src/widgets/list/state.rs

@@ -1,289 +0,0 @@
-/// State of the [`List`] widget
-///
-/// This state can be used to scroll through items and select one. When the list is rendered as a
-/// stateful widget, the selected item will be highlighted and the list will be shifted to ensure
-/// that the selected item is visible. This will modify the [`ListState`] object passed to the
-/// [`Frame::render_stateful_widget`](crate::terminal::Frame::render_stateful_widget) method.
-///
-/// The state consists of two fields:
-/// - [`offset`]: the index of the first item to be displayed
-/// - [`selected`]: the index of the selected item, which can be `None` if no item is selected
-///
-/// [`offset`]: ListState::offset()
-/// [`selected`]: ListState::selected()
-///
-/// See the list in the [Examples] directory for a more in depth example of the various
-/// configuration options and for how to handle state.
-///
-/// [Examples]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
-///
-/// # Example
-///
-/// ```rust
-/// # use ratatui::{prelude::*, widgets::*};
-/// # fn ui(frame: &mut Frame) {
-/// # let area = Rect::default();
-/// # let items = ["Item 1"];
-/// let list = List::new(items);
-///
-/// // This should be stored outside of the function in your application state.
-/// let mut state = ListState::default();
-///
-/// *state.offset_mut() = 1; // display the second item and onwards
-/// state.select(Some(3)); // select the forth item (0-indexed)
-///
-/// frame.render_stateful_widget(list, area, &mut state);
-/// # }
-/// ```
-///
-/// [`List`]: crate::widgets::List
-#[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct ListState {
-    pub(crate) offset: usize,
-    pub(crate) selected: Option<usize>,
-}
-
-impl ListState {
-    /// Sets the index of the first item to be displayed
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let state = ListState::default().with_offset(1);
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub const fn with_offset(mut self, offset: usize) -> Self {
-        self.offset = offset;
-        self
-    }
-
-    /// Sets the index of the selected item
-    ///
-    /// This is a fluent setter method which must be chained or used as it consumes self
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let state = ListState::default().with_selected(Some(1));
-    /// ```
-    #[must_use = "method moves the value of self and returns the modified value"]
-    pub const fn with_selected(mut self, selected: Option<usize>) -> Self {
-        self.selected = selected;
-        self
-    }
-
-    /// Index of the first item to be displayed
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let state = ListState::default();
-    /// assert_eq!(state.offset(), 0);
-    /// ```
-    pub const fn offset(&self) -> usize {
-        self.offset
-    }
-
-    /// Mutable reference to the index of the first item to be displayed
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = ListState::default();
-    /// *state.offset_mut() = 1;
-    /// ```
-    pub fn offset_mut(&mut self) -> &mut usize {
-        &mut self.offset
-    }
-
-    /// Index of the selected item
-    ///
-    /// Returns `None` if no item is selected
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let state = TableState::default();
-    /// assert_eq!(state.selected(), None);
-    /// ```
-    pub const fn selected(&self) -> Option<usize> {
-        self.selected
-    }
-
-    /// Mutable reference to the index of the selected item
-    ///
-    /// Returns `None` if no item is selected
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = ListState::default();
-    /// *state.selected_mut() = Some(1);
-    /// ```
-    pub fn selected_mut(&mut self) -> &mut Option<usize> {
-        &mut self.selected
-    }
-
-    /// Sets the index of the selected item
-    ///
-    /// Set to `None` if no item is selected. This will also reset the offset to `0`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = ListState::default();
-    /// state.select(Some(1));
-    /// ```
-    pub fn select(&mut self, index: Option<usize>) {
-        self.selected = index;
-        if index.is_none() {
-            self.offset = 0;
-        }
-    }
-
-    /// Selects the next item or the first one if no item is selected
-    ///
-    /// Note: until the list is rendered, the number of items is not known, so the index is set to
-    /// `0` and will be corrected when the list is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = ListState::default();
-    /// state.select_next();
-    /// ```
-    pub fn select_next(&mut self) {
-        let next = self.selected.map_or(0, |i| i.saturating_add(1));
-        self.select(Some(next));
-    }
-
-    /// Selects the previous item or the last one if no item is selected
-    ///
-    /// Note: until the list is rendered, the number of items is not known, so the index is set to
-    /// `usize::MAX` and will be corrected when the list is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = ListState::default();
-    /// state.select_previous();
-    /// ```
-    pub fn select_previous(&mut self) {
-        let previous = self.selected.map_or(usize::MAX, |i| i.saturating_sub(1));
-        self.select(Some(previous));
-    }
-
-    /// Selects the first item
-    ///
-    /// Note: until the list is rendered, the number of items is not known, so the index is set to
-    /// `0` and will be corrected when the list is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = ListState::default();
-    /// state.select_first();
-    /// ```
-    pub fn select_first(&mut self) {
-        self.select(Some(0));
-    }
-
-    /// Selects the last item
-    ///
-    /// Note: until the list is rendered, the number of items is not known, so the index is set to
-    /// `usize::MAX` and will be corrected when the list is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = ListState::default();
-    /// state.select_last();
-    /// ```
-    pub fn select_last(&mut self) {
-        self.select(Some(usize::MAX));
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use pretty_assertions::assert_eq;
-
-    use crate::widgets::ListState;
-
-    #[test]
-    fn selected() {
-        let mut state = ListState::default();
-        assert_eq!(state.selected(), None);
-
-        state.select(Some(1));
-        assert_eq!(state.selected(), Some(1));
-
-        state.select(None);
-        assert_eq!(state.selected(), None);
-    }
-
-    #[test]
-    fn select() {
-        let mut state = ListState::default();
-        assert_eq!(state.selected, None);
-        assert_eq!(state.offset, 0);
-
-        state.select(Some(2));
-        assert_eq!(state.selected, Some(2));
-        assert_eq!(state.offset, 0);
-
-        state.select(None);
-        assert_eq!(state.selected, None);
-        assert_eq!(state.offset, 0);
-    }
-
-    #[test]
-    fn state_navigation() {
-        let mut state = ListState::default();
-        state.select_first();
-        assert_eq!(state.selected, Some(0));
-
-        state.select_previous(); // should not go below 0
-        assert_eq!(state.selected, Some(0));
-
-        state.select_next();
-        assert_eq!(state.selected, Some(1));
-
-        state.select_previous();
-        assert_eq!(state.selected, Some(0));
-
-        state.select_last();
-        assert_eq!(state.selected, Some(usize::MAX));
-
-        state.select_next(); // should not go above usize::MAX
-        assert_eq!(state.selected, Some(usize::MAX));
-
-        state.select_previous();
-        assert_eq!(state.selected, Some(usize::MAX - 1));
-
-        state.select_next();
-        assert_eq!(state.selected, Some(usize::MAX));
-
-        let mut state = ListState::default();
-        state.select_next();
-        assert_eq!(state.selected, Some(0));
-
-        let mut state = ListState::default();
-        state.select_previous();
-        assert_eq!(state.selected, Some(usize::MAX));
-    }
-}

src/widgets/paragraph.rs

@@ -20,42 +20,6 @@ const fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Align
 
 /// A widget to display some text.
 ///
-/// It is used to display a block of text. The text can be styled and aligned. It can also be
-/// wrapped to the next line if it is too long to fit in the given area.
-///
-/// The text can be any type that can be converted into a [`Text`]. By default, the text is styled
-/// with [`Style::default()`], not wrapped, and aligned to the left.
-///
-/// The text can be wrapped to the next line if it is too long to fit in the given area. The
-/// wrapping can be configured with the [`wrap`] method. For more complex wrapping, consider using
-/// the [Textwrap crate].
-///
-/// The text can be aligned to the left, right, or center. The alignment can be configured with the
-/// [`alignment`] method or with the [`left_aligned`], [`right_aligned`], and [`centered`] methods.
-///
-/// The text can be scrolled to show a specific part of the text. The scroll offset can be set with
-/// the [`scroll`] method.
-///
-/// The text can be surrounded by a [`Block`] with a title and borders. The block can be configured
-/// with the [`block`] method.
-///
-/// The style of the text can be set with the [`style`] method. This style will be applied to the
-/// entire widget, including the block if one is present. Any style set on the block or text will be
-/// added to this style. See the [`Style`] type for more information on how styles are combined.
-///
-/// Note: If neither wrapping or a block is needed, consider rendering the [`Text`], [`Line`], or
-/// [`Span`] widgets directly.
-///
-/// [Textwrap crate]: https://crates.io/crates/textwrap
-/// [`wrap`]: Self::wrap
-/// [`alignment`]: Self::alignment
-/// [`left_aligned`]: Self::left_aligned
-/// [`right_aligned`]: Self::right_aligned
-/// [`centered`]: Self::centered
-/// [`scroll`]: Self::scroll
-/// [`block`]: Self::block
-/// [`style`]: Self::style
-///
 /// # Example
 ///
 /// ```
@@ -295,8 +259,6 @@ impl<'a> Paragraph<'a> {
     /// need in order to be fully rendered. For paragraphs that do not use wrapping, this count is
     /// simply the number of lines present in the paragraph.
     ///
-    /// This method will also account for the [`Block`] if one is set through [`Self::block`].
-    ///
     /// Note: The design for text wrapping is not stable and might affect this API.
     ///
     /// # Example
@@ -308,7 +270,7 @@ impl<'a> Paragraph<'a> {
     /// assert_eq!(paragraph.line_count(20), 1);
     /// assert_eq!(paragraph.line_count(10), 2);
     /// ```
-    #[instability::unstable(
+    #[stability::unstable(
         feature = "rendered-line-info",
         issue = "https://github.com/ratatui-org/ratatui/issues/293"
     )]
@@ -317,13 +279,7 @@ impl<'a> Paragraph<'a> {
             return 0;
         }
 
-        let (top, bottom) = self
-            .block
-            .as_ref()
-            .map(Block::vertical_space)
-            .unwrap_or_default();
-
-        let count = if let Some(Wrap { trim }) = self.wrap {
+        if let Some(Wrap { trim }) = self.wrap {
             let styled = self.text.iter().map(|line| {
                 let graphemes = line
                     .spans
@@ -340,17 +296,11 @@ impl<'a> Paragraph<'a> {
             count
         } else {
             self.text.height()
-        };
-
-        count
-            .saturating_add(top as usize)
-            .saturating_add(bottom as usize)
+        }
     }
 
     /// Calculates the shortest line width needed to avoid any word being wrapped or truncated.
     ///
-    /// Accounts for the [`Block`] if a block is set through [`Self::block`].
-    ///
     /// Note: The design for text wrapping is not stable and might affect this API.
     ///
     /// # Example
@@ -363,21 +313,12 @@ impl<'a> Paragraph<'a> {
     /// let paragraph = Paragraph::new("Hello World\nhi\nHello World!!!");
     /// assert_eq!(paragraph.line_width(), 14);
     /// ```
-    #[instability::unstable(
+    #[stability::unstable(
         feature = "rendered-line-info",
         issue = "https://github.com/ratatui-org/ratatui/issues/293"
     )]
     pub fn line_width(&self) -> usize {
-        let width = self.text.iter().map(Line::width).max().unwrap_or_default();
-        let (left, right) = self
-            .block
-            .as_ref()
-            .map(Block::horizontal_space)
-            .unwrap_or_default();
-
-        width
-            .saturating_add(left as usize)
-            .saturating_add(right as usize)
+        self.text.iter().map(Line::width).max().unwrap_or_default()
     }
 }
 
@@ -1006,69 +947,6 @@ mod test {
         assert_eq!(paragraph.line_count(6), 200);
     }
 
-    #[test]
-    fn widgets_paragraph_rendered_line_count_accounts_block() {
-        let block = Block::new();
-        let paragraph = Paragraph::new("Hello World").block(block);
-        assert_eq!(paragraph.line_count(20), 1);
-        assert_eq!(paragraph.line_count(10), 1);
-
-        let block = Block::new().borders(Borders::TOP);
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(20), 2);
-        assert_eq!(paragraph.line_count(10), 2);
-
-        let block = Block::new().borders(Borders::BOTTOM);
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(20), 2);
-        assert_eq!(paragraph.line_count(10), 2);
-
-        let block = Block::new().borders(Borders::TOP | Borders::BOTTOM);
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(20), 3);
-        assert_eq!(paragraph.line_count(10), 3);
-
-        let block = Block::bordered();
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(20), 3);
-        assert_eq!(paragraph.line_count(10), 3);
-
-        let block = Block::bordered();
-        let paragraph = paragraph.block(block).wrap(Wrap { trim: true });
-        assert_eq!(paragraph.line_count(20), 3);
-        assert_eq!(paragraph.line_count(10), 4);
-
-        let block = Block::bordered();
-        let paragraph = paragraph.block(block).wrap(Wrap { trim: false });
-        assert_eq!(paragraph.line_count(20), 3);
-        assert_eq!(paragraph.line_count(10), 4);
-
-        let text = "Hello World ".repeat(100);
-        let block = Block::new();
-        let paragraph = Paragraph::new(text.trim()).block(block);
-        assert_eq!(paragraph.line_count(11), 1);
-
-        let block = Block::bordered();
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(11), 3);
-        assert_eq!(paragraph.line_count(6), 3);
-
-        let block = Block::new().borders(Borders::TOP);
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(11), 2);
-        assert_eq!(paragraph.line_count(6), 2);
-
-        let block = Block::new().borders(Borders::BOTTOM);
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(11), 2);
-        assert_eq!(paragraph.line_count(6), 2);
-
-        let block = Block::new().borders(Borders::LEFT | Borders::RIGHT);
-        let paragraph = paragraph.block(block);
-        assert_eq!(paragraph.line_count(11), 1);
-        assert_eq!(paragraph.line_count(6), 1);
-    }
-
     #[test]
     fn widgets_paragraph_line_width() {
         let paragraph = Paragraph::new("Hello World");
@@ -1087,29 +965,6 @@ mod test {
         assert_eq!(paragraph.line_width(), 1200);
     }
 
-    #[test]
-    fn widgets_paragraph_line_width_accounts_for_block() {
-        let block = Block::bordered();
-        let paragraph = Paragraph::new("Hello World").block(block);
-        assert_eq!(paragraph.line_width(), 13);
-
-        let block = Block::new().borders(Borders::LEFT);
-        let paragraph = Paragraph::new("Hello World").block(block);
-        assert_eq!(paragraph.line_width(), 12);
-
-        let block = Block::new().borders(Borders::LEFT);
-        let paragraph = Paragraph::new("Hello World")
-            .block(block)
-            .wrap(Wrap { trim: true });
-        assert_eq!(paragraph.line_width(), 12);
-
-        let block = Block::new().borders(Borders::LEFT);
-        let paragraph = Paragraph::new("Hello World")
-            .block(block)
-            .wrap(Wrap { trim: false });
-        assert_eq!(paragraph.line_width(), 12);
-    }
-
     #[test]
     fn left_aligned() {
         let p = Paragraph::new("Hello, world!").left_aligned();

src/widgets/reflow.rs

@@ -5,6 +5,9 @@ use unicode_width::UnicodeWidthStr;
 
 use crate::{layout::Alignment, text::StyledGrapheme};
 
+const NBSP: &str = "\u{00a0}";
+const ZWSP: &str = "\u{200b}";
+
 /// A state machine to pack styled symbols into lines.
 /// Cannot implement it as Iterator since it yields slices of the internal buffer (need streaming
 /// iterators for that).
@@ -56,124 +59,6 @@ where
             trim,
         }
     }
-
-    fn next_cached_line(&mut self) -> Option<Vec<StyledGrapheme<'a>>> {
-        self.wrapped_lines.as_mut()?.next()
-    }
-
-    /// Split an input line (`line_symbols`) into wrapped lines
-    /// and cache them to be emitted later
-    fn process_input(&mut self, line_symbols: impl IntoIterator<Item = StyledGrapheme<'a>>) {
-        let mut result_lines = vec![];
-        let mut pending_line = vec![];
-        let mut line_width = 0;
-        let mut pending_word = vec![];
-        let mut word_width = 0;
-        let mut pending_whitespace: VecDeque<StyledGrapheme> = VecDeque::new();
-        let mut whitespace_width = 0;
-        let mut non_whitespace_previous = false;
-
-        for grapheme in line_symbols {
-            let is_whitespace = grapheme.is_whitespace();
-            let symbol_width = grapheme.symbol.width() as u16;
-
-            // ignore symbols wider than line limit
-            if symbol_width > self.max_line_width {
-                continue;
-            }
-
-            let word_found = non_whitespace_previous && is_whitespace;
-            // current word would overflow after removing whitespace
-            let trimmed_overflow = pending_line.is_empty()
-                && self.trim
-                && word_width + symbol_width > self.max_line_width;
-            // separated whitespace would overflow on its own
-            let whitespace_overflow = pending_line.is_empty()
-                && self.trim
-                && whitespace_width + symbol_width > self.max_line_width;
-            // current full word (including whitespace) would overflow
-            let untrimmed_overflow = pending_line.is_empty()
-                && !self.trim
-                && word_width + whitespace_width + symbol_width > self.max_line_width;
-
-            // append finished segment to current line
-            if word_found || trimmed_overflow || whitespace_overflow || untrimmed_overflow {
-                if !pending_line.is_empty() || !self.trim {
-                    pending_line.extend(pending_whitespace.drain(..));
-                    line_width += whitespace_width;
-                }
-
-                pending_line.append(&mut pending_word);
-                line_width += word_width;
-
-                pending_whitespace.clear();
-                whitespace_width = 0;
-                word_width = 0;
-            }
-
-            // pending line fills up limit
-            let line_full = line_width >= self.max_line_width;
-            // pending word would overflow line limit
-            let pending_word_overflow = symbol_width > 0
-                && line_width + whitespace_width + word_width >= self.max_line_width;
-
-            // add finished wrapped line to remaining lines
-            if line_full || pending_word_overflow {
-                let mut remaining_width = u16::saturating_sub(self.max_line_width, line_width);
-
-                result_lines.push(std::mem::take(&mut pending_line));
-                line_width = 0;
-
-                // remove whitespace up to the end of line
-                while let Some(grapheme) = pending_whitespace.front() {
-                    let width = grapheme.symbol.width() as u16;
-
-                    if width > remaining_width {
-                        break;
-                    }
-
-                    whitespace_width -= width;
-                    remaining_width -= width;
-                    pending_whitespace.pop_front();
-                }
-
-                // don't count first whitespace toward next word
-                if is_whitespace && pending_whitespace.is_empty() {
-                    continue;
-                }
-            }
-
-            // append symbol to a pending buffer
-            if is_whitespace {
-                whitespace_width += symbol_width;
-                pending_whitespace.push_back(grapheme);
-            } else {
-                word_width += symbol_width;
-                pending_word.push(grapheme);
-            }
-
-            non_whitespace_previous = !is_whitespace;
-        }
-
-        // append remaining text parts
-        if pending_line.is_empty() && pending_word.is_empty() && !pending_whitespace.is_empty() {
-            result_lines.push(vec![]);
-        }
-        if !pending_line.is_empty() || !self.trim {
-            pending_line.extend(pending_whitespace);
-        }
-        pending_line.extend(pending_word);
-
-        if !pending_line.is_empty() {
-            result_lines.push(pending_line);
-        }
-        if result_lines.is_empty() {
-            result_lines.push(vec![]);
-        }
-
-        // save processed lines for emitting later
-        self.wrapped_lines = Some(result_lines.into_iter());
-    }
 }
 
 impl<'a, O, I> LineComposer<'a> for WordWrapper<'a, O, I>
@@ -187,26 +72,155 @@ where
             return None;
         }
 
-        loop {
-            // emit next cached line if present
-            if let Some(line) = self.next_cached_line() {
-                let line_width = line
-                    .iter()
-                    .map(|grapheme| grapheme.symbol.width() as u16)
-                    .sum();
+        let mut current_line: Option<Vec<StyledGrapheme<'a>>> = None;
+        let mut line_width: u16 = 0;
 
-                self.current_line = line;
-                return Some(WrappedLine {
-                    line: &self.current_line,
-                    width: line_width,
-                    alignment: self.current_alignment,
-                });
+        // Try to repeatedly retrieve next line
+        while current_line.is_none() {
+            // Retrieve next preprocessed wrapped line
+            if let Some(line_iterator) = &mut self.wrapped_lines {
+                if let Some(line) = line_iterator.next() {
+                    line_width = line
+                        .iter()
+                        .map(|grapheme| grapheme.symbol.width())
+                        .sum::<usize>() as u16;
+                    current_line = Some(line);
+                }
             }
 
-            // otherwise, process pending wrapped lines from input
-            let (line_symbols, line_alignment) = self.input_lines.next()?;
-            self.current_alignment = line_alignment;
-            self.process_input(line_symbols);
+            // When no more preprocessed wrapped lines
+            if current_line.is_none() {
+                // Try to calculate next wrapped lines based on current whole line
+                if let Some((line_symbols, line_alignment)) = &mut self.input_lines.next() {
+                    // Save the whole line's alignment
+                    self.current_alignment = *line_alignment;
+                    let mut wrapped_lines = vec![]; // Saves the wrapped lines
+                                                    // Saves the unfinished wrapped line
+                    let (mut current_line, mut current_line_width) = (vec![], 0);
+                    // Saves the partially processed word
+                    let (mut unfinished_word, mut word_width) = (vec![], 0);
+                    // Saves the whitespaces of the partially unfinished word
+                    let (mut unfinished_whitespaces, mut whitespace_width) =
+                        (VecDeque::<StyledGrapheme>::new(), 0);
+
+                    let mut has_seen_non_whitespace = false;
+                    for StyledGrapheme { symbol, style } in line_symbols {
+                        let symbol_whitespace = symbol == ZWSP
+                            || (symbol.chars().all(&char::is_whitespace) && symbol != NBSP);
+                        let symbol_width = symbol.width() as u16;
+                        // Ignore characters wider than the total max width
+                        if symbol_width > self.max_line_width {
+                            continue;
+                        }
+
+                        // Append finished word to current line
+                        if has_seen_non_whitespace && symbol_whitespace
+                            // Append if trimmed (whitespaces removed) word would overflow
+                            || word_width + symbol_width > self.max_line_width && current_line.is_empty() && self.trim
+                            // Append if removed whitespace would overflow -> reset whitespace counting to prevent overflow
+                            || whitespace_width + symbol_width > self.max_line_width && current_line.is_empty() && self.trim
+                            // Append if complete word would overflow
+                            || word_width + whitespace_width + symbol_width > self.max_line_width && current_line.is_empty() && !self.trim
+                        {
+                            if !current_line.is_empty() || !self.trim {
+                                // Also append whitespaces if not trimming or current line is not
+                                // empty
+                                current_line.extend(
+                                    std::mem::take(&mut unfinished_whitespaces).into_iter(),
+                                );
+                                current_line_width += whitespace_width;
+                            }
+                            // Append trimmed word
+                            current_line.append(&mut unfinished_word);
+                            current_line_width += word_width;
+
+                            // Clear whitespace buffer
+                            unfinished_whitespaces.clear();
+                            whitespace_width = 0;
+                            word_width = 0;
+                        }
+
+                        // Append the unfinished wrapped line to wrapped lines if it is as wide as
+                        // max line width
+                        if current_line_width >= self.max_line_width
+                            // or if it would be too long with the current partially processed word added
+                            || current_line_width + whitespace_width + word_width >= self.max_line_width && symbol_width > 0
+                        {
+                            let mut remaining_width = (i32::from(self.max_line_width)
+                                - i32::from(current_line_width))
+                            .max(0) as u16;
+                            wrapped_lines.push(std::mem::take(&mut current_line));
+                            current_line_width = 0;
+
+                            // Remove all whitespaces till end of just appended wrapped line + next
+                            // whitespace
+                            let mut first_whitespace = unfinished_whitespaces.pop_front();
+                            while let Some(grapheme) = first_whitespace.as_ref() {
+                                let symbol_width = grapheme.symbol.width() as u16;
+                                whitespace_width -= symbol_width;
+
+                                if symbol_width > remaining_width {
+                                    break;
+                                }
+                                remaining_width -= symbol_width;
+                                first_whitespace = unfinished_whitespaces.pop_front();
+                            }
+                            // In case all whitespaces have been exhausted
+                            if symbol_whitespace && first_whitespace.is_none() {
+                                // Prevent first whitespace to count towards next word
+                                continue;
+                            }
+                        }
+
+                        // Append symbol to unfinished, partially processed word
+                        if symbol_whitespace {
+                            whitespace_width += symbol_width;
+                            unfinished_whitespaces.push_back(StyledGrapheme { symbol, style });
+                        } else {
+                            word_width += symbol_width;
+                            unfinished_word.push(StyledGrapheme { symbol, style });
+                        }
+
+                        has_seen_non_whitespace = !symbol_whitespace;
+                    }
+
+                    // Append remaining text parts
+                    if !unfinished_word.is_empty() || !unfinished_whitespaces.is_empty() {
+                        if current_line.is_empty() && unfinished_word.is_empty() {
+                            wrapped_lines.push(vec![]);
+                        } else if !self.trim || !current_line.is_empty() {
+                            current_line.extend(unfinished_whitespaces.into_iter());
+                        } else {
+                            // TODO: explain why this else branch is ok.
+                            // See clippy::else_if_without_else
+                        }
+                        current_line.append(&mut unfinished_word);
+                    }
+                    if !current_line.is_empty() {
+                        wrapped_lines.push(current_line);
+                    }
+                    if wrapped_lines.is_empty() {
+                        // Append empty line if there was nothing to wrap in the first place
+                        wrapped_lines.push(vec![]);
+                    }
+
+                    self.wrapped_lines = Some(wrapped_lines.into_iter());
+                } else {
+                    // No more whole lines available -> stop repeatedly retrieving next wrapped line
+                    break;
+                }
+            }
+        }
+
+        if let Some(line) = current_line {
+            self.current_line = line;
+            Some(WrappedLine {
+                line: &self.current_line,
+                width: line_width,
+                alignment: self.current_alignment,
+            })
+        } else {
+            None
         }
     }
 }

src/widgets/table.rs

@@ -1,6 +1,7 @@
 mod cell;
 mod highlight_spacing;
 mod row;
+#[allow(clippy::module_inception)]
 mod table;
 mod table_state;
 

src/widgets/table/cell.rs

@@ -134,7 +134,7 @@ impl<'a> Cell<'a> {
 impl Cell<'_> {
     pub(crate) fn render(&self, area: Rect, buf: &mut Buffer) {
         buf.set_style(area, self.style);
-        self.content.render_ref(area, buf);
+        self.content.clone().render(area, buf);
     }
 }
 

src/widgets/table/table.rs

@@ -20,9 +20,7 @@ use crate::{layout::Flex, prelude::*, style::Styled, widgets::Block};
 /// [`Table`] implements [`Widget`] and so it can be drawn using [`Frame::render_widget`].
 ///
 /// [`Table`] is also a [`StatefulWidget`], which means you can use it with [`TableState`] to allow
-/// the user to scroll through the rows and select one of them. When rendering a [`Table`] with a
-/// [`TableState`], the selected row will be highlighted. If the selected row is not visible (based
-/// on the offset), the table will be scrolled to make the selected row visible.
+/// the user to scroll through the rows and select one of them.
 ///
 /// Note: if the `widths` field is empty, the table will be rendered with equal widths.
 ///
@@ -598,14 +596,14 @@ impl StatefulWidget for Table<'_> {
 impl StatefulWidget for &Table<'_> {
     type State = TableState;
     fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-        StatefulWidgetRef::render_ref(self, area, buf, state);
+        self.render_stateful_ref(area, buf, state);
     }
 }
 
 impl StatefulWidgetRef for Table<'_> {
     type State = TableState;
 
-    fn render_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+    fn render_stateful_ref(&self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
         buf.set_style(area, self.style);
         self.block.render_ref(area, buf);
         let table_area = self.block.inner_if_some(area);
@@ -613,14 +611,6 @@ impl StatefulWidgetRef for Table<'_> {
             return;
         }
 
-        if state.selected.is_some_and(|s| s >= self.rows.len()) {
-            state.select(Some(self.rows.len().saturating_sub(1)));
-        }
-
-        if self.rows.is_empty() {
-            state.select(None);
-        }
-
         let selection_width = self.selection_width(state);
         let columns_widths = self.get_columns_widths(table_area.width, selection_width);
         let (header_area, rows_area, footer_area) = self.layout(table_area);
@@ -722,7 +712,7 @@ impl Table<'_> {
                     ..row_area
                 };
                 buf.set_style(selection_area, row.style);
-                highlight_symbol.render_ref(selection_area, buf);
+                highlight_symbol.clone().render(selection_area, buf);
             };
             for ((x, width), cell) in columns_widths.iter().zip(row.cells.iter()) {
                 cell.render(
@@ -785,14 +775,7 @@ impl Table<'_> {
             end += 1;
         }
 
-        let Some(selected) = selected else {
-            return (start, end);
-        };
-
-        // clamp the selected row to the last row
-        let selected = selected.min(self.rows.len() - 1);
-
-        // scroll down until the selected row is visible
+        let selected = selected.unwrap_or(0).min(self.rows.len() - 1);
         while selected >= end {
             height = height.saturating_add(self.rows[end].height_with_margin());
             end += 1;
@@ -801,8 +784,6 @@ impl Table<'_> {
                 start += 1;
             }
         }
-
-        // scroll up until the selected row is visible
         while selected < start {
             start -= 1;
             height = height.saturating_add(self.rows[start].height_with_margin());
@@ -927,8 +908,6 @@ mod tests {
         let table = Table::default().widths([Constraint::Length(100)]);
         assert_eq!(table.widths, [Constraint::Length(100)]);
 
-        // ensure that code that uses &[] continues to work as there is a large amount of code that
-        // uses this pattern
         #[allow(clippy::needless_borrows_for_generic_args)]
         let table = Table::default().widths(&[Constraint::Length(100)]);
         assert_eq!(table.widths, [Constraint::Length(100)]);
@@ -936,9 +915,6 @@ mod tests {
         let table = Table::default().widths(vec![Constraint::Length(100)]);
         assert_eq!(table.widths, [Constraint::Length(100)]);
 
-        // ensure that code that uses &some_vec continues to work as there is a large amount of code
-        // that uses this pattern
-        #[allow(clippy::needless_borrows_for_generic_args)]
         let table = Table::default().widths(&vec![Constraint::Length(100)]);
         assert_eq!(table.widths, [Constraint::Length(100)]);
 
@@ -1029,64 +1005,8 @@ mod tests {
         assert_eq!(table.widths, vec![Constraint::Percentage(100)], "vec ref");
     }
 
-    #[cfg(test)]
-    mod state {
-        use rstest::{fixture, rstest};
-
-        use super::TableState;
-        use crate::{
-            buffer::Buffer,
-            layout::{Constraint, Rect},
-            widgets::{Row, StatefulWidget, Table},
-        };
-
-        #[fixture]
-        fn table_buf() -> Buffer {
-            Buffer::empty(Rect::new(0, 0, 10, 10))
-        }
-
-        #[rstest]
-        fn test_list_state_empty_list(mut table_buf: Buffer) {
-            let mut state = TableState::default();
-
-            let rows: Vec<Row> = Vec::new();
-            let widths = vec![Constraint::Percentage(100)];
-            let table = Table::new(rows, widths);
-            state.select_first();
-            StatefulWidget::render(table, table_buf.area, &mut table_buf, &mut state);
-            assert_eq!(state.selected, None);
-        }
-
-        #[rstest]
-        fn test_list_state_single_item(mut table_buf: Buffer) {
-            let mut state = TableState::default();
-
-            let widths = vec![Constraint::Percentage(100)];
-
-            let items = vec![Row::new(vec!["Item 1"])];
-            let table = Table::new(items, widths);
-            state.select_first();
-            StatefulWidget::render(&table, table_buf.area, &mut table_buf, &mut state);
-            assert_eq!(state.selected, Some(0));
-
-            state.select_last();
-            StatefulWidget::render(&table, table_buf.area, &mut table_buf, &mut state);
-            assert_eq!(state.selected, Some(0));
-
-            state.select_previous();
-            StatefulWidget::render(&table, table_buf.area, &mut table_buf, &mut state);
-            assert_eq!(state.selected, Some(0));
-
-            state.select_next();
-            StatefulWidget::render(&table, table_buf.area, &mut table_buf, &mut state);
-            assert_eq!(state.selected, Some(0));
-        }
-    }
-
     #[cfg(test)]
     mod render {
-        use rstest::rstest;
-
         use super::*;
 
         #[test]
@@ -1277,36 +1197,6 @@ mod tests {
             ]);
             assert_eq!(buf, expected);
         }
-
-        /// Note that this includes a regression test for a bug where the table would not render the
-        /// correct rows when there is no selection.
-        /// <https://github.com/ratatui-org/ratatui/issues/1179>
-        #[rstest]
-        #[case::no_selection(None, 50, ["50", "51", "52", "53", "54"])]
-        #[case::selection_before_offset(20, 20, ["20", "21", "22", "23", "24"])]
-        #[case::selection_immediately_before_offset(49, 49, ["49", "50", "51", "52", "53"])]
-        #[case::selection_at_start_of_offset(50, 50, ["50", "51", "52", "53", "54"])]
-        #[case::selection_at_end_of_offset(54, 50, ["50", "51", "52", "53", "54"])]
-        #[case::selection_immediately_after_offset(55, 51, ["51", "52", "53", "54", "55"])]
-        #[case::selection_after_offset(80, 76, ["76", "77", "78", "79", "80"])]
-        fn render_with_selection_and_offset<T: Into<Option<usize>>>(
-            #[case] selected_row: T,
-            #[case] expected_offset: usize,
-            #[case] expected_items: [&str; 5],
-        ) {
-            // render 100 rows offset at 50, with a selected row
-            let rows = (0..100).map(|i| Row::new([i.to_string()]));
-            let table = Table::new(rows, [Constraint::Length(2)]);
-            let mut buf = Buffer::empty(Rect::new(0, 0, 2, 5));
-            let mut state = TableState::new()
-                .with_offset(50)
-                .with_selected(selected_row);
-
-            StatefulWidget::render(table.clone(), Rect::new(0, 0, 5, 5), &mut buf, &mut state);
-
-            assert_eq!(buf, Buffer::with_lines(expected_items));
-            assert_eq!(state.offset, expected_offset);
-        }
     }
 
     // test how constraints interact with table column width allocation

src/widgets/table/table_state.rs

@@ -175,72 +175,6 @@ impl TableState {
             self.offset = 0;
         }
     }
-
-    /// Selects the next item or the first one if no item is selected
-    ///
-    /// Note: until the table is rendered, the number of items is not known, so the index is set to
-    /// `0` and will be corrected when the table is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = TableState::default();
-    /// state.select_next();
-    /// ```
-    pub fn select_next(&mut self) {
-        let next = self.selected.map_or(0, |i| i.saturating_add(1));
-        self.select(Some(next));
-    }
-
-    /// Selects the previous item or the last one if no item is selected
-    ///
-    /// Note: until the table is rendered, the number of items is not known, so the index is set to
-    /// `usize::MAX` and will be corrected when the table is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = TableState::default();
-    /// state.select_previous();
-    /// ```
-    pub fn select_previous(&mut self) {
-        let previous = self.selected.map_or(usize::MAX, |i| i.saturating_sub(1));
-        self.select(Some(previous));
-    }
-
-    /// Selects the first item
-    ///
-    /// Note: until the table is rendered, the number of items is not known, so the index is set to
-    /// `0` and will be corrected when the table is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = TableState::default();
-    /// state.select_first();
-    /// ```
-    pub fn select_first(&mut self) {
-        self.select(Some(0));
-    }
-
-    /// Selects the last item
-    ///
-    /// Note: until the table is rendered, the number of items is not known, so the index is set to
-    /// `usize::MAX` and will be corrected when the table is rendered
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ratatui::{prelude::*, widgets::*};
-    /// let mut state = TableState::default();
-    /// state.select_last();
-    /// ```
-    pub fn select_last(&mut self) {
-        self.select(Some(usize::MAX));
-    }
 }
 
 #[cfg(test)]
@@ -305,40 +239,4 @@ mod tests {
         state.select(None);
         assert_eq!(state.selected, None);
     }
-
-    #[test]
-    fn test_table_state_navigation() {
-        let mut state = TableState::default();
-        state.select_first();
-        assert_eq!(state.selected, Some(0));
-
-        state.select_previous(); // should not go below 0
-        assert_eq!(state.selected, Some(0));
-
-        state.select_next();
-        assert_eq!(state.selected, Some(1));
-
-        state.select_previous();
-        assert_eq!(state.selected, Some(0));
-
-        state.select_last();
-        assert_eq!(state.selected, Some(usize::MAX));
-
-        state.select_next(); // should not go above usize::MAX
-        assert_eq!(state.selected, Some(usize::MAX));
-
-        state.select_previous();
-        assert_eq!(state.selected, Some(usize::MAX - 1));
-
-        state.select_next();
-        assert_eq!(state.selected, Some(usize::MAX));
-
-        let mut state = TableState::default();
-        state.select_next();
-        assert_eq!(state.selected, Some(0));
-
-        let mut state = TableState::default();
-        state.select_previous();
-        assert_eq!(state.selected, Some(usize::MAX));
-    }
 }

tests/widgets_list.rs

@@ -186,7 +186,7 @@ fn widgets_list_should_clamp_offset_if_items_are_removed() {
         })
         .unwrap();
     terminal.backend().assert_buffer_lines([
-        ">> Item 3 ",
+        "   Item 3 ",
         "          ",
         "          ",
         "          ",