Sync from Intellij to Others

This commit provides the basic implementation of sending edits from
Intellij to the other peers. The other way around it not yet
implemented.

Author: schrieveslaach

src/main/kotlin/io/github/ethersync/DaemonOutputNotifier.kt

@@ -11,5 +11,7 @@ interface DaemonOutputNotifier {
          Topic.create("ethersync daemon output", DaemonOutputNotifier::class.java)
    }
 
+   fun clear()
+
    fun logOutput(line: String)
 }

src/main/kotlin/io/github/ethersync/EthersyncServiceImpl.kt

@@ -5,19 +5,18 @@ import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.EditorFactory
 import com.intellij.openapi.editor.LogicalPosition
-import com.intellij.openapi.editor.event.CaretEvent
-import com.intellij.openapi.editor.event.CaretListener
-import com.intellij.openapi.editor.event.EditorFactoryEvent
-import com.intellij.openapi.editor.event.EditorFactoryListener
+import com.intellij.openapi.editor.event.*
+import com.intellij.openapi.editor.impl.DocumentImpl
 import com.intellij.openapi.editor.markup.*
+import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.fileEditor.FileEditorManagerListener
 import com.intellij.openapi.fileEditor.TextEditor
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.ProjectManager
 import com.intellij.openapi.project.ProjectManagerListener
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.platform.diagnostic.telemetry.EDT
+import com.intellij.refactoring.suggested.newRange
 import com.intellij.ui.JBColor
 import com.intellij.util.io.await
 import com.intellij.util.io.awaitExit
@@ -34,8 +33,7 @@ import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import java.io.BufferedReader
 import java.io.File
 import java.io.InputStreamReader
-import java.util.Collections
-import java.util.LinkedList
+import java.util.*
 import java.util.concurrent.Executors
 
 private val LOG = logger<EthersyncServiceImpl>()
