scancscode 1.0.37 → 1.0.39

package/dist/src/CSharpStringExtractor.js

@@ -2,11 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CSharpStringExtractor = exports.CodeSnippet = void 0;
 class CodeSnippet {
+    /**
+     * 代码片段在原始源代码中的起始位置索引
+     */
     originalIndex;
+    /**
+     * 原始上下文，与 originalCode 相同，保存原始的代码片段内容
+     */
     originalContext;
+    /**
+     * 从源代码中提取的原始代码片段
+     */
     originalCode;
+    /**
+     * 经过国际化处理后的代码片段，可能添加了 .TR() 调用或转换为 Tr.Format(...) 形式
+     */
     convertedCode;
+    /**
+     * 从代码片段中提取出的字符串字面量数组，已进行去重和标准化处理
+     */
     literals;
+    /**
+     * 意外情况记录数组
+     */
     unexpects;
     literalPositions;
     constructor() {
@@ -18,6 +36,10 @@ class CodeSnippet {
         this.unexpects = [];
         this.literalPositions = new Map();
     }
+    /**
+     * 判断代码片段是否经过修改
+     * @returns 如果 convertedCode 与 originalCode 不同则返回 true，否则返回 false
+     */
     get isChanged() {
         return this.originalCode !== this.convertedCode;
     }
@@ -82,6 +104,9 @@ class CodeSnippet {
 }
 exports.CodeSnippet = CodeSnippet;
 class CSharpStringExtractor {
+    static TEXT_ASSIGNMENT_PATTERN = /\b[\p{L}\p{N}_]+\.text\s*=/u;
+    static TITLE_ASSIGNMENT_PATTERN = /\bm_btn_[\p{L}_][\p{L}\p{N}_]*\.title\s*=/u;
+    static SPECIAL_ASSIGNMENT_PATTERN = /(?:\b[\p{L}\p{N}_]+\.text|\bm_btn_[\p{L}_][\p{L}\p{N}_]*\.title)\s*=/u;
     variableIndex = 0;
     extractStrings(code, snippets = [], trClass = 'Tr', trMethod = 'TR', trFormatMethod = 'Format') {
         const statements = [];
@@ -180,7 +205,7 @@ class CSharpStringExtractor {
         for (const { statement, originalIndex } of statements) {
             const trimmedStatement = statement.trim();
             const isStringFormatCall = trimmedStatement.startsWith('string.Format(');
-            const isTextAssignment = /\w+\.text\s*=/.test(trimmedStatement);
+            const isTextAssignment = this.isSpecialAssignment(trimmedStatement);
             const isRegularAssignment = /^[\s\S]*?=/.test(trimmedStatement);
             const isCaseOrDefault = trimmedStatement.startsWith('case ') || trimmedStatement.startsWith('default:');
             const isFunctionCall = /^\s*[\w\.<>]+[\s\w\.<>]*\(/.test(trimmedStatement) && !isStringFormatCall && !isCaseOrDefault;
@@ -1411,6 +1436,10 @@ class CSharpStringExtractor {
         }
         return statements;
     }
+    isSpecialAssignment(statement) {
+        const trimmedStatement = statement.trim();
+        return CSharpStringExtractor.SPECIAL_ASSIGNMENT_PATTERN.test(trimmedStatement);
+    }
     isStatementToProcess(statement) {
         const blockKeywords = ['if', 'while', 'for', 'foreach', 'do', 'switch', 'try', 'catch', 'finally', 'class', 'struct', 'interface', 'enum', 'namespace', 'using', 'void', 'public', 'private', 'protected', 'internal', 'static', 'readonly', 'const'];
         const trimmedStatement = statement.trim();
@@ -1429,7 +1458,7 @@ class CSharpStringExtractor {
             return false;
         }
         const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(trimmedStatement);
-        const isTextAssignment = /\w+\.text\s*=/.test(trimmedStatement);
+        const isTextAssignment = this.isSpecialAssignment(trimmedStatement);
         const isReturnStatement = trimmedStatement.startsWith('return ');
         return hasStringLiteral || isTextAssignment || (isReturnStatement && hasStringLiteral);
     }
@@ -1739,8 +1768,8 @@ class CSharpStringExtractor {
         return processedStatement;
     }
     processTextAssignments(statement, snippet, trClass, trFormatMethod, trMethod) {
-        const textAssignmentRegex = /([\s\S]*?\.text\s*=\s*)([\s\S]*?)(?=;|$)/;
-        const match = textAssignmentRegex.exec(statement);
+        const specialAssignmentRegex = /([\s\S]*?(?:\.text|\.title)\s*=\s*)([\s\S]*?)(?=;|$)/;
+        const match = specialAssignmentRegex.exec(statement);
         let prefix = null;
         let value;
         if (match) {
@@ -1782,7 +1811,7 @@ class CSharpStringExtractor {
                 if (trimmedPart.includes(`${trClass}.${trFormatMethod}(`) || trimmedPart.includes('Tr.Format(')) {
                     return part;
                 }
-                if (trimmedPart.startsWith('"') || /^\w+/.test(trimmedPart) || trimmedPart.startsWith('(')) {
+                if (trimmedPart.startsWith('"') || trimmedPart.startsWith('$"') || trimmedPart.startsWith('$@"') || trimmedPart.startsWith('@$"') || /^\w+/.test(trimmedPart) || trimmedPart.startsWith('(')) {
                     const whitespaceBefore = part.substring(0, part.search(/\S/));
                     const actualPart = part.substring(part.search(/\S/));
                     const whitespaceAfter = actualPart.search(/\s*$/) === 0 ? actualPart : actualPart.substring(actualPart.search(/\S/) + trimmedPart.length);
@@ -1795,7 +1824,7 @@ class CSharpStringExtractor {
         else {
             const trimmedValue = value.trim();
             if (!trimmedValue.includes(`${trClass}.${trFormatMethod}(`) && !trimmedValue.endsWith(`.${trMethod}()`)) {
-                if (trimmedValue !== 'null' && (trimmedValue.startsWith('"') || /^\w+/.test(trimmedValue) || trimmedValue.startsWith('('))) {
+                if (trimmedValue !== 'null' && (trimmedValue.startsWith('"') || trimmedValue.startsWith('$"') || trimmedValue.startsWith('$@"') || trimmedValue.startsWith('@$"') || /^\w+/.test(trimmedValue) || trimmedValue.startsWith('('))) {
                     const whitespaceBefore = value.substring(0, value.search(/\S/));
                     const actualValue = value.substring(value.search(/\S/));
                     const whitespaceAfter = actualValue.search(/\s*$/) === 0 ? actualValue : actualValue.substring(actualValue.search(/\S/) + trimmedValue.length);
@@ -1820,7 +1849,7 @@ class CSharpStringExtractor {
             return statement;
         }
         const hasStringLiteral = /"(?:[^"\\]|\\.)*"/.test(statement);
-        const isTextAssignment = /\w+\.text\s*=/.test(statement);
+        const isTextAssignment = this.isSpecialAssignment(statement);
         if (isTextAssignment) {
             return statement;
         }
@@ -2137,14 +2166,26 @@ class CSharpStringExtractor {
     }
     extractValueExpression(statement, statementIndex, fullCode) {
         const trimmedStatement = statement.trim();
-        const textAssignmentIndex = trimmedStatement.indexOf('.text =');
-        if (textAssignmentIndex !== -1) {
-            const prefix = trimmedStatement.substring(0, textAssignmentIndex + '.text ='.length);
-            const valuePart = trimmedStatement.substring(textAssignmentIndex + '.text ='.length);
+        let assignmentMatch = null;
+        let assignmentSuffix = '';
+        const textMatch = CSharpStringExtractor.TEXT_ASSIGNMENT_PATTERN.exec(trimmedStatement);
+        const titleMatch = CSharpStringExtractor.TITLE_ASSIGNMENT_PATTERN.exec(trimmedStatement);
+        if (textMatch) {
+            assignmentMatch = textMatch;
+            assignmentSuffix = '.text =';
+        }
+        else if (titleMatch) {
+            assignmentMatch = titleMatch;
+            assignmentSuffix = '.title =';
+        }
+        if (assignmentMatch) {
+            const assignmentIndex = assignmentMatch.index + assignmentMatch[0].indexOf(assignmentSuffix);
+            const prefix = trimmedStatement.substring(0, assignmentIndex + assignmentSuffix.length);
+            const valuePart = trimmedStatement.substring(assignmentIndex + assignmentSuffix.length);
             const value = this.extractValueUntilSemicolon(valuePart);
             const valueExpression = value.trim();
             const valueStartInStatement = statement.indexOf(value);
-            const valueExpressionIndex = statementIndex + (valueStartInStatement !== -1 ? valueStartInStatement : textAssignmentIndex + '.text ='.length);
+            const valueExpressionIndex = statementIndex + (valueStartInStatement !== -1 ? valueStartInStatement : assignmentIndex + assignmentSuffix.length);
             const actualValueStart = fullCode.indexOf(valueExpression, valueExpressionIndex);
             const finalIndex = actualValueStart !== -1 ? actualValueStart : valueExpressionIndex;
             return {
@@ -2156,29 +2197,10 @@ class CSharpStringExtractor {
             const valuePart = trimmedStatement.substring('return '.length);
             const value = this.extractValueUntilSemicolon(valuePart);
             const valueExpression = value.trim();
-            let finalIndex = statementIndex;
-            const returnKeywordInStatement = statement.indexOf('return ');
-            if (returnKeywordInStatement !== -1) {
-                const afterReturnInStatement = returnKeywordInStatement + 'return '.length;
-                let startInStatement = -1;
-                for (let i = afterReturnInStatement; i < statement.length - 1; i++) {
-                    if (statement[i] === '$' && statement[i + 1] === '"') {
-                        startInStatement = i;
-                        break;
-                    }
-                }
-                if (startInStatement === -1) {
-                    for (let i = afterReturnInStatement; i < statement.length; i++) {
-                        if (statement[i] === '"') {
-                            startInStatement = i;
-                            break;
-                        }
-                    }
-                }
-                if (startInStatement !== -1) {
-                    finalIndex = statementIndex + startInStatement;
-                }
-            }
+            const valueStartInStatement = statement.indexOf(value);
+            const valueExpressionIndex = statementIndex + (valueStartInStatement !== -1 ? valueStartInStatement : 'return '.length);
+            const actualValueStart = fullCode.indexOf(valueExpression, valueExpressionIndex);
+            const finalIndex = actualValueStart !== -1 ? actualValueStart : valueExpressionIndex;
             return {
                 valueExpression: valueExpression,
                 valueExpressionIndex: finalIndex
@@ -2442,7 +2464,7 @@ class CSharpStringExtractor {
     }
     processStatementAndExtractValue(snippet, fullStatement, valueExpression, trClass, trFormatMethod, trMethod) {
         let processedValueExpression = valueExpression;
-        const isTextAssignment = /\w+\.text\s*=/.test(fullStatement.trim());
+        const isTextAssignment = this.isSpecialAssignment(fullStatement);
         this.extractTrFormatStrings(processedValueExpression, snippet, trClass, trFormatMethod);
         processedValueExpression = this.processStringTemplates(processedValueExpression, snippet, trClass, trFormatMethod);
         processedValueExpression = this.processStringFormat(processedValueExpression, snippet, trClass, trFormatMethod);

package/dist/src/CmdExecutor.js

@@ -13,12 +13,11 @@ function isNullOrEmpty(arr) {
 class CmdExecutor {
     static testConvert() {
         let cwd = "E:/DATA/Projects/ZhiYou/ProjectFClient/GameClient/";
-        let cscodeFolders = 
-        // [cwd + "Assets/Bundles/FGUI/"]
-        [
-            "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/UI/",
-            "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/Battle/",
-            "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Scripts/",
+        let cscodeFolders = [
+            cwd + "Assets/Bundles/FGUI/",
+            // "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/UI/",
+            // "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Bundles/Battle/",
+            // "E:/DATA/Projects/ZhiYou/DXTSProject/Client/Assets/Scripts/",
         ];
         let gameConfigFolders = [cwd + "Assets/Bundles/GameConfigs/"];
         let outCsvFile = "E:/DATA/Projects/e-gbl-client/client/Assets/Bundles/GameConfigs/Translation/hello.csv";

package/dist/test/CSharpStringExtractor.test.js

@@ -76,6 +76,73 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].literals).toContain('pre');
         expect(snippets[0].literals).toContain('sub');
     });
+    // 形如 `m_btn_xxx.title = yyy;` 的赋值语句要和形如 `xxx.text = yyy;` 的赋值语句完全等同处理, 其中 `xxx`和`yyy` 代表某段C#字面量, 可以是对象、字符串、或其他表达式, `m_btn_` 为引用符号名固定前缀; 为了便于理解, 用正则表达式表示, 也就是相当于需要同时匹配 `/^m_btn_\w+\.title\s*=/` 形式的表达式和 `/\w+\.text\s*=/` 形式的表达式, 而其中对于 `xxx` 和 `yyy` 部分的处理逻辑是完全一致的
+    test('should handle m_btn_xxx.title = yyy', () => {
+        const code = `
+        buy.title = "lkwjelkfj1";
+        m_btn1_buy.title = "lkwjelkfj2";
+        am_btn_buy.title = "lkwjelkfj3";
+        m_btn_buy.title = "lkwjelkfj4";
+        m_btn_wwefHwref.title = $"Hello";
+        m_btn_fxx_wf.title = $"Hello, {name}!";
+`;
+        const snippets = extractor.extractStrings(code);
+        {
+            let snippet = snippets[0];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj1"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj1"');
+            // `buy` 不符合 `m_btn_` 开头的条件, 不需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj1"');
+            expect(snippet.literals).toContain('lkwjelkfj1');
+            expect(snippet.isChanged).toBe(false);
+        }
+        {
+            let snippet = snippets[1];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj2"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj2"');
+            // `m_btn1_buy` 不符合 `m_btn_` 开头的条件, 不需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj2"');
+            expect(snippet.literals).toContain('lkwjelkfj2');
+            expect(snippet.isChanged).toBe(false);
+        }
+        {
+            let snippet = snippets[2];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj3"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj3"');
+            // `am_btn_buy` 不符合 `m_btn_` 开头的条件, 不需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj3"');
+            expect(snippet.literals).toContain('lkwjelkfj3');
+            expect(snippet.isChanged).toBe(false);
+        }
+        {
+            let snippet = snippets[3];
+            expect(snippet.originalIndex).toBe(code.indexOf('"lkwjelkfj4"'));
+            expect(snippet.originalCode).toBe('"lkwjelkfj4"');
+            // `m_btn_buy` 符合 `m_btn_` 开头的条件, 需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('"lkwjelkfj4".TR()');
+            expect(snippet.literals).toContain('lkwjelkfj4');
+            expect(snippet.isChanged).toBe(true);
+        }
+        {
+            let snippet = snippets[4];
+            expect(snippet.originalIndex).toBe(code.indexOf('$"Hello"'));
+            expect(snippet.originalCode).toBe('$"Hello"');
+            // `m_btn_wwefHwref` 符合 `m_btn_` 开头的条件, 需要强制加 `.TR()`
+            expect(snippet.convertedCode).toBe('$"Hello".TR()');
+            expect(snippet.literals).toContain('Hello');
+            expect(snippet.isChanged).toBe(true);
+        }
+        {
+            let snippet = snippets[5];
+            expect(snippet.originalIndex).toBe(code.indexOf('$"Hello, {name}!"'));
+            expect(snippet.originalCode).toBe('$"Hello, {name}!"');
+            // `m_btn_fxx_wf` 符合 `m_btn_` 开头的条件
+            expect(snippet.convertedCode).toBe('Tr.Format("Hello, {0}!", name)');
+            expect(snippet.literals).toContain('Hello, {0}!');
+            expect(snippet.isChanged).toBe(true);
+        }
+        expect(snippets.length).toBe(6);
+    });
     // 测试用 `+` 连接的字符串表达式, 确保用 `+` 符号拼接的字符串表达式被整体处理, 从中提取字符串表达式信息, 而不是分别处理 `+` 两边每个字符串表达式; 并且给 `+` 连接的每个成分追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式
     test('should handle string concatenation', () => {
         const code = 'var label2 = "Hello, " + name + "!";';
@@ -84,7 +151,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].originalCode).toBe('"Hello, " + name + "!"');
         expect(snippets[0].convertedCode).toBe('"Hello, ".TR() + name.TR() + "!".TR()');
     });
-    // 测试 `xxx.text = yyy` 形式的赋值语句, 确保将 `yyy` 中的字符串表达式信息提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#字面量, 可以是对象、字符串、或其他表达式
+    // 测试 `xxx.text = yyy;` 形式的赋值语句, 确保将 `yyy` 中的字符串表达式信息提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#字面量, 可以是对象、字符串、或其他表达式
     test('should handle .text = assignments with function calls', () => {
         const code = 'label.text = Func();';
         const snippets = extractor.extractStrings(code);
@@ -92,7 +159,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].originalCode).toBe('Func()');
         expect(snippets[0].convertedCode).toBe('Func().TR()');
     });
-    // 测试 `xxx.text = xxx + xxx` 形式的赋值语句, 确保将 `xxx.text` 中的 `xxx` 字符串表达式提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
+    // 测试 `xxx.text = xxx + xxx;` 形式的赋值语句, 确保将 `xxx.text` 中的 `xxx` 字符串表达式提取出来, 并追加 `.TR()` 或者转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
     test('should handle .text = assignments with multiple function calls', () => {
         const code = 'label.text = Func() + Func();';
         const snippets = extractor.extractStrings(code);
@@ -100,7 +167,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippets[0].originalCode).toBe('Func() + Func()');
         expect(snippets[0].convertedCode).toBe('Func().TR() + Func().TR()');
     });
-    // 测试 `xxx.text = yyy` 形式的赋值语句, 确保将 `yyy` 中的 `xxx` 内插字符串提取出来, 并转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
+    // 测试 `xxx.text = yyy;` 形式的赋值语句, 确保将 `yyy` 中的 `xxx` 内插字符串提取出来, 并转换为 `Tr.Format(...)` 形式; 其中 `xxx`和`yyy` 代表某段C#表达式, 可以是对象、字符串、或其他表达式
     test('should handle .text = assignments with string templates', () => {
         const code = 'label.text = $"pre{Func()}sub";';
         const snippets = extractor.extractStrings(code);
@@ -176,7 +243,7 @@ describe('CSharpStringExtractor', () => {
         expect(snippet.literals).toEqual(['Hello, {0}!']);
         expect(snippet.isChanged).toBe(true);
     });
-    // 测试处理 `xxx.text = yyy` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式, 需要从 `yyy` 中正确提取字符串表达式信息, 并给普通字符串表达式追加 `.TR()` 或者让内插字符串转换为 `Tr.Format(...)` 形式
+    // 测试处理 `xxx.text = yyy;` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式, 需要从 `yyy` 中正确提取字符串表达式信息, 并给普通字符串表达式追加 `.TR()` 或者让内插字符串转换为 `Tr.Format(...)` 形式
     test('should handle .text = assignments', () => {
         const code = 'label.text = "Test";';
         const snippets = extractor.extractStrings(code);
@@ -273,9 +340,9 @@ describe('CSharpStringExtractor', () => {
         const snippets = extractor.extractStrings(code);
         const snippet = snippets[0];
         expect(snippet.originalCode).toBe('$"[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]"');
-        expect(snippet.convertedCode).toBe('$"[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]"');
+        expect(snippet.convertedCode).toBe('$"[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]".TR()');
         expect(snippet.literals).toEqual(['[color=#FFFFFF]上期奖励：[/color][color=#FFE97E][/color][color=#FFFFFF]暂无获奖[/color]']);
-        expect(snippet.isChanged).toBe(false);
+        expect(snippet.isChanged).toBe(true);
     });
     // 处理C#多行语句
     test('should handle non string assignment 1', () => {
@@ -1756,7 +1823,7 @@ namespace TestNamespace{
         }
     });
     // 正确识别C# 行注释语句边界, 行注释不能影响上下行的字符串提取
-    test('should handle comment boundary 2', () => {
+    test('should handle comment boundary 3', () => {
         const code = `
 // klwjfe
 namespace TestNamespace{
@@ -1950,7 +2017,7 @@ namespace FaBao.UI.Comp
         expect(snippets.length).toBe(1);
     });
     // 正确提取C#方法参数中的字符串表达式信息, 支持1到多个形参有默认值的情形
-    test('should handle string expression in method call parameter 3', () => {
+    test('should handle string expression in method call parameter 4', () => {
         const code = `
 namespace FaBao.UI.Comp
 {
@@ -2173,7 +2240,7 @@ namespace FaBao.UI.MainUI
         }
     });
     // 需要正确识别C#代码中的匿名函数, 匿名函数中的字符串表达式也同样需要提取; 匿名函数通常以 `0到多个修饰词 (可选参数列表) => { ... }` 或者 `0到多个修饰词 (可选参数列表) => 一句表达式` 形式定义实现.
-    test('should handle class member initialization assignment with anonymous function 2', () => {
+    test('should handle class member initialization assignment with anonymous function 3', () => {
         const code = `
                 FUISys.Instance.ShowLayer<MainConfirmDialog>(UISceneType.Main, new MainConfirmDialog.MainConfirmDialogParam()
                 {
@@ -2197,7 +2264,7 @@ namespace FaBao.UI.MainUI
         }
     });
     // 需要正确识别C#代码中的匿名函数, 匿名函数中的字符串表达式也同样需要提取; 匿名函数通常以 `0到多个修饰词 (可选参数列表) => { ... }` 或者 `0到多个修饰词 (可选参数列表) => 一句表达式` 形式定义实现.
-    test('should handle class member initialization assignment with anonymous function 3', () => {
+    test('should handle class member initialization assignment with anonymous function 4', () => {
         const code = `
                 FUISys.Instance.ShowLayer<MainConfirmDialog>(UISceneType.Main, new MainConfirmDialog.MainConfirmDialogParam()
                 {
@@ -2218,7 +2285,7 @@ namespace FaBao.UI.MainUI
         }
     });
     // 需要正确识别C#代码中的匿名函数, 匿名函数中的字符串表达式也同样需要提取; 匿名函数通常以 `0到多个修饰词 (可选参数列表) => { ... }` 或者 `0到多个修饰词 (可选参数列表) => 一句表达式` 形式定义实现.
-    test('should handle class member initialization assignment with anonymous function 4', () => {
+    test('should handle class member initialization assignment with anonymous function 5', () => {
         const code = `
                 FUISys.Instance.ShowLayer<MainConfirmDialog>(UISceneType.Main, new MainConfirmDialog.MainConfirmDialogParam()
                 {
@@ -2238,7 +2305,7 @@ namespace FaBao.UI.MainUI
             expect(targetSnippet.isChanged).toBe(false);
         }
     });
-    // 测试处理 `xxx.text = yyy` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
+    // 测试处理 `xxx.text = yyy;` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
     test('should handle .text = format 1', () => {
         const code = `m_text_iwff.text = info ;`;
         const snippets = extractor.extractStrings(code);
@@ -2251,8 +2318,8 @@ namespace FaBao.UI.MainUI
             expect(targetSnippet.isChanged).toBe(true);
         }
     });
-    // 测试处理 `xxx.text = yyy` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
-    test('should handle .text = format 1', () => {
+    // 测试处理 `xxx.text = yyy;` 形式赋值语句, 以 `.text =` 给 `text` 成员赋值的表达式中, `yyy` 部分必定是字符串表达式; 如果`yyy`中不存在字符串, 则`yyy` 中以 `+` 连接的表达式需要加上 `.TR()`; 如果 `yyy` 是作为值表达式整体(必定返回字符串类型值), 也需要追加 `.TR()`。
+    test('should handle .text = format 2', () => {
         const code = `m_text_info.text = info1.member1 + info2.member2;`;
         const snippets = extractor.extractStrings(code);
         {
@@ -2329,7 +2396,7 @@ namespace FaBao.UI.MainUI
         expect(snippets.length).toBe(2);
     });
     // 支持处理字符串里出现各种特殊符号的情况
-    test('should handle special characters in string 8', () => {
+    test('should handle special characters in string 9', () => {
         const code = `
                 (GetChild($"m_textAnime{GetNextNumber()}") as TurtleTextAnimeComp)?.SetText(word);
 `;
@@ -2347,7 +2414,7 @@ namespace FaBao.UI.MainUI
         expect(snippets.length).toBe(1);
     });
     // 支持处理字符串里出现各种特殊符号的情况
-    test('should handle special characters in string 9', () => {
+    test('should handle special characters in string 10', () => {
         const code = `
                 (GetChild($"m_textAnime{GetNextNumber()}") as TurtleTextAnimeComp)?.SetText(word);
 `;
@@ -2438,4 +2505,60 @@ namespace FaBao.UI.MainUI
         const snippets = extractor.extractStrings(code);
         expect(snippets.length).toBe(0);
     });
+    // 需要正确获取 `originalIndex`, `originalIndex` 的定义为 `originalIndex=code.indexOf(originalCode)`, 其中 `code` 表示原始代码, `originalCode` 表示匹配出的原始代码中的字符串表达式
+    test('should handle calculate originalIndex', () => {
+        const code = `
+namespace FaBao
+{
+    public partial class UserInfoModel
+    {
+        public bool HasJoinedGuild()
+        {
+            return !string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0";
+        }
+
+        public void UpdateBargain(BargainShopData bargainShopData)
+        {
+            MyGuildInfo.IsBargainShopBargain = true;
+        }
+
+    }
+}
+`;
+        const snippets = extractor.extractStrings(code);
+        {
+            let targetSnippet = snippets[0];
+            expect(targetSnippet.originalCode).toBe(`!string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0"`);
+            expect(targetSnippet.originalIndex).toBe(code.indexOf(`!string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0"`));
+            expect(targetSnippet.convertedCode).toBe(`!string.IsNullOrEmpty(MyGuildInfo.GuildId) && MyGuildInfo.GuildId != "0"`);
+            expect(targetSnippet.literals).toEqual([
+                '0'
+            ]);
+            expect(targetSnippet.isChanged).toBe(false);
+        }
+    });
+    // 测试 `xxx.text = yyy;` 和 `m_btn_xxx.title = yyy;` 形式的赋值语句都需要支持中文， 包括字符串表达式中也要支持包含中文的情况
+    test('should handle .text = assignments contains chinese', () => {
+        const code = `
+        为栓饭cxs12.text = 南方eflkj.d文件 + "完善ew";
+        m_btn_为栓饭cxs12.title = bw尅kljekl.完善 + "栏栏nfc";
+`;
+        const snippets = extractor.extractStrings(code);
+        {
+            let snippet = snippets[0];
+            expect(snippet.originalCode).toBe('南方eflkj.d文件 + "完善ew"');
+            expect(snippet.convertedCode).toBe('南方eflkj.d文件.TR() + "完善ew".TR()');
+            expect(snippet.literals).toEqual([
+                '完善ew'
+            ]);
+        }
+        {
+            let snippet = snippets[1];
+            expect(snippet.originalCode).toBe('bw尅kljekl.完善 + "栏栏nfc"');
+            expect(snippet.convertedCode).toBe('bw尅kljekl.完善.TR() + "栏栏nfc".TR()');
+            expect(snippet.literals).toEqual([
+                '栏栏nfc'
+            ]);
+        }
+    });
 });

package/dist/test/TestConvert.test.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const CmdExecutor_1 = require("../src/CmdExecutor");
 describe('TestCmdExecutor', () => {
     test("test convert", async () => {
-        await CmdExecutor_1.CmdExecutor.testConvert();
+        // await CmdExecutor.testConvert();
         expect(true).toBe(true);
     }, 50000);
 });

package/package.json

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