feat: Auto-detect git submodules and mark all projects under them as affected

Author: garghimanshu0786

affectedmoduledetector/src/main/kotlin/com/dropbox/affectedmoduledetector/AffectedModuleDetector.kt

@@ -507,6 +507,11 @@ class AffectedModuleDetectorImpl(
 
     private var unknownFiles: MutableSet<String> = mutableSetOf()
 
+    /** Lazily loaded set of submodule paths from .gitmodules file */
+    private val submodulePaths: Set<String> by lazy {
+        parseSubmodulePaths()
+    }
+
     override fun shouldInclude(project: ProjectPath): Boolean {
         val isProjectAffected = affectedProjects.contains(project)
         val isProjectProvided = isProjectProvided2(project)
@@ -566,6 +571,15 @@ class AffectedModuleDetectorImpl(
         val changedProjects = mutableSetOf<ProjectPath>()
 
         for (filePath in changedFiles) {
+            if (submodulePaths.contains(filePath)) {
+                val submoduleProjects = projectGraph.findAllProjectsUnderPath(filePath, logger)
+                if (submoduleProjects.isNotEmpty()) {
+                    changedProjects.addAll(submoduleProjects)
+                    logger?.info("Submodule $filePath changed. Added ${submoduleProjects.size} projects: $submoduleProjects")
+                    continue
+                }
+            }
+
             val containingProject = findContainingProject(filePath)
             if (containingProject == null) {
                 unknownFiles.add(filePath)
@@ -662,6 +676,31 @@ class AffectedModuleDetectorImpl(
             logger?.info("search result for $filePath resulted in ${it?.path}")
         }
     }
+
+    /**
+     * Parses .gitmodules file to extract submodule paths.
+     * Returns empty set if no .gitmodules file exists.
+     */
+    private fun parseSubmodulePaths(): Set<String> {
+        val gitmodulesFile = File(gitRoot, ".gitmodules")
+        if (!gitmodulesFile.exists()) {
+            logger?.info("No .gitmodules file found at ${gitmodulesFile.absolutePath}")
+            return emptySet()
+        }
+
+        val pathRegex = Regex("""^\s*path\s*=\s*(.+)\s*$""")
+        val paths = mutableSetOf<String>()
+
+        gitmodulesFile.readLines().forEach { line ->
+            pathRegex.find(line)?.let { match ->
+                val path = match.groupValues[1].trim().replace("/", File.separator)
+                paths.add(path)
+            }
+        }
+
+        logger?.info("Found ${paths.size} submodules: $paths")
+        return paths
+    }
 }
 
 val Project.isRoot get() = this == rootProject

affectedmoduledetector/src/main/kotlin/com/dropbox/affectedmoduledetector/ProjectGraph.kt

@@ -70,6 +70,19 @@ class ProjectGraph(project: Project, logger: Logger? = null) : Serializable {
         return rootNode.find(sections, 0, logger)
     }
 
+    /**
+     * Finds all projects whose directory is under the given path prefix.
+     * Used for submodule support - when a submodule path changes, all projects under it are affected.
+     */
+    fun findAllProjectsUnderPath(pathPrefix: String, logger: Logger? = null): Set<ProjectPath> {
+        val sections = pathPrefix.split(File.separatorChar)
+        val node = rootNode.findNode(sections, 0) ?: return emptySet()
+        val result = mutableSetOf<ProjectPath>()
+        node.addAllProjectPaths(result)
+        logger?.info("Found ${result.size} projects under $pathPrefix: $result")
+        return result
+    }
+
     val allProjects by lazy {
         val result = mutableSetOf<ProjectPath>()
         rootNode.addAllProjectPaths(result)
@@ -98,6 +111,11 @@ class ProjectGraph(project: Project, logger: Logger? = null) : Serializable {
             }
         }
 
+        fun findNode(sections: List<String>, index: Int): Node? {
+            if (sections.size <= index) return this
+            return children[sections[index]]?.findNode(sections, index + 1)
+        }
+
         fun addAllProjectPaths(collection: MutableSet<ProjectPath>) {
             projectPath?.let { path -> collection.add(path) }
             for (child in children.values) {

affectedmoduledetector/src/test/kotlin/com/dropbox/affectedmoduledetector/AffectedModuleDetectorImplTest.kt

@@ -1773,6 +1773,50 @@ class AffectedModuleDetectorImplTest {
         )
     }
 
+    @Test
+    fun `GIVEN submodule with projects WHEN submodule changes THEN all projects under submodule are affected`() {
+        // Create submodule directory with a project inside
+        val submodulePath = convertToFilePath("libs", "my-submodule")
+        val submoduleDir = File(tmpFolder.root, submodulePath)
+        submoduleDir.mkdirs()
+
+        // Create .gitmodules file
+        File(tmpFolder.root, ".gitmodules").writeText("""
+            [submodule "libs/my-submodule"]
+                path = libs/my-submodule
+                url = https://github.com/example/repo.git
+        """.trimIndent())
+
+        // Create a project inside the submodule
+        val submoduleProject = ProjectBuilder.builder()
+            .withProjectDir(submoduleDir.resolve("module-a"))
+            .withName("module-a")
+            .withParent(root)
+            .build()
+
+        val submoduleProjectGraph = ProjectGraph(root, null)
+
+        val detector = AffectedModuleDetectorImpl(
+            projectGraph = submoduleProjectGraph,
+            dependencyTracker = DependencyTracker(root, null),
+            logger = logger.toLogger(),
+            ignoreUnknownProjects = false,
+            projectSubset = ProjectSubset.CHANGED_PROJECTS,
+            modules = null,
+            changedFilesProvider = MockGitClient(
+                changedFiles = listOf(submodulePath),
+                tmpFolder = tmpFolder.root
+            ).findChangedFiles(root),
+            gitRoot = tmpFolder.root,
+            config = affectedModuleConfiguration
+        )
+
+        MatcherAssert.assertThat(
+            detector.affectedProjects,
+            CoreMatchers.hasItem(submoduleProject.projectPath)
+        )
+    }
+
     // For both Linux/Windows
     fun convertToFilePath(vararg list: String): String {
         return list.toList().joinToString(File.separator)

affectedmoduledetector/src/test/kotlin/com/dropbox/affectedmoduledetector/ProjectGraphTest.kt

@@ -62,5 +62,51 @@ class ProjectGraphTest {
             graph.findContainingProject("p2/a/b/c/d/e/f/a.java".toLocalPath())
         )
     }
+
+    @Test
+    fun testFindAllProjectsUnderPath() {
+        val tmpDir = tmpFolder.root
+        val root = ProjectBuilder.builder()
+            .withProjectDir(tmpDir)
+            .withName("root")
+            .build()
+        (root.properties.get("ext") as ExtraPropertiesExtension).set("supportRootFolder", tmpDir)
+
+        // Create submodule directory with multiple projects
+        val submoduleDir = tmpDir.resolve("submodule")
+        submoduleDir.mkdirs()
+
+        val p1 = ProjectBuilder.builder()
+            .withProjectDir(submoduleDir.resolve("module-a"))
+            .withName("module-a")
+            .withParent(root)
+            .build()
+        val p2 = ProjectBuilder.builder()
+            .withProjectDir(submoduleDir.resolve("module-b"))
+            .withName("module-b")
+            .withParent(root)
+            .build()
+
+        val graph = ProjectGraph(root, null)
+        val result = graph.findAllProjectsUnderPath("submodule")
+
+        assertEquals(setOf(p1.projectPath, p2.projectPath), result)
+    }
+
+    @Test
+    fun testFindAllProjectsUnderPath_returnsEmptyForNonexistent() {
+        val tmpDir = tmpFolder.root
+        val root = ProjectBuilder.builder()
+            .withProjectDir(tmpDir)
+            .withName("root")
+            .build()
+        (root.properties.get("ext") as ExtraPropertiesExtension).set("supportRootFolder", tmpDir)
+
+        val graph = ProjectGraph(root, null)
+        val result = graph.findAllProjectsUnderPath("nonexistent")
+
+        assertEquals(emptySet<ProjectPath>(), result)
+    }
+
     private fun String.toLocalPath() = this.split("/").joinToString(File.separator)
 }