Construyendo una Aplicación de Línea de Comandos en Rust

Las aplicaciones de línea de comandos (CLIs) son una forma útil de interactuar con tu computadora y realizar tareas sin una interfaz gráfica. Son especialmente útiles para automatizar tareas y escribir scripts.

En este tutorial, aprenderemos cómo crear una aplicación de línea de comandos en Rust que hipotéticamente lee una ruta de archivo dada y guarda su contenido en una base de datos. Para hacer esto, utilizaremos el crate clap. clap es un analizador de argumentos de línea de comandos que simplifica el proceso de analizar los argumentos y opciones pasados a tu CLI.

Primero, necesitaremos agregar clap a nuestro archivo Cargo.toml. Para hacerlo, ejecuta el siguiente comando en tu consola:

cargo add clap --features derive

Alternativamente, puedes agregar manualmente la dependencia de esta forma:

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

A continuación, crea un nuevo archivo Rust (main.rs) y agrega el siguiente código:

use clap::Parser;

/// Lee el archivo de entrada y guarda el contenido en una base de datos
#[derive(Parser, Debug)]
#[command(author = "Alfonso Bribiesca", version, about, long_about = None)]
struct Args {
    /// Ruta del archivo a leer
    input_file: String,

    /// Crea una nueva tabla
    #[arg(short, long, default_value = "false")]
    create_table: bool,

    /// Elimina la tabla
    #[arg(short, long, default_value = "false")]
    drop_table: bool,

    /// Nombre de la tabla
    #[arg(short, long="table", default_value = "")]
    table_name: String,
}

Este código es para un CLI que lee un archivo de entrada y guarda su contenido en una base de datos.

Define una estructura llamada Args que representa los argumentos y opciones pasados al CLI. El atributo #[derive(Parser, Debug)] genera código para analizar los argumentos y opciones de la línea de comandos y para imprimir los valores de la estructura Args. El atributo #[command(author = "Alfonso Bribiesca", version, about, long_about = None)] proporciona metadatos sobre el CLI, como el nombre del autor y una breve descripción del CLI.

La estructura Args contiene cuatro campos:

• input_file: un String que representa el archivo de entrada pasado como primer argumento al CLI.
• create_table: un bool que representa si la opción create_table está configurada. Si se establece esta opción, hipotéticamente se creará una nueva tabla en la base de datos.
• drop_table: un bool que representa si la opción drop_table está configurada. Si se establece esta opción, hipotéticamente se eliminará la tabla de la base de datos.
• table_name: un String que representa el nombre de la tabla que hipotéticamente se utilizará para nombrar la tabla de la base de datos.

Para definir los argumentos y opciones para nuestro CLI, utilizamos el atributo #[arg(short, long, value_name = "VALUE", index = INDEX, default_value = "DEFAULT")]. Los argumentos short y long definen las formas abreviadas y completas de la opción, respectivamente. El argumento default_value especifica un valor predeterminado para la opción si no se proporciona.

Ahora agreguemos la función principal a nuestro código:

fn main() {
    let args = Args::parse();

    // Imprime todos los argumentos
    println!("{:#?}", args);
}

En la función principal, llamamos al método Args::parse() para analizar los argumentos y opciones de la línea de comandos. Este método devuelve una estructura Args que contiene los valores de los argumentos y opciones pasados al CLI.

Luego, podemos imprimir los valores de la estructura Args utilizando la macro println!. Esto es útil para depurar y comprender los valores pasados al CLI.

Con esto, tendrás un CLI básico. Ahora depende de ti agregar la funcionalidad real.

Puedes probar la aplicación ejecutando el comando:

cargo run -- <arguments>

Reemplaza <arguments> con los argumentos y opciones que desees pasar al CLI. Por ejemplo:

cargo run -- --drop-table --table=my-table /ruta/al/archivo.xls

Debería mostrar la siguiente salida:

Args {
    input_file: "/ruta/al/archivo.xls",
    create_table: false,
    drop_table: true,
    table_name: "my-table",
}

También puedes usar la opción --help para ver una lista de las opciones disponibles y un resumen de tu aplicación.

cargo run -- --help

Lee el archivo de entrada y guarda el contenido en una base de datos

Uso: parser [OPTIONS] <INPUT_FILE>

Argumentos:
  <INPUT_FILE>  El primer argumento posicional es el archivo de entrada

Opciones:
  -c, --create-table        Crea una nueva tabla
  -d, --drop-table          Elimina la tabla
  -t, --table <TABLE_NAME>  Nombre de la tabla [por defecto: ]
  -h, --help                Mostrar información de ayuda
  -V, --version             Mostrar información de versión

¡Espero que esto te ayude! Avísame si tienes alguna pregunta.