feat(content): add cargo format

Author: SergioRibera

content/4.cargo/1.format.md

@@ -0,0 +1,179 @@
+---
+title: 'Cargo'
+description: ''
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 200
+    y: 750
+  sourcePosition:
+    error-handling: 'right'
+  targetPosition:
+    traits: 'bottom'
+---
+## `cargo fmt`: El Formateador Oficial de Rust para Código Limpio y Consistente
+
+Una de las mayores fortalezas de Rust es su énfasis en la claridad y legibilidad del código. Para garantizar un estilo uniforme en proyectos individuales y colaborativos, Rust incluye una herramienta llamada `rustfmt`, que se integra directamente con Cargo mediante el comando `cargo fmt`.
+
+En este artículo, exploraremos cómo usar `cargo fmt` para formatear tu código, configurarlo según tus necesidades, y automatizar su uso en pipelines como GitHub Actions y GitLab CI/CD. Además, explicaremos cómo instalarlo en caso de que no esté disponible en tu entorno.
+
+---
+
+### ¿Qué es `cargo fmt` y por qué es útil?
+
+`cargo fmt` es el comando de Cargo que ejecuta `rustfmt`, el formateador oficial de Rust. Esta herramienta reformatea tu código siguiendo las convenciones oficiales de estilo de Rust, lo que asegura:
+
+1. **Consistencia:** Todo el código sigue un estándar, independientemente de quién lo escribió.
+2. **Legibilidad:** Mejora la comprensión del código al aplicar un formato claro y predecible.
+3. **Productividad:** Reduce el tiempo dedicado a debates sobre estilo de código en revisiones de código (code reviews).
+
+Además, es particularmente útil en entornos colaborativos y automatizaciones, como pipelines de integración continua (CI), donde puedes validar automáticamente que el código esté correctamente formateado antes de aceptar cambios.
+
+---
+
+### Instalación y Configuración Inicial
+
+#### Instalación de `rustfmt`
+
+Si tienes Rust instalado mediante `rustup`, `rustfmt` ya debería estar disponible. Si no, puedes instalarlo fácilmente con el siguiente comando:
+
+```bash
+rustup component add rustfmt
+```
+
+Este comando asegura que `rustfmt` esté disponible para tu versión actual de Rust.
+
+#### Verificando la instalación
+
+Para confirmar que `rustfmt` está instalado, puedes ejecutar:
+
+```bash
+cargo fmt --version
+```
+
+Esto debería mostrar la versión instalada de `rustfmt`.
+
+---
+
+### Uso Básico de `cargo fmt`
+
+Para formatear todo tu proyecto, simplemente ejecuta:
+
+```bash
+cargo fmt
+```
+
+Esto aplicará las reglas de estilo a todos los archivos en tu proyecto, incluidos los módulos en subdirectorios. Si deseas verificar el formato sin modificar los archivos (modo de comprobación), usa:
+
+```bash
+cargo fmt --check
+```
+
+El modo `--check` es especialmente útil en pipelines de CI para validar que el código esté correctamente formateado antes de fusionar cambios.
+
+---
+
+### Configuración de `rustfmt`
+
+Puedes personalizar `rustfmt` mediante un archivo de configuración llamado `rustfmt.toml`. Este archivo puede colocarse en la raíz de tu proyecto y permite ajustar varias opciones de estilo.
+
+#### Ejemplo de archivo `rustfmt.toml`
+
+```toml
+# rustfmt.toml
+max_width = 100          # Establece el ancho máximo de las líneas
+tab_spaces = 4           # Usa 4 espacios por tabulación
+use_small_heuristics = "Off" # Desactiva heurísticas para expresiones cortas
+newline_style = "Unix"   # Usa saltos de línea estilo Unix (\n)
+```
+
+#### Configuración desde `Cargo.toml`
+
+Si deseas asegurarte de que todos los colaboradores utilicen la configuración adecuada, puedes especificar el archivo `rustfmt.toml` en el archivo `Cargo.toml`:
+
+```toml
+[package.metadata.rustfmt]
+config-path = "rustfmt.toml"
+```
+
+Esto garantiza que `cargo fmt` use la configuración personalizada, incluso si el archivo `rustfmt.toml` está en una ubicación no estándar.
+
+---
+
+### Integración de `cargo fmt` en Pipelines de CI
+
+#### Usando GitHub Actions
+
+Aquí tienes un ejemplo de configuración para GitHub Actions que valida el formato de código en cada push:
+
+```yaml
+name: Check Code Format
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  format-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+
+      - name: Install rustfmt
+        run: rustup component add rustfmt
+
+      - name: Check Code Format
+        run: cargo fmt --all --check
+```
+
+Este pipeline asegura que el código esté correctamente formateado antes de fusionar cambios en la rama principal.
+
+#### Usando GitLab CI/CD
+
+En GitLab CI/CD, puedes configurar un trabajo para validar el formato del código de la siguiente manera:
+
+```yaml
+stages:
+  - format
+
+format_check:
+  stage: format
+  image: rust:latest
+  script:
+    - rustup component add rustfmt
+    - cargo fmt --all --check
+  only:
+    - merge_requests
+    - main
+```
+
+Este trabajo valida el formato en los cambios propuestos (merge requests) y en la rama principal.
+
+---
+
+### Buenas Prácticas y Recomendaciones
+
+1. **Formatea antes de hacer commits:** Integra `cargo fmt` en tus hooks de pre-commit con herramientas como [pre-commit](https://pre-commit.com/). Esto asegura que todos los commits tengan un formato limpio.
+
+2. **Automatiza validaciones:** Usa `cargo fmt --check` en tus pipelines para garantizar la consistencia del formato en todos los cambios.
+
+3. **Mantén una configuración compartida:** Incluye un archivo `rustfmt.toml` en el repositorio para que todos los colaboradores usen el mismo estilo.
+
+4. **Evita excepciones innecesarias:** Aunque puedes personalizar el formato, es mejor adherirse a las reglas predeterminadas, ya que son el estándar en la comunidad Rust.
+
+---
+
+### Conclusión
+
+`cargo fmt` es una herramienta esencial en el ecosistema Rust para garantizar un código limpio, legible y consistente. Su facilidad de uso, combinada con la capacidad de personalización y la integración en pipelines, lo hace indispensable para proyectos de cualquier escala. A medida que trabajes en proyectos colaborativos, adoptar `cargo fmt` no solo te ahorrará tiempo, sino que también mejorará la calidad general del código. ¡Haz que `cargo fmt` sea parte de tu flujo de trabajo y lleva tus proyectos al siguiente nivel! 🚀