Read excluded patterns from configuration

server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt

@@ -18,6 +18,7 @@ import java.nio.file.Path
 class CompilerClassPath(
     private val config: CompilerConfiguration,
     private val scriptsConfig: ScriptsConfiguration,
+    private val exclusionsConfig: ExclusionsConfiguration,
     private val codegenConfig: CodegenConfiguration,
     private val databaseService: DatabaseService
 ) : Closeable {
@@ -162,7 +163,7 @@ class CompilerClassPath(
 
     private fun findJavaSourceFiles(root: Path): Set<Path> {
         val sourceMatcher = FileSystems.getDefault().getPathMatcher("glob:*.java")
-        return SourceExclusions(listOf(root), scriptsConfig)
+        return SourceExclusions(listOf(root), scriptsConfig, exclusionsConfig)
             .walkIncluded()
             .filter { sourceMatcher.matches(it.fileName) }
             .toSet()

server/src/main/kotlin/org/javacs/kt/Configuration.kt

@@ -114,4 +114,5 @@ public data class Configuration(
     val externalSources: ExternalSourcesConfiguration = ExternalSourcesConfiguration(),
     val inlayHints: InlayHintsConfiguration = InlayHintsConfiguration(),
     val formatting: FormattingConfiguration = FormattingConfiguration(),
+    val exclusions: ExclusionsConfiguration = ExclusionsConfiguration(),
 )

server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt

@@ -26,12 +26,12 @@ class KotlinLanguageServer(
     val config: Configuration = Configuration()
 ) : LanguageServer, LanguageClientAware, Closeable {
     val databaseService = DatabaseService()
-    val classPath = CompilerClassPath(config.compiler, config.scripts, config.codegen, databaseService)
+    val classPath = CompilerClassPath(config.compiler, config.scripts, config.exclusions, config.codegen, databaseService)
 
     private val tempDirectory = TemporaryDirectory()
     private val uriContentProvider = URIContentProvider(ClassContentProvider(config.externalSources, classPath, tempDirectory, CompositeSourceArchiveProvider(JdkSourceArchiveProvider(classPath), ClassPathSourceArchiveProvider(classPath))))
     val sourcePath = SourcePath(classPath, uriContentProvider, config.indexing, databaseService)
-    val sourceFiles = SourceFiles(sourcePath, uriContentProvider, config.scripts)
+    val sourceFiles = SourceFiles(sourcePath, uriContentProvider, config.scripts, config.exclusions)
 
     private val textDocuments = KotlinTextDocumentService(sourceFiles, sourcePath, config, tempDirectory, uriContentProvider, classPath)
     private val workspaces = KotlinWorkspaceService(sourceFiles, sourcePath, classPath, textDocuments, config)

server/src/main/kotlin/org/javacs/kt/KotlinWorkspaceService.kt

@@ -188,6 +188,13 @@ class KotlinWorkspaceService(
                 get("useKlsScheme")?.asBoolean?.let { externalSources.useKlsScheme = it }
                 get("autoConvertToKotlin")?.asBoolean?.let { externalSources.autoConvertToKotlin = it }
             }
+
+            // Update source file exclusions
+            get("exclusions")?.asJsonObject?.apply {
+                val exclusions = config.exclusions
+                get("excludePatterns")?.asJsonArray?.let { exclusions.excludePatterns = it.asList().map { it.asString } }
+                sf.updateExclusions()
+            }
         }
 
         LOG.info("Updated configuration: {}", settings)

server/src/main/kotlin/org/javacs/kt/SourceFiles.kt

@@ -66,10 +66,11 @@ private class NotifySourcePath(private val sp: SourcePath) {
 class SourceFiles(
     private val sp: SourcePath,
     private val contentProvider: URIContentProvider,
-    private val scriptsConfig: ScriptsConfiguration
+    private val scriptsConfig: ScriptsConfiguration,
+    private val exclusionsConfig: ExclusionsConfiguration,
 ) {
     private val workspaceRoots = mutableSetOf<Path>()
-    private var exclusions = SourceExclusions(workspaceRoots, scriptsConfig)
+    private var exclusions = SourceExclusions(workspaceRoots, scriptsConfig, exclusionsConfig)
     private val files = NotifySourcePath(sp)
     private val open = mutableSetOf<URI>()
 
@@ -181,15 +182,15 @@ class SourceFiles(
 
     private fun findSourceFiles(root: Path): Set<URI> {
         val sourceMatcher = FileSystems.getDefault().getPathMatcher("glob:*.{kt,kts}")
-        return SourceExclusions(listOf(root), scriptsConfig)
+        return SourceExclusions(listOf(root), scriptsConfig, exclusionsConfig)
             .walkIncluded()
             .filter { sourceMatcher.matches(it.fileName) }
             .map(Path::toUri)
             .toSet()
     }
 
     fun updateExclusions() {
-        exclusions = SourceExclusions(workspaceRoots, scriptsConfig)
+        exclusions = SourceExclusions(workspaceRoots, scriptsConfig, exclusionsConfig)
         LOG.info("Updated exclusions: ${exclusions.excludedPatterns}")
     }
 

server/src/test/kotlin/org/javacs/kt/CompiledFileTest.kt

@@ -36,7 +36,7 @@ class CompiledFileTest {
         val file = testResourcesRoot().resolve("compiledFile/CompiledFileExample.kt")
         val content = Files.readAllLines(file).joinToString("\n")
         val parse = compiler.createKtFile(content, file)
-        val classPath = CompilerClassPath(CompilerConfiguration(), ScriptsConfiguration(), CodegenConfiguration(), DatabaseService())
+        val classPath = CompilerClassPath(CompilerConfiguration(), ScriptsConfiguration(), ExclusionsConfiguration(), CodegenConfiguration(), DatabaseService())
         val sourcePath = listOf(parse)
         val (context, container) = compiler.compileKtFiles(sourcePath, sourcePath)
         CompiledFile(content, parse, context, container, sourcePath, classPath)

shared/src/main/kotlin/org/javacs/kt/ExclusionsConfiguration.kt

@@ -0,0 +1,5 @@
+package org.javacs.kt
+
+data class ExclusionsConfiguration(
+    var excludePatterns: List<String> = listOf(), // List of glob patterns
+)

shared/src/main/kotlin/org/javacs/kt/SourceExclusions.kt

@@ -3,28 +3,53 @@ package org.javacs.kt
 import org.javacs.kt.util.filePath
 import java.io.File
 import java.net.URI
+import java.util.regex.PatternSyntaxException
 import java.nio.file.FileSystems
+import java.nio.file.PathMatcher
 import java.nio.file.Path
 import java.nio.file.Paths
 
-// TODO: Read exclusions from gitignore/settings.json/... instead of
-// hardcoding them
 class SourceExclusions(
     private val workspaceRoots: Collection<Path>,
-    private val scriptsConfig: ScriptsConfiguration
+    private val scriptsConfig: ScriptsConfiguration,
+    private val exclusionsConfig: ExclusionsConfiguration,
 ) {
-    val excludedPatterns = (listOf(
+    val configuredExclusions = exclusionsConfig.excludePatterns.map { it.trim() }.filter { it.isNotEmpty() }
+    val excludedPatterns = listOf(
         ".git", ".hg", ".svn",                                                      // Version control systems
         ".idea", ".idea_modules", ".vs", ".vscode", ".code-workspace", ".settings", // IDEs
-        "bazel-*", "bin", "build", "node_modules", "target",                        // Build systems
+        "bazel-*", "bin", "node_modules",                                           // Build systems
     ) + when {
         !scriptsConfig.enabled -> listOf("*.kts")
         !scriptsConfig.buildScriptsEnabled -> listOf("*.gradle.kts")
         else -> emptyList()
-    })
+    } + configuredExclusions
 
     private val exclusionMatchers = excludedPatterns
-        .map { FileSystems.getDefault().getPathMatcher("glob:$it") }
+        .map(::parseExcludePattern)
+        .filterNotNull()
+
+    private fun parseExcludePattern(pattern: String): PathMatcher? {
+        fun warning(e: Exception) = LOG.warn("Did not recognize exclude pattern: '$pattern' (${e.message})")
+        try {
+            val normalizedPattern = pattern.removeSuffix("/").trim()
+            val pathMatcher =
+                // Takes inspiration from https://git-scm.com/docs/gitignore
+                if (normalizedPattern.contains("/")) {
+                    FileSystems.getDefault().getPathMatcher("glob:$normalizedPattern")
+                } else {
+                    PathMatcher { path -> path.any { FileSystems.getDefault().getPathMatcher("glob:$normalizedPattern").matches(it) } }
+                }
+            return pathMatcher
+        } catch (e: IllegalArgumentException) {
+            warning(e)
+        } catch (e: PatternSyntaxException) {
+            warning(e)
+        } catch (e: UnsupportedOperationException) {
+            warning(e)
+        }
+        return null
+    }
 
     /** Finds all non-excluded files recursively. */
     fun walkIncluded(): Sequence<Path> = workspaceRoots.asSequence().flatMap { root ->
@@ -42,7 +67,6 @@ class SourceExclusions(
         && exclusionMatchers.none { matcher ->
             workspaceRoots
                 .mapNotNull { if (file.startsWith(it)) it.relativize(file) else null }
-                .flatMap { it } // Extract path segments
                 .any(matcher::matches)
         }
 }

shared/src/test/kotlin/org/javacs/kt/SourceExclusionsTest.kt

@@ -0,0 +1,59 @@
+package org.javacs.kt
+
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.attribute.PosixFilePermissions
+import org.hamcrest.Matchers.equalTo
+import org.junit.After
+import org.junit.Assert.assertTrue
+import org.junit.Assert.assertFalse
+import org.junit.Before
+import org.junit.Test
+
+class SourceExclusionsTest {
+    private val workspaceRoots = listOf(File("/test/workspace1").toPath(), File("/test/workspace2").toPath())
+    private var excludePatterns = listOf<String>()
+
+    @Test
+    fun `test only default exclusions`() {
+        assertIncluded("/test/workspace1/src/main/kotlin/MyClass.kt")
+        assertIncluded("/test/workspace1/build/generated/blah.kt")
+        assertExcluded("/test/workspace1/.git")
+        assertExcluded("/test/workspace1/.git/HEAD")
+    }
+
+    @Test
+    fun `test configured exclusions`() {
+        excludePatterns = listOf("build","junk")
+        assertIncluded("/test/workspace1/src/main/kotlin/MyClass.kt")
+        assertExcluded("/test/workspace1/build/generated/blah.kt")
+        assertExcluded("/test/workspace1/src/main/kotlin/junk/blah.kt")
+    }
+
+    @Test
+    fun `test configured directory exclusions`() {
+        excludePatterns = listOf("build/dist/**")
+        assertIncluded("/test/workspace1/build/generated/blah.kt")
+        assertIncluded("/test/workspace1/blah/build/dist/blah.kt")
+        assertExcluded("/test/workspace1/build/dist/blah.kt")
+    }
+
+    @Test
+    fun `test configured wildcard directory exclusions`() {
+        excludePatterns = listOf("**/build/dist/**", "build/dist/**")
+        assertIncluded("/test/workspace1/build/generated/blah.kt")
+        assertExcluded("/test/workspace1/blah/build/dist/blah.kt")
+        assertExcluded("/test/workspace1/build/dist/blah.kt")
+    }
+
+    fun assertExcluded(path: String) {
+        val exclusions = SourceExclusions(workspaceRoots, ScriptsConfiguration(enabled = true, buildScriptsEnabled = true), ExclusionsConfiguration(excludePatterns=excludePatterns))
+        assertFalse("Expected $path to be excluded by $excludePatterns", exclusions.isPathIncluded(File(path).toPath()))
+    }
+
+    fun assertIncluded(path: String) {
+        val exclusions = SourceExclusions(workspaceRoots, ScriptsConfiguration(enabled = true, buildScriptsEnabled = true), ExclusionsConfiguration(excludePatterns=excludePatterns))
+        assertTrue("Expected $path to be included by $excludePatterns", exclusions.isPathIncluded(File(path).toPath()))
+    }
+}