If you are building a command-line tool with Rust, you may find it useful to highlight output in a style to make it stand out. Doing so, simply means wrapping your text in the necessary ANSI escape codes.
ANSI Color | Normal | Bold | With Background ---- | ---- | ---- | ---- Black | 0;30 | 1;30 | 0;40 Red | 0;31 | 1;31 | 0;41 Green | 0;32 | 1;31 | 0;42 Yellow | 0;33 | 1;31 | 0;43 Blue | 0;34 | 1;31 | 0;44 Magenta | 0;35 | 1;31 | 0;45 Cyan | 0;36 | 1;31 | 0;46 White | 0;37 | 1;31 | 0;47 Bright Black | 0;90 | 1;31 | 0;100 Bright Red | 0;91 | 1;31 | 0;101 Bright Green | 0;92 | 1;31 | 0;102 Bright Yellow | 0;93 | 1;31 | 0;103 Bright Blue | 0;94 | 1;31 | 0;104 Bright Purple | 0;95 | 1;95 | 0;105 Bright Cyan | 0;96 | 1;96 | 0;106 Bright White | 0;97 | 1;97 | 0;107
For example:
RED='\033[0;31m'
NC='\033[0m' # No Color
printf "I ${RED}love${NC} Stack Overflow\n"
Source: StackOverflow
In Rust, we can just replace '\033' with the unicode "\u{001B}" (Source: StackOverflow).
So, we can switch to the desired color by placing the escape code to start that color in our text and end it by using the escape code for no color. That's all there is to it! So, to highlight our text in yellow, we can just do this:
rust
let greeting = r"\u{001B}[0;31mHello, World!\u{001B}[0m";
println!("{}", greeting);
But, that's kinda clunky and hard to read. That's where this package comes in.
With the TerminalStyle struct, we can build a color by giving the ANSI escape codes or building out styles with the supplied enums.
```rust use terminaltextstyler::{TerminalStyle, SGREffect, ANSIForegroundColor};
// Manual with codes let yellow_manual = TerminalStyle::from(vec![0, 93]);
// Using enums let yellow = TerminalStyle::new(vec![SGREffect::Normal], Some(ANSIForegroundColor::BrightYellow), None); let nocolor = TerminalStyle::newempty(); // Initialize without input parameters for no color asserteq!(yellow.command(), "\u{001B}[0;93m"); asserteq!(nocolor.command(), "\u{001B}[0m"); asserteq!(yellow.wrap("Hello, World!"), "\u{001B}[0;93mHello, World!\u{001B}[0m"); ```
Now, when placed in a string (or by accessing the command method), a TerminalStyle instance will generate the ANSI escape code string:
rust
println!("{}Hello, World!{}", yellow, no_color));
This is much better, but we can make it a bit easier. We can call the wrap method to wrap the given text in that color.
rust
println!("{} Blah blah blah...", yellow.wrap("Hello, World!"));
For your convenience, TerminalStyle comes in with some static presets:
rust
let yellow = TerminalStyle::bright_yellow();
let red = TerminalStyle::red();
// Etc...
The StyledTerminalText struct builds on the wrap command to put the emphasis back on your text, not the color. The StyledTerminalText instance can then be placed right into a String (or turned into a String by accessing the output property):
```rust use terminaltextstyler::{StyledTerminalText, TerminalStyle};
let greeting = StyledTerminalText::new("Hello, World!", TerminalStyle::brightyellow()); asserteq!(greeting.output(), "\u{001B}[1;93mHello, World!\u{001B}[0m"); ```
The last step to making your code clean and easy is by just using the highlight convenience function to generate a StyledTerminalText:
```rust use terminaltextstyler::{highlight, TerminalStyle};
println!("{} Blah blah blah...", highlight("Hello, World!", TerminalStyle::bright_yellow())); ```
Each style in the table above also has a unique highlight function:
rust
use terminal_text_styler::{highlight_bright_yellow, highlight_red};
println!("This is {} and this is {}.", highlight_bright_yellow("highlighted in bright yellow"), highlight_red("highlighted in red"));