Projet 2 - Mini outil CLI de gestion de tâches (en mémoire)

Votre deuxième défi en Rust : un gestionnaire de tâches personnel

Après avoir exploré le monde ludique avec le jeu de devinette, notre second projet Rust vous propose de construire une application plus utilitaire : un mini outil en ligne de commande (CLI) pour la gestion de tâches. Ce type d'outil, bien que simple dans sa version de base, est extrêmement courant et constitue une excellente plateforme pour approfondir votre maîtrise des structures de données et de la logique applicative en Rust.

L'idée est de créer un programme qui permet à l'utilisateur d'ajouter des tâches à une liste, de visualiser les tâches existantes, et potentiellement (en guise d'amélioration) de marquer des tâches comme complétées ou de les supprimer. Pour cette version initiale, nous nous concentrerons sur l'ajout et la listage, et les tâches seront stockées uniquement en mémoire, c'est-à-dire qu'elles disparaîtront à la fermeture du programme.

Ce projet vous amènera à manipuler des collections de données, à définir vos propres types avec des structures, et à concevoir une interface utilisateur textuelle simple mais efficace. C'est une étape logique après le jeu de devinette, introduisant plus de complexité dans la gestion des données tout en restant accessible.

Objectif : créer un programme pour ajouter et lister des tâches simples

L'objectif principal de ce second projet est de concevoir et implémenter un programme permettant à un utilisateur d'ajouter des descriptions de tâches à une liste et de consulter cette liste. Chaque tâche sera représentée par une simple description textuelle.

Les fonctionnalités minimales attendues sont :

• Ajouter une tâche : L'utilisateur doit pouvoir entrer une commande (par exemple, "ajouter Ma nouvelle tâche") pour insérer une nouvelle tâche dans sa liste.
• Lister les tâches : L'utilisateur doit pouvoir entrer une commande (par exemple, "lister") pour afficher toutes les tâches actuellement enregistrées, peut-être avec un numéro d'identification.
• Quitter : Une commande pour terminer l'application proprement (par exemple, "quitter").

Ce périmètre, bien que restreint, couvre les aspects fondamentaux de la manipulation de données en mémoire et de l'interaction utilisateur en mode texte. Il pose les bases pour des fonctionnalités plus avancées si vous souhaitez étendre le projet par la suite.

Compétences mises en oeuvre : structuration des données et interactions CLI

Ce projet de gestionnaire de tâches vous permettra de mettre en oeuvre et de renforcer plusieurs compétences clés en Rust, en s'appuyant sur les acquis du projet précédent et en introduisant de nouveaux concepts :

• Utilisation de struct pour modéliser une tâche : Vous apprendrez à définir votre propre type de données pour représenter une tâche. Une structure simple pourrait contenir un champ pour la description (String) et peut-être un identifiant unique (usize) ou un statut (bool pour complétée/non complétée, dans une version plus avancée).
• Utilisation de Vec<T> pour stocker les tâches : Le vecteur (Vec) de Rust est une collection redimensionnable qui sera parfaite pour stocker la liste des tâches. Vous pratiquerez l'ajout d'éléments à un vecteur et l'itération sur ses éléments.
• Manipulation de chaînes de caractères (String et &str) : L'interprétation des commandes de l'utilisateur (par exemple, séparer "ajouter" de "Ma nouvelle tâche") et le stockage des descriptions de tâches impliqueront une manipulation plus poussée des chaînes.
• Définition et appel de fonctions : Pour organiser le code de manière modulaire et lisible, vous décomposerez la logique de l'application en plusieurs fonctions (par exemple, une fonction pour ajouter une tâche, une pour lister les tâches, une pour traiter l'entrée utilisateur).
• Interaction basique avec l'utilisateur en ligne de commande : Similaire au projet précédent, vous lirez les commandes de l'utilisateur, mais cette fois, vous devrez analyser ces commandes pour déterminer l'action à effectuer et les éventuels arguments (comme le texte de la tâche).

Maîtriser ces éléments est crucial pour développer des applications CLI robustes et bien structurées en Rust. Ce projet offre un cadre pratique idéal pour cet apprentissage.

Structure du développement : étapes guidées et pistes d'amélioration

Comme pour le jeu de devinette, nous procéderons par étapes guidées pour construire notre gestionnaire de tâches. Cette approche incrémentale vous aidera à assimiler chaque nouvelle fonctionnalité et chaque concept Rust associé.

Les étapes typiques pourraient inclure :

1. Initialisation du projet et définition de la structure de base (la boucle principale d'interaction).
2. Définition de la structure Tache (ou Task).
3. Implémentation de la logique pour ajouter une tâche (lecture de la description, création d'une instance de Tache, ajout au vecteur).
4. Implémentation de la logique pour lister les tâches (itération sur le vecteur et affichage formaté).
5. Mise en place de la reconnaissance des commandes utilisateur.
6. Ajout d'une commande pour quitter le programme.

Une fois le coeur fonctionnel de l'application en place, nous explorerons également quelques pistes d'amélioration simples. Celles-ci pourraient inclure :

• Attribuer un identifiant unique à chaque tâche lors de son ajout.
• Permettre de marquer une tâche comme "complétée".
• Permettre de supprimer une tâche (par son identifiant).
• Une gestion d'erreur plus fine pour les commandes invalides ou les arguments manquants.

Ces extensions optionnelles vous donneront l'occasion de relever des défis supplémentaires et d'approfondir encore davantage votre compréhension de Rust. L'objectif est de vous fournir un projet de base solide que vous pourrez ensuite faire évoluer selon vos envies et votre curiosité.