Using C++ as Shell Script

A while ago I had created a script in Bash(Shell Script) which cleaned up some things on my system, including:

The cache of images that were viewed, including thumbnails;
The cache of the browsers I had installed on my machine: Google Chrome, Firefox and Opera;
History with Bash;
Recent files;
And the trash can!

The script worked normally, I just had to run the limpeza command in terminal.

However, one fine day when I ran this script, I noticed that it took a long time to execute. The reason for this was that in the trash there were several .iso files, together I think they were about 5GB in size!

And then I thought asking myself:

— Why did Bash take so long to remove???

And I think:

— If I wrote this script in C++, would it take so long?!

So, I decided to do it and test it! After finishing writing, I deleted about 10GB of .iso (I threw it in the trash) and ran the post-compiled code to test with the command time and compared the result of the same command with that of the Bash script.

And the difference was BIG! In other words, the same script made in C++ was much faster!

Well, it’s been a long time, but I decided to post it here, because this “script” serves as an exercise for those who are training their C++ codes, it’s a good idea to use: C++ as Shell Script to improve your skills!

Writing the code

As we are going to compile with CMake, the ideal is to create a folder for the project:

mkdir cleanup
cd cleanup

All files

`cleanup.hpp`

#pragma once
#include <iostream>
#include <filesystem>
#include <memory>
#include <array>
#include <fstream>
#include "colors.hpp"

namespace fs = std::filesystem;

class Cleanup {

    bool m_debug;
    std::string m_path;

    const std::string m_home = std::getenv("HOME");

    const fs::path m_trash  = ".local/share/Trash/files";
    const fs::path m_thumbs = ".cache/thumbnails";
    const fs::path m_chrome = ".cache/google-chrome";
    const fs::path m_fox    = ".cache/mozilla";
    const fs::path m_opera  = ".cache/opera";
    const fs::path m_recent = ".local/share/recently-used.xbel";
    const fs::path m_bash_h = ".bash_history";

    protected:
        void print(bool, const std::string&);
        bool clean_dir(const std::array<std::string, 3>& = {});
        bool clean_file(const std::array<std::string, 3>& = {});

    public:
        Cleanup(bool);
        void run();
};

`colors.cpp`

#ifndef COLORS_H
#define COLORS_H
#include <iostream>

namespace hey {

  const std::string gray = "\033[30;10m", // normal
        grayn = "\033[30;1m", // bold
        grayf = "\033[30;2m", // weak
        grayi = "\033[30;3m", // italics
        grays = "\033[30;4m", // underline
        grayp = "\033[30;5m", // blinking
        grayb = "\033[30;7m", // background
        grayc = "\033[30;9m", // canceled

        red = "\033[31;10m", // normal
        redn = "\033[31;1m", // bold
        redf = "\033[31;2m", // weak
        redi = "\033[31;3m", // italics
        reds = "\033[31;4m", // underscore
        redp = "\033[31;5m", // flashing
        redb = "\033[31;7m", // background
        redc = "\033[31;9m", // canceled

        green = "\033[32;10m", // normal
        greenn = "\033[32;1m", // bold
        greenf = "\033[32;2m", // weak
        greeni = "\033[32;3m", // italics
        greens = "\033[32;4m", // underline
        greenp = "\033[32;5m", // blinking
        greenb = "\033[32;7m", // background
        greenc = "\033[32;9m", // canceled

        yellow = "\033[33;10m", // normal
        yellown = "\033[33;1m", // bold
        yellowf = "\033[33;2m", // weak
        yellowi = "\033[33;3m", // italics
        yellows = "\033[33;4m", // underlined
        yellowp = "\033[33;5m", // blinking
        yellowb = "\033[33;7m", // background
        yellowc = "\033[33;9m", // canceled

        blue = "\033[34;10m", // normal
        bluen = "\033[34;1m", // bold
        bluef = "\033[34;2m", // weak
        bluei = "\033[34;3m", // italics
        blues = "\033[34;4m", // underline
        bluep = "\033[34;5m", // blinking
        blueb = "\033[34;7m", // background
        bluec = "\033[34;9m", // canceled

        purple = "\033[35;10m", // normal
        purplen = "\033[35;1m", // bold
        purplef = "\033[35;2m", // weak
        purplei = "\033[35;3m", // italics
        purples = "\033[35;4m", // underline
        purplep = "\033[35;5m", // blinking
        purpleb = "\033[35;7m", // background
        purplec = "\033[35;9m", // canceled

        cyan = "\033[36;10m", // normal
        cyann = "\033[36;1m", // bold
        cyanf = "\033[36;2m", // weak
        cyani = "\033[36;3m", // italics
        cyans = "\033[36;4m", // underscore
        cyanp = "\033[36;5m", // blinking
        cyanb = "\033[36;7m", // background
        cyanc = "\033[36;9m", // canceled

        white = "\033[38;10m", // normal
        whiten = "\033[38;1m", // bold
        whitef = "\033[38;2m", // weak
        whitei = "\033[38;3m", // italics
        whites = "\033[38;4m", // underscore
        whitep = "\033[38;5m", // blinking
        whiteb = "\033[38;7m", // background
        whitec = "\033[38;9m", // canceled

        off = "\033[m"; // turns off
}

#endif

`cleanup.cpp`

#include "cleanup.hpp"

Cleanup::Cleanup(bool debug) : m_debug(debug){
  m_path = {};
}

