# 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.
