refactor(parser): simplify devin block processing logic

- Replace complex manual string manipulation with regex-based processing in `processDevinBlock`. - Remove redundant code and improve readability. - Update test imports to reflect changes in `CodeFence` class. - Adjust timeout in `ProjectFileUtil` from 10 to 5 seconds.
unit-mesh · Feb 10, 2025 · 4f54344 · 4f54344
1 parent 782e7c1
commit 4f54344
Show file tree

Hide file tree

Showing 3 changed files with 15 additions and 49 deletions.
diff --git a/core/src/main/kotlin/cc/unitmesh/devti/util/parser/CodeFence.kt b/core/src/main/kotlin/cc/unitmesh/devti/util/parser/CodeFence.kt
@@ -104,7 +104,6 @@ class CodeFence(
                 }
             }
 
-            // 处理最后剩余的内容
             if (currentIndex < content.length) {
                 val remainingContent = content.substring(currentIndex)
                 parseMarkdownContent(remainingContent, codeFences)
@@ -113,55 +112,23 @@ class CodeFence(
             return codeFences.filter { it.text.isNotEmpty() }
         }
 
-        private fun processDevinBlock(content: String): String {
+        fun processDevinBlock(content: String): String {
             var currentContent = content
-            var startIndex = 0
-
-            /// check for normal devin block, like ```devin\n// code\n```\n
-            val normalRegex = Regex("(^|\\n)```devin\\n(.*?)\\n```\\n")
-            val normalMatches = normalRegex.findAll(currentContent)
-            for (match in normalMatches) {
-                val devinContent = match.groups[2]?.value ?: ""
-                currentContent = currentContent.replaceRange(match.range.first, match.range.last + 1, "\n<devin>\n$devinContent</devin>")
-            }
-
-            while (true) {
-                val devinStart = currentContent.indexOf("```devin\n", startIndex)
-                if (devinStart == -1) {
-                    break
-                }
-
-                currentContent = currentContent.replaceRange(devinStart, devinStart + "```devin\n".length, "<devin>\n")
 
-                var devinEnd: Int
-                val standardEndPattern = "\n```\n```\n"
-                val errorEndPattern = "\n```\n"
+            val devinRegexBlock = Regex("(?<=^|\\n)```devin\\n([\\s\\S]*?)\\n```\\n")
+            val devinMatches = devinRegexBlock.findAll(content).toList()
+            val normalCodeBlock = Regex("```([\\w#+\\s]*)\\n")
 
-                if (currentContent.substring(devinStart + "<devin>\n".length).contains(standardEndPattern)) {
-                    devinEnd = currentContent.indexOf(standardEndPattern, startIndex = devinStart + "<devin>\n".length)
-                    if (devinEnd != -1) {
-                        devinEnd += standardEndPattern.length - "\n```\n".length
-                        currentContent = currentContent.replaceRange(
-                            devinEnd,
-                            devinEnd + standardEndPattern.length - "\n```\n".length,
-                            "</devin>"
-                        )
-                        startIndex = devinEnd + "</devin>".length
-                    } else {
-                        break
-                    }
-                } else if (currentContent.substring(devinStart + "<devin>\n".length).contains(errorEndPattern)) {
-                    devinEnd = currentContent.indexOf(errorEndPattern, startIndex = devinStart + "<devin>\n".length)
-                    if (devinEnd != -1) {
-                        currentContent =
-                            currentContent.replaceRange(devinEnd, devinEnd + errorEndPattern.length, "\n```\n</devin>")
-                        startIndex = devinEnd + "</devin>".length
-                    } else {
-                        break
+            for (match in devinMatches) {
+                var devinContent = match.groups[1]?.value ?: ""
+                if (normalCodeBlock.find(devinContent) != null) {
+                    if (!devinContent.trim().endsWith("```")) {
+                        devinContent += "\n```"
                     }
-                } else {
-                    break
                 }
+
+                val replacement = "\n<devin>\n$devinContent\n</devin>"
+                currentContent = currentContent.replace(match.value, replacement)
             }
 
             return currentContent

diff --git a/core/src/test/kotlin/cc/unitmesh/devti/parser/CodeFenceTest.kt b/core/src/test/kotlin/cc/unitmesh/devti/parser/CodeFenceTest.kt
@@ -1,6 +1,7 @@
 package cc.unitmesh.devti.parser
 
 import cc.unitmesh.devti.util.parser.CodeFence
+import cc.unitmesh.devti.util.parser.CodeFence.Companion.processDevinBlock
 import com.intellij.testFramework.fixtures.BasePlatformTestCase
 
 class CodeFenceTest : BasePlatformTestCase() {

diff --git a/exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/utils/ProjectFileUtil.kt b/exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/utils/ProjectFileUtil.kt
@@ -21,16 +21,14 @@ fun Project.findFile(filename: String, caseSensitively: Boolean = true): Virtual
     ApplicationManager.getApplication().assertReadAccessAllowed()
     val currentTask = ApplicationManager.getApplication().executeOnPooledThread<VirtualFile?> {
         val searchedFiles = runReadAction {
-                FilenameIndex.getVirtualFilesByName(filename, caseSensitively, ProjectScope.getProjectScope(this))
+                FilenameIndex.getVirtualFilesByName(filename, caseSensitively, ProjectScope.getContentScope(this))
             }
         return@executeOnPooledThread searchedFiles.firstOrNull()
     }
 
-    return currentTask.get(10, TimeUnit.SECONDS)
+    return currentTask.get(5, TimeUnit.SECONDS)
 }
 
-// getVirtualFilesByNamesIgnoringCase
-
 fun VirtualFile.canBeAdded(): Boolean {
     if (!this.isValid || this.isDirectory) return false
     if (this.fileType.isBinary || FileUtilRt.isTooLarge(this.length)) return false