Initialiser un nouveau projet : `cargo new` vs `cargo init`

Comprendre les commandes d'initialisation de projet Cargo

Lancer un nouveau projet en Rust est une opération fluide et standardisée grâce à Cargo, l'outil de gestion de projet et de construction officiel de Rust. Au coeur de cette initialisation se trouvent deux commandes principales : `cargo new` et `cargo init`. Bien qu'elles servent toutes deux à mettre en place la structure d'un projet Rust, elles répondent à des contextes d'utilisation distincts. Une compréhension claire de leurs différences vous permettra de choisir l'outil adéquat pour chaque situation et de démarrer vos développements sur des fondations solides et bien organisées.

Ces commandes sont les portes d'entrée dans l'écosystème de développement Rust, préparant le terrain pour l'écriture de votre code, la gestion des dépendances et la compilation. Que vous partiez d'une feuille blanche ou que vous souhaitiez intégrer Rust dans une structure de fichiers préexistante, Cargo a une solution adaptée. Explorons en détail le fonctionnement et les cas d'usage de `cargo new` et `cargo init`.

La maîtrise de ces commandes initiales est une étape fondamentale pour tout développeur souhaitant devenir opérationnel rapidement avec Rust, car elles établissent les conventions et la structure que vous utiliserez tout au long du cycle de vie de votre projet.

`cargo new` : créer un nouveau projet Rust à partir de zéro

La commande `cargo new ` est l'outil de choix lorsque vous souhaitez démarrer un projet Rust entièrement nouveau, sans structure de répertoires préexistante. Lorsque vous invoquez cette commande, Cargo effectue plusieurs opérations pour vous simplifier la vie et vous mettre sur les rails rapidement. Premièrement, il crée un nouveau répertoire portant le nom que vous avez spécifié pour votre projet. C'est dans ce répertoire que tous les fichiers et sous-répertoires de votre projet seront contenus.

A l'intérieur de ce nouveau répertoire, `cargo new` initialise automatiquement un dépôt Git, à condition que Git soit installé et accessible sur votre système. Cette intégration native avec Git facilite dès le départ le versionnement de votre code, une pratique essentielle en développement logiciel. Si vous ne souhaitez pas cette initialisation Git, vous pouvez utiliser l'option `--vcs none`.

Plus important encore, Cargo génère la structure de base d'un projet Rust. Cela inclut le fichier manifeste `Cargo.toml`, pré-rempli avec des informations de base comme le nom du projet (déduit du nom du répertoire), une version initiale (`0.1.0`), et l'édition de Rust à utiliser (généralement la dernière édition stable). Il crée également un répertoire `src` qui contiendra votre code source. Par défaut, `cargo new` configure un projet binaire (une application exécutable). Dans ce cas, il place un fichier `src/main.rs` contenant un simple programme "Hello, world!" :

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

Si votre intention est de créer une bibliothèque (une *crate* destinée à être utilisée par d'autres projets Rust) plutôt qu'un exécutable, vous devez ajouter l'option `--lib` à la commande : `cargo new --lib`. Dans ce scénario, au lieu de `src/main.rs`, Cargo générera un fichier `src/lib.rs` avec un exemple de code de bibliothèque et un test unitaire associé. Ce fichier est le point d'entrée de votre bibliothèque.

Voici une illustration de l'utilisation de `cargo new` pour un projet binaire :

$ cargo new mon_app_rust
     Created binary (application) `mon_app_rust` package
$ cd mon_app_rust
$ tree
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

Et pour une bibliothèque :

$ cargo new ma_lib_rust --lib
     Created library `ma_lib_rust` package
$ cd ma_lib_rust
$ tree
.
├── Cargo.toml
└── src
    └── lib.rs

1 directory, 2 files

En somme, `cargo new` est la commande à privilégier pour une initialisation complète et autonome d'un nouveau projet Rust, vous fournissant une structure de départ propre et conforme aux conventions.

`cargo init` : initialiser Cargo dans un répertoire existant

Contrairement à `cargo new` qui crée un nouveau répertoire pour votre projet, la commande `cargo init` est conçue pour structurer un projet Rust au sein d'un répertoire qui existe déjà. Ce scénario se présente typiquement lorsque vous avez un dossier contenant des fichiers de configuration, des données, ou peut-être un projet non-Rust que vous souhaitez migrer ou compléter avec des composants Rust. `cargo init` vous permet d'"activer" Cargo dans ce contexte existant.

Pour utiliser `cargo init`, vous devez d'abord vous placer dans le répertoire que vous souhaitez transformer en projet Rust. Une fois dans ce répertoire, l'exécution de `cargo init` aura pour effet de créer les fichiers et la structure nécessaires à Cargo, à savoir le fichier `Cargo.toml` et le répertoire `src` avec son fichier source initial (`main.rs` par défaut). Elle n'initialise pas de nouveau dépôt Git si le répertoire est déjà suivi par Git, mais peut le faire si ce n'est pas le cas et que l'option `--vcs git` est spécifiée ou implicite.

Tout comme `cargo new`, `cargo init` peut également être utilisé pour créer une bibliothèque en utilisant l'option `--lib` : `cargo init --lib`. Cela générera un `src/lib.rs` au lieu de `src/main.rs`. L'avantage principal de `cargo init` est donc sa capacité à s'intégrer de manière non destructive dans une structure de fichiers préexistante, sans imposer la création d'un nouveau dossier parent.

Prenons un exemple concret. Supposons que vous ayez un répertoire `mon_projet_existant` qui contient déjà des éléments :

$ mkdir mon_projet_existant
$ touch mon_projet_existant/README.md
$ cd mon_projet_existant

Maintenant, pour y initialiser un projet Rust binaire :

$ cargo init
     Created binary (application) `mon_projet_existant` package
$ tree
.
├── Cargo.toml
├── README.md
└── src
    └── main.rs

1 directory, 3 files

Vous pouvez observer que `Cargo.toml` et `src/main.rs` ont été ajoutés aux côtés du `README.md` existant. Le nom du paquet dans `Cargo.toml` sera, par défaut, le nom du répertoire courant.

Si le répertoire est vide, `cargo init` se comporte de manière très similaire à `cargo new .` (en utilisant un point pour indiquer le répertoire courant), mais sans créer de sous-répertoire. Le choix entre `cargo new` et `cargo init` dépend donc essentiellement de votre point de départ : `cargo new` pour une création "ex nihilo" dans un nouveau dossier, et `cargo init` pour une intégration dans un dossier existant.

Tableau récapitulatif : `cargo new` versus `cargo init`

Pour synthétiser les différences et vous aider à choisir la commande la plus appropriée à votre besoin, voici un tableau comparatif des caractéristiques principales de `cargo new` et `cargo init` :

En comprenant ces distinctions, vous êtes désormais armé pour initialiser vos projets Rust de la manière la plus efficace, en fonction de la situation. Ces deux commandes, bien que simples, sont les fondations sur lesquelles repose l'organisation et la gestion de vos futurs développements en Rust avec Cargo.