Split collection of nodes and their levels, optimize graph search

Author: ondrej.basler

src/main/kotlin/com/github/ivancarras/graphfity/plugin/task/GraphfityTask.kt

@@ -34,16 +34,20 @@ abstract class GraphfityTask : DefaultTask() {
         val nodesLevel = HashMap<String, Int>()
         val dotFile = createDotFile(dotPath)
 
-        obtainDependenciesData(rootProject, nodes, dependencies, nodeTypes, nodesLevel)
+        obtainNodesAndDependencies(rootProject, nodes, dependencies, nodeTypes)
+        obtainNodesLevels(projectRootName, dependencies, nodesLevel)
         addNodesToFile(dotFile, nodes)
         addDependenciesToFile(dotFile, dependencies)
         addNodeLevelsToFile(dotFile, nodesLevel)
         generateGraph(dotFile)
     }
 
     private fun getRootProject(projectRootName: String): Project {
-        return project.findProject(projectRootName)
-            ?: throw kotlin.IllegalArgumentException("The property provided as projectRootPath: $projectRootName does not correspond to any project")
+        return requireNotNull(
+            project.findProject(projectRootName)
+        ) {
+            "The property provided as projectRootPath: $projectRootName does not correspond to any project"
+        }
     }
 
     private fun loadNodeTypes(nodeTypesPath: String): List<NodeType> {
@@ -86,23 +90,16 @@ abstract class GraphfityTask : DefaultTask() {
             }
     }
 
-    private fun obtainDependenciesData(
+    private fun obtainNodesAndDependencies(
         project: Project,
         projects: HashSet<NodeData>,
         dependencies: HashSet<Pair<NodeData, NodeData>>,
         nodeTypes: List<NodeType>,
-        nodesLevel: HashMap<String, Int>,
-        level: Int = 0
     ) {
         val projectNodeData = mapProjectToNode(project, nodeTypes)
 
         if (projectNodeData != null && projectNodeData.nodeType.isEnabled) {
             projects.add(projectNodeData)
-
-            val nodeLevel = nodesLevel[project.path]
-            if (nodeLevel == null || level > nodeLevel) {
-                nodesLevel[projectNodeData.path] = level
-            }
         }
 
         project.configurations.forEach { config ->
@@ -115,26 +112,41 @@ abstract class GraphfityTask : DefaultTask() {
                     if (dependencyProjectNodeData != null && projectNodeData != null &&
                         dependencyProjectNodeData.nodeType.isEnabled
                     ) {
-                        projects.add(dependencyProjectNodeData)
+                        dependencies.add(Pair(projectNodeData, dependencyProjectNodeData))
 
-                        val nodeLevel = nodesLevel[dependencyProjectNodeData.path]
-                        if (nodeLevel == null || level > nodeLevel) {
-                            nodesLevel[dependencyProjectNodeData.path] = level + 1
+                        if (dependencyProjectNodeData !in projects) {
+                            obtainNodesAndDependencies(
+                                project = dependencyProject,
+                                projects = projects,
+                                dependencies = dependencies,
+                                nodeTypes = nodeTypes,
+                            )
                         }
-                        dependencies.add(Pair(projectNodeData, dependencyProjectNodeData))
-                        obtainDependenciesData(
-                            dependencyProject,
-                            projects,
-                            dependencies,
-                            nodeTypes,
-                            nodesLevel,
-                            level + 1
-                        )
                     }
                 }
         }
     }
 
+    private fun obtainNodesLevels(
+        rootProjectName: String,
+        dependencies: HashSet<Pair<NodeData, NodeData>>,
+        nodeLevel: HashMap<String, Int>,
+    ) {
+        var currentLevel = listOf(rootProjectName)
+        var level = 0
+        while (currentLevel.isNotEmpty()) {
+            currentLevel
+                .forEach { nodeLevel[it] = level }
+
+            val nextLevel = dependencies
+                .filter { it.first.path in currentLevel }
+                .map { it.second.path }
+
+            currentLevel = nextLevel
+            level++
+        }
+    }
+
     private fun createDotFile(dotPath: String): File = File(dotPath + DOT_FILE).apply {
         delete()
         parentFile.mkdirs()