SONARPY-3802 Corrected package root computation (#860)

GitOrigin-RevId: 5363c8fbdb6e649aecbc658e43c8a5ce23263b90

Author: joke1196

python-commons/src/main/java/org/sonar/plugins/python/indexer/ConfigSourceRoots.java

@@ -0,0 +1,62 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2025 SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.indexer;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * Represents source roots extracted from a build configuration file (pyproject.toml or setup.py).
+ *
+ * <p>This record associates relative source root paths with the configuration file they were
+ * extracted from, allowing proper resolution of absolute paths relative to the config file's
+ * location rather than the project base directory.
+ *
+ * @param configFile the configuration file from which the source roots were extracted
+ * @param relativeRoots the relative source root paths defined in the config file
+ */
+public record ConfigSourceRoots(File configFile, List<String> relativeRoots) {
+
+  /**
+   * Converts the relative source roots to absolute paths.
+   *
+   * <p>Each relative path is resolved relative to the parent directory of the configuration file.
+   * For example, if the config file is at {@code /project/app/pyproject.toml} and a relative root
+   * is {@code "src"}, the absolute path will be {@code /project/app/src}.
+   *
+   * @return list of absolute paths for the source roots
+   */
+  public List<String> toAbsolutePaths() {
+    File parentDir = configFile.getParentFile();
+    if (parentDir == null) {
+      return List.of();
+    }
+    return relativeRoots.stream()
+      .map(root -> new File(parentDir, root).getAbsolutePath())
+      .toList();
+  }
+
+  /**
+   * Creates a ConfigSourceRoots with an empty list of relative roots.
+   *
+   * @param configFile the configuration file
+   * @return a ConfigSourceRoots with no relative roots
+   */
+  public static ConfigSourceRoots empty(File configFile) {
+    return new ConfigSourceRoots(configFile, List.of());
+  }
+}

python-commons/src/main/java/org/sonar/plugins/python/indexer/PackageRootResolver.java

@@ -38,17 +38,19 @@ private PackageRootResolver() {
   /**
    * Resolves package root directories.
    *
-   * <p>If extracted roots from build system configuration are provided, resolves them to absolute paths.
+   * <p>If extracted roots from build system configuration are provided (already as absolute paths
+   * resolved relative to their config file locations), returns them directly.
    * Otherwise, applies a fallback chain to determine appropriate roots.
    *
-   * @param extractedRoots roots extracted from build system config (e.g., from BuildSystemSourceRoots.extract())
-   * @param config         the Sonar configuration to read sonar.sources property
-   * @param baseDir        the project base directory
+   * @param extractedRoots roots extracted from build system config, already as absolute paths
+   * @param config the Sonar configuration to read sonar.sources property
+   * @param baseDir the project base directory (used only for fallback resolution)
    * @return list of resolved package root absolute paths
    */
   public static List<String> resolve(List<String> extractedRoots, Configuration config, File baseDir) {
     if (!extractedRoots.isEmpty()) {
-      return toAbsolutePaths(extractedRoots, baseDir);
+      // Extracted roots are already absolute paths (resolved relative to config file location)
+      return extractedRoots;
     }
     return resolveFallback(config, baseDir);
   }

python-commons/src/main/java/org/sonar/plugins/python/indexer/PyProjectTomlSourceRoots.java

@@ -21,6 +21,7 @@
 import com.fasterxml.jackson.annotation.Nulls;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.dataformat.toml.TomlMapper;
+import com.google.common.annotations.VisibleForTesting;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -62,7 +63,8 @@ private PyProjectTomlSourceRoots() {
    * @param tomlContent the content of a pyproject.toml file
    * @return list of source root paths (relative), empty if none found or on parse error
    */
-  public static List<String> extract(String tomlContent) {
+  @VisibleForTesting
+  static List<String> extract(String tomlContent) {
     try {
       PyProjectConfig config = TOML_MAPPER.readValue(tomlContent, PyProjectConfig.class);
       return extractFromConfig(config);
@@ -77,14 +79,29 @@ public static List<String> extract(String tomlContent) {
    * @param file the pyproject.toml file
    * @return list of source root paths (relative), empty if none found or on parse error
    */
-  public static List<String> extract(File file) {
+  private static List<String> extract(File file) {
     try {
       return extract(Files.readString(file.toPath()));
     } catch (IOException e) {
       return List.of();
     }
   }
 
+  /**
+   * Extracts source root directories from a pyproject.toml File, preserving the config file location.
+   *
+   * <p>This method returns a {@link ConfigSourceRoots} that associates the extracted relative paths
+   * with the config file, allowing callers to resolve absolute paths relative to the config file's
+   * directory rather than the project base directory.
+   *
+   * @param file the pyproject.toml file
+   * @return ConfigSourceRoots containing the config file and its relative source roots
+   */
+  public static ConfigSourceRoots extractWithLocation(File file) {
+    List<String> roots = extract(file);
+    return new ConfigSourceRoots(file, roots);
+  }
+
   private static List<String> extractFromConfig(PyProjectConfig config) {
     Set<String> sourceRoots = new LinkedHashSet<>();
 

python-commons/src/main/java/org/sonar/plugins/python/indexer/PythonIndexer.java

@@ -134,14 +134,19 @@ protected List<String> resolvePackageRoots(SensorContext context) {
   /**
    * Extracts source root directories from build configuration files (pyproject.toml and setup.py).
    *
+   * <p>Source roots are resolved to absolute paths relative to the configuration file's directory,
+   * not the project base directory. This correctly handles cases where config files are in
+   * subdirectories (e.g., monorepos with multiple Python projects).
+   *
    * @param fileSystem the file system to search for configuration files
-   * @return list of extracted source root paths (relative), or empty list if none found
+   * @return list of extracted source root absolute paths, or empty list if none found
    */
   private static List<String> extractSourceRoots(FileSystem fileSystem) {
-    List<String> pyprojectRoots = extractSourceRootsFromPyProjectToml(fileSystem);
-    List<String> setupPyRoots = extractSourceRootsFromSetupPy(fileSystem);
+    List<ConfigSourceRoots> pyprojectRoots = extractSourceRootsFromPyProjectToml(fileSystem);
+    List<ConfigSourceRoots> setupPyRoots = extractSourceRootsFromSetupPy(fileSystem);
 
     return Stream.concat(pyprojectRoots.stream(), setupPyRoots.stream())
+      .flatMap(csr -> csr.toAbsolutePaths().stream())
       .distinct()
       .toList();
   }
@@ -195,25 +200,25 @@ private static Stream<File> findFilesRecursively(FileSystem fileSystem, String f
    * Extracts source root directories from pyproject.toml files in the project.
    *
    * @param fileSystem the file system to search for pyproject.toml
-   * @return list of extracted source root paths (relative), or empty list if none found
+   * @return list of ConfigSourceRoots containing config file locations and their relative roots
    */
-  private static List<String> extractSourceRootsFromPyProjectToml(FileSystem fileSystem) {
+  private static List<ConfigSourceRoots> extractSourceRootsFromPyProjectToml(FileSystem fileSystem) {
     return findFilesRecursively(fileSystem, "pyproject.toml")
-      .flatMap(file -> PyProjectTomlSourceRoots.extract(file).stream())
-      .distinct()
+      .map(PyProjectTomlSourceRoots::extractWithLocation)
+      .filter(csr -> !csr.relativeRoots().isEmpty())
       .toList();
   }
 
   /**
    * Extracts source root directories from setup.py files in the project.
    *
    * @param fileSystem the file system to search for setup.py
-   * @return list of extracted source root paths (relative), or empty list if none found
+   * @return list of ConfigSourceRoots containing config file locations and their relative roots
    */
-  private static List<String> extractSourceRootsFromSetupPy(FileSystem fileSystem) {
+  private static List<ConfigSourceRoots> extractSourceRootsFromSetupPy(FileSystem fileSystem) {
     return findFilesRecursively(fileSystem, "setup.py")
-      .flatMap(file -> SetupPySourceRoots.extract(file).stream())
-      .distinct()
+      .map(SetupPySourceRoots::extractWithLocation)
+      .filter(csr -> !csr.relativeRoots().isEmpty())
       .toList();
   }
 

python-commons/src/main/java/org/sonar/plugins/python/indexer/SetupPySourceRoots.java

@@ -16,6 +16,7 @@
  */
 package org.sonar.plugins.python.indexer;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.sonar.sslr.api.AstNode;
 import java.io.File;
 import java.io.IOException;
@@ -58,7 +59,8 @@ private SetupPySourceRoots() {
    * @param setupPyContent the content of a setup.py file
    * @return list of source root paths (relative), empty if none found or on parse error
    */
-  public static List<String> extract(String setupPyContent) {
+  @VisibleForTesting
+  static List<String> extract(String setupPyContent) {
     try {
       PythonParser parser = PythonParser.create();
       AstNode astNode = parser.parse(setupPyContent);
@@ -88,6 +90,21 @@ public static List<String> extract(File file) {
     }
   }
 
+  /**
+   * Extracts source root directories from a setup.py File, preserving the config file location.
+   *
+   * <p>This method returns a {@link ConfigSourceRoots} that associates the extracted relative paths
+   * with the config file, allowing callers to resolve absolute paths relative to the config file's
+   * directory rather than the project base directory.
+   *
+   * @param file the setup.py file
+   * @return ConfigSourceRoots containing the config file and its relative source roots
+   */
+  public static ConfigSourceRoots extractWithLocation(File file) {
+    List<String> roots = extract(file);
+    return new ConfigSourceRoots(file, roots);
+  }
+
   private static class SetupCallVisitor extends BaseTreeVisitor {
     private final Set<String> sourceRoots = new LinkedHashSet<>();
     private final Map<String, Expression> variables = new HashMap<>();

python-commons/src/test/java/org/sonar/plugins/python/indexer/ConfigSourceRootsTest.java

@@ -0,0 +1,115 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2025 SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.plugins.python.indexer;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ConfigSourceRootsTest {
+
+  @TempDir
+  Path tempDir;
+
+  @Test
+  void toAbsolutePaths_resolvesRelativeToConfigFileParent() throws IOException {
+    Path subDir = tempDir.resolve("subproject");
+    Files.createDirectories(subDir);
+    File configFile = subDir.resolve("pyproject.toml").toFile();
+    Files.writeString(configFile.toPath(), "");
+
+    ConfigSourceRoots csr = new ConfigSourceRoots(configFile, List.of("src", "lib"));
+
+    assertThat(csr.toAbsolutePaths()).containsExactly(
+      subDir.resolve("src").toFile().getAbsolutePath(),
+      subDir.resolve("lib").toFile().getAbsolutePath()
+    );
+  }
+
+  @Test
+  void toAbsolutePaths_emptyListForEmptyRelativeRoots() throws IOException {
+    File configFile = tempDir.resolve("pyproject.toml").toFile();
+    Files.writeString(configFile.toPath(), "");
+
+    ConfigSourceRoots csr = new ConfigSourceRoots(configFile, List.of());
+
+    assertThat(csr.toAbsolutePaths()).isEmpty();
+  }
+
+  @Test
+  void toAbsolutePaths_handlesNestedDirectories() throws IOException {
+    Path deepDir = tempDir.resolve("a/b/c");
+    Files.createDirectories(deepDir);
+    File configFile = deepDir.resolve("pyproject.toml").toFile();
+    Files.writeString(configFile.toPath(), "");
+
+    ConfigSourceRoots csr = new ConfigSourceRoots(configFile, List.of("src"));
+
+    assertThat(csr.toAbsolutePaths()).containsExactly(
+      deepDir.resolve("src").toFile().getAbsolutePath()
+    );
+  }
+
+  @Test
+  void empty_createsConfigSourceRootsWithEmptyRelativeRoots() throws IOException {
+    File configFile = tempDir.resolve("pyproject.toml").toFile();
+    Files.writeString(configFile.toPath(), "");
+
+    ConfigSourceRoots csr = ConfigSourceRoots.empty(configFile);
+
+    assertThat(csr.configFile()).isEqualTo(configFile);
+    assertThat(csr.relativeRoots()).isEmpty();
+    assertThat(csr.toAbsolutePaths()).isEmpty();
+  }
+
+  @Test
+  void configFile_returnsOriginalFile() throws IOException {
+    File configFile = tempDir.resolve("setup.py").toFile();
+    Files.writeString(configFile.toPath(), "");
+
+    ConfigSourceRoots csr = new ConfigSourceRoots(configFile, List.of("src"));
+
+    assertThat(csr.configFile()).isSameAs(configFile);
+  }
+
+  @Test
+  void relativeRoots_returnsOriginalList() throws IOException {
+    File configFile = tempDir.resolve("pyproject.toml").toFile();
+    Files.writeString(configFile.toPath(), "");
+    List<String> roots = List.of("src", "lib");
+
+    ConfigSourceRoots csr = new ConfigSourceRoots(configFile, roots);
+
+    assertThat(csr.relativeRoots()).isEqualTo(roots);
+  }
+
+  @Test
+  void toAbsolutePaths_returnsEmptyListWhenParentDirIsNull() {
+    // A File with no parent (relative path with no directory component)
+    File configFile = new File("pyproject.toml");
+
+    ConfigSourceRoots csr = new ConfigSourceRoots(configFile, List.of("src", "lib"));
+
+    assertThat(csr.toAbsolutePaths()).isEmpty();
+  }
+}

python-commons/src/test/java/org/sonar/plugins/python/indexer/PackageRootResolverTest.java

@@ -35,17 +35,23 @@ class PackageRootResolverTest {
   Path tempDir;
 
   @Test
-  void resolve_withExtractedRoots_returnsAbsolutePaths() {
+  void resolve_withExtractedRoots_returnsThemDirectly() {
+    // Extracted roots are now expected to be already absolute paths
+    // (resolved relative to the config file location by PythonIndexer)
     Configuration config = mock(Configuration.class);
     when(config.getStringArray("sonar.sources")).thenReturn(new String[0]);
 
     File baseDir = tempDir.toFile();
-    List<String> extractedRoots = List.of("src", "lib");
+    List<String> extractedRoots = List.of(
+      new File(baseDir, "subproject/src").getAbsolutePath(),
+      new File(baseDir, "subproject/lib").getAbsolutePath()
+    );
     List<String> result = PackageRootResolver.resolve(extractedRoots, config, baseDir);
 
+    // Should return the paths as-is since they're already absolute
     assertThat(result).containsExactly(
-      new File(baseDir, "src").getAbsolutePath(),
-      new File(baseDir, "lib").getAbsolutePath());
+      new File(baseDir, "subproject/src").getAbsolutePath(),
+      new File(baseDir, "subproject/lib").getAbsolutePath());
   }
 
   @Test
@@ -54,10 +60,12 @@ void resolve_withExtractedRoots_ignoresSonarSources() {
     when(config.getStringArray("sonar.sources")).thenReturn(new String[]{"other"});
 
     File baseDir = tempDir.toFile();
-    List<String> extractedRoots = List.of("src");
+    // Extracted roots are already absolute paths
+    List<String> extractedRoots = List.of(new File(baseDir, "app/src").getAbsolutePath());
     List<String> result = PackageRootResolver.resolve(extractedRoots, config, baseDir);
 
-    assertThat(result).containsExactly(new File(baseDir, "src").getAbsolutePath());
+    // Should return the extracted root as-is, ignoring sonar.sources
+    assertThat(result).containsExactly(new File(baseDir, "app/src").getAbsolutePath());
   }
 
   @Test