readme src

src/fr/monlouyan/bakefile/README.md

@@ -0,0 +1,147 @@
+# Documentation du répertoire `src` 📂
+
+Ce répertoire contient les fichiers source Java de l'outil **Bake**, organisé en plusieurs classes principales responsables du parsing du Bakefile, de la gestion des règles et de l'exécution des commandes.
+
+## Structure des fichiers
+
+| Fichier                 | Description |
+|-------------------------|-------------|
+| `Main.java`            | Point d'entrée du programme, initialise Bake. |
+| `BakeCLI.java`         | Gestion des arguments en ligne de commande. |
+| `BakeEngine.java`      | Moteur principal qui orchestre la compilation. |
+| `BakefileParser.java`  | Analyse et interprète le fichier `Bakefile`. |
+| `CommandExecutor.java` | Exécute les commandes associées aux règles. |
+| `DependencyResolver.java` | Gère les dépendances entre règles. |
+| `Rule.java`            | Représente une règle de compilation avec ses dépendances et commandes. |
+| `TimestampManager.java` | Gère les timestamps des fichiers pour déterminer s'ils doivent être recompilés. |
+
+---
+
+## Détail des fichiers
+
+### 🔹 `Main.java`
+📌 **Rôle :**  
+- Classe principale qui initialise et lance le moteur `BakeEngine`.
+- Passe les arguments de la ligne de commande à `BakeCLI`.
+
+🔗 **Extrait de code :**
+```java
+public static void main(String[] args) {
+    BakeCLI cli = new BakeCLI(args);
+    BakeEngine engine = new BakeEngine();
+    engine.run();
+}
+```
+
+---
+
+### 🔹 `BakeCLI.java`
+📌 **Rôle :**  
+- Gère les arguments passés en ligne de commande.
+- Active le mode debug avec `-d`.
+- Récupère les cibles demandées.
+
+🔗 **Méthodes clés :**
+```java
+public static boolean isDebug() { return debug; }
+public static List<String> getTargets() { return targets; }
+```
+
+---
+
+### 🔹 `BakeEngine.java`
+📌 **Rôle :**  
+- Parse le `Bakefile` pour récupérer les règles.
+- Résout les dépendances entre les règles.
+- Exécute les règles dans l’ordre correct.
+
+🔗 **Étapes clés du `run()` :**
+```java
+List<Rule> rules = parser.parse();
+List<Rule> rulesToBuild = resolver.resolve(rules, BakeCLI.getTargets());
+for (Rule rule : rulesToBuild) {
+    executor.execute(rule);
+}
+```
+
+---
+
+### 🔹 `BakefileParser.java`
+📌 **Rôle :**  
+- Lit et interprète le fichier `Bakefile`.
+- Extrait les règles, leurs dépendances et commandes associées.
+
+🔗 **Fonctionnalités :**
+- Gestion des variables `VAR = valeur`.
+- Détection des règles `.PHONY`.
+- Support des lignes de continuation (`\`).
+
+```java
+Pattern TARGET_PATTERN = Pattern.compile("(.+?)\s*:\s*(.+?)");
+Pattern COMMAND_PATTERN = Pattern.compile("^\t(.+)$");
+```
+
+---
+
+### 🔹 `CommandExecutor.java`
+📌 **Rôle :**  
+- Exécute les commandes définies dans les règles.
+- Gère les erreurs (`exit code`).
+- Supporte les commandes silencieuses (`@`) et les suppressions forcées (`-`).
+
+🔗 **Gestion des erreurs :**
+```java
+if (exitCode != 0) {
+    System.err.println("bake: *** [" + rule.getName() + "] Error " + exitCode);
+    System.exit(2);
+}
+```
+
+---
+
+### 🔹 `DependencyResolver.java`
+📌 **Rôle :**  
+- Résout les dépendances entre règles.
+- Détecte et gère les dépendances circulaires.
+
+🔗 **Détection des cycles :**
+```java
+if (stack.contains(ruleName)) {
+    System.out.println("bake: Circular dependency detected: " + ruleName);
+}
+```
+
+---
+
+### 🔹 `Rule.java`
+📌 **Rôle :**  
+- Représente une règle du `Bakefile`.
+- Contient le nom, les dépendances et les commandes associées.
+
+🔗 **Définition d’une règle :**
+```java
+public Rule(String name, List<String> dependencies, List<String> commands, boolean isPhony) {
+    this.name = name;
+    this.dependencies = dependencies;
+    this.commands = commands;
+    this.isPhony = isPhony;
+}
+```
+
+---
+
+### 🔹 `TimestampManager.java`
+📌 **Rôle :**  
+- Vérifie si un fichier doit être recompilé en comparant ses timestamps.
+
+🔗 **Gestion des timestamps :**
+```java
+public static long getTimestamp(File file) {
+    return file.exists() ? file.lastModified() : 0;
+}
+```
+
+---
+
+## 📌 Conclusion
+Ce répertoire contient les éléments clés de **Bake**, organisés pour assurer une exécution efficace des `Bakefile`. Chaque classe joue un rôle spécifique dans la gestion du parsing, des règles et de l'exécution des commandes.