Cargo - Sistema de compilación y gestor de paquetes

En este capítulo te mostraré una introducción al uso de Cargo.

¿Qué es Cargo?

Cargo es un sistema de compilación y gestor de paquetes para Rust. Esta herramienta fundamental nos facilita muchas tareas, tales como compilar programas, descargar las dependencias necesarias, etc.

Por el momento no hemos utilizado dependencias, lo haremos cuando empecemos a trabajar con bibliotecas.

La herramienta Cargo viene instalada con Rust, por ese motivo la pudimos utilizar de forma muy básica en un capítulo anterior.

Comprobar la versión de Cargo

Para comprobar la versión de Cargo, utiliza este comando en la terminal:

cargo --version

Si te aparece un error como '"cargo" no se reconoce como un comando interno o externo...' quiere decir que tienes algún problema con las variables de entorno. Tendrás que revisar el capítulo de la instalación, ya que se debería configurar con la instalación de Rust.

Crear un proyecto de prueba

Para probar un poco esta nueva extensión, vamos a probar de crear un nuevo proyecto, que ejecutará un ¡Hola mundo! en la consola.

Para ello abre un proyecto vacío en Visual Studio Code. Abre la terminal y pon el siguiente comando (lo explicaré todo con más detalle en otro capítulo):

cargo new hola_mundo

Se creará una carpeta con archivos. Te interesa abrir el archivo "main.rs".

Los archivos que se han creado son los siguientes:

• hola_mundo: carpeta de proyecto
• src: carpeta (sources) que contendrá los archivos de código fuente
• main.rs: archivo de código fuente Rust
• .gitignore: archivo para ignorar ciertos elementos del proyecto al utilizar control de versiones con Git.
• Cargo.toml: archivo con formato TOML (Tom's Obvious Minimal Language).

Configuración del archivo TOML

Vamos a configurar de forma básica el archivo Cargo.toml.

Al abrirlo nos encontramos con estas líneas:

[package]
name = "hola_mundo"
version = "0.1.0"
edition = "2021"

[dependencies]

Si quieres ayudas para el código TOML en Visual Studio Code, instala una extensión como esta:

Análisis del archivo TOML

Sección package

Esta sección define la información básica sobre tu proyecto Rust:

• name = "hola_mundo": Indica que el nombre del proyecto es "hola_mundo".
• version = "0.1.0": Especifica la versión actual del proyecto, en este caso "0.1.0".
• edition = "2021": Define la edición del lenguaje Rust que se utiliza en el proyecto. En este caso, se está utilizando la edición de 2021. Las ediciones del lenguaje Rust introducen cambios en la sintaxis y las características disponibles, por lo que es importante especificar la que se utiliza para garantizar la compatibilidad.

Sección dependencies

Esta sección nos servirá para ir añadiendo dependencias para el proyecto.

Carpeta src

Finalmente tenemos la carpeta src que lleva un archivo llamado main.rs. Este contiene una función de inicio main():

fn main() {
    println!("Hello, world!");
}

Fíjate bien en el println!(), no es exactamente una función, se llama macro en Rust. Puedes diferenciar una llamada a una función de una macro mediante el símbolo ! en el nombre.
Hablaremos más sobre macros y funciones cuando llegue el momento.

Todos los archivos y carpetas del programa, deberías dejarlos en la carpeta src, para seguir unas buenas prácticas.

Fuera de esta, colocarás archivos de información y configuraciones, tales como README.md, Cargo.toml, .gitignore, etc.

Compilar con Cargo

Ahora, vamos a compilar con Cargo. Para ello, vamos a poner el siguiente comando en la terminal:

cargo build

Piensa que el prompt debe estar en la ruta del proyecto Rust, en el caso de estos ejemplos, en la carpeta "hola_mundo".

E:\Cursos\rust\hola_mundo>cargo build   
    Compiling hola_mundo v0.1.0 (E:\Cursos\rust\hola_mundo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 8.96s

El comando cargo build es una de las funciones más utilizadas en el desarrollo de proyectos Rust. Su función principal es compilar el código Rust de tu proyecto en un ejecutable o biblioteca.

¿Qué hace cargo build?

• Compilación: Toma el código fuente Rust escrito en archivos .rs y lo transforma en un ejecutable o biblioteca que se puede ejecutar en tu sistema.
• Gestión de dependencias: Resuelve las dependencias de tu proyecto, descargando e instalando las bibliotecas externas que necesitas para que tu código funcione correctamente.
• Optimización: Si se utiliza la bandera --release, optimiza el código para mejorar su rendimiento y tamaño.
• Salida: Genera archivos ejecutables en la carpeta target/debug (modo depuración) o target/release (modo release).

Vamos a ejecutar el ejecutable creado. Para ello, debes acceder a la ruta "target\debug\". Ahí lo encontrarás. Luego, introduce el nombre del ejecutable en la terminal, para ejecutarlo.

E:\Cursos\rust\hola_mundo\target\debug>hola_mundo.exe
Hello, world!

Cargo run

Utilizar cargo run es más simple que lo anterior. Con este comando podemos compilar el programa, y ejecutarlo todo de una vez.

E:\Cursos\rust\hola_mundo>cargo run     
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.03s
    Running `target\debug\hola_mundo.exe`
Hello, world!

Además, con la extensión que instalamos anteriormente, podrás ejecutar directamente desde un botón que añade a Visual Studio Code:

Cargo check

Con el comando Cargo check, puedes comprobar el código sin generar un archivo ejecutable.

Esto hace que el proceso sea más rápido, al no tener que generar un ejecutable.

Vamos a provocar un fallo. Así lo probamos:

fn main() {
    println!("Hello, world!"); asdfghjkl
}

E:\Cursos\rust\hola_mundo>cargo check
    Checking hola_mundo v0.1.0 (E:\Cursos\rust\hola_mundo)
error[E0425]: cannot find value `asdfghjkl` in this scope
 --> src\main.rs:2:32
  |
2 |     println!("Hello, world!"); asdfghjkl
  |                                ^^^^^^^^^ not found in this scope

For more information about this error, try `rustc --explain E0425`.
error: could not compile `hola_mundo` (bin "hola_mundo") due to 1 previous error

Cada vez que vayas a compilar o comprobar un programa, acuérdate de guardar los cambios, para que se hagan efectivos.

Tenemos un error, pero si lo ponemos todo correcto, la comprobación con cargo chechk será satisfactoria.

Cargo build --release

Una vez terminado el programa, puedes crear un ejecutable final compilado con optimizaciones. Esto tarda más que hacer una compilación sin ellas, pero está pensado para hacerse para finalizar. Esto hará que el código Rust sea más rápido.

Algo que me gusta de Rust y Cargo es que separan una parte para el desarrollo (modo debug), y otra para el usuario final (modo release).

De las prácticas anteriores, tenemos creada la carpeta debug en la carpeta target. Ahora crearemos una llamada release, que contendrá el ejecutable final.

E:\Cursos\rust\hola_mundo>cargo build --release
    Compiling hola_mundo v0.1.0 (E:\Cursos\rust\hola_mundo)
    Finished `release` profile [optimized] target(s) in 1.60s

Fíjate que en la salida pone profile [optimized]. Antes ponía profile [unoptimized]

Archivo .gitignore

Por defecto, como he comentado antes, en el archivo .gitignore se ignoran los archivos contenidos en la carpeta target. Esto quiere decir que no van a ser manejados en las versiones de Git, si no borramos esa línea.

Por el momento no lo tocaremos.