From 50af9a5d80ed5446f3e6cc554911f606580edde9 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 14:34:40 -0500 Subject: [PATCH 001/109] =?UTF-8?q?new:=20Initial=20commit=20=F0=9F=8E=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 1 + Cargo.toml | 10 +++ LICENSE | 19 ++++++ src/lib.rs | 168 ++++++++++++++++++++++++++++++++++++++++++++++++ tests/macros.rs | 62 ++++++++++++++++++ 5 files changed, 260 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.toml create mode 100644 LICENSE create mode 100644 src/lib.rs create mode 100644 tests/macros.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..ea8c4bf7 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/target diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 00000000..58d89788 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "ratatui-macros" +version = "0.1.0" +edition = "2021" +authors = ["Dheepak Krishnamurthy"] + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +ratatui = "0.25.0" diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..8c544594 --- /dev/null +++ b/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2024 Dheepak Krishnamurthy + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 00000000..4bc5f649 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,168 @@ +/// This macro creates an iterator of constraints. +/// +/// # Syntax +/// +/// The macro supports the following form: +/// - `constraints!([$( $constraint:tt )+])` +/// +/// Constraints are defined using a specific syntax: +/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. +/// - `== $token:tt %`: Sets a percentage constraint for the token. +/// - `>= $token:tt`: Sets a minimum size constraint for the token. +/// - `<= $token:tt`: Sets a maximum size constraint for the token. +/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// +/// # Examples +/// +/// ``` +/// use ratatui_macros::constraints; +/// constraints!([==5, ==30%, >=3, <=1, ==1/2]); +/// ``` +/// +/// # Internal Implementation +/// +/// - `@parse`: Internal rule to parse and accumulate constraints. +/// - `@process`: Internal rule to convert tokens into constraints. +/// +/// This macro simplifies the process of creating various constraints. +#[macro_export] +macro_rules! constraints { + // Entry rule for constraints + // e.g. `[ ==100%, >=1, >=1 ]` + ([ $( $constraint:tt )+ ]) => { + // e.g. the tokens `==100%, >=1, >=1` are matched with @parse rules + $crate::constraints!(@parse () $($constraint)+) + }; + // Internal parsing rules for constraints + // This rule checks if `,` exists after the `head` token + // e.g. acc: `==100`; head: `%`; `,`; tail: `>=1, >=1` will match this rule + (@parse ($($acc:tt)*) $head:tt , $($tail:tt)*) => { + // Combines the head constraint with the tail constraints into a vector + std::iter::once( + // e.g. (acc head): `==100%`; this can be processed as a `Constraint` + $crate::constraints!(@process ($($acc)* $head)) // -> Constraint + ).chain( + // e.g. tail: `>=1, >=1`; this can be parsed as a `Iterator` + $crate::constraints!(@parse () $($tail)*).into_iter() // -> Iterator with type Constraint + ) + }; + // If there is no `,` then accumulate `next` token into existing `acc` tokens + // and return `Iterator` + // e.g. for tokens `==100%, >=1, >=1` + // 1. acc: `` ; next: `=` ; tail: `=100 %, >=1, >=1` ; will match this rule + // acc: `=` ; tail: `=100 %, >=1, >=1` ; is the next parse + // 2. acc: `=` ; next: `=` ; tail: `100 %, >=1, >=1` ; will match this rule again + // acc: `==` ; tail: `100 %, >=1, >=1` ; is the next parse + // 3. acc: `==` ; next: `100` ; tail: `%, >=1, >=1` ; will match this rule again + // acc: `==100` ; tail: `%, >=1, >=1` ; is the next parse + // OR acc: `==100` ; head: `%`; `,`; tail: `>=1, >=1` ; i.e. this is the match for the next parse + // ^^^ --------------------------------> this will match previous rule because of this comma + (@parse ($($acc:tt)*) $next:tt $($tail:tt)*) => { + $crate::constraints!(@parse ($($acc)* $next) $($tail)*) + }; + // At the end there will a set of tokens left after the last `,` + // Process that as a `Constraint` + (@parse ($($acc:tt)*)) => { + [$crate::constraints!(@process ($($acc)*))] + }; + // Process different types of constraints into a `Constraint` + (@process (== $token1:tt / $token2:tt)) => { + // Ratio constraint + { + let t1: u32 = $token1; + let t2: u32 = $token2; + ratatui::prelude::Constraint::Ratio(t1, t2) + } + }; + (@process (== $token:tt %)) => { + // Percentage constraint + ratatui::prelude::Constraint::Percentage($token) + }; + (@process (>= $token:expr)) => { + // Minimum size constraint + ratatui::prelude::Constraint::Min($token) + }; + (@process (<= $token:expr)) => { + // Maximum size constraint + ratatui::prelude::Constraint::Max($token) + }; + (@process (== $token:expr)) => { + // Fixed size constraint + ratatui::prelude::Constraint::Length($token) + }; +} + +/// This macro creates a layout with specified constraints and direction. +/// +/// # Syntax +/// +/// The macro supports three main forms: +/// - `layout!([$( $constraint:tt )+])`: Defines a default layout (vertical) with constraints. +/// - `layout!([$( $constraint:tt )+], direction = h)`: Defines a horizontal layout with +/// constraints. +/// - `layout!([$( $constraint:tt )+], direction = v)`: Defines a vertical layout with constraints. +/// +/// Constraints are defined using a specific syntax: +/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. +/// - `== $token:tt %`: Sets a percentage constraint for the token. +/// - `>= $token:tt`: Sets a minimum size constraint for the token. +/// - `<= $token:tt`: Sets a maximum size constraint for the token. +/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// +/// # Examples +/// +/// ``` +/// // Vertical layout with fixed size and percentage constraints +/// use ratatui_macros::layout; +/// layout!([== 50, == 30%]); +/// ``` +/// +/// ``` +/// // Horizontal layout with ratio and minimum size constraints +/// use ratatui_macros::layout; +/// layout!([== 1/3, >= 100, <=4], direction = h); +/// ``` +/// +/// # Internal Implementation +/// +/// - `@construct`: Internal rule to construct the final Layout with the specified direction and +/// constraints. +/// +/// This macro simplifies the process of creating complex layouts with various constraints. +#[macro_export] +macro_rules! layout { + // Default layout variant + ([ $( $constraint:tt )+ ]) => { + $crate::layout!([ $( $constraint )+ ], direction = v) + }; + // Horizontal layout variant + ([ $( $constraint:tt )+ ], direction = h) => { + // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator + $crate::layout!(@construct ratatui::prelude::Direction::Horizontal, $crate::constraints!(@parse () $($constraint)+)) + }; + // Vertical layout variant + ([ $( $constraint:tt )+ ], direction = v) => { + // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator + $crate::layout!(@construct ratatui::prelude::Direction::Vertical, $crate::constraints!(@parse () $($constraint)+)) + }; + // Construct the final `Layout` object + (@construct $direction:expr, $constraints:expr) => { + ratatui::prelude::Layout::default() + .direction($direction) + .constraints($constraints) + }; +} + +#[macro_export] +macro_rules! vertical { + ([ $( $constraint:tt )+ ]) => { + $crate::layout!([ $( $constraint )+ ], direction = v) + }; +} + +#[macro_export] +macro_rules! horizontal { + ([ $( $constraint:tt )+ ]) => { + $crate::layout!([ $( $constraint )+ ], direction = h) + }; +} diff --git a/tests/macros.rs b/tests/macros.rs new file mode 100644 index 00000000..ddd4c7e3 --- /dev/null +++ b/tests/macros.rs @@ -0,0 +1,62 @@ +use ratatui::prelude::*; +use ratatui_macros::{constraints, layout}; + +#[test] +fn layout_constraints_macro() { + let rect = Rect { x: 0, y: 0, width: 10, height: 10 }; + + let [rect1, rect2] = layout!([==7, <=3]).split(rect).to_vec().try_into().unwrap(); + assert_eq!(rect1, Rect::new(0, 0, 10, 7)); + assert_eq!(rect2, Rect::new(0, 7, 10, 3)); + + let one = 1; + let two = 2; + let ten = 10; + let zero = 0; + let [a, b, c, d, e, f] = layout!([==one, >=one, <=one, == 1 / two, == ten %, >=zero], direction = h) + .split(rect) + .to_vec() + .try_into() + .unwrap(); + + assert_eq!(a, Rect::new(0, 0, 1, 10)); + assert_eq!(b, Rect::new(1, 0, 1, 10)); + assert_eq!(c, Rect::new(2, 0, 1, 10)); + assert_eq!(d, Rect::new(3, 0, 5, 10)); + assert_eq!(e, Rect::new(8, 0, 1, 10)); + assert_eq!(f, Rect::new(9, 0, 1, 10)); + + let one = 1; + let two = 2; + let ten = 10; + let zero = 0; + let [a, b, c, d, e, f] = layout!( + [ + == one*one, // expr allowed here + >= one+zero, // expr allowed here + <= one-zero, // expr allowed here + == 1/two, // only single token allowed in numerator and denominator + == ten%, // only single token allowed before % + >= zero // no trailing comma + ], + direction = h + ) + .split(rect) + .to_vec() + .try_into() + .unwrap(); + + assert_eq!(a, Rect::new(0, 0, 1, 10)); + assert_eq!(b, Rect::new(1, 0, 1, 10)); + assert_eq!(c, Rect::new(2, 0, 1, 10)); + assert_eq!(d, Rect::new(3, 0, 5, 10)); + assert_eq!(e, Rect::new(8, 0, 1, 10)); + assert_eq!(f, Rect::new(9, 0, 1, 10)); + + let [a, b, c, d, e] = constraints!([>=0, ==1, <=5, ==10%, ==1/2]).collect::>().try_into().unwrap(); + assert_eq!(a, Constraint::Min(0)); + assert_eq!(b, Constraint::Length(1)); + assert_eq!(c, Constraint::Max(5)); + assert_eq!(d, Constraint::Percentage(10)); + assert_eq!(e, Constraint::Ratio(1, 2)); +} From 272e9709c6eed45cd7e0c183624b7898f4e0ae69 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 14:51:01 -0500 Subject: [PATCH 002/109] =?UTF-8?q?feat:=20Add=20array=20style=20constrain?= =?UTF-8?q?ts=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 78 +++++++++++++++++++++++++++++++++++++++++++++---- tests/macros.rs | 23 +++++++++++++-- 2 files changed, 94 insertions(+), 7 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 4bc5f649..2bc6d362 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -17,6 +17,7 @@ /// ``` /// use ratatui_macros::constraints; /// constraints!([==5, ==30%, >=3, <=1, ==1/2]); +/// constraints!([==5; 5]); /// ``` /// /// # Internal Implementation @@ -33,6 +34,10 @@ macro_rules! constraints { // e.g. the tokens `==100%, >=1, >=1` are matched with @parse rules $crate::constraints!(@parse () $($constraint)+) }; + // Special case for `;` + (@parse ($($acc:tt)*) ; $count:expr) => { + $crate::constraints!(@process ($($acc)* ; $count)) + }; // Internal parsing rules for constraints // This rule checks if `,` exists after the `head` token // e.g. acc: `==100`; head: `%`; `,`; tail: `>=1, >=1` will match this rule @@ -74,18 +79,33 @@ macro_rules! constraints { ratatui::prelude::Constraint::Ratio(t1, t2) } }; + (@process (== $token:tt % ; $count:expr)) => { + // Percentage constraint + std::iter::repeat(ratatui::prelude::Constraint::Percentage($token)).take($count as usize) + }; (@process (== $token:tt %)) => { // Percentage constraint ratatui::prelude::Constraint::Percentage($token) }; + (@process (>= $token:expr; $count:expr)) => { + // Percentage constraint + std::iter::repeat(ratatui::prelude::Constraint::Min($token)).take($count as usize) + }; (@process (>= $token:expr)) => { // Minimum size constraint ratatui::prelude::Constraint::Min($token) }; + (@process (<= $token:expr; $count:expr)) => { + // Percentage constraint + std::iter::repeat(ratatui::prelude::Constraint::Max($token)).take($count as usize) + }; (@process (<= $token:expr)) => { // Maximum size constraint ratatui::prelude::Constraint::Max($token) }; + (@process (== $token:expr ; $count:expr)) => { + std::iter::repeat(ratatui::prelude::Constraint::Length($token)).take($count as usize) + }; (@process (== $token:expr)) => { // Fixed size constraint ratatui::prelude::Constraint::Length($token) @@ -114,7 +134,7 @@ macro_rules! constraints { /// ``` /// // Vertical layout with fixed size and percentage constraints /// use ratatui_macros::layout; -/// layout!([== 50, == 30%]); +/// layout!([== 50, == 30%], direction = v); /// ``` /// /// ``` @@ -131,10 +151,6 @@ macro_rules! constraints { /// This macro simplifies the process of creating complex layouts with various constraints. #[macro_export] macro_rules! layout { - // Default layout variant - ([ $( $constraint:tt )+ ]) => { - $crate::layout!([ $( $constraint )+ ], direction = v) - }; // Horizontal layout variant ([ $( $constraint:tt )+ ], direction = h) => { // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator @@ -153,6 +169,32 @@ macro_rules! layout { }; } +/// Creates a vertical layout with specified constraints. +/// +/// This macro is a convenience wrapper around the `layout!` macro for defining vertical layouts. +/// It accepts a series of constraints and applies them to create a vertical layout. The constraints +/// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. +/// +/// # Syntax +/// +/// - `vertical!([$( $constraint:tt )+])`: Defines a vertical layout with the given constraints. +/// +/// # Constraints +/// +/// Constraints are defined using a specific syntax: +/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. +/// - `== $token:tt %`: Sets a percentage constraint for the token. +/// - `>= $token:tt`: Sets a minimum size constraint for the token. +/// - `<= $token:tt`: Sets a maximum size constraint for the token. +/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// +/// # Examples +/// +/// ``` +/// // Vertical layout with a fixed size and a percentage constraint +/// use ratatui_macros::vertical; +/// vertical!([== 50, == 30%]); +/// ``` #[macro_export] macro_rules! vertical { ([ $( $constraint:tt )+ ]) => { @@ -160,6 +202,32 @@ macro_rules! vertical { }; } +/// Creates a horizontal layout with specified constraints. +/// +/// This macro is a convenience wrapper around the `layout!` macro for defining horizontal layouts. +/// It takes a series of constraints and applies them to create a horizontal layout. The constraints +/// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. +/// +/// # Syntax +/// +/// - `horizontal!([$( $constraint:tt )+])`: Defines a horizontal layout with the given constraints. +/// +/// # Constraints +/// +/// Constraints are defined using a specific syntax: +/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. +/// - `== $token:tt %`: Sets a percentage constraint for the token. +/// - `>= $token:tt`: Sets a minimum size constraint for the token. +/// - `<= $token:tt`: Sets a maximum size constraint for the token. +/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// +/// # Examples +/// +/// ``` +/// // Horizontal layout with a ratio constraint and a minimum size constraint +/// use ratatui_macros::horizontal; +/// horizontal!([== 1/3, >= 100]); +/// ``` #[macro_export] macro_rules! horizontal { ([ $( $constraint:tt )+ ]) => { diff --git a/tests/macros.rs b/tests/macros.rs index ddd4c7e3..74239178 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -1,14 +1,26 @@ use ratatui::prelude::*; -use ratatui_macros::{constraints, layout}; +use ratatui_macros::{constraints, horizontal, layout, vertical}; #[test] fn layout_constraints_macro() { let rect = Rect { x: 0, y: 0, width: 10, height: 10 }; - let [rect1, rect2] = layout!([==7, <=3]).split(rect).to_vec().try_into().unwrap(); + let [rect1, rect2] = layout!([==7, <=3], direction = v).split(rect).to_vec().try_into().unwrap(); assert_eq!(rect1, Rect::new(0, 0, 10, 7)); assert_eq!(rect2, Rect::new(0, 7, 10, 3)); + let [rect1, rect2] = vertical!([==7, <=3]).split(rect).to_vec().try_into().unwrap(); + assert_eq!(rect1, Rect::new(0, 0, 10, 7)); + assert_eq!(rect2, Rect::new(0, 7, 10, 3)); + + let [rect1, rect2] = layout!([==7, <=3], direction = h).split(rect).to_vec().try_into().unwrap(); + assert_eq!(rect1, Rect::new(0, 0, 7, 10)); + assert_eq!(rect2, Rect::new(7, 0, 3, 10)); + + let [rect1, rect2] = horizontal!([==7, <=3]).split(rect).to_vec().try_into().unwrap(); + assert_eq!(rect1, Rect::new(0, 0, 7, 10)); + assert_eq!(rect2, Rect::new(7, 0, 3, 10)); + let one = 1; let two = 2; let ten = 10; @@ -59,4 +71,11 @@ fn layout_constraints_macro() { assert_eq!(c, Constraint::Max(5)); assert_eq!(d, Constraint::Percentage(10)); assert_eq!(e, Constraint::Ratio(1, 2)); + + let [a, b, c, d, e] = constraints!([>=0; 5]).collect::>().try_into().unwrap(); + assert_eq!(a, Constraint::Min(0)); + assert_eq!(b, Constraint::Min(0)); + assert_eq!(c, Constraint::Min(0)); + assert_eq!(d, Constraint::Min(0)); + assert_eq!(e, Constraint::Min(0)); } From adc8fdc35aa57d6dad2ae8dd30ec2e9256576c09 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 14:58:21 -0500 Subject: [PATCH 003/109] =?UTF-8?q?docs:=20Add=20README.md=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 00000000..35c5facf --- /dev/null +++ b/README.md @@ -0,0 +1,62 @@ +# Ratatui Macros + +`ratatui_macros` is a Rust crate that provides easy-to-use macros for simplifying boilerplate +associated with creating UI using ratatui. + +## Features + +- Constraint-based Layouts: Easily define layout constraints such as fixed, percentage, minimum, and + maximum sizes, as well as ratios. +- Directional Layouts: Specify layouts as either horizontal or vertical with simple macro commands. + +## Getting Started + +To use `ratatui_macros` in your Rust project, add it as a dependency in your Cargo.toml: + +```toml +[dependencies] +ratatui_macros = "0.1.0" +``` + +Then, import the macros in your Rust file: + +```rust +use ratatui_macros::{constraints, layout, vertical, horizontal}; +``` + +Use the `constraints!` macro to define layout constraints: + +```rust +constraints!([==50, ==30%, >=3, <=1, ==1/2]); +// is equivalent to +[ + ratatui::prelude::Constraint::Length(50)), + ratatui::prelude::Constraint::Percentage(30)), + ratatui::prelude::Constraint::Min(3)), + ratatui::prelude::Constraint::Max(1)), + ratatui::prelude::Constraint::Ratio(1, 2)), +] +``` + +```rust +constraints!([==1/4; 4]); +// is equivalent to +[ + ratatui::prelude::Constraint::Ratio(1, 4)), + ratatui::prelude::Constraint::Ratio(1, 4)), + ratatui::prelude::Constraint::Ratio(1, 4)), + ratatui::prelude::Constraint::Ratio(1, 4)), +] +``` + +Create vertical and horizontal layouts using the `vertical!` and `horizontal!` macros: + +```rust +let vertical_layout = vertical!([==50, ==30%]); +let horizontal_layout = horizontal!([==1/3, >=100, <=4]); +``` + +## Contributing + +Contributions to `ratatui-macros` are welcome! Whether it's submitting a bug report, a feature +request, or a pull request, all forms of contributions are valued and appreciated. From 31711dbf82a4c7bb3b78692da34d9f469725dd6e Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 15:08:32 -0500 Subject: [PATCH 004/109] =?UTF-8?q?feat:=20Add=20ci.yml=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/ci.yml | 42 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..bab75491 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,42 @@ +name: Continuous Integration + +on: + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + push: + branches: + - main + pull_request: + branches: + - main + merge_group: + +# ensure that the workflow is only triggered once per PR, subsequent pushes to the PR will cancel +# and restart the workflow. See https://docs.github.com/en/actions/using-jobs/using-concurrency +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +env: + # don't install husky hooks during CI as they are only needed for for pre-push + CARGO_HUSKY_DONT_INSTALL_HOOKS: true + +jobs: + test: + strategy: + fail-fast: false + matrix: + os: [ ubuntu-latest, windows-latest, macos-latest ] + toolchain: [ "stable" ] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Install Rust ${{ matrix.toolchain }}} + uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ matrix.toolchain }} + - name: Test ${{ matrix.os }} + run: cargo test + env: + RUST_BACKTRACE: full From b6356aa7a529a491d63dd6628b8985adae337f16 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 15:12:12 -0500 Subject: [PATCH 005/109] =?UTF-8?q?feat:=20Add=20cd.yml=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/cd.yml | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 .github/workflows/cd.yml diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml new file mode 100644 index 00000000..556f5ba1 --- /dev/null +++ b/.github/workflows/cd.yml @@ -0,0 +1,25 @@ +name: Continuous Deployment + +on: + push: + tags: + - "v*.*.*" + +defaults: + run: + shell: bash + +jobs: + publish: + name: Create a stable release + runs-on: ubuntu-latest + if: ${{ startsWith(github.event.ref, 'refs/tags/v') }} + steps: + - name: Checkout the repository + uses: actions/checkout@v4 + + - name: Publish on crates.io + uses: actions-rs/cargo@v1 + with: + command: publish + args: --token ${{ secrets.CARGO_REGISTRY_TOKEN }} From 885558b6f89df642317d39c5b44c94c742d1e0c8 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 15:26:53 -0500 Subject: [PATCH 006/109] =?UTF-8?q?feat:=20Update=20Cargo.toml=20with=20me?= =?UTF-8?q?tadata=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 58d89788..61ad947b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,12 @@ name = "ratatui-macros" version = "0.1.0" edition = "2021" authors = ["Dheepak Krishnamurthy"] +description = "Macros for Ratatui" +license = "MIT" # or any other appropriate license +repository = "https://github.com/kdheepak/ratatui-macros" +documentation = "https://docs.rs/ratatui-macros" +keywords = ["macros", "tui", "ui", "layout", "ratatui"] +categories = ["tui", "macro"] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html From 6440eb9d76379340953420629ab0a3d9039d6c48 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 15:42:25 -0500 Subject: [PATCH 007/109] =?UTF-8?q?feat:=20Ratio=20array=20syntax=20?= =?UTF-8?q?=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 2bc6d362..759d3bf9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -70,14 +70,14 @@ macro_rules! constraints { (@parse ($($acc:tt)*)) => { [$crate::constraints!(@process ($($acc)*))] }; + (@process (== $token1:tt / token2::tt ; $count:expr)) => { + // Percentage constraint + std::iter::repeat(ratatui::prelude::Constraint::Ratio($token1 as u32, $token2 as u32)).take($count as usize) + }; // Process different types of constraints into a `Constraint` (@process (== $token1:tt / $token2:tt)) => { // Ratio constraint - { - let t1: u32 = $token1; - let t2: u32 = $token2; - ratatui::prelude::Constraint::Ratio(t1, t2) - } + ratatui::prelude::Constraint::Ratio($token1 as u32, $token2 as u32) }; (@process (== $token:tt % ; $count:expr)) => { // Percentage constraint From 3870583ea868452191857f9bda97a3d5c35d0a4f Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 15:46:11 -0500 Subject: [PATCH 008/109] =?UTF-8?q?feat:=20Add=20more=20tests=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 2 +- tests/macros.rs | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index 759d3bf9..217924b3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -70,7 +70,7 @@ macro_rules! constraints { (@parse ($($acc:tt)*)) => { [$crate::constraints!(@process ($($acc)*))] }; - (@process (== $token1:tt / token2::tt ; $count:expr)) => { + (@process (== $token1:tt / $token2:tt ; $count:expr)) => { // Percentage constraint std::iter::repeat(ratatui::prelude::Constraint::Ratio($token1 as u32, $token2 as u32)).take($count as usize) }; diff --git a/tests/macros.rs b/tests/macros.rs index 74239178..de3da680 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -78,4 +78,23 @@ fn layout_constraints_macro() { assert_eq!(c, Constraint::Min(0)); assert_eq!(d, Constraint::Min(0)); assert_eq!(e, Constraint::Min(0)); + + let [a, b, c, d, e] = constraints!([<=0; 5]).collect::>().try_into().unwrap(); + assert_eq!(a, Constraint::Max(0)); + assert_eq!(b, Constraint::Max(0)); + assert_eq!(c, Constraint::Max(0)); + assert_eq!(d, Constraint::Max(0)); + assert_eq!(e, Constraint::Max(0)); + + let [a, b] = constraints!([==0; 2]).collect::>().try_into().unwrap(); + assert_eq!(a, Constraint::Length(0)); + assert_eq!(b, Constraint::Length(0)); + + let [a, b] = constraints!([== 50%; 2]).collect::>().try_into().unwrap(); + assert_eq!(a, Constraint::Percentage(50)); + assert_eq!(b, Constraint::Percentage(50)); + + let [a, b] = constraints!([== 1/2; 2]).collect::>().try_into().unwrap(); + assert_eq!(a, Constraint::Ratio(1, 2)); + assert_eq!(b, Constraint::Ratio(1, 2)); } From 487edc8399683fb8a9a66359729c015780d248f2 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Fri, 5 Jan 2024 15:46:39 -0500 Subject: [PATCH 009/109] =?UTF-8?q?build(release):=20Bump=20to=20v0.1.1=20?= =?UTF-8?q?=F0=9F=9B=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 61ad947b..4313db86 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ratatui-macros" -version = "0.1.0" +version = "0.1.1" edition = "2021" authors = ["Dheepak Krishnamurthy"] description = "Macros for Ratatui" From 250c222cc4aaab09184a28efc68f75ca03133794 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Sat, 6 Jan 2024 06:40:06 -0500 Subject: [PATCH 010/109] =?UTF-8?q?docs:=20README.md=20update=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 35c5facf..65d7f0c1 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,12 @@ # Ratatui Macros -`ratatui_macros` is a Rust crate that provides easy-to-use macros for simplifying boilerplate +[![Crates.io](https://img.shields.io/crates/v/ratatui-macros)](https://crates.io/crates/ratatui-macros) +[![Docs.rs](https://docs.rs/ratatui-macros/badge.svg)](https://docs.rs/ratatui-macros) +[![Build Status](https://github.com/kdheepak/ratatui-macros/actions/workflows/ci.yml/badge.svg)](https://github.com/kdheepak/ratatui-macros/actions) +[![License](https://img.shields.io/crates/l/ratatui-macros)](https://crates.io/crates/ratatui-macros#license) +[![Downloads](https://img.shields.io/crates/d/ratatui-macros)](https://crates.io/crates/ratatui-macros) + +`ratatui-macros` is a Rust crate that provides easy-to-use macros for simplifying boilerplate associated with creating UI using ratatui. ## Features @@ -11,11 +17,10 @@ associated with creating UI using ratatui. ## Getting Started -To use `ratatui_macros` in your Rust project, add it as a dependency in your Cargo.toml: +To use `ratatui-macros` in your Rust project, add it as a dependency in your `Cargo.toml`: -```toml -[dependencies] -ratatui_macros = "0.1.0" +```shell +cargo add ratatui-macros ``` Then, import the macros in your Rust file: From 590a392ab11c1a215767614931036781f4cf6a29 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Sat, 6 Jan 2024 06:45:49 -0500 Subject: [PATCH 011/109] =?UTF-8?q?feat:=20Add=20doc=20attribute=20to=20in?= =?UTF-8?q?clude=20README=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/lib.rs b/src/lib.rs index 217924b3..280ac65b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,5 @@ +#![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))] + /// This macro creates an iterator of constraints. /// /// # Syntax From 6443f7408af4a8834bc68cd35d2ba9be47e45f38 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Sat, 6 Jan 2024 06:46:24 -0500 Subject: [PATCH 012/109] =?UTF-8?q?build(release):=20Bump=20to=20v0.1.2=20?= =?UTF-8?q?=F0=9F=9B=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 4313db86..7f1f5687 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ratatui-macros" -version = "0.1.1" +version = "0.1.2" edition = "2021" authors = ["Dheepak Krishnamurthy"] description = "Macros for Ratatui" From 8339cce10a51c9c951b3c9750d527d80168626eb Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Sat, 6 Jan 2024 06:49:04 -0500 Subject: [PATCH 013/109] =?UTF-8?q?docs:=20Update=20README.md=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 65d7f0c1..a0ad0fa3 100644 --- a/README.md +++ b/README.md @@ -26,37 +26,40 @@ cargo add ratatui-macros Then, import the macros in your Rust file: ```rust -use ratatui_macros::{constraints, layout, vertical, horizontal}; +use ratatui_macros::{constraints, vertical, horizontal}; ``` Use the `constraints!` macro to define layout constraints: ```rust +use ratatui_macros::constraints; constraints!([==50, ==30%, >=3, <=1, ==1/2]); // is equivalent to [ - ratatui::prelude::Constraint::Length(50)), - ratatui::prelude::Constraint::Percentage(30)), - ratatui::prelude::Constraint::Min(3)), - ratatui::prelude::Constraint::Max(1)), - ratatui::prelude::Constraint::Ratio(1, 2)), -] + ratatui::prelude::Constraint::Length(50), + ratatui::prelude::Constraint::Percentage(30), + ratatui::prelude::Constraint::Min(3), + ratatui::prelude::Constraint::Max(1), + ratatui::prelude::Constraint::Ratio(1, 2), +]; ``` ```rust +use ratatui_macros::constraints; constraints!([==1/4; 4]); // is equivalent to [ - ratatui::prelude::Constraint::Ratio(1, 4)), - ratatui::prelude::Constraint::Ratio(1, 4)), - ratatui::prelude::Constraint::Ratio(1, 4)), - ratatui::prelude::Constraint::Ratio(1, 4)), -] + ratatui::prelude::Constraint::Ratio(1, 4), + ratatui::prelude::Constraint::Ratio(1, 4), + ratatui::prelude::Constraint::Ratio(1, 4), + ratatui::prelude::Constraint::Ratio(1, 4), +]; ``` Create vertical and horizontal layouts using the `vertical!` and `horizontal!` macros: ```rust +use ratatui_macros::{vertical, horizontal}; let vertical_layout = vertical!([==50, ==30%]); let horizontal_layout = horizontal!([==1/3, >=100, <=4]); ``` From ac342231c344e893f2f630ee38167aab28c736a6 Mon Sep 17 00:00:00 2001 From: Ash Date: Mon, 8 Jan 2024 13:40:59 -0800 Subject: [PATCH 014/109] refactor: clean up implementation of constraints! macro --- src/lib.rs | 108 ++++++++++++++---------------------------------- tests/macros.rs | 12 +++--- 2 files changed, 36 insertions(+), 84 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 280ac65b..a6eb1544 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -30,90 +30,42 @@ /// This macro simplifies the process of creating various constraints. #[macro_export] macro_rules! constraints { - // Entry rule for constraints - // e.g. `[ ==100%, >=1, >=1 ]` + // Rules for parsing one constraint at a time. + + // Entrypoint; we add a comma to make sure there's always a trailing comma. Right-hand side + // will accumulate the actual Constraint literals. ([ $( $constraint:tt )+ ]) => { - // e.g. the tokens `==100%, >=1, >=1` are matched with @parse rules - $crate::constraints!(@parse () $($constraint)+) + $crate::constraints!([ $($constraint)+ , ] -> () []) }; - // Special case for `;` - (@parse ($($acc:tt)*) ; $count:expr) => { - $crate::constraints!(@process ($($acc)* ; $count)) + + // No more input tokens; emit the parsed constraints. + ([$(,)?] -> () [ $( $parsed:tt )* ]) => { + [$($parsed)*] }; - // Internal parsing rules for constraints - // This rule checks if `,` exists after the `head` token - // e.g. acc: `==100`; head: `%`; `,`; tail: `>=1, >=1` will match this rule - (@parse ($($acc:tt)*) $head:tt , $($tail:tt)*) => { - // Combines the head constraint with the tail constraints into a vector - std::iter::once( - // e.g. (acc head): `==100%`; this can be processed as a `Constraint` - $crate::constraints!(@process ($($acc)* $head)) // -> Constraint - ).chain( - // e.g. tail: `>=1, >=1`; this can be parsed as a `Iterator` - $crate::constraints!(@parse () $($tail)*).into_iter() // -> Iterator with type Constraint - ) + + ([ , $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { + $crate::constraints!([$($rest)*] -> () [$($parsed)* $crate::constraint!($($partial)*) ,]) }; - // If there is no `,` then accumulate `next` token into existing `acc` tokens - // and return `Iterator` - // e.g. for tokens `==100%, >=1, >=1` - // 1. acc: `` ; next: `=` ; tail: `=100 %, >=1, >=1` ; will match this rule - // acc: `=` ; tail: `=100 %, >=1, >=1` ; is the next parse - // 2. acc: `=` ; next: `=` ; tail: `100 %, >=1, >=1` ; will match this rule again - // acc: `==` ; tail: `100 %, >=1, >=1` ; is the next parse - // 3. acc: `==` ; next: `100` ; tail: `%, >=1, >=1` ; will match this rule again - // acc: `==100` ; tail: `%, >=1, >=1` ; is the next parse - // OR acc: `==100` ; head: `%`; `,`; tail: `>=1, >=1` ; i.e. this is the match for the next parse - // ^^^ --------------------------------> this will match previous rule because of this comma - (@parse ($($acc:tt)*) $next:tt $($tail:tt)*) => { - $crate::constraints!(@parse ($($acc)* $next) $($tail)*) + + // the comma here is because we always have a trailing comma + ([ ; $count:expr , ] -> ($($partial:tt)*) []) => { + [$crate::constraint!($($partial)*); $count] }; - // At the end there will a set of tokens left after the last `,` - // Process that as a `Constraint` - (@parse ($($acc:tt)*)) => { - [$crate::constraints!(@process ($($acc)*))] - }; - (@process (== $token1:tt / $token2:tt ; $count:expr)) => { - // Percentage constraint - std::iter::repeat(ratatui::prelude::Constraint::Ratio($token1 as u32, $token2 as u32)).take($count as usize) - }; - // Process different types of constraints into a `Constraint` - (@process (== $token1:tt / $token2:tt)) => { - // Ratio constraint - ratatui::prelude::Constraint::Ratio($token1 as u32, $token2 as u32) - }; - (@process (== $token:tt % ; $count:expr)) => { - // Percentage constraint - std::iter::repeat(ratatui::prelude::Constraint::Percentage($token)).take($count as usize) - }; - (@process (== $token:tt %)) => { - // Percentage constraint - ratatui::prelude::Constraint::Percentage($token) - }; - (@process (>= $token:expr; $count:expr)) => { - // Percentage constraint - std::iter::repeat(ratatui::prelude::Constraint::Min($token)).take($count as usize) - }; - (@process (>= $token:expr)) => { - // Minimum size constraint - ratatui::prelude::Constraint::Min($token) - }; - (@process (<= $token:expr; $count:expr)) => { - // Percentage constraint - std::iter::repeat(ratatui::prelude::Constraint::Max($token)).take($count as usize) - }; - (@process (<= $token:expr)) => { - // Maximum size constraint - ratatui::prelude::Constraint::Max($token) - }; - (@process (== $token:expr ; $count:expr)) => { - std::iter::repeat(ratatui::prelude::Constraint::Length($token)).take($count as usize) - }; - (@process (== $token:expr)) => { - // Fixed size constraint - ratatui::prelude::Constraint::Length($token) + + ([ $head:tt $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { + $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) }; } +#[macro_export] +macro_rules! constraint { + ( == $token:tt % ) => { ratatui::prelude::Constraint::Percentage($token) }; + ( >= $expr:expr ) => { ratatui::prelude::Constraint::Min($expr) }; + ( <= $expr:expr ) => { ratatui::prelude::Constraint::Max($expr) }; + ( == $num:tt / $denom:tt ) => { ratatui::prelude::Constraint::Ratio($num as u32, $denom as u32) }; + ( == $expr:expr ) => { ratatui::prelude::Constraint::Length($expr) }; +} + /// This macro creates a layout with specified constraints and direction. /// /// # Syntax @@ -156,12 +108,12 @@ macro_rules! layout { // Horizontal layout variant ([ $( $constraint:tt )+ ], direction = h) => { // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator - $crate::layout!(@construct ratatui::prelude::Direction::Horizontal, $crate::constraints!(@parse () $($constraint)+)) + $crate::layout!(@construct ratatui::prelude::Direction::Horizontal, $crate::constraints!( [ $($constraint)+ ])) }; // Vertical layout variant ([ $( $constraint:tt )+ ], direction = v) => { // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator - $crate::layout!(@construct ratatui::prelude::Direction::Vertical, $crate::constraints!(@parse () $($constraint)+)) + $crate::layout!(@construct ratatui::prelude::Direction::Vertical, $crate::constraints!( [ $($constraint)+ ] )) }; // Construct the final `Layout` object (@construct $direction:expr, $constraints:expr) => { diff --git a/tests/macros.rs b/tests/macros.rs index de3da680..cda6d6b1 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -65,36 +65,36 @@ fn layout_constraints_macro() { assert_eq!(e, Rect::new(8, 0, 1, 10)); assert_eq!(f, Rect::new(9, 0, 1, 10)); - let [a, b, c, d, e] = constraints!([>=0, ==1, <=5, ==10%, ==1/2]).collect::>().try_into().unwrap(); + let [a, b, c, d, e] = constraints!([>=0, ==1, <=5, ==10%, ==1/2]); assert_eq!(a, Constraint::Min(0)); assert_eq!(b, Constraint::Length(1)); assert_eq!(c, Constraint::Max(5)); assert_eq!(d, Constraint::Percentage(10)); assert_eq!(e, Constraint::Ratio(1, 2)); - let [a, b, c, d, e] = constraints!([>=0; 5]).collect::>().try_into().unwrap(); + let [a, b, c, d, e] = constraints!([>=0; 5]); assert_eq!(a, Constraint::Min(0)); assert_eq!(b, Constraint::Min(0)); assert_eq!(c, Constraint::Min(0)); assert_eq!(d, Constraint::Min(0)); assert_eq!(e, Constraint::Min(0)); - let [a, b, c, d, e] = constraints!([<=0; 5]).collect::>().try_into().unwrap(); + let [a, b, c, d, e] = constraints!([<=0; 5]); assert_eq!(a, Constraint::Max(0)); assert_eq!(b, Constraint::Max(0)); assert_eq!(c, Constraint::Max(0)); assert_eq!(d, Constraint::Max(0)); assert_eq!(e, Constraint::Max(0)); - let [a, b] = constraints!([==0; 2]).collect::>().try_into().unwrap(); + let [a, b] = constraints!([==0; 2]); assert_eq!(a, Constraint::Length(0)); assert_eq!(b, Constraint::Length(0)); - let [a, b] = constraints!([== 50%; 2]).collect::>().try_into().unwrap(); + let [a, b] = constraints!([== 50%; 2]); assert_eq!(a, Constraint::Percentage(50)); assert_eq!(b, Constraint::Percentage(50)); - let [a, b] = constraints!([== 1/2; 2]).collect::>().try_into().unwrap(); + let [a, b] = constraints!([== 1/2; 2]); assert_eq!(a, Constraint::Ratio(1, 2)); assert_eq!(b, Constraint::Ratio(1, 2)); } From 0fb103680028a6e26a1923f87b60bde51acaec4f Mon Sep 17 00:00:00 2001 From: Ash Date: Mon, 8 Jan 2024 15:22:52 -0800 Subject: [PATCH 015/109] docs: improve documentation for macros --- src/lib.rs | 69 +++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 47 insertions(+), 22 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index a6eb1544..0f9ed21a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,6 +6,7 @@ /// /// The macro supports the following form: /// - `constraints!([$( $constraint:tt )+])` +/// - `constraints!([$( $constraint:tt )+; $count:expr])` /// /// Constraints are defined using a specific syntax: /// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. @@ -18,19 +19,35 @@ /// /// ``` /// use ratatui_macros::constraints; -/// constraints!([==5, ==30%, >=3, <=1, ==1/2]); -/// constraints!([==5; 5]); +/// assert_eq!(constraints!([==5, ==30%, >=3, <=1, ==1/2]).len(), 5); +/// assert_eq!(constraints!([==5; 5]).len(), 5); /// ``` -/// -/// # Internal Implementation -/// -/// - `@parse`: Internal rule to parse and accumulate constraints. -/// - `@process`: Internal rule to convert tokens into constraints. -/// -/// This macro simplifies the process of creating various constraints. #[macro_export] macro_rules! constraints { - // Rules for parsing one constraint at a time. + // Note: this implementation forgoes speed for the sake of simplicity. Adding variations of the + // comma and semicolon rules for each constraint type would be faster, but would result in a lot + // of duplicated code. + + // Comma finishes a constraint element, so parse it and continue. + ([ , $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { + $crate::constraints!([$($rest)*] -> () [$($parsed)* $crate::constraint!($($partial)*) ,]) + }; + + // Semicolon indicates that there's repetition. The trailing comma is because the 'entrypoint' + // rule adds a trailing comma. + ([ ; $count:expr , ] -> ($($partial:tt)*) []) => { + [$crate::constraint!($($partial)*); $count] + }; + + // User wrote something like `constraints!([== 3, == 4; 10])`. + ([ ; $count:expr , ] -> ($($partial:tt)*) [$($_:expr)+]) => { + compile_error!("constraint repetition requires exactly one constraint") + }; + + // Pull the first token (which can't be a comma or semicolon) onto the accumulator. + ([ $head:tt $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { + $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) + }; // Entrypoint; we add a comma to make sure there's always a trailing comma. Right-hand side // will accumulate the actual Constraint literals. @@ -43,20 +60,28 @@ macro_rules! constraints { [$($parsed)*] }; - ([ , $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { - $crate::constraints!([$($rest)*] -> () [$($parsed)* $crate::constraint!($($partial)*) ,]) - }; - - // the comma here is because we always have a trailing comma - ([ ; $count:expr , ] -> ($($partial:tt)*) []) => { - [$crate::constraint!($($partial)*); $count] - }; - - ([ $head:tt $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { - $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) - }; } +/// Expands to a single constraint. If creating an array of constraints, you probably want to use +/// [`constraints!`] instead. +/// +/// # Syntax +/// +/// Constraints are defined using a specific syntax: +/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. +/// - `== $token:tt %`: Sets a percentage constraint for the token. +/// - `>= $token:tt`: Sets a minimum size constraint for the token. +/// - `<= $token:tt`: Sets a maximum size constraint for the token. +/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// +/// # Examples +/// +/// ``` +/// use ratatui_macros::constraint; +/// use ratatui::prelude::Constraint; +/// assert_eq!(constraint!(>= 3 + 4), Constraint::Min(7)); +/// assert_eq!(constraint!(== 1 / 3), Constraint::Ratio(1, 3)); +/// ``` #[macro_export] macro_rules! constraint { ( == $token:tt % ) => { ratatui::prelude::Constraint::Percentage($token) }; From 4335a90a00aeeedb69a92442c7f2711727944017 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Mon, 8 Jan 2024 23:54:37 -0500 Subject: [PATCH 016/109] =?UTF-8?q?feat:=20Remove=20inner=20[]=20for=20con?= =?UTF-8?q?straints!,=20vertical!=20and=20horizontal!=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 47 ++++++++++++++++++++++++++++------------------- tests/macros.rs | 24 ++++++++---------------- 2 files changed, 36 insertions(+), 35 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 0f9ed21a..1a4ed971 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -19,8 +19,8 @@ /// /// ``` /// use ratatui_macros::constraints; -/// assert_eq!(constraints!([==5, ==30%, >=3, <=1, ==1/2]).len(), 5); -/// assert_eq!(constraints!([==5; 5]).len(), 5); +/// assert_eq!(constraints![==5, ==30%, >=3, <=1, ==1/2].len(), 5); +/// assert_eq!(constraints![==5; 5].len(), 5); /// ``` #[macro_export] macro_rules! constraints { @@ -49,17 +49,16 @@ macro_rules! constraints { $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) }; - // Entrypoint; we add a comma to make sure there's always a trailing comma. Right-hand side - // will accumulate the actual Constraint literals. - ([ $( $constraint:tt )+ ]) => { - $crate::constraints!([ $($constraint)+ , ] -> () []) - }; - // No more input tokens; emit the parsed constraints. ([$(,)?] -> () [ $( $parsed:tt )* ]) => { [$($parsed)*] }; + // Entrypoint; we add a comma to make sure there's always a trailing comma. Right-hand side + // will accumulate the actual Constraint literals. + ($( $constraint:tt )+) => { + $crate::constraints!([ $($constraint)+ , ] -> () []) + }; } /// Expands to a single constraint. If creating an array of constraints, you probably want to use @@ -84,11 +83,21 @@ macro_rules! constraints { /// ``` #[macro_export] macro_rules! constraint { - ( == $token:tt % ) => { ratatui::prelude::Constraint::Percentage($token) }; - ( >= $expr:expr ) => { ratatui::prelude::Constraint::Min($expr) }; - ( <= $expr:expr ) => { ratatui::prelude::Constraint::Max($expr) }; - ( == $num:tt / $denom:tt ) => { ratatui::prelude::Constraint::Ratio($num as u32, $denom as u32) }; - ( == $expr:expr ) => { ratatui::prelude::Constraint::Length($expr) }; + ( == $token:tt % ) => { + ratatui::prelude::Constraint::Percentage($token) + }; + ( >= $expr:expr ) => { + ratatui::prelude::Constraint::Min($expr) + }; + ( <= $expr:expr ) => { + ratatui::prelude::Constraint::Max($expr) + }; + ( == $num:tt / $denom:tt ) => { + ratatui::prelude::Constraint::Ratio($num as u32, $denom as u32) + }; + ( == $expr:expr ) => { + ratatui::prelude::Constraint::Length($expr) + }; } /// This macro creates a layout with specified constraints and direction. @@ -133,12 +142,12 @@ macro_rules! layout { // Horizontal layout variant ([ $( $constraint:tt )+ ], direction = h) => { // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator - $crate::layout!(@construct ratatui::prelude::Direction::Horizontal, $crate::constraints!( [ $($constraint)+ ])) + $crate::layout!(@construct ratatui::prelude::Direction::Horizontal, $crate::constraints!( $($constraint)+)) }; // Vertical layout variant ([ $( $constraint:tt )+ ], direction = v) => { // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator - $crate::layout!(@construct ratatui::prelude::Direction::Vertical, $crate::constraints!( [ $($constraint)+ ] )) + $crate::layout!(@construct ratatui::prelude::Direction::Vertical, $crate::constraints!( $($constraint)+ )) }; // Construct the final `Layout` object (@construct $direction:expr, $constraints:expr) => { @@ -172,11 +181,11 @@ macro_rules! layout { /// ``` /// // Vertical layout with a fixed size and a percentage constraint /// use ratatui_macros::vertical; -/// vertical!([== 50, == 30%]); +/// vertical![== 50, == 30%]; /// ``` #[macro_export] macro_rules! vertical { - ([ $( $constraint:tt )+ ]) => { + ($( $constraint:tt )+) => { $crate::layout!([ $( $constraint )+ ], direction = v) }; } @@ -205,11 +214,11 @@ macro_rules! vertical { /// ``` /// // Horizontal layout with a ratio constraint and a minimum size constraint /// use ratatui_macros::horizontal; -/// horizontal!([== 1/3, >= 100]); +/// horizontal![== 1/3, >= 100]; /// ``` #[macro_export] macro_rules! horizontal { - ([ $( $constraint:tt )+ ]) => { + ($( $constraint:tt )+) => { $crate::layout!([ $( $constraint )+ ], direction = h) }; } diff --git a/tests/macros.rs b/tests/macros.rs index cda6d6b1..3d8922db 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -5,19 +5,11 @@ use ratatui_macros::{constraints, horizontal, layout, vertical}; fn layout_constraints_macro() { let rect = Rect { x: 0, y: 0, width: 10, height: 10 }; - let [rect1, rect2] = layout!([==7, <=3], direction = v).split(rect).to_vec().try_into().unwrap(); + let [rect1, rect2] = vertical![==7, <=3].split(rect).to_vec().try_into().unwrap(); assert_eq!(rect1, Rect::new(0, 0, 10, 7)); assert_eq!(rect2, Rect::new(0, 7, 10, 3)); - let [rect1, rect2] = vertical!([==7, <=3]).split(rect).to_vec().try_into().unwrap(); - assert_eq!(rect1, Rect::new(0, 0, 10, 7)); - assert_eq!(rect2, Rect::new(0, 7, 10, 3)); - - let [rect1, rect2] = layout!([==7, <=3], direction = h).split(rect).to_vec().try_into().unwrap(); - assert_eq!(rect1, Rect::new(0, 0, 7, 10)); - assert_eq!(rect2, Rect::new(7, 0, 3, 10)); - - let [rect1, rect2] = horizontal!([==7, <=3]).split(rect).to_vec().try_into().unwrap(); + let [rect1, rect2] = horizontal![==7, <=3].split(rect).to_vec().try_into().unwrap(); assert_eq!(rect1, Rect::new(0, 0, 7, 10)); assert_eq!(rect2, Rect::new(7, 0, 3, 10)); @@ -65,36 +57,36 @@ fn layout_constraints_macro() { assert_eq!(e, Rect::new(8, 0, 1, 10)); assert_eq!(f, Rect::new(9, 0, 1, 10)); - let [a, b, c, d, e] = constraints!([>=0, ==1, <=5, ==10%, ==1/2]); + let [a, b, c, d, e] = constraints![ >=0, ==1, <=5, ==10%, ==1/2 ]; assert_eq!(a, Constraint::Min(0)); assert_eq!(b, Constraint::Length(1)); assert_eq!(c, Constraint::Max(5)); assert_eq!(d, Constraint::Percentage(10)); assert_eq!(e, Constraint::Ratio(1, 2)); - let [a, b, c, d, e] = constraints!([>=0; 5]); + let [a, b, c, d, e] = constraints![ >=0; 5 ]; assert_eq!(a, Constraint::Min(0)); assert_eq!(b, Constraint::Min(0)); assert_eq!(c, Constraint::Min(0)); assert_eq!(d, Constraint::Min(0)); assert_eq!(e, Constraint::Min(0)); - let [a, b, c, d, e] = constraints!([<=0; 5]); + let [a, b, c, d, e] = constraints![ <=0; 5 ]; assert_eq!(a, Constraint::Max(0)); assert_eq!(b, Constraint::Max(0)); assert_eq!(c, Constraint::Max(0)); assert_eq!(d, Constraint::Max(0)); assert_eq!(e, Constraint::Max(0)); - let [a, b] = constraints!([==0; 2]); + let [a, b] = constraints![ ==0; 2 ]; assert_eq!(a, Constraint::Length(0)); assert_eq!(b, Constraint::Length(0)); - let [a, b] = constraints!([== 50%; 2]); + let [a, b] = constraints![ == 50%; 2 ]; assert_eq!(a, Constraint::Percentage(50)); assert_eq!(b, Constraint::Percentage(50)); - let [a, b] = constraints!([== 1/2; 2]); + let [a, b] = constraints![ == 1/2; 2 ]; assert_eq!(a, Constraint::Ratio(1, 2)); assert_eq!(b, Constraint::Ratio(1, 2)); } From 71480242a926f98e9081ed6e2dc8c381757b3a42 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 00:03:37 -0500 Subject: [PATCH 017/109] =?UTF-8?q?docs:=20Better=20README.md=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 ++--- src/lib.rs | 81 +++++++++---------------------------------------- tests/macros.rs | 28 +++++++---------- 3 files changed, 29 insertions(+), 88 deletions(-) diff --git a/README.md b/README.md index a0ad0fa3..fba06750 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ Use the `constraints!` macro to define layout constraints: ```rust use ratatui_macros::constraints; -constraints!([==50, ==30%, >=3, <=1, ==1/2]); +constraints![==50, ==30%, >=3, <=1, ==1/2]; // is equivalent to [ ratatui::prelude::Constraint::Length(50), @@ -46,7 +46,7 @@ constraints!([==50, ==30%, >=3, <=1, ==1/2]); ```rust use ratatui_macros::constraints; -constraints!([==1/4; 4]); +constraints![==1/4; 4]; // is equivalent to [ ratatui::prelude::Constraint::Ratio(1, 4), @@ -60,8 +60,8 @@ Create vertical and horizontal layouts using the `vertical!` and `horizontal!` m ```rust use ratatui_macros::{vertical, horizontal}; -let vertical_layout = vertical!([==50, ==30%]); -let horizontal_layout = horizontal!([==1/3, >=100, <=4]); +let vertical_layout = vertical![==50, ==30%]; +let horizontal_layout = horizontal![==1/3, >=100, <=4]; ``` ## Contributing diff --git a/src/lib.rs b/src/lib.rs index 1a4ed971..adc3f212 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,6 +1,6 @@ #![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))] -/// This macro creates an iterator of constraints. +/// This macro creates an array of constraints. /// /// # Syntax /// @@ -100,63 +100,6 @@ macro_rules! constraint { }; } -/// This macro creates a layout with specified constraints and direction. -/// -/// # Syntax -/// -/// The macro supports three main forms: -/// - `layout!([$( $constraint:tt )+])`: Defines a default layout (vertical) with constraints. -/// - `layout!([$( $constraint:tt )+], direction = h)`: Defines a horizontal layout with -/// constraints. -/// - `layout!([$( $constraint:tt )+], direction = v)`: Defines a vertical layout with constraints. -/// -/// Constraints are defined using a specific syntax: -/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. -/// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:tt`: Sets a minimum size constraint for the token. -/// - `<= $token:tt`: Sets a maximum size constraint for the token. -/// - `== $token:tt`: Sets a fixed size constraint for the token. -/// -/// # Examples -/// -/// ``` -/// // Vertical layout with fixed size and percentage constraints -/// use ratatui_macros::layout; -/// layout!([== 50, == 30%], direction = v); -/// ``` -/// -/// ``` -/// // Horizontal layout with ratio and minimum size constraints -/// use ratatui_macros::layout; -/// layout!([== 1/3, >= 100, <=4], direction = h); -/// ``` -/// -/// # Internal Implementation -/// -/// - `@construct`: Internal rule to construct the final Layout with the specified direction and -/// constraints. -/// -/// This macro simplifies the process of creating complex layouts with various constraints. -#[macro_export] -macro_rules! layout { - // Horizontal layout variant - ([ $( $constraint:tt )+ ], direction = h) => { - // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator - $crate::layout!(@construct ratatui::prelude::Direction::Horizontal, $crate::constraints!( $($constraint)+)) - }; - // Vertical layout variant - ([ $( $constraint:tt )+ ], direction = v) => { - // use internal `constraint!(@parse ...)` rule directly since it will always be an iterator - $crate::layout!(@construct ratatui::prelude::Direction::Vertical, $crate::constraints!( $($constraint)+ )) - }; - // Construct the final `Layout` object - (@construct $direction:expr, $constraints:expr) => { - ratatui::prelude::Layout::default() - .direction($direction) - .constraints($constraints) - }; -} - /// Creates a vertical layout with specified constraints. /// /// This macro is a convenience wrapper around the `layout!` macro for defining vertical layouts. @@ -172,9 +115,9 @@ macro_rules! layout { /// Constraints are defined using a specific syntax: /// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. /// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:tt`: Sets a minimum size constraint for the token. -/// - `<= $token:tt`: Sets a maximum size constraint for the token. -/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// - `>= $token:expr`: Sets a minimum size constraint for the token. +/// - `<= $token:expr`: Sets a maximum size constraint for the token. +/// - `== $token:expr`: Sets a fixed size constraint for the token. /// /// # Examples /// @@ -186,7 +129,9 @@ macro_rules! layout { #[macro_export] macro_rules! vertical { ($( $constraint:tt )+) => { - $crate::layout!([ $( $constraint )+ ], direction = v) + ratatui::prelude::Layout::default() + .direction(ratatui::prelude::Direction::Vertical) + .constraints($crate::constraints!( $($constraint)+ )) }; } @@ -198,16 +143,16 @@ macro_rules! vertical { /// /// # Syntax /// -/// - `horizontal!([$( $constraint:tt )+])`: Defines a horizontal layout with the given constraints. +/// - `horizontal![$( $constraint:tt )+]`: Defines a horizontal layout with the given constraints. /// /// # Constraints /// /// Constraints are defined using a specific syntax: /// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. /// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:tt`: Sets a minimum size constraint for the token. -/// - `<= $token:tt`: Sets a maximum size constraint for the token. -/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// - `>= $token:expr`: Sets a minimum size constraint for the token. +/// - `<= $token:expr`: Sets a maximum size constraint for the token. +/// - `== $token:expr`: Sets a fixed size constraint for the token. /// /// # Examples /// @@ -219,6 +164,8 @@ macro_rules! vertical { #[macro_export] macro_rules! horizontal { ($( $constraint:tt )+) => { - $crate::layout!([ $( $constraint )+ ], direction = h) + ratatui::prelude::Layout::default() + .direction(ratatui::prelude::Direction::Horizontal) + .constraints($crate::constraints!( $($constraint)+ )) }; } diff --git a/tests/macros.rs b/tests/macros.rs index 3d8922db..661c03ed 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -1,5 +1,5 @@ use ratatui::prelude::*; -use ratatui_macros::{constraints, horizontal, layout, vertical}; +use ratatui_macros::{constraints, horizontal, vertical}; #[test] fn layout_constraints_macro() { @@ -17,11 +17,8 @@ fn layout_constraints_macro() { let two = 2; let ten = 10; let zero = 0; - let [a, b, c, d, e, f] = layout!([==one, >=one, <=one, == 1 / two, == ten %, >=zero], direction = h) - .split(rect) - .to_vec() - .try_into() - .unwrap(); + let [a, b, c, d, e, f] = + horizontal![==one, >=one, <=one, == 1 / two, == ten %, >=zero].split(rect).to_vec().try_into().unwrap(); assert_eq!(a, Rect::new(0, 0, 1, 10)); assert_eq!(b, Rect::new(1, 0, 1, 10)); @@ -34,17 +31,14 @@ fn layout_constraints_macro() { let two = 2; let ten = 10; let zero = 0; - let [a, b, c, d, e, f] = layout!( - [ - == one*one, // expr allowed here - >= one+zero, // expr allowed here - <= one-zero, // expr allowed here - == 1/two, // only single token allowed in numerator and denominator - == ten%, // only single token allowed before % - >= zero // no trailing comma - ], - direction = h - ) + let [a, b, c, d, e, f] = horizontal![ + == one*one, // expr allowed here + >= one+zero, // expr allowed here + <= one-zero, // expr allowed here + == 1/two, // only single token allowed in numerator and denominator + == ten%, // only single token allowed before % + >= zero // no trailing comma + ] .split(rect) .to_vec() .try_into() From e1a31db55913bd690bcaef380e9dbc3b6a5dc175 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 00:05:18 -0500 Subject: [PATCH 018/109] =?UTF-8?q?docs:=20fix=20docstrings=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index adc3f212..32628648 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,15 +5,15 @@ /// # Syntax /// /// The macro supports the following form: -/// - `constraints!([$( $constraint:tt )+])` -/// - `constraints!([$( $constraint:tt )+; $count:expr])` +/// - `constraints![$( $constraint:tt )+]` +/// - `constraints![$( $constraint:tt )+; $count:expr]` /// /// Constraints are defined using a specific syntax: /// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. /// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:tt`: Sets a minimum size constraint for the token. -/// - `<= $token:tt`: Sets a maximum size constraint for the token. -/// - `== $token:tt`: Sets a fixed size constraint for the token. +/// - `>= $token:expr`: Sets a minimum size constraint for the token. +/// - `<= $token:expr`: Sets a maximum size constraint for the token. +/// - `== $token:expr`: Sets a fixed size constraint for the token. /// /// # Examples /// @@ -108,7 +108,7 @@ macro_rules! constraint { /// /// # Syntax /// -/// - `vertical!([$( $constraint:tt )+])`: Defines a vertical layout with the given constraints. +/// - `vertical![$( $constraint:tt )+]`: Defines a vertical layout with the given constraints. /// /// # Constraints /// From 38490ff8da6f11e309ba1bcb3e88a562f7c953c5 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 00:37:51 -0500 Subject: [PATCH 019/109] =?UTF-8?q?feat:=20Add=20trybuild=20for=20testing?= =?UTF-8?q?=20fails=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 3 +++ src/lib.rs | 16 ++++++++++++++++ tests/fails.rs | 5 +++++ tests/fails.stderr | 13 +++++++++++++ tests/macros.rs | 6 ++++++ 5 files changed, 43 insertions(+) create mode 100644 tests/fails.rs create mode 100644 tests/fails.stderr diff --git a/Cargo.toml b/Cargo.toml index 7f1f5687..10c7f1f9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,3 +14,6 @@ categories = ["tui", "macro"] [dependencies] ratatui = "0.25.0" + +[dev-dependencies] +trybuild = { version = "1.0.88", features = ["diff"] } diff --git a/src/lib.rs b/src/lib.rs index 32628648..0f2e6fb9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -40,11 +40,27 @@ macro_rules! constraints { }; // User wrote something like `constraints!([== 3, == 4; 10])`. + // TODO: Unable to get this compiler error to trigger ([ ; $count:expr , ] -> ($($partial:tt)*) [$($_:expr)+]) => { compile_error!("constraint repetition requires exactly one constraint") }; // Pull the first token (which can't be a comma or semicolon) onto the accumulator. + // if first token is a comma or semicolon, previous rules will match before this rule + // + // [ $head:tt $($rest:tt)* ] -> In the rule matcher, this pulls a single `head` token + // out of the previous rest, and puts + // the remaining into `rest` + // [ $($rest)* ] -> This is what is fed back into the `constraints!` macro + // as the first segment for the match rule + // + // ($($partial:tt)*) -> In the rule matcher, this contains previous partial + // tokens that will make up a `Constraint` expression + // ($($partial)* $head) -> This combines head with the previous partial tokens + // i.e. this is the accumulated tokens + // + // [ $($parsed:tt)* ] -> In the rule matcher, this contains all parsed exprs + // [$($parsed)* ] -> These are passed on to the next match untouched. ([ $head:tt $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) }; diff --git a/tests/fails.rs b/tests/fails.rs new file mode 100644 index 00000000..90c1dbda --- /dev/null +++ b/tests/fails.rs @@ -0,0 +1,5 @@ +use ratatui_macros::constraints; + +fn test() { + // constraints![== 3, == 4; 10]; +} diff --git a/tests/fails.stderr b/tests/fails.stderr new file mode 100644 index 00000000..7c4f399a --- /dev/null +++ b/tests/fails.stderr @@ -0,0 +1,13 @@ +warning: unused import: `ratatui_macros::constraints` + --> tests/fails.rs:1:5 + | +1 | use ratatui_macros::constraints; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(unused_imports)]` on by default + +error[E0601]: `main` function not found in crate `$CRATE` + --> tests/fails.rs:5:2 + | +5 | } + | ^ consider adding a `main` function to `$DIR/tests/fails.rs` diff --git a/tests/macros.rs b/tests/macros.rs index 661c03ed..ca7cbe0f 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -84,3 +84,9 @@ fn layout_constraints_macro() { assert_eq!(a, Constraint::Ratio(1, 2)); assert_eq!(b, Constraint::Ratio(1, 2)); } + +#[test] +fn fails() { + let t = trybuild::TestCases::new(); + t.compile_fail("tests/fails.rs"); +} From a4bb143e4767137d6a9e9927d3da66562611f86f Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 00:49:42 -0500 Subject: [PATCH 020/109] =?UTF-8?q?feat:=20Better=20trybuild=20test=20suit?= =?UTF-8?q?e=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 5 +++++ tests/fails.stderr | 13 ------------- tests/macros.rs | 2 +- tests/{ => ui}/fails.rs | 2 +- tests/ui/fails.stderr | 13 +++++++++++++ 5 files changed, 20 insertions(+), 15 deletions(-) delete mode 100644 tests/fails.stderr rename tests/{ => ui}/fails.rs (57%) create mode 100644 tests/ui/fails.stderr diff --git a/src/lib.rs b/src/lib.rs index 0f2e6fb9..e84c188d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,6 +28,11 @@ macro_rules! constraints { // comma and semicolon rules for each constraint type would be faster, but would result in a lot // of duplicated code. + // Comma finishes a constraint element, so parse it and continue. + ([ , $($rest:tt)* ] -> () []) => { + compile_error!("No rules expected the token `,` while trying to match the end of the macro") + }; + // Comma finishes a constraint element, so parse it and continue. ([ , $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { $crate::constraints!([$($rest)*] -> () [$($parsed)* $crate::constraint!($($partial)*) ,]) diff --git a/tests/fails.stderr b/tests/fails.stderr deleted file mode 100644 index 7c4f399a..00000000 --- a/tests/fails.stderr +++ /dev/null @@ -1,13 +0,0 @@ -warning: unused import: `ratatui_macros::constraints` - --> tests/fails.rs:1:5 - | -1 | use ratatui_macros::constraints; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: `#[warn(unused_imports)]` on by default - -error[E0601]: `main` function not found in crate `$CRATE` - --> tests/fails.rs:5:2 - | -5 | } - | ^ consider adding a `main` function to `$DIR/tests/fails.rs` diff --git a/tests/macros.rs b/tests/macros.rs index ca7cbe0f..67947fb6 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -88,5 +88,5 @@ fn layout_constraints_macro() { #[test] fn fails() { let t = trybuild::TestCases::new(); - t.compile_fail("tests/fails.rs"); + t.compile_fail("tests/ui/fails.rs"); } diff --git a/tests/fails.rs b/tests/ui/fails.rs similarity index 57% rename from tests/fails.rs rename to tests/ui/fails.rs index 90c1dbda..9058eaf4 100644 --- a/tests/fails.rs +++ b/tests/ui/fails.rs @@ -1,5 +1,5 @@ use ratatui_macros::constraints; fn test() { - // constraints![== 3, == 4; 10]; + constraints![,]; } diff --git a/tests/ui/fails.stderr b/tests/ui/fails.stderr new file mode 100644 index 00000000..aacfb9db --- /dev/null +++ b/tests/ui/fails.stderr @@ -0,0 +1,13 @@ +error: No rules expected the token `,` while trying to match the end of the macro + --> tests/ui/fails.rs:4:3 + | +4 | constraints![,]; + | ^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `$crate::constraints` which comes from the expansion of the macro `constraints` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0601]: `main` function not found in crate `$CRATE` + --> tests/ui/fails.rs:5:2 + | +5 | } + | ^ consider adding a `main` function to `$DIR/tests/ui/fails.rs` From bc73f2dcbe5ea48fc4d1555a8e931f40d7b0e03f Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:06:51 -0500 Subject: [PATCH 021/109] =?UTF-8?q?feat:=20Add=20test=20for=20not=20suppor?= =?UTF-8?q?ting=20trailing=20comma=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 7 ++++--- tests/ui/fails.rs | 6 ++++++ tests/ui/fails.stderr | 49 +++++++++++++++++++++++++++++++++++++++---- 3 files changed, 55 insertions(+), 7 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index e84c188d..a5ece643 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,7 +28,7 @@ macro_rules! constraints { // comma and semicolon rules for each constraint type would be faster, but would result in a lot // of duplicated code. - // Comma finishes a constraint element, so parse it and continue. + // Cannot start the constraints macro with a , ([ , $($rest:tt)* ] -> () []) => { compile_error!("No rules expected the token `,` while trying to match the end of the macro") }; @@ -75,8 +75,9 @@ macro_rules! constraints { [$($parsed)*] }; - // Entrypoint; we add a comma to make sure there's always a trailing comma. Right-hand side - // will accumulate the actual Constraint literals. + // Entrypoint where there's a no comma at the end + // We add a comma to make sure there's always a trailing comma. + // Right-hand side will accumulate the actual `Constraint` literals. ($( $constraint:tt )+) => { $crate::constraints!([ $($constraint)+ , ] -> () []) }; diff --git a/tests/ui/fails.rs b/tests/ui/fails.rs index 9058eaf4..5bfcf6ea 100644 --- a/tests/ui/fails.rs +++ b/tests/ui/fails.rs @@ -3,3 +3,9 @@ use ratatui_macros::constraints; fn test() { constraints![,]; } + +fn test2() { + let [a, b] = constraints![ == 1/2, == 2, ]; + assert_eq!(a, Constraint::Ratio(1, 2)); + assert_eq!(b, Constraint::Length(2)); +} diff --git a/tests/ui/fails.stderr b/tests/ui/fails.stderr index aacfb9db..a70ec8cd 100644 --- a/tests/ui/fails.stderr +++ b/tests/ui/fails.stderr @@ -6,8 +6,49 @@ error: No rules expected the token `,` while trying to match the end of the macr | = note: this error originates in the macro `$crate::constraints` which comes from the expansion of the macro `constraints` (in Nightly builds, run with -Z macro-backtrace for more info) -error[E0601]: `main` function not found in crate `$CRATE` - --> tests/ui/fails.rs:5:2 +error: unexpected end of macro invocation + --> tests/ui/fails.rs:8:16 | -5 | } - | ^ consider adding a `main` function to `$DIR/tests/ui/fails.rs` +8 | let [a, b] = constraints![ == 1/2, == 2, ]; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing tokens in macro arguments + | +note: while trying to match `==` + --> src/lib.rs + | + | ( == $token:tt % ) => { + | ^^ + = note: this error originates in the macro `$crate::constraints` which comes from the expansion of the macro `constraints` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0433]: failed to resolve: use of undeclared type `Constraint` + --> tests/ui/fails.rs:9:17 + | +9 | assert_eq!(a, Constraint::Ratio(1, 2)); + | ^^^^^^^^^^ use of undeclared type `Constraint` + | +help: consider importing this enum + | +1 + use ratatui::prelude::Constraint; + | + +error[E0433]: failed to resolve: use of undeclared type `Constraint` + --> tests/ui/fails.rs:10:17 + | +10 | assert_eq!(b, Constraint::Length(2)); + | ^^^^^^^^^^ use of undeclared type `Constraint` + | +help: consider importing this enum + | +1 + use ratatui::prelude::Constraint; + | + +error[E0601]: `main` function not found in crate `$CRATE` + --> tests/ui/fails.rs:11:2 + | +11 | } + | ^ consider adding a `main` function to `$DIR/tests/ui/fails.rs` + +error[E0527]: pattern requires 2 elements but array has 3 + --> tests/ui/fails.rs:8:7 + | +8 | let [a, b] = constraints![ == 1/2, == 2, ]; + | ^^^^^^ expected 3 elements From 77dea441e5637b1c428c2aa71ea67fb3aac20c12 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:11:05 -0500 Subject: [PATCH 022/109] =?UTF-8?q?feat:=20Update=20tests=20that=20fail=20?= =?UTF-8?q?=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/ui/fails.rs | 13 ++++++--- tests/ui/fails.stderr | 62 +++++++++++++++++-------------------------- 2 files changed, 34 insertions(+), 41 deletions(-) diff --git a/tests/ui/fails.rs b/tests/ui/fails.rs index 5bfcf6ea..6f3d4763 100644 --- a/tests/ui/fails.rs +++ b/tests/ui/fails.rs @@ -1,11 +1,16 @@ +use ratatui::prelude::*; use ratatui_macros::constraints; -fn test() { +fn main() { constraints![,]; -} -fn test2() { - let [a, b] = constraints![ == 1/2, == 2, ]; + // TODO: Make this compiler error pass + let [a, b] = constraints![ + == 1/2, + == 2, + ]; assert_eq!(a, Constraint::Ratio(1, 2)); assert_eq!(b, Constraint::Length(2)); + + let [a, b, c] = constraints![ == 1, == 10%, == 2; 4]; } diff --git a/tests/ui/fails.stderr b/tests/ui/fails.stderr index a70ec8cd..2a5044c7 100644 --- a/tests/ui/fails.stderr +++ b/tests/ui/fails.stderr @@ -1,54 +1,42 @@ error: No rules expected the token `,` while trying to match the end of the macro - --> tests/ui/fails.rs:4:3 + --> tests/ui/fails.rs:5:3 | -4 | constraints![,]; +5 | constraints![,]; | ^^^^^^^^^^^^^^^ | = note: this error originates in the macro `$crate::constraints` which comes from the expansion of the macro `constraints` (in Nightly builds, run with -Z macro-backtrace for more info) error: unexpected end of macro invocation - --> tests/ui/fails.rs:8:16 - | -8 | let [a, b] = constraints![ == 1/2, == 2, ]; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing tokens in macro arguments - | + --> tests/ui/fails.rs:8:16 + | +8 | let [a, b] = constraints![ + | ________________^ +9 | | == 1/2, +10 | | == 2, +11 | | ]; + | |___^ missing tokens in macro arguments + | note: while trying to match `==` - --> src/lib.rs - | - | ( == $token:tt % ) => { - | ^^ - = note: this error originates in the macro `$crate::constraints` which comes from the expansion of the macro `constraints` (in Nightly builds, run with -Z macro-backtrace for more info) + --> src/lib.rs + | + | ( == $token:tt % ) => { + | ^^ + = note: this error originates in the macro `$crate::constraints` which comes from the expansion of the macro `constraints` (in Nightly builds, run with -Z macro-backtrace for more info) -error[E0433]: failed to resolve: use of undeclared type `Constraint` - --> tests/ui/fails.rs:9:17 - | -9 | assert_eq!(a, Constraint::Ratio(1, 2)); - | ^^^^^^^^^^ use of undeclared type `Constraint` - | -help: consider importing this enum - | -1 + use ratatui::prelude::Constraint; - | - -error[E0433]: failed to resolve: use of undeclared type `Constraint` - --> tests/ui/fails.rs:10:17 +error: no rules expected the token `;` + --> tests/ui/fails.rs:15:51 | -10 | assert_eq!(b, Constraint::Length(2)); - | ^^^^^^^^^^ use of undeclared type `Constraint` +15 | let [a, b, c] = constraints![ == 1, == 10%, == 2; 4]; + | ^ no rules expected this token in macro call | -help: consider importing this enum +note: while trying to match `%` + --> src/lib.rs | -1 + use ratatui::prelude::Constraint; - | - -error[E0601]: `main` function not found in crate `$CRATE` - --> tests/ui/fails.rs:11:2 - | -11 | } - | ^ consider adding a `main` function to `$DIR/tests/ui/fails.rs` + | ( == $token:tt % ) => { + | ^ error[E0527]: pattern requires 2 elements but array has 3 --> tests/ui/fails.rs:8:7 | -8 | let [a, b] = constraints![ == 1/2, == 2, ]; +8 | let [a, b] = constraints![ | ^^^^^^ expected 3 elements From 06af14107e70e49a4cba3babb8ab0a0c57b4bdf8 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:11:38 -0500 Subject: [PATCH 023/109] =?UTF-8?q?fix:=20Remove=20compile=5Ferror=20rule?= =?UTF-8?q?=20that=20never=20triggers=20=F0=9F=90=9B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index a5ece643..8c4cb6ea 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -44,12 +44,6 @@ macro_rules! constraints { [$crate::constraint!($($partial)*); $count] }; - // User wrote something like `constraints!([== 3, == 4; 10])`. - // TODO: Unable to get this compiler error to trigger - ([ ; $count:expr , ] -> ($($partial:tt)*) [$($_:expr)+]) => { - compile_error!("constraint repetition requires exactly one constraint") - }; - // Pull the first token (which can't be a comma or semicolon) onto the accumulator. // if first token is a comma or semicolon, previous rules will match before this rule // From 9acdab32df69517b93dd2b861b85586d47c71540 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:21:06 -0500 Subject: [PATCH 024/109] =?UTF-8?q?docs:=20Add=20comments=20explaining=20r?= =?UTF-8?q?ules=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 41 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 8c4cb6ea..42896c11 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -4,7 +4,8 @@ /// /// # Syntax /// -/// The macro supports the following form: +/// The `constraints!` macro supports the following forms: +/// /// - `constraints![$( $constraint:tt )+]` /// - `constraints![$( $constraint:tt )+; $count:expr]` /// @@ -34,12 +35,43 @@ macro_rules! constraints { }; // Comma finishes a constraint element, so parse it and continue. + // When a comma is encountered, it marks the end of a constraint element, so this rule is responsible + // for parsing the constraint expression up to the comma and continuing the parsing process. + // It accumulated the $partial contains a Constraint and is parsed using a separate $crate::constraint! macro. + // The constraint is then appended to the list of parsed constraints. + // + // [ , $($rest:tt)* ] -> In the rule matcher, this pattern matches a comma followed + // by the rest of the tokens. The comma signals the end of + // the current constraint element. + // ($($partial:tt)*) -> In the rule matcher, this contains the partial tokens + // accumulated so far for the current constraint element. + // [$($parsed:tt)* ] -> This contains the constraints that have been successfully + // parsed so far. + // $crate::constraint!($($partial)*) -> This macro call parses and expands the accumulated + // partial tokens into a single Constraint expression. + // [$($parsed)* $crate::constraint!(...)] -> Appends the newly parsed constraint to the list of + // already parsed constraints. ([ , $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { $crate::constraints!([$($rest)*] -> () [$($parsed)* $crate::constraint!($($partial)*) ,]) }; - // Semicolon indicates that there's repetition. The trailing comma is because the 'entrypoint' + // Semicolon indicates that there's repetition. The trailing comma is required because the 'entrypoint' // rule adds a trailing comma. + // This rule is triggered when a semicolon is encountered, indicating that there is repetition of + // constraints. It handles the repetition logic by parsing the count and generating an array of + // constraints using the $crate::constraint! macro. + // + // [ ; $count:expr , ] -> In the rule matcher, this pattern matches a semicolon + // followed by an expression representing the count, and a + // trailing comma. + // ($($partial:tt)*) -> In the rule matcher, this contains the partial tokens + // accumulated so far for the current constraint element. + // This represents everything before the ; + // [] -> There will be no existed parsed constraints when using ; + // $crate::constraint!($($partial)*) -> This macro call parses and expands the accumulated + // partial tokens into a single Constraint expression. + // [$crate::constraint!(...) ; $count] -> Generates an array of constraints by repeating the + // parsed constraint count number of times. ([ ; $count:expr , ] -> ($($partial:tt)*) []) => { [$crate::constraint!($($partial)*); $count] }; @@ -64,12 +96,13 @@ macro_rules! constraints { $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) }; - // No more input tokens; emit the parsed constraints. + // This rule is triggered when there are no more input tokens to process. It signals the end of the + // macro invocation and outputs the parsed constraints as a final array. ([$(,)?] -> () [ $( $parsed:tt )* ]) => { [$($parsed)*] }; - // Entrypoint where there's a no comma at the end + // Entrypoint where there's no comma at the end. // We add a comma to make sure there's always a trailing comma. // Right-hand side will accumulate the actual `Constraint` literals. ($( $constraint:tt )+) => { From b7f8ec0ff9659473d936eae53a57cd9de38cec1f Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:29:30 -0500 Subject: [PATCH 025/109] =?UTF-8?q?build(release):=20Bump=20to=20v0.2.0=20?= =?UTF-8?q?=F0=9F=9B=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 10c7f1f9..90720141 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ratatui-macros" -version = "0.1.2" +version = "0.2.0" edition = "2021" authors = ["Dheepak Krishnamurthy"] description = "Macros for Ratatui" From 31a2c4548c304270a8c852f19baa7a4eaac5e75c Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:36:03 -0500 Subject: [PATCH 026/109] =?UTF-8?q?docs:=20Update=20README=20with=20better?= =?UTF-8?q?=20examples=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index fba06750..accb5dcd 100644 --- a/README.md +++ b/README.md @@ -60,8 +60,14 @@ Create vertical and horizontal layouts using the `vertical!` and `horizontal!` m ```rust use ratatui_macros::{vertical, horizontal}; -let vertical_layout = vertical![==50, ==30%]; -let horizontal_layout = horizontal![==1/3, >=100, <=4]; +use ratatui::prelude::Rect; +let area = Rect { x: 0, y: 0, width: 10, height: 10 }; + +let vertical_layout = vertical![==100%, >=3]; +let [main, bottom] = vertical_layout.split(area).to_vec().try_into().unwrap(); + +let horizontal_layout = horizontal![==10, ==100%, ==10]; +let [left, main, right] = horizontal_layout.split(area).to_vec().try_into().unwrap(); ``` ## Contributing From 57b681b053c019b66e0ed92959638997fea731b1 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:38:26 -0500 Subject: [PATCH 027/109] =?UTF-8?q?docs:=20Update=20README=20with=20better?= =?UTF-8?q?=20tests=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index accb5dcd..8462a141 100644 --- a/README.md +++ b/README.md @@ -33,27 +33,29 @@ Use the `constraints!` macro to define layout constraints: ```rust use ratatui_macros::constraints; -constraints![==50, ==30%, >=3, <=1, ==1/2]; -// is equivalent to -[ - ratatui::prelude::Constraint::Length(50), - ratatui::prelude::Constraint::Percentage(30), - ratatui::prelude::Constraint::Min(3), - ratatui::prelude::Constraint::Max(1), - ratatui::prelude::Constraint::Ratio(1, 2), -]; +assert_eq!( + constraints![==50, ==30%, >=3, <=1, ==1/2], + [ + ratatui::prelude::Constraint::Length(50), + ratatui::prelude::Constraint::Percentage(30), + ratatui::prelude::Constraint::Min(3), + ratatui::prelude::Constraint::Max(1), + ratatui::prelude::Constraint::Ratio(1, 2), + ] +) ``` ```rust use ratatui_macros::constraints; -constraints![==1/4; 4]; -// is equivalent to -[ - ratatui::prelude::Constraint::Ratio(1, 4), - ratatui::prelude::Constraint::Ratio(1, 4), - ratatui::prelude::Constraint::Ratio(1, 4), - ratatui::prelude::Constraint::Ratio(1, 4), -]; +assert_eq!( + constraints![==1/4; 4], + [ + ratatui::prelude::Constraint::Ratio(1, 4), + ratatui::prelude::Constraint::Ratio(1, 4), + ratatui::prelude::Constraint::Ratio(1, 4), + ratatui::prelude::Constraint::Ratio(1, 4), + ] +) ``` Create vertical and horizontal layouts using the `vertical!` and `horizontal!` macros: From 131b9ec41751163d43d94564363247b60f031486 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:44:10 -0500 Subject: [PATCH 028/109] =?UTF-8?q?docs:=20Update=20README=20with=20better?= =?UTF-8?q?=20tests=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 8462a141..f536d503 100644 --- a/README.md +++ b/README.md @@ -63,13 +63,16 @@ Create vertical and horizontal layouts using the `vertical!` and `horizontal!` m ```rust use ratatui_macros::{vertical, horizontal}; use ratatui::prelude::Rect; -let area = Rect { x: 0, y: 0, width: 10, height: 10 }; +let area = Rect { x: 0, y: 0, width: 10, height: 10 }; let vertical_layout = vertical![==100%, >=3]; let [main, bottom] = vertical_layout.split(area).to_vec().try_into().unwrap(); +assert_eq!(bottom.height, 3); -let horizontal_layout = horizontal![==10, ==100%, ==10]; -let [left, main, right] = horizontal_layout.split(area).to_vec().try_into().unwrap(); +let area = Rect { x: 0, y: 0, width: 10, height: 10 }; +let horizontal_layout = horizontal![==100%, >=3]; +let [main, right] = horizontal_layout.split(area).to_vec().try_into().unwrap(); +assert_eq!(right.width, 3); ``` ## Contributing From 8b32f82b4dd526580d00fa13f053bf507e8ea933 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:44:34 -0500 Subject: [PATCH 029/109] =?UTF-8?q?docs:=20Update=20README=20with=20better?= =?UTF-8?q?=20tests=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f536d503..2c18f46b 100644 --- a/README.md +++ b/README.md @@ -65,11 +65,11 @@ use ratatui_macros::{vertical, horizontal}; use ratatui::prelude::Rect; let area = Rect { x: 0, y: 0, width: 10, height: 10 }; + let vertical_layout = vertical![==100%, >=3]; let [main, bottom] = vertical_layout.split(area).to_vec().try_into().unwrap(); assert_eq!(bottom.height, 3); -let area = Rect { x: 0, y: 0, width: 10, height: 10 }; let horizontal_layout = horizontal![==100%, >=3]; let [main, right] = horizontal_layout.split(area).to_vec().try_into().unwrap(); assert_eq!(right.width, 3); From 76d1e5b1733d47a7f05acf563db26cb1a66b540d Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:50:32 -0500 Subject: [PATCH 030/109] =?UTF-8?q?docs:=20Improve=20README=20examples=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 32 ++++++++++++++++++++++---------- 1 file changed, 22 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 2c18f46b..8d8b9846 100644 --- a/README.md +++ b/README.md @@ -32,37 +32,49 @@ use ratatui_macros::{constraints, vertical, horizontal}; Use the `constraints!` macro to define layout constraints: ```rust +use ratatui::prelude::*; use ratatui_macros::constraints; assert_eq!( constraints![==50, ==30%, >=3, <=1, ==1/2], [ - ratatui::prelude::Constraint::Length(50), - ratatui::prelude::Constraint::Percentage(30), - ratatui::prelude::Constraint::Min(3), - ratatui::prelude::Constraint::Max(1), - ratatui::prelude::Constraint::Ratio(1, 2), + Constraint::Length(50), + Constraint::Percentage(30), + Constraint::Min(3), + Constraint::Max(1), + Constraint::Ratio(1, 2), ] ) ``` ```rust +use ratatui::prelude::*; use ratatui_macros::constraints; assert_eq!( constraints![==1/4; 4], [ - ratatui::prelude::Constraint::Ratio(1, 4), - ratatui::prelude::Constraint::Ratio(1, 4), - ratatui::prelude::Constraint::Ratio(1, 4), - ratatui::prelude::Constraint::Ratio(1, 4), + Constraint::Ratio(1, 4), + Constraint::Ratio(1, 4), + Constraint::Ratio(1, 4), + Constraint::Ratio(1, 4), ] ) ``` +You can also use the `constraint!` macro to define individual constraints: + +```rust +use ratatui::prelude::*; +use ratatui_macros::constraint; +assert_eq!( + constraint!(==50), Constraint::Length(50), +) +``` + Create vertical and horizontal layouts using the `vertical!` and `horizontal!` macros: ```rust +use ratatui::prelude::*; use ratatui_macros::{vertical, horizontal}; -use ratatui::prelude::Rect; let area = Rect { x: 0, y: 0, width: 10, height: 10 }; From 57a0a34f924e0d488c9e9f917900e677c3488dc4 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:52:57 -0500 Subject: [PATCH 031/109] =?UTF-8?q?docs:=20Improve=20README=20examples=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 8d8b9846..f16c2ab5 100644 --- a/README.md +++ b/README.md @@ -78,12 +78,19 @@ use ratatui_macros::{vertical, horizontal}; let area = Rect { x: 0, y: 0, width: 10, height: 10 }; -let vertical_layout = vertical![==100%, >=3]; -let [main, bottom] = vertical_layout.split(area).to_vec().try_into().unwrap(); +let [main, bottom] = vertical![==100%, >=3] + .split(area) + .to_vec() + .try_into() + .unwrap(); assert_eq!(bottom.height, 3); -let horizontal_layout = horizontal![==100%, >=3]; -let [main, right] = horizontal_layout.split(area).to_vec().try_into().unwrap(); +let [left, main, right] = horizontal![>=3, ==100%, >=3] + .split(area) + .to_vec() + .try_into() + .unwrap(); +assert_eq!(left.width, 3); assert_eq!(right.width, 3); ``` From 12aa58601ddd0704256c56019bd2c7139d41f7a2 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:55:46 -0500 Subject: [PATCH 032/109] =?UTF-8?q?docs:=20Improve=20README=20examples=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index f16c2ab5..076938d6 100644 --- a/README.md +++ b/README.md @@ -79,17 +79,17 @@ use ratatui_macros::{vertical, horizontal}; let area = Rect { x: 0, y: 0, width: 10, height: 10 }; let [main, bottom] = vertical![==100%, >=3] - .split(area) - .to_vec() - .try_into() - .unwrap(); + .split(area) + .to_vec() + .try_into() + .unwrap(); assert_eq!(bottom.height, 3); let [left, main, right] = horizontal![>=3, ==100%, >=3] - .split(area) - .to_vec() - .try_into() - .unwrap(); + .split(area) + .to_vec() + .try_into() + .unwrap(); assert_eq!(left.width, 3); assert_eq!(right.width, 3); ``` From 2dc81833c60951d16f9bd60f3da003edfc9a11f5 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 01:56:59 -0500 Subject: [PATCH 033/109] =?UTF-8?q?docs:=20Improve=20README=20examples=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 076938d6..8e6de074 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ cargo add ratatui-macros Then, import the macros in your Rust file: ```rust -use ratatui_macros::{constraints, vertical, horizontal}; +use ratatui_macros::{constraints, constraint, vertical, horizontal}; ``` Use the `constraints!` macro to define layout constraints: @@ -60,7 +60,7 @@ assert_eq!( ) ``` -You can also use the `constraint!` macro to define individual constraints: +Use the `constraint!` macro to define individual constraints: ```rust use ratatui::prelude::*; From 20e41f1d1da6db8abbc2504814531d4d97bdf94b Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 02:04:30 -0500 Subject: [PATCH 034/109] =?UTF-8?q?docs:=20Update=20README=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8e6de074..6807de7c 100644 --- a/README.md +++ b/README.md @@ -83,6 +83,7 @@ let [main, bottom] = vertical![==100%, >=3] .to_vec() .try_into() .unwrap(); +assert_eq!(bottom.y, 7); assert_eq!(bottom.height, 3); let [left, main, right] = horizontal![>=3, ==100%, >=3] From 68b55a12a29e70ebfcc063c2d5d5845de3b5a27e Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 02:13:27 -0500 Subject: [PATCH 035/109] =?UTF-8?q?docs:=20Remove=20syntax=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 108 +++++++++++++++-------------------------------------- 1 file changed, 30 insertions(+), 78 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 42896c11..4b596e5d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,20 +1,38 @@ #![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))] -/// This macro creates an array of constraints. +/// Creates a single constraint. /// -/// # Syntax +/// If creating an array of constraints, you probably want to use +/// [`constraints!`] instead. /// -/// The `constraints!` macro supports the following forms: +/// # Examples /// -/// - `constraints![$( $constraint:tt )+]` -/// - `constraints![$( $constraint:tt )+; $count:expr]` -/// -/// Constraints are defined using a specific syntax: -/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. -/// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:expr`: Sets a minimum size constraint for the token. -/// - `<= $token:expr`: Sets a maximum size constraint for the token. -/// - `== $token:expr`: Sets a fixed size constraint for the token. +/// ``` +/// use ratatui_macros::constraint; +/// use ratatui::prelude::Constraint; +/// assert_eq!(constraint!(>= 3 + 4), Constraint::Min(7)); +/// assert_eq!(constraint!(== 1 / 3), Constraint::Ratio(1, 3)); +/// ``` +#[macro_export] +macro_rules! constraint { + ( == $token:tt % ) => { + ratatui::prelude::Constraint::Percentage($token) + }; + ( >= $expr:expr ) => { + ratatui::prelude::Constraint::Min($expr) + }; + ( <= $expr:expr ) => { + ratatui::prelude::Constraint::Max($expr) + }; + ( == $num:tt / $denom:tt ) => { + ratatui::prelude::Constraint::Ratio($num as u32, $denom as u32) + }; + ( == $expr:expr ) => { + ratatui::prelude::Constraint::Length($expr) + }; +} + +/// Creates an array of constraints. /// /// # Examples /// @@ -110,64 +128,11 @@ macro_rules! constraints { }; } -/// Expands to a single constraint. If creating an array of constraints, you probably want to use -/// [`constraints!`] instead. -/// -/// # Syntax -/// -/// Constraints are defined using a specific syntax: -/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. -/// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:tt`: Sets a minimum size constraint for the token. -/// - `<= $token:tt`: Sets a maximum size constraint for the token. -/// - `== $token:tt`: Sets a fixed size constraint for the token. -/// -/// # Examples -/// -/// ``` -/// use ratatui_macros::constraint; -/// use ratatui::prelude::Constraint; -/// assert_eq!(constraint!(>= 3 + 4), Constraint::Min(7)); -/// assert_eq!(constraint!(== 1 / 3), Constraint::Ratio(1, 3)); -/// ``` -#[macro_export] -macro_rules! constraint { - ( == $token:tt % ) => { - ratatui::prelude::Constraint::Percentage($token) - }; - ( >= $expr:expr ) => { - ratatui::prelude::Constraint::Min($expr) - }; - ( <= $expr:expr ) => { - ratatui::prelude::Constraint::Max($expr) - }; - ( == $num:tt / $denom:tt ) => { - ratatui::prelude::Constraint::Ratio($num as u32, $denom as u32) - }; - ( == $expr:expr ) => { - ratatui::prelude::Constraint::Length($expr) - }; -} - /// Creates a vertical layout with specified constraints. /// -/// This macro is a convenience wrapper around the `layout!` macro for defining vertical layouts. /// It accepts a series of constraints and applies them to create a vertical layout. The constraints /// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. /// -/// # Syntax -/// -/// - `vertical![$( $constraint:tt )+]`: Defines a vertical layout with the given constraints. -/// -/// # Constraints -/// -/// Constraints are defined using a specific syntax: -/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. -/// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:expr`: Sets a minimum size constraint for the token. -/// - `<= $token:expr`: Sets a maximum size constraint for the token. -/// - `== $token:expr`: Sets a fixed size constraint for the token. -/// /// # Examples /// /// ``` @@ -190,19 +155,6 @@ macro_rules! vertical { /// It takes a series of constraints and applies them to create a horizontal layout. The constraints /// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. /// -/// # Syntax -/// -/// - `horizontal![$( $constraint:tt )+]`: Defines a horizontal layout with the given constraints. -/// -/// # Constraints -/// -/// Constraints are defined using a specific syntax: -/// - `== $token:tt / $token2:tt`: Sets a ratio constraint between two tokens. -/// - `== $token:tt %`: Sets a percentage constraint for the token. -/// - `>= $token:expr`: Sets a minimum size constraint for the token. -/// - `<= $token:expr`: Sets a maximum size constraint for the token. -/// - `== $token:expr`: Sets a fixed size constraint for the token. -/// /// # Examples /// /// ``` From 693003314a25e792ffc5d53146b28bfb6a4582e3 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 02:15:50 -0500 Subject: [PATCH 036/109] =?UTF-8?q?docs:=20Add=20examples=20=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index 4b596e5d..e744edaa 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,7 +11,10 @@ /// use ratatui_macros::constraint; /// use ratatui::prelude::Constraint; /// assert_eq!(constraint!(>= 3 + 4), Constraint::Min(7)); +/// assert_eq!(constraint!(<= 3 + 4), Constraint::Max(7)); /// assert_eq!(constraint!(== 1 / 3), Constraint::Ratio(1, 3)); +/// assert_eq!(constraint!(== 3), Constraint::Length(3)); +/// assert_eq!(constraint!(== 10 %), Constraint::Percentage(10)); /// ``` #[macro_export] macro_rules! constraint { @@ -36,11 +39,26 @@ macro_rules! constraint { /// /// # Examples /// -/// ``` +/// ```rust /// use ratatui_macros::constraints; /// assert_eq!(constraints![==5, ==30%, >=3, <=1, ==1/2].len(), 5); /// assert_eq!(constraints![==5; 5].len(), 5); /// ``` +/// +/// ```rust +/// use ratatui::prelude::*; +/// use ratatui_macros::constraints; +/// assert_eq!( +/// constraints![==50, ==30%, >=3, <=1, ==1/2], +/// [ +/// Constraint::Length(50), +/// Constraint::Percentage(30), +/// Constraint::Min(3), +/// Constraint::Max(1), +/// Constraint::Ratio(1, 2), +/// ] +/// ) +/// ``` #[macro_export] macro_rules! constraints { // Note: this implementation forgoes speed for the sake of simplicity. Adding variations of the From 63441e259bc38b56e0369197bed14788b2cb3d54 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 02:16:30 -0500 Subject: [PATCH 037/109] =?UTF-8?q?build(release):=20Bump=20to=20v0.2.1=20?= =?UTF-8?q?=F0=9F=9B=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 90720141..923598f8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ratatui-macros" -version = "0.2.0" +version = "0.2.1" edition = "2021" authors = ["Dheepak Krishnamurthy"] description = "Macros for Ratatui" From fa88152c808eeb6c9d9b3662361aab1e57e1b1bf Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 02:21:32 -0500 Subject: [PATCH 038/109] =?UTF-8?q?docs:=20Update=20docstrings=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index e744edaa..eb0cd1d5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -169,7 +169,6 @@ macro_rules! vertical { /// Creates a horizontal layout with specified constraints. /// -/// This macro is a convenience wrapper around the `layout!` macro for defining horizontal layouts. /// It takes a series of constraints and applies them to create a horizontal layout. The constraints /// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. /// From 30d9daa59b1843786cde00e25c3e69cfe818b80b Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 02:21:45 -0500 Subject: [PATCH 039/109] =?UTF-8?q?build(release):=20Bump=20to=20v0.2.2=20?= =?UTF-8?q?=F0=9F=9B=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 923598f8..c2fe25b4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ratatui-macros" -version = "0.2.1" +version = "0.2.2" edition = "2021" authors = ["Dheepak Krishnamurthy"] description = "Macros for Ratatui" From 92540b2f6ab25f3a5400aebb28af3c498ac793a4 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 02:26:53 -0500 Subject: [PATCH 040/109] =?UTF-8?q?docs:=20Improved=20documentation=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 ++ src/lib.rs | 9 +++++++++ 2 files changed, 11 insertions(+) diff --git a/README.md b/README.md index 6807de7c..25d2584b 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,8 @@ Then, import the macros in your Rust file: use ratatui_macros::{constraints, constraint, vertical, horizontal}; ``` +If you are new to Ratatui, check out before proceeding. + Use the `constraints!` macro to define layout constraints: ```rust diff --git a/src/lib.rs b/src/lib.rs index eb0cd1d5..0605b792 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -37,6 +37,11 @@ macro_rules! constraint { /// Creates an array of constraints. /// +/// See [`constraint!`] for more information. +/// +/// If you want to solve the constraints, see +/// [`vertical!`] and [`horizontal!`] macros. +/// /// # Examples /// /// ```rust @@ -151,6 +156,8 @@ macro_rules! constraints { /// It accepts a series of constraints and applies them to create a vertical layout. The constraints /// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. /// +/// See [`constraint!`] or [`constraints!`] for more information. +/// /// # Examples /// /// ``` @@ -172,6 +179,8 @@ macro_rules! vertical { /// It takes a series of constraints and applies them to create a horizontal layout. The constraints /// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. /// +/// See [`constraint!`] or [`constraints!`] for more information. +/// /// # Examples /// /// ``` From 29edc3a7a38c512611a80cf5d8d42027558419b2 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 11:03:34 -0500 Subject: [PATCH 041/109] =?UTF-8?q?feat:=20Add=20color=20palette=20based?= =?UTF-8?q?=20on=20tailwindcss=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 43 +++- src/color.rs | 565 ++++++++++++++++++++++++++++++++++++++++++ src/layout.rs | 196 +++++++++++++++ src/lib.rs | 198 +-------------- tests/ui/fails.stderr | 4 +- 5 files changed, 807 insertions(+), 199 deletions(-) create mode 100644 src/color.rs create mode 100644 src/layout.rs diff --git a/README.md b/README.md index 25d2584b..83185467 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,10 @@ associated with creating UI using ratatui. - Constraint-based Layouts: Easily define layout constraints such as fixed, percentage, minimum, and maximum sizes, as well as ratios. - Directional Layouts: Specify layouts as either horizontal or vertical with simple macro commands. +- Color palette: Define color palette based on [TailwindCSS]'s expertly-crafted default color + palette. + +[TailwindCSS]: https://tailwindcss.com/docs/customizing-colors ## Getting Started @@ -26,9 +30,41 @@ cargo add ratatui-macros Then, import the macros in your Rust file: ```rust -use ratatui_macros::{constraints, constraint, vertical, horizontal}; +use ratatui_macros::{constraints, constraint, vertical, horizontal, palette}; ``` +### Color + +The `palette!` macro allows you to define color palettes with ease. It is based on [TailwindCSS]'s +default color palette. + +```rust +use ratatui::prelude::Color; +use ratatui_macros::palette; + +palette!(SLATE); + +assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); +``` + +The `palette!(SLATE)` macro expands to the following: + +```rust +use ratatui::prelude::Color; +const SLATE_50: Color = Color::Rgb(248, 250, 252); +const SLATE_100: Color = Color::Rgb(241, 245, 249); +const SLATE_200: Color = Color::Rgb(226, 232, 240); +const SLATE_300: Color = Color::Rgb(203, 213, 225); +const SLATE_400: Color = Color::Rgb(148, 163, 184); +const SLATE_500: Color = Color::Rgb(100, 116, 139); +const SLATE_600: Color = Color::Rgb(71, 85, 105); +const SLATE_700: Color = Color::Rgb(51, 65, 85); +const SLATE_800: Color = Color::Rgb(30, 41, 59); +const SLATE_900: Color = Color::Rgb(15, 23, 42); +``` + +### Layout + If you are new to Ratatui, check out before proceeding. Use the `constraints!` macro to define layout constraints: @@ -36,6 +72,7 @@ Use the `constraints!` macro to define layout constraints: ```rust use ratatui::prelude::*; use ratatui_macros::constraints; + assert_eq!( constraints![==50, ==30%, >=3, <=1, ==1/2], [ @@ -51,6 +88,7 @@ assert_eq!( ```rust use ratatui::prelude::*; use ratatui_macros::constraints; + assert_eq!( constraints![==1/4; 4], [ @@ -67,6 +105,7 @@ Use the `constraint!` macro to define individual constraints: ```rust use ratatui::prelude::*; use ratatui_macros::constraint; + assert_eq!( constraint!(==50), Constraint::Length(50), ) @@ -85,6 +124,7 @@ let [main, bottom] = vertical![==100%, >=3] .to_vec() .try_into() .unwrap(); + assert_eq!(bottom.y, 7); assert_eq!(bottom.height, 3); @@ -93,6 +133,7 @@ let [left, main, right] = horizontal![>=3, ==100%, >=3] .to_vec() .try_into() .unwrap(); + assert_eq!(left.width, 3); assert_eq!(right.width, 3); ``` diff --git a/src/color.rs b/src/color.rs new file mode 100644 index 00000000..c3668252 --- /dev/null +++ b/src/color.rs @@ -0,0 +1,565 @@ +/// Define a color palette for use in Ratatui. +/// +/// The colors are from https://tailwindcss.com/docs/customizing-colors +/// +/// The following palettes are available for use: +/// +/// - `SLATE` +/// - `GRAY` +/// - `ZINC` +/// - `NEUTRAL` +/// - `STONE` +/// - `RED` +/// - `ORANGE` +/// - `AMBER` +/// - `YELLOW` +/// - `LIME` +/// - `GREEN` +/// - `EMERALD` +/// - `TEAL` +/// - `CYAN` +/// - `SKY` +/// - `BLUE` +/// - `INDIGO` +/// - `VIOLET` +/// - `PURPLE` +/// - `FUCHSIA` +/// - `PINK` +/// - `ROSE` +/// +/// This `palette!` macro can be used both in module and function scope. +/// +/// # Examples +/// +/// ```rust +/// use ratatui::prelude::Color; +/// use ratatui_macros::palette; +/// +/// palette!(SLATE); +/// +/// assert_eq!(SLATE_50, Color::Rgb(248, 250, 252)); +/// assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); +/// +/// fn color() { +/// palette!(RED); +/// +/// assert_eq!(RED_50, Color::Rgb(254, 242, 242)); +/// assert_eq!(RED_900, Color::Rgb(127, 29, 29)); +/// } +/// # color(); +/// ``` +/// +/// The `palette!(SLATE)` macro expands to the following: +/// +/// ```rust +/// # use ratatui::prelude::Color; +/// const SLATE_50: Color = Color::Rgb(248, 250, 252); +/// const SLATE_100: Color = Color::Rgb(241, 245, 249); +/// const SLATE_200: Color = Color::Rgb(226, 232, 240); +/// const SLATE_300: Color = Color::Rgb(203, 213, 225); +/// const SLATE_400: Color = Color::Rgb(148, 163, 184); +/// const SLATE_500: Color = Color::Rgb(100, 116, 139); +/// const SLATE_600: Color = Color::Rgb(71, 85, 105); +/// const SLATE_700: Color = Color::Rgb(51, 65, 85); +/// const SLATE_800: Color = Color::Rgb(30, 41, 59); +/// const SLATE_900: Color = Color::Rgb(15, 23, 42); +/// ``` +#[macro_export] +macro_rules! palette { + (SLATE) => { + #[allow(dead_code)] + const SLATE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 250, 252); + #[allow(dead_code)] + const SLATE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(241, 245, 249); + #[allow(dead_code)] + const SLATE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(226, 232, 240); + #[allow(dead_code)] + const SLATE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(203, 213, 225); + #[allow(dead_code)] + const SLATE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(148, 163, 184); + #[allow(dead_code)] + const SLATE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(100, 116, 139); + #[allow(dead_code)] + const SLATE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(71, 85, 105); + #[allow(dead_code)] + const SLATE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(51, 65, 85); + #[allow(dead_code)] + const SLATE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 41, 59); + #[allow(dead_code)] + const SLATE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 23, 42); + }; + (GRAY) => { + #[allow(dead_code)] + const GRAY_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 250, 251); + #[allow(dead_code)] + const GRAY_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(243, 244, 246); + #[allow(dead_code)] + const GRAY_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(229, 231, 235); + #[allow(dead_code)] + const GRAY_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(209, 213, 219); + #[allow(dead_code)] + const GRAY_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(156, 163, 175); + #[allow(dead_code)] + const GRAY_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(107, 114, 128); + #[allow(dead_code)] + const GRAY_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(75, 85, 99); + #[allow(dead_code)] + const GRAY_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(55, 65, 81); + #[allow(dead_code)] + const GRAY_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(31, 41, 55); + #[allow(dead_code)] + const GRAY_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(17, 24, 39); + }; + (ZINC) => { + #[allow(dead_code)] + const ZINC_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 250); + #[allow(dead_code)] + const ZINC_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 244, 245); + #[allow(dead_code)] + const ZINC_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(228, 228, 231); + #[allow(dead_code)] + const ZINC_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(212, 212, 216); + #[allow(dead_code)] + const ZINC_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(161, 161, 170); + #[allow(dead_code)] + const ZINC_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(113, 113, 122); + #[allow(dead_code)] + const ZINC_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(82, 82, 91); + #[allow(dead_code)] + const ZINC_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(63, 63, 70); + #[allow(dead_code)] + const ZINC_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(39, 39, 42); + #[allow(dead_code)] + const ZINC_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(24, 24, 27); + }; + (NEUTRAL) => { + #[allow(dead_code)] + const NEUTRAL_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 250); + #[allow(dead_code)] + const NEUTRAL_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 245, 245); + #[allow(dead_code)] + const NEUTRAL_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(229, 229, 229); + #[allow(dead_code)] + const NEUTRAL_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(212, 212, 212); + #[allow(dead_code)] + const NEUTRAL_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(163, 163, 163); + #[allow(dead_code)] + const NEUTRAL_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(115, 115, 115); + #[allow(dead_code)] + const NEUTRAL_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(82, 82, 82); + #[allow(dead_code)] + const NEUTRAL_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(64, 64, 64); + #[allow(dead_code)] + const NEUTRAL_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(38, 38, 38); + #[allow(dead_code)] + const NEUTRAL_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(23, 23, 23); + }; + (STONE) => { + #[allow(dead_code)] + const STONE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 249); + #[allow(dead_code)] + const STONE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 245, 244); + #[allow(dead_code)] + const STONE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(231, 229, 228); + #[allow(dead_code)] + const STONE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(214, 211, 209); + #[allow(dead_code)] + const STONE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(168, 162, 158); + #[allow(dead_code)] + const STONE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(120, 113, 108); + #[allow(dead_code)] + const STONE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(87, 83, 78); + #[allow(dead_code)] + const STONE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(68, 64, 60); + #[allow(dead_code)] + const STONE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(41, 37, 36); + #[allow(dead_code)] + const STONE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(28, 25, 23); + }; + (RED) => { + #[allow(dead_code)] + const RED_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 242, 242); + #[allow(dead_code)] + const RED_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 226, 226); + #[allow(dead_code)] + const RED_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 202, 202); + #[allow(dead_code)] + const RED_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 165, 165); + #[allow(dead_code)] + const RED_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 113, 113); + #[allow(dead_code)] + const RED_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(239, 68, 68); + #[allow(dead_code)] + const RED_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(220, 38, 38); + #[allow(dead_code)] + const RED_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(185, 28, 28); + #[allow(dead_code)] + const RED_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(153, 27, 27); + #[allow(dead_code)] + const RED_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(127, 29, 29); + }; + (ORANGE) => { + #[allow(dead_code)] + const ORANGE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 247, 237); + #[allow(dead_code)] + const ORANGE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 237, 213); + #[allow(dead_code)] + const ORANGE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 215, 170); + #[allow(dead_code)] + const ORANGE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 186, 116); + #[allow(dead_code)] + const ORANGE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 146, 60); + #[allow(dead_code)] + const ORANGE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 115, 22); + #[allow(dead_code)] + const ORANGE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(234, 88, 12); + #[allow(dead_code)] + const ORANGE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(194, 65, 12); + #[allow(dead_code)] + const ORANGE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(154, 52, 18); + #[allow(dead_code)] + const ORANGE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(124, 45, 18); + }; + (AMBER) => { + #[allow(dead_code)] + const AMBER_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 251, 235); + #[allow(dead_code)] + const AMBER_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 243, 199); + #[allow(dead_code)] + const AMBER_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 230, 138); + #[allow(dead_code)] + const AMBER_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 211, 77); + #[allow(dead_code)] + const AMBER_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 191, 36); + #[allow(dead_code)] + const AMBER_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 158, 11); + #[allow(dead_code)] + const AMBER_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 119, 6); + #[allow(dead_code)] + const AMBER_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(180, 83, 9); + #[allow(dead_code)] + const AMBER_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(146, 64, 14); + #[allow(dead_code)] + const AMBER_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(120, 53, 15); + }; + (YELLOW) => { + #[allow(dead_code)] + const YELLOW_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 252, 232); + #[allow(dead_code)] + const YELLOW_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 249, 195); + #[allow(dead_code)] + const YELLOW_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 240, 138); + #[allow(dead_code)] + const YELLOW_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 224, 71); + #[allow(dead_code)] + const YELLOW_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 204, 21); + #[allow(dead_code)] + const YELLOW_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(234, 179, 8); + #[allow(dead_code)] + const YELLOW_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(202, 138, 4); + #[allow(dead_code)] + const YELLOW_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(161, 98, 7); + #[allow(dead_code)] + const YELLOW_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(133, 77, 14); + #[allow(dead_code)] + const YELLOW_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(113, 63, 18); + }; + (LIME) => { + #[allow(dead_code)] + const LIME_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(247, 254, 231); + #[allow(dead_code)] + const LIME_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 252, 203); + #[allow(dead_code)] + const LIME_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 249, 157); + #[allow(dead_code)] + const LIME_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 242, 100); + #[allow(dead_code)] + const LIME_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(163, 230, 53); + #[allow(dead_code)] + const LIME_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(132, 204, 22); + #[allow(dead_code)] + const LIME_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(101, 163, 13); + #[allow(dead_code)] + const LIME_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(77, 124, 15); + #[allow(dead_code)] + const LIME_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(63, 98, 18); + #[allow(dead_code)] + const LIME_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(54, 83, 20); + }; + (GREEN) => { + #[allow(dead_code)] + const GREEN_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 253, 244); + #[allow(dead_code)] + const GREEN_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(220, 252, 231); + #[allow(dead_code)] + const GREEN_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(187, 247, 208); + #[allow(dead_code)] + const GREEN_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(134, 239, 172); + #[allow(dead_code)] + const GREEN_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(74, 222, 128); + #[allow(dead_code)] + const GREEN_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(34, 197, 94); + #[allow(dead_code)] + const GREEN_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 163, 74); + #[allow(dead_code)] + const GREEN_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(21, 128, 61); + #[allow(dead_code)] + const GREEN_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 101, 52); + #[allow(dead_code)] + const GREEN_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(20, 83, 45); + }; + (EMERALD) => { + #[allow(dead_code)] + const EMERALD_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 253, 245); + #[allow(dead_code)] + const EMERALD_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(209, 250, 229); + #[allow(dead_code)] + const EMERALD_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(167, 243, 208); + #[allow(dead_code)] + const EMERALD_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(110, 231, 183); + #[allow(dead_code)] + const EMERALD_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(52, 211, 153); + #[allow(dead_code)] + const EMERALD_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(16, 185, 129); + #[allow(dead_code)] + const EMERALD_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(5, 150, 105); + #[allow(dead_code)] + const EMERALD_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(4, 120, 87); + #[allow(dead_code)] + const EMERALD_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 95, 70); + #[allow(dead_code)] + const EMERALD_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 78, 59); + }; + (TEAL) => { + #[allow(dead_code)] + const TEAL_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 253, 250); + #[allow(dead_code)] + const TEAL_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(204, 251, 241); + #[allow(dead_code)] + const TEAL_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(153, 246, 228); + #[allow(dead_code)] + const TEAL_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(94, 234, 212); + #[allow(dead_code)] + const TEAL_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(45, 212, 191); + #[allow(dead_code)] + const TEAL_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(20, 184, 166); + #[allow(dead_code)] + const TEAL_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(13, 148, 136); + #[allow(dead_code)] + const TEAL_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 118, 110); + #[allow(dead_code)] + const TEAL_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(17, 94, 89); + #[allow(dead_code)] + const TEAL_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(19, 78, 74); + }; + (CYAN) => { + #[allow(dead_code)] + const CYAN_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 254, 255); + #[allow(dead_code)] + const CYAN_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(207, 250, 254); + #[allow(dead_code)] + const CYAN_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(165, 243, 252); + #[allow(dead_code)] + const CYAN_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(103, 232, 249); + #[allow(dead_code)] + const CYAN_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(34, 211, 238); + #[allow(dead_code)] + const CYAN_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 182, 212); + #[allow(dead_code)] + const CYAN_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(8, 145, 178); + #[allow(dead_code)] + const CYAN_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(14, 116, 144); + #[allow(dead_code)] + const CYAN_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(21, 94, 117); + #[allow(dead_code)] + const CYAN_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 78, 99); + }; + (SKY) => { + #[allow(dead_code)] + const SKY_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 249, 255); + #[allow(dead_code)] + const SKY_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(224, 242, 254); + #[allow(dead_code)] + const SKY_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(186, 230, 253); + #[allow(dead_code)] + const SKY_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(125, 211, 252); + #[allow(dead_code)] + const SKY_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(56, 189, 248); + #[allow(dead_code)] + const SKY_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(14, 165, 233); + #[allow(dead_code)] + const SKY_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(2, 132, 199); + #[allow(dead_code)] + const SKY_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(3, 105, 161); + #[allow(dead_code)] + const SKY_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(7, 89, 133); + #[allow(dead_code)] + const SKY_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(12, 74, 110); + }; + (BLUE) => { + #[allow(dead_code)] + const BLUE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(239, 246, 255); + #[allow(dead_code)] + const BLUE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(219, 234, 254); + #[allow(dead_code)] + const BLUE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(191, 219, 254); + #[allow(dead_code)] + const BLUE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(147, 197, 253); + #[allow(dead_code)] + const BLUE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(96, 165, 250); + #[allow(dead_code)] + const BLUE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(59, 130, 246); + #[allow(dead_code)] + const BLUE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(37, 99, 235); + #[allow(dead_code)] + const BLUE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(29, 78, 216); + #[allow(dead_code)] + const BLUE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 64, 175); + #[allow(dead_code)] + const BLUE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 58, 138); + }; + (INDIGO) => { + #[allow(dead_code)] + const INDIGO_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(238, 242, 255); + #[allow(dead_code)] + const INDIGO_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(224, 231, 255); + #[allow(dead_code)] + const INDIGO_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(199, 210, 254); + #[allow(dead_code)] + const INDIGO_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(165, 180, 252); + #[allow(dead_code)] + const INDIGO_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(129, 140, 248); + #[allow(dead_code)] + const INDIGO_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(99, 102, 241); + #[allow(dead_code)] + const INDIGO_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(79, 70, 229); + #[allow(dead_code)] + const INDIGO_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(67, 56, 202); + #[allow(dead_code)] + const INDIGO_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(55, 48, 163); + #[allow(dead_code)] + const INDIGO_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(49, 46, 129); + }; + (VIOLET) => { + #[allow(dead_code)] + const VIOLET_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 243, 255); + #[allow(dead_code)] + const VIOLET_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(237, 233, 254); + #[allow(dead_code)] + const VIOLET_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(221, 214, 254); + #[allow(dead_code)] + const VIOLET_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(196, 181, 253); + #[allow(dead_code)] + const VIOLET_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(167, 139, 250); + #[allow(dead_code)] + const VIOLET_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(139, 92, 246); + #[allow(dead_code)] + const VIOLET_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(124, 58, 237); + #[allow(dead_code)] + const VIOLET_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(109, 40, 217); + #[allow(dead_code)] + const VIOLET_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(91, 33, 182); + #[allow(dead_code)] + const VIOLET_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(76, 29, 149); + }; + (PURPLE) => { + #[allow(dead_code)] + const PURPLE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 245, 255); + #[allow(dead_code)] + const PURPLE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(243, 232, 255); + #[allow(dead_code)] + const PURPLE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(233, 213, 255); + #[allow(dead_code)] + const PURPLE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(216, 180, 254); + #[allow(dead_code)] + const PURPLE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(192, 132, 252); + #[allow(dead_code)] + const PURPLE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(168, 85, 247); + #[allow(dead_code)] + const PURPLE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(147, 51, 234); + #[allow(dead_code)] + const PURPLE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(126, 34, 206); + #[allow(dead_code)] + const PURPLE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(107, 33, 168); + #[allow(dead_code)] + const PURPLE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(88, 28, 135); + }; + (FUCHSIA) => { + #[allow(dead_code)] + const FUCHSIA_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 244, 255); + #[allow(dead_code)] + const FUCHSIA_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 232, 255); + #[allow(dead_code)] + const FUCHSIA_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 208, 254); + #[allow(dead_code)] + const FUCHSIA_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 171, 252); + #[allow(dead_code)] + const FUCHSIA_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(232, 121, 249); + #[allow(dead_code)] + const FUCHSIA_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 70, 239); + #[allow(dead_code)] + const FUCHSIA_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(192, 38, 211); + #[allow(dead_code)] + const FUCHSIA_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(162, 28, 175); + #[allow(dead_code)] + const FUCHSIA_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(134, 25, 143); + #[allow(dead_code)] + const FUCHSIA_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(112, 26, 117); + }; + (PINK) => { + #[allow(dead_code)] + const PINK_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 242, 248); + #[allow(dead_code)] + const PINK_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 231, 243); + #[allow(dead_code)] + const PINK_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 207, 232); + #[allow(dead_code)] + const PINK_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 168, 212); + #[allow(dead_code)] + const PINK_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 114, 182); + #[allow(dead_code)] + const PINK_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 72, 153); + #[allow(dead_code)] + const PINK_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(219, 39, 119); + #[allow(dead_code)] + const PINK_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 24, 93); + #[allow(dead_code)] + const PINK_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(157, 23, 77); + #[allow(dead_code)] + const PINK_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(131, 24, 67); + }; + (ROSE) => { + #[allow(dead_code)] + const ROSE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 241, 242); + #[allow(dead_code)] + const ROSE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 228, 230); + #[allow(dead_code)] + const ROSE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 205, 211); + #[allow(dead_code)] + const ROSE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 164, 175); + #[allow(dead_code)] + const ROSE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 113, 133); + #[allow(dead_code)] + const ROSE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 63, 94); + #[allow(dead_code)] + const ROSE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(225, 29, 72); + #[allow(dead_code)] + const ROSE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 18, 60); + #[allow(dead_code)] + const ROSE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(159, 18, 57); + #[allow(dead_code)] + const ROSE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(136, 19, 55); + }; +} + +#[cfg(test)] +mod tests { + + use ratatui::prelude::Color; + palette!(SLATE); + + #[test] + fn color_test() { + assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); + } +} diff --git a/src/layout.rs b/src/layout.rs new file mode 100644 index 00000000..4eb8c653 --- /dev/null +++ b/src/layout.rs @@ -0,0 +1,196 @@ +/// Creates a single constraint. +/// +/// If creating an array of constraints, you probably want to use +/// [`constraints!`] instead. +/// +/// # Examples +/// +/// ``` +/// use ratatui_macros::constraint; +/// use ratatui::prelude::Constraint; +/// assert_eq!(constraint!(>= 3 + 4), Constraint::Min(7)); +/// assert_eq!(constraint!(<= 3 + 4), Constraint::Max(7)); +/// assert_eq!(constraint!(== 1 / 3), Constraint::Ratio(1, 3)); +/// assert_eq!(constraint!(== 3), Constraint::Length(3)); +/// assert_eq!(constraint!(== 10 %), Constraint::Percentage(10)); +/// ``` +#[macro_export] +macro_rules! constraint { + ( == $token:tt % ) => { + ratatui::prelude::Constraint::Percentage($token) + }; + ( >= $expr:expr ) => { + ratatui::prelude::Constraint::Min($expr) + }; + ( <= $expr:expr ) => { + ratatui::prelude::Constraint::Max($expr) + }; + ( == $num:tt / $denom:tt ) => { + ratatui::prelude::Constraint::Ratio($num as u32, $denom as u32) + }; + ( == $expr:expr ) => { + ratatui::prelude::Constraint::Length($expr) + }; +} + +/// Creates an array of constraints. +/// +/// See [`constraint!`] for more information. +/// +/// If you want to solve the constraints, see +/// [`vertical!`] and [`horizontal!`] macros. +/// +/// # Examples +/// +/// ```rust +/// use ratatui_macros::constraints; +/// assert_eq!(constraints![==5, ==30%, >=3, <=1, ==1/2].len(), 5); +/// assert_eq!(constraints![==5; 5].len(), 5); +/// ``` +/// +/// ```rust +/// use ratatui::prelude::*; +/// use ratatui_macros::constraints; +/// assert_eq!( +/// constraints![==50, ==30%, >=3, <=1, ==1/2], +/// [ +/// Constraint::Length(50), +/// Constraint::Percentage(30), +/// Constraint::Min(3), +/// Constraint::Max(1), +/// Constraint::Ratio(1, 2), +/// ] +/// ) +/// ``` +#[macro_export] +macro_rules! constraints { + // Note: this implementation forgoes speed for the sake of simplicity. Adding variations of the + // comma and semicolon rules for each constraint type would be faster, but would result in a lot + // of duplicated code. + + // Cannot start the constraints macro with a , + ([ , $($rest:tt)* ] -> () []) => { + compile_error!("No rules expected the token `,` while trying to match the end of the macro") + }; + + // Comma finishes a constraint element, so parse it and continue. + // When a comma is encountered, it marks the end of a constraint element, so this rule is responsible + // for parsing the constraint expression up to the comma and continuing the parsing process. + // It accumulated the $partial contains a Constraint and is parsed using a separate $crate::constraint! macro. + // The constraint is then appended to the list of parsed constraints. + // + // [ , $($rest:tt)* ] -> In the rule matcher, this pattern matches a comma followed + // by the rest of the tokens. The comma signals the end of + // the current constraint element. + // ($($partial:tt)*) -> In the rule matcher, this contains the partial tokens + // accumulated so far for the current constraint element. + // [$($parsed:tt)* ] -> This contains the constraints that have been successfully + // parsed so far. + // $crate::constraint!($($partial)*) -> This macro call parses and expands the accumulated + // partial tokens into a single Constraint expression. + // [$($parsed)* $crate::constraint!(...)] -> Appends the newly parsed constraint to the list of + // already parsed constraints. + ([ , $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { + $crate::constraints!([$($rest)*] -> () [$($parsed)* $crate::constraint!($($partial)*) ,]) + }; + + // Semicolon indicates that there's repetition. The trailing comma is required because the 'entrypoint' + // rule adds a trailing comma. + // This rule is triggered when a semicolon is encountered, indicating that there is repetition of + // constraints. It handles the repetition logic by parsing the count and generating an array of + // constraints using the $crate::constraint! macro. + // + // [ ; $count:expr , ] -> In the rule matcher, this pattern matches a semicolon + // followed by an expression representing the count, and a + // trailing comma. + // ($($partial:tt)*) -> In the rule matcher, this contains the partial tokens + // accumulated so far for the current constraint element. + // This represents everything before the ; + // [] -> There will be no existed parsed constraints when using ; + // $crate::constraint!($($partial)*) -> This macro call parses and expands the accumulated + // partial tokens into a single Constraint expression. + // [$crate::constraint!(...) ; $count] -> Generates an array of constraints by repeating the + // parsed constraint count number of times. + ([ ; $count:expr , ] -> ($($partial:tt)*) []) => { + [$crate::constraint!($($partial)*); $count] + }; + + // Pull the first token (which can't be a comma or semicolon) onto the accumulator. + // if first token is a comma or semicolon, previous rules will match before this rule + // + // [ $head:tt $($rest:tt)* ] -> In the rule matcher, this pulls a single `head` token + // out of the previous rest, and puts + // the remaining into `rest` + // [ $($rest)* ] -> This is what is fed back into the `constraints!` macro + // as the first segment for the match rule + // + // ($($partial:tt)*) -> In the rule matcher, this contains previous partial + // tokens that will make up a `Constraint` expression + // ($($partial)* $head) -> This combines head with the previous partial tokens + // i.e. this is the accumulated tokens + // + // [ $($parsed:tt)* ] -> In the rule matcher, this contains all parsed exprs + // [$($parsed)* ] -> These are passed on to the next match untouched. + ([ $head:tt $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { + $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) + }; + + // This rule is triggered when there are no more input tokens to process. It signals the end of the + // macro invocation and outputs the parsed constraints as a final array. + ([$(,)?] -> () [ $( $parsed:tt )* ]) => { + [$($parsed)*] + }; + + // Entrypoint where there's no comma at the end. + // We add a comma to make sure there's always a trailing comma. + // Right-hand side will accumulate the actual `Constraint` literals. + ($( $constraint:tt )+) => { + $crate::constraints!([ $($constraint)+ , ] -> () []) + }; +} + +/// Creates a vertical layout with specified constraints. +/// +/// It accepts a series of constraints and applies them to create a vertical layout. The constraints +/// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. +/// +/// See [`constraint!`] or [`constraints!`] for more information. +/// +/// # Examples +/// +/// ``` +/// // Vertical layout with a fixed size and a percentage constraint +/// use ratatui_macros::vertical; +/// vertical![== 50, == 30%]; +/// ``` +#[macro_export] +macro_rules! vertical { + ($( $constraint:tt )+) => { + ratatui::prelude::Layout::default() + .direction(ratatui::prelude::Direction::Vertical) + .constraints($crate::constraints!( $($constraint)+ )) + }; +} + +/// Creates a horizontal layout with specified constraints. +/// +/// It takes a series of constraints and applies them to create a horizontal layout. The constraints +/// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. +/// +/// See [`constraint!`] or [`constraints!`] for more information. +/// +/// # Examples +/// +/// ``` +/// // Horizontal layout with a ratio constraint and a minimum size constraint +/// use ratatui_macros::horizontal; +/// horizontal![== 1/3, >= 100]; +/// ``` +#[macro_export] +macro_rules! horizontal { + ($( $constraint:tt )+) => { + ratatui::prelude::Layout::default() + .direction(ratatui::prelude::Direction::Horizontal) + .constraints($crate::constraints!( $($constraint)+ )) + }; +} diff --git a/src/lib.rs b/src/lib.rs index 0605b792..c88304aa 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,198 +1,4 @@ #![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))] -/// Creates a single constraint. -/// -/// If creating an array of constraints, you probably want to use -/// [`constraints!`] instead. -/// -/// # Examples -/// -/// ``` -/// use ratatui_macros::constraint; -/// use ratatui::prelude::Constraint; -/// assert_eq!(constraint!(>= 3 + 4), Constraint::Min(7)); -/// assert_eq!(constraint!(<= 3 + 4), Constraint::Max(7)); -/// assert_eq!(constraint!(== 1 / 3), Constraint::Ratio(1, 3)); -/// assert_eq!(constraint!(== 3), Constraint::Length(3)); -/// assert_eq!(constraint!(== 10 %), Constraint::Percentage(10)); -/// ``` -#[macro_export] -macro_rules! constraint { - ( == $token:tt % ) => { - ratatui::prelude::Constraint::Percentage($token) - }; - ( >= $expr:expr ) => { - ratatui::prelude::Constraint::Min($expr) - }; - ( <= $expr:expr ) => { - ratatui::prelude::Constraint::Max($expr) - }; - ( == $num:tt / $denom:tt ) => { - ratatui::prelude::Constraint::Ratio($num as u32, $denom as u32) - }; - ( == $expr:expr ) => { - ratatui::prelude::Constraint::Length($expr) - }; -} - -/// Creates an array of constraints. -/// -/// See [`constraint!`] for more information. -/// -/// If you want to solve the constraints, see -/// [`vertical!`] and [`horizontal!`] macros. -/// -/// # Examples -/// -/// ```rust -/// use ratatui_macros::constraints; -/// assert_eq!(constraints![==5, ==30%, >=3, <=1, ==1/2].len(), 5); -/// assert_eq!(constraints![==5; 5].len(), 5); -/// ``` -/// -/// ```rust -/// use ratatui::prelude::*; -/// use ratatui_macros::constraints; -/// assert_eq!( -/// constraints![==50, ==30%, >=3, <=1, ==1/2], -/// [ -/// Constraint::Length(50), -/// Constraint::Percentage(30), -/// Constraint::Min(3), -/// Constraint::Max(1), -/// Constraint::Ratio(1, 2), -/// ] -/// ) -/// ``` -#[macro_export] -macro_rules! constraints { - // Note: this implementation forgoes speed for the sake of simplicity. Adding variations of the - // comma and semicolon rules for each constraint type would be faster, but would result in a lot - // of duplicated code. - - // Cannot start the constraints macro with a , - ([ , $($rest:tt)* ] -> () []) => { - compile_error!("No rules expected the token `,` while trying to match the end of the macro") - }; - - // Comma finishes a constraint element, so parse it and continue. - // When a comma is encountered, it marks the end of a constraint element, so this rule is responsible - // for parsing the constraint expression up to the comma and continuing the parsing process. - // It accumulated the $partial contains a Constraint and is parsed using a separate $crate::constraint! macro. - // The constraint is then appended to the list of parsed constraints. - // - // [ , $($rest:tt)* ] -> In the rule matcher, this pattern matches a comma followed - // by the rest of the tokens. The comma signals the end of - // the current constraint element. - // ($($partial:tt)*) -> In the rule matcher, this contains the partial tokens - // accumulated so far for the current constraint element. - // [$($parsed:tt)* ] -> This contains the constraints that have been successfully - // parsed so far. - // $crate::constraint!($($partial)*) -> This macro call parses and expands the accumulated - // partial tokens into a single Constraint expression. - // [$($parsed)* $crate::constraint!(...)] -> Appends the newly parsed constraint to the list of - // already parsed constraints. - ([ , $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { - $crate::constraints!([$($rest)*] -> () [$($parsed)* $crate::constraint!($($partial)*) ,]) - }; - - // Semicolon indicates that there's repetition. The trailing comma is required because the 'entrypoint' - // rule adds a trailing comma. - // This rule is triggered when a semicolon is encountered, indicating that there is repetition of - // constraints. It handles the repetition logic by parsing the count and generating an array of - // constraints using the $crate::constraint! macro. - // - // [ ; $count:expr , ] -> In the rule matcher, this pattern matches a semicolon - // followed by an expression representing the count, and a - // trailing comma. - // ($($partial:tt)*) -> In the rule matcher, this contains the partial tokens - // accumulated so far for the current constraint element. - // This represents everything before the ; - // [] -> There will be no existed parsed constraints when using ; - // $crate::constraint!($($partial)*) -> This macro call parses and expands the accumulated - // partial tokens into a single Constraint expression. - // [$crate::constraint!(...) ; $count] -> Generates an array of constraints by repeating the - // parsed constraint count number of times. - ([ ; $count:expr , ] -> ($($partial:tt)*) []) => { - [$crate::constraint!($($partial)*); $count] - }; - - // Pull the first token (which can't be a comma or semicolon) onto the accumulator. - // if first token is a comma or semicolon, previous rules will match before this rule - // - // [ $head:tt $($rest:tt)* ] -> In the rule matcher, this pulls a single `head` token - // out of the previous rest, and puts - // the remaining into `rest` - // [ $($rest)* ] -> This is what is fed back into the `constraints!` macro - // as the first segment for the match rule - // - // ($($partial:tt)*) -> In the rule matcher, this contains previous partial - // tokens that will make up a `Constraint` expression - // ($($partial)* $head) -> This combines head with the previous partial tokens - // i.e. this is the accumulated tokens - // - // [ $($parsed:tt)* ] -> In the rule matcher, this contains all parsed exprs - // [$($parsed)* ] -> These are passed on to the next match untouched. - ([ $head:tt $($rest:tt)* ] -> ($($partial:tt)*) [ $($parsed:tt)* ]) => { - $crate::constraints!([$($rest)*] -> ($($partial)* $head) [$($parsed)* ]) - }; - - // This rule is triggered when there are no more input tokens to process. It signals the end of the - // macro invocation and outputs the parsed constraints as a final array. - ([$(,)?] -> () [ $( $parsed:tt )* ]) => { - [$($parsed)*] - }; - - // Entrypoint where there's no comma at the end. - // We add a comma to make sure there's always a trailing comma. - // Right-hand side will accumulate the actual `Constraint` literals. - ($( $constraint:tt )+) => { - $crate::constraints!([ $($constraint)+ , ] -> () []) - }; -} - -/// Creates a vertical layout with specified constraints. -/// -/// It accepts a series of constraints and applies them to create a vertical layout. The constraints -/// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. -/// -/// See [`constraint!`] or [`constraints!`] for more information. -/// -/// # Examples -/// -/// ``` -/// // Vertical layout with a fixed size and a percentage constraint -/// use ratatui_macros::vertical; -/// vertical![== 50, == 30%]; -/// ``` -#[macro_export] -macro_rules! vertical { - ($( $constraint:tt )+) => { - ratatui::prelude::Layout::default() - .direction(ratatui::prelude::Direction::Vertical) - .constraints($crate::constraints!( $($constraint)+ )) - }; -} - -/// Creates a horizontal layout with specified constraints. -/// -/// It takes a series of constraints and applies them to create a horizontal layout. The constraints -/// can include fixed sizes, minimum and maximum sizes, percentages, and ratios. -/// -/// See [`constraint!`] or [`constraints!`] for more information. -/// -/// # Examples -/// -/// ``` -/// // Horizontal layout with a ratio constraint and a minimum size constraint -/// use ratatui_macros::horizontal; -/// horizontal![== 1/3, >= 100]; -/// ``` -#[macro_export] -macro_rules! horizontal { - ($( $constraint:tt )+) => { - ratatui::prelude::Layout::default() - .direction(ratatui::prelude::Direction::Horizontal) - .constraints($crate::constraints!( $($constraint)+ )) - }; -} +mod color; +mod layout; diff --git a/tests/ui/fails.stderr b/tests/ui/fails.stderr index 2a5044c7..dcd56266 100644 --- a/tests/ui/fails.stderr +++ b/tests/ui/fails.stderr @@ -17,7 +17,7 @@ error: unexpected end of macro invocation | |___^ missing tokens in macro arguments | note: while trying to match `==` - --> src/lib.rs + --> src/layout.rs | | ( == $token:tt % ) => { | ^^ @@ -30,7 +30,7 @@ error: no rules expected the token `;` | ^ no rules expected this token in macro call | note: while trying to match `%` - --> src/lib.rs + --> src/layout.rs | | ( == $token:tt % ) => { | ^ From 4756526829a4e849d9e256b6cf821eb66afe3ade Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 13:22:12 -0500 Subject: [PATCH 042/109] =?UTF-8?q?build(release):=20Bump=20to=20v0.2.3=20?= =?UTF-8?q?=F0=9F=9B=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index c2fe25b4..bc23f098 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ratatui-macros" -version = "0.2.2" +version = "0.2.3" edition = "2021" authors = ["Dheepak Krishnamurthy"] description = "Macros for Ratatui" From 8f35437d5ad78d31cd45c4af888f20f0b5ab4196 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 13:33:55 -0500 Subject: [PATCH 043/109] =?UTF-8?q?feat:=20Add=20colors=20into=20keywords?= =?UTF-8?q?=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index bc23f098..6dfed507 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,7 +7,7 @@ description = "Macros for Ratatui" license = "MIT" # or any other appropriate license repository = "https://github.com/kdheepak/ratatui-macros" documentation = "https://docs.rs/ratatui-macros" -keywords = ["macros", "tui", "ui", "layout", "ratatui"] +keywords = ["ratatui", "macros", "tui", "ui", "layout", "colors"] categories = ["tui", "macro"] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html From 39bd72b1f702dadb1ebbaf4e77ad2fada166ac49 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 13:46:30 -0500 Subject: [PATCH 044/109] =?UTF-8?q?feat:=20Add=20pub=20visibility=20to=20c?= =?UTF-8?q?olor=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 24 +-- src/color.rs | 514 ++++++++++++++++++++++++++------------------------- 2 files changed, 271 insertions(+), 267 deletions(-) diff --git a/README.md b/README.md index 83185467..5cb6472c 100644 --- a/README.md +++ b/README.md @@ -42,25 +42,25 @@ default color palette. use ratatui::prelude::Color; use ratatui_macros::palette; -palette!(SLATE); +palette!(pub SLATE); assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); ``` -The `palette!(SLATE)` macro expands to the following: +The `palette!(pub SLATE)` macro expands to the following: ```rust use ratatui::prelude::Color; -const SLATE_50: Color = Color::Rgb(248, 250, 252); -const SLATE_100: Color = Color::Rgb(241, 245, 249); -const SLATE_200: Color = Color::Rgb(226, 232, 240); -const SLATE_300: Color = Color::Rgb(203, 213, 225); -const SLATE_400: Color = Color::Rgb(148, 163, 184); -const SLATE_500: Color = Color::Rgb(100, 116, 139); -const SLATE_600: Color = Color::Rgb(71, 85, 105); -const SLATE_700: Color = Color::Rgb(51, 65, 85); -const SLATE_800: Color = Color::Rgb(30, 41, 59); -const SLATE_900: Color = Color::Rgb(15, 23, 42); +pub const SLATE_50: Color = Color::Rgb(248, 250, 252); +pub const SLATE_100: Color = Color::Rgb(241, 245, 249); +pub const SLATE_200: Color = Color::Rgb(226, 232, 240); +pub const SLATE_300: Color = Color::Rgb(203, 213, 225); +pub const SLATE_400: Color = Color::Rgb(148, 163, 184); +pub const SLATE_500: Color = Color::Rgb(100, 116, 139); +pub const SLATE_600: Color = Color::Rgb(71, 85, 105); +pub const SLATE_700: Color = Color::Rgb(51, 65, 85); +pub const SLATE_800: Color = Color::Rgb(30, 41, 59); +pub const SLATE_900: Color = Color::Rgb(15, 23, 42); ``` ### Layout diff --git a/src/color.rs b/src/color.rs index c3668252..14202a66 100644 --- a/src/color.rs +++ b/src/color.rs @@ -35,7 +35,7 @@ /// use ratatui::prelude::Color; /// use ratatui_macros::palette; /// -/// palette!(SLATE); +/// palette!(pub SLATE); /// /// assert_eq!(SLATE_50, Color::Rgb(248, 250, 252)); /// assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); @@ -49,506 +49,506 @@ /// # color(); /// ``` /// -/// The `palette!(SLATE)` macro expands to the following: +/// The `palette!(pub SLATE)` macro expands to the following: /// /// ```rust /// # use ratatui::prelude::Color; -/// const SLATE_50: Color = Color::Rgb(248, 250, 252); -/// const SLATE_100: Color = Color::Rgb(241, 245, 249); -/// const SLATE_200: Color = Color::Rgb(226, 232, 240); -/// const SLATE_300: Color = Color::Rgb(203, 213, 225); -/// const SLATE_400: Color = Color::Rgb(148, 163, 184); -/// const SLATE_500: Color = Color::Rgb(100, 116, 139); -/// const SLATE_600: Color = Color::Rgb(71, 85, 105); -/// const SLATE_700: Color = Color::Rgb(51, 65, 85); -/// const SLATE_800: Color = Color::Rgb(30, 41, 59); -/// const SLATE_900: Color = Color::Rgb(15, 23, 42); +/// pub const SLATE_50: Color = Color::Rgb(248, 250, 252); +/// pub const SLATE_100: Color = Color::Rgb(241, 245, 249); +/// pub const SLATE_200: Color = Color::Rgb(226, 232, 240); +/// pub const SLATE_300: Color = Color::Rgb(203, 213, 225); +/// pub const SLATE_400: Color = Color::Rgb(148, 163, 184); +/// pub const SLATE_500: Color = Color::Rgb(100, 116, 139); +/// pub const SLATE_600: Color = Color::Rgb(71, 85, 105); +/// pub const SLATE_700: Color = Color::Rgb(51, 65, 85); +/// pub const SLATE_800: Color = Color::Rgb(30, 41, 59); +/// pub const SLATE_900: Color = Color::Rgb(15, 23, 42); /// ``` #[macro_export] macro_rules! palette { - (SLATE) => { + ($v:vis SLATE) => { #[allow(dead_code)] - const SLATE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 250, 252); + $v const SLATE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 250, 252); #[allow(dead_code)] - const SLATE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(241, 245, 249); + $v const SLATE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(241, 245, 249); #[allow(dead_code)] - const SLATE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(226, 232, 240); + $v const SLATE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(226, 232, 240); #[allow(dead_code)] - const SLATE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(203, 213, 225); + $v const SLATE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(203, 213, 225); #[allow(dead_code)] - const SLATE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(148, 163, 184); + $v const SLATE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(148, 163, 184); #[allow(dead_code)] - const SLATE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(100, 116, 139); + $v const SLATE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(100, 116, 139); #[allow(dead_code)] - const SLATE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(71, 85, 105); + $v const SLATE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(71, 85, 105); #[allow(dead_code)] - const SLATE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(51, 65, 85); + $v const SLATE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(51, 65, 85); #[allow(dead_code)] - const SLATE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 41, 59); + $v const SLATE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 41, 59); #[allow(dead_code)] - const SLATE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 23, 42); + $v const SLATE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 23, 42); }; - (GRAY) => { + ($v:vis GRAY) => { #[allow(dead_code)] - const GRAY_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 250, 251); + $v const GRAY_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 250, 251); #[allow(dead_code)] - const GRAY_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(243, 244, 246); + $v const GRAY_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(243, 244, 246); #[allow(dead_code)] - const GRAY_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(229, 231, 235); + $v const GRAY_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(229, 231, 235); #[allow(dead_code)] - const GRAY_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(209, 213, 219); + $v const GRAY_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(209, 213, 219); #[allow(dead_code)] - const GRAY_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(156, 163, 175); + $v const GRAY_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(156, 163, 175); #[allow(dead_code)] - const GRAY_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(107, 114, 128); + $v const GRAY_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(107, 114, 128); #[allow(dead_code)] - const GRAY_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(75, 85, 99); + $v const GRAY_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(75, 85, 99); #[allow(dead_code)] - const GRAY_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(55, 65, 81); + $v const GRAY_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(55, 65, 81); #[allow(dead_code)] - const GRAY_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(31, 41, 55); + $v const GRAY_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(31, 41, 55); #[allow(dead_code)] - const GRAY_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(17, 24, 39); + $v const GRAY_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(17, 24, 39); }; - (ZINC) => { + ($v:vis ZINC) => { #[allow(dead_code)] - const ZINC_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 250); + $v const ZINC_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 250); #[allow(dead_code)] - const ZINC_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 244, 245); + $v const ZINC_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 244, 245); #[allow(dead_code)] - const ZINC_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(228, 228, 231); + $v const ZINC_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(228, 228, 231); #[allow(dead_code)] - const ZINC_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(212, 212, 216); + $v const ZINC_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(212, 212, 216); #[allow(dead_code)] - const ZINC_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(161, 161, 170); + $v const ZINC_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(161, 161, 170); #[allow(dead_code)] - const ZINC_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(113, 113, 122); + $v const ZINC_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(113, 113, 122); #[allow(dead_code)] - const ZINC_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(82, 82, 91); + $v const ZINC_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(82, 82, 91); #[allow(dead_code)] - const ZINC_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(63, 63, 70); + $v const ZINC_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(63, 63, 70); #[allow(dead_code)] - const ZINC_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(39, 39, 42); + $v const ZINC_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(39, 39, 42); #[allow(dead_code)] - const ZINC_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(24, 24, 27); + $v const ZINC_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(24, 24, 27); }; - (NEUTRAL) => { + ($v:vis NEUTRAL) => { #[allow(dead_code)] - const NEUTRAL_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 250); + $v const NEUTRAL_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 250); #[allow(dead_code)] - const NEUTRAL_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 245, 245); + $v const NEUTRAL_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 245, 245); #[allow(dead_code)] - const NEUTRAL_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(229, 229, 229); + $v const NEUTRAL_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(229, 229, 229); #[allow(dead_code)] - const NEUTRAL_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(212, 212, 212); + $v const NEUTRAL_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(212, 212, 212); #[allow(dead_code)] - const NEUTRAL_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(163, 163, 163); + $v const NEUTRAL_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(163, 163, 163); #[allow(dead_code)] - const NEUTRAL_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(115, 115, 115); + $v const NEUTRAL_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(115, 115, 115); #[allow(dead_code)] - const NEUTRAL_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(82, 82, 82); + $v const NEUTRAL_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(82, 82, 82); #[allow(dead_code)] - const NEUTRAL_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(64, 64, 64); + $v const NEUTRAL_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(64, 64, 64); #[allow(dead_code)] - const NEUTRAL_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(38, 38, 38); + $v const NEUTRAL_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(38, 38, 38); #[allow(dead_code)] - const NEUTRAL_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(23, 23, 23); + $v const NEUTRAL_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(23, 23, 23); }; - (STONE) => { + ($v:vis STONE) => { #[allow(dead_code)] - const STONE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 249); + $v const STONE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 250, 249); #[allow(dead_code)] - const STONE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 245, 244); + $v const STONE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 245, 244); #[allow(dead_code)] - const STONE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(231, 229, 228); + $v const STONE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(231, 229, 228); #[allow(dead_code)] - const STONE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(214, 211, 209); + $v const STONE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(214, 211, 209); #[allow(dead_code)] - const STONE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(168, 162, 158); + $v const STONE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(168, 162, 158); #[allow(dead_code)] - const STONE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(120, 113, 108); + $v const STONE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(120, 113, 108); #[allow(dead_code)] - const STONE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(87, 83, 78); + $v const STONE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(87, 83, 78); #[allow(dead_code)] - const STONE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(68, 64, 60); + $v const STONE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(68, 64, 60); #[allow(dead_code)] - const STONE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(41, 37, 36); + $v const STONE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(41, 37, 36); #[allow(dead_code)] - const STONE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(28, 25, 23); + $v const STONE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(28, 25, 23); }; - (RED) => { + ($v:vis RED) => { #[allow(dead_code)] - const RED_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 242, 242); + $v const RED_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 242, 242); #[allow(dead_code)] - const RED_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 226, 226); + $v const RED_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 226, 226); #[allow(dead_code)] - const RED_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 202, 202); + $v const RED_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 202, 202); #[allow(dead_code)] - const RED_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 165, 165); + $v const RED_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 165, 165); #[allow(dead_code)] - const RED_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 113, 113); + $v const RED_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 113, 113); #[allow(dead_code)] - const RED_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(239, 68, 68); + $v const RED_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(239, 68, 68); #[allow(dead_code)] - const RED_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(220, 38, 38); + $v const RED_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(220, 38, 38); #[allow(dead_code)] - const RED_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(185, 28, 28); + $v const RED_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(185, 28, 28); #[allow(dead_code)] - const RED_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(153, 27, 27); + $v const RED_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(153, 27, 27); #[allow(dead_code)] - const RED_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(127, 29, 29); + $v const RED_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(127, 29, 29); }; - (ORANGE) => { + ($v:vis ORANGE) => { #[allow(dead_code)] - const ORANGE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 247, 237); + $v const ORANGE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 247, 237); #[allow(dead_code)] - const ORANGE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 237, 213); + $v const ORANGE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 237, 213); #[allow(dead_code)] - const ORANGE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 215, 170); + $v const ORANGE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 215, 170); #[allow(dead_code)] - const ORANGE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 186, 116); + $v const ORANGE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 186, 116); #[allow(dead_code)] - const ORANGE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 146, 60); + $v const ORANGE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 146, 60); #[allow(dead_code)] - const ORANGE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 115, 22); + $v const ORANGE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 115, 22); #[allow(dead_code)] - const ORANGE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(234, 88, 12); + $v const ORANGE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(234, 88, 12); #[allow(dead_code)] - const ORANGE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(194, 65, 12); + $v const ORANGE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(194, 65, 12); #[allow(dead_code)] - const ORANGE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(154, 52, 18); + $v const ORANGE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(154, 52, 18); #[allow(dead_code)] - const ORANGE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(124, 45, 18); + $v const ORANGE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(124, 45, 18); }; - (AMBER) => { + ($v:vis AMBER) => { #[allow(dead_code)] - const AMBER_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 251, 235); + $v const AMBER_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 251, 235); #[allow(dead_code)] - const AMBER_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 243, 199); + $v const AMBER_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 243, 199); #[allow(dead_code)] - const AMBER_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 230, 138); + $v const AMBER_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 230, 138); #[allow(dead_code)] - const AMBER_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 211, 77); + $v const AMBER_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 211, 77); #[allow(dead_code)] - const AMBER_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 191, 36); + $v const AMBER_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 191, 36); #[allow(dead_code)] - const AMBER_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 158, 11); + $v const AMBER_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 158, 11); #[allow(dead_code)] - const AMBER_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 119, 6); + $v const AMBER_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 119, 6); #[allow(dead_code)] - const AMBER_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(180, 83, 9); + $v const AMBER_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(180, 83, 9); #[allow(dead_code)] - const AMBER_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(146, 64, 14); + $v const AMBER_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(146, 64, 14); #[allow(dead_code)] - const AMBER_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(120, 53, 15); + $v const AMBER_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(120, 53, 15); }; - (YELLOW) => { + ($v:vis YELLOW) => { #[allow(dead_code)] - const YELLOW_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 252, 232); + $v const YELLOW_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 252, 232); #[allow(dead_code)] - const YELLOW_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 249, 195); + $v const YELLOW_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 249, 195); #[allow(dead_code)] - const YELLOW_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 240, 138); + $v const YELLOW_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 240, 138); #[allow(dead_code)] - const YELLOW_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 224, 71); + $v const YELLOW_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 224, 71); #[allow(dead_code)] - const YELLOW_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 204, 21); + $v const YELLOW_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 204, 21); #[allow(dead_code)] - const YELLOW_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(234, 179, 8); + $v const YELLOW_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(234, 179, 8); #[allow(dead_code)] - const YELLOW_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(202, 138, 4); + $v const YELLOW_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(202, 138, 4); #[allow(dead_code)] - const YELLOW_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(161, 98, 7); + $v const YELLOW_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(161, 98, 7); #[allow(dead_code)] - const YELLOW_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(133, 77, 14); + $v const YELLOW_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(133, 77, 14); #[allow(dead_code)] - const YELLOW_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(113, 63, 18); + $v const YELLOW_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(113, 63, 18); }; - (LIME) => { + ($v:vis LIME) => { #[allow(dead_code)] - const LIME_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(247, 254, 231); + $v const LIME_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(247, 254, 231); #[allow(dead_code)] - const LIME_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 252, 203); + $v const LIME_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 252, 203); #[allow(dead_code)] - const LIME_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 249, 157); + $v const LIME_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 249, 157); #[allow(dead_code)] - const LIME_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 242, 100); + $v const LIME_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 242, 100); #[allow(dead_code)] - const LIME_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(163, 230, 53); + $v const LIME_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(163, 230, 53); #[allow(dead_code)] - const LIME_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(132, 204, 22); + $v const LIME_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(132, 204, 22); #[allow(dead_code)] - const LIME_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(101, 163, 13); + $v const LIME_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(101, 163, 13); #[allow(dead_code)] - const LIME_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(77, 124, 15); + $v const LIME_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(77, 124, 15); #[allow(dead_code)] - const LIME_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(63, 98, 18); + $v const LIME_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(63, 98, 18); #[allow(dead_code)] - const LIME_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(54, 83, 20); + $v const LIME_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(54, 83, 20); }; - (GREEN) => { + ($v:vis GREEN) => { #[allow(dead_code)] - const GREEN_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 253, 244); + $v const GREEN_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 253, 244); #[allow(dead_code)] - const GREEN_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(220, 252, 231); + $v const GREEN_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(220, 252, 231); #[allow(dead_code)] - const GREEN_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(187, 247, 208); + $v const GREEN_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(187, 247, 208); #[allow(dead_code)] - const GREEN_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(134, 239, 172); + $v const GREEN_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(134, 239, 172); #[allow(dead_code)] - const GREEN_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(74, 222, 128); + $v const GREEN_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(74, 222, 128); #[allow(dead_code)] - const GREEN_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(34, 197, 94); + $v const GREEN_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(34, 197, 94); #[allow(dead_code)] - const GREEN_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 163, 74); + $v const GREEN_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 163, 74); #[allow(dead_code)] - const GREEN_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(21, 128, 61); + $v const GREEN_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(21, 128, 61); #[allow(dead_code)] - const GREEN_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 101, 52); + $v const GREEN_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 101, 52); #[allow(dead_code)] - const GREEN_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(20, 83, 45); + $v const GREEN_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(20, 83, 45); }; - (EMERALD) => { + ($v:vis EMERALD) => { #[allow(dead_code)] - const EMERALD_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 253, 245); + $v const EMERALD_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 253, 245); #[allow(dead_code)] - const EMERALD_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(209, 250, 229); + $v const EMERALD_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(209, 250, 229); #[allow(dead_code)] - const EMERALD_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(167, 243, 208); + $v const EMERALD_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(167, 243, 208); #[allow(dead_code)] - const EMERALD_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(110, 231, 183); + $v const EMERALD_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(110, 231, 183); #[allow(dead_code)] - const EMERALD_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(52, 211, 153); + $v const EMERALD_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(52, 211, 153); #[allow(dead_code)] - const EMERALD_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(16, 185, 129); + $v const EMERALD_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(16, 185, 129); #[allow(dead_code)] - const EMERALD_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(5, 150, 105); + $v const EMERALD_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(5, 150, 105); #[allow(dead_code)] - const EMERALD_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(4, 120, 87); + $v const EMERALD_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(4, 120, 87); #[allow(dead_code)] - const EMERALD_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 95, 70); + $v const EMERALD_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 95, 70); #[allow(dead_code)] - const EMERALD_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 78, 59); + $v const EMERALD_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 78, 59); }; - (TEAL) => { + ($v:vis TEAL) => { #[allow(dead_code)] - const TEAL_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 253, 250); + $v const TEAL_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 253, 250); #[allow(dead_code)] - const TEAL_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(204, 251, 241); + $v const TEAL_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(204, 251, 241); #[allow(dead_code)] - const TEAL_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(153, 246, 228); + $v const TEAL_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(153, 246, 228); #[allow(dead_code)] - const TEAL_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(94, 234, 212); + $v const TEAL_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(94, 234, 212); #[allow(dead_code)] - const TEAL_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(45, 212, 191); + $v const TEAL_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(45, 212, 191); #[allow(dead_code)] - const TEAL_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(20, 184, 166); + $v const TEAL_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(20, 184, 166); #[allow(dead_code)] - const TEAL_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(13, 148, 136); + $v const TEAL_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(13, 148, 136); #[allow(dead_code)] - const TEAL_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 118, 110); + $v const TEAL_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 118, 110); #[allow(dead_code)] - const TEAL_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(17, 94, 89); + $v const TEAL_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(17, 94, 89); #[allow(dead_code)] - const TEAL_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(19, 78, 74); + $v const TEAL_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(19, 78, 74); }; - (CYAN) => { + ($v:vis CYAN) => { #[allow(dead_code)] - const CYAN_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 254, 255); + $v const CYAN_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 254, 255); #[allow(dead_code)] - const CYAN_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(207, 250, 254); + $v const CYAN_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(207, 250, 254); #[allow(dead_code)] - const CYAN_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(165, 243, 252); + $v const CYAN_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(165, 243, 252); #[allow(dead_code)] - const CYAN_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(103, 232, 249); + $v const CYAN_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(103, 232, 249); #[allow(dead_code)] - const CYAN_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(34, 211, 238); + $v const CYAN_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(34, 211, 238); #[allow(dead_code)] - const CYAN_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 182, 212); + $v const CYAN_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(6, 182, 212); #[allow(dead_code)] - const CYAN_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(8, 145, 178); + $v const CYAN_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(8, 145, 178); #[allow(dead_code)] - const CYAN_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(14, 116, 144); + $v const CYAN_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(14, 116, 144); #[allow(dead_code)] - const CYAN_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(21, 94, 117); + $v const CYAN_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(21, 94, 117); #[allow(dead_code)] - const CYAN_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 78, 99); + $v const CYAN_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(22, 78, 99); }; - (SKY) => { + ($v:vis SKY) => { #[allow(dead_code)] - const SKY_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 249, 255); + $v const SKY_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 249, 255); #[allow(dead_code)] - const SKY_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(224, 242, 254); + $v const SKY_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(224, 242, 254); #[allow(dead_code)] - const SKY_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(186, 230, 253); + $v const SKY_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(186, 230, 253); #[allow(dead_code)] - const SKY_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(125, 211, 252); + $v const SKY_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(125, 211, 252); #[allow(dead_code)] - const SKY_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(56, 189, 248); + $v const SKY_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(56, 189, 248); #[allow(dead_code)] - const SKY_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(14, 165, 233); + $v const SKY_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(14, 165, 233); #[allow(dead_code)] - const SKY_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(2, 132, 199); + $v const SKY_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(2, 132, 199); #[allow(dead_code)] - const SKY_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(3, 105, 161); + $v const SKY_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(3, 105, 161); #[allow(dead_code)] - const SKY_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(7, 89, 133); + $v const SKY_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(7, 89, 133); #[allow(dead_code)] - const SKY_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(12, 74, 110); + $v const SKY_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(12, 74, 110); }; - (BLUE) => { + ($v:vis BLUE) => { #[allow(dead_code)] - const BLUE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(239, 246, 255); + $v const BLUE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(239, 246, 255); #[allow(dead_code)] - const BLUE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(219, 234, 254); + $v const BLUE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(219, 234, 254); #[allow(dead_code)] - const BLUE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(191, 219, 254); + $v const BLUE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(191, 219, 254); #[allow(dead_code)] - const BLUE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(147, 197, 253); + $v const BLUE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(147, 197, 253); #[allow(dead_code)] - const BLUE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(96, 165, 250); + $v const BLUE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(96, 165, 250); #[allow(dead_code)] - const BLUE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(59, 130, 246); + $v const BLUE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(59, 130, 246); #[allow(dead_code)] - const BLUE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(37, 99, 235); + $v const BLUE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(37, 99, 235); #[allow(dead_code)] - const BLUE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(29, 78, 216); + $v const BLUE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(29, 78, 216); #[allow(dead_code)] - const BLUE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 64, 175); + $v const BLUE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 64, 175); #[allow(dead_code)] - const BLUE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 58, 138); + $v const BLUE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 58, 138); }; - (INDIGO) => { + ($v:vis INDIGO) => { #[allow(dead_code)] - const INDIGO_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(238, 242, 255); + $v const INDIGO_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(238, 242, 255); #[allow(dead_code)] - const INDIGO_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(224, 231, 255); + $v const INDIGO_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(224, 231, 255); #[allow(dead_code)] - const INDIGO_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(199, 210, 254); + $v const INDIGO_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(199, 210, 254); #[allow(dead_code)] - const INDIGO_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(165, 180, 252); + $v const INDIGO_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(165, 180, 252); #[allow(dead_code)] - const INDIGO_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(129, 140, 248); + $v const INDIGO_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(129, 140, 248); #[allow(dead_code)] - const INDIGO_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(99, 102, 241); + $v const INDIGO_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(99, 102, 241); #[allow(dead_code)] - const INDIGO_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(79, 70, 229); + $v const INDIGO_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(79, 70, 229); #[allow(dead_code)] - const INDIGO_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(67, 56, 202); + $v const INDIGO_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(67, 56, 202); #[allow(dead_code)] - const INDIGO_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(55, 48, 163); + $v const INDIGO_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(55, 48, 163); #[allow(dead_code)] - const INDIGO_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(49, 46, 129); + $v const INDIGO_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(49, 46, 129); }; - (VIOLET) => { + ($v:vis VIOLET) => { #[allow(dead_code)] - const VIOLET_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 243, 255); + $v const VIOLET_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 243, 255); #[allow(dead_code)] - const VIOLET_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(237, 233, 254); + $v const VIOLET_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(237, 233, 254); #[allow(dead_code)] - const VIOLET_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(221, 214, 254); + $v const VIOLET_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(221, 214, 254); #[allow(dead_code)] - const VIOLET_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(196, 181, 253); + $v const VIOLET_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(196, 181, 253); #[allow(dead_code)] - const VIOLET_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(167, 139, 250); + $v const VIOLET_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(167, 139, 250); #[allow(dead_code)] - const VIOLET_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(139, 92, 246); + $v const VIOLET_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(139, 92, 246); #[allow(dead_code)] - const VIOLET_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(124, 58, 237); + $v const VIOLET_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(124, 58, 237); #[allow(dead_code)] - const VIOLET_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(109, 40, 217); + $v const VIOLET_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(109, 40, 217); #[allow(dead_code)] - const VIOLET_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(91, 33, 182); + $v const VIOLET_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(91, 33, 182); #[allow(dead_code)] - const VIOLET_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(76, 29, 149); + $v const VIOLET_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(76, 29, 149); }; - (PURPLE) => { + ($v:vis PURPLE) => { #[allow(dead_code)] - const PURPLE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 245, 255); + $v const PURPLE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 245, 255); #[allow(dead_code)] - const PURPLE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(243, 232, 255); + $v const PURPLE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(243, 232, 255); #[allow(dead_code)] - const PURPLE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(233, 213, 255); + $v const PURPLE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(233, 213, 255); #[allow(dead_code)] - const PURPLE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(216, 180, 254); + $v const PURPLE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(216, 180, 254); #[allow(dead_code)] - const PURPLE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(192, 132, 252); + $v const PURPLE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(192, 132, 252); #[allow(dead_code)] - const PURPLE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(168, 85, 247); + $v const PURPLE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(168, 85, 247); #[allow(dead_code)] - const PURPLE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(147, 51, 234); + $v const PURPLE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(147, 51, 234); #[allow(dead_code)] - const PURPLE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(126, 34, 206); + $v const PURPLE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(126, 34, 206); #[allow(dead_code)] - const PURPLE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(107, 33, 168); + $v const PURPLE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(107, 33, 168); #[allow(dead_code)] - const PURPLE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(88, 28, 135); + $v const PURPLE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(88, 28, 135); }; - (FUCHSIA) => { + ($v:vis FUCHSIA) => { #[allow(dead_code)] - const FUCHSIA_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 244, 255); + $v const FUCHSIA_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 244, 255); #[allow(dead_code)] - const FUCHSIA_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 232, 255); + $v const FUCHSIA_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(250, 232, 255); #[allow(dead_code)] - const FUCHSIA_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 208, 254); + $v const FUCHSIA_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(245, 208, 254); #[allow(dead_code)] - const FUCHSIA_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 171, 252); + $v const FUCHSIA_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(240, 171, 252); #[allow(dead_code)] - const FUCHSIA_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(232, 121, 249); + $v const FUCHSIA_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(232, 121, 249); #[allow(dead_code)] - const FUCHSIA_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 70, 239); + $v const FUCHSIA_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(217, 70, 239); #[allow(dead_code)] - const FUCHSIA_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(192, 38, 211); + $v const FUCHSIA_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(192, 38, 211); #[allow(dead_code)] - const FUCHSIA_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(162, 28, 175); + $v const FUCHSIA_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(162, 28, 175); #[allow(dead_code)] - const FUCHSIA_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(134, 25, 143); + $v const FUCHSIA_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(134, 25, 143); #[allow(dead_code)] - const FUCHSIA_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(112, 26, 117); + $v const FUCHSIA_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(112, 26, 117); }; - (PINK) => { + ($v:vis PINK) => { #[allow(dead_code)] - const PINK_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 242, 248); + $v const PINK_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 242, 248); #[allow(dead_code)] - const PINK_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 231, 243); + $v const PINK_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(252, 231, 243); #[allow(dead_code)] - const PINK_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 207, 232); + $v const PINK_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 207, 232); #[allow(dead_code)] - const PINK_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 168, 212); + $v const PINK_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(249, 168, 212); #[allow(dead_code)] - const PINK_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 114, 182); + $v const PINK_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 114, 182); #[allow(dead_code)] - const PINK_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 72, 153); + $v const PINK_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(236, 72, 153); #[allow(dead_code)] - const PINK_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(219, 39, 119); + $v const PINK_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(219, 39, 119); #[allow(dead_code)] - const PINK_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 24, 93); + $v const PINK_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 24, 93); #[allow(dead_code)] - const PINK_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(157, 23, 77); + $v const PINK_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(157, 23, 77); #[allow(dead_code)] - const PINK_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(131, 24, 67); + $v const PINK_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(131, 24, 67); }; - (ROSE) => { + ($v:vis ROSE) => { #[allow(dead_code)] - const ROSE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 241, 242); + $v const ROSE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 241, 242); #[allow(dead_code)] - const ROSE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 228, 230); + $v const ROSE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(255, 228, 230); #[allow(dead_code)] - const ROSE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 205, 211); + $v const ROSE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(254, 205, 211); #[allow(dead_code)] - const ROSE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 164, 175); + $v const ROSE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(253, 164, 175); #[allow(dead_code)] - const ROSE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 113, 133); + $v const ROSE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(251, 113, 133); #[allow(dead_code)] - const ROSE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 63, 94); + $v const ROSE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(244, 63, 94); #[allow(dead_code)] - const ROSE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(225, 29, 72); + $v const ROSE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(225, 29, 72); #[allow(dead_code)] - const ROSE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 18, 60); + $v const ROSE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(190, 18, 60); #[allow(dead_code)] - const ROSE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(159, 18, 57); + $v const ROSE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(159, 18, 57); #[allow(dead_code)] - const ROSE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(136, 19, 55); + $v const ROSE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(136, 19, 55); }; } @@ -556,10 +556,14 @@ macro_rules! palette { mod tests { use ratatui::prelude::Color; - palette!(SLATE); + palette!(pub SLATE); #[test] fn color_test() { assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); + + palette!(RED); + + assert_eq!(RED_900, Color::Rgb(127, 29, 29)); } } From bd90e3d928e0f9f0b915933ebbc32c2256fe8cfa Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 13:53:08 -0500 Subject: [PATCH 045/109] =?UTF-8?q?build(release):=20Bump=20to=20v0.2.4=20?= =?UTF-8?q?=F0=9F=9B=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 6dfed507..fbc3cb7d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ratatui-macros" -version = "0.2.3" +version = "0.2.4" edition = "2021" authors = ["Dheepak Krishnamurthy"] description = "Macros for Ratatui" From b820c0c7e4c576c1e39b5e482a8aac08076a039c Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 13:53:33 -0500 Subject: [PATCH 046/109] =?UTF-8?q?docs:=20Update=20README.md=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 5cb6472c..e50d0303 100644 --- a/README.md +++ b/README.md @@ -107,7 +107,8 @@ use ratatui::prelude::*; use ratatui_macros::constraint; assert_eq!( - constraint!(==50), Constraint::Length(50), + constraint!(==50), + Constraint::Length(50), ) ``` From 74194759756bb111b4da3e9a5cdb968275a2fab0 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 13:54:09 -0500 Subject: [PATCH 047/109] =?UTF-8?q?docs:=20Update=20README.md=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index e50d0303..62b2768d 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,13 @@ cargo add ratatui-macros Then, import the macros in your Rust file: ```rust -use ratatui_macros::{constraints, constraint, vertical, horizontal, palette}; +use ratatui_macros::{ + constraint, + constraints, + horizontal, + palette + vertical, +}; ``` ### Color From 38b2f27efe0e1829bc503df7fd64b94b7bb80d97 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 13:54:31 -0500 Subject: [PATCH 048/109] =?UTF-8?q?docs:=20Update=20README.md=20?= =?UTF-8?q?=F0=9F=93=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 62b2768d..e5b0c52e 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ use ratatui_macros::{ constraint, constraints, horizontal, - palette + palette, vertical, }; ``` From 21aa3232d762d6e3f81f15fc5b66ba462385ac05 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 15:01:08 -0500 Subject: [PATCH 049/109] =?UTF-8?q?feat:=20Remove=20keywords=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index fbc3cb7d..d98f9e98 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,7 +7,7 @@ description = "Macros for Ratatui" license = "MIT" # or any other appropriate license repository = "https://github.com/kdheepak/ratatui-macros" documentation = "https://docs.rs/ratatui-macros" -keywords = ["ratatui", "macros", "tui", "ui", "layout", "colors"] +keywords = ["ratatui", "macros", "tui", "ui"] categories = ["tui", "macro"] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html From 903bb0ae32d22393783edfda96db900739864f0a Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Tue, 9 Jan 2024 15:17:17 -0500 Subject: [PATCH 050/109] docs: Add link to ratatui --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e5b0c52e..cb8aef0e 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ [![Downloads](https://img.shields.io/crates/d/ratatui-macros)](https://crates.io/crates/ratatui-macros) `ratatui-macros` is a Rust crate that provides easy-to-use macros for simplifying boilerplate -associated with creating UI using ratatui. +associated with creating UI using [Ratatui](https://github.com/ratatui-org/ratatui). ## Features From 5cee13ab6d9c49751cf9283d9099e37f0cc3632c Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Wed, 10 Jan 2024 10:51:55 -0500 Subject: [PATCH 051/109] docs: Update README.md --- README.md | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index cb8aef0e..b6cf1063 100644 --- a/README.md +++ b/README.md @@ -56,17 +56,16 @@ assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); The `palette!(pub SLATE)` macro expands to the following: ```rust -use ratatui::prelude::Color; -pub const SLATE_50: Color = Color::Rgb(248, 250, 252); -pub const SLATE_100: Color = Color::Rgb(241, 245, 249); -pub const SLATE_200: Color = Color::Rgb(226, 232, 240); -pub const SLATE_300: Color = Color::Rgb(203, 213, 225); -pub const SLATE_400: Color = Color::Rgb(148, 163, 184); -pub const SLATE_500: Color = Color::Rgb(100, 116, 139); -pub const SLATE_600: Color = Color::Rgb(71, 85, 105); -pub const SLATE_700: Color = Color::Rgb(51, 65, 85); -pub const SLATE_800: Color = Color::Rgb(30, 41, 59); -pub const SLATE_900: Color = Color::Rgb(15, 23, 42); +pub const SLATE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 250, 252); +pub const SLATE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(241, 245, 249); +pub const SLATE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(226, 232, 240); +pub const SLATE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(203, 213, 225); +pub const SLATE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(148, 163, 184); +pub const SLATE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(100, 116, 139); +pub const SLATE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(71, 85, 105); +pub const SLATE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(51, 65, 85); +pub const SLATE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 41, 59); +pub const SLATE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 23, 42); ``` ### Layout From 0a0997702dd4cf2217160f5652f5c39cbd4a1010 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Wed, 10 Jan 2024 10:57:41 -0500 Subject: [PATCH 052/109] docs: Update README.md --- README.md | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index b6cf1063..daa2fbc0 100644 --- a/README.md +++ b/README.md @@ -53,19 +53,20 @@ palette!(pub SLATE); assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); ``` -The `palette!(pub SLATE)` macro expands to the following: +The `palette!(pub SLATE)` macro expands to effectively the following: ```rust -pub const SLATE_50: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(248, 250, 252); -pub const SLATE_100: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(241, 245, 249); -pub const SLATE_200: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(226, 232, 240); -pub const SLATE_300: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(203, 213, 225); -pub const SLATE_400: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(148, 163, 184); -pub const SLATE_500: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(100, 116, 139); -pub const SLATE_600: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(71, 85, 105); -pub const SLATE_700: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(51, 65, 85); -pub const SLATE_800: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(30, 41, 59); -pub const SLATE_900: ratatui::prelude::Color = ratatui::prelude::Color::Rgb(15, 23, 42); +use ratatui::prelude::Color; +pub const SLATE_50: Color = Color::Rgb(248, 250, 252); +pub const SLATE_100: Color = Color::Rgb(241, 245, 249); +pub const SLATE_200: Color = Color::Rgb(226, 232, 240); +pub const SLATE_300: Color = Color::Rgb(203, 213, 225); +pub const SLATE_400: Color = Color::Rgb(148, 163, 184); +pub const SLATE_500: Color = Color::Rgb(100, 116, 139); +pub const SLATE_600: Color = Color::Rgb(71, 85, 105); +pub const SLATE_700: Color = Color::Rgb(51, 65, 85); +pub const SLATE_800: Color = Color::Rgb(30, 41, 59); +pub const SLATE_900: Color = Color::Rgb(15, 23, 42); ``` ### Layout From 778f2f5ec511bef431b54157242b91d083ea9840 Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Sat, 13 Jan 2024 02:02:14 -0500 Subject: [PATCH 053/109] docs: Update README.md --- README.md | 37 ++----------------------------------- 1 file changed, 2 insertions(+), 35 deletions(-) diff --git a/README.md b/README.md index daa2fbc0..cb3aee8a 100644 --- a/README.md +++ b/README.md @@ -9,15 +9,13 @@ `ratatui-macros` is a Rust crate that provides easy-to-use macros for simplifying boilerplate associated with creating UI using [Ratatui](https://github.com/ratatui-org/ratatui). +This is an experimental playground to us explore macros that would be useful to have in Ratatui proper. + ## Features - Constraint-based Layouts: Easily define layout constraints such as fixed, percentage, minimum, and maximum sizes, as well as ratios. - Directional Layouts: Specify layouts as either horizontal or vertical with simple macro commands. -- Color palette: Define color palette based on [TailwindCSS]'s expertly-crafted default color - palette. - -[TailwindCSS]: https://tailwindcss.com/docs/customizing-colors ## Getting Started @@ -34,41 +32,10 @@ use ratatui_macros::{ constraint, constraints, horizontal, - palette, vertical, }; ``` -### Color - -The `palette!` macro allows you to define color palettes with ease. It is based on [TailwindCSS]'s -default color palette. - -```rust -use ratatui::prelude::Color; -use ratatui_macros::palette; - -palette!(pub SLATE); - -assert_eq!(SLATE_900, Color::Rgb(15, 23, 42)); -``` - -The `palette!(pub SLATE)` macro expands to effectively the following: - -```rust -use ratatui::prelude::Color; -pub const SLATE_50: Color = Color::Rgb(248, 250, 252); -pub const SLATE_100: Color = Color::Rgb(241, 245, 249); -pub const SLATE_200: Color = Color::Rgb(226, 232, 240); -pub const SLATE_300: Color = Color::Rgb(203, 213, 225); -pub const SLATE_400: Color = Color::Rgb(148, 163, 184); -pub const SLATE_500: Color = Color::Rgb(100, 116, 139); -pub const SLATE_600: Color = Color::Rgb(71, 85, 105); -pub const SLATE_700: Color = Color::Rgb(51, 65, 85); -pub const SLATE_800: Color = Color::Rgb(30, 41, 59); -pub const SLATE_900: Color = Color::Rgb(15, 23, 42); -``` - ### Layout If you are new to Ratatui, check out before proceeding. From 7d23bd2ceaf96e81972b5f746fdcba0d17f6391f Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Sat, 13 Jan 2024 02:02:35 -0500 Subject: [PATCH 054/109] docs: Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index cb3aee8a..2077fe3e 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ `ratatui-macros` is a Rust crate that provides easy-to-use macros for simplifying boilerplate associated with creating UI using [Ratatui](https://github.com/ratatui-org/ratatui). -This is an experimental playground to us explore macros that would be useful to have in Ratatui proper. +This is an experimental playground for us to explore macros that would be useful to have in Ratatui proper. ## Features From 2c02a56bce31519386303571e0b66b7d4beb378e Mon Sep 17 00:00:00 2001 From: Josh McKinney Date: Sat, 13 Jan 2024 00:33:14 -0800 Subject: [PATCH 055/109] docs: readme tweaks (#5) --- README.md | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 2077fe3e..5b5cf449 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,13 @@ # Ratatui Macros -[![Crates.io](https://img.shields.io/crates/v/ratatui-macros)](https://crates.io/crates/ratatui-macros) -[![Docs.rs](https://docs.rs/ratatui-macros/badge.svg)](https://docs.rs/ratatui-macros) -[![Build Status](https://github.com/kdheepak/ratatui-macros/actions/workflows/ci.yml/badge.svg)](https://github.com/kdheepak/ratatui-macros/actions) -[![License](https://img.shields.io/crates/l/ratatui-macros)](https://crates.io/crates/ratatui-macros#license) -[![Downloads](https://img.shields.io/crates/d/ratatui-macros)](https://crates.io/crates/ratatui-macros) +[![Crates.io badge]][ratatui_macros crate] +[![License badge]](./LICENSE) +[![Docs.rs badge]][API Docs] +[![CI Badge]][CI Status] +[![Crate Downloads badge]][ratatui_macros crate] `ratatui-macros` is a Rust crate that provides easy-to-use macros for simplifying boilerplate -associated with creating UI using [Ratatui](https://github.com/ratatui-org/ratatui). +associated with creating UI using [Ratatui]. This is an experimental playground for us to explore macros that would be useful to have in Ratatui proper. @@ -38,7 +38,8 @@ use ratatui_macros::{ ### Layout -If you are new to Ratatui, check out before proceeding. +If you are new to Ratatui, check out the [Layout concepts] article on the Ratatui website before +proceeding. Use the `constraints!` macro to define layout constraints: @@ -116,3 +117,16 @@ assert_eq!(right.width, 3); Contributions to `ratatui-macros` are welcome! Whether it's submitting a bug report, a feature request, or a pull request, all forms of contributions are valued and appreciated. + +[Crates.io badge]: https://img.shields.io/crates/v/ratatui-macros?logo=rust&style=flat-square +[License badge]: https://img.shields.io/crates/l/ratatui-macros +[CI Badge]: https://img.shields.io/github/actions/workflow/status/ratatui-org/ratatui-macros/ci.yml?logo=github&style=flat-square +[Docs.rs badge]: https://img.shields.io/docsrs/ratatui-macros?logo=rust&style=flat-square +[Crate Downloads badge]: https://img.shields.io/crates/d/ratatui-macros?logo=rust&style=flat-square + +[ratatui_macros crate]: https://crates.io/crates/ratatui-macros +[API Docs]: https://docs.rs/ratatui-macros +[CI Status]: https://github.com/kdheepak/ratatui-macros/actions + +[Ratatui]: https://github.com/ratatui-org/ratatui +[Layout concepts]: https://ratatui.rs/concepts/layout From f33d51e7d9ccf9fe52ec3289d04d97c722d9ee17 Mon Sep 17 00:00:00 2001 From: Josh McKinney Date: Sat, 13 Jan 2024 00:45:38 -0800 Subject: [PATCH 056/109] feat(text): add raw! and styled! macros (#4) These macros are similar to the format! macro, but return a raw or styled Span instead of a String. ```rust use ratatui_macros::{raw, styled}; let name = "world"; raw!("Hello, {name}!"); styled!(Style::new().green(), "Hello, {name}!"); styled!(Color::Green, "Hello, {name}!"); styled!(Modifier::BOLD, "Hello, {name}!"); ``` --- Cargo.lock | 583 ++++++++++++++++++++++++++++++++++++++++++++++++++++ Cargo.toml | 3 +- README.md | 20 ++ src/lib.rs | 1 + src/span.rs | 180 ++++++++++++++++ 5 files changed, 786 insertions(+), 1 deletion(-) create mode 100644 Cargo.lock create mode 100644 src/span.rs diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 00000000..5c0f3f57 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,583 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "ahash" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "allocator-api2" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5" + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "basic-toml" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2db21524cad41c5591204d22d75e1970a2d1f71060214ca931dc7d5afe2c14e5" +dependencies = [ + "serde", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" + +[[package]] +name = "cassowary" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "crossterm" +version = "0.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df" +dependencies = [ + "bitflags 2.4.1", + "crossterm_winapi", + "libc", + "mio", + "parking_lot", + "signal-hook", + "signal-hook-mio", + "winapi", +] + +[[package]] +name = "crossterm_winapi" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b" +dependencies = [ + "winapi", +] + +[[package]] +name = "dissimilar" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86e3bdc80eee6e16b2b6b0f87fbc98c04bee3455e35174c0de1a125d0688c632" + +[[package]] +name = "either" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" + +[[package]] +name = "glob" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" + +[[package]] +name = "hashbrown" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" +dependencies = [ + "ahash", + "allocator-api2", +] + +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + +[[package]] +name = "indoc" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e186cfbae8084e513daff4240b4797e342f988cecda4fb6c939150f96315fd8" + +[[package]] +name = "itertools" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25db6b064527c5d482d0423354fcd07a89a2dfe07b67892e62411946db7f07b0" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" + +[[package]] +name = "libc" +version = "0.2.152" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7" + +[[package]] +name = "lock_api" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" + +[[package]] +name = "lru" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2994eeba8ed550fd9b47a0b38f0242bc3344e496483c6180b69139cc2fa5d1d7" +dependencies = [ + "hashbrown", +] + +[[package]] +name = "mio" +version = "0.8.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09" +dependencies = [ + "libc", + "log", + "wasi", + "windows-sys", +] + +[[package]] +name = "once_cell" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" + +[[package]] +name = "parking_lot" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets", +] + +[[package]] +name = "paste" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" + +[[package]] +name = "proc-macro2" +version = "1.0.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "ratatui" +version = "0.26.0-alpha.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af44af108313dc2c17def8af60e234522fa596f7c5b2339f84a120b10d43f943" +dependencies = [ + "bitflags 2.4.1", + "cassowary", + "crossterm", + "indoc", + "itertools", + "lru", + "paste", + "stability", + "strum", + "unicode-segmentation", + "unicode-width", +] + +[[package]] +name = "ratatui-macros" +version = "0.2.4" +dependencies = [ + "ratatui", + "trybuild", +] + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "rustversion" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" + +[[package]] +name = "ryu" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c" + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "serde" +version = "1.0.195" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.195" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.48", +] + +[[package]] +name = "serde_json" +version = "1.0.111" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "signal-hook" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801" +dependencies = [ + "libc", + "signal-hook-registry", +] + +[[package]] +name = "signal-hook-mio" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29ad2e15f37ec9a6cc544097b78a1ec90001e9f71b81338ca39f430adaca99af" +dependencies = [ + "libc", + "mio", + "signal-hook", +] + +[[package]] +name = "signal-hook-registry" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1" +dependencies = [ + "libc", +] + +[[package]] +name = "smallvec" +version = "1.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970" + +[[package]] +name = "stability" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebd1b177894da2a2d9120208c3386066af06a488255caabc5de8ddca22dbc3ce" +dependencies = [ + "quote", + "syn 1.0.109", +] + +[[package]] +name = "strum" +version = "0.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.25.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "rustversion", + "syn 2.0.48", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "trybuild" +version = "1.0.88" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76de4f783e610194f6c98bfd53f9fc52bb2e0d02c947621e8a0f4ecc799b2880" +dependencies = [ + "basic-toml", + "dissimilar", + "glob", + "once_cell", + "serde", + "serde_derive", + "serde_json", + "termcolor", +] + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" + +[[package]] +name = "unicode-segmentation" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36" + +[[package]] +name = "unicode-width" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "zerocopy" +version = "0.7.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.48", +] diff --git a/Cargo.toml b/Cargo.toml index d98f9e98..accf002d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,8 @@ categories = ["tui", "macro"] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -ratatui = "0.25.0" +# requires alpha version of ratatui for the Into