Comment structurer un projet Rust ?

02/10/2024

André Leclercq

Lorsque l’on démarre un nouveau projet, il est crucial de savoir comment il sera structuré. Cela peut être difficile lorsqu’on apprend les bases d’un langage de programmation. Je vais donc vous expliquer une organisation pratique et simple pour structurer un projet Rust.

Nous allons voir comment se structure un projet de base et la différence entre un projet binaire et une bibliothèque. Ainsi, vous pourrez vous concentrer sur l’apprentissage de Rust tout en bénéficiant d’une structure claire pour vos premiers projets.

Structure de base d’un projet Rust

En Rust, les projets sont structurés pour faciliter la gestion du code, la compilation et les tests. Voici un exemple de structure de base.

Exemple de structure de projet

my_project/
├── Cargo.toml
├── Cargo.lock
├── src/
│   ├── main.rs
│   └── lib.rs
├── tests/
│   └── integration_test.rs
├── examples/
│   └── example_usage.rs
└── benches/
    └── benchmark.rs

Descriptions des dossiers et fichiers

Cargo.toml : ce fichier est à la racine du projet et contient les informations de configuration du projet. Il définit les métadonnées du projet comme le nom, la version, les auteurs, ainsi que les dépendances nécessaires pour le projet.
src/ : ce répertoire contient le code source du projet. Le fichier principal est généralement src/main.rs pour les applications binaires ou src/lib.rs pour les bibliothèques.
Cargo.lock : ce fichier est généré automatiquement par Cargo, le gestionnaire de paquets de Rust. Il verrouille les versions des dépendances utilisées dans le projet pour garantir que les mêmes versions sont utilisées à chaque compilation.
target/ : ce répertoire est généré automatiquement et contient les artefacts de compilation. Il inclut les exécutables compilés et les fichiers intermédiaires.
tests/ (optionnel) : ce répertoire peut contenir des tests d’intégration. Ces tests sont des programmes Rust complets qui vérifient le comportement du projet dans son ensemble.
examples/ (optionnel) : ce répertoire peut contenir des exemples de programmes utilisant le projet. Ces exemples montrent comment utiliser la bibliothèque ou les fonctionnalités de l’application.
benches/ (optionnel) : ce répertoire peut contenir des benchmarks pour mesurer les performances du projet. Les benchmarks sont des tests de performance qui utilisent la bibliothèque criterion ou d’autres outils de benchmarking.

Détails sur certains fichiers et répertoires

Cargo.toml

Il inclut des sections pour les dépendances ([dependencies]), les dépendances de développement ([dev-dependencies]), et d’autres configurations spécifiques comme les caractéristiques ([features]).

[package]
name = "my_project"
version = "0.1.0"
authors = ["Votre Nom <email@example.com>"]
edition = "2021"

[dependencies]
serde = "1.0"

src/main.rs

Pour un projet binaire, ce fichier contient le point d’entrée principal du programme.

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

src/lib.rs

Pour une bibliothèque, ce fichier contient les fonctions et structures principales que la bibliothèque expose.

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

Tests d’intégration

Les tests d’intégration dans tests/ sont des fichiers Rust complets qui peuvent utiliser la bibliothèque de manière similaire à un utilisateur final. Un simple cargo test permet de lancer les tests.

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

En suivant cette structure, les projets Rust restent bien organisés et conformes aux standards, ce qui facilite la collaboration, la maintenance et la distribution du code.

Projet binaire ou bibliothèque ?

La principale différence entre un projet binaire et une bibliothèque en Rust réside dans leur objectif et dans leur structure. Un projet binaire produit un exécutable autonome avec un point d’entrée, main, tandis qu’une bibliothèque produit un ensemble réutilisable de fonctionnalités sans point d’entrée. Cette distinction guide comment vous structurez et organisez votre projet en Rust.

Projet binaire

Un projet binaire en Rust est une application autonome qui compile en un exécutable. Il contient un point d’entrée, main qui est exécutée lorsque vous lancez le programme. Un projet binaire contient généralement un fichier src/main.rs qui définit la fonction main. La fonction main est le point d’entrée du programme et est exécutée lorsque le programme démarre.
Le résultat de la compilation est un fichier exécutable que vous pouvez exécuter directement sur votre système d’exploitation. Les projets binaires sont utilisés pour créer des applications complètes comme des outils en ligne de commande, des serveurs web, des jeux, etc.

src/main.rs :

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

Cargo.toml pour un projet binaire :

[package]
name = "my_binary_project"
version = "0.1.0"
authors = ["Votre Nom <email@example.com>"]
edition = "2021"

[dependencies]
# Dépendances pour le projet binaire

Bibliothèque

Une bibliothèque en Rust est un ensemble de fonctions, structures, traits et autres éléments de code réutilisables que d’autres projets peuvent inclure et utiliser. Elle n’a pas de point d’entrée. Le résultat de la compilation est une crate (un paquet de Rust) qui peut être utilisé comme une dépendance dans d’autres projets. Elles sont utilisées pour encapsuler du code réutilisable qui peut être partagé entre différents projets. Elles sont souvent publiées sur des registres de paquets comme crates.io.

src/lib.rs :

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

Cargo.toml pour une bibliothèque :

[package]
name = "my_library_project"
version = "0.1.0"
authors = ["Votre Nom <email@example.com>"]
edition = "2021"

[lib]
name = "my_library"
path = "src/lib.rs"

[dependencies]
# Dépendances pour la bibliothèque

Structurer un projet Rust, encore un atout pour ce langage !

Structurer un projet Rust correctement dès le départ est essentiel pour une gestion efficace de son code, une compilation sans difficulté et des tests robustes. Peu importe que votre projet soit binaire ou une bibliothèque, Rust offre une organisation claire et standardisée qui vous permet de vous concentrer sur votre apprentissage et le développement. En suivant les recommandations et en adoptant les bonnes pratiques de structuration que propose Rust, vous pourrez non seulement faciliter votre travail, mais aussi collaborer plus facilement avec d’autres développeurs et maintenir votre code de manière plus efficace tout en réduisant la dette technique.

Bon code à tous ! Et puisque vous savez maintenant tout pour bien structurer un projet Rust, nous vous invitons à installer Rust, si ça n’est pas déjà fait ou à réviser le concept d’ownership.