Renamed TaskDependencyGraph -> TaskInfoFactory

gradle · Jun 1, 2017 · 8f99c08 · 8f99c08
1 parent bb1da09
commit 8f99c08
Show file tree

Hide file tree

Showing 3 changed files with 19 additions and 27 deletions.
diff --git a/subprojects/core/src/main/java/org/gradle/execution/taskgraph/DefaultTaskExecutionPlan.java b/subprojects/core/src/main/java/org/gradle/execution/taskgraph/DefaultTaskExecutionPlan.java
@@ -89,7 +89,7 @@
 public class DefaultTaskExecutionPlan implements TaskExecutionPlan {
     private final Set<TaskInfo> tasksInUnknownState = new LinkedHashSet<TaskInfo>();
     private final Set<TaskInfo> entryTasks = new LinkedHashSet<TaskInfo>();
-    private final TaskDependencyGraph graph = new TaskDependencyGraph();
+    private final TaskInfoFactory nodeFactory = new TaskInfoFactory();
     private final LinkedHashMap<Task, TaskInfo> executionPlan = new LinkedHashMap<Task, TaskInfo>();
     private final List<TaskInfo> executionQueue = new LinkedList<TaskInfo>();
     private final Map<Project, ResourceLock> projectLocks = Maps.newHashMap();
@@ -120,7 +120,7 @@ public void addToTaskGraph(Collection<? extends Task> tasks) {
         List<Task> sortedTasks = new ArrayList<Task>(tasks);
         Collections.sort(sortedTasks);
         for (Task task : sortedTasks) {
-            TaskInfo node = graph.addNode(task);
+            TaskInfo node = nodeFactory.createNode(task);
             if (node.isMustNotRun()) {
                 requireWithDependencies(node);
             } else if (filter.isSatisfiedBy(task)) {
@@ -159,25 +159,25 @@ public void addToTaskGraph(Collection<? extends Task> tasks) {
                 ((TaskContainerInternal) task.getProject().getTasks()).prepareForExecution(task);
                 Set<? extends Task> dependsOnTasks = context.getDependencies(task);
                 for (Task dependsOnTask : dependsOnTasks) {
-                    TaskInfo targetNode = graph.addNode(dependsOnTask);
+                    TaskInfo targetNode = nodeFactory.createNode(dependsOnTask);
                     node.addDependencySuccessor(targetNode);
                     if (!visiting.contains(targetNode)) {
                         queue.add(0, targetNode);
                     }
                 }
                 for (Task finalizerTask : task.getFinalizedBy().getDependencies(task)) {
-                    TaskInfo targetNode = graph.addNode(finalizerTask);
+                    TaskInfo targetNode = nodeFactory.createNode(finalizerTask);
                     addFinalizerNode(node, targetNode);
                     if (!visiting.contains(targetNode)) {
                         queue.add(0, targetNode);
                     }
                 }
                 for (Task mustRunAfter : task.getMustRunAfter().getDependencies(task)) {
-                    TaskInfo targetNode = graph.addNode(mustRunAfter);
+                    TaskInfo targetNode = nodeFactory.createNode(mustRunAfter);
                     node.addMustSuccessor(targetNode);
                 }
                 for (Task shouldRunAfter : task.getShouldRunAfter().getDependencies(task)) {
-                    TaskInfo targetNode = graph.addNode(shouldRunAfter);
+                    TaskInfo targetNode = nodeFactory.createNode(shouldRunAfter);
                     node.addShouldSuccessor(targetNode);
                 }
                 if (node.isRequired()) {
@@ -490,7 +490,7 @@ public void clear() {
         coordinationService.withStateLock(new Transformer<ResourceLockState.Disposition, ResourceLockState>() {
             @Override
             public ResourceLockState.Disposition transform(ResourceLockState resourceLockState) {
-                graph.clear();
+                nodeFactory.clear();
                 entryTasks.clear();
                 executionPlan.clear();
                 executionQueue.clear();

diff --git a/...cution/taskgraph/TaskDependencyGraph.java → .../execution/taskgraph/TaskInfoFactory.java b/...cution/taskgraph/TaskDependencyGraph.java → .../execution/taskgraph/TaskInfoFactory.java
@@ -17,7 +17,6 @@
 package org.gradle.execution.taskgraph;
 
 
-import org.gradle.api.Nullable;
 import org.gradle.api.Task;
 import org.gradle.api.internal.TaskInternal;
 import org.gradle.initialization.includedbuild.IncludedBuildTaskResource;
@@ -26,20 +25,14 @@
 import java.util.Map;
 import java.util.Set;
 
-// TODO:DAZ Rename TaskInfoFactory and remove `getNode`
-public class TaskDependencyGraph {
+public class TaskInfoFactory {
     private final Map<Task, TaskInfo> nodes = new HashMap<Task, TaskInfo>();
 
     public Set<Task> getTasks() {
         return nodes.keySet();
     }
 
-    @Nullable
-    public TaskInfo getNode(Task task) {
-        return nodes.get(task);
-    }
-
-    public TaskInfo addNode(Task task) {
+    public TaskInfo createNode(Task task) {
         TaskInfo node = nodes.get(task);
         if (node == null) {
             if (task instanceof IncludedBuildTaskResource) {

diff --git a/.../taskgraph/TaskDependencyGraphTest.groovy → ...tion/taskgraph/TaskInfoFactoryTest.groovy b/.../taskgraph/TaskDependencyGraphTest.groovy → ...tion/taskgraph/TaskInfoFactoryTest.groovy
@@ -19,8 +19,8 @@ package org.gradle.execution.taskgraph
 import org.gradle.api.internal.TaskInternal
 import spock.lang.Specification
 
-class TaskDependencyGraphTest extends Specification {
-    def graph = new TaskDependencyGraph()
+class TaskInfoFactoryTest extends Specification {
+    def graph = new TaskInfoFactory()
     def a = task('a')
     def b = task('b')
     def c = task('c')
@@ -36,7 +36,7 @@ class TaskDependencyGraphTest extends Specification {
 
     void 'can create a node for a task'() {
         when:
-        def node = graph.addNode(a)
+        def node = graph.createNode(a)
 
         then:
         !node.inKnownState
@@ -49,27 +49,26 @@ class TaskDependencyGraphTest extends Specification {
 
     void 'caches node for a given task'() {
         when:
-        def node = graph.addNode(a)
+        def node = graph.createNode(a)
 
         then:
-        graph.getNode(a).is(node)
-        graph.addNode(a).is(node)
+        graph.createNode(a).is(node)
     }
 
     void 'can add multiple nodes'() {
         when:
-        graph.addNode(a)
-        graph.addNode(b)
+        graph.createNode(a)
+        graph.createNode(b)
 
         then:
         graph.tasks == [a, b] as Set
     }
 
     void 'clear'() {
         when:
-        graph.addNode(a)
-        graph.addNode(b)
-        graph.addNode(c)
+        graph.createNode(a)
+        graph.createNode(b)
+        graph.createNode(c)
         graph.clear()
 
         then: