Améliorations des dépendances circulaire

This commit is contained in:
Moncef STITI 2025-02-04 21:25:16 +01:00
parent c20a508069
commit 1f31e318dc
35 changed files with 156 additions and 58 deletions

Binary file not shown.

@ -10,12 +10,12 @@ public class BakeEngine {
public BakeEngine() {
this.parser = new BakefileParser("Bakefile");
this.resolver = new DependencyResolver(BakeCLI.isDebug());
this.executor = new CommandExecutor(BakeCLI.isDebug());
}
public void run() {
List<Rule> rules = parser.parse();
List<Rule> rulesToBuild = resolver.resolve(rules, BakeCLI.getTargets());
this.executor = new CommandExecutor(BakeCLI.isDebug(), resolver.isCircular());
for (Rule rule : rulesToBuild) {
executor.execute(rule);

@ -4,9 +4,12 @@ import java.io.IOException;
public class CommandExecutor {
private boolean debug;
public CommandExecutor(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é
public CommandExecutor(boolean debug, boolean isCircular) {
this.debug = debug;
this.isCircular = isCircular;
}
public void execute(Rule rule) {
@ -15,28 +18,43 @@ public class CommandExecutor {
return;
}
if (!rule.needsUpdate()) {
if (rule.getName().equals(BakefileParser.getFirstTarget())) {
System.out.println("bake: '" + rule.getName() + "' is up to date.");
}
return;
// On vérifie d'abord si cette règle a besoin d'être mise à jour
boolean ruleNeedsUpdate = rule.needsUpdate();
if (ruleNeedsUpdate) {
needsUpdate = true; // Au moins une règle doit être mise à jour
}
try {
for (String command : rule.getCommands()) {
System.out.println(command); // Affichage de la commande executée
ProcessBuilder pb = new ProcessBuilder("sh", "-c", command);
Process process = pb.start();
int exitCode = process.waitFor();
if (debug) System.out.println("Executed: " + command + " with exit code " + exitCode);
if (exitCode != 0) {
System.err.println("Error executing " + rule.getName() + "");
break;
for (String command : rule.getCommands()) {
if (isCircular){
System.out.println(command);
}
// Mais on n'exécute que si nécessaire
if (ruleNeedsUpdate) {
try {
if(!isCircular){
System.out.println(command);
}
if (debug) System.out.println("Debug: Executing " + command);
ProcessBuilder pb = new ProcessBuilder("sh", "-c", command);
Process process = pb.start();
int exitCode = process.waitFor();
if (exitCode != 0) {
System.err.println("Error executing " + rule.getName());
System.exit(1);
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
System.exit(1);
}
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
// On affiche "up to date" seulement après avoir traité TOUTES les règles
// et seulement si AUCUNE règle n'avait besoin d'être mise à jour
if (rule.getName().equals(BakefileParser.getFirstTarget()) && !needsUpdate) {
System.out.println("bake: '" + rule.getName() + "' is up to date.");
}
}
}

@ -5,52 +5,98 @@ import java.util.*;
public class DependencyResolver {
private boolean debug;
private Map<String, Rule> ruleMap;
private boolean isCircular;
public DependencyResolver(boolean debug) {
this.debug = debug;
this.isCircular = false;
}
public List<Rule> resolve(List<Rule> allRules, List<String> requestedRules) {
List<Rule> rulesToBuild = new ArrayList<>();
ruleMap = new HashMap<>();
Set<String> builtRules = new HashSet<>(); // Éviter d'ajouter des règles déjà vérifiées
// Construire la map des règles
for (Rule rule : allRules) {
ruleMap.put(rule.getName(), rule);
}
// Premier passage : détection et suppression des cycles
Set<String> visited = new HashSet<>();
Set<String> stack = new HashSet<>();
List<String> targetRules = requestedRules.isEmpty() ?
Collections.singletonList(BakefileParser.getFirstTarget()) :
requestedRules;
for (String ruleName : requestedRules.isEmpty() ? ruleMap.keySet() : requestedRules) {
for (String ruleName : targetRules) {
if (ruleMap.containsKey(ruleName)) {
detectCycle(ruleName, visited, stack);
collectDependencies(ruleName, rulesToBuild, builtRules);
detectCycle(ruleName, visited, stack, ruleName);
} else if (debug) {
System.out.println("Warning: Rule '" + ruleName + "' not found.");
}
}
// Deuxième passage : collecte des dépendances dans l'ordre
Set<String> processed = new HashSet<>();
List<String> buildOrder = new ArrayList<>();
for (String ruleName : targetRules) {
topologicalSort(ruleName, processed, buildOrder);
}
// Construire la liste finale des règles dans l'ordre
for (String ruleName : buildOrder) {
Rule rule = ruleMap.get(ruleName);
if (rule != null) {
rulesToBuild.add(rule);
}
}
return rulesToBuild;
}
/**
* Détection des cycles avec DFS
*/
private void detectCycle(String ruleName, Set<String> visited, Set<String> stack) {
if (stack.contains(ruleName)) {
throw new RuntimeException("Dependency cycle detected involving rule: " + ruleName);
private void topologicalSort(String ruleName, Set<String> processed, List<String> buildOrder) {
if (!ruleMap.containsKey(ruleName) || processed.contains(ruleName)) {
return;
}
processed.add(ruleName);
Rule rule = ruleMap.get(ruleName);
// D'abord traiter les dépendances
for (String dep : rule.getDependencies()) {
topologicalSort(dep, processed, buildOrder);
}
// Puis ajouter la règle courante
buildOrder.add(ruleName);
}
// La méthode detectCycle reste inchangée
private void detectCycle(String ruleName, Set<String> visited, Set<String> stack, String parent) {
if (stack.contains(ruleName)) {
if (parent != null) {
System.out.println("make: Circular " + parent + " <- " + ruleName + " dependency dropped.");
this.isCircular = true;
Rule parentRule = ruleMap.get(parent);
if (parentRule != null) {
parentRule.getDependencies().remove(ruleName);
}
}
return;
}
if (!visited.contains(ruleName)) {
visited.add(ruleName);
stack.add(ruleName);
Rule rule = ruleMap.get(ruleName);
if (rule != null) {
for (String dependency : rule.getDependencies()) {
List<String> dependenciesCopy = new ArrayList<>(rule.getDependencies());
for (String dependency : dependenciesCopy) {
if (ruleMap.containsKey(dependency)) {
detectCycle(dependency, visited, stack);
detectCycle(dependency, visited, stack, ruleName);
}
}
}
@ -58,23 +104,7 @@ public class DependencyResolver {
}
}
/**
* Collecte récursive des règles à construire en évitant les doublons
*/
private void collectDependencies(String ruleName, List<Rule> rulesToBuild, Set<String> builtRules) {
if (builtRules.contains(ruleName)) {
return; // Évite d'ajouter une règle plusieurs fois
}
Rule rule = ruleMap.get(ruleName);
if (rule != null) {
for (String dependency : rule.getDependencies()) {
if (ruleMap.containsKey(dependency)) {
collectDependencies(dependency, rulesToBuild, builtRules);
}
}
rulesToBuild.add(rule);
builtRules.add(ruleName);
}
public boolean isCircular() {
return isCircular;
}
}
}

@ -0,0 +1,11 @@
main: ClasseA ClasseB ClasseC Main.java
javac Main.java
ClasseA: ClasseB
javac ClasseA.java
ClasseB: ClasseA
javac ClasseB.java
ClasseC: ClasseB ClasseA
javac ClasseC.java

@ -0,0 +1,7 @@
public class ClasseA {
private ClasseB b;
public ClasseA(ClasseB b) {
this.b = b;
}
}

@ -0,0 +1,7 @@
public class ClasseB {
private ClasseA a;
public ClasseB(ClasseA a) {
this.a = a;
}
}

@ -0,0 +1,9 @@
public class ClasseC {
private ClasseA a;
private ClasseB b;
public ClasseC(ClasseA a, ClasseB b) {
this.a = a;
this.b = b;
}
}

@ -0,0 +1,16 @@
public class Main {
private ClasseA a;
private ClasseB b;
private ClasseC c;
public Main() {
this.a = new ClasseA(b);
this.b = new ClasseB(a);
this.c = new ClasseC(a,b);
}
public static void main(String[] args) {
Main m = new Main();
System.out.println("Ceci est un test de dépendences circulaires");
}
}

Binary file not shown.