261 lines
7.8 KiB
Rust
261 lines
7.8 KiB
Rust
use crate::{component::Component, theme::Color};
|
|
|
|
// (line (centered (limited (padded "hello world"))))
|
|
#[derive(Debug, Clone)]
|
|
pub enum Token {
|
|
Centered(Box<Token>),
|
|
Limited(Box<Token>, usize),
|
|
CharPad(Box<Token>, char, usize),
|
|
Fg(Box<Token>, Color),
|
|
Bg(Box<Token>, Color),
|
|
String(Box<Token>, String),
|
|
End,
|
|
}
|
|
|
|
impl From<String> for Token {
|
|
fn from(value: String) -> Self {
|
|
Self::text(value)
|
|
}
|
|
}
|
|
|
|
impl From<&str> for Token {
|
|
fn from(value: &str) -> Self {
|
|
Self::text(value)
|
|
}
|
|
}
|
|
|
|
impl Token {
|
|
pub fn text<T>(t: T) -> Self
|
|
where
|
|
T: Into<String>,
|
|
{
|
|
Self::End.string(t)
|
|
}
|
|
|
|
pub fn string<S>(self, s: S) -> Self
|
|
where
|
|
S: Into<String>,
|
|
{
|
|
Token::String(Box::new(self), s.into())
|
|
}
|
|
|
|
pub fn centered(self) -> Self {
|
|
Self::Centered(Box::new(self))
|
|
}
|
|
|
|
pub fn limited(self, lim: usize) -> Self {
|
|
Self::Limited(Box::new(self), lim)
|
|
}
|
|
|
|
pub fn padded(self, pad_to: usize) -> Self {
|
|
Self::CharPad(Box::new(self), ' ', pad_to)
|
|
}
|
|
|
|
pub fn str_len(&self) -> usize {
|
|
match self {
|
|
Token::String(t, s) => s.len() + t.str_len(),
|
|
Token::Fg(t, _) => t.str_len(),
|
|
Token::Bg(t, _) => t.str_len(),
|
|
Token::Centered(t) => t.str_len(),
|
|
Token::Limited(t, lim) => (*lim).min(t.str_len()),
|
|
Token::CharPad(t, _, pad_to) => {
|
|
(*pad_to).max(t.str_len())
|
|
}
|
|
Token::End => 0,
|
|
}
|
|
}
|
|
|
|
pub fn pad_char(self, c: char, pad_to: usize) -> Self {
|
|
Self::CharPad(Box::new(self), c, pad_to)
|
|
}
|
|
|
|
pub fn fg(self, c: Color) -> Self {
|
|
Self::Fg(Box::new(self), c)
|
|
}
|
|
|
|
pub fn bg(self, c: Color) -> Self {
|
|
Self::Bg(Box::new(self), c)
|
|
}
|
|
|
|
fn with_width(self, width: usize) -> Vec<Component> {
|
|
match self {
|
|
Token::String(t, s) => vec![Component::String(s)]
|
|
.into_iter()
|
|
.chain(t.with_width(width))
|
|
.collect(),
|
|
Token::Centered(cnt) => {
|
|
let mut str_len = cnt.str_len();
|
|
let components = if str_len > width {
|
|
str_len = width;
|
|
cnt.limited(width).with_width(width)
|
|
} else {
|
|
cnt.with_width(width)
|
|
};
|
|
vec![Component::X((width - str_len) / 2)]
|
|
.into_iter()
|
|
.chain(components)
|
|
.collect()
|
|
}
|
|
Token::Limited(s, lim) => s
|
|
.with_width(width)
|
|
.into_iter()
|
|
.map(|cmp| {
|
|
if let Component::String(mut s) = cmp {
|
|
s.truncate(lim);
|
|
Component::String(s)
|
|
} else {
|
|
cmp
|
|
}
|
|
})
|
|
.collect(),
|
|
Token::CharPad(s, c, pad_to) => s
|
|
.with_width(width)
|
|
.into_iter()
|
|
.map(|comp| {
|
|
if let Component::String(s) = comp {
|
|
if s.len() >= pad_to {
|
|
return Component::String(s);
|
|
}
|
|
Component::String(format!(
|
|
"{}{}",
|
|
s,
|
|
c.to_string().repeat(pad_to - s.len())
|
|
))
|
|
} else {
|
|
comp
|
|
}
|
|
})
|
|
.collect(),
|
|
Token::Fg(t, c) => vec![Component::Fg(c)]
|
|
.into_iter()
|
|
.chain(t.with_width(width))
|
|
.collect(),
|
|
Token::Bg(t, c) => vec![Component::Bg(c)]
|
|
.into_iter()
|
|
.chain(t.with_width(width))
|
|
.collect(),
|
|
Token::End => vec![],
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_token_gen() {
|
|
const WIDTH: usize = 20;
|
|
vec![
|
|
(
|
|
"string -> string",
|
|
Token::text("hello"),
|
|
vec![Component::String("hello".into())],
|
|
),
|
|
(
|
|
"string -> limited",
|
|
Token::text("This string is too long for this!")
|
|
.limited(4),
|
|
vec![Component::String("This".into())],
|
|
),
|
|
(
|
|
"string -> limit -> pad_to",
|
|
Token::text("This string is too long, but some")
|
|
.limited(10)
|
|
.padded(15),
|
|
vec![Component::String("This strin ".into())],
|
|
),
|
|
(
|
|
"center limited string",
|
|
Token::text("Ahhh this won't go far")
|
|
.limited(10)
|
|
.centered(),
|
|
vec![
|
|
Component::X((WIDTH - 10) / 2),
|
|
Component::String("Ahhh this ".into()),
|
|
],
|
|
),
|
|
(
|
|
"padded string with underscores is centered",
|
|
Token::text("It was...").pad_char('_', 15).centered(),
|
|
vec![
|
|
Component::X((WIDTH - 15) / 2),
|
|
Component::String("It was...______".into()),
|
|
],
|
|
),
|
|
(
|
|
"prefixes color",
|
|
Token::text("this is red").fg(Color::RED),
|
|
vec![
|
|
Component::Fg(Color::RED),
|
|
Component::String("this is red".into()),
|
|
],
|
|
),
|
|
(
|
|
"color at beginning of line",
|
|
Token::text("colored").centered().bg(Color::RED),
|
|
vec![
|
|
Component::Bg(Color::RED),
|
|
Component::X((WIDTH - 7) / 2),
|
|
Component::String("colored".into()),
|
|
],
|
|
),
|
|
(
|
|
"color isnt part of limit",
|
|
Token::text("ten chars!")
|
|
.bg(Color::RED)
|
|
.fg(Color::GREEN)
|
|
.bg(Color::BLUE)
|
|
.fg(Color::BLACK)
|
|
.limited(10),
|
|
vec![
|
|
Component::Fg(Color::BLACK),
|
|
Component::Bg(Color::BLUE),
|
|
Component::Fg(Color::GREEN),
|
|
Component::Bg(Color::RED),
|
|
Component::String("ten chars!".into()),
|
|
],
|
|
),
|
|
(
|
|
"multicolor string centered",
|
|
Token::text("end")
|
|
.fg(Color::RED)
|
|
.string("mid")
|
|
.fg(Color::BLUE)
|
|
.string("start")
|
|
.fg(Color::GREEN)
|
|
.centered(),
|
|
vec![
|
|
Component::X(0),
|
|
Component::Fg(Color::GREEN),
|
|
Component::String("start".into()),
|
|
Component::Fg(Color::BLUE),
|
|
Component::String("mid".into()),
|
|
Component::Fg(Color::RED),
|
|
Component::String("end".into()),
|
|
],
|
|
),
|
|
]
|
|
.into_iter()
|
|
.for_each(|test| {
|
|
let (name, token, expected) = test;
|
|
eprintln!("token: {:#?}", &token);
|
|
let actual = token.with_width(WIDTH);
|
|
let actual_fmt = format!("{:#?}", &actual);
|
|
assert!(
|
|
expected
|
|
.clone()
|
|
.iter()
|
|
.zip(actual.iter())
|
|
.filter(|&(l, r)| l == r)
|
|
.count()
|
|
!= 0,
|
|
"{} expected: {:#?} actual: {}",
|
|
name,
|
|
expected,
|
|
actual_fmt,
|
|
)
|
|
})
|
|
}
|
|
}
|