Add API for retrieving the list of files that will be accessed

CHANGELOG.md

@@ -6,6 +6,14 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ### API Changes & RuleSet providers
 
+#### Retrieve input files
+
+The list of files which will be accessed by KtLint when linting or formatting a given path can now be retrieved with the new API `KtLint.getInputPaths(path: Path): List<Path>`. Currently, the `.editorconfig` files are the only files which will be accessed during linting or formatting in addition to the source files itself. 
+
+This API can be called with either a file or a directory. It's intended usage is that it is called once with a directory path before actually linting or formatting files. When called with a directory path, all `.editorconfig` in the directory or any of its subdirectories (except hidden directories) are returned. In case the given directory does not contain an `.editorconfig` file or if it does not contain the `root=true` setting, the parent directories are scanned as well until a root `.editorconfig` file is found.
+
+Calling this API with a file path results in the `.editorconfig` files that will be accessed when processing that specific file. In case the directory in which the file resides does not contain an `.editorconfig` file or if it does not contain the `root=true` setting, the parent directories are scanned until a root `.editorconfig` file is found.
+
 ### Added
 
 ### Fixed

ktlint-core/src/main/kotlin/com/pinterest/ktlint/core/KtLint.kt

@@ -8,6 +8,7 @@ import com.pinterest.ktlint.core.api.EditorConfigOverride
 import com.pinterest.ktlint.core.api.EditorConfigOverride.Companion.emptyEditorConfigOverride
 import com.pinterest.ktlint.core.api.EditorConfigProperties
 import com.pinterest.ktlint.core.api.UsesEditorConfigProperties
+import com.pinterest.ktlint.core.internal.EditorConfigFinder
 import com.pinterest.ktlint.core.internal.EditorConfigGenerator
 import com.pinterest.ktlint.core.internal.EditorConfigLoader
 import com.pinterest.ktlint.core.internal.RuleExecutionContext
@@ -21,6 +22,7 @@ import java.nio.file.FileSystems
 import java.nio.file.Path
 import java.nio.file.Paths
 import java.util.Locale
+import kotlin.io.path.isDirectory
 import org.ec4j.core.Resource
 import org.ec4j.core.model.PropertyType
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
@@ -340,6 +342,15 @@ public object KtLint {
         )
     }
 
+    /**
+     * Get the list of files which will be accessed by KtLint when linting or formatting the given file or directory.
+     */
+    public fun getInputPaths(path: Path): List<Path> =
+        EditorConfigFinder().findEditorConfigs(path) +
+            listOfNotNull(
+                path.takeIf { !it.isDirectory() },
+            )
+
     /**
      * Generates Kotlin `.editorconfig` file section content based on [ExperimentalParams].
      *

ktlint-core/src/main/kotlin/com/pinterest/ktlint/core/internal/EditorConfigFinder.kt

@@ -0,0 +1,85 @@
+package com.pinterest.ktlint.core.internal
+
+import com.pinterest.ktlint.core.initKtLintKLogger
+import com.pinterest.ktlint.core.internal.ThreadSafeEditorConfigCache.Companion.threadSafeEditorConfigCache
+import java.nio.charset.StandardCharsets
+import java.nio.file.FileVisitResult
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.SimpleFileVisitor
+import java.nio.file.attribute.BasicFileAttributes
+import kotlin.io.path.isDirectory
+import mu.KotlinLogging
+import org.ec4j.core.Resource
+import org.ec4j.core.ResourcePropertiesService
+import org.ec4j.core.model.Version
+import org.jetbrains.kotlin.konan.file.File
+
+private val logger = KotlinLogging.logger {}.initKtLintKLogger()
+
+internal class EditorConfigFinder {
+    /**
+     * Finds all relevant ".editorconfig" files for the given path.
+     */
+    fun findEditorConfigs(path: Path): List<Path> {
+        val result = mutableListOf<Path>()
+        val normalizedPath = path.normalize().toAbsolutePath()
+        if (path.isDirectory()) {
+            result += findEditorConfigsInSubDirectories(normalizedPath)
+        }
+        result += findEditorConfigsInParentDirectories(normalizedPath)
+        return result.toList()
+    }
+
+    private fun findEditorConfigsInSubDirectories(path: Path): List<Path> {
+        val result = mutableListOf<Path>()
+
+        Files.walkFileTree(
+            path,
+            object : SimpleFileVisitor<Path>() {
+                override fun visitFile(
+                    filePath: Path,
+                    fileAttrs: BasicFileAttributes,
+                ): FileVisitResult {
+                    if (filePath.File().name == ".editorconfig") {
+                        logger.trace { "- File: $filePath: add to list of accessed files" }
+                        result.add(filePath)
+                    }
+                    return FileVisitResult.CONTINUE
+                }
+
+                override fun preVisitDirectory(
+                    dirPath: Path,
+                    dirAttr: BasicFileAttributes,
+                ): FileVisitResult {
+                    return if (Files.isHidden(dirPath)) {
+                        logger.trace { "- Dir: $dirPath: Ignore" }
+                        FileVisitResult.SKIP_SUBTREE
+                    } else {
+                        logger.trace { "- Dir: $dirPath: Traverse" }
+                        FileVisitResult.CONTINUE
+                    }
+                }
+            },
+        )
+
+        return result.toList()
+    }
+
+    private fun findEditorConfigsInParentDirectories(path: Path): List<Path> {
+        // The logic to load parental ".editorconfig" files resides in the ec4j library. This library however uses a
+        // cache provided by KtLint. As of this the list of parental ".editorconfig" files can be extracted from the
+        // cache.
+        createLoaderService().queryProperties(path.resource())
+        return threadSafeEditorConfigCache.getPaths()
+    }
+
+    private fun Path?.resource() =
+        Resource.Resources.ofPath(this, StandardCharsets.UTF_8)
+
+    private fun createLoaderService() =
+        ResourcePropertiesService.builder()
+            .cache(threadSafeEditorConfigCache)
+            .loader(org.ec4j.core.EditorConfigLoader.of(Version.CURRENT))
+            .build()
+}

