test:添加测试用例

Author: yefansky

src/cvbManager.ts

@@ -830,13 +830,11 @@ export function applyGlobalReplace(
     });
   }
 
-  try {
     return FuzzyMatch.applyFuzzyGlobalReplace(strContent, op.m_strOldContent, op.m_strNewContent);
-  } catch {
+    
     const errorMsg = `GLOBAL-REPLACE 失败：FILE:"${op.m_strFilePath}" 中未找到OLD_CONTENT: "${op.m_strOldContent}" 可能是和原文有细微差异，或者文件路径和别的文件搞错了`;
     console.log(errorMsg + `\n表达式: ${regPattern}`);
     throw new Error(errorMsg);
-  }
 }
 
 // 根据前锚点、内容、后锚点构建正则表达式（dotall 模式）

src/fuzzyMatch.ts

@@ -37,33 +37,141 @@ export function applyFuzzyGlobalReplace(
 }
 
 // ================ 算法核心模块 ================
-function normalizeContent(original: string): NormalizedContent {
-    const mapping: number[] = [];
-    let normalized = "";
-    let lastCharIsWhitespace = true;
-    let currentPos = 0;
-
-    for (const char of original) {
-        if (/\s/.test(char)) {
-        if (!lastCharIsWhitespace) {
-            normalized += ' ';
-            mapping.push(currentPos);
-            lastCharIsWhitespace = true;
+export function normalizeContent(original: string): { content: string; mapping: number[] } {
+    // 第一步：去除注释
+    const { content: noComments, mapping: mapping1 } = removeComments(original);
+
+    // 第二步：去除符号前后的空格
+    const { content: noSymbolSpaces, mapping: mapping2 } = removeSymbolSpaces(noComments);
+
+    // 第三步：将换行符改为空格，并合并连续的空格
+    const { content: finalContent, mapping: mapping3 } = normalizeWhitespace(noSymbolSpaces);
+
+    // 合并 mapping
+    const finalMapping = mapping3.map(idx => mapping2[idx]).map(idx => mapping1[idx]);
+
+    return { content: finalContent, mapping: finalMapping };
+}
+
+// 辅助函数1：去除注释，并确保 mapping 数组严格对应每个输出字符（包括换行符）
+export function removeComments(original: string): { content: string; mapping: number[] } {
+    const astrLines: string[] = original.split('\n');
+    let strContent: string = "";
+    const arrMapping: number[] = [];
+    let nCurrentPos: number = 0;
+
+    for (let i = 0; i < astrLines.length; i++) {
+        const strLine = astrLines[i];
+        const nCommentIndex: number = strLine.indexOf('//');
+        const strCleanLine: string = nCommentIndex !== -1 ? strLine.slice(0, nCommentIndex) : strLine;
+        
+        // 添加清理后的行内容，并记录映射
+        strContent += strCleanLine;
+        for (let nI: number = 0; nI < strCleanLine.length; nI++) {
+            arrMapping.push(nCurrentPos + nI);
         }
-        currentPos++;
+
+        // 只有在不是最后一行时添加换行符
+        if (i < astrLines.length - 1) {
+            strContent += "\n";
+            arrMapping.push(nCurrentPos + strLine.length);
+            nCurrentPos += strLine.length + 1; // +1 表示换行符
         } else {
-        normalized += char;
-        mapping.push(currentPos);
-        currentPos++;
-        lastCharIsWhitespace = false;
+            nCurrentPos += strLine.length; // 最后一行没有换行符
         }
     }
+    return { content: strContent, mapping: arrMapping };
+}
 
-    return { content: normalized, mapping };
+// 辅助函数2：去除符号前后的空格
+export function removeSymbolSpaces(strContentIn: string): { content: string; mapping: number[] } {
+    // 更新正则表达式，匹配常见符号
+    const regSymbols: RegExp = /[+\-/*()\[\]{};=,'"`!&|]/;
+    let strNewContent: string = "";
+    const arrMapping: number[] = [];
+    const nLen: number = strContentIn.length;
+    
+    for (let nI: number = 0; nI < nLen; nI++) {
+        const strCurrentChar: string = strContentIn[nI];
+        
+        // 使用正则表达式匹配所有空白字符（空格、制表符、换行符等）
+        if (/\s/.test(strCurrentChar) && strCurrentChar !== '\n') {
+            // 查找向左第一个非空白字符
+            let nPrev: number = nI - 1;
+            while (nPrev >= 0 && /\s/.test(strContentIn[nPrev])) {
+                nPrev--;
+            }
+            // 查找向右第一个非空白字符
+            let nNext: number = nI + 1;
+            while (nNext < nLen && /\s/.test(strContentIn[nNext])) {
+                nNext++;
+            }
+            
+            let bSkipSpace: boolean = false;
+            // 如果前一个字符是符号，跳过当前空白字符
+            if (nPrev >= 0 && regSymbols.test(strContentIn[nPrev])) {
+                bSkipSpace = true;
+            }
+            // 如果后一个字符是符号，跳过当前空白字符
+            if (nNext < nLen && regSymbols.test(strContentIn[nNext])) {
+                bSkipSpace = true;
+            }
+            
+            if (bSkipSpace) {
+                continue; // 跳过符号附近的空白字符
+            }
+        }
+        
+        // 保留非空白字符或未跳过的空白字符
+        strNewContent += strCurrentChar;
+        arrMapping.push(nI);
+    }
+    
+    return { content: strNewContent, mapping: arrMapping };
+}
+
+// 辅助函数3：将换行符改为空格，并合并连续的空格
+export function normalizeWhitespace(content: string): { content: string; mapping: number[] } {
+    let newContent = '';
+    const mapping: number[] = [];
+    let inNonNewlineWhitespace = false; // 跟踪连续的非换行空白字符
+    let inNewlineSequence = false;      // 跟踪连续的换行符
+
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+
+        if (char === '\n') {
+            if (!inNewlineSequence) {
+                // 第一个换行符，保留
+                newContent += '\n';
+                mapping.push(i);
+                inNewlineSequence = true;
+            }
+            // 重置非换行空白字符状态
+            inNonNewlineWhitespace = false;
+        } else if (/\s/.test(char)) { // 非换行空白字符（如空格、制表符）
+            if (!inNonNewlineWhitespace) {
+                // 第一个非换行空白字符，转换为单个空格
+                newContent += ' ';
+                mapping.push(i);
+                inNonNewlineWhitespace = true;
+            }
+            // 重置换行符状态
+            inNewlineSequence = false;
+        } else {
+            // 非空白字符，直接添加
+            newContent += char;
+            mapping.push(i);
+            inNonNewlineWhitespace = false;
+            inNewlineSequence = false;
+        }
+    }
+    return { content: newContent, mapping };
 }
 
-function normalizePattern(pattern: string): string {
-    return pattern.replace(/\s+/g, ' ').trim();
+export function normalizePattern(pattern: string): string {
+    const { content } = normalizeContent(pattern);
+    return content;
 }
 
 function findCandidatePositions(content: string, pattern: string): number[] {
@@ -95,7 +203,9 @@ function verifyMatches(
     candidates: number[],
     mapping: number[]
 ): MatchPosition[] {
-    const validMatches: MatchPosition[] = [];
+    let bestMatch: MatchPosition | null = null;
+    let minDistance = MAX_EDIT_DISTANCE + 1; // 设为比允许的最大距离大1
+
     const patternLen = pattern.length;
 
     candidates.forEach(start => {
@@ -106,21 +216,26 @@ function verifyMatches(
 
         const substring = content.substring(start, end);
         const distance = calculateEditDistance(substring, pattern, MAX_EDIT_DISTANCE);
-        
-        if (distance <= MAX_EDIT_DISTANCE) {
-            validMatches.push({
+
+        if (distance < minDistance) {
+            minDistance = distance;
+            bestMatch = {
                 start: mapping[start],
                 end: mapping[end] || mapping[mapping.length - 1]
-            });
+            };
         }
     });
 
-    return processOverlaps(validMatches);
+    return bestMatch ? [bestMatch] : [];
 }
-
 // ================ 工具函数 ================
 function splitPattern(pattern: string, count: number): string[] {
     const segments: string[] = [];
+
+    if (pattern.length / count < 3) {
+        count = pattern.length / 3;
+    }
+
     const baseLength = Math.floor(pattern.length / count);
     let remaining = pattern.length % count;
     let pos = 0;

src/test/fuzzyMatch.test.ts

@@ -1,6 +1,7 @@
 import * as assert from 'assert';
 import * as vscode from 'vscode';
 import { applyGlobalReplace, normalizeInput } from '../cvbManager';
+import { normalizeContent, removeComments, normalizeWhitespace, normalizePattern, removeSymbolSpaces} from '../fuzzyMatch';
 
 // 定义 GlobalReplaceOperation 接口
 
@@ -34,7 +35,7 @@ function normalizeData(operation: GlobalReplaceOperation): GlobalReplaceOperatio
     operation.m_strNewContent = normalizeInput(operation.m_strNewContent);
     return operation;
 }
-  
+
 suite('Extension Test Suite', () => {
     vscode.window.showInformationMessage('Start all tests.');
 
@@ -261,4 +262,153 @@ function empty() {}
             applyGlobalReplace(content, normalizeData(op));
         }, /GLOBAL-REPLACE 失败：FILE:"test.js" OLD_CONTENT 是空的/);
     });
-});
+});
+  
+suite('Normalization Full Coverage Test Suite', () => 
+{
+    // 1. 测试 removeComments：多行混合注释的情况
+    test('removeComments - 多行代码包含注释', () => 
+    {
+        const strInput: string = `function test() { // 这是一个函数
+    let nValue = 10; // 这里初始化变量
+    // 这是一整行注释
+    return nValue; // 返回变量
+} // 结束函数
+`;
+
+        const stResult = removeComments(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string =
+            "function test() { \n" +
+            "    let nValue = 10; \n" +
+            "    \n" +
+            "    return nValue; \n" +
+            "} \n";
+
+        assert.strictEqual(strContent, strExpectedContent, "removeComments 多行内容不正确");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "removeComments 多行 mapping 长度不正确");
+    });
+
+    // 2. 测试 removeSymbolSpaces：符号前后空格
+    test('removeSymbolSpaces - 符号前后带空格', () => 
+    {
+        const strInput: string = `a +  b
+( x - y )
+{ c *  d }`;
+        const stResult = removeSymbolSpaces(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string =
+            "a+b\n" +
+            "(x-y)\n" +
+            "{c*d}";
+
+        assert.strictEqual(strContent, strExpectedContent, "removeSymbolSpaces 符号空格去除不正确");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "removeSymbolSpaces mapping 长度不正确");
+    });
+
+    // 3. 测试 normalizeWhitespace：空白字符处理
+    test('normalizeWhitespace - 处理换行符、tab 和连续空格', () => 
+    {
+        const strInput: string = `abc   def
+ghi\t\tjkl
+mno    pqr`;
+        const stResult = normalizeWhitespace(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string = "abc def\nghi jkl\nmno pqr";
+
+        assert.strictEqual(strContent, strExpectedContent, "normalizeWhitespace 处理空白字符错误");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "normalizeWhitespace mapping 长度错误");
+    });
+
+    // 4. 测试 removeComments 对全是注释的代码
+    test('removeComments - 代码全是注释', () => 
+    {
+        const strInput: string = `// 这是注释
+// 这也是注释
+// 还有注释
+`;
+
+        const stResult = removeComments(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string = "\n\n\n";
+
+        assert.strictEqual(strContent, strExpectedContent, "removeComments 全注释去除不正确");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "removeComments 全注释 mapping 错误");
+    });
+
+    // 5. 测试 normalizeWhitespace 处理连续换行
+    test('normalizeWhitespace - 处理连续换行', () => 
+    {
+        const strInput: string = `abc
+
+
+def`;
+        const stResult = normalizeWhitespace(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string = "abc\ndef";
+
+        assert.strictEqual(strContent, strExpectedContent, "normalizeWhitespace 处理连续换行错误");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "normalizeWhitespace mapping 长度错误");
+    });
+
+    // 6. 测试 removeSymbolSpaces 处理特殊符号混合情况
+    test('removeSymbolSpaces - 复杂符号空格情况', () => 
+    {
+        const strInput: string = `a  + ( b *  c ) / [ d -  e ]`;
+        const stResult = removeSymbolSpaces(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string = "a+(b*c)/[d-e]";
+
+        assert.strictEqual(strContent, strExpectedContent, "removeSymbolSpaces 复杂符号空格处理错误");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "removeSymbolSpaces mapping 长度错误");
+    });
+
+    // 7. 测试 normalizeWhitespace 处理只有空格和换行符的输入
+    test('normalizeWhitespace - 只有空格和换行符', () => 
+    {
+        const strInput: string = "   \n   \n   ";
+        const stResult = normalizeWhitespace(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string = "\n";
+
+        assert.strictEqual(strContent, strExpectedContent, "normalizeWhitespace 纯空格处理错误");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "normalizeWhitespace mapping 长度错误");
+    });
+
+    // 8. 综合测试 normalizeContent
+    test('normalizeContent - 复杂综合测试', () => 
+    {
+        const strInput: string = `function test() { // 这是注释
+    let a  =  5 + 6 ;  // 多个空格
+    let b = a *  2;  // 还有注释
+    return  b;
+}`; 
+        const stResult = normalizeContent(strInput);
+        const strContent: string = stResult.content;
+        const arrMapping: number[] = stResult.mapping;
+
+        const strExpectedContent: string = 
+            "function test(){\n" +
+            "let a=5+6;\n" +
+            "let b=a*2;\n" +
+            "return b;\n" +
+            "}";
+
+        assert.strictEqual(strContent, strExpectedContent, "normalizeContent 复杂测试错误");
+        assert.strictEqual(arrMapping.length, strExpectedContent.length, "normalizeContent mapping 长度错误");
+    });
+});