Framework CLI pour Rust : création d'applications console…

Framework CLI pour Rust : création d'applications console puissantes

Rust est un langage de programmation système idéal pour créer des utilitaires console rapides et fiables. Grâce à son typage strict, ses abstractions à coût zéro et son gestionnaire de paquets intégré Cargo, Rust permet de développer des outils CLI qui fonctionnent instantanément sans nécessiter d'interpréteur. Dans cet article, nous examinerons trois frameworks CLI populaires pour Rust : clap, structopt et argh, et montrerons comment créer des applications console professionnelles avec eux.

Pourquoi Rust pour la CLI ?

Rust est choisi pour le développement CLI pour plusieurs raisons :

Performance — le code compilé fonctionne au niveau du C/C++.
Sécurité mémoire — le système de propriété élimine les fuites et les conditions de concurrence.
Multiplateforme — une seule base de code fonctionne sur Windows, macOS et Linux.
Écosystème — des milliers de crates prêts à l'emploi pour toutes les tâches.

1. Clap — la référence du secteur

clap (Command Line Argument Parser) est le framework le plus populaire pour l'analyse des arguments en ligne de commande en Rust. Il prend en charge les arguments positionnels, les options, les drapeaux, les sous-commandes, la génération automatique d'aide et l'auto-complétion pour Bash/Zsh/Fish.

Installation

Ajoutez dans Cargo.toml :

[dependencies]clap = { version = "4.5", features = ["derive"] }

Exemple : une calculatrice simple

use clap::Parser;

#[derive(Parser)]#[command(name = "calc")]#[command(about = "Calculatrice CLI simple")]struct Cli {    /// Premier nombre    a: f64,

    /// Deuxième nombre    b: f64,

    /// Opération : add, sub, mul, div    #[arg(short, long, default_value = "add")]    operation: String,}

fn main() {    let cli = Cli::parse();    let result = match cli.operation.as_str() {        "add" => cli.a + cli.b,        "sub" => cli.a - cli.b,        "mul" => cli.a * cli.b,        "div" => {            if cli.b == 0.0 {                eprintln!("Erreur : division par zéro");                std::process::exit(1);            }            cli.a / cli.b        }        _ => {            eprintln!("Opération inconnue : {}", cli.operation);            std::process::exit(1);        }    };    println!("Résultat : {}", result);}

Exécution :

cargo run -- 10 5 --operation mul# Sortie : Résultat : 50

2. Structopt — une approche élégante

structopt était auparavant un crate séparé, mais ses fonctionnalités sont désormais intégrées dans clap via les macros derive. Cependant, de nombreux anciens projets l'utilisent encore directement. Structopt permet de décrire les arguments comme des champs de structure avec des annotations.

Installation (pour les projets legacy)

[dependencies]structopt = "0.3"

Exemple : utilitaire de gestion de fichiers

use structopt::StructOpt;use std::path::PathBuf;

#[derive(StructOpt)]#[structopt(name = "fileutil", about = "Utilitaire de gestion de fichiers")]struct Opt {    /// Fichier d'entrée    #[structopt(parse(from_os_str))]    input: PathBuf,

    /// Fichier de sortie (optionnel)    #[structopt(parse(from_os_str), short = "o", long = "output")]    output: Option<PathBuf>,

    /// Mode : copy ou move    #[structopt(short, long, default_value = "copy")]    mode: String,

    /// Drapeau verbose    #[structopt(short, long)]    verbose: bool,}

fn main() {    let opt = Opt::from_args();    if opt.verbose {        println!("Traitement du fichier : {:?}", opt.input);    }    // Logique de copie/déplacement}