Amélioration de la javadoc

src/fr/monlouyan/bakefile/BakeCLI.java

@@ -8,7 +8,6 @@ import java.util.ArrayList;
  * 
  * @author Moncef STITI
  * @version 1.0
- * @date 03/02/2025
  * @see Main
  */
 public class BakeCLI {
@@ -26,7 +25,6 @@ public class BakeCLI {
      * Constructeur de la classe BakeCLI
      * 
      * @param args Les arguments passés en ligne de commande
-     * @return void
      * @see Main
      */
     public BakeCLI(String[] args){
@@ -58,7 +56,7 @@ public class BakeCLI {
 
     /**
      * Permet de récupérer les arguments autres que "-d" passés en ligne de commande
-     * @return
+     * @return La liste des arguments
      */
     public static List<String> getTargets(){ return targets; }
 }

src/fr/monlouyan/bakefile/BakeEngine.java

@@ -4,36 +4,83 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+/**
+ * Moteur principal de l'application Bake.
+ * Cette classe est responsable de l'orchestration du processus de build
+ * en utilisant les règles définies dans le fichier Bakefile.
+ * 
+ * @author Moncef STITI, Yanis HAMOUDI, Louay DARDOURI
+ * @version 1.0
+ */
 public class BakeEngine {
+
+	/** Analyseur syntaxique du fichier Bakefile */
     private BakefileParser parser;
+
+	/** Responsable de la résolution des dépendances entre règles */
     private DependencyResolver resolver;
+
+	/** Exécuteur des commandes définies dans les règles */
     private CommandExecutor executor;
+
+	/** Map qui stocke toutes les règles indexées par leur nom */
     private static Map<String, Rule> ruleMap;
     
+	/**
+     * Constructeur qui initialise le moteur Bake.
+     * Crée un parser pour le fichier "Bakefile" par défaut et initialise le résolveur de dépendances.
+     */
     public BakeEngine() {
         this.parser = new BakefileParser("Bakefile");
         this.resolver = new DependencyResolver(BakeCLI.isDebug());
         ruleMap = new HashMap<>();
     }
 
+	/**
+     * Vérifie si une règle avec le nom spécifié existe.
+     * 
+     * @param target Nom de la règle à vérifier
+     * @return true si la règle existe, false sinon
+     */
     public static boolean hasRule(String target) {
         return ruleMap.containsKey(target);
     }
 
+
+	/**
+     * Récupère une règle par son nom.
+     * 
+     * @param target Nom de la règle à récupérer
+     * @return La règle correspondante ou null si elle n'existe pas
+     */
     public static Rule getRule(String target) {
         return ruleMap.get(target);
     }
     
+	/**
+     * Exécute le processus de build complet.
+     * Cette méthode réalise les étapes suivantes :
+     * <ol>
+     *   <li>Parse le fichier Bakefile</li>
+     *   <li>Construit la carte des règles</li>
+     *   <li>Résout les dépendances entre les règles</li>
+     *   <li>Exécute les règles dans l'ordre déterminé</li>
+     * </ol>
+     */
     public void run() {
+		// Analyse le fichier Bakefile pour extraire les règles
         List<Rule> rules = parser.parse();
 
+		// Ajoute toutes les règles à la map pour référence rapide
         for (Rule rule : rules) {
             ruleMap.put(rule.getName(), rule);
         }
 
+		// Résout les dépendances pour déterminer l'ordre d'exécution
         List<Rule> rulesToBuild = resolver.resolve(rules, BakeCLI.getTargets());
         this.executor = new CommandExecutor(BakeCLI.isDebug(), resolver.isCircular());
-        
+		
+		// Exécute les règles dans l'ordre déterminé
         for (Rule rule : rulesToBuild) {
             executor.execute(rule);
         }

src/fr/monlouyan/bakefile/BakefileParser.java

@@ -8,6 +8,14 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
+/**
+ * Parseur de fichier Bakefile.
+ * Cette classe est responsable de l'analyse syntaxique du fichier Bakefile
+ * pour extraire les règles de build, les dépendances et les commandes associées.
+ * 
+ * @author Moncef STITI, Yanis HAMOUDI, Louay DARDOURI
+ * @version 1.0
+ */
 public class BakefileParser {
 	
 	/**
@@ -62,11 +70,21 @@ public class BakefileParser {
      */
     private Map<String, String> variables = new HashMap<>();
     
+	/**
+	 * Constructeur de la classe BakefileParser.
+	 * @param filename Nom du fichier Bakefile à parser
+	 */
     public BakefileParser(String filename) {
         this.filename = filename;
         firstTarget = null;
     }
 
+	/**
+	 * Gérer les lignes de continuation.
+	 * @param lines Liste des lignes du fichier Bakefile
+	 * @param startIndex Index de la première ligne de continuation
+	 * @return La ligne combinée
+	 */
     private String handleContinuationLines(List<String> lines, int startIndex) {
         StringBuilder combinedLine = new StringBuilder();
         int i = startIndex;
@@ -89,6 +107,11 @@ public class BakefileParser {
         return combinedLine.toString();
     }
 
+	/**
+	 * Remplacer les variables dans une chaîne.
+	 * @param input Chaîne à traiter
+	 * @return Chaîne avec les variables remplacées
+	 */
     private String replaceVariables(String input) {
         if (input == null) return null;
         
@@ -126,12 +149,22 @@ public class BakefileParser {
         return result.trim();
     }
 
+	/**
+	 * Remplacer les variables dans une liste de chaînes.
+	 * @param items Liste de chaînes à traiter
+	 * @return Liste de chaînes avec les variables remplacées
+	 */
     private List<String> replaceVariablesInList(List<String> items) {
         return items.stream()
                    .map(this::replaceVariables)
                    .collect(Collectors.toList());
     }
 
+	/**
+	 * Découper les dépendances en une liste de chaînes.
+	 * @param depStr Chaîne de dépendances
+	 * @return Liste de dépendances
+	 */
     private List<String> splitDependencies(String depStr) {
         if (depStr == null || depStr.trim().isEmpty()) {
             return new ArrayList<>();
@@ -144,6 +177,11 @@ public class BakefileParser {
                     .collect(Collectors.toList());
     }
 
+	/**
+	 * Découper les cibles en une liste de chaînes.
+	 * @param targetStr Chaîne de cibles
+	 * @return Liste de cibles
+	 */
     private List<String> splitTargets(String targetStr) {
         if (targetStr == null || targetStr.trim().isEmpty()) {
             return new ArrayList<>();
@@ -156,6 +194,10 @@ public class BakefileParser {
                     .collect(Collectors.toList());
     }
 
+	/**
+	 * Analyser le fichier Bakefile pour extraire les règles de build.
+	 * @return Liste des règles extraites
+	 */
     public List<Rule> parse() {
         List<Rule> rules = new ArrayList<>();
         Set<String> phonyTargets = new HashSet<>();

src/fr/monlouyan/bakefile/CommandExecutor.java

@@ -3,17 +3,49 @@ package fr.monlouyan.bakefile;
 import java.io.File;
 import java.io.IOException;
 
+/**
+ * Exécuteur des commandes définies dans les règles.
+ * Cette classe est responsable de l'exécution des commandes définies dans les règles
+ * du fichier Bakefile.
+ * 
+ * @author Moncef STITI, Yanis HAMOUDI, Louay DARDOURI
+ * @version 1.0
+ */
 public class CommandExecutor {
+	/**
+	 * true si le mode debug est activé, false sinon
+	 */
     private boolean debug;
-    private boolean needsUpdate = false;  // Pour tracker si quelque chose doit être mis à jour
-    private boolean isCircular = false;  // Pour tracker si un cycle a été détecté
-    private boolean futureTimestampDetected = false; // Pour détecter les timestamps dans le futur
 
+	/**
+	 * Pour tracker si quelque chose doit être mis à jour
+	 */
+    private boolean needsUpdate = false;
+
+	/**
+	 * Pour tracker si un cycle a été détecté
+	 */
+    private boolean isCircular = false;
+	
+	/**
+	 * Pour détecter les timestamps dans le futur
+	 */
+    private boolean futureTimestampDetected = false;
+
+	/**
+	 * Constructeur de la classe CommandExecutor.
+	 * @param debug true si le mode debug est activé, false sinon
+	 * @param isCircular true si on est en mode circulaire, false sinon
+	 */
     public CommandExecutor(boolean debug, boolean isCircular) {
         this.debug = debug;
         this.isCircular = isCircular;
     }
     
+	/**
+	 * Exécute les commandes d'une règle.
+	 * @param rule La règle à exécuter
+	 */
     public void execute(Rule rule) {
         // On vérifie d'abord si cette règle a besoin d'être mise à jour
         boolean ruleNeedsUpdate = rule.needsUpdate();

src/fr/monlouyan/bakefile/DependencyResolver.java

@@ -2,16 +2,40 @@ package fr.monlouyan.bakefile;
 
 import java.util.*;
 
+/**
+ * Résolveur de dépendances entre les règles du fichier Bakefile.
+ * Cette classe est responsable de la résolution des dépendances entre les règles
+ * pour déterminer l'ordre dans lequel les règles doivent être
+ * 
+ * @author Moncef STITI, Yanis HAMOUDI, Louay DARDOURI
+ * @version 1.0
+ */
 public class DependencyResolver {
+
+	/*** true si le mode debug est activé, false sinon */
     private boolean debug;
+
+	/*** Map des règles indexées par leur nom */
     private Map<String, Rule> ruleMap;
+
+	/*** true si une dépendance circulaire est détectée, false sinon */
     private boolean isCircular;
-    
+	
+	/**
+	 * Constructeur de la classe DependencyResolver.
+	 * @param debug true si le mode debug est activé, false sinon
+	 */
     public DependencyResolver(boolean debug) {
         this.debug = debug;
         this.isCircular = false;
     }
 
+	/**
+	 * Résout les dépendances entre les règles.
+	 * @param allRules Liste de toutes les règles
+	 * @param requestedRules Liste des règles demandées
+	 * @return Liste 
+	 */
     public List<Rule> resolve(List<Rule> allRules, List<String> requestedRules) {
         List<Rule> rulesToBuild = new ArrayList<>();
         ruleMap = new HashMap<>();
@@ -64,6 +88,12 @@ public class DependencyResolver {
         return rulesToBuild;
     }
 
+	/**
+	 * Méthode de tri topologique pour résoudre les dépendances.
+	 * @param ruleName Nom de la règle
+	 * @param processed Set des règles déjà traitées
+	 * @param buildOrder Liste des règles dans l'ordre
+	 */
     private void topologicalSort(String ruleName, Set<String> processed, List<String> buildOrder) {
         if (!ruleMap.containsKey(ruleName) || processed.contains(ruleName)) {
             return;
@@ -85,7 +115,13 @@ public class DependencyResolver {
         buildOrder.add(ruleName);
     }
 
-    // La méthode detectCycle avec une modification pour les chemins home
+    /**
+	 * Méthode de détection des cycles dans les dépendances.
+	 * @param ruleName Nom de la règle
+	 * @param visited Set des règles déjà visitées
+	 * @param stack Set des règles en cours de traitement
+	 * @param parent Nom de la règle parente
+	 */
     private void detectCycle(String ruleName, Set<String> visited, Set<String> stack, String parent) {
         if (stack.contains(ruleName)) {
             if (parent != null) { 
@@ -121,6 +157,10 @@ public class DependencyResolver {
         }
     }
 
+	/**
+	 * Vérifie si une dépendance circulaire a été détectée.
+	 * @return true si une dépendance circulaire a été détectée, false sinon
+	 */
     public boolean isCircular() {
         return isCircular;
     }

src/fr/monlouyan/bakefile/Main.java

@@ -5,15 +5,20 @@ package fr.monlouyan.bakefile;
  * 
  * @version 1.0
  * @author Moncef STITI
- * @date 03/02/2025
  */
 public class Main{
 
+	/**
+	 * Constructeur de la classe Main (privé pour empêcher l'instanciation)
+	 */
+	private Main() {
+		// Constructeur inutile
+	}
+
     /**
      * Méthode principale du programme
      * 
      * @param args Les arguments passés en ligne de commande
-     * @return void
      */
     public static void main(String[] args){
         @SuppressWarnings("unused")

src/fr/monlouyan/bakefile/Rule.java

@@ -2,14 +2,36 @@ package fr.monlouyan.bakefile;
 
 import java.io.File;
 import java.util.List;
-import java.util.Date;
 
+/**
+ * Représente une règle du fichier Bakefile.
+ * Chaque règle est composée d'un nom, d'une liste de dépendances et d'une liste de commandes.
+ * Une règle peut être phony, c'est-à-dire qu'elle n'a pas de fichier cible associé.
+ * 
+ * @author Moncef STITI, Yanis HAMOUDI, Louay DARDOURI
+ * @version 1.0
+ */
 public class Rule {
+
+	/*** Nom de la règle */
     private String name;
+
+	/*** Liste des dépendances de la règle */
     private List<String> dependencies;
+	
+	/*** Liste des commandes */
     private List<String> commands;
+
+	/*** true si la règle est phony, false sinon */
     private boolean isPhony;
 
+	/**
+	 * Constructeur de la classe Rule.
+	 * @param name Nom de la règle
+	 * @param dependencies Liste des dépendances
+	 * @param commands Liste des commandes
+	 * @param isPhony true si la règle est phony, false sinon
+	 */
     public Rule(String name, List<String> dependencies, List<String> commands, boolean isPhony) {
         this.name = name;
         this.dependencies = dependencies;
@@ -17,12 +39,40 @@ public class Rule {
         this.isPhony = isPhony;
     }
 
+	/**
+	 * Récupère le nom de la règle.
+	 * @return Le nom de la règle
+	 */
     public String getName() { return name; }
+
+	/**
+	 * Récupère la liste des dépendances de la règle.
+	 * @return La liste des dépendances
+	 */
     public List<String> getDependencies() { return dependencies; }
+
+	/**
+	 * Récupère la liste des commandes de la règle.
+	 * @return La liste des commandes
+	 */
     public List<String> getCommands() { return commands; }
+
+	/**
+	 * Vérifie si la règle est phony.
+	 * @return true si la règle est phony, false sinon.
+	 */
     public boolean isPhony() { return isPhony; }
+
+	/**
+	 * Vérifie si la règle est vide (sans dépendances ni commandes).
+	 * @return true si la règle est vide, false sinon
+	 */
     public boolean isEmpty() { return dependencies.isEmpty() && commands.isEmpty(); }
 
+	/**
+	 * Vérifie si la règle doit être mise à jour.
+	 * @return true si la règle doit être mise à jour, false sinon
+	 */
     public boolean needsUpdate() {
         if (BakeCLI.isDebug()){
             System.out.println("Debug : Checking if rule " + name + " needs update");

src/fr/monlouyan/bakefile/TimestampManager.java

@@ -6,18 +6,23 @@ import java.util.Date;
 
 /**
  * Classe utilitaire pour la gestion des timestamps des fichiers.
- * Dernière modification : 04/02/2025
  * 
  * @author Moncef STITI, Yanis HAMOUDI
  * @version 1.0
- * @date 04/02/2025
  */
 public class TimestampManager {
 
+	/**
+	 * Constructeur de TimestampManager.
+	 */
+	public TimestampManager() {
+		// Constructeur inutile
+	}
+
     /**
      * Récupère le timestamp d'un fichier.
-     * @param filePath Le chemin du fichier.
      * @return Le timestamp du fichier, ou 0 si le fichier n'existe pas.
+	 * @param file Le fichier
      */
     public static long getTimestamp(File file) {
         if (file.exists()) {