In the terminal, colors and text styles can make output more readable and visually appealing. Whether you’re creating a script with status messages or customizing your prompt, knowing how to use ANSI escape codes for colors and styles is invaluable.

In this post, let’s explore a simple Bash script that prints all possible combinations of colors and styles of text in the terminal, along with the respective codes that generate them.

The script

#!/bin/bash

for style in '' '1;' '2;' '3;' '4;' '9;'; do
    for fg in {30..37}; do
        for bg in {40..48}; do
            if [ -z "$style" ]; then
              echo -en "\x1b[${bg}m  \x1b[0m"
            fi

            echo -en "\x1b[${style}${fg};${bg}m ${style}${fg};${bg} \x1b[0m"
        done
        echo  # Newline after each row
    done
    echo # Newline after each style for separation
done

How it works

The outermost for-loop will iterate over different text styles.

• ’’: This means no styling is added

• 1: This will make the text bold

• 2: This will make the text a little dim

• 3: This will italicize the text

• 4: This will add an underline to the text

• 9: This will add a strikethrough to the text

The next for-loop iterates over all the foreground colors (30-37) and the next one over all the background colors (40-48).

The \x1b[0m resets the formatting of the text, so that each formatting is applied without affecting the next one.

Running the script

I named the file as ansi-test. Hence, I can run the following commands to execute the script:

chmod +x ansi-test
./ansi-test

This prints a grid displaying all possible combinations of colors and styles! 🎨

Where to find the code

I have uploaded this script to GitHub here so you can easily access and modify it. I have added the path to this directory to the $PATH variable on my machine, so I don’t have to navigate to this directory to execute it. I can just type ansi-test anywhere and can execute it 😉. I will share that piece of configuration in a future article. Until then, happy scripting!⚡

• rg - ripgrep command-line tool

• fzf - fuzzy finder command-line tool

• bat (optional) - a cat clone with syntax highlighting

rg is a search tool that recursively searches for a regex pattern in a given directory. It is similar to the grep command but with extra features.

You can use this command in the following way:

rg 'configurations' ~/Documents

This will recursively search for the pattern 'configurations' in all files in the ~/Documents directory.

The potential problems

Now, to get to one specific instance of your search term, you have to scroll through the output of thergcommand which is not practical if the output is very long.

Enter fzf to the rescue again! In my previous blog, I showcased how fzf can be used to go through a list of fonts to choose from easily. Similarly, we can take the output of the search query from thergcommand and pipe it intofzf.

However, first, we need to see how to get the output of the search term to see if we need to make any changes.

Exploring the solutions

First, I created a script called rgf that I can run anywhere. As you can see, it takes an argument, which is the term to search for.

#!/bin/bash

rg "$1" .

The output of this command, as expected, will be as follows:

(By the way, this is a sneak peek at my custom prompt, using starship. I will share my starship config in a future blog.)

The problem I talked about will be visible now. What if there are many instances of the text "hello" across all the files in the current directory? We have to pipe this output into fzf to search for the occurrence of "hello" that we want.

For that, first, we have to make some modifications to this output before piping it into fzf.

#!/bin/bash

rg \
  --with-filename \
  --line-number \
  --hidden \
  --no-ignore \
  --no-heading \
  --color=always \
  --smart-case \
  "$1" .

--with-filename: This flag will print the filename for every line in the output.

--line-number: This flag will show line numbers in the search output.

--hidden: This flag will tell rg to search in the hidden files as well.

--no-ignore: This flag will make rg not respect the ignore files in your directory. For example, it will not respect the .gitignore file and will search for the pattern in the files mentioned in the .gitignore file too.

--no-heading: By default, the rg command will print the filename above the search output. This flag will make it print the filename in the same line as the search output.

--color=always: This flag will make the output colorful.

--smart-case: This flag will tell rg to search case insensitively if the pattern is all lowercase, else search case sensitively.

(Feel free to experiment with these flags or add new ones.)

The output of the above command becomes:

Great! Now we just need to pipe this into fzf. But now after looking at this output, don't you think we can type "hello" intofzfitself? This way, we can search for any term by typing it out.

Final solution

#/bin/bash/

rg \
  --with-filename \
  --line-number \
  --hidden \
  --no-ignore \
  --no-heading \
  --color=always \
  --smart-case \
  . $@ | \

fzf \
  --ansi \
  --delimiter : \
  --nth=3.. \
  --preview 'bat --color=always {1} --highlight-line {2}' \
  --preview-window 'right,60%,+{2}+3/3,~3'

--ansi: This flag will accept the incoming lines as having ansi codes for colors in them and render them properly on the screen.

--delimiter :: This flag will tell fzf to use : as the delimiter for each line when dealing with fields.

--nth=3..: This flag will limit the search to only the 3rd field onwards in every line (Because the 1st field is the filename and the 2nd field is the line number, we don't want to consider them when searching).

--preview: This flag will help specify a command to use for previewing each line. Here, we use the bat command with syntax highlighting (--color=always) and also highlighting the line matching the query (--highlight-line {2}).

--preview-window: This flag will set the properties of the preview window. Currently, the preview window is made to show up on the right of the fzf screen with 60% width. Additionally, it will scroll to three lines after the specified line (+{2}+3) and place the line at one-third height of the total preview window height (/3). Since we are using the bat command, it uses the first three lines of the output to display the filename. We don't want that to vanish as we scroll, so we fix the top three lines (~3).

(fzftruly is a powerful tool!)

I made some changes to the rg command too. Now it will search for ".", meaning it will now return every line in all the files in the current directory, and feed the output to fzf where we can type our search query. Another change I made is that the command will still take an argument, but it will be the directory. This means that multiple directories can be passed simultaneously and the script will run the search on all files in all the specified directories! So you can run rgf /path/to/folder1 /path/to/folder2 /path/to/folder3 and this script will run the search on all three directories.

Running this command in the terminal will bring this screen where you can now type your search term.

Conclusion

By combining the powerful search capabilities of ripgrep and the features of fzf, we've crafted a versatile and efficient script for interactive file searching. This script highlights the efficiency and adaptability of command-line tools, showcasing how they can streamline workflows and enhance productivity in a CLI environment. Experiment with these tools, tailor the script to meet your specific needs and unlock the full potential of your command-line experience.

• figlet

• fzf

figlet is a command-line utility to display large letters out of ordinary characters. You can learn more about it here. A typical output looks like this:

So what's the problem?

There are many types of "fonts" available to choose from. You can select them using the -f flag. For example, to use the "avatar" style, run the following command:

figlet -f avatar hello world!

But you don't want to run the figlet command with every single style and see the output before deciding which one to use. I faced this issue where I wanted to print texts with different styles but I didn't want to go through a long list of styles before picking just a few out of them.

The Solution

In order to quickly preview all available styles, I created a script that utilizes fzf (learn more about this amazing tool here) to navigate through the different styles and preview the entered text with that style applied.

Here is the script file:

#!/usr/bin/env bash

figlet -I2 \
  | xargs ls \
  | grep ".flf$" \
  | sed "s/\.flf//" \
  | fzf --preview="figlet -f {} $1" \
  | xargs -I {} figlet -f {} $1

Let's dissect this command step by step:

1. figlet -I2

   The -I2 flag retrieves the directory where the font files (with the .flf extension) for figlet are located.

2. xargs ls

   The output from figlet -I2 (the directory path) is piped into xargs, which then executes ls using that directory path as an argument. This command lists all files in the font directory.

3. grep ".flf"

   Since there are other types of files present in the fonts directory, we filter out those that have the .flf extension.

4. sed "s/.flf//"

   sed is another powerful command-line utility. Here, using regular expressions, we replace the .flf in the file names with empty strings. This cleans up the list to show just the font names, making it easier for the user to understand which fonts are available.

5. fzf --preview="figlet -f {} $1"

   The list of font names is passed to the fzf command, allowing you to search through a list with real-time query updates. The --preview option lets us render a preview of how the input text (passed as $1 argument to the whole command) would look in each font. The {} is a placeholder for each font name dynamically replaced by fzf.

6. xargs -I {} figlet -f {} $1

   Finally, the selected font (represented by {}) is used to invoke the figlet command to print the input text (again, the $1 argument) with the selected style.

Usage

In order to use this script, simply make it executable and then invoke it by passing your input string. Since I named my script as fig, the command for me looks like:

cd /path/to/the/script/file
chmod +x ./fig
./fig "desired text"

Conclusion

The figlet command has a lot of great ASCII art fonts at its disposal but previewing them all on your input text is time-consuming. By using this script, users can efficiently browse through all the available fonts, preview what their specific text looks like in each font, and select the font that best fits their needs, all within a few keystrokes in the terminal.