test:模糊匹配通过部分单元测试

Author: yefansky

src/fuzzyMatch.ts

@@ -189,106 +189,126 @@ export function normalizePattern(pattern: string): string {
     return content;
 }
 
-function findCandidatePositions(content: string, pattern: string): number[] {
+export function findCandidatePositions(content: string, pattern: string): number[] {
     const candidates = new Set<number>();
-    const segments = splitPattern(pattern, SEGMENT_COUNT);
-
-    // 查找每个分片的匹配位置
-    segments.forEach(segment => {
-            let pos = -1;
-            while ((pos = content.indexOf(segment, pos + 1)) !== -1) {
-            if (pos === -1) {
-                break;
-            }
-            // 向前后扩展可能的匹配范围
-            const start = Math.max(0, pos - pattern.length);
-            const end = Math.min(content.length, pos + pattern.length * 2);
-            for (let i = start; i < end; i++) {
+    const segments = splitPatternWithStart(pattern, SEGMENT_COUNT);
+    segments.forEach(({ segment, start }) => {
+        let pos = -1;
+        while ((pos = content.indexOf(segment, pos + 1)) !== -1) {
+            const expectedStart = pos - start;
+            const minStart = Math.max(0, expectedStart - MAX_EDIT_DISTANCE);
+            const maxStart = Math.min(content.length - pattern.length, expectedStart + MAX_EDIT_DISTANCE);
+            for (let i = minStart; i <= maxStart; i++) {
                 candidates.add(i);
             }
         }
     });
-
     return Array.from(candidates).sort((a, b) => a - b);
 }
 
-function verifyMatches(
+export function verifyMatches(
     content: string,
     pattern: string,
     candidates: number[],
     mapping: number[]
 ): MatchPosition[] {
     let bestMatch: MatchPosition | null = null;
-    let minDistance = MAX_EDIT_DISTANCE + 1; // 设为比允许的最大距离大1
-
+    let minDistance = Infinity;
+    let bestCandidate: number = -1;
     const patternLen = pattern.length;
 
     candidates.forEach(start => {
-        const end = start + patternLen;
-        if (end > content.length) {
+        if (start + patternLen > content.length) {
             return;
         }
 
-        const substring = content.substring(start, end);
+        const substring = content.substring(start, start + patternLen + MAX_EDIT_DISTANCE);
         const distance = calculateEditDistance(substring, pattern, MAX_EDIT_DISTANCE);
-
-        if (distance < minDistance) {
+        if (distance <= MAX_EDIT_DISTANCE && distance < minDistance) {
             minDistance = distance;
+            bestCandidate = start;
+            const end = start + patternLen + distance;
             bestMatch = {
                 start: mapping[start],
-                end: mapping[end] || mapping[mapping.length - 1]
+                end: mapping[Math.min(end, content.length - 1)]
             };
         }
     });
+    
+    // 如果找到了最佳候选，则用贪心方式扩展匹配范围
+    if (bestMatch && bestCandidate !== -1)
+    {
+        let candidateIdx: number = bestCandidate;
+        let patternIdx: number = 0;
+        let startIndex: number = -1;
+        // 从最佳候选起点开始，贪心扫描候选区域，遇到匹配的字符则同步推进模式串下标
+        while (candidateIdx < content.length && patternIdx < pattern.length)
+        {
+            if (content.charAt(candidateIdx) === pattern.charAt(patternIdx))
+            {
+                patternIdx++;
+
+                if (startIndex === -1) {
+                    startIndex = candidateIdx;
+                }
+            }
+            candidateIdx++;
+        }
+
+        let tmpMatch : MatchPosition = bestMatch;
+        // nCandidateIdx 作为最终匹配结束位置（注意这里是最后一次匹配后加1的位置）
+        tmpMatch.start = mapping[startIndex];
+        tmpMatch.end = mapping[Math.min(candidateIdx, content.length - 1)];
+        bestMatch = tmpMatch;
+    }
 
     return bestMatch ? [bestMatch] : [];
 }
-// ================ 工具函数 ================
-function splitPattern(pattern: string, count: number): string[] {
-    const segments: string[] = [];
 
-    if (pattern.length / count < 3) {
-        count = pattern.length / 3;
+// ================ 工具函数 ================
+function splitPatternWithStart(pattern: string, count: number): { segment: string, start: number }[] {
+    const segments: { segment: string, start: number }[] = [];
+    const minSegmentLength = 3;
+    if (pattern.length < minSegmentLength * count) {
+        count = Math.max(1, Math.floor(pattern.length / minSegmentLength));
     }
 
     const baseLength = Math.floor(pattern.length / count);
     let remaining = pattern.length % count;
     let pos = 0;
-
     for (let i = 0; i < count; i++) {
         const length = baseLength + (remaining-- > 0 ? 1 : 0);
-        segments.push(pattern.substr(pos, length));
+        segments.push({ segment: pattern.substr(pos, length), start: pos });
         pos += length;
     }
-
-    return segments.filter(s => s.length > 0);
+    return segments.filter(s => s.segment.length > 0);
 }
 
 function calculateEditDistance(a: string, b: string, maxDistance: number): number {
-if (Math.abs(a.length - b.length) > maxDistance) {
-    return Infinity;
-}
+    if (Math.abs(a.length - b.length) > maxDistance) {
+        return Infinity;
+    }
 
-// 使用滚动数组优化
-let prevRow = Array(b.length + 1).fill(0).map((_, i) => i);
-let currentRow = new Array(b.length + 1);
+    // 使用滚动数组优化
+    let prevRow = Array(b.length + 1).fill(0).map((_, i) => i);
+    let currentRow = new Array(b.length + 1);
 
-for (let i = 1; i <= a.length; i++) {
+    for (let i = 1; i <= a.length; i++) {
         currentRow[0] = i;
         let minInRow = i;
 
         for (let j = 1; j <= b.length; j++) {
-        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-        currentRow[j] = Math.min(
-            prevRow[j] + 1,
-            currentRow[j - 1] + 1,
-            prevRow[j - 1] + cost
-        );
-        minInRow = Math.min(minInRow, currentRow[j]);
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            currentRow[j] = Math.min(
+                prevRow[j] + 1,
+                currentRow[j - 1] + 1,
+                prevRow[j - 1] + cost
+            );
+            minInRow = Math.min(minInRow, currentRow[j]);
         }
 
         if (minInRow > maxDistance) {
-        return Infinity;
+            return Infinity;
         }
         [prevRow, currentRow] = [currentRow, prevRow];
     }
@@ -300,20 +320,14 @@ function processOverlaps(matches: MatchPosition[]): MatchPosition[] {
     return matches
         .sort((a, b) => a.start - b.start)
         .filter((match, index, arr) => {
-        return index === 0 || match.start >= arr[index - 1].end;
+            return index === 0 || match.start >= arr[index - 1].end;
         });
 }
 
-function applyReplacements(
-    original: string,
-    matches: MatchPosition[],
-    replacement: string
-): string {
-    let result = original;
-    // 从后往前替换避免影响索引
-    for (let i = matches.length - 1; i >= 0; i--) {
-        const { start, end } = matches[i];
-        result = result.slice(0, start) + replacement + result.slice(end);
+export function applyReplacements(content: string, matches: MatchPosition[], newContent: string): string {
+    let result = content;
+    for (const match of matches.reverse()) {
+        result = result.slice(0, match.start) + newContent + result.slice(match.end);
     }
     return result;
 }

src/test/fuzzyMatch.test.ts

@@ -1,7 +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';
+import * as fuzzyMatch from '../fuzzyMatch';
 
 // 定义 GlobalReplaceOperation 接口
 
@@ -276,7 +276,7 @@ suite('Normalization Full Coverage Test Suite', () =>
 } // 结束函数
 `;
 
-        const stResult = removeComments(strInput);
+        const stResult = fuzzyMatch.removeComments(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -297,7 +297,7 @@ suite('Normalization Full Coverage Test Suite', () =>
         const strInput: string = `a +  b
 ( x - y )
 { c *  d }`;
-        const stResult = removeSymbolSpaces(strInput);
+        const stResult = fuzzyMatch.removeSymbolSpaces(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -316,7 +316,7 @@ suite('Normalization Full Coverage Test Suite', () =>
         const strInput: string = `abc   def
 ghi\t\tjkl
 mno    pqr`;
-        const stResult = normalizeWhitespace(strInput);
+        const stResult = fuzzyMatch.normalizeWhitespace(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -334,7 +334,7 @@ mno    pqr`;
 // 还有注释
 `;
 
-        const stResult = removeComments(strInput);
+        const stResult = fuzzyMatch.removeComments(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -351,7 +351,7 @@ mno    pqr`;
 
 
 def`;
-        const stResult = normalizeWhitespace(strInput);
+        const stResult = fuzzyMatch.normalizeWhitespace(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -365,7 +365,7 @@ def`;
     test('removeSymbolSpaces - 复杂符号空格情况', () => 
     {
         const strInput: string = `a  + ( b *  c ) / [ d -  e ]`;
-        const stResult = removeSymbolSpaces(strInput);
+        const stResult = fuzzyMatch.removeSymbolSpaces(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -379,7 +379,7 @@ def`;
     test('normalizeWhitespace - 只有空格和换行符', () => 
     {
         const strInput: string = "   \n   \n   ";
-        const stResult = normalizeWhitespace(strInput);
+        const stResult = fuzzyMatch.normalizeWhitespace(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -397,7 +397,7 @@ def`;
     let b = a *  2;  // 还有注释
     return  b;
 }`; 
-        const stResult = normalizeContent(strInput);
+        const stResult = fuzzyMatch.normalizeContent(strInput);
         const strContent: string = stResult.content;
         const arrMapping: number[] = stResult.mapping;
 
@@ -412,3 +412,113 @@ def`;
         assert.strictEqual(arrMapping.length, strExpectedContent.length, "normalizeContent mapping 长度错误");
     });
 });
+
+// 测试套件
+suite('Fuzzy Global Replace Test Suite', () => {
+    vscode.window.showInformationMessage('Start all fuzzy global replace tests.');
+
+    const originalContent = `
+function logMessage(message) {
+    console.log(message);
+}
+
+function logError(error) {
+    console.log(error);
+}
+
+function logWarning(warning) {
+    console.log(warning);
+}
+    `.trim();
+    const oldContent = `
+console.log(warn);
+    `.trim();
+    const newContent = `
+console.warn(warning);
+    `.trim();
+    const expectedContent = `
+function logMessage(message) {
+    console.log(message);
+}
+
+function logError(error) {
+    console.log(error);
+}
+
+function logWarning(warning) {
+    console.warn(warning);
+}
+    `.trim();
+
+    test('normalizeContent should correctly normalize content and provide accurate mapping', () => {
+        const { content: normContent, mapping } = fuzzyMatch.normalizeContent(originalContent);
+        const logWarningStart = originalContent.indexOf('console.log(warning);');
+        const logWarningEnd = logWarningStart + 'console.log(warning);'.length;
+        const normLogWarningStart = normContent.indexOf('console.log(warning);');
+
+        assert.ok(normContent.includes('console.log(warning);'), 'Normalized content should contain the target string');
+        assert.strictEqual(
+            mapping[normLogWarningStart],
+            logWarningStart,
+            'Mapping should point to original start position'
+        );
+        assert.strictEqual(
+            mapping[normLogWarningStart + 'console.log(warning);'.length] || mapping[mapping.length - 1],
+            logWarningEnd,
+            'Mapping should point to original end position'
+        );
+    });
+
+    test('normalizePattern should correctly normalize the old content', () => {
+        const normPattern = fuzzyMatch.normalizePattern(oldContent);
+        assert.strictEqual(
+            normPattern.trim(),
+            'console.log(warn);',
+            'Pattern should be normalized correctly'
+        );
+    });
+
+    test('findCandidatePositions should find potential match positions', () => {
+        const { content: normContent } = fuzzyMatch.normalizeContent(originalContent);
+        const normPattern = fuzzyMatch.normalizePattern(oldContent);
+        const candidates = fuzzyMatch.findCandidatePositions(normContent, normPattern);
+
+        assert.ok(candidates.length > 0, 'Should find at least one candidate position');
+        const logWarningPos = normContent.indexOf('console.log(warning);');
+        assert.ok(
+            candidates.some(pos => Math.abs(pos - logWarningPos) < normPattern.length * 2),
+            'Should include a position near the target string'
+        );
+    });
+
+    test('verifyMatches should select the best match with correct positions', () => {
+        const { content: normContent, mapping } = fuzzyMatch.normalizeContent(originalContent);
+        const normPattern = fuzzyMatch.normalizePattern(oldContent);
+        const candidates = fuzzyMatch.findCandidatePositions(normContent, normPattern);
+        const matches = fuzzyMatch.verifyMatches(normContent, normPattern, candidates, mapping);
+
+        assert.strictEqual(matches.length, 1, 'Should find exactly one best match');
+        assert.strictEqual(
+            originalContent.slice(matches[0].start, matches[0].end).trim(),
+            'console.log(warning);',
+            'Best match should correspond to the closest substring'
+        );
+    });
+
+    test('applyReplacements should replace content correctly without extra characters', () => {
+        const matches = [{
+            start: originalContent.indexOf('console.log(warning);'),
+            end: originalContent.indexOf('console.log(warning);') + 'console.log(warning);'.length
+        }];
+        const result = fuzzyMatch.applyReplacements(originalContent, matches, newContent);
+
+        assert.strictEqual(result.trim(), expectedContent, 'Replacement should match expected output');
+        assert.ok(!result.includes('g);'), 'Result should not contain extra characters like "g);"');
+    });
+
+    test('applyFuzzyGlobalReplace should perform the full replacement correctly', () => {
+        const result = fuzzyMatch.applyFuzzyGlobalReplace(originalContent, oldContent, newContent);
+        assert.strictEqual(result.trim(), expectedContent, 'Full fuzzy replace should produce the expected output');
+        assert.ok(!result.includes('g);'), 'Result should not contain extra characters like "g);"');
+    });
+});