Merge pull request #6 from OndraBasler/feature/dependency-optimization

Optimize graph generation

Author: ivancarras

.gitignore

@@ -27,4 +27,5 @@ gradle-app.setting
 
 # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
 gradle-wrapper.jar
-path/to/standalone/plugin/project/
+path/to/standalone/plugin/project/
+/local.properties

build.gradle.kts

@@ -5,14 +5,15 @@ plugins {
     id("java")
     id("java-gradle-plugin")
     id("maven-publish")
-    kotlin("jvm") version "1.8.0"
-    id("com.gradle.plugin-publish") version "1.2.1"
+    kotlin("jvm") version "2.1.0"
+    id("com.gradle.plugin-publish") version "1.3.0"
 }
 
 repositories {
     mavenCentral()
 }
 
+@Suppress("UnstableApiUsage")
 gradlePlugin {
     website.set("https://github.com/ivancarras/graphfity")
     vcsUrl.set("https://github.com/ivancarras/graphfity.git")
@@ -42,11 +43,4 @@ publishing {
             url = uri("path/to/standalone/plugin/project")
         }
     }
-}
-
-dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.8.0")
-    implementation("org.codehaus.groovy:groovy-all:3.0.16")
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.2")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.2")
-}
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -34,16 +34,40 @@ abstract class GraphfityTask : DefaultTask() {
         val nodesLevel = HashMap<String, Int>()
         val dotFile = createDotFile(dotPath)
 
-        obtainDependenciesData(rootProject, nodes, dependencies, nodeTypes, nodesLevel)
-        addNodesToFile(dotFile, nodes)
-        addDependenciesToFile(dotFile, dependencies)
-        addNodeLevelsToFile(dotFile, nodesLevel)
-        generateGraph(dotFile)
+        obtainNodesAndDependencies(
+            project = rootProject,
+            nodes = nodes,
+            dependencies = dependencies,
+            nodeTypes = nodeTypes
+        )
+        obtainNodesLevels(
+            rootProjectName = projectRootName,
+            dependencies = dependencies,
+            nodeLevel = nodesLevel
+        )
+        addNodesToFile(
+            dotFile = dotFile,
+            nodes = nodes
+        )
+        addDependenciesToFile(
+            dotFile = dotFile,
+            dependencies = dependencies
+        )
+        addNodeLevelsToFile(
+            dotFile = dotFile,
+            nodeLevels = nodesLevel
+        )
+        generateGraph(
+            dotFile = 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,55 +110,63 @@ abstract class GraphfityTask : DefaultTask() {
             }
     }
 
-    private fun obtainDependenciesData(
+    private fun obtainNodesAndDependencies(
         project: Project,
-        projects: HashSet<NodeData>,
+        nodes: 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
-            }
+            nodes.add(projectNodeData)
         }
 
         project.configurations.forEach { config ->
             config.dependencies
                 .withType(ProjectDependency::class.java)
-                .map { it.dependencyProject }
+                .map { project.project(it.path) }
                 .filterNot { project == it.project }
                 .forEach { dependencyProject ->
                     val dependencyProjectNodeData = mapProjectToNode(dependencyProject, nodeTypes)
                     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 nodes) {
+                            obtainNodesAndDependencies(
+                                project = dependencyProject,
+                                nodes = nodes,
+                                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()
@@ -179,7 +211,8 @@ abstract class GraphfityTask : DefaultTask() {
     }
 
     private fun addNodeLevelsToFile(
-        dotFile: File, nodeLevels: HashMap<String, Int>
+        dotFile: File,
+        nodeLevels: HashMap<String, Int>
     ) {
         nodeLevels.asSequence().groupBy({ it.value }, { it.key }).forEach {
             dotFile.appendText("\n{ rank=same;")