Creating a CLI with Rust

Alejandro López — Wed, 16 Mar 2022 20:40:37 +0000

Setup

⚠ Warning

This post requires basic understanding of some programming concepts as structs, functions, modules, and I/O handling. It is also recommended to have Rust knowledge, if you are new to programming I highly recommend you to check out this video and/or if you are new to Rust, you should read the official book.

Before getting into our hacker mood,
let's create a cargo project and install the packages we'll need:

cargo new ferris-say

Now, open your Cargo.toml, and add this below [dependencies]:

[dependencies]
ansi_term = "0.12.1"
clap = { version = "3.1.6", features = ["derive"] }

Or, if you have cargo edit (which I prefer using), write right in your terminal:

cargo add ansi_term 
cargo add clap --features derive

After it's installed, we're ready to go to the next step.

Getting input from arguments

The crate clap that we just installed and used in the snippet below, helps us not only to parse but to validate the input given by the user. Let's see how to implement and use it into our application.

First thing is to create a function called input here we'll handle and parse the arguments provided; Our Cli will request only two arguments to work with: quote and color but for color we need an enum as we'll only allow to use a few types of colors (but a cool ones).

The function signature

The function signatures let us to know how many parameters will it receive and what will be the output generated, and let's bring into scope both of the crate we'll be using along this tutorial:

// Imports
use ansi_term::{self, Colour};
use clap::{ArgEnum, Parser};
fn input() -> (String, Colour)

Parsing the input

  #[derive(Parser, Debug)]
  #[clap(author, version, about = "cowsay rusty version")]
    struct Args {
        /// Quote that ferris will say
        #[clap(short, long)]
        quote: String,
        /// Colors to choose
        #[clap(arg_enum)]
        color: Colors,
    }

The Parser trait that our struct derives, parses all the arguments provided by the user and turns it into that struct fields. As you can see, we only have two fields, so it means, we'll only receive two arguments, as we state before.

Note that quote is the type of String and color is the type of Colors, but it doesn't exist yet, so let's create it.

  #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ArgEnum, Debug)]
    enum Colors {
        // Not black because it's the background color
        Red,
        Green,
        Yellow,
        Blue,
        Purple,
        Cyan,
        White,
    }

Focus on that ArgEnum derived trait, that means: "Hey, this enum's variants are the only few valid types for a argument" and clap will ensure that the argument provided fits into it.

Once we have our Colors enum, let's handle each variant using the classic match statement.

Handling the input

At this point we already brought into scope our ansi_term crate so it's time to use it

// Imports
use clap::{ArgEnum, Parser};
use ansi_term::{self, Colour} // -> This one
// fn input(){...}