@@ -50,6 +48,12 @@ class EthersyncServiceImpl(
    private var daemonProcess: Process? = null
    private var clientProcess: Process? = null
 
+   data class EthersyncRevision(
+      var daemon: UInt = 0u,
+      var editor: UInt = 0u,
+   )
+   val revisions: HashMap<String, EthersyncRevision> = HashMap()
+
    init {
       val bus = project.messageBus.connect()
       bus.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, object : FileEditorManagerListener {
@@ -71,42 +75,82 @@ class EthersyncServiceImpl(
          }
       }
 
+      val documentListener = object : DocumentListener {
+         override fun documentChanged(event: DocumentEvent) {
+            val file = FileDocumentManager.getInstance().getFile(event.document)!!
+            val fileEditor = FileEditorManager.getInstance(project).getEditors(file)
+               .filterIsInstance<TextEditor>()
+               .first()
+
+            val editor = fileEditor.editor
+
+            val uri = file.url
+
+            val rev = revisions.getOrPut(uri) { EthersyncRevision() };
+            rev.editor += 1u
+
+            // TODO: this calc doesn't seem right because there are some odd changes on the Neovim instance
+            val start = editor.offsetToLogicalPosition(event.newRange.startOffset)
+            val end = editor.offsetToLogicalPosition(event.newRange.endOffset)
+
+            launchEditRequest(
+               EditRequest(
+                  uri,
+                  rev.daemon,
+                  Collections.singletonList(Delta(
+                     Range(
+                        Position(start.line, start.column),
+                        Position(end.line, end.column)
+                     ),
+                     event.newFragment.toString()
+                  ))
+               )
+            )
+         }
+      }
+
       for (editor in FileEditorManager.getInstance(project).allEditors) {
          if (editor is TextEditor) {
             editor.editor.caretModel.addCaretListener(caretListener)
+            editor.editor.document.addDocumentListener(documentListener)
          }
       }
 
       EditorFactory.getInstance().addEditorFactoryListener(object : EditorFactoryListener {
          override fun editorCreated(event: EditorFactoryEvent) {
             event.editor.caretModel.addCaretListener(caretListener)
+            event.editor.document.addDocumentListener(documentListener)
          }
 
          override fun editorReleased(event: EditorFactoryEvent) {
             event.editor.caretModel.removeCaretListener(caretListener)
+            event.editor.document.removeDocumentListener(documentListener)
          }
       }, project)
 
       ProjectManager.getInstance().addProjectManagerListener(project, object: ProjectManagerListener {
          override fun projectClosingBeforeSave(project: Project) {
-            if (clientProcess != null) {
-               cs.launch {
-                  clientProcess!!.destroy()
-                  clientProcess!!.awaitExit()
-                  clientProcess = null
-               }
-            }
-            if (daemonProcess != null) {
-               cs.launch {
-                  daemonProcess!!.destroy()
-                  daemonProcess!!.awaitExit()
-                  daemonProcess = null
-               }
+            cs.launch {
+               shutdown()
             }
          }
       })
    }
 
+   suspend fun shutdown() {
+      clientProcess?.let {
+         it.destroy()
+         it.awaitExit()
+         clientProcess = null
+      }
+      daemonProcess?.let {
+         it.destroy()
+         it.awaitExit()
+         daemonProcess = null
+      }
+      revisions.clear()
+   }
+
    override fun connectToPeer(peer: String) {
       val projectDirectory = File(project.basePath!!)
       val ethersyncDirectory = File(projectDirectory, ".ethersync")
@@ -118,14 +162,18 @@ class EthersyncServiceImpl(
             ethersyncDirectory.mkdir()
          }
 
+         val notifier = project.messageBus.syncPublisher(DaemonOutputNotifier.CHANGE_ACTION_TOPIC)
+         if (daemonProcess != null || clientProcess != null) {
+            notifier.clear()
+            shutdown()
+         }
+
          LOG.info("Starting ethersync daemon")
          val daemonProcessBuilder = ProcessBuilder("ethersync", "daemon", "--peer", peer, "--socket-name", socket)
             .directory(projectDirectory)
          daemonProcess = daemonProcessBuilder.start()
          val daemonProcess = daemonProcess!!
 
-         val notifier = project.messageBus.syncPublisher(DaemonOutputNotifier.CHANGE_ACTION_TOPIC)
-
          cs.launch {
             val stdout = BufferedReader(InputStreamReader(daemonProcess.inputStream))
             stdout.use {
@@ -229,9 +277,7 @@ class EthersyncServiceImpl(
    }
 
    private fun launchEthersyncClient(socket: String, projectDirectory: File) {
-
       cs.launch {
-
          LOG.info("Starting ethersync client")
          val clientProcessBuilder = ProcessBuilder("ethersync", "client", "--socket-name", socket)
                .directory(projectDirectory)
@@ -302,4 +348,15 @@ class EthersyncServiceImpl(
          }
       }
    }
+
+   fun launchEditRequest(editRequest: EditRequest) {
+      val launcher = launcher ?: return
+      cs.launch {
+         try {
+            launcher.remoteProxy.edit(editRequest).await()
+         } catch (e: ResponseErrorException) {
+            TODO("not yet implemented: notify about an protocol error")
+         }
+      }
+   }
 }

src/main/kotlin/io/github/ethersync/ToolWindowFactory.kt

@@ -35,6 +35,11 @@ class ToolWindowFactory : ToolWindowFactory {
       project.messageBus.connect().subscribe(
          DaemonOutputNotifier.CHANGE_ACTION_TOPIC,
          object : DaemonOutputNotifier {
+            override fun clear() {
+               body.clear()
+               logTextArea.text = document.html()
+            }
+
             override fun logOutput(line: String) {
                body.append(utilsAnsiHtml.convertAnsiToHtml(line))
                body.append("<br>")

src/main/kotlin/io/github/ethersync/protocol/Delta.kt

@@ -0,0 +1,11 @@
+package io.github.ethersync.protocol
+
+import com.google.gson.annotations.SerializedName
+import org.eclipse.lsp4j.Range
+
+data class Delta(
+   @SerializedName("range")
+   val range: Range,
+   @SerializedName("replacement")
+   val replacement: String
+)

src/main/kotlin/io/github/ethersync/protocol/EditRequest.kt

@@ -0,0 +1,12 @@
+package io.github.ethersync.protocol
+
+import com.google.gson.annotations.SerializedName
+
+data class EditRequest(
+   @SerializedName("uri")
+   val documentUri: String,
+   @SerializedName("revision")
+   val revision: UInt,
+   @SerializedName("delta")
+   val delta: List<Delta>,
+)

src/main/kotlin/io/github/ethersync/protocol/EthersyncEditorProtocol.kt

@@ -1,12 +1,9 @@
 package io.github.ethersync.protocol
 
-import com.google.gson.JsonObject
 import org.eclipse.lsp4j.jsonrpc.services.JsonNotification
-import org.eclipse.lsp4j.jsonrpc.services.JsonRequest
-import java.util.concurrent.CompletableFuture
 
 interface EthersyncEditorProtocol {
+
    @JsonNotification("cursor")
    fun cursor(cursorEvent: CursorEvent)
-
 }

src/main/kotlin/io/github/ethersync/protocol/RemoteEthersyncClientProtocol.kt

@@ -12,6 +12,9 @@ interface RemoteEthersyncClientProtocol {
     @JsonRequest
     fun open(documentRequest: DocumentRequest): CompletableFuture<JsonObject>
 
+    @JsonRequest
+    fun edit(editRequest: EditRequest): CompletableFuture<JsonObject>
+
     @JsonNotification
     fun close(documentRequest: DocumentRequest)
 }