void Cleanup::run(){
  this->clean_dir({m_trash, "Recycle bin emptied", "empty trash"});
  if(m_debug){ std::cout << hey::yellow << m_path << hey::off << "\n\n";}

  this->clean_file({m_recent, "Recent files cleaned", "clean recent files"});
  if(m_debug){ std::cout << hey::yellow << m_path << hey::off << "\n\n";}

  this->clean_file({m_bash_h, "Bash history removed", "clear Bash history"});
  if(m_debug){ std::cout << hey::yellow << m_path << hey::off << "\n\n";}

  this->clean_dir({m_thumbs, "Thumbnails removed", "remove Thumbnails cache"});
  if(m_debug){ std::cout << hey::yellow << m_path << hey::off << "\n\n";}

  this->clean_dir({m_chrome, "Chrome cache cleaned", "remove Chrome cache"});
  if(m_debug){ std::cout << hey::yellow << m_path << hey::off << "\n\n";}

  this->clean_dir({m_fox, "Firefox cache cleared", "remove Firefox cache"});
  if(m_debug){ std::cout << hey::yellow << m_path << hey::off << "\n\n";}

  this->clean_dir({m_opera, "Opera cache cleaned", "remove Opera cache"});
  if(m_debug){ std::cout << hey::yellow << m_path << hey::off << "\n\n";}
}

void Cleanup::print(bool action, const std::string& msg){
  (action) ?
    std::cout << hey::green + "\u2705 " + msg + "!" + hey::off << '\n' :
    std::cerr << hey::red + "\u274C Failed to " + msg + "." + hey::off << '\n';
}

bool Cleanup::clean_dir(const std::array<std::string, 3>& arr){
  m_path = m_home + '/' + arr[0];
  if(m_debug){
    this->print(true, arr[1]);
    return true;
  }

  try {
    if (fs::exists(m_path) && fs::is_directory(m_path)) {
      if (fs::is_empty(m_path)) {
        return false;
      }else{
        if(fs::remove_all(m_path)){
          this->print(true, arr[1]);
          fs::create_directory(m_path);
        }else{
          this->print(false, arr[2]);
          return false;
        }
      }
    }else{
      return false;
    }
  }catch (const fs::filesystem_error& e){
    std::cerr << "PERFORM THIS ACTION: " << e.what() << '\n';
    return false;
  }
  return true;
}

bool Cleanup::clean_file(const std::array<std::string, 3>& arr){
  m_path = m_home + '/' + arr[0];
  if(m_debug){
    this->print(true, arr[1]);
    return true;
  }

  try {
    if (fs::exists(m_path) && fs::is_regular_file(m_path)) {
      std::size_t size = std::filesystem::file_size(m_path);
      if(size == 0){
        return false;
      }
      if(fs::remove_all(m_path)){
        this->print(true, arr[1]);
        std::ofstream out(m_path);
        out.close();
      }else{
        this->print(false, arr[2]);
        return false;
      }
    }else{
      return false;
    }
  }catch (const fs::filesystem_error& e){
    std::cerr << "PERFORM THIS ACTION: " << e.what() << '\n';
    return false;
  }
  return true;
}

`main.cpp`

#include "cleanup.hpp"

int main(int argc, char** argv){
    bool debug {false};
    if(argc > 1){
        std::string param = argv[1];
        if(param == "--debug"){
            debug = true;
        }else{
            std::cerr << "Use: " << argv[0] << " [--debug]\n";
            return EXIT_FAILURE;
        }
    }
    auto lp = std::make_unique<Cleanup>(debug);
    lp->run();
    return EXIT_SUCCESS;
}

Compiling with CMake, running and installing

To compile we will use this CMakeLists.txt:

cmake_minimum_required(VERSION 3.10)
set_property(GLOBAL PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)

project(Cleanup
 LANGUAGES CXX
 VERSION 0.0.1
)

add_compile_options(-g -Wall -Wextra -Wpedantic -pedantic)
if(CHECK_MEM)
 message("Compiling with libasan. Learn more: <https://github.com/google/sanitizers/>")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
endif()

set (CMAKE_CXX_STANDARD 23)
add_executable(cleanup main.cpp cleanup.cpp)

Note in CMakeLists.txt that we can pass the optional parameter: -DCHECK_MEM=ON to use libasan which is the library: Google sanitizers, for more information see the video: 10 Flags and Parameters Tips for GNU GCC.

If you want to download all files click on the button below to download cleanup.zip:

Download cleanup.zip

So you can use CMake like this (with libasan):

cmake -B build . -DCHECK_MEM=ON

Or just: cmake -B build .

Then compile and test with debug mode:

cmake --build build
build/clean --debug

If you want to install and use it to do your cleanup, I recommend using it locally (only for your user):

mkdir -p ~/.local/bin
echo 'export PATH="${PATH}:${HOME}/.local/bin" >> ~/.bashrc'
exec $SHELL
install -v ./build/cleanup ~/.local/bin

Test again to see everything that will or will not be removed and then run it definitively:

Remembering that without being in debug mode, only the actions it executes will be output. For example, you don’t have Opera installed, or you’ve already run the command before, it won’t do anything or display it!

cleanup

Output:

Output cleaning command done with C++

If you want the terminal history to be clean after running everything, add an alias like this:

vim ~/.bashrc and paste this code at the end of the file:
cleanup(){
  ${HOME}/.local/bin/cleanup $@
  history -c
}
And run: exec $SHELL or source ~/.bashrc

Do it this way, as running processes like this with std::system not only doesn’t work, it’s not recommended!