So we can crate a match statement to filter through the Colors(our enum) variants, return a Colour(ansi_term's enum) variant and bind it to a variale named color_matched.

First, create a new instance of Args. To access to its field (quote and color) we need to use the dot notation:

// ...
let args = Args::parse();
// to access to the quote:
args.quote
// to access to the color:
args.color // If you want to show through terminal remember using ":?"

Now we are up to handle:

// ...
    let color_matched = match args.color {
        Colors::Red => Colour::Red,
        Colors::Green => Colour::Green,
        Colors::Yellow => Colour::Yellow,
        Colors::Blue => Colour::Blue,
        Colors::Purple => Colour::Purple,
        Colors::Cyan => Colour::Cyan,
        Colors::White => Colour::White,
    };
    println!("The user picked the color {:?}", color_matched);

Last thing to do is return the tuple:

//...
(args.quote, color_matched)

Time to test it!

cargo build
target/debug/ferris_say.exe -h
ferris-say 0.1.0
cowsay rusty version
USAGE:
    ferris_say.exe --quote <QUOTE> <COLOR>
ARGS:
    <COLOR>    Colors to choose [possible values: red, green, yellow, blue, purple,
               cyan, white]
OPTIONS:
    -h, --help             Print help information
    -q, --quote <QUOTE>    Quote that ferris will say
    -V, --version          Print version information

passing the -h or --help shows the arguments we can use.

Once we know what are the arguments, we're able to use it correctly.

target/debug/ferris_say.exe -q "Hello world!" red
The user picked the color Red

But...what if I pass a color that isn't valid?

target/debug/ferris_say.exe -q "hello world!" black
error: "black" isn't a valid value for '<COLOR>'
        [possible values: red, green, yellow, blue, purple, cyan, white]
USAGE:
    ferris_say.exe --quote <QUOTE> <COLOR>
For more information try --help

We are ready to go to the next step: drawing the ferris.

Draw the ferris

Here, I highly recommend you just to copy and paste the drawing. But first, let's create another function draw:

The function signature

fn draw(quote: &str, color: &Colour)

Inside the draw function:

// Ferris drawing
    const FERRIS: &'static str = r"
    .
     .
      .
       █ █           █ █
        ▀█  ▄█████▄  █▀
         ▀▄███▀█▀███▄▀ 
         ▄▀███▀▀▀███▀▄ 
         █ ▄▀▀▀▀▀▀▀▄ █
    ";
    println!("{}", format!("\"{}\"{}", quote, color.paint(FERRIS)));

A r"" String is called as "raw string", in short, it tells the compiler to ignore every scape character, It's easier for us to draw our ferris that way. On the other hand we have a format!macro, we use it as we'll place the text right above the ferris. It will be better illustrated as we run the program.
Last but not least color is a Colour instance passed by reference, that means we can use the paint that receives a &str params. It "paints" the text to a given color.
Finally inside our main function:

fn main() {
    let (q, c) = input();
    draw(&q, &c)
}

Final code

use ansi_term::{self, Colour}; // 0.12.1
use clap::{ArgEnum, Parser};
fn draw(quote: &str, color: &Colour) {
    // Ferris drawing
    const FERRIS: &'static str = r"
    .
     .
      .
       █ █           █ █
        ▀█  ▄█████▄  █▀
         ▀▄███▀█▀███▄▀ 
         ▄▀███▀▀▀███▀▄ 
         █ ▄▀▀▀▀▀▀▀▄ █
    ";
    println!("{}", format!("\"{}\"{}", quote, color.paint(FERRIS)));
}
fn input()-> (String, Colour) {
    #[derive(Parser, Debug)]
    #[clap(author, version, about = "cowsay rusty version")]
    struct Args {
        /// Quote that ferris will say
        #[clap(short, long)]
        quote: String,
        /// Colors to choose
        #[clap(arg_enum)]
        color: Colors,
    }
    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ArgEnum, Debug)]
    enum Colors {
        // Not black because it's the our background color
        Red,
        Green,
        Yellow,
        Blue,
        Purple,
        Cyan,
        White,
    }
    let args = Args::parse();
    // validate colors argument:
    let color_matched = match args.color {
        Colors::Red => Colour::Red,
        Colors::Green => Colour::Green,
        Colors::Yellow => Colour::Yellow,
        Colors::Blue => Colour::Blue,
        Colors::Purple => Colour::Purple,
        Colors::Cyan => Colour::Cyan,
        Colors::White => Colour::White,
    };
    (args.quote, color_matched)
}
fn main() {
    let (q, c) = input();
    draw(&q, &c)
}

I hope you guys enjoyed this tutorial, any comment or suggestion my email is opened!

This post is also available in my personal blog

Starting at backend development [part 1]

Alejandro López — Tue, 29 Dec 2020 19:56:44 +0000

Hello everyone, in this article I will introduce you to node.js development, focused on backend development.

In these series of articles we will be able to learn basic concepts that will let us achieve tasks as creating simple applications.

Let’s get started with a little introduction of node.js.

What is backend development?

Backend development refers to server-side development.
Web development is divided into two big concepts: frontend, and backend. To give you a general idea, frontend development is meant to be what we see when we visit a web page and it includes all graphical resources; on the other hand, backend development contains the business logic.

E.g. Login system from facebook, or uploading video process from Tiktok, the system that carries with all that logic is called backend.

Ready to go more deep in?

What is node.js?

Node.js is an Asynchronous event-driven Javascript runtime. But, what does it means? Well, let's go step by step.

1. Runtime? Mmm, what is it?
Runtime provides the environment in which programs run.
This environment may manage how the program uses the memory, or how it interacts with the operative system.

2. Asynchronous?
Normally, a given program's code runs straight along from top to bottom, running only one thing at once. Imagine you have a function that execute a process that takes time, your whole program will be stopped until your function finishes its process.

This isn't very useful because the user will have to wait a lot of time! and your program may crash if there are many people requesting something at the same time.

So, how can we avoid that? Asynchronous programming is the answer!

3. Event-driven
Is a programming paradigm in which the flow is determined by events, such a user interaction (like clicks), sensors, HTTP methods, etc.
There's a main loop that listen to an event, and then triggers a callback to handle it.

We will discuss these topics deeper afterwards, for now it is enough for us to know them in general terms.

In the next chapter we're going to learn more about node.js in web development, its use and its potential as Javascript technology.

Here my twitter account.
And here my github

Hello world!

Alejandro López — Tue, 10 Nov 2020 03:06:56 +0000

Hello everybody, I'm a mevn stack developer, i'm here to explain myself! Next days I'll be uploading tutorials about some of my repos on my github (you can check it here: github.com/alejandro0619)

DEV Community: Alejandro López

Creating a CLI with Rust

Setup

Getting input from arguments

The function signature

Parsing the input

Handling the input

Draw the ferris

The function signature

Final code

Starting at backend development [part 1]

What is backend development?

What is node.js?

Hello world!