Frameworks CLI para Rust: visão geral das melhores ferramentas para criar utilitários de linha de comando

CLI frameworks para Rust: ferramentas poderosas para criar aplicações de console

Rust é uma linguagem de programação de sistemas que está ganhando popularidade devido ao seu desempenho, segurança e recursos modernos. Uma das aplicações mais comuns do Rust é a criação de utilitários de linha de comando (CLI). De ripgrep a bat e fd — muitas ferramentas conhecidas são escritas em Rust. Neste artigo, vamos explorar os principais frameworks CLI para Rust que ajudarão você a desenvolver rapidamente suas próprias aplicações de console com qualidade.

Por que escolher Rust para CLI?

Rust oferece várias vantagens importantes para o desenvolvimento de CLI:

• Desempenho — código compilado opera com sobrecarga mínima.
• Segurança de memória — o sistema de ownership (propriedade) previne vazamentos e condições de corrida.
• Multiplataforma — uma única base de código funciona em Windows, macOS e Linux.
• Ecossistema — conjunto rico de bibliotecas para parsing de argumentos, saída colorida, trabalho com configurações.

Principais frameworks CLI para Rust

1. Clap (Command Line Argument Parser)

Clap é o framework mais popular e funcional para parsing de argumentos de linha de comando em Rust. Ele suporta geração automática de ajuda, sugestões, validação, subcomandos e muito mais.

use clap::{Parser, Subcommand};

#[derive(Parser)]#[command(name = "git")]#[command(about = "A fictional version of git", long_about = None)]struct Cli {    #[command(subcommand)]    command: Commands,}

#[derive(Subcommand)]enum Commands {    /// Clone a repository    Clone {        /// URL of the repository        url: String,    },    /// Push changes    Push {        /// Remote name        remote: String,        /// Branch name        branch: String,    },}

fn main() {    let cli = Cli::parse();    match &cli.command {        Commands::Clone { url } => println!("Cloning from {}", url),        Commands::Push { remote, branch } => println!("Pushing to {} branch {}", remote, branch),    }}

Clap oferece duas abordagens: declarativa (através de derive macros) e funcional (através do Builder API). Para a maioria dos projetos, recomenda-se usar a abordagem derive — é mais concisa e legível.

2. StructOpt

StructOpt é uma camada sobre o Clap que permite definir argumentos através de estruturas. A partir da versão 3.0, o Clap incorporou a funcionalidade do StructOpt diretamente, então atualmente o StructOpt é considerado obsoleto. No entanto, muitos projetos antigos ainda o utilizam.

use structopt::StructOpt;

#[derive(StructOpt)]struct Cli {    #[structopt(short = 'n', long = "name")]    name: String,    #[structopt(short = 'c', long = "count", default_value = "1")]    count: u32,}

fn main() {    let args = Cli::from_args();    for _ in 0..args.count {        println!("Hello, {}!", args.name);    }}

Importante: para novos projetos, use Clap com derive macros — é a alternativa moderna e suportada.

3. Argh

Argh é um framework leve e rápido que foca no minimalismo. Ele não requer dependências adicionais (além de si mesmo) e compila muito rapidamente. Ideal para utilitários pequenos.

use argh::FromArgs;

#[derive(FromArgs)]/// A simple greeting toolstruct Greeting {    /// name to greet    #[argh(option, short = 'n')]    name: String,

    /// number of times to greet    #[argh(option, short = 'c', default = "1")]    count: u32,}

fn main() {    let greeting: Greeting = argh::from_env();    for _ in 0..greeting.count {        println!("Hello, {}!", greet