How to create a File Organizer CLI Tool in Rust – Beginner’s guide to Rust

# To install Rust 
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# To install Docker
# Follow this link https://docs.docker.com/engine/install/

Step 2: Setting Up the Rust Project

You will create a new Rust project using cargo Rust’s package manager. Open your terminal and run the command below

cargo new file_organizer_cli_tool_rust
cd file_organizer_cli_tool_rust

Step 3: Implementing the CLI Tool

This will create a new directory  file_organizer containing the necessary files for our Rust project. You can now implement the core functionality for your file organizer, open the file src/main.rs in your favourite code editor, and replace it with the content in the code snippet below. 

use clap::{Arg, Command};
use std::fs;
use std::path::{Path};
use std::error::Error;

fn organize_files(dir: &Path) -> Result<(), Box<dyn Error>> {
// Iterate over entries in the specified directory
for entry in fs::read_dir(dir)? {
let entry = entry?;
let path = entry.path();

// Check if the entry is a file
if path.is_file() {
// Get the file extension
if let Some(extension) = path.extension() {
let ext_str = extension.to_string_lossy();
let dest_dir = dir.join(ext_str.as_ref());

// Create a directory for the extension if it doesn't exist
if !dest_dir.exists() {
                    fs::create_dir(&dest_dir)?;
                }

// Move the file into the corresponding directory
let new_path = dest_dir.join(path.file_name().unwrap());
                fs::rename(&path, new_path)?;
println!("Moved: {:?}", path.file_name().unwrap());
            }
        }
    }
Ok(())
}

fn main() -> Result<(), Box<dyn Error>> {
let matches = Command::new("File Organizer")
        .version("1.0")
        .about("Organizes files in a directory by their extensions")
        .arg(
            Arg::new("directory")
                .help("The directory to organize")
                .required(true)
                .index(1),
        )
        .get_matches();

let dir = matches.get_one::<String>("directory").unwrap();
let path = Path::new(dir);

if path.exists() && path.is_dir() {
organize_files(&path)?;
println!("Files organized successfully.");
    } else {
        eprintln!("Provided path is not a valid directory.");
    }

Ok(())
}

Code Explanation 

The Rust code above is a simple command-line application that organizes files into a specified directory based on the extensions of the files. Here is a breakdown of the code. 

let matches = Command::new("File Organizer")
    .version("1.0")
    .about("Organizes files in a directory by their extensions")
    .arg(
        Arg::new("directory")
            .about("The directory to organize")
            .required(true)
            .index(1),
    )
    .get_matches();

The command snippet above is used for accepting command-line arguments using clap . The program takes one required argument called directory 

Step 6: Create the Dockerfile

Create a file called Dockerfile in your root project. The filename will be Dockerfile . Copy and paste the code snippet below for a copy of the Dockerfile 

FROM rust:alpine3.20 as builder

# Install necessary build dependencies
RUN apk add --no-cache musl-dev gcc openssl-dev

WORKDIR /app

# Copy the Cargo.toml file to build the dependency cache
COPY Cargo.toml ./

# Now copy the actual source code
COPY ./src ./src

# Build the Rust application in release mode
RUN cargo build --release

# Stage 2: Create a minimal image
FROM alpine:3.20

# Copy the compiled binary from the builder stage
COPY --from=builder /app/target/release/file_organizer_cli_tool_rust /usr/local/bin/file_organizer

# Expose the desired port
EXPOSE 8082

# Set the entry point for the container
ENTRYPOINT ["file_organizer_cli_tool_rust"]

Step 7: Build the Docker Image

To run your Docker image. Execute the command from the root directory of your project or the same path where your Dockerfile resides. 

docker build -t file_organizer_cli_tool_rust:v0.0.2 .

Step 8: Running the Docker Container

You can run your Docker container by specifying the directory you want to organize. Make sure you mount the directory to the container, the directory will contain the files you want to organize. See below the code snippet. Where 

• DATA_DIR the files to be organized reside. Replace DATA_DIR with the location of your directory.
• file_organizer_cli_tool_rust The Docker container we recently built contains the Rust code.

Below is the screenshot of the files before running the CLI Program