scancscode 1.0.33 → 1.0.35

package/docs/CSharpStringExtractor/344/273/243/347/240/201/347/224/237/346/210/220/346/217/220/347/244/272/350/257/215.txt

@@ -1,73 +1,73 @@
-对文件进行TypeScript代码重构，重点优化字符串匹配方法设计，将原有的整句C#语句捕获逻辑精确调整为仅捕获字符串值表达式部分，通过90%的测试用例。开发过程中必须严格遵循以下规范：采用原生TypeScript开发方式，严禁使用反编译JavaScript的方法；禁止使用`git show`等需要用户手动确认的操作；所有中间生成的临时文件仅在最终结束时，以清单形式提示用户需要清理的文件列表，不得自动执行清理操作。不要使用 `<`、 `&`、`>` 等html代码中才有的符号，严格使用 typescript 语言语法, 不使用 `arguments` 等保留字段作为局部变量名。
-其中CodeSnippet类成员定义如下:
-
-```typescript
-export class CodeSnippet {
-    /**
-     * 要替换的原始内容在代码全文中的起始位置，从0开始
-     */
-    originalIndex: number;
-    /**
-     * 从originalIndex开始长度至少30个字符的原始代码文本,如果从originalIndex开始后续全文中包含`;`符号,那么originalContext必须包含一个`;`号
-     */
-    originalContext: string;
-    /**
-     * 标记是否改变了原始代码内容，如果需要替换文件内容则为true，否则为false; 具体定义为: isChanged = originalCode!=convertedCode
-     */
-    isChanged: boolean;
-    /**
-     * 要替换的C#语句整句原始内容
-     */
-    originalCode: string;
-    /**
-     * originalCode转换后的代码
-     */
-    convertedCode: string;
-    /**
-     * 匹配出的所有字符串列表, 包括转换出来的字符串模板，同一个位置匹配出的字符串会合并到一个元素中
-     */
-    literals: string[];
-    /**
-     * 无法识别的疑似字符串列表
-     */
-    unexpects: string[];
-}
-```
-
-
-代码实现需满足以下具体技术要求：
-1. 重构originalCode的解析逻辑，实现精确的字符串操作表达式定位与提取，严格排除非字符串表达式的代码部分
-2. 基于调整后的originalCode提取逻辑，同步更新convertedCode的转换逻辑和originalIndex的位置映射关系，确保代码转换的准确性和位置对应关系
-3. 完整实现CSharpStringExtractor类，该类必须包含名为`extractStrings`的公共成员方法。此方法接收C#代码字符串作为输入参数，提取其中的字符串文本转换信息，并以CodeSnippet[]数组形式返回处理结果
-
-CodeSnippet数据结构必须严格符合以下规范：
-- CodeSnippet.originalCode：存储从C#代码中提取的完整字符串值表达式文本，确保不包含多余的代码内容
-- CodeSnippet.convertedCode：存储按照"规则A"转换后的字符串值表达式文本，保持语法正确性
-- CodeSnippet.literals：存储从字符串值表达式中提取的所有字符串文本组成的字符串数组，确保包含所有嵌套和连接的字符串片段，包括转义字符和特殊符号
-
-"规则A"转换逻辑的详细实现规范：
-1. 对于赋值表达式中形如`xxx.text = 字符串值表达式`的模式：
-   - 非内插字符串（不以$@或$开头）：在原始字符串值表达式末尾添加`.TR()`方法调用，保持原有字符串内容不变
-   - 内插字符串（以$@或$开头）：将整个字符串表达式转换为`Tr.Format(...)`格式，保持原有占位符结构和表达式逻辑
-2. 对于使用`+`运算符连接的字符串表达式：
-   - 对每个独立的字符串子表达式应用与规则1相同的转换处理，保持原有的连接结构和运算顺序
-3. 其他所有不符合上述模式的情况：
-   - CodeSnippet.convertedCode字段保持原始字符串值表达式不变
-   - CodeSnippet.literals字段仍需准确提取所有字符串文本内容，包括转义字符和特殊符号
-4. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
-5. 需要捕获类对象成员初始化赋值表达式中, 出现在赋值操作符`=`右侧的字符串值表达式
-6. 需要能捕获 switch 语句中包含普通字符串的情况
-7. 需要正确识别字符串包含各种特殊符号和转译符号组合的情况, 能正确识别这种情况下的字符串边界
-8. 函数参数需要拆分, 逐个参数捕获
-9. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
-
-
-
-实现过程中必须特别注意以下技术要点：
-- 实现精确的字符串边界识别算法，正确处理单引号和双引号字符串的开始与结束位置
-- 设计转义字符处理机制，妥善处理字符串中的转义字符（如\"、\'、\\等），避免错误识别字符串边界
-- 开发代码结构分析逻辑，正确区分字符串内的代码内容与字符串外的代码结构
-- 确保提取的字符串文本的准确性和完整性，包括多行字符串、复杂嵌套结构和特殊编码字符
-- 全面处理各种边缘情况，如空字符串、仅包含空格的字符串、包含特殊字符的字符串、零长度字符串等
-
+对文件进行TypeScript代码重构，重点优化字符串匹配方法设计，将原有的整句C#语句捕获逻辑精确调整为仅捕获字符串值表达式部分，通过90%的测试用例。开发过程中必须严格遵循以下规范：采用原生TypeScript开发方式，严禁使用反编译JavaScript的方法；禁止使用`git show`等需要用户手动确认的操作；所有中间生成的临时文件仅在最终结束时，以清单形式提示用户需要清理的文件列表，不得自动执行清理操作。不要使用 `<`、 `&`、`>` 等html代码中才有的符号，严格使用 typescript 语言语法, 不使用 `arguments` 等保留字段作为局部变量名。
+其中CodeSnippet类成员定义如下:
+
+```typescript
+export class CodeSnippet {
+    /**
+     * 要替换的原始内容在代码全文中的起始位置，从0开始
+     */
+    originalIndex: number;
+    /**
+     * 从originalIndex开始长度至少30个字符的原始代码文本,如果从originalIndex开始后续全文中包含`;`符号,那么originalContext必须包含一个`;`号
+     */
+    originalContext: string;
+    /**
+     * 标记是否改变了原始代码内容，如果需要替换文件内容则为true，否则为false; 具体定义为: isChanged = originalCode!=convertedCode
+     */
+    isChanged: boolean;
+    /**
+     * 要替换的C#语句整句原始内容
+     */
+    originalCode: string;
+    /**
+     * originalCode转换后的代码
+     */
+    convertedCode: string;
+    /**
+     * 匹配出的所有字符串列表, 包括转换出来的字符串模板，同一个位置匹配出的字符串会合并到一个元素中
+     */
+    literals: string[];
+    /**
+     * 无法识别的疑似字符串列表
+     */
+    unexpects: string[];
+}
+```
+
+
+代码实现需满足以下具体技术要求：
+1. 重构originalCode的解析逻辑，实现精确的字符串操作表达式定位与提取，严格排除非字符串表达式的代码部分
+2. 基于调整后的originalCode提取逻辑，同步更新convertedCode的转换逻辑和originalIndex的位置映射关系，确保代码转换的准确性和位置对应关系
+3. 完整实现CSharpStringExtractor类，该类必须包含名为`extractStrings`的公共成员方法。此方法接收C#代码字符串作为输入参数，提取其中的字符串文本转换信息，并以CodeSnippet[]数组形式返回处理结果
+
+CodeSnippet数据结构必须严格符合以下规范：
+- CodeSnippet.originalCode：存储从C#代码中提取的完整字符串值表达式文本，确保不包含多余的代码内容
+- CodeSnippet.convertedCode：存储按照"规则A"转换后的字符串值表达式文本，保持语法正确性
+- CodeSnippet.literals：存储从字符串值表达式中提取的所有字符串文本组成的字符串数组，确保包含所有嵌套和连接的字符串片段，包括转义字符和特殊符号
+
+"规则A"转换逻辑的详细实现规范：
+1. 对于赋值表达式中形如`xxx.text = 字符串值表达式`的模式：
+   - 非内插字符串（不以$@或$开头）：在原始字符串值表达式末尾添加`.TR()`方法调用，保持原有字符串内容不变
+   - 内插字符串（以$@或$开头）：将整个字符串表达式转换为`Tr.Format(...)`格式，保持原有占位符结构和表达式逻辑
+2. 对于使用`+`运算符连接的字符串表达式：
+   - 对每个独立的字符串子表达式应用与规则1相同的转换处理，保持原有的连接结构和运算顺序
+3. 其他所有不符合上述模式的情况：
+   - CodeSnippet.convertedCode字段保持原始字符串值表达式不变
+   - CodeSnippet.literals字段仍需准确提取所有字符串文本内容，包括转义字符和特殊符号
+4. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
+5. 需要捕获类对象成员初始化赋值表达式中, 出现在赋值操作符`=`右侧的字符串值表达式
+6. 需要能捕获 switch 语句中包含普通字符串的情况
+7. 需要正确识别字符串包含各种特殊符号和转译符号组合的情况, 能正确识别这种情况下的字符串边界
+8. 函数参数需要拆分, 逐个参数捕获
+9. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
+
+
+
+实现过程中必须特别注意以下技术要点：
+- 实现精确的字符串边界识别算法，正确处理单引号和双引号字符串的开始与结束位置
+- 设计转义字符处理机制，妥善处理字符串中的转义字符（如\"、\'、\\等），避免错误识别字符串边界
+- 开发代码结构分析逻辑，正确区分字符串内的代码内容与字符串外的代码结构
+- 确保提取的字符串文本的准确性和完整性，包括多行字符串、复杂嵌套结构和特殊编码字符
+- 全面处理各种边缘情况，如空字符串、仅包含空格的字符串、包含特殊字符的字符串、零长度字符串等
+
 完成实现后，需进行全面测试验证：确保代码通过90%以上的测试用例，对未通过的测试用例进行针对性分析和优化，提供详细的测试报告和优化方案。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scancscode",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "description": "",
   "main": "./dist/index.js",
   "bin": {

package/src/CSharpStringExtractor.ts

@@ -443,12 +443,14 @@ export class CSharpStringExtractor {
             let stringStartPos = -1;
             let inComment = false;
             let commentType = '';
+            let inAnonymousFunction = false;
+            let anonymousFunctionBraceDepth = 0;
 
             for (j = braceOpenIndex + 1; j < code.length; j++) {
                 const char = code[j];
                 const nextChar = j + 1 < code.length ? code[j + 1] : '';
 
-                if (braceDepth > 1 || parenthesesDepth > 0) {
+                if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
                     afterEqual = false;
                 }
                 
@@ -459,6 +461,13 @@ export class CSharpStringExtractor {
                     parenthesesDepth--;
                 }
 
+                if (!inString && !inComment && char === '=' && nextChar === '>') {
+                    inAnonymousFunction = true;
+                    anonymousFunctionBraceDepth = braceDepth;
+                    j++;
+                    continue;
+                }
+
                 if (!inString && !inComment && char === '/' && nextChar === '/') {
                     inComment = true;
                     commentType = '//';
@@ -498,7 +507,7 @@ export class CSharpStringExtractor {
                         inString = false;
                         stringDelimiter = '';
                         
-                        if (afterEqual && braceDepth === 1) {
+                        if (afterEqual || inAnonymousFunction) {
                             const stringLiteral = code.substring(stringStartPos, j + 1);
                             
                             let alreadyExists = false;
@@ -526,7 +535,7 @@ export class CSharpStringExtractor {
                     continue;
                 }
 
-                if (!inString && afterEqual && braceDepth === 1 && j + 1 < code.length && char === '$') {
+                if (!inString && (afterEqual || inAnonymousFunction) && j + 1 < code.length && char === '$') {
                     if (code[j + 1] === '"') {
                         inString = true;
                         stringDelimiter = '"';
@@ -540,14 +549,14 @@ export class CSharpStringExtractor {
                         j += 2;
                         continue;
                     }
-                } else if (!inString && afterEqual && braceDepth === 1 && j + 1 < code.length && char === '@' && code[j + 1] === '$' && j + 2 < code.length && code[j + 2] === '"') {
+                } else if (!inString && (afterEqual || inAnonymousFunction) && j + 1 < code.length && char === '@' && code[j + 1] === '$' && j + 2 < code.length && code[j + 2] === '"') {
                     inString = true;
                     stringDelimiter = '"';
                     stringStartPos = j;
                     j += 2;
                     continue;
                 } else if (!inString && (char === '"' || char === "'")) {
-                    if (afterEqual && braceDepth === 1) {
+                    if (afterEqual || inAnonymousFunction) {
                         inString = true;
                         stringDelimiter = char;
                         stringStartPos = j;
@@ -557,7 +566,7 @@ export class CSharpStringExtractor {
 
                 if (char === '{') {
                     braceDepth++;
-                    if (braceDepth > 1) {
+                    if (!inAnonymousFunction && braceDepth > 1) {
                         afterEqual = false;
                     }
                     continue;
@@ -568,7 +577,10 @@ export class CSharpStringExtractor {
                     if (braceDepth === 0) {
                         break;
                     }
-                    if (braceDepth > 1 || parenthesesDepth > 0) {
+                    if (inAnonymousFunction && braceDepth === anonymousFunctionBraceDepth) {
+                        inAnonymousFunction = false;
+                    }
+                    if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
                         afterEqual = false;
                     }
                     continue;
@@ -581,6 +593,7 @@ export class CSharpStringExtractor {
 
                 if (char === ',' && braceDepth === 1) {
                     afterEqual = false;
+                    inAnonymousFunction = false;
                     continue;
                 }
             }
@@ -1088,12 +1101,14 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
         let stringStartPos = -1;
         let inComment = false;
         let commentType = '';
+        let inAnonymousFunction = false;
+        let anonymousFunctionBraceDepth = 0;
 
         for (let i = braceOpenIndex + 1; i < fullCode.length; i++) {
             const char = fullCode[i];
             const nextChar = i + 1 < fullCode.length ? fullCode[i + 1] : '';
 
-            if (braceDepth > 1 || parenthesesDepth > 0) {
+            if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
                 afterEqual = false;
             }
                 
@@ -1104,6 +1119,13 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
                 parenthesesDepth--;
             }
 
+            if (!inString && !inComment && char === '=' && nextChar === '>') {
+                inAnonymousFunction = true;
+                anonymousFunctionBraceDepth = braceDepth;
+                i++;
+                continue;
+            }
+
             if (!inString && !inComment && char === '/' && nextChar === '/') {
                 inComment = true;
                 commentType = '//';
@@ -1143,25 +1165,35 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
                     inString = false;
                     stringDelimiter = '';
                     
-                    if (afterEqual && braceDepth === 1) {
+                    if (afterEqual || inAnonymousFunction) {
                         const stringLiteral = fullCode.substring(stringStartPos, i + 1);
                         
-                        const snippet = new CodeSnippet();
-                        snippet.originalIndex = stringStartPos;
-                        snippet.originalCode = stringLiteral;
-                        snippet.originalContext = stringLiteral;
+                        let alreadyExists = false;
+                        for (const snippet of snippets) {
+                            if (snippet.originalIndex === stringStartPos) {
+                                alreadyExists = true;
+                                break;
+                            }
+                        }
+                        
+                        if (!alreadyExists) {
+                            const snippet = new CodeSnippet();
+                            snippet.originalIndex = stringStartPos;
+                            snippet.originalCode = stringLiteral;
+                            snippet.originalContext = stringLiteral;
 
-                        this.variableIndex = 0;
+                            this.variableIndex = 0;
 
-                        this.processSingleArgument(snippet, stringLiteral, trClass, trFormatMethod, trMethod);
+                            this.processSingleArgument(snippet, stringLiteral, trClass, trFormatMethod, trMethod);
 
-                        snippets.push(snippet);
+                            snippets.push(snippet);
+                        }
                     }
                 }
                 continue;
             }
 
-            if (!inString && afterEqual && braceDepth === 1 && i + 1 < fullCode.length && char === '$') {
+            if (!inString && (afterEqual || inAnonymousFunction) && i + 1 < fullCode.length && char === '$') {
                 if (fullCode[i + 1] === '"') {
                     inString = true;
                     stringDelimiter = '"';
@@ -1175,14 +1207,14 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
                     i += 2;
                     continue;
                 }
-            } else if (!inString && afterEqual && braceDepth === 1 && i + 1 < fullCode.length && char === '@' && fullCode[i + 1] === '$' && i + 2 < fullCode.length && fullCode[i + 2] === '"') {
+            } else if (!inString && (afterEqual || inAnonymousFunction) && i + 1 < fullCode.length && char === '@' && fullCode[i + 1] === '$' && i + 2 < fullCode.length && fullCode[i + 2] === '"') {
                 inString = true;
                 stringDelimiter = '"';
                 stringStartPos = i;
                 i += 2;
                 continue;
             } else if (!inString && (char === '"' || char === "'")) {
-                if (afterEqual && braceDepth === 1) {
+                if (afterEqual || inAnonymousFunction) {
                     inString = true;
                     stringDelimiter = char;
                     stringStartPos = i;
@@ -1192,6 +1224,9 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
 
             if (char === '{') {
                 braceDepth++;
+                if (!inAnonymousFunction && braceDepth > 1) {
+                    afterEqual = false;
+                }
                 continue;
             }
 
@@ -1200,7 +1235,10 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
                 if (braceDepth === 0) {
                     break;
                 }
-                if (braceDepth > 1 || parenthesesDepth > 0) {
+                if (inAnonymousFunction && braceDepth === anonymousFunctionBraceDepth) {
+                    inAnonymousFunction = false;
+                }
+                if (!inAnonymousFunction && (braceDepth > 1 || parenthesesDepth > 0)) {
                     afterEqual = false;
                 }
                 continue;
@@ -1213,6 +1251,7 @@ private extractCommentStrings(code: string, snippets: CodeSnippet[], trClass: st
 
             if (char === ',' && braceDepth === 1) {
                 afterEqual = false;
+                inAnonymousFunction = false;
                 continue;
             }
         }

package/src/LiteralCollector.ts

@@ -15,8 +15,8 @@ export class LiteralCollector {
 
         let files = glob.sync("**/*.cs", { cwd: folder });
         let testFullPath = "@";
-        // let testFullPath = "E:/DATA/Projects/ZhiYou/ProjectFClient/GameClient/Assets/Bundles/GameConfigs/Main/UnitAttributeTable-UnitAttributeTable.cs";
-        
+        // let testFullPath = "E:/DATA/Projects/ZhiYou/ProjectFClient/GameClient/Assets/Bundles/FGUI/Basics/Comp/InfoToastComp.cs";
+
         // 限制并行处理的文件数量，避免内存占用过高
         const batchSize = 10;
         for (let i = 0; i < files.length; i += batchSize) {
@@ -32,8 +32,7 @@ export class LiteralCollector {
                 try {
                     const content = await fs.promises.readFile(fullPath, "utf-8");
                     const snippets = CSCodeScanner.scanFile(fullPath, content, trmethod);
-                    CSCodeScanner.filterSnippets(snippets);
-                    
+
                     if (snippets.length > 0) {
                         if (!scanonly) {
                             let convertedContent = CSCodeScanner.replaceInFile(content, snippets);
@@ -42,9 +41,11 @@ export class LiteralCollector {
                             }
                         }
 
+                        let filteredSnippets = [...snippets];
+                        CSCodeScanner.filterSnippets(filteredSnippets);
                         const fileLiterals: string[] = [];
                         const fileUnexpects: string[] = [];
-                        for (const snippet of snippets) {
+                        for (const snippet of filteredSnippets) {
                             fileLiterals.push(...snippet.literals);
                             fileUnexpects.push(...snippet.unexpects);
                         }
@@ -106,7 +107,7 @@ export class LiteralCollector {
 
         let literals: string[] = [];
         let unexpects: string[] = [];
-        
+
         // 并行处理代码文件夹
         const codeFolderPromises = cscodeFolders.map(async (cscodeFolder) => {
             const folderLiterals: string[] = [];
@@ -114,19 +115,19 @@ export class LiteralCollector {
             await this.scanCodeInFolder(cscodeFolder, folderLiterals, folderUnexpects, trmethod, scanonly, verbose);
             return { literals: folderLiterals, unexpects: folderUnexpects };
         });
-        
+
         const codeFolderResults = await Promise.all(codeFolderPromises);
         for (const result of codeFolderResults) {
             literals.push(...result.literals);
             unexpects.push(...result.unexpects);
         }
-        
+
         // 并行处理表格文件夹
         const tableFolderPromises = gameConfigFolders.map(async (gameConfigFolder) => {
             await this.scanTablesInFolder(gameConfigFolder, literals, verbose);
         });
         await Promise.all(tableFolderPromises);
-        
+
         // 去重和过滤
         this.filterLiterals(literals);