fix(model-sync-lib): fixed parameter type of model importer/exporter, fixed import

Author: mhuster23

model-sync-lib/build.gradle.kts

@@ -2,8 +2,6 @@ plugins {
     kotlin("jvm")
 }
 
-group = "org.modelix"
-
 repositories {
     mavenCentral()
 }

model-sync-lib/src/main/kotlin/org/modelix/model/sync/ModelExporter.kt

@@ -1,27 +1,19 @@
 package org.modelix.model.sync
 
-import org.modelix.model.api.IBranch
 import org.modelix.model.api.INode
-import org.modelix.model.api.getRootNode
 import org.modelix.model.api.serialize
 import org.modelix.model.data.ModelData
 import org.modelix.model.data.NodeData
 import org.modelix.model.data.associateWithNotNull
 import java.io.File
 
-class ModelExporter(private val branch: IBranch) {
+class ModelExporter(private val root: INode) {
 
     fun export(outputFile: File) {
-        lateinit var modelData: ModelData
-        branch.runRead {
-            val root = branch.getRootNode()
-            modelData = ModelData(root = root.asExported())
-        }
+        val modelData = ModelData(root = root.asExported())
         outputFile.parentFile.mkdirs()
         outputFile.writeText(modelData.toJson())
     }
-
-
 }
 
 fun INode.asExported() : NodeData {

model-sync-lib/src/main/kotlin/org/modelix/model/sync/ModelImporter.kt

@@ -1,13 +1,16 @@
 package org.modelix.model.sync
 
-import org.modelix.model.api.*
+import org.modelix.model.api.ConceptReference
+import org.modelix.model.api.INode
+import org.modelix.model.api.INodeReference
 import org.modelix.model.data.ModelData
 import org.modelix.model.data.NodeData
 import java.io.File
 
-class ModelImporter(private val branch: IBranch) {
+class ModelImporter(private val root: INode) {
 
     private lateinit var originalIdToRef: MutableMap<String, INodeReference>
+    private lateinit var originalIdToSpec: MutableMap<String, NodeData>
 
     fun import(jsonFile: File) {
         require(jsonFile.exists())
@@ -19,59 +22,72 @@ class ModelImporter(private val branch: IBranch) {
 
     fun import(data: ModelData) {
         originalIdToRef = mutableMapOf()
-        branch.runWrite {
-            val rootNode = branch.getRootNode()
-            if (rootNode.allChildren.none()) {
-                data.load(branch)
-                return@runWrite
-            }
-            buildRefIndex(rootNode)
-            syncNode(rootNode, data.root)
-        }
+        originalIdToSpec = mutableMapOf()
+        buildSpecIndex(data.root)
+        syncNode(root, data.root)
+        buildRefIndex(root)
+        syncAllReferences(root, data.root)
     }
 
     private fun buildRefIndex(node: INode) {
         node.originalId()?.let { originalIdToRef[it] = node.reference }
         node.allChildren.forEach { buildRefIndex(it) }
     }
 
+    private fun buildSpecIndex(nodeData: NodeData) {
+        nodeData.originalId()?.let { originalIdToSpec[it] = nodeData }
+        nodeData.children.forEach { buildSpecIndex(it) }
+    }
+
     private fun syncNode(node: INode, nodeData: NodeData) {
         syncProperties(node, nodeData)
-        syncReferences(node, nodeData)
         syncChildNodes(node, nodeData)
     }
 
     private fun syncProperties(node: INode, nodeData: NodeData) {
         nodeData.properties.forEach { node.setPropertyValue(it.key, it.value) }
+        val toBeRemoved = node.getPropertyRoles().toSet()
+            .subtract(nodeData.properties.keys)
+            .filter { it != NodeData.idPropertyKey }
+        toBeRemoved.forEach { node.setPropertyValue(it, null) }
+    }
+
+    private fun syncAllReferences(root: INode, rootData: NodeData) {
+        syncReferences(root, rootData)
+        for ((node, data) in root.allChildren.zip(rootData.children)) {
+            syncAllReferences(node, data)
+        }
     }
 
     private fun syncReferences(node: INode, nodeData: NodeData) {
         nodeData.references.forEach { node.setReferenceTarget(it.key, originalIdToRef[it.value]) }
+        val toBeRemoved = node.getReferenceRoles().toSet().subtract(nodeData.references.keys)
+        toBeRemoved.forEach { node.setPropertyValue(it, null) }
     }
 
     private fun syncChildNodes(node: INode, nodeData: NodeData) {
         val toBeRemoved = mutableSetOf<INode>()
-        val existingIds = mutableSetOf<String>()
+        val existingIds = node.allChildren.map { it.originalId() }
+
+        val toBeAdded = nodeData.children.filter { !existingIds.contains(it.id) }
+
+        toBeAdded.forEach {
+            val index = nodeData.children.indexOf(it)
+            val createdNode = node.addNewChild(it.role, index, it.concept?.let { s -> ConceptReference(s) })
+            createdNode.setPropertyValue(NodeData.idPropertyKey, it.originalId())
+        }
 
         for (child in node.allChildren) {
-            child.originalId()?.let { existingIds.add(it) }
-            val foundChildData: NodeData? = nodeData.children.find { it.id == child.originalId() }
+            val foundChildData: NodeData? = originalIdToSpec[child.originalId()]
             if (foundChildData != null) {
                 syncNode(child, foundChildData)
             } else {
                 toBeRemoved.add(child)
             }
         }
 
-        val toBeAdded = nodeData.children.filter { !existingIds.contains(it.id) }
-
-        toBeAdded.forEach {
-            val index = nodeData.children.indexOf(it)
-            val createdNode = node.addNewChild(it.role, index, it.concept?.let { s -> ConceptReference(s) })
-            createdNode.setPropertyValue(NodeData.idPropertyKey, it.originalId())
-        }
         toBeRemoved.forEach { node.removeChild(it) }
-            syncChildOrder(node, nodeData)
+        syncChildOrder(node, nodeData)
     }
 
     private fun syncChildOrder(node: INode, nodeData: NodeData) {

model-sync-lib/src/test/kotlin/org/modelix/model/sync/ModelExporterTest.kt

@@ -38,7 +38,9 @@ class ModelExporterTest {
     fun `can export`() {
         val outputFile = File("build/test/model-export/model.json")
         assertDoesNotThrow {
-            ModelExporter(branch).export(outputFile)
+            branch.runRead {
+                ModelExporter(branch.getRootNode()).export(outputFile)
+            }
         }
 
         branch.runRead {

model-sync-lib/src/test/kotlin/org/modelix/model/sync/ModelImporterTest.kt

@@ -37,7 +37,7 @@ class ModelImporterTest {
                 model.load(branch)
 //                println("PRE-SPEC ${model.toJson()}")
 //                println("PRE-LOADED ${branch.getRootNode().toJson()}")
-                ModelImporter(branch).import(newModelFile)
+                ModelImporter(branch.getRootNode()).import(newModelFile)
 //                println("POST-SPEC ${newModel.root.toJson()}")
 //                println("POST-LOADED ${branch.getRootNode().toJson()}")
             }
@@ -84,7 +84,7 @@ class ModelImporterTest {
         val tempBranch = PBranch(tree, IdGenerator.getInstance(1))
         tempBranch.runWrite {
             assertDoesNotThrow {
-                ModelImporter(tempBranch).import(newModel)
+                ModelImporter(tempBranch.getRootNode()).import(newModel)
             }
             val children = tempBranch.getRootNode().allChildren.toList()
             assertEquals(newModel.root.children.size, children.size)