367 lines
13 KiB
Rust
367 lines
13 KiB
Rust
#![allow(dead_code)]
|
|
|
|
use std::io::{Result, Error};
|
|
|
|
pub const ESC: &str = "\x1b";
|
|
pub const PREFIX: &str = "\x1b[";
|
|
pub const RESET_ARG: &str = "0";
|
|
pub const TERMINATION: &str = "m";
|
|
pub const RESET_SEQ: &str = "\x1b[0m";
|
|
pub const FG: ColorContext = ColorContext::Foreground;
|
|
pub const BG: ColorContext = ColorContext::Background;
|
|
|
|
pub const STYLES: Styles = Styles {
|
|
set: StyleCodes {
|
|
bold: "1",
|
|
dim: "2",
|
|
italic: "3",
|
|
underlined: "4",
|
|
blinking: "5",
|
|
reversed: "7",
|
|
invisible: "8",
|
|
strikethrough: "9",
|
|
},
|
|
reset: StyleCodes {
|
|
bold: "22",
|
|
dim: "22",
|
|
italic: "23",
|
|
underlined: "24",
|
|
blinking: "25",
|
|
reversed: "27",
|
|
invisible: "28",
|
|
strikethrough: "29",
|
|
},
|
|
};
|
|
|
|
pub const COLORS: Colors = Colors {
|
|
fg: ColorCodes {
|
|
black: "30",
|
|
red: "31",
|
|
green: "32",
|
|
yellow: "33",
|
|
blue: "34",
|
|
magenta: "35",
|
|
cyan: "36",
|
|
white: "37",
|
|
extended: "38",
|
|
default: "39",
|
|
},
|
|
bg: ColorCodes {
|
|
black: "40",
|
|
red: "41",
|
|
green: "42",
|
|
yellow: "43",
|
|
blue: "44",
|
|
magenta: "45",
|
|
cyan: "46",
|
|
white: "47",
|
|
extended: "48",
|
|
default: "49",
|
|
},
|
|
};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Styles {
|
|
pub set: StyleCodes,
|
|
pub reset: StyleCodes,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct StyleCodes {
|
|
pub bold: &'static str,
|
|
pub dim: &'static str,
|
|
pub italic: &'static str,
|
|
pub underlined: &'static str,
|
|
pub blinking: &'static str,
|
|
pub reversed: &'static str,
|
|
pub invisible: &'static str,
|
|
pub strikethrough: &'static str,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Colors {
|
|
pub fg: ColorCodes,
|
|
pub bg: ColorCodes,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct ColorCodes {
|
|
pub black: &'static str,
|
|
pub red: &'static str,
|
|
pub green: &'static str,
|
|
pub yellow: &'static str,
|
|
pub blue: &'static str,
|
|
pub magenta: &'static str,
|
|
pub cyan: &'static str,
|
|
pub white: &'static str,
|
|
pub extended: &'static str,
|
|
pub default: &'static str,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum ColorContext {
|
|
Foreground,
|
|
Background,
|
|
}
|
|
|
|
/// prepends input with style string and appends the reset sequence at the end
|
|
pub fn apply_format(input: &String, style: &String) -> Result<String> {
|
|
let style_set: String = match parse_ansi_set(style) {
|
|
Ok(value) => value,
|
|
Err(error) => return Err(error),
|
|
};
|
|
let style_reset: String = match parse_ansi_reset(style) {
|
|
Ok(value) => value,
|
|
Err(error) => return Err(error),
|
|
};
|
|
Ok(format!("{}{}{}", style_set, input, style_reset))
|
|
}
|
|
|
|
/// generates a common style sequence of format
|
|
/// `\x1B[<styles>;<foreground-color>;<background-color>m`
|
|
/// all elements are optional, if none is supplied the function returns an error
|
|
pub fn generate_style_sequence(
|
|
style: Option<&str>,
|
|
foreground: Option<&str>,
|
|
background: Option<&str>,
|
|
) -> String {
|
|
// assemble sequence as vector of string
|
|
// this way the semicolons to separate arguments
|
|
// can be inserted with 'join()'
|
|
let mut sequence = PREFIX.to_owned();
|
|
let mut arguments = Vec::<String>::new();
|
|
if let Some(item) = style {
|
|
arguments.push(item.to_owned());
|
|
}
|
|
if let Some(item) = foreground {
|
|
arguments.push(item.to_owned());
|
|
}
|
|
if let Some(item) = background {
|
|
arguments.push(item.to_owned());
|
|
}
|
|
|
|
// panic if no arguments provided since this is a programming mistake
|
|
if arguments.is_empty() {
|
|
panic!("no arguments provided to 'generate_style_sequence()'");
|
|
}
|
|
sequence.push_str(&arguments.join(";"));
|
|
sequence.push_str(TERMINATION); // terminate sequence with the termination character
|
|
sequence
|
|
}
|
|
|
|
/// generates a 256 color sequence
|
|
/// see `generate_rgb_sequence(..)` for details
|
|
pub fn generate_256color_sequence(context: ColorContext, color: u8) -> String {
|
|
if color < 16 {
|
|
return "".to_owned();
|
|
}
|
|
let mut sequence = PREFIX.to_owned();
|
|
// choose context
|
|
match context {
|
|
ColorContext::Foreground => sequence.push_str(COLORS.fg.extended),
|
|
ColorContext::Background => sequence.push_str(COLORS.bg.extended),
|
|
};
|
|
// make it a rgb sequence
|
|
sequence.push_str(";5;");
|
|
sequence.push_str(&format!("{color}{TERMINATION}"));
|
|
sequence
|
|
}
|
|
|
|
/// generates a rgb color sequence
|
|
/// **note**: not all terminal emulators support rgb colors
|
|
///
|
|
/// rgb sequences are built the same as 256 color sequences:
|
|
/// `\x1B[<context>;2;<r>;<g>;<b>m`
|
|
/// where *context* is either '38' or '48' for foreground and background respectively
|
|
/// and *r,g,b* are the values of each color channel
|
|
pub fn generate_rgb_sequence(context: ColorContext, red: u8, green: u8, blue: u8) -> String {
|
|
let mut sequence = PREFIX.to_owned();
|
|
// choose context
|
|
match context {
|
|
ColorContext::Foreground => sequence.push_str(COLORS.fg.extended),
|
|
ColorContext::Background => sequence.push_str(COLORS.bg.extended),
|
|
};
|
|
// make it a rgb sequence
|
|
sequence.push_str(";2;");
|
|
sequence.push_str(&format!("{red};{green};{blue}m"));
|
|
sequence
|
|
}
|
|
|
|
/// generates a padding string for numbers in a list
|
|
pub fn make_padding_string(len: usize) -> String {
|
|
// determine padding needed to align the paths
|
|
String::from_utf8(vec![b' '; len]).unwrap()
|
|
}
|
|
|
|
/// convert color setting to ansi escape sequence to set style
|
|
/// input format is a quoted string (either double or single)
|
|
/// the style can be a combination of **one** color and
|
|
/// one or more style options (bold, italic, underlined, strikethrough)
|
|
pub fn parse_ansi_set(arg: &String) -> Result<String> {
|
|
let mut colors: Vec<String> = Vec::<String>::new();
|
|
let mut styles: Vec<String> = Vec::<String>::new();
|
|
|
|
// separate style options
|
|
let mut tokens: Vec<String> = arg.split([' ', ',', '\"', '\'']).map(|entry| entry.trim().to_lowercase()).collect();
|
|
tokens.retain(|entry| !entry.is_empty());
|
|
|
|
// parse options
|
|
for option in tokens {
|
|
// parse numbered colors
|
|
if let Ok(sequence) = parse_numbered_color(&option) {
|
|
colors.push(sequence);
|
|
continue;
|
|
}
|
|
|
|
// parse rgb colors
|
|
if let Ok(sequence) = parse_rgb_color(&option) {
|
|
colors.push(sequence);
|
|
continue;
|
|
}
|
|
|
|
// parse styles and named colors
|
|
match option.as_str() {
|
|
// styles
|
|
"bold" => styles.push(generate_style_sequence(Some(STYLES.set.bold), None, None)),
|
|
"dim" => styles.push(generate_style_sequence(Some(STYLES.set.dim), None, None)),
|
|
"italic" => styles.push(generate_style_sequence(Some(STYLES.set.italic), None, None)),
|
|
"underlined" => styles.push(generate_style_sequence(Some(STYLES.set.underlined), None, None)),
|
|
"blinking" => styles.push(generate_style_sequence(Some(STYLES.set.blinking), None, None)),
|
|
"reversed" => styles.push(generate_style_sequence(Some(STYLES.set.reversed), None, None)),
|
|
"invisible" => styles.push(generate_style_sequence(Some(STYLES.set.invisible), None, None)),
|
|
"strikethrough" => styles.push(generate_style_sequence(Some(STYLES.set.strikethrough), None, None)),
|
|
// named colors
|
|
"black" => colors.push(generate_style_sequence(None, Some(COLORS.fg.black), None)),
|
|
"red" => colors.push(generate_style_sequence(None, Some(COLORS.fg.red), None)),
|
|
"green" => colors.push(generate_style_sequence(None, Some(COLORS.fg.green), None)),
|
|
"yellow" => colors.push(generate_style_sequence(None, Some(COLORS.fg.yellow), None)),
|
|
"blue" => colors.push(generate_style_sequence(None, Some(COLORS.fg.blue), None)),
|
|
"magenta" => colors.push(generate_style_sequence(None, Some(COLORS.fg.magenta), None)),
|
|
"cyan" => colors.push(generate_style_sequence(None, Some(COLORS.fg.cyan), None)),
|
|
"white" => colors.push(generate_style_sequence(None, Some(COLORS.fg.white), None)),
|
|
"default" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
_ => return Err(Error::other(format!("-- could not parse style token `{}` in config file", option))),
|
|
};
|
|
|
|
};
|
|
|
|
if colors.len() > 1 {
|
|
return Err(Error::other(format!("-- too many colors found in setting <{}>", arg)));
|
|
}
|
|
if !colors.is_empty() {
|
|
styles.push(colors.pop().unwrap());
|
|
}
|
|
Ok(styles.join(""))
|
|
}
|
|
|
|
/// convert color setting to ansi escape sequence to reset style
|
|
/// input format is a quoted string (either double or single)
|
|
/// the style can be a combination of **one** color and
|
|
/// one or more style options (bold, italic, underlined, strikethrough)
|
|
pub fn parse_ansi_reset(arg: &String) -> Result<String> {
|
|
let mut colors: Vec<String> = Vec::<String>::new();
|
|
let mut styles: Vec<String> = Vec::<String>::new();
|
|
|
|
// separate style options
|
|
let mut tokens: Vec<String> = arg.split([' ', ',', '\"', '\'']).map(|entry| entry.trim().to_lowercase()).collect();
|
|
tokens.retain(|entry| !entry.is_empty());
|
|
|
|
// parse options
|
|
for option in tokens {
|
|
// parse numbered colors
|
|
if let Ok(_) = parse_numbered_color(&option) {
|
|
colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None));
|
|
continue;
|
|
}
|
|
|
|
// parse rgb colors
|
|
if let Ok(_) = parse_rgb_color(&option) {
|
|
colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None));
|
|
continue;
|
|
}
|
|
|
|
// parse styles and named colors
|
|
match option.as_str() {
|
|
// styles
|
|
"bold" => styles.push(generate_style_sequence(Some(STYLES.reset.bold), None, None)),
|
|
"dim" => styles.push(generate_style_sequence(Some(STYLES.reset.dim), None, None)),
|
|
"italic" => styles.push(generate_style_sequence(Some(STYLES.reset.italic), None, None)),
|
|
"underlined" => styles.push(generate_style_sequence(Some(STYLES.reset.underlined), None, None)),
|
|
"blinking" => styles.push(generate_style_sequence(Some(STYLES.reset.blinking), None, None)),
|
|
"reversed" => styles.push(generate_style_sequence(Some(STYLES.reset.reversed), None, None)),
|
|
"invisible" => styles.push(generate_style_sequence(Some(STYLES.reset.invisible), None, None)),
|
|
"strikethrough" => styles.push(generate_style_sequence(Some(STYLES.reset.strikethrough), None, None)),
|
|
// named colors
|
|
"black" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"red" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"green" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"yellow" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"blue" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"magenta" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"cyan" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"white" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
"default" => colors.push(generate_style_sequence(None, Some(COLORS.fg.default), None)),
|
|
_ => return Err(Error::other(format!("-- could not parse style token `{}` in config file", option))),
|
|
};
|
|
}
|
|
|
|
if colors.len() > 1 {
|
|
return Err(Error::other(format!("-- too many colors found in setting <{}>", arg)));
|
|
}
|
|
if !colors.is_empty() {
|
|
styles.push(colors.pop().unwrap());
|
|
}
|
|
Ok(styles.join(""))
|
|
}
|
|
|
|
fn parse_numbered_color(string: &String) -> Result<String> {
|
|
// check for numbered color
|
|
if let Ok(number) = string.parse::<u8>() {
|
|
return Ok(generate_256color_sequence(
|
|
ColorContext::Foreground,
|
|
number,
|
|
));
|
|
}
|
|
Err(Error::other(format!("no numbered color found in '{}'", string)))
|
|
}
|
|
|
|
fn parse_rgb_color(string: &String) -> Result<String> {
|
|
// check for rgb color
|
|
if string.as_bytes()[0] == b'#' && string.len() == 7 {
|
|
let red = match u8::from_str_radix(&string[1..=2], 16) {
|
|
Ok(value) => value,
|
|
Err(_) => {
|
|
return Err(Error::other(format!(
|
|
"-- failed to parse rgb color `{}` in config file",
|
|
string
|
|
)))
|
|
}
|
|
};
|
|
let green = match u8::from_str_radix(&string[3..=4], 16) {
|
|
Ok(value) => value,
|
|
Err(_) => {
|
|
return Err(Error::other(format!(
|
|
"-- failed to parse rgb color `{}` in config file",
|
|
string
|
|
)))
|
|
}
|
|
};
|
|
let blue = match u8::from_str_radix(&string[5..=6], 16) {
|
|
Ok(value) => value,
|
|
Err(_) => {
|
|
return Err(Error::other(format!(
|
|
"-- failed to parse rgb color `{}` in config file",
|
|
string
|
|
)))
|
|
}
|
|
};
|
|
return Ok(generate_rgb_sequence(
|
|
ColorContext::Foreground,
|
|
red,
|
|
green,
|
|
blue,
|
|
));
|
|
}
|
|
Err(Error::other(format!("no rgb color found in '{}'", string)))
|
|
}
|