Teamtype v0.9.x Support

schrieveslaach · schrieveslaach · commit e2eadf74dd5e · 2026-02-18T00:05:02.000+01:00
This change ports the code to support Teamtype 0.9.x (fixes #12). Additionally, this change provides the first and rudimentary test infrastructure to make sure that the plugin works as intended.
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
@@ -8,6 +8,14 @@ Make sure you have at least a JDK 21 installed on your machine and that the
 `./gradlew runIde --no-daemon` directly builds & starts a sandboxed IntelliJ
 IDEA with the plugin enabled.
 
+Testing is currently in the beginning and there is exists some issue in the
+`HeavyPlatfromTestCase` so one has to manually run tests in isolation:
+
+```bash
+./gradlew test --info --rerun --tests EthersyncServiceImplTest.test01SyncChangesFromRemoteProjectToJetbrains
+./gradlew test --info --rerun --tests EthersyncServiceImplTest.test02SyncChangesFromJetbrainsToRemoteProject
+```
+
 ## Install into existing IDE
 
 `./gradlew buildPlugin` creates in `build/distributions/` a ZIP archive that
diff --git a/README.md b/README.md
@@ -11,7 +11,7 @@ Currently, the project is in development but the pre-release version of the
 plugin can be installed by downloading the latest ZIP from [here][nightly
 download] and this ZIP can be installed into the Jetbrains product from disk
 (see [install from disk] instructions for IntelliJ). Please note, that this
-version currently only supports Ethersync 0.8.
+version currently only supports Teamtype 0.9.x.
 
 # Development
 
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -1,3 +1,5 @@
+import org.jetbrains.intellij.platform.gradle.TestFrameworkType
+
 plugins {
    id("java")
    // Do not upgrade until following has been fixed:
@@ -21,10 +23,17 @@ dependencies {
    intellijPlatform {
       intellijIdeaCommunity("2024.3.1.1")
       bundledPlugin("org.jetbrains.plugins.terminal")
+
+      testFramework(TestFrameworkType.Platform)
    }
 
    implementation("org.eclipse.lsp4j:org.eclipse.lsp4j:0.23.1")
    implementation("org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc:0.23.1")
+
+   testImplementation("junit:junit:4.13.2")
+   testImplementation("org.junit.jupiter:junit-jupiter-api:5.14.1")
+   testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.14.1")
+   testRuntimeOnly("org.junit.vintage:junit-vintage-engine")
 }
 
 kotlin {
@@ -38,13 +47,9 @@ tasks {
       sinceBuild.set("243")
    }
 
-   signPlugin {
-      certificateChain.set(System.getenv("CERTIFICATE_CHAIN"))
-      privateKey.set(System.getenv("PRIVATE_KEY"))
-      password.set(System.getenv("PRIVATE_KEY_PASSWORD"))
-   }
-
-   publishPlugin {
-      token.set(System.getenv("PUBLISH_TOKEN"))
+   test {
+      useJUnitPlatform {
+         includeEngines("junit-vintage")
+      }
    }
 }
diff --git a/src/main/kotlin/io/github/ethersync/EthersyncService.kt b/src/main/kotlin/io/github/ethersync/EthersyncService.kt
@@ -1,8 +1,10 @@
 package io.github.ethersync
 
+import kotlinx.coroutines.Job
+
 interface EthersyncService {
 
-   fun start(joinCode: String?)
+   fun start(joinCode: String?): Job
 
    fun shutdown()
 
diff --git a/src/main/kotlin/io/github/ethersync/EthersyncServiceImpl.kt b/src/main/kotlin/io/github/ethersync/EthersyncServiceImpl.kt
@@ -8,7 +8,8 @@ import com.intellij.openapi.application.EDT
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.EditorFactory
-import com.intellij.openapi.editor.event.*
+import com.intellij.openapi.editor.event.EditorFactoryEvent
+import com.intellij.openapi.editor.event.EditorFactoryListener
 import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.fileEditor.FileEditorManagerListener
 import com.intellij.openapi.fileEditor.TextEditor
@@ -18,23 +19,24 @@ import com.intellij.openapi.project.ProjectManager
 import com.intellij.openapi.project.ProjectManagerListener
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.wm.ToolWindowManager
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.util.io.BaseOutputReader
 import com.intellij.util.io.await
 import com.intellij.util.io.awaitExit
 import com.intellij.util.io.readLineAsync
-import com.intellij.util.io.BaseOutputReader
 import io.github.ethersync.protocol.*
 import io.github.ethersync.settings.AppSettings
 import io.github.ethersync.sync.Changetracker
 import io.github.ethersync.sync.Cursortracker
 import io.github.ethersync.ui.ToolWindow
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.consumeEach
 import org.eclipse.lsp4j.jsonrpc.Launcher
 import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import java.io.BufferedReader
 import java.io.File
+import java.io.IOException
 import java.io.InputStreamReader
 import java.nio.file.Files
 import java.nio.file.attribute.PosixFilePermissions
@@ -46,7 +48,7 @@ private val LOG = logger<EthersyncServiceImpl>()
 class EthersyncServiceImpl(
    private val project: Project,
    private val cs: CoroutineScope,
-)  : EthersyncService {
+) : EthersyncService {
 
    private var launcher: Launcher<RemoteEthersyncClientProtocol>? = null
    private var daemonProcess: ColoredProcessHandler? = null
@@ -55,6 +57,9 @@ class EthersyncServiceImpl(
    private val changetracker: Changetracker = Changetracker(project, cs)
    private val cursortracker: Cursortracker = Cursortracker(project, cs)
 
+   /** test-only! */
+   var attachDaemonOutputToUi: Boolean = true
+
    init {
       val bus = project.messageBus.connect()
       bus.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, object : FileEditorManagerListener {
@@ -83,10 +88,9 @@ class EthersyncServiceImpl(
 
       EditorFactory.getInstance().addEditorFactoryListener(object : EditorFactoryListener {
          override fun editorCreated(event: EditorFactoryEvent) {
-            val file = event.editor.virtualFile ?: return
-            if (!file.exists()) {
-               return
-            }
+            val doc = event.editor.document
+            val file = PsiDocumentManager.getInstance(project).getPsiFile(doc) ?: return
+            LOG.debug("Starting to watch changes of ${file}")
 
             event.editor.caretModel.addCaretListener(cursortracker)
             event.editor.document.addDocumentListener(changetracker)
@@ -103,7 +107,7 @@ class EthersyncServiceImpl(
          }
       }, project)
 
-      ProjectManager.getInstance().addProjectManagerListener(project, object: ProjectManagerListener {
+      ProjectManager.getInstance().addProjectManagerListener(project, object : ProjectManagerListener {
          override fun projectClosingBeforeSave(project: Project) {
             shutdown()
          }
@@ -132,75 +136,97 @@ class EthersyncServiceImpl(
       cursortracker.clear()
    }
 
-   override fun start(joinCode: String?) {
+   override fun start(joinCode: String?): Job {
       val cmd = GeneralCommandLine(AppSettings.getInstance().state.ethersyncBinaryPath)
 
       if (joinCode == null || joinCode.trim().isEmpty()) {
          cmd.addParameter("share")
-      }
-      else {
+      } else {
          cmd.addParameter("join")
          cmd.addParameter(joinCode.trim())
       }
 
-      launchDaemon(cmd)
+      return cs.launch {
+         val channel = Channel<Unit>()
+         launchDaemon(cmd, channel)
+         channel.consumeEach { msg ->
+            LOG.debug("Started: $msg")
+         }
+      }
    }
 
    override fun startWithCustomCommandLine(commandLine: String) {
       // TODO: splitting by " " is probably insufficient if there is an argument with spaces in it…
       val cmd = GeneralCommandLine(commandLine.split(" "))
 
-      launchDaemon(cmd)
+      cs.launch {
+         val channel = Channel<Unit>()
+         launchDaemon(cmd, channel)
+         channel.consumeEach { msg ->
+            LOG.debug("Started: $msg")
+         }
+      }
    }
 
-   private fun launchDaemon(cmd: GeneralCommandLine) {
+   private suspend fun launchDaemon(cmd: GeneralCommandLine, clientStarted: Channel<Unit>) {
       val projectDirectory = File(project.basePath!!)
-      val ethersyncDirectory = File(projectDirectory, ".ethersync")
+      val ethersyncDirectory = File(projectDirectory, ".teamtype")
       cmd.workDirectory = projectDirectory
 
-      cs.launch {
-         shutdownImpl()
+      shutdownImpl()
+
+      if (!ethersyncDirectory.exists()) {
+         LOG.debug("Creating teamtype directory")
+         val permissions = PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwx------"));
+         withContext(Dispatchers.IO) {
+            Files.createDirectory(ethersyncDirectory.toPath(), permissions)
+         };
+      }
 
-         if (!ethersyncDirectory.exists()) {
-            LOG.debug("Creating ethersync directory")
-            val permissions = PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwx------"));
-            Files.createDirectory(ethersyncDirectory.toPath(), permissions);
+      daemonProcess = object : ColoredProcessHandler(cmd) {
+         override fun readerOptions(): BaseOutputReader.Options {
+            return BaseOutputReader.Options.forMostlySilentProcess()
          }
+      }
 
-         withContext(Dispatchers.EDT) {
-            daemonProcess = object : ColoredProcessHandler(cmd) {
-               override fun readerOptions(): BaseOutputReader.Options {
-                  return BaseOutputReader.Options.forMostlySilentProcess()
+      daemonProcess!!.addProcessListener(object : ProcessListener {
+         override fun startNotified(event: ProcessEvent) {
+            cs.launch {
+               val ethersyncSocket = File(ethersyncDirectory, "socket").toPath()
+               while (!Files.exists(ethersyncSocket)) {
+                  Thread.sleep(100)
                }
+               launchEthersyncClient(projectDirectory, clientStarted)
             }
+         }
 
-            daemonProcess!!.addProcessListener(object : ProcessListener {
-               override fun startNotified(event: ProcessEvent) {
-                  cs.launch {
-                     val ethersyncSocket = File(ethersyncDirectory, "socket").toPath()
-                     while (!Files.exists(ethersyncSocket)) {
-                        Thread.sleep(100)
-                     }
-                     launchEthersyncClient(projectDirectory)
-                  }
-               }
+         override fun processTerminated(event: ProcessEvent) {
+            shutdown()
+         }
+      })
 
-               override fun processTerminated(event: ProcessEvent) {
-                  shutdown()
-               }
-            })
 
-            val tw = ToolWindowManager.getInstance(project).getToolWindow("ethersync")!!
-            val toolWindow = tw.contentManager.findContent("Daemon")!!.component
-            if (toolWindow is ToolWindow) {
-               toolWindow.attachToProcess(daemonProcess!!)
-            }
+      attachDaemonToToolWindow()
 
-            tw.show()
+      daemonProcess!!.startNotify()
+   }
 
-            daemonProcess!!.startNotify()
+   private suspend fun attachDaemonToToolWindow() {
+      if (!attachDaemonOutputToUi) {
+         return
+      }
+      val process = daemonProcess ?: return
+
+      withContext(Dispatchers.EDT) {
+         val tw = ToolWindowManager.getInstance(project).getToolWindow("ethersync") ?: return@withContext
+
+         val daemon = tw.contentManager.findContent("Daemon") ?: return@withContext
+         val toolWindow = daemon.component
+         if (toolWindow is ToolWindow) {
+            toolWindow.attachToProcess(process)
          }
 
+         tw.show()
       }
    }
 
@@ -218,51 +244,56 @@ class EthersyncServiceImpl(
       }
    }
 
-   private fun launchEthersyncClient(projectDirectory: File) {
+   private suspend fun launchEthersyncClient(projectDirectory: File, clientStarted: Channel<Unit>) {
       if (clientProcess != null) {
          return
       }
 
-      cs.launch {
-         LOG.info("Starting ethersync client")
-         // TODO: try catch not existing binary
-         val clientProcessBuilder = ProcessBuilder(AppSettings.getInstance().state.ethersyncBinaryPath, "client")
-               .directory(projectDirectory)
-         clientProcess = clientProcessBuilder.start()
-         val clientProcess = clientProcess!!
-
-         val ethersyncEditorProtocol = createProtocolHandler()
-         launcher = Launcher.createIoLauncher(
-               ethersyncEditorProtocol,
-               RemoteEthersyncClientProtocol::class.java,
-               clientProcess.inputStream,
-               clientProcess.outputStream,
-               Executors.newCachedThreadPool(),
-               { c -> c },
-               { _ -> run {} }
-         )
-
-         val listening = launcher!!.startListening()
-         cursortracker.remoteProxy = launcher!!.remoteProxy
-         changetracker.remoteProxy = launcher!!.remoteProxy
-
-         val fileEditorManager = FileEditorManager.getInstance(project)
-         for (file in fileEditorManager.openFiles) {
-            val content = LoadTextUtil.loadText(file).toString()
-            launchDocumentOpenRequest(file.canonicalFile!!.url, content)
-         }
+      LOG.info("Starting teamtype client")
+      // TODO: try catch not existing binary
+      val clientProcessBuilder = ProcessBuilder(AppSettings.getInstance().state.ethersyncBinaryPath, "client")
+         .directory(projectDirectory)
+      clientProcess = clientProcessBuilder.start()
+      val clientProcess = clientProcess!!
+
+      val ethersyncEditorProtocol = createProtocolHandler()
+      launcher = Launcher.createIoLauncher(
+         ethersyncEditorProtocol,
+         RemoteEthersyncClientProtocol::class.java,
+         clientProcess.inputStream,
+         clientProcess.outputStream,
+         Executors.newCachedThreadPool(),
+         { c -> c },
+         { _ -> run {} }
+      )
+
+      val listening = launcher!!.startListening()
+      cursortracker.remoteProxy = launcher!!.remoteProxy
+      changetracker.remoteProxy = launcher!!.remoteProxy
+
+      val fileEditorManager = FileEditorManager.getInstance(project)
+      for (file in fileEditorManager.openFiles) {
+         val content = LoadTextUtil.loadText(file).toString()
+         launchDocumentOpenRequest(file.canonicalFile!!.url, content)
+      }
 
-         clientProcess.awaitExit()
+      clientStarted.send(Unit)
+      clientStarted.close()
+      clientProcess.awaitExit()
 
-         listening.cancel(true)
-         listening.await()
+      listening.cancel(true)
+      listening.await()
 
-         if (clientProcess.exitValue() != 0) {
-            val stderr = BufferedReader(InputStreamReader(clientProcess.errorStream))
-            stderr.use {
-               while (true) {
+      if (clientProcess.exitValue() != 0) {
+         val stderr = BufferedReader(InputStreamReader(clientProcess.errorStream))
+         stderr.use {
+            while (true) {
+               try {
                   val line = stderr.readLineAsync() ?: break;
                   LOG.trace(line)
+               } catch (e: IOException) {
+                  LOG.trace(e)
+                  break
                }
             }
          }
diff --git a/src/main/kotlin/io/github/ethersync/settings/AppSettings.kt b/src/main/kotlin/io/github/ethersync/settings/AppSettings.kt
@@ -14,7 +14,7 @@ class AppSettings : PersistentStateComponent<AppSettings.State> {
 
    data class State(
       @NonNls
-      var ethersyncBinaryPath: String = "ethersync"
+      var ethersyncBinaryPath: String = "teamtype"
    )
 
    private var state: State = State()
diff --git a/src/main/kotlin/io/github/ethersync/sync/Changetracker.kt b/src/main/kotlin/io/github/ethersync/sync/Changetracker.kt
diff --git a/src/main/kotlin/io/github/ethersync/sync/Cursortracker.kt b/src/main/kotlin/io/github/ethersync/sync/Cursortracker.kt
diff --git a/src/test/kotlin/io/github/ethersync/EthersyncServiceImplTest.kt b/src/test/kotlin/io/github/ethersync/EthersyncServiceImplTest.kt

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ class AppSettings : PersistentStateComponent<AppSettings.State> {`
`14`	`14`
`15`	`15`	`data class State(`
`16`	`16`	`@NonNls`
`17`		`- var ethersyncBinaryPath: String = "ethersync"`
	`17`	`+ var ethersyncBinaryPath: String = "teamtype"`
`18`	`18`	`)`
`19`	`19`
`20`	`20`	`private var state: State = State()`