Améliorations des dépendances circulaire
This commit is contained in:
parent
c20a508069
commit
1f31e318dc
bakefile.jar
src/fr/monlouyan/bakefile
tests
C
test-01-from-nothing
test-02-already-exist
test-03-circular
test-04-edited
test-05-variables
test-06-variables-on-cascade
Java/test-03-circular
bakefile.jar
BIN
bakefile.jar
BIN
bakefile.jar
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;
|
||||
}
|
||||
}
|
||||
}
|
11
tests/Java/test-03-circular/Bakefile
Normal file
11
tests/Java/test-03-circular/Bakefile
Normal file
@ -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
|
7
tests/Java/test-03-circular/ClasseA.java
Normal file
7
tests/Java/test-03-circular/ClasseA.java
Normal file
@ -0,0 +1,7 @@
|
||||
public class ClasseA {
|
||||
private ClasseB b;
|
||||
|
||||
public ClasseA(ClasseB b) {
|
||||
this.b = b;
|
||||
}
|
||||
}
|
7
tests/Java/test-03-circular/ClasseB.java
Normal file
7
tests/Java/test-03-circular/ClasseB.java
Normal file
@ -0,0 +1,7 @@
|
||||
public class ClasseB {
|
||||
private ClasseA a;
|
||||
|
||||
public ClasseB(ClasseA a) {
|
||||
this.a = a;
|
||||
}
|
||||
}
|
9
tests/Java/test-03-circular/ClasseC.java
Normal file
9
tests/Java/test-03-circular/ClasseC.java
Normal file
@ -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;
|
||||
}
|
||||
}
|
16
tests/Java/test-03-circular/Main.java
Normal file
16
tests/Java/test-03-circular/Main.java
Normal file
@ -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.
Loading…
x
Reference in New Issue
Block a user