ktlint-core/src/main/kotlin/com/pinterest/ktlint/core/internal/ThreadSafeEditorConfigCache.kt

@@ -1,6 +1,7 @@
 package com.pinterest.ktlint.core.internal
 
 import com.pinterest.ktlint.core.initKtLintKLogger
+import java.nio.file.Paths
 import java.util.concurrent.locks.ReentrantReadWriteLock
 import kotlin.concurrent.read
 import kotlin.concurrent.write
@@ -72,6 +73,14 @@ internal class ThreadSafeEditorConfigCache : Cache {
             }.clear()
     }
 
+    /**
+     * Get the paths of files stored in the cache.
+     */
+    fun getPaths() =
+        inMemoryMap
+            .keys
+            .map { Paths.get(it.path.toString()) }
+
     private data class CacheValue(
         val editorConfigLoader: EditorConfigLoader,
         val editConfig: EditorConfig,

ktlint-core/src/test/kotlin/com/pinterest/ktlint/core/internal/EditorConfigFinderTest.kt

@@ -0,0 +1,191 @@
+package com.pinterest.ktlint.core.internal
+
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.absolutePathString
+import kotlin.io.path.writeText
+import org.assertj.core.api.Assertions.assertThat
+import org.jetbrains.kotlin.konan.file.File
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+
+class EditorConfigFinderTest {
+    @Nested
+    inner class FindByFile {
+        @Test
+        fun `Given a kotlin file in a subdirectory and a root-editorconfig file in the same directory then get the path of that editorconfig file`(
+            @TempDir
+            tempDir: Path,
+        ) {
+            val someSubDir = "some-project/src/main/kotlin"
+            tempDir.createFile("$someSubDir/.editorconfig", "root=true")
+            val kotlinFilePath = tempDir.createFile("$someSubDir/test.kt", "val foo = 42")
+
+            val actual =
+                EditorConfigFinder()
+                    .findEditorConfigs(kotlinFilePath)
+                    .mapNotNull { it.toRelativePathStringIn(tempDir) }
+
+            assertThat(actual).contains("$someSubDir/.editorconfig")
+        }
+
+        @Test
+        fun `Given a kotlin file in a subdirectory and a root-editorconfig file in a parent directory then get the path of that parent editorconfig file`(
+            @TempDir
+            tempDir: Path,
+        ) {
+            val someProjectDirectory = "some-project"
+            tempDir.createFile("$someProjectDirectory/.editorconfig", "root=true")
+            val kotlinFilePath = tempDir.createFile("$someProjectDirectory/src/main/kotlin/test.kt", "val foo = 42")
+
+            val actual =
+                EditorConfigFinder()
+                    .findEditorConfigs(kotlinFilePath)
+                    .mapNotNull { it.toRelativePathStringIn(tempDir) }
+
+            assertThat(actual).contains("$someProjectDirectory/.editorconfig")
+        }
+
+        @Test
+        fun `Given a kotlin file in a subdirectory and a non-root-editorconfig file in that same directory and a root-editorconfig file in a parent directory then get the paths of both editorconfig files`(
+            @TempDir
+            tempDir: Path,
+        ) {
+            val someProjectDirectory = "some-project"
+            tempDir.createFile("$someProjectDirectory/.editorconfig", "root=true")
+            tempDir.createFile("$someProjectDirectory/src/main/.editorconfig", "root=false")
+            val kotlinFilePath = tempDir.createFile("$someProjectDirectory/src/main/kotlin/test.kt", "val foo = 42")
+
+            val actual =
+                EditorConfigFinder()
+                    .findEditorConfigs(kotlinFilePath)
+                    .mapNotNull { it.toRelativePathStringIn(tempDir) }
+
+            assertThat(actual).contains(
+                "$someProjectDirectory/.editorconfig",
+                "$someProjectDirectory/src/main/.editorconfig",
+            )
+        }
+
+        @Test
+        fun `Given a kotlin file in a subdirectory and a root-editorconfig file in the parent directory and another root-editorconfig file in a great-parent directory then get the paths of editorconfig files excluding root-editorconfig once the first one is found`(
+            @TempDir
+            tempDir: Path,
+        ) {
+            val someProjectDirectory = "some-project"
+            tempDir.createFile("$someProjectDirectory/src/main/.editorconfig", "root=false")
+            tempDir.createFile("$someProjectDirectory/src/.editorconfig", "root=true")
+            tempDir.createFile("$someProjectDirectory/.editorconfig", "root=true")
+            val kotlinFilePath = tempDir.createFile("$someProjectDirectory/src/main/kotlin/test.kt", "val foo = 42")
+
+            val actual =
+                EditorConfigFinder()
+                    .findEditorConfigs(kotlinFilePath)
+                    .mapNotNull { it.toRelativePathStringIn(tempDir) }
+
+            assertThat(actual)
+                .contains(
+                    "$someProjectDirectory/src/main/.editorconfig",
+                    "$someProjectDirectory/src/.editorconfig",
+                ).doesNotContain(
+                    "$someProjectDirectory/.editorconfig",
+                )
+        }
+    }
+
+    @Nested
+    inner class FindByDirectory {
+        @Test
+        fun `Given a directory containing a root-editorconfig file and a subdirectory containing a editorconfig file then get the paths of both editorconfig files`(
+            @TempDir
+            tempDir: Path,
+        ) {
+            val someDirectory = "some-project"
+            tempDir.createFile("$someDirectory/.editorconfig", "root=true")
+            tempDir.createFile("$someDirectory/src/main/kotlin/.editorconfig", "some-property=some-value")
+
+            val actual =
+                EditorConfigFinder()
+                    .findEditorConfigs(tempDir.plus(someDirectory))
+                    .mapNotNull { it.toRelativePathStringIn(tempDir) }
+
+            assertThat(actual).contains(
+                "$someDirectory/.editorconfig",
+                "$someDirectory/src/main/kotlin/.editorconfig",
+            )
+        }
+
+        @Test
+        fun `Given a subdirectory containing an editorconfig file and a sibling subdirectory contain a editorconfig file in a parent directory then get the path of all editorconfig file except of the sibling subdirectory`(
+            @TempDir
+            tempDir: Path,
+        ) {
+            val someProjectDirectory = "some-project"
+            tempDir.createFile("$someProjectDirectory/.editorconfig", "root=true")
+            tempDir.createFile("$someProjectDirectory/src/main/kotlin/.editorconfig", "some-property=some-value")
+            tempDir.createFile("$someProjectDirectory/src/test/kotlin/.editorconfig", "some-property=some-value")
+
+            val actual =
+                EditorConfigFinder()
+                    .findEditorConfigs(tempDir.plus("$someProjectDirectory/src/main/kotlin"))
+                    .mapNotNull { it.toRelativePathStringIn(tempDir) }
+
+            assertThat(actual)
+                .contains(
+                    "$someProjectDirectory/.editorconfig",
+                    "$someProjectDirectory/src/main/kotlin/.editorconfig",
+                ).doesNotContain(
+                    "$someProjectDirectory/src/test/kotlin/.editorconfig",
+                )
+        }
+
+        @Test
+        fun `Given a directory containing an editorconfig file and multiple subdirectores containing a editorconfig file then get the path of all editorconfig files`(
+            @TempDir
+            tempDir: Path,
+        ) {
+            val someProjectDirectory = "some-project"
+            tempDir.createFile("$someProjectDirectory/.editorconfig", "root=true")
+            tempDir.createFile("$someProjectDirectory/src/main/kotlin/.editorconfig", "some-property=some-value")
+            tempDir.createFile("$someProjectDirectory/src/test/kotlin/.editorconfig", "some-property=some-value")
+
+            val actual =
+                EditorConfigFinder()
+                    .findEditorConfigs(tempDir.plus(someProjectDirectory))
+                    .mapNotNull { it.toRelativePathStringIn(tempDir) }
+
+            assertThat(actual).contains(
+                "$someProjectDirectory/.editorconfig",
+                "$someProjectDirectory/src/main/kotlin/.editorconfig",
+                "$someProjectDirectory/src/test/kotlin/.editorconfig",
+            )
+        }
+    }
+
+    private fun Path.createFile(fileName: String, content: String): Path {
+        val dirPath = fileName.substringBeforeLast("/", "")
+        Files.createDirectories(plus(dirPath))
+        return Files
+            .createFile(plus(fileName))
+            .also { it.writeText(content) }
+    }
+
+    private fun Path.plus(subPath: String): Path =
+        this
+            .absolutePathString()
+            .plus(File.separator)
+            .plus(subPath)
+            .let { Paths.get(it) }
+
+    private fun Path.toRelativePathStringIn(tempDir: Path): String? =
+        this
+            .takeIf {
+                // Ignore files created in temp dirs of other tests
+                it.startsWith(tempDir)
+            }?.absolutePathString()
+            ?.removePrefix(tempDir.absolutePathString())
+            ?.removePrefix(File.separator)
+            ?.replace(tempDir.fileSystem.separator, "/")
+}