How to Build a CLI Program in Rust

Are you tired of using clunky command line programs that don't quite fit your needs? Do you want to create your own custom CLI program that is fast, efficient, and easy to use? Look no further than Rust!

Rust is a modern programming language that is perfect for building command line programs. It is fast, safe, and has a growing community of developers who are creating amazing tools for the command line. In this article, we will walk you through the steps of building your own CLI program in Rust.

Getting Started

Before we dive into the code, let's make sure we have everything we need to get started. First, you will need to install Rust on your machine. You can do this by following the instructions on the Rust website.

Once you have Rust installed, you will need to create a new Rust project. You can do this by running the following command in your terminal:

cargo new my-cli-program

This will create a new Rust project called "my-cli-program" in a directory with the same name. Navigate into this directory by running:

cd my-cli-program

Now that we have our project set up, let's start building our CLI program.

Parsing Command Line Arguments

The first thing we need to do is parse the command line arguments that our program will receive. Rust has a great library called "clap" that makes this process easy.

To use clap, we need to add it to our project's dependencies. Open the Cargo.toml file in your project directory and add the following line under the [dependencies] section:

clap = "3.0.0-beta.2"

Now, let's create a new file called src/main.rs and add the following code:

use clap::{App, Arg};

fn main() {
    let matches = App::new("My CLI Program")
        .version("1.0")
        .author("Your Name <your@email.com>")
        .about("A CLI program built with Rust")
        .arg(
            Arg::with_name("input")
                .short("i")
                .long("input")
                .value_name("FILE")
                .help("Sets the input file to use")
                .takes_value(true),
        )
        .arg(
            Arg::with_name("output")
                .short("o")
                .long("output")
                .value_name("FILE")
                .help("Sets the output file to use")
                .takes_value(true),
        )
        .get_matches();

    let input_file = matches.value_of("input").unwrap_or("input.txt");
    let output_file = matches.value_of("output").unwrap_or("output.txt");

    println!("Input file: {}", input_file);
    println!("Output file: {}", output_file);
}

This code creates a new App using clap and defines two arguments: input and output. The input argument is optional and takes a file name as its value. The output argument is also optional and takes a file name as its value.

We then use the get_matches method to parse the command line arguments and store them in the matches variable. Finally, we use the unwrap_or method to set default values for the input and output files if they are not provided by the user.

Reading and Writing Files

Now that we have our command line arguments parsed, let's write some code to read from the input file and write to the output file.

First, let's create a new function called read_file that takes a file name as its argument and returns a Result containing the contents of the file as a String:

use std::fs::File;
use std::io::prelude::*;

fn read_file(file_name: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(file_name)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

This code uses Rust's built-in File and io modules to open the file, read its contents, and return them as a String. If an error occurs, it returns a std::io::Error.

Next, let's create a new function called write_file that takes a file name and some contents as its arguments and writes the contents to the file:

use std::fs::File;
use std::io::prelude::*;

fn write_file(file_name: &str, contents: &str) -> Result<(), std::io::Error> {
    let mut file = File::create(file_name)?;
    file.write_all(contents.as_bytes())?;
    Ok(())
}

This code uses Rust's File and io modules again to create the file, write the contents to it, and return Ok(()) if everything was successful.

Now that we have these two functions, we can use them in our main function to read from the input file and write to the output file. Replace the println statements in the main function with the following code:

let input_contents = read_file(input_file).expect("Unable to read input file");
println!("Input contents:\n{}", input_contents);

let output_contents = "Hello, world!";
write_file(output_file, output_contents).expect("Unable to write output file");
println!("Output contents:\n{}", output_contents);

This code reads the contents of the input file using the read_file function and prints them to the console. It then writes the string "Hello, world!" to the output file using the write_file function and prints it to the console.

Conclusion

Congratulations! You have just built your own CLI program in Rust. This is just the beginning, though. Rust has a lot of great libraries and tools for building command line programs, and we encourage you to explore them further.

In this article, we covered how to parse command line arguments using the clap library, and how to read from and write to files using Rust's built-in File and io modules. We hope you found this article helpful, and we look forward to seeing what amazing command line programs you create with Rust.

Happy coding!

Editor Recommended Sites