TaskManagerTest.

modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt

@@ -24,6 +24,7 @@ import javax.inject.Singleton
 public class TaskManager @Inject constructor(val args: Args,
         val incrementalManagerFactory: IncrementalManager.IFactory) {
     private val runBefore = TreeMultimap.create<String, String>()
+    private val runAfter = TreeMultimap.create<String, String>()
     private val alwaysRunAfter = TreeMultimap.create<String, String>()
 
     /**
@@ -37,6 +38,10 @@ public class TaskManager @Inject constructor(val args: Args,
         runBefore.put(task1, task2)
     }
 
+    fun runAfter(task1: String, task2: String) {
+        runAfter.put(task1, task2)
+    }
+
     fun alwaysRunAfter(task1: String, task2: String) {
         alwaysRunAfter.put(task1, task2)
     }
@@ -89,7 +94,7 @@ public class TaskManager @Inject constructor(val args: Args,
                 }
 
                 val graph = createGraph(project.name, taskNames, tasksByNames,
-                        runBefore, alwaysRunAfter,
+                        runBefore, runAfter, alwaysRunAfter,
                         { task: PluginTask -> task.name },
                         { task: PluginTask -> task.plugin.accept(project) })
 
@@ -120,6 +125,7 @@ public class TaskManager @Inject constructor(val args: Args,
     @VisibleForTesting
     fun <T> createGraph(projectName: String, taskNames: List<String>, dependencies: Multimap<String, T>,
             runBefore: TreeMultimap<String, String>,
+            runAfter: TreeMultimap<String, String>,
             alwaysRunAfter: TreeMultimap<String, String>,
             toName: (T) -> String,
             accept: (T) -> Boolean):
@@ -173,14 +179,29 @@ public class TaskManager @Inject constructor(val args: Args,
                             }
                         }
 
+                        //
+                        // Add all the runAfter nodes if applicable
+                        //
+                        graph.nodes.forEach { node ->
+                            val ra = runAfter[toName(node)]
+                            ra.forEach { o ->
+                                dependencies[o].forEach {
+                                    if (o != null) {
+                                        graph.addEdge(it, node)
+                                    }
+                                }
+                            }
+                            println("RA: $ra")
+                        }
+
                         //
                         // If any of the nodes in the graph has an "alwaysRunAfter", add that edge too
                         //
                         val allNodes = arrayListOf<T>()
                         allNodes.addAll(graph.nodes)
                         allNodes.forEach { node ->
-                            val other = alwaysRunAfter.get(toName(node))
+                            val ra = alwaysRunAfter[toName(node)]
-                            other?.forEach { o ->
+                            ra?.forEach { o ->
                                 dependencies[o]?.forEach {
                                     graph.addEdge(it, node)
                                 }
@@ -350,7 +371,7 @@ public class TaskManager @Inject constructor(val args: Args,
                     }
                 })
         runBefore.forEach { runBefore(it, name) }
-        runAfter.forEach { runBefore(name, it) }
+        runAfter.forEach { runAfter(it, name) }
         alwaysRunAfter.forEach { alwaysRunAfter(it, name)}
     }
 

src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt

@@ -1,6 +1,7 @@
 package com.beust.kobalt.internal
 
 import com.beust.kobalt.TestModule
+import com.beust.kobalt.misc.KobaltLogger
 import com.google.common.collect.TreeMultimap
 import com.google.inject.Inject
 import org.testng.Assert
@@ -26,15 +27,19 @@ class TaskManagerTest @Inject constructor(val taskManager: TaskManager) {
     private fun runTasks(tasks: List<String>) : List<String> {
         val runBefore = TreeMultimap.create<String, String>().apply {
             put("assemble", "compile")
-            put("compile", "clean")
         }
-        val alwaysRunAfter = TreeMultimap.create<String, String>()
+        val runAfter = TreeMultimap.create<String, String>().apply {
+            put("clean", "compile")
+        }
+        val alwaysRunAfter = TreeMultimap.create<String, String>().apply {
+            put("clean", "copyVersion")
+        }
         val dependencies = TreeMultimap.create<String, String>().apply {
             listOf("assemble", "compile", "clean").forEach {
                 put(it, it)
             }
         }
-        val graph = taskManager.createGraph("", tasks, dependencies, runBefore, alwaysRunAfter,
+        val graph = taskManager.createGraph("", tasks, dependencies, runBefore, runAfter, alwaysRunAfter,
                 { it }, { t -> true })
         val result = DryRunGraphExecutor(graph).run()
         return result
@@ -42,6 +47,9 @@ class TaskManagerTest @Inject constructor(val taskManager: TaskManager) {
 
     @Test
     fun graphTest() {
+        KobaltLogger.LOG_LEVEL = 3
+        Assert.assertEquals(runTasks(listOf("clean")), listOf("clean", "copyVersion"))
+        Assert.assertEquals(runTasks(listOf("compile")), listOf("compile"))
         Assert.assertEquals(runTasks(listOf("assemble")), listOf("compile", "assemble"))
         Assert.assertEquals(runTasks(listOf("clean", "assemble")), listOf("clean", "compile", "assemble"))
     }