fix: cargo correct position in map

content/4.cargo/1.format.md

@@ -1,18 +1,15 @@
 ---
-title: 'Cargo'
-description: ''
+title: "Cargo Format"
+description: "cargo fmt: El Formateador Oficial de Rust para Código Limpio y Consistente"
 draft: true
 data:
-  type: 'custom'
-  topicLevel: 'start'
+  type: "custom"
+  topicLevel: "start"
   position:
-    x: 200
+    x: -150
     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`.

content/4.cargo/2.modules.md

@@ -1,18 +1,17 @@
 ---
-title: 'Cargo'
-description: ''
+title: "Modulos"
+description: "Organizando Proyectos en Rust: Módulos y Visibilidad"
 draft: true
 data:
-  type: 'custom'
-  topicLevel: 'start'
+  type: "custom"
+  topicLevel: "medium"
   position:
-    x: 200
+    x: 0
     y: 750
   sourcePosition:
-    error-handling: 'right'
-  targetPosition:
-    traits: 'bottom'
+    cargo: "right"
 ---
+
 # Organizando Proyectos en Rust: Módulos y Visibilidad
 
 Cuando desarrollamos en Rust, mantener el código organizado es esencial para la escalabilidad y la mantenibilidad. Rust ofrece un sistema de módulos flexible que nos ayuda a dividir el código en componentes más manejables. En este artículo exploraremos cómo crear y gestionar módulos, controlar su visibilidad, y estructurar proyectos de manera eficiente, abordando las prácticas más recomendadas en la comunidad.
@@ -34,6 +33,7 @@ Un módulo puede contener funciones, estructuras, enumeraciones, constantes e in
 ## Crear y gestionar módulos
 
 ### Módulos en el mismo archivo
+
 La forma más sencilla de declarar un módulo es hacerlo directamente en el archivo:
 
 ```rust
@@ -45,6 +45,7 @@ mod math {
 ```
 
 Luego accedes a los elementos públicos con el prefijo del módulo:
+
 ```rust
 fn main() {
     let sum = math::add(2, 3);
@@ -53,9 +54,11 @@ fn main() {
 ```
 
 ### Módulos en archivos separados
+
 Para mantener el código limpio, puedes mover los módulos a archivos independientes:
 
 En `main.rs`:
+
 ```rust
 mod math;
 
@@ -66,16 +69,19 @@ fn main() {
 ```
 
 En `math.rs`:
+
 ```rust
 pub fn add(a: i32, b: i32) -> i32 {
     a + b
 }
 ```
 
 ### Módulos como directorios
+
 Si un módulo incluye submódulos, puedes organizarlo en un directorio con un archivo `mod.rs` o estructurarlo usando archivos con el mismo nombre que los submódulos.
 
 Estructura de ejemplo:
+
 ```
 src/
 ├── main.rs
@@ -86,6 +92,7 @@ src/
 ```
 
 En `math/mod.rs`:
+
 ```rust
 pub mod add;
 pub mod multiply;
@@ -113,6 +120,7 @@ mod shapes {
 ```
 
 El acceso desde otro módulo o función será así:
+
 ```rust
 fn main() {
     let rect = shapes::Rectangle { width: 10, height: 20 };
@@ -127,6 +135,7 @@ fn main() {
 La organización de un proyecto depende de su propósito. Aquí hay patrones comunes:
 
 ### 1. **Proyectos ejecutables simples**
+
 Los proyectos pequeños suelen tener un único archivo `main.rs`:
 
 ```
@@ -135,6 +144,7 @@ src/
 ```
 
 ### 2. **Proyectos ejecutables grandes**
+
 A medida que crece, puedes mover lógica a módulos:
 
 ```
@@ -146,13 +156,15 @@ src/
 ```
 
 En `main.rs`:
+
 ```rust
 mod config;
 mod handlers;
 mod utils;
 ```
 
 ### 3. **Bibliotecas**
+
 Las bibliotecas usan un archivo `lib.rs` para exponer su API pública:
 
 ```
@@ -162,11 +174,13 @@ src/
 ```
 
 En `lib.rs`:
+
 ```rust
 pub mod utils;
 ```
 
 ### 4. **Híbridos (ejecutable + biblioteca)**
+
 Un proyecto puede tener `main.rs` para la aplicación y `lib.rs` para lógica reutilizable:
 
 ```
@@ -176,6 +190,7 @@ src/
 ```
 
 En `main.rs`:
+
 ```rust
 use mycrate::utils::some_function;
 
@@ -185,6 +200,7 @@ fn main() {
 ```
 
 En `lib.rs`:
+
 ```rust
 pub mod utils {
     pub fn some_function() {
@@ -194,6 +210,7 @@ pub mod utils {
 ```
 
 ### 5. **Proyectos con múltiples binarios**
+
 Usa un directorio `src/bin/` para incluir otros ejecutables:
 
 ```
@@ -210,22 +227,27 @@ src/
 ## Puntos de entrada: `main.rs` y `lib.rs`
 
 ### `main.rs`
+
 Es el punto de entrada de los ejecutables. Aquí defines la lógica inicial de tu programa.
 
 ### `lib.rs`
+
 Sirve como punto de entrada para bibliotecas. Aquí defines qué módulos y funciones serán públicos para los usuarios de la biblioteca.
 
 ### Coexistencia de `main.rs` y `lib.rs`
+
 En proyectos híbridos, `lib.rs` puede contener la lógica principal reutilizable y `main.rs` consumirla:
 
 En `lib.rs`:
+
 ```rust
 pub fn greet(name: &str) {
     println!("Hola, {}!", name);
 }
 ```
 
 En `main.rs`:
+
 ```rust
 use mycrate::greet;
 

content/4.cargo/3.workspaces.md

@@ -1,18 +1,16 @@
 ---
-title: 'Cargo'
-description: ''
+title: "Organización de proyectos"
+description: "Workspaces en Rust: Organización Escalable para Proyectos Grandes"
 draft: true
 data:
-  type: 'custom'
-  topicLevel: 'start'
+  type: "custom"
+  topicLevel: "medium"
+  width: 255
   position:
-    x: 200
-    y: 750
-  sourcePosition:
-    error-handling: 'right'
-  targetPosition:
-    traits: 'bottom'
+    x: -150
+    y: 790
 ---
+
 # Workspaces en Rust: Organización Escalable para Proyectos Grandes
 
 A medida que los proyectos en Rust crecen, mantenerlos organizados y eficientes puede volverse un desafío. Aquí es donde los **workspaces** entran en juego. Un workspace te permite gestionar múltiples crates en un mismo proyecto, promoviendo la modularidad, el rendimiento y la mantenibilidad. En este artículo, exploraremos cómo estructurar y aprovechar al máximo los workspaces en Rust.
@@ -63,6 +61,7 @@ my_project/
 ## Configuración de un workspace
 
 ### Archivo `Cargo.toml` raíz
+
 El archivo principal debe incluir la clave `[workspace]` y especificar los miembros del workspace:
 
 ```toml
@@ -75,6 +74,7 @@ members = [
 ```
 
 ### Configuraciones compartidas
+
 Puedes definir dependencias o configuraciones comunes en el archivo raíz:
 
 ```toml
@@ -101,15 +101,19 @@ Separar un proyecto en múltiples crates dentro de un workspace tiene sentido cu
 ## Mejores prácticas para organizar workspaces
 
 ### 1. Usa la convención `crates/`
+
 Agrupar los crates bajo `crates/` facilita la navegación y muestra claramente que forman parte del mismo proyecto.
 
 ### 2. Crea crates reutilizables
+
 Si un módulo puede ser útil en otros proyectos, conviértelo en un crate separado dentro del workspace.
 
 ### 3. Mantén un crate "principal"
+
 Usualmente, un proyecto tiene un crate principal (normalmente en `src/`) que actúa como ejecutable o punto de entrada, mientras los demás crates proveen funcionalidad modular.
 
 ### 4. Reexporta dependencias
+
 Si varios crates usan las mismas dependencias, considera centralizarlas en un crate compartido y reexportarlas para simplificar:
 
 ```rust
@@ -124,6 +128,7 @@ Esto reduce la duplicación y mejora el tiempo de compilación.
 ## Gestión de dependencias compartidas
 
 ### Usar `[workspace.dependencies]`
+
 Define dependencias compartidas en el archivo raíz para evitar redundancia:
 
 ```toml
@@ -134,6 +139,7 @@ tokio = { version = "1", features = ["full"] }
 Esto asegura que todas las crates usen exactamente la misma versión de la dependencia.
 
 ### Información de paquetes compartida
+
 Puedes especificar configuraciones comunes como autor o licencia en el archivo raíz:
 
 ```toml
@@ -147,6 +153,7 @@ license = "MIT"
 ## Comandos comunes en un workspace
 
 ### 1. Afectar un crate específico
+
 En workspaces, puedes usar la opción `-p` (o `--package`) para seleccionar un crate:
 
 ```bash
@@ -155,6 +162,7 @@ cargo test -p crate_b
 ```
 
 ### 2. Agregar o eliminar dependencias
+
 Cuando trabajas con crates específicos, usa `--manifest-path`:
 
 ```bash
@@ -163,6 +171,7 @@ cargo remove log --manifest-path crates/crate_b/Cargo.toml
 ```
 
 ### 3. Crear un nuevo crate
+
 Usa `cargo new` dentro del directorio de crates y luego agrégalo al workspace:
 
 ```bash
@@ -172,6 +181,7 @@ cargo new crates/crate_d --lib
 Luego, edita el archivo `Cargo.toml` principal para incluirlo en `[workspace.members]`.
 
 ### 4. Ejecutar un crate
+
 Si el workspace contiene múltiples ejecutables, selecciona cuál ejecutar:
 
 ```bash
@@ -183,6 +193,7 @@ cargo run -p crate_c
 ## Automatización y pruebas en workspaces
 
 ### Pruebas
+
 Ejecuta las pruebas de todos los crates con:
 
 ```bash
@@ -196,6 +207,7 @@ cargo test -p crate_a
 ```
 
 ### Benchmarks
+
 Ejecuta benchmarks de todos los crates o selecciona uno:
 
 ```bash

content/4.cargo/index.md

@@ -1,18 +1,20 @@
 ---
-title: 'Cargo'
-description: ''
+title: "Cargo"
+description: ""
 draft: true
 data:
-  type: 'custom'
-  topicLevel: 'start'
+  type: "custom"
+  topicLevel: "start"
   position:
     x: 200
     y: 750
   sourcePosition:
-    error-handling: 'right'
+    error-handling: "right"
   targetPosition:
-    traits: 'bottom'
+    traits: "bottom"
+    modules: "left"
 ---
+
 ## Introducción a Cargo: La Herramienta Esencial para el Ecosistema Rust
 
 Una de las razones por las que Rust se ha convertido en un lenguaje popular es su ecosistema robusto y bien integrado. En el corazón de este ecosistema está **Cargo**, la herramienta oficial para gestionar proyectos en Rust. Cargo no solo se encarga de la construcción de tus proyectos, sino también de la gestión de dependencias, pruebas, y mucho más. Este artículo explora los comandos y características más importantes de Cargo, ayudándote a aprovechar al máximo esta poderosa herramienta.
@@ -56,9 +58,11 @@ cargo add serde
 Esto agrega `serde` a tu archivo `Cargo.toml` bajo las dependencias estándar. Si quieres marcar una dependencia como opcional o específica de desarrollo, puedes usar las siguientes opciones:
 
 - **Dependencia de desarrollo:**
+
   ```bash
   cargo add --dev rand
   ```
+
   Esto agrega la dependencia bajo `[dev-dependencies]`, útil para herramientas y pruebas que no se incluyen en el binario final.
 
 - **Dependencia opcional:**