Support reading source files from jars (#588)

* Support reading source files from jars

* Close test FileSystems and add changelog entry

* Apply spotless

---------

Co-authored-by: hfhbd <hfhbd@users.noreply.github.com>

Author: hfhbd

CHANGELOG.md

@@ -2,7 +2,8 @@
 
 ## Unreleased
 
-- Change visibility on CreateTableElementType https://github.com/sqldelight/sql-psi/pull/691
+- Change visibility on CreateTableElementType (https://github.com/sqldelight/sql-psi/pull/691)
+- Support reading jar files (https://github.com/sqldelight/sql-psi/pull/588)
 
 
 ## [0.6.0] - 2025-08-08

core/src/test/kotlin/com/alecstrong/sql/psi/core/PassingPredefinedTablesTest.kt

@@ -3,14 +3,15 @@ package com.alecstrong.sql.psi.core
 import com.alecstrong.sql.psi.test.fixtures.TestHeadlessParser
 import org.junit.Assert.fail
 import org.junit.Test
-import java.io.File
 import java.nio.file.Files
+import kotlin.io.path.div
+import kotlin.io.path.writeText
 
 class PassingPredefinedTablesTest {
   @Test
   fun mirrorSqlDelight() {
-    val temp = Files.createTempDirectory("predefinedTest").toFile()
-    File(temp, "Test.s").writeText(
+    val temp = Files.createTempDirectory("predefinedTest")
+    (temp / "Test.s").writeText(
       """
       SELECT * FROM dual;
       SELECT name FROM dual;

core/src/testFixtures/kotlin/com/alecstrong/sql/psi/test/fixtures/CompileFile.kt

@@ -2,8 +2,9 @@ package com.alecstrong.sql.psi.test.fixtures
 
 import com.alecstrong.sql.psi.core.SqlFileBase
 import com.intellij.core.CoreApplicationEnvironment
-import java.io.File
 import java.nio.file.Files
+import kotlin.io.path.div
+import kotlin.io.path.writeText
 
 fun compileFile(
   // language=sql
@@ -23,9 +24,9 @@ fun compileFiles(
   predefined: List<String> = emptyList(),
   action: (List<SqlFileBase>) -> Unit,
 ) {
-  val directory = Files.createTempDirectory("sql-psi").toFile()
+  val directory = Files.createTempDirectory("sql-psi")
   for ((index, content) in files.withIndex()) {
-    val file = File(directory, "$index.s")
+    val file = directory / "$index.s"
     file.writeText(content)
   }
 

core/src/testFixtures/kotlin/com/alecstrong/sql/psi/test/fixtures/FixturesTest.kt

@@ -33,7 +33,7 @@ abstract class FixturesTest(
     }
 
     val environment = TestHeadlessParser.build(
-      root = newRoot.path,
+      root = newRoot.toPath(),
       customInit = {
         setupDialect()
       },

core/src/testFixtures/kotlin/com/alecstrong/sql/psi/test/fixtures/TestHeadlessParser.kt

@@ -11,20 +11,20 @@ import com.intellij.openapi.fileTypes.LanguageFileType
 import com.intellij.psi.FileViewProvider
 import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.tree.IFileElementType
-import java.io.File
+import java.nio.file.Path
 
 object TestHeadlessParser {
   fun build(
-    root: String,
+    root: Path,
     annotator: SqlAnnotationHolder,
     predefinedTables: List<String> = emptyList(),
     customInit: CoreApplicationEnvironment.() -> Unit = { },
   ): SqlCoreEnvironment {
-    return build(listOf(File(root)), annotator, predefinedTables, customInit)
+    return build(listOf(root), annotator, predefinedTables, customInit)
   }
 
   fun build(
-    sourceFolders: List<File>,
+    sourceFolders: List<Path>,
     annotator: SqlAnnotationHolder,
     predefinedTables: List<String> = emptyList(),
     customInit: CoreApplicationEnvironment.() -> Unit = { },

environment/src/main/kotlin/com/alecstrong/sql/psi/core/SqlCoreEnvironment.kt

@@ -21,7 +21,6 @@ import com.intellij.openapi.roots.impl.ProjectRootManagerImpl
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.openapi.vfs.VirtualFileSystem
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiErrorElement
@@ -33,7 +32,8 @@ import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileIndex
 import com.intellij.workspaceModel.core.fileIndex.WorkspaceFileIndexContributor
 import com.intellij.workspaceModel.core.fileIndex.impl.WorkspaceFileIndexImpl
-import java.io.File
+import java.nio.file.Path
+import kotlin.io.path.pathString
 import kotlin.reflect.KClass
 
 private class ApplicationEnvironment {
@@ -65,8 +65,8 @@ private class ApplicationEnvironment {
 }
 
 open class SqlCoreEnvironment(
-  sourceFolders: List<File>,
-  dependencies: List<File>,
+  sourceFolders: List<Path>,
+  dependencies: List<Path>,
 ) : AutoCloseable {
   private val fileIndex: CoreFileIndex
 
@@ -76,9 +76,8 @@ open class SqlCoreEnvironment(
     env.coreApplicationEnvironment,
   )
 
-  protected val localFileSystem: VirtualFileSystem = VirtualFileManager.getInstance().getFileSystem(
-    StandardFileSystems.FILE_PROTOCOL,
-  )
+  private val localFileSystem: VirtualFileSystem = StandardFileSystems.local()
+  private val jarFileSystem: VirtualFileSystem = StandardFileSystems.jar()
 
   init {
     projectEnvironment.registerProjectComponent(
@@ -94,10 +93,20 @@ open class SqlCoreEnvironment(
       DirectoryIndexImpl(projectEnvironment.project),
     )
 
-    fileIndex = CoreFileIndex(sourceFolders, localFileSystem, projectEnvironment.project)
+    fileIndex = CoreFileIndex(
+      sourceFolders,
+      localFileSystem,
+      jarFileSystem,
+      project = projectEnvironment.project,
+    )
     projectEnvironment.project.registerService(ProjectFileIndex::class.java, fileIndex)
 
-    val contributorIndex = CoreFileIndex(sourceFolders + dependencies, localFileSystem, projectEnvironment.project)
+    val contributorIndex = CoreFileIndex(
+      sourceFolders + dependencies,
+      localFileSystem,
+      jarFileSystem,
+      project = projectEnvironment.project,
+    )
     projectEnvironment.project.registerService(
       SchemaContributorIndex::class.java,
       object : SchemaContributorIndex {
@@ -204,16 +213,27 @@ open class SqlCoreEnvironment(
 }
 
 private class CoreFileIndex(
-  val sourceFolders: List<File>,
-  private val localFileSystem: VirtualFileSystem,
+  val sourceFolders: List<Path>,
+  val localFileSystems: VirtualFileSystem,
+  val jarFileSystem: VirtualFileSystem,
   project: Project,
 ) : ProjectFileIndexImpl(project) {
   override fun iterateContent(iterator: ContentIterator): Boolean {
-    return sourceFolders.all {
-      val file = localFileSystem.findFileByPath(it.absolutePath)
-        ?: throw NullPointerException("File ${it.absolutePath} not found")
-      iterateContentUnderDirectory(file, iterator)
+    for (file in sourceFolders) {
+      val vFile = when (val schema = file.fileSystem.provider().scheme) {
+        StandardFileSystems.JAR_PROTOCOL -> {
+          val jarFilePath = file.toUri().toString().removePrefix("jar:file://")
+          jarFileSystem.findFileByPath(jarFilePath)
+        }
+        StandardFileSystems.FILE_PROTOCOL -> localFileSystems.findFileByPath(file.pathString)
+        else -> error("Not supported schema $schema")
+      } ?: throw NullPointerException("File ${file.pathString} not found")
+
+      if (!iterateContentUnderDirectory(vFile, iterator)) {
+        return false
+      }
     }
+    return true
   }
 
   override fun iterateContentUnderDirectory(file: VirtualFile, iterator: ContentIterator): Boolean {

sample-core/build.gradle

@@ -1,6 +1,7 @@
 plugins {
   alias(libs.plugins.kotlinJvm)
   alias(libs.plugins.grammarKitComposer)
+  id("java-test-fixtures")
 }
 
 grammarKit {
@@ -9,6 +10,7 @@ grammarKit {
 
 dependencies {
   compileOnly libs.bundles.intelliJ
+  testFixturesCompileOnly libs.bundles.intelliJ
 
   implementation projects.core
 }

sample-core/src/testFixtures/kotlin/SqliteTestFixtures.kt

@@ -0,0 +1,38 @@
+import com.alecstrong.sql.psi.sample.core.SampleFileType
+import java.net.URI
+import java.nio.file.FileSystem
+import java.nio.file.FileSystemNotFoundException
+import java.nio.file.FileSystems
+import java.nio.file.Path
+import kotlin.io.path.toPath
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+class SqliteTestFixtures : ReadOnlyProperty<Nothing?, Path>, AutoCloseable {
+  val jarFile: Path get() = SqliteTestFixtures::class.java.getResource("/SqliteTestFixtures.class")!!.toURI().toJarPath().parent
+
+  override operator fun getValue(thisRef: Nothing?, property: KProperty<*>): Path {
+    val uri =
+      SqliteTestFixtures::class.java.getResource("/${property.name}.${SampleFileType.defaultExtension}")!!.toURI()
+    return uri.toJarPath()
+  }
+
+  private val openFileSystems = mutableSetOf<FileSystem>()
+
+  override fun close() {
+    for (openFileSystem in openFileSystems) {
+      openFileSystem.close()
+    }
+  }
+
+  private fun URI.toJarPath(): Path {
+    val fileSystem = try {
+      FileSystems.getFileSystem(this)
+    } catch (_: FileSystemNotFoundException) {
+      val env = mapOf("create" to "true")
+      FileSystems.newFileSystem(this, env)
+    }
+    openFileSystems.add(fileSystem)
+    return toPath()
+  }
+}

sample-headless/src/main/kotlin/com/alecstrong/sql/psi/sample/headless/test.samplesql renamed to sample-core/src/testFixtures/resources/test.samplesql

@@ -0,0 +1,10 @@
+CREATE TABLE test2 (
+  sample_column 42 TEXT AS "java.util.List" NOT NULL
+);
+
+SELECT *
+FROM test, test2
+WHERE test.sample_column = "foo";
+
+SELECT * FROM test2 WHERE (1 = 1) FOO 13;
+SELECT * FROM test2 WHERE (1 = 1);