feat(mps-sync-plugin): readonly bindings will have readonly modules (like stubs)

abstraktor · abstraktor · commit 3a4c1d96b4c9 · 2025-12-17T15:22:27.000+01:00
diff --git a/model-api/src/commonMain/kotlin/org/modelix/model/api/BuiltinLanguages.kt b/model-api/src/commonMain/kotlin/org/modelix/model/api/BuiltinLanguages.kt
@@ -146,6 +146,11 @@ object BuiltinLanguages {
                 uid = "0a7577d1-d4e5-431d-98b1-fae38f9aee80/474657388638618895/2206727074858242373",
             ).also(this::addProperty)
 
+            val readonlyStubModule = SimpleProperty(
+                "readonlyStubModule",
+                uid = "0a7577d1-d4e5-431d-98b1-fae38f9aee80/474657388638618895/4225291355523310000",
+            ).also(this::addProperty)
+
             val models = SimpleChildLink(
                 simpleName = "models",
                 isMultiple = true,
diff --git a/mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/MPSRepositoryAsNode.kt b/mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/MPSRepositoryAsNode.kt
@@ -66,6 +66,7 @@ data class MPSRepositoryAsNode(@get:JvmName("getRepository_") val repository: SR
                                 requireNotNull(sourceNode.getNode().getPropertyValue(BuiltinLanguages.MPSRepositoryConcepts.Module.id.toReference())) {
                                     "Solution has no ID: ${sourceNode.getNode()}"
                                 }.let { ModuleId.fromString(it) },
+                                sourceNode.getNode().getPropertyValue(BuiltinLanguages.MPSRepositoryConcepts.Module.readonlyStubModule.toReference()).toBoolean(),
                             ).let { MPSModuleAsNode(it) }
                         }
                         BuiltinLanguages.MPSRepositoryConcepts.Language.getReference() -> {
diff --git a/mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/SolutionProducer.kt b/mps-model-adapters/src/main/kotlin/org/modelix/model/mpsadapters/SolutionProducer.kt
@@ -20,23 +20,23 @@ import jetbrains.mps.vfs.IFile
 
 class SolutionProducer(private val myProject: IMPSProject) {
 
-    fun create(name: String, id: ModuleId): Solution {
+    fun create(name: String, id: ModuleId, readOnly: Boolean = false): Solution {
         val basePath = checkNotNull(myProject.getBasePath()) { "Project has no base path: $myProject" }
         val projectBaseDir = myProject.getFileSystem().getFile(basePath)
         val solutionBaseDir = projectBaseDir.findChild("solutions").findChild(name)
-        return create(name, id, solutionBaseDir)
+        return create(name, id, solutionBaseDir, readOnly)
     }
 
-    fun create(namespace: String, id: ModuleId, moduleDir: IFile): Solution {
+    fun create(namespace: String, id: ModuleId, moduleDir: IFile, readOnly: Boolean): Solution {
         val descriptorFile = moduleDir.findChild(namespace + MPSExtentions.DOT_SOLUTION)
-        val descriptor: SolutionDescriptor = createSolutionDescriptor(namespace, id, descriptorFile)
+        val descriptor: SolutionDescriptor = createSolutionDescriptor(namespace, id, descriptorFile, readOnly)
         val module = GeneralModuleFactory().instantiate(descriptor, descriptorFile) as Solution
         myProject.addModule(module)
         module.save()
         return module
     }
 
-    private fun createSolutionDescriptor(namespace: String, id: ModuleId, descriptorFile: IFile): SolutionDescriptor {
+    private fun createSolutionDescriptor(namespace: String, id: ModuleId, descriptorFile: IFile, readOnly: Boolean): SolutionDescriptor {
         val descriptor = SolutionDescriptor()
         // using outputPath instead of outputRoot for backwards compatibility
         // descriptor.outputRoot = "\${module}/source_gen"
@@ -53,6 +53,7 @@ class SolutionProducer(private val myProject: IMPSProject) {
 
         descriptor.modelRootDescriptors.add(DefaultModelRoot.createDescriptor(modelsDir.parent!!, modelsDir))
         descriptor.outputPath = descriptorFile.parent!!.findChild("source_gen").path
+        descriptor.readOnlyStubModule(readOnly)
         return descriptor
     }
 }
diff --git a/mps-sync-plugin3/src/main/kotlin/org/modelix/mps/sync3/BindingWorker.kt b/mps-sync-plugin3/src/main/kotlin/org/modelix/mps/sync3/BindingWorker.kt
@@ -154,6 +154,10 @@ class BindingWorker(
 
     private inline fun <R> forEachTarget(body: SyncTarget.() -> R): List<R> = syncTargets.map { body(it) }
     private inline fun <R> forEachTargetIndexed(body: SyncTarget.(index: Int) -> R): List<R> = syncTargets.withIndex().map { body(it.value, it.index) }
+    private inline fun forEachTargetIndexedMaybeReadonly(body: SyncTarget.(index: Int) -> IVersion): List<NewVersionSpec> =
+        forEachTargetIndexed { index ->
+            NewVersionSpec(body(this, index), bindingId.readonly)
+        }
 
     private suspend fun checkInSync(): String? {
         check(activated.get()) { "Binding is deactivated" }
@@ -268,7 +272,7 @@ class BindingWorker(
                 // Binding was never activated before. Overwrite local changes or do initial upload.
 
                 val existingRemoteVersions = forEachTargetIndexed { client().pullIfExists(branchRef) }
-                val createdRemoteVersions = forEachTargetIndexed { index ->
+                val createdRemoteVersions = forEachTargetIndexedMaybeReadonly { index ->
                     existingRemoteVersions[index] ?: client().initRepository(branchRef.repositoryId)
                 }
 
@@ -291,7 +295,7 @@ class BindingWorker(
                 // push local changes that happened while the binding was deactivated
                 val localChanges = doSyncFromMPS(createdBaseVersions, incremental = false)
 
-                val mergedVersions = forEachTargetIndexed { index ->
+                val mergedVersions = forEachTargetIndexedMaybeReadonly { index ->
                     val baseVersion = createdBaseVersions[index]
                     val localChange = localChanges?.get(index)?.takeIf { it != baseVersion }
                     if (localChange != null) {
@@ -311,7 +315,7 @@ class BindingWorker(
 
     suspend fun syncToMPS(incremental: Boolean): List<IVersion> {
         return runSync { oldVersions ->
-            val newVersions = forEachTargetIndexed { index ->
+            val newVersions = forEachTargetIndexedMaybeReadonly { index ->
                 val oldVersion = oldVersions?.get(index)
                 client().pull(branchRef, oldVersion)
             }
@@ -332,13 +336,15 @@ class BindingWorker(
         }
     }
 
-    private suspend fun doSyncToMPS(oldVersions: List<IVersion?>, newVersions: List<IVersion>, incremental: Boolean) {
+    data class NewVersionSpec(val version: IVersion, val readonly: Boolean) : IVersion by version
+
+    private suspend fun doSyncToMPS(oldVersions: List<IVersion?>, newVersions: List<NewVersionSpec>, incremental: Boolean) {
         if (oldVersions.zip(newVersions).all { it.first?.getContentHash() == it.second.getContentHash() }) return
 
         LOG.debug { "Updating MPS project from $oldVersions to $newVersions" }
 
         val newTrees = newVersions.map { it.getModelTree() }
-        val sourceModel = SyncTargetModel(newTrees.map { it.asModelSingleThreaded() })
+        val sourceModel = SyncTargetModel(newVersions.map { MaybeReadonlyIModel(it.getModelTree().asModelSingleThreaded(), it.readonly) })
         val baseVersions = oldVersions
         val filter = if (baseVersions.all { it != null } && incremental) {
             val invalidationTree = DefaultInvalidationTree(sourceModel.getRootNode().getNodeReference(), 100_000)
@@ -446,7 +452,7 @@ class BindingWorker(
             fun sync(invalidationTree: ModelSynchronizer.IIncrementalUpdateInformation): List<IVersion>? {
                 val idGenerator = DummyIdGenerator<INodeReference>()
                 val versionedTrees = oldVersions.map { VersionedModelTree(it, idGenerator) }
-                val model = SyncTargetModel(versionedTrees.map { it.asModel() })
+                val model = SyncTargetModel(versionedTrees.map { MaybeReadonlyIModel(it.asModel(), false) })
                 model.executeWrite {
                     val targetRoot = model.getRootNode()
                     MPSProjectAsNode.runWithProject(mpsProject) {
diff --git a/mps-sync-plugin3/src/main/kotlin/org/modelix/mps/sync3/ModelSyncService.kt b/mps-sync-plugin3/src/main/kotlin/org/modelix/mps/sync3/ModelSyncService.kt
@@ -236,6 +236,7 @@ class ModelSyncService(val project: Project) :
                         it.children.add(Element("repository").also { it.text = bindingEntry.key.branchRef.repositoryId.id })
                         it.children.add(Element("branch").also { it.text = bindingEntry.key.branchRef.branchName })
                         it.children.add(Element("versionHash").also { it.text = bindingEntry.value.versionHash })
+                        it.children.add(Element("readonly").also { it.text = bindingEntry.key.readonly.toString() })
                     }
                 },
             )
@@ -256,6 +257,7 @@ class ModelSyncService(val project: Project) :
                                 repositoryId,
                                 element.getChild("branch")?.text ?: return@mapNotNull null,
                             ),
+                            readonly = element.getChild("readonly")?.text.toBoolean(),
                         ) to BindingState(
                             versionHash = element.getChild("versionHash")?.text,
                             enabled = element.getChild("enabled")?.text.toBoolean(),
@@ -462,9 +464,10 @@ suspend fun jobLoop(
     }
 }
 
-data class BindingId(val connectionProperties: ModelServerConnectionProperties, val branchRef: BranchReference) {
+data class BindingId(val connectionProperties: ModelServerConnectionProperties, val branchRef: BranchReference, val readonly: Boolean = false) {
     override fun toString(): String {
-        return "BindingId($connectionProperties, ${branchRef.repositoryId}, ${branchRef.branchName})"
+        val readonlyStr = if (readonly) " readonly" else ""
+        return "BindingId($connectionProperties, ${branchRef.repositoryId}, ${branchRef.branchName}$readonlyStr)"
     }
 }
 
diff --git a/mps-sync-plugin3/src/main/kotlin/org/modelix/mps/sync3/SyncTargetModel.kt b/mps-sync-plugin3/src/main/kotlin/org/modelix/mps/sync3/SyncTargetModel.kt
@@ -20,7 +20,8 @@ import org.modelix.mps.multiplatform.model.MPSModuleReference
 import org.modelix.mps.multiplatform.model.MPSProjectModuleReference
 import org.modelix.mps.multiplatform.model.MPSProjectReference
 
-class SyncTargetModel(val models: List<IMutableModel>) : IMutableModel {
+data class MaybeReadonlyIModel(val model: IMutableModel, val readonly: Boolean) : IMutableModel by model
+class SyncTargetModel(val models: List<MaybeReadonlyIModel>) : IMutableModel {
     private val repositoryNode: RepositoryWrapper = RepositoryWrapper()
 
     override fun getRootNode(): IWritableNode = repositoryNode
@@ -74,9 +75,11 @@ class SyncTargetModel(val models: List<IMutableModel>) : IMutableModel {
         }
 
         fun getMPSModules(): List<IWritableNode> {
-            return getRepositories()
-                .flatMap { it.getChildren(modulesRole) }
-                .distinctBy { it.getNodeReference() }
+            return models.flatMap { model ->
+                NodeWrapper(model, model.getRootNode())
+                    .getChildren(modulesRole)
+                    .map { ModuleWrapper(model, it, model.readonly) }
+            }.distinctBy { it.getNodeReference() }
         }
 
         fun getMPSProjects(): List<IWritableNode> {
@@ -467,7 +470,7 @@ class SyncTargetModel(val models: List<IMutableModel>) : IMutableModel {
 
     private fun IWritableNode.unwrap() = if (this is NodeWrapper) this.node else this
 
-    inner class NodeWrapper(private val model: IMutableModel, val node: IWritableNode) : IWritableNode by node, ISyncTargetNode {
+    open inner class NodeWrapper(private val model: IMutableModel, val node: IWritableNode) : IWritableNode by node, ISyncTargetNode {
         private fun IWritableNode.wrap() = NodeWrapper(model, this)
         private fun Iterable<IWritableNode>.wrap() = map { it.wrap() }
 
@@ -559,6 +562,24 @@ class SyncTargetModel(val models: List<IMutableModel>) : IMutableModel {
         }
     }
 
+    inner class ModuleWrapper(model: IMutableModel, node: IWritableNode, val readonly: Boolean) : NodeWrapper(model, node) {
+        override fun getPropertyValue(property: IPropertyReference): String? {
+            if (property.matches(BuiltinLanguages.MPSRepositoryConcepts.Module.readonlyStubModule.toReference())) {
+                return readonly.toString()
+            } else {
+                return super.getPropertyValue(property)
+            }
+        }
+
+        override fun setPropertyValue(property: IPropertyReference, value: String?) {
+            if (property.matches(BuiltinLanguages.MPSRepositoryConcepts.Module.readonlyStubModule.toReference())) {
+                return // not supported
+            } else {
+                return super.setPropertyValue(property, value)
+            }
+        }
+    }
+
     abstract inner class WrapperBase : IWritableNode, ISyncTargetNode {
         abstract fun delegates(): Sequence<IWritableNode>
 
diff --git a/mps-sync-plugin3/src/test/kotlin/org/modelix/mps/sync3/MultipleBindingsTest.kt b/mps-sync-plugin3/src/test/kotlin/org/modelix/mps/sync3/MultipleBindingsTest.kt
@@ -95,6 +95,7 @@ class MultipleBindingsTest : ProjectSyncTestBase() {
                       <url>http://localhost:$port</url>
                       <repository>${branchRefLib.repositoryId.id}</repository>
                       <branch>${branchRefLib.branchName}</branch>
+                      <readonly>true</readonly>
                     </binding>
                   </component>
                 </project>
@@ -114,8 +115,13 @@ class MultipleBindingsTest : ProjectSyncTestBase() {
             "module4",
         )
         assertEquals(
-            setOf("module1", "module2", "module3", "module4"),
-            readAction { mpsProject.projectModules.map { it.moduleName }.toSet() },
+            setOf(
+                "module1" to false,
+                "module2" to false,
+                "module3" to true,
+                "module4" to true,
+            ),
+            readAction { mpsProject.projectModules.map { it.moduleName to it.isReadOnly }.toSet() },
         )
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,7 @@ data class MPSRepositoryAsNode(@get:JvmName("getRepository_") val repository: SR`
`66`	`66`	`requireNotNull(sourceNode.getNode().getPropertyValue(BuiltinLanguages.MPSRepositoryConcepts.Module.id.toReference())) {`
`67`	`67`	`"Solution has no ID: ${sourceNode.getNode()}"`
`68`	`68`	`}.let { ModuleId.fromString(it) },`
	`69`	`+ sourceNode.getNode().getPropertyValue(BuiltinLanguages.MPSRepositoryConcepts.Module.readonlyStubModule.toReference()).toBoolean(),`
`69`	`70`	`).let { MPSModuleAsNode(it) }`
`70`	`71`	`}`
`71`	`72`	`BuiltinLanguages.MPSRepositoryConcepts.Language.getReference() -> {`
Original file line number	Diff line number	Diff line change
`@@ -236,6 +236,7 @@ class ModelSyncService(val project: Project) :`
`236`	`236`	`it.children.add(Element("repository").also { it.text = bindingEntry.key.branchRef.repositoryId.id })`
`237`	`237`	`it.children.add(Element("branch").also { it.text = bindingEntry.key.branchRef.branchName })`
`238`	`238`	`it.children.add(Element("versionHash").also { it.text = bindingEntry.value.versionHash })`
	`239`	`+ it.children.add(Element("readonly").also { it.text = bindingEntry.key.readonly.toString() })`
`239`	`240`	`}`
`240`	`241`	`},`
`241`	`242`	`)`
`@@ -256,6 +257,7 @@ class ModelSyncService(val project: Project) :`
`256`	`257`	`repositoryId,`
`257`	`258`	`element.getChild("branch")?.text ?: return@mapNotNull null,`
`258`	`259`	`),`
	`260`	`+ readonly = element.getChild("readonly")?.text.toBoolean(),`
`259`	`261`	`) to BindingState(`
`260`	`262`	`versionHash = element.getChild("versionHash")?.text,`
`261`	`263`	`enabled = element.getChild("enabled")?.text.toBoolean(),`
`@@ -462,9 +464,10 @@ suspend fun jobLoop(`
`462`	`464`	`}`
`463`	`465`	`}`
`464`	`466`
`465`		`-data class BindingId(val connectionProperties: ModelServerConnectionProperties, val branchRef: BranchReference) {`
	`467`	`+data class BindingId(val connectionProperties: ModelServerConnectionProperties, val branchRef: BranchReference, val readonly: Boolean = false) {`
`466`	`468`	`override fun toString(): String {`
`467`		`- return "BindingId($connectionProperties, ${branchRef.repositoryId}, ${branchRef.branchName})"`
	`469`	`+ val readonlyStr = if (readonly) " readonly" else ""`
	`470`	`+ return "BindingId($connectionProperties, ${branchRef.repositoryId}, ${branchRef.branchName}$readonlyStr)"`
`468`	`471`	`}`
`469`	`472`	`}`
`470`	`473`
Original file line number	Diff line number	Diff line change
`@@ -95,6 +95,7 @@ class MultipleBindingsTest : ProjectSyncTestBase() {`
`95`	`95`	`<url>http://localhost:$port</url>`
`96`	`96`	`<repository>${branchRefLib.repositoryId.id}</repository>`
`97`	`97`	`<branch>${branchRefLib.branchName}</branch>`
	`98`	`+ <readonly>true</readonly>`
`98`	`99`	`</binding>`
`99`	`100`	`</component>`
`100`	`101`	`</project>`
`@@ -114,8 +115,13 @@ class MultipleBindingsTest : ProjectSyncTestBase() {`
`114`	`115`	`"module4",`
`115`	`116`	`)`
`116`	`117`	`assertEquals(`
`117`		`- setOf("module1", "module2", "module3", "module4"),`
`118`		`- readAction { mpsProject.projectModules.map { it.moduleName }.toSet() },`
	`118`	`+ setOf(`
	`119`	`+ "module1" to false,`
	`120`	`+ "module2" to false,`
	`121`	`+ "module3" to true,`
	`122`	`+ "module4" to true,`
	`123`	`+ ),`
	`124`	`+ readAction { mpsProject.projectModules.map { it.moduleName to it.isReadOnly }.toSet() },`
`119`	`125`	`)`
`120`	`126`	`}`
`121`	`127`	`}`