refactor(mps-sync-plugin-lib): ApplicationScope -> ProjectScope refactoring (#112)

* refactor(mps-sync-plugin): remove unused listeners (MODELIX-952)

* refactor(mps-sync-plugin): make ModelSyncService project scoped instead of application scoped

* docs(mps-sync-plugin-lib): experimental api linting

* refactor(mps-sync-plugin): create a new GUI for each opened project

* refactor(mps-sync-plugin-lib): make some objects project-scoped (WIP)

BindingsRegistry, BranchRegistry, InjectableNotifierWrapper, BindingsComboBoxRefresher

* refactor(mps-sync-plugin-lib): make SyncQueue project-scoped (WIP)

* refactor(mps-sync-plugin-lib): refactor application-scoped objects to project-scoped services (WIP)

* refactor(mps-sync-plugin-lib): rename InjectableNotifierWrapper for a more descriptive name

* refactor(mps-sync-plugin-lib): move clases to more fitting packages

* refactor(mps-sync-plugin-lib): implement ServiceLocator to unify service injection (WIP)

* refactor(mps-sync-plugin): refactor plugin.xml

Remove those Services and Actions that are registered via annotations or the intelliJ API.
For simplicity reasons, start the BindingsComBoBoxRefresher directly in the ModelSyncGui.

* fix(mps-sync-plugin): avoid registering the Modelix Actions twice if we have more MPS windows open

* fix(mps-sync-plugin-lib): listen to ProjectManagerListener instead of ApplicationLifecycleListener

To get notified about when a Project is about to be disposed, before the actual disposal is happening.

* fix(mps-sync-plugin-lib): implement MPSLanguageRepository hashCode and equals by delegate

Otherwise it will cause troubles when more than once MPS instaces are running and register their ProjectRepositories.

* refactor(mps-sync-plugin): remove unncessary hashCode and equals from object

* fix(mps-sync-plugin): replace requireNotNull by checkNotNull

* fix(mps-sync-plugin): make ModelixActionGroup singleton

* refactor(mps-sync-plugin-lib): make MPS Language Repository Provider application-level

And use it once, instead of registering the MPSLanguageRepository for each project. At the end of the day, all ProjectRepositories use the same MPSModuleRepository internally. Therefore, it's enough to register this repository only once.

Author: benedekh

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/IRebindModulesSyncService.kt

@@ -11,7 +11,10 @@ import java.io.IOException
  * A sub-interface of [ISyncService] that can be implemented by all users of the modelix sync lib, so that they can
  * extend the default implementation in [SyncServiceImpl], e.g. adding extra logging or informing the users by errors.
  */
-@UnstableModelixFeature(reason = "The new modelix MPS plugin is under construction", intendedFinalization = "2024.1")
+@UnstableModelixFeature(
+    reason = "The new modelix MPS plugin is under construction",
+    intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.",
+)
 interface IRebindModulesSyncService {
 
     /**

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/ISyncService.kt

@@ -1,6 +1,5 @@
 package org.modelix.mps.sync
 
-import com.intellij.openapi.project.Project
 import jetbrains.mps.extapi.model.SModelBase
 import jetbrains.mps.project.AbstractModule
 import org.modelix.kotlin.utils.UnstableModelixFeature
@@ -13,7 +12,7 @@ import java.net.URL
 import java.util.concurrent.CompletableFuture
 
 @UnstableModelixFeature(reason = "The new modelix MPS plugin is under construction", intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.")
-interface ISyncService : AutoCloseable, IRebindModulesSyncService {
+interface ISyncService : IRebindModulesSyncService {
 
     override fun connectModelServer(serverURL: String, jwt: String?) = connectModelServer(URL(serverURL), jwt)
 
@@ -37,8 +36,6 @@ interface ISyncService : AutoCloseable, IRebindModulesSyncService {
     fun bindModuleFromMps(module: AbstractModule, branch: IBranch): Iterable<IBinding>
 
     fun bindModelFromMps(model: SModelBase, branch: IBranch): IBinding
-
-    fun setActiveProject(project: Project)
 }
 
 @UnstableModelixFeature(reason = "The new modelix MPS plugin is under construction", intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.")

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/SyncServiceImpl.kt

@@ -1,17 +1,15 @@
 package org.modelix.mps.sync
 
-import com.intellij.openapi.project.Project
 import jetbrains.mps.extapi.model.SModelBase
 import jetbrains.mps.project.AbstractModule
-import jetbrains.mps.project.MPSProject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import mu.KotlinLogging
+import org.jetbrains.mps.openapi.module.SRepository
 import org.modelix.kotlin.utils.UnstableModelixFeature
 import org.modelix.model.api.IBranch
-import org.modelix.model.api.ILanguageRepository
 import org.modelix.model.client2.ModelClientV2
 import org.modelix.model.client2.ReplicatedModel
 import org.modelix.model.lazy.BranchReference
@@ -21,17 +19,14 @@ import org.modelix.mps.sync.bindings.BindingsRegistry
 import org.modelix.mps.sync.bindings.EmptyBinding
 import org.modelix.mps.sync.bindings.ModelBinding
 import org.modelix.mps.sync.bindings.ModuleBinding
-import org.modelix.mps.sync.modelix.BranchRegistry
-import org.modelix.mps.sync.modelix.ITreeTraversal
-import org.modelix.mps.sync.modelix.ReplicatedModelInitContext
-import org.modelix.mps.sync.mps.ActiveMpsProjectInjector
-import org.modelix.mps.sync.mps.notifications.INotifier
-import org.modelix.mps.sync.mps.notifications.InjectableNotifierWrapper
+import org.modelix.mps.sync.modelix.branch.BranchRegistry
+import org.modelix.mps.sync.modelix.branch.ReplicatedModelInitContext
+import org.modelix.mps.sync.modelix.tree.ITreeTraversal
+import org.modelix.mps.sync.mps.notifications.WrappedNotifier
+import org.modelix.mps.sync.mps.services.InjectableService
+import org.modelix.mps.sync.mps.services.ServiceLocator
 import org.modelix.mps.sync.mps.util.ModuleIdWithName
 import org.modelix.mps.sync.mps.util.isDescriptorModel
-import org.modelix.mps.sync.tasks.FuturesWaitQueue
-import org.modelix.mps.sync.tasks.SyncQueue
-import org.modelix.mps.sync.transformation.cache.MpsToModelixMap
 import org.modelix.mps.sync.transformation.cache.MpsToModelixMapInitializerVisitor
 import org.modelix.mps.sync.transformation.modelixToMps.initial.ITreeToSTreeTransformer
 import org.modelix.mps.sync.transformation.mpsToModelix.initial.ModelSynchronizer
@@ -43,21 +38,32 @@ import java.net.URL
     reason = "The new modelix MPS plugin is under construction",
     intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.",
 )
-class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
+class SyncServiceImpl : ISyncService, InjectableService {
 
     private val logger = KotlinLogging.logger {}
-    private val mpsProjectInjector = ActiveMpsProjectInjector
-    private val notifierInjector = InjectableNotifierWrapper
 
     private val networkDispatcher = Dispatchers.IO // rather IO-intensive tasks
     private val cpuDispatcher = Dispatchers.Default // rather CPU-intensive tasks
 
-    init {
-        notifierInjector.notifier = userNotifier
+    private val notifier: WrappedNotifier
+        get() = serviceLocator.wrappedNotifier
 
-        logger.debug { "ModelixSyncPlugin: Registering built-in languages" }
-        // just a dummy call, the initializer of ILanguageRegistry takes care of the rest...
-        ILanguageRepository.default.javaClass
+    private val bindingsRegistry: BindingsRegistry
+        get() = serviceLocator.bindingsRegistry
+
+    private val branchRegistry: BranchRegistry
+        get() = serviceLocator.branchRegistry
+
+    private val mpsRepository: SRepository
+        get() = serviceLocator.mpsProject.repository
+
+    private val languageRepository: MPSLanguageRepository
+        get() = serviceLocator.languageRepository
+
+    private lateinit var serviceLocator: ServiceLocator
+
+    override fun initService(serviceLocator: ServiceLocator) {
+        this.serviceLocator = serviceLocator
     }
 
     @Throws(IOException::class)
@@ -78,19 +84,19 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
         logger.info { "Disconnected from ${client.baseUrl}" }
 
         logger.info { "Deactivating bindings and disposing cloned branch." }
-        BindingsRegistry.deactivateBindings(waitForCompletion = true)
-        BranchRegistry.close()
+        bindingsRegistry.deactivateBindings(waitForCompletion = true)
+        branchRegistry.dispose()
         logger.info { "Bindings are deactivated and branch is disposed." }
     }
 
     override fun disconnectFromBranch(branch: IBranch, branchName: String) {
         logger.info { "Deactivating bindings and disposing cloned branch $branchName." }
-        BindingsRegistry.deactivateBindings(waitForCompletion = true)
-        BranchRegistry.unsetBranch(branch)
+        bindingsRegistry.deactivateBindings(waitForCompletion = true)
+        branchRegistry.unsetBranch(branch)
         logger.info { "Bindings are deactivated and branch ($branchName) is disposed." }
     }
 
-    override fun getActiveBranch(): IBranch? = BranchRegistry.branch
+    override fun getActiveBranch(): IBranch? = branchRegistry.getBranch()
 
     /**
      * WARNING: this is a long-running blocking call.
@@ -112,13 +118,10 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
         initialVersion: CLVersion? = null,
     ): ReplicatedModel {
         logger.info { "Connecting to branch $branchReference with initial version $initialVersion (null = latest version)." }
-        val targetProject = mpsProjectInjector.activeMpsProject!!
-        val languageRepository = registerLanguages(targetProject)
-        val model = BranchRegistry.setReplicatedModel(
+        val model = branchRegistry.setReplicatedModel(
             client,
             branchReference,
             languageRepository,
-            targetProject,
             ReplicatedModelInitContext(CoroutineScope(networkDispatcher), initialVersion),
         )
         logger.info { "Connected to branch $branchReference with initial version $initialVersion" }
@@ -137,15 +140,11 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
     ): Iterable<IBinding> {
         val moduleName = module.name
         logger.info { "Binding Module '$moduleName' from the server ($branchReference)." }
-
-        val targetProject = mpsProjectInjector.activeMpsProject!!
-        val languageRepository = registerLanguages(targetProject)
-
         // fetch replicated model and branch content
         val branch = connectToBranch(client, branchReference)
 
         // transform the modules and models
-        val bindings = ITreeToSTreeTransformer(branch, languageRepository).transform(module.id)
+        val bindings = ITreeToSTreeTransformer(branch, languageRepository, serviceLocator).transform(module.id)
 
         notifyUserAboutBindings(bindings, moduleName)
 
@@ -164,7 +163,7 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
         if (!modules.iterator().hasNext()) {
             val message =
                 "The list is restorable Modules is empty, therefore no Module- or Model Binding is restored for them."
-            notifierInjector.notifyAndLogWarning(message, logger)
+            notifier.notifyAndLogWarning(message, logger)
             return null
         }
 
@@ -174,27 +173,25 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
         // recreate the mapping between the local MPS elements and the modelix Nodes
         val branch = replicatedModel.getBranch()
         runBlocking(cpuDispatcher) {
-            val repository = ActiveMpsProjectInjector.activeMpsProject?.repository
-            requireNotNull(repository) { "SRepository must exist, otherwise we cannot restore the Modules." }
-            val mappingRecreator = MpsToModelixMapInitializerVisitor(MpsToModelixMap, repository, branch)
+            val mappingRecreator = MpsToModelixMapInitializerVisitor(serviceLocator.nodeMap, mpsRepository, branch)
             val treeTraversal = ITreeTraversal(branch)
             treeTraversal.visit(mappingRecreator)
         }
 
         // register the bindings
         val bindings = mutableListOf<IBinding>()
         modules.forEach { module ->
-            val moduleBinding = ModuleBinding(module, branch)
-            BindingsRegistry.addModuleBinding(moduleBinding)
+            val moduleBinding = ModuleBinding(module, branch, serviceLocator)
+            bindingsRegistry.addModuleBinding(moduleBinding)
 
             module.models.forEach { model ->
                 require(model is SModelBase) { "Model ($model) is not an SModelBase." }
                 val binding = if (model.isDescriptorModel()) {
                     // We do not track changes in descriptor models. See ModelTransformer.isDescriptorModel()
                     EmptyBinding()
                 } else {
-                    val modelBinding = ModelBinding(model, branch)
-                    BindingsRegistry.addModelBinding(modelBinding)
+                    val modelBinding = ModelBinding(model, branch, serviceLocator)
+                    bindingsRegistry.addModelBinding(modelBinding)
                     modelBinding
                 }
                 bindings.add(binding)
@@ -218,7 +215,9 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
 
         // warning: blocking call
         @Suppress("UNCHECKED_CAST")
-        val bindings = ModuleSynchronizer(branch).addModule(module, true).getResult().get() as Iterable<IBinding>
+        val bindings = ModuleSynchronizer(branch, serviceLocator)
+            .addModule(module, true)
+            .getResult().get() as Iterable<IBinding>
 
         notifyUserAboutBindings(bindings, module.moduleName)
 
@@ -229,11 +228,11 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
         val hasAnyBinding = bindings.iterator().hasNext()
         if (hasAnyBinding) {
             val message = "Module- and Model Bindings for Module '$moduleName' are created."
-            notifierInjector.notifyAndLogInfo(message, logger)
+            notifier.notifyAndLogInfo(message, logger)
         } else {
             val message =
                 "No Module- or Model Binding is created for Module '$moduleName'. This might be due to an error."
-            notifierInjector.notifyAndLogWarning(message, logger)
+            notifier.notifyAndLogWarning(message, logger)
         }
     }
 
@@ -243,43 +242,20 @@ class SyncServiceImpl(userNotifier: INotifier) : ISyncService {
     override fun bindModelFromMps(model: SModelBase, branch: IBranch): IBinding {
         logger.info { "Binding Model '${model.name}' to the server." }
 
-        val synchronizer = ModelSynchronizer(branch)
+        val synchronizer = ModelSynchronizer(branch, serviceLocator = serviceLocator)
         // synchronize model. Warning: blocking call
         val binding = synchronizer.addModel(model).getResult().get() as IBinding
         // wait until the model imports are synced. Warning: blocking call
         synchronizer.resolveModelImportsInTask().getResult().get()
 
         if (binding !is EmptyBinding) {
             val message = "Model Binding for '${model.name}' is created."
-            notifierInjector.notifyAndLogInfo(message, logger)
+            notifier.notifyAndLogInfo(message, logger)
         } else {
             val message = "No Model Binding is created for '${model.name}'. This might be due to an error."
-            notifierInjector.notifyAndLogWarning(message, logger)
+            notifier.notifyAndLogWarning(message, logger)
         }
 
         return binding
     }
-
-    override fun setActiveProject(project: Project) {
-        mpsProjectInjector.setActiveProject(project)
-    }
-
-    override fun close() {
-        logger.debug { "Closing SyncServiceImpl." }
-        // dispose task and wait queues
-        SyncQueue.close()
-        FuturesWaitQueue.close()
-        // dispose replicated model
-        BranchRegistry.close()
-        // dispose all bindings
-        BindingsRegistry.deactivateBindings()
-        logger.debug { "SyncServiceImpl is closed." }
-    }
-
-    private fun registerLanguages(project: MPSProject): MPSLanguageRepository {
-        val repository = project.repository
-        val mpsLanguageRepo = MPSLanguageRepository(repository)
-        ILanguageRepository.register(mpsLanguageRepo)
-        return mpsLanguageRepo
-    }
 }

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/bindings/BindingsRegistry.kt

@@ -22,6 +22,7 @@ import org.jetbrains.mps.openapi.model.SModelId
 import org.jetbrains.mps.openapi.module.SModule
 import org.modelix.kotlin.utils.UnstableModelixFeature
 import org.modelix.mps.sync.IBinding
+import org.modelix.mps.sync.mps.services.InjectableService
 import org.modelix.mps.sync.util.synchronizedLinkedHashSet
 import org.modelix.mps.sync.util.synchronizedMap
 import java.util.concurrent.CompletableFuture
@@ -30,7 +31,7 @@ import java.util.concurrent.LinkedBlockingQueue
 import java.util.function.BiConsumer
 
 @UnstableModelixFeature(reason = "The new modelix MPS plugin is under construction", intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.")
-object BindingsRegistry {
+class BindingsRegistry : InjectableService {
 
     private val modelBindingsByModule = synchronizedMap<SModule, MutableSet<ModelBinding>>()
     private val moduleBindings = synchronizedLinkedHashSet<ModuleBinding>()
@@ -119,6 +120,10 @@ object BindingsRegistry {
 
     private fun bindingRemoved(binding: IBinding) =
         changedBindings.put(BindingState(binding, BindingLifecycleState.REMOVE))
+
+    override fun dispose() {
+        deactivateBindings()
+    }
 }
 
 @UnstableModelixFeature(reason = "The new modelix MPS plugin is under construction", intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.")

mps-sync-plugin-lib/src/main/kotlin/org/modelix/mps/sync/bindings/ModelBinding.kt

@@ -22,27 +22,30 @@ import mu.KotlinLogging
 import org.modelix.kotlin.utils.UnstableModelixFeature
 import org.modelix.model.api.IBranch
 import org.modelix.mps.sync.IBinding
-import org.modelix.mps.sync.mps.notifications.InjectableNotifierWrapper
+import org.modelix.mps.sync.mps.services.ServiceLocator
 import org.modelix.mps.sync.tasks.SyncDirection
 import org.modelix.mps.sync.tasks.SyncLock
-import org.modelix.mps.sync.tasks.SyncQueue
-import org.modelix.mps.sync.transformation.cache.MpsToModelixMap
 import org.modelix.mps.sync.transformation.mpsToModelix.incremental.ModelChangeListener
 import org.modelix.mps.sync.transformation.mpsToModelix.incremental.NodeChangeListener
 import org.modelix.mps.sync.util.completeWithDefault
 import java.util.concurrent.CompletableFuture
 
-@UnstableModelixFeature(reason = "The new modelix MPS plugin is under construction", intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.")
-class ModelBinding(val model: SModelBase, branch: IBranch) : IBinding {
+@UnstableModelixFeature(
+    reason = "The new modelix MPS plugin is under construction",
+    intendedFinalization = "This feature is finalized when the new sync plugin is ready for release.",
+)
+class ModelBinding(val model: SModelBase, branch: IBranch, serviceLocator: ServiceLocator) : IBinding {
 
     private val logger = KotlinLogging.logger {}
-    private val nodeMap = MpsToModelixMap
-    private val syncQueue = SyncQueue
-    private val bindingsRegistry = BindingsRegistry
-    private val notifierInjector = InjectableNotifierWrapper
 
-    private val modelChangeListener = ModelChangeListener(branch, this)
-    private val nodeChangeListener = NodeChangeListener(branch)
+    private val nodeMap = serviceLocator.nodeMap
+    private val syncQueue = serviceLocator.syncQueue
+
+    private val bindingsRegistry = serviceLocator.bindingsRegistry
+    private val notifier = serviceLocator.wrappedNotifier
+
+    private val modelChangeListener = ModelChangeListener(this, branch, serviceLocator)
+    private val nodeChangeListener = NodeChangeListener(branch, serviceLocator)
 
     @Volatile
     private var isDisposed = false
@@ -68,7 +71,7 @@ class ModelBinding(val model: SModelBase, branch: IBranch) : IBinding {
         bindingsRegistry.bindingActivated(this)
 
         val message = "${name()} is activated."
-        notifierInjector.notifyAndLogInfo(message, logger)
+        notifier.notifyAndLogInfo(message, logger)
 
         callback?.run()
     }
@@ -142,7 +145,7 @@ class ModelBinding(val model: SModelBase, branch: IBranch) : IBinding {
                     ""
                 }
             }."
-            notifierInjector.notifyAndLogInfo(message, logger)
+            notifier.notifyAndLogInfo(message, logger)
 
             callback?.run()
         }.getResult()