Added a new menu for path mappings to allow shortcuts like the built-in `...`

Note: need to rethink how normal paths are saved, they should potentially be saved raw (not absolute paths) and then the virtual file list needs to change to string and then dynamically on the fly replace with mappings of key -> value to make an absolute path that then will be used

1 files changed, 87 insertions, 26 deletions

diff --git a/src/main/kotlin/me/kyren223/trident/TridentState.kt b/src/main/kotlin/me/kyren223/trident/TridentState.kt
index 57a47b8..1163789 100644
--- a/src/main/kotlin/me/kyren223/trident/TridentState.kt
+++ b/src/main/kotlin/me/kyren223/trident/TridentState.kt
@@ -8,10 +8,14 @@ import com.intellij.openapi.vfs.VirtualFile
 
 object TridentState {
     private var projectFiles: MutableMap<String, MutableList<VirtualFile>> = mutableMapOf()
+    private var pathMappings: MutableMap<String, MutableMap<String, String>> = mutableMapOf()
     private const val TRIDENT_LIST_KEY = "TridentList"
-    private var quickMenu: TridentQuickMenu? = null
+    private const val PATH_MAPPINGS_LIST_KEY = "PathMappings"
+    private var quickMenu: QuickMenu? = null
     var quickMenuSelectedIndex: Int? = null
-    var quickMenuContent: String? = ""
+    var quickMenuContent: String = ""
+    private var pathMappingsMenu: PathMappingsMenu? = null
+    var pathMappingsContent: String = ""
 
     fun appendFile(project: Project, file: VirtualFile) {
         if (!file.isValid) return
@@ -33,30 +37,49 @@ object TridentState {
         if (project.name in projectFiles) return
         val properties = PropertiesComponent.getInstance(project)
 
+        val pathMappingsList = properties.getList(PATH_MAPPINGS_LIST_KEY)
+        var map = mutableMapOf<String, String>()
+        if (pathMappingsList == null) {
+            map["..."] = project.basePath!!
+        } else {
+            for (entry in pathMappingsList) {
+                val split = entry.split("=")
+                if (split.size != 2) continue
+                map[split[0]] = split[1]
+            }
+        }
+        this.pathMappings[project.name] = map
+
         val list = properties.getList(TRIDENT_LIST_KEY)
         if (list == null) {
             projectFiles[project.name] = mutableListOf()
-            return
-        }
-        val fs = LocalFileSystem.getInstance()
-        val files = list.stream()
+        } else {
+            val fs = LocalFileSystem.getInstance()
+            val files = list.stream()
                 .map { fs.findFileByPath(it) }
                 .toList()
                 .filterNotNull()
                 .filter { it.isValid }
                 .toMutableList()
-        projectFiles[project.name] = files
+            projectFiles[project.name] = files
+        }
     }
 
     private fun saveProject(project: Project) {
         if (project.name !in projectFiles) return
         val files = projectFiles[project.name]
         val properties = PropertiesComponent.getInstance(project)
+
         val stringList = files!!.stream()
-                .filter { it.isValid }
-                .map { it.path }
-                .toList()
+            .filter { it.isValid }
+            .map { it.path }
+            .toList()
         properties.setList(TRIDENT_LIST_KEY, stringList)
+
+        val pathMappingsString = pathMappings[project.name]!!.entries
+            .joinToString("\n") { "${it.key}=${it.value}" }
+            .split("\n")
+        properties.setList(PATH_MAPPINGS_LIST_KEY, pathMappingsString)
     }
 
     fun getIndexOfFile(project: Project, data: VirtualFile?): Int {
@@ -79,11 +102,11 @@ object TridentState {
 
         loadProject(project)
         val content = getProjectContent(project)
-        quickMenu = TridentQuickMenu(content)
+        quickMenu = QuickMenu(content)
         val result = quickMenu!!.showAndGet()
 
-        if (quickMenuContent != null && content != quickMenuContent) {
-            retrieveProjectFiles(project, quickMenuContent!!)
+        if (content != quickMenuContent) {
+            retrieveProjectFiles(project, quickMenuContent)
             saveProject(project)
         }
 
@@ -100,25 +123,63 @@ object TridentState {
     }
 
     private fun getProjectContent(project: Project): String {
-        val content = projectFiles[project.name]!!
-                .joinToString("\n") { it.path }
-                .replace(project.basePath!!, "...")
-                .trim()
+        loadProject(project)
+        val map = pathMappings[project.name] ?: throw IllegalStateException("Path mappings not found")
+        println("map: $map")
+        var content = projectFiles[project.name]!!
+            .joinToString("\n") { it.path }
+            .trim()
+        println("content: $content")
+        for ((key, value) in map) {
+            println("key: $key | value: $value")
+            content = content.replace(value, key)
+        }
+        println("content: $content")
         return content
     }
 
     private fun retrieveProjectFiles(project: Project, content: String) {
         loadProject(project)
         val files = content
-                .split("\n")
-                .asSequence()
-                .map { it.trim() }
-                .map { it.replace("...", project.basePath!!) }
-                .filter { it.isNotBlank() }
-                .map { LocalFileSystem.getInstance().findFileByPath(it) }
-                .filterNotNull()
-                .filter { it.isValid }
-                .toMutableList()
+            .split("\n")
+            .asSequence()
+            .map { it.trim() }
+            .map { line ->
+                pathMappings[project.name]!!.entries.fold(line) { acc, (key, value) ->
+                    acc.replace(key, value)
+                }
+            }
+//            .map {
+//                pathMappings[project.name]!!.entries.forEach { (key, value) -> it.replace(key, value) }
+//                it
+//            }
+            .filter { it.isNotBlank() }
+            .map { LocalFileSystem.getInstance().findFileByPath(it) }
+            .filterNotNull()
+            .filter { it.isValid }
+            .toMutableList()
         projectFiles[project.name] = files
     }
+
+    fun togglePathMappingsMenu(project: Project) {
+        if (pathMappingsMenu != null && pathMappingsMenu!!.isShowing) {
+            pathMappingsMenu!!.doCancelAction()
+            return
+        }
+
+        loadProject(project)
+        val content = pathMappings[project.name]!!.entries
+            .joinToString("\n") { "${it.key}=${it.value}" }
+        pathMappingsMenu = PathMappingsMenu(content)
+        pathMappingsMenu!!.showAndGet()
+
+        if (content != pathMappingsContent) {
+            pathMappingsContent.split("\n").forEach {
+                val split = it.split("=")
+                if (split.size != 2) return@forEach
+                this.pathMappings[project.name]!![split[0]] = split[1]
+            }
+            saveProject(project)
+        }
+    }
 }
\ No newline at end of file