com.xmobitea.changx.mini-localization 1.5.2 → 1.5.3

package/Editor/KeyUsageAnalyzerWindowsEditor.cs

@@ -0,0 +1,884 @@
+namespace XmobiTea.MiniLocalization.Editor
+{
+    using XmobiTea.MiniLocalization;
+    using UnityEditor;
+    using UnityEditor.SceneManagement;
+    using UnityEngine;
+    using UnityEngine.SceneManagement;
+
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Reflection;
+    using System.Text.RegularExpressions;
+
+
+    public class KeyUsageAnalyzerWindowsEditor : EditorWindow
+    {
+        private const string StringLiteralPattern = @"@""(?:""""|[^""])*""|""(?:\\.|[^""\\])*""";
+
+        private static readonly Regex ConstantRegex = new Regex(
+            @"public\s+(?:const|static\s+readonly)\s+string\s+(?<field>[A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?<literal>" + StringLiteralPattern + @")",
+            RegexOptions.Compiled);
+
+        private static readonly Regex ConstantReferenceRegex = new Regex(
+            @"\bLocalizationConstantId\s*\.\s*(?<field>[A-Za-z_][A-Za-z0-9_]*)\b",
+            RegexOptions.Compiled);
+
+        private static readonly Regex LocalizationGetTextRegex = new Regex(
+            @"\b(?:XmobiTea\s*\.\s*MiniLocalization\s*\.\s*)?LocalizationManager\s*\.\s*GetText\s*\(\s*(?<literal>" + StringLiteralPattern + @")",
+            RegexOptions.Compiled);
+
+        private static readonly Regex LocalizationKeyAssignmentRegex = new Regex(
+            @"\b(?<target>[A-Za-z_][A-Za-z0-9_]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_]*)*)\s*\.\s*(?:_key|key)\s*=\s*(?<literal>" + StringLiteralPattern + @")",
+            RegexOptions.Compiled);
+
+        private static readonly Regex AnyStringLiteralRegex = new Regex(
+            @"(?<literal>" + StringLiteralPattern + @")",
+            RegexOptions.Compiled);
+
+        private readonly Dictionary<string, LocalizationConstantInfo> _constantsByKey = new Dictionary<string, LocalizationConstantInfo>();
+        private readonly Dictionary<string, string> _fieldToKey = new Dictionary<string, string>();
+        private readonly Dictionary<string, KeyUsageInfo> _usageByFingerprint = new Dictionary<string, KeyUsageInfo>();
+        private readonly Dictionary<string, List<KeyUsageInfo>> _usagesByKey = new Dictionary<string, List<KeyUsageInfo>>();
+
+        private List<KeyUsageInfo> _missingConstantUsages = new List<KeyUsageInfo>();
+        private List<LocalizationConstantInfo> _unusedConstants = new List<LocalizationConstantInfo>();
+
+        private Vector2 _scrollPos;
+        private string _searchText = string.Empty;
+        private string _lastScanSummary = "Not scanned";
+        private bool _showMissingKeys = true;
+        private bool _showUnusedKeys = true;
+
+        [MenuItem("XmobiTea Tools/Localization/Show KeyUsageAnalyzerWindows")]
+        public static void ShowWindow()
+        {
+            var window = GetWindow<KeyUsageAnalyzerWindowsEditor>();
+
+            window.minSize = new Vector2(900, 420);
+            window.Refresh();
+        }
+
+        private void OnEnable()
+        {
+            _lastScanSummary = "Click Refresh to scan localization key usage.";
+        }
+
+        private void OnGUI()
+        {
+            DrawToolbar();
+
+            _searchText = EditorGUILayout.TextField("Search", _searchText);
+
+            EditorGUILayout.Space(4);
+            EditorGUILayout.LabelField(_lastScanSummary, EditorStyles.miniLabel);
+
+            _scrollPos = EditorGUILayout.BeginScrollView(_scrollPos);
+
+            _showMissingKeys = EditorGUILayout.Foldout(_showMissingKeys, "Used keys missing in LocalizationConstantId.cs (" + GetFilteredMissingUsages().Count + ")", true);
+            if (_showMissingKeys)
+            {
+                DrawMissingConstantUsages();
+            }
+
+            EditorGUILayout.Space(8);
+
+            _showUnusedKeys = EditorGUILayout.Foldout(_showUnusedKeys, "Unused keys in LocalizationConstantId.cs (" + GetFilteredUnusedConstants().Count + ")", true);
+            if (_showUnusedKeys)
+            {
+                DrawUnusedConstants();
+            }
+
+            EditorGUILayout.EndScrollView();
+        }
+
+        private void DrawToolbar()
+        {
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
+
+            if (GUILayout.Button("Refresh", EditorStyles.toolbarButton, GUILayout.Width(70)))
+            {
+                Refresh();
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Clear Search", EditorStyles.toolbarButton, GUILayout.Width(90)))
+            {
+                _searchText = string.Empty;
+            }
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private void DrawMissingConstantUsages()
+        {
+            var usages = GetFilteredMissingUsages();
+            if (usages.Count == 0)
+            {
+                EditorGUILayout.LabelField("No used keys are missing from LocalizationConstantId.cs.");
+                return;
+            }
+
+            DrawMissingHeader();
+
+            foreach (var usage in usages)
+            {
+                EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
+
+                EditorGUILayout.SelectableLabel(usage.key, GUILayout.Width(220), GUILayout.Height(EditorGUIUtility.singleLineHeight));
+                EditorGUILayout.LabelField(usage.matchType, GUILayout.Width(140));
+                EditorGUILayout.LabelField(usage.location.sourceType.ToString(), GUILayout.Width(80));
+                EditorGUILayout.SelectableLabel(usage.location.GetDisplayLocation(), GUILayout.Height(EditorGUIUtility.singleLineHeight));
+
+                if (GUILayout.Button("Ping", GUILayout.Width(50)))
+                {
+                    PingLocation(usage.location);
+                }
+
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+
+        private void DrawUnusedConstants()
+        {
+            var constants = GetFilteredUnusedConstants();
+            if (constants.Count == 0)
+            {
+                EditorGUILayout.LabelField("No unused key was found in LocalizationConstantId.cs.");
+                return;
+            }
+
+            DrawUnusedHeader();
+
+            foreach (var constantInfo in constants)
+            {
+                EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
+
+                EditorGUILayout.SelectableLabel(constantInfo.key, GUILayout.Width(220), GUILayout.Height(EditorGUIUtility.singleLineHeight));
+                EditorGUILayout.LabelField(constantInfo.fieldName, GUILayout.Width(160));
+                EditorGUILayout.SelectableLabel(constantInfo.GetDisplayLocation(), GUILayout.Height(EditorGUIUtility.singleLineHeight));
+
+                using (new EditorGUI.DisabledScope(string.IsNullOrEmpty(constantInfo.assetPath)))
+                {
+                    if (GUILayout.Button("Ping", GUILayout.Width(50)))
+                    {
+                        PingAsset(constantInfo.assetPath);
+                    }
+                }
+
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+
+        private static void DrawMissingHeader()
+        {
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
+            GUILayout.Label("Key", EditorStyles.boldLabel, GUILayout.Width(220));
+            GUILayout.Label("Usage", EditorStyles.boldLabel, GUILayout.Width(140));
+            GUILayout.Label("Source", EditorStyles.boldLabel, GUILayout.Width(80));
+            GUILayout.Label("Location", EditorStyles.boldLabel);
+            GUILayout.Label("", GUILayout.Width(50));
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private static void DrawUnusedHeader()
+        {
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
+            GUILayout.Label("Key", EditorStyles.boldLabel, GUILayout.Width(220));
+            GUILayout.Label("Field", EditorStyles.boldLabel, GUILayout.Width(160));
+            GUILayout.Label("Location", EditorStyles.boldLabel);
+            GUILayout.Label("", GUILayout.Width(50));
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private void Refresh()
+        {
+            _constantsByKey.Clear();
+            _fieldToKey.Clear();
+            _usageByFingerprint.Clear();
+            _usagesByKey.Clear();
+
+            try
+            {
+                CollectConstants();
+                CollectCodeUsages();
+                CollectPrefabComponentUsages();
+                CollectSceneComponentUsages();
+                BuildResults();
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
+        private void CollectConstants()
+        {
+            foreach (var fullPath in Directory.GetFiles(Application.dataPath, "LocalizationConstantId.cs", SearchOption.AllDirectories))
+            {
+                var assetPath = ToAssetPath(fullPath);
+                var lines = File.ReadAllLines(fullPath);
+
+                for (var i = 0; i < lines.Length; i++)
+                {
+                    var match = ConstantRegex.Match(lines[i]);
+                    if (!match.Success) continue;
+
+                    if (!TryReadCSharpStringLiteral(match.Groups["literal"].Value, out var key)) continue;
+
+                    AddConstant(new LocalizationConstantInfo
+                    {
+                        key = key,
+                        fieldName = match.Groups["field"].Value,
+                        assetPath = assetPath,
+                        line = i + 1
+                    });
+                }
+            }
+
+            foreach (var type in AppDomain.CurrentDomain.GetAssemblies()
+                         .SelectMany(GetTypesSafe)
+                         .Where(p => p != null && p.Name == "LocalizationConstantId" && p.Namespace == "XmobiTea.MiniLocalization"))
+            {
+                foreach (var field in type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy))
+                {
+                    if (field.FieldType != typeof(string)) continue;
+
+                    var key = field.GetValue(null) as string;
+                    if (string.IsNullOrEmpty(key)) continue;
+
+                    AddConstant(new LocalizationConstantInfo
+                    {
+                        key = key,
+                        fieldName = field.Name
+                    });
+                }
+            }
+        }
+
+        private static IEnumerable<Type> GetTypesSafe(Assembly assembly)
+        {
+            try
+            {
+                return assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException exception)
+            {
+                return exception.Types.Where(p => p != null).Cast<Type>();
+            }
+            catch
+            {
+                return Array.Empty<Type>();
+            }
+        }
+
+        private void AddConstant(LocalizationConstantInfo constantInfo)
+        {
+            if (string.IsNullOrEmpty(constantInfo.key)) return;
+
+            if (!_constantsByKey.TryGetValue(constantInfo.key, out var existingConstant)
+                || string.IsNullOrEmpty(existingConstant.assetPath))
+            {
+                _constantsByKey[constantInfo.key] = constantInfo;
+            }
+
+            if (!string.IsNullOrEmpty(constantInfo.fieldName) && !_fieldToKey.ContainsKey(constantInfo.fieldName))
+            {
+                _fieldToKey[constantInfo.fieldName] = constantInfo.key;
+            }
+        }
+
+        private void CollectCodeUsages()
+        {
+            var files = Directory.GetFiles(Application.dataPath, "*.cs", SearchOption.AllDirectories)
+                .OrderBy(ToAssetPath)
+                .ToArray();
+
+            for (var i = 0; i < files.Length; i++)
+            {
+                var fullPath = files[i];
+                var assetPath = ToAssetPath(fullPath);
+
+                if (IsLocalizationConstantFile(assetPath)) continue;
+
+                EditorUtility.DisplayProgressBar("Localization Key Usage Analyzer", "Scanning code " + assetPath, files.Length == 0 ? 1 : (float)i / files.Length);
+
+                var lines = File.ReadAllLines(fullPath);
+                var insideBlockComment = false;
+                for (var lineIndex = 0; lineIndex < lines.Length; lineIndex++)
+                {
+                    var line = lines[lineIndex];
+                    var codeLine = RemoveCSharpComments(line, ref insideBlockComment);
+                    if (string.IsNullOrWhiteSpace(codeLine)) continue;
+
+                    var lineNumber = lineIndex + 1;
+                    ScanConstantReferences(assetPath, lineNumber, MaskCSharpStringLiterals(codeLine));
+                    ScanLocalizationStringLiterals(assetPath, lineNumber, codeLine);
+                }
+            }
+        }
+
+        private void ScanConstantReferences(string assetPath, int lineNumber, string line)
+        {
+            foreach (Match match in ConstantReferenceRegex.Matches(line))
+            {
+                var fieldName = match.Groups["field"].Value;
+                if (_fieldToKey.TryGetValue(fieldName, out var key))
+                {
+                    AddUsage(key, "LocalizationConstantId." + fieldName, new UsageLocation
+                    {
+                        sourceType = UsageSourceType.Code,
+                        assetPath = assetPath,
+                        line = lineNumber
+                    });
+                }
+                else
+                {
+                    AddUsage(fieldName, "Missing constant field", new UsageLocation
+                    {
+                        sourceType = UsageSourceType.Code,
+                        assetPath = assetPath,
+                        line = lineNumber
+                    });
+                }
+            }
+        }
+
+        private void ScanLocalizationStringLiterals(string assetPath, int lineNumber, string line)
+        {
+            foreach (Match match in LocalizationGetTextRegex.Matches(line))
+            {
+                AddStringLiteralUsage(assetPath, lineNumber, match, "LocalizationManager.GetText");
+            }
+
+            foreach (Match match in LocalizationKeyAssignmentRegex.Matches(line))
+            {
+                if (!IsLikelyLocalizationComponentKeyAssignment(match, line)) continue;
+
+                AddStringLiteralUsage(assetPath, lineNumber, match, "Localization key assignment");
+            }
+        }
+
+        private static bool IsLikelyLocalizationComponentKeyAssignment(Match match, string line)
+        {
+            var target = Regex.Replace(match.Groups["target"].Value, @"\s+", string.Empty);
+            if (target.IndexOf("LocalizationComponent", StringComparison.OrdinalIgnoreCase) >= 0) return true;
+            if (target.IndexOf("TMP_LocalizationComponent", StringComparison.OrdinalIgnoreCase) >= 0) return true;
+
+            return Regex.IsMatch(line, @"\b(?:LocalizationComponentBase|LocalizationComponent|TMP_LocalizationComponent)\b");
+        }
+
+        private void AddStringLiteralUsage(string assetPath, int lineNumber, Match match, string matchType)
+        {
+            if (!TryReadCSharpStringLiteral(match.Groups["literal"].Value, out var key)) return;
+
+            AddUsage(key, matchType, new UsageLocation
+            {
+                sourceType = UsageSourceType.Code,
+                assetPath = assetPath,
+                line = lineNumber
+            });
+        }
+
+        private void CollectPrefabComponentUsages()
+        {
+            var prefabGuids = AssetDatabase.FindAssets("t:Prefab", new[] { "Assets" });
+
+            for (var i = 0; i < prefabGuids.Length; i++)
+            {
+                var assetPath = AssetDatabase.GUIDToAssetPath(prefabGuids[i]);
+                EditorUtility.DisplayProgressBar("Localization Key Usage Analyzer", "Scanning prefab " + assetPath, prefabGuids.Length == 0 ? 1 : (float)i / prefabGuids.Length);
+
+                var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+                if (prefab == null) continue;
+
+                foreach (var component in prefab.GetComponentsInChildren<LocalizationComponentBase>(true))
+                {
+                    AddComponentUsage(assetPath, UsageSourceType.Prefab, component);
+                }
+            }
+        }
+
+        private void CollectSceneComponentUsages()
+        {
+            var sceneGuids = AssetDatabase.FindAssets("t:Scene", new[] { "Assets" });
+            var activeScene = SceneManager.GetActiveScene();
+
+            try
+            {
+                for (var i = 0; i < sceneGuids.Length; i++)
+                {
+                    var assetPath = AssetDatabase.GUIDToAssetPath(sceneGuids[i]);
+                    EditorUtility.DisplayProgressBar("Localization Key Usage Analyzer", "Scanning scene " + assetPath, sceneGuids.Length == 0 ? 1 : (float)i / sceneGuids.Length);
+
+                    var scene = GetLoadedSceneByPath(assetPath);
+                    var openedForScan = false;
+
+                    try
+                    {
+                        if (!scene.IsValid() || !scene.isLoaded)
+                        {
+                            scene = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.Additive);
+                            openedForScan = true;
+                        }
+
+                        foreach (var rootGameObject in scene.GetRootGameObjects())
+                        {
+                            foreach (var component in rootGameObject.GetComponentsInChildren<LocalizationComponentBase>(true))
+                            {
+                                AddComponentUsage(assetPath, UsageSourceType.Scene, component);
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        if (openedForScan && scene.IsValid() && scene.isLoaded)
+                        {
+                            EditorSceneManager.CloseScene(scene, true);
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (activeScene.IsValid() && activeScene.isLoaded)
+                {
+                    SceneManager.SetActiveScene(activeScene);
+                }
+            }
+        }
+
+        private static Scene GetLoadedSceneByPath(string assetPath)
+        {
+            for (var i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (scene.path == assetPath) return scene;
+            }
+
+            return default;
+        }
+
+        private void AddComponentUsage(string assetPath, UsageSourceType sourceType, LocalizationComponentBase component)
+        {
+            if (component == null || string.IsNullOrEmpty(component.key)) return;
+
+            AddUsage(component.key, component.GetType().Name, new UsageLocation
+            {
+                sourceType = sourceType,
+                assetPath = assetPath,
+                gameObjectPath = GetTransformPath(component.transform),
+                componentType = component.GetType().Name,
+                globalObjectId = GlobalObjectId.GetGlobalObjectIdSlow(component.gameObject).ToString()
+            });
+        }
+
+        private void AddUsage(string key, string matchType, UsageLocation location)
+        {
+            if (string.IsNullOrEmpty(key)) return;
+
+            var fingerprint = key + "|" + location.sourceType + "|" + location.assetPath + "|" + location.line + "|" + location.gameObjectPath + "|" + location.globalObjectId;
+            if (_usageByFingerprint.ContainsKey(fingerprint)) return;
+
+            var usage = new KeyUsageInfo
+            {
+                key = key,
+                matchType = matchType,
+                location = location
+            };
+
+            _usageByFingerprint[fingerprint] = usage;
+
+            if (!_usagesByKey.TryGetValue(key, out var usages))
+            {
+                usages = new List<KeyUsageInfo>();
+                _usagesByKey[key] = usages;
+            }
+
+            usages.Add(usage);
+        }
+
+        private void BuildResults()
+        {
+            _missingConstantUsages = _usagesByKey
+                .Where(p => !_constantsByKey.ContainsKey(p.Key))
+                .SelectMany(p => p.Value)
+                .OrderBy(p => p.key)
+                .ThenBy(p => p.location.assetPath)
+                .ThenBy(p => p.location.line)
+                .ToList();
+
+            _unusedConstants = _constantsByKey.Values
+                .Where(p => !_usagesByKey.ContainsKey(p.key))
+                .OrderBy(p => p.key)
+                .ToList();
+
+            _lastScanSummary = "Constants: " + _constantsByKey.Count
+                + " | Usages: " + _usageByFingerprint.Count
+                + " | Missing constants: " + _missingConstantUsages.Count
+                + " | Unused constants: " + _unusedConstants.Count;
+        }
+
+        private List<KeyUsageInfo> GetFilteredMissingUsages()
+        {
+            if (string.IsNullOrEmpty(_searchText)) return _missingConstantUsages;
+
+            return _missingConstantUsages
+                .Where(p => p.Contains(_searchText))
+                .ToList();
+        }
+
+        private List<LocalizationConstantInfo> GetFilteredUnusedConstants()
+        {
+            if (string.IsNullOrEmpty(_searchText)) return _unusedConstants;
+
+            return _unusedConstants
+                .Where(p => p.Contains(_searchText))
+                .ToList();
+        }
+
+        private static void PingLocation(UsageLocation location)
+        {
+            if (location.sourceType == UsageSourceType.Code)
+            {
+                PingAsset(location.assetPath);
+                return;
+            }
+
+            if (location.sourceType == UsageSourceType.Prefab)
+            {
+                PingPrefabObject(location);
+                return;
+            }
+
+            if (location.sourceType == UsageSourceType.Scene)
+            {
+                PingSceneObject(location);
+            }
+        }
+
+        private static void PingAsset(string assetPath)
+        {
+            if (string.IsNullOrEmpty(assetPath)) return;
+
+            var asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);
+            if (asset == null) return;
+
+            Selection.activeObject = asset;
+            EditorGUIUtility.PingObject(asset);
+        }
+
+        private static void PingPrefabObject(UsageLocation location)
+        {
+            if (PingGlobalObjectId(location.globalObjectId)) return;
+
+            var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(location.assetPath);
+            if (prefab == null)
+            {
+                PingAsset(location.assetPath);
+                return;
+            }
+
+            var gameObject = FindGameObjectInRoot(prefab, location.gameObjectPath);
+            var target = gameObject != null ? gameObject : prefab;
+
+            Selection.activeObject = target;
+            EditorGUIUtility.PingObject(target);
+        }
+
+        private static void PingSceneObject(UsageLocation location)
+        {
+            var scene = GetLoadedSceneByPath(location.assetPath);
+            if (!scene.IsValid() || !scene.isLoaded)
+            {
+                PingAsset(location.assetPath);
+                return;
+            }
+
+            if (PingGlobalObjectId(location.globalObjectId)) return;
+
+            foreach (var rootGameObject in scene.GetRootGameObjects())
+            {
+                var gameObject = FindGameObjectInRoot(rootGameObject, location.gameObjectPath);
+                if (gameObject == null) continue;
+
+                Selection.activeObject = gameObject;
+                EditorGUIUtility.PingObject(gameObject);
+                return;
+            }
+
+            PingAsset(location.assetPath);
+        }
+
+        private static bool PingGlobalObjectId(string globalObjectId)
+        {
+            if (string.IsNullOrEmpty(globalObjectId)) return false;
+            if (!GlobalObjectId.TryParse(globalObjectId, out var id)) return false;
+
+            var target = GlobalObjectId.GlobalObjectIdentifierToObjectSlow(id);
+            if (target == null) return false;
+
+            Selection.activeObject = target;
+            EditorGUIUtility.PingObject(target);
+            return true;
+        }
+
+        private static GameObject FindGameObjectInRoot(GameObject root, string gameObjectPath)
+        {
+            if (root == null || string.IsNullOrEmpty(gameObjectPath)) return null;
+
+            var parts = gameObjectPath.Split('/');
+            if (parts.Length == 0 || parts[0] != root.name) return null;
+
+            var current = root.transform;
+            for (var i = 1; i < parts.Length; i++)
+            {
+                current = current.Find(parts[i]);
+                if (current == null) return null;
+            }
+
+            return current.gameObject;
+        }
+
+        private static string GetTransformPath(Transform transform)
+        {
+            var names = new Stack<string>();
+            while (transform != null)
+            {
+                names.Push(transform.name);
+                transform = transform.parent;
+            }
+
+            return string.Join("/", names.ToArray());
+        }
+
+        private static bool IsLocalizationConstantFile(string assetPath)
+        {
+            return string.Equals(Path.GetFileName(assetPath), "LocalizationConstantId.cs", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static string ToAssetPath(string fullPath)
+        {
+            var normalizedFullPath = fullPath.Replace('\\', '/');
+            var normalizedDataPath = Application.dataPath.Replace('\\', '/');
+
+            if (!normalizedFullPath.StartsWith(normalizedDataPath, StringComparison.OrdinalIgnoreCase))
+            {
+                return normalizedFullPath;
+            }
+
+            return "Assets" + normalizedFullPath.Substring(normalizedDataPath.Length);
+        }
+
+        private static string RemoveCSharpComments(string line, ref bool insideBlockComment)
+        {
+            if (string.IsNullOrEmpty(line)) return string.Empty;
+
+            var result = new System.Text.StringBuilder(line.Length);
+
+            for (var i = 0; i < line.Length; i++)
+            {
+                if (insideBlockComment)
+                {
+                    if (i + 1 < line.Length && line[i] == '*' && line[i + 1] == '/')
+                    {
+                        insideBlockComment = false;
+                        i++;
+                    }
+
+                    continue;
+                }
+
+                if (i + 1 < line.Length && line[i] == '/' && line[i + 1] == '/')
+                {
+                    break;
+                }
+
+                if (i + 1 < line.Length && line[i] == '/' && line[i + 1] == '*')
+                {
+                    insideBlockComment = true;
+                    i++;
+                    continue;
+                }
+
+                if (line[i] == '@' && i + 1 < line.Length && line[i + 1] == '"')
+                {
+                    result.Append(line[i]);
+                    i++;
+                    result.Append(line[i]);
+
+                    while (i + 1 < line.Length)
+                    {
+                        i++;
+                        result.Append(line[i]);
+
+                        if (line[i] == '"')
+                        {
+                            if (i + 1 < line.Length && line[i + 1] == '"')
+                            {
+                                i++;
+                                result.Append(line[i]);
+                                continue;
+                            }
+
+                            break;
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (line[i] == '"' || line[i] == '\'')
+                {
+                    var quote = line[i];
+                    result.Append(line[i]);
+
+                    while (i + 1 < line.Length)
+                    {
+                        i++;
+                        result.Append(line[i]);
+
+                        if (line[i] == '\\' && i + 1 < line.Length)
+                        {
+                            i++;
+                            result.Append(line[i]);
+                            continue;
+                        }
+
+                        if (line[i] == quote)
+                        {
+                            break;
+                        }
+                    }
+
+                    continue;
+                }
+
+                result.Append(line[i]);
+            }
+
+            return result.ToString();
+        }
+
+        private static string MaskCSharpStringLiterals(string line)
+        {
+            return AnyStringLiteralRegex.Replace(line, "\"\"");
+        }
+
+        private static bool TryReadCSharpStringLiteral(string literal, out string value)
+        {
+            value = string.Empty;
+            if (string.IsNullOrEmpty(literal)) return false;
+
+            if (literal.StartsWith("@\"", StringComparison.Ordinal))
+            {
+                if (literal.Length < 3 || literal[literal.Length - 1] != '"') return false;
+
+                value = literal.Substring(2, literal.Length - 3).Replace("\"\"", "\"");
+                return true;
+            }
+
+            if (literal.Length < 2 || literal[0] != '"' || literal[literal.Length - 1] != '"') return false;
+
+            var innerValue = literal.Substring(1, literal.Length - 2);
+            try
+            {
+                value = Regex.Unescape(innerValue);
+            }
+            catch
+            {
+                value = innerValue.Replace("\\\"", "\"").Replace("\\\\", "\\");
+            }
+
+            return true;
+        }
+
+        private enum UsageSourceType
+        {
+            Code,
+            Prefab,
+            Scene
+        }
+
+        private sealed class LocalizationConstantInfo
+        {
+            public string key;
+            public string fieldName;
+            public string assetPath;
+            public int line;
+
+            public string GetDisplayLocation()
+            {
+                if (string.IsNullOrEmpty(assetPath)) return "Compiled LocalizationConstantId";
+                if (line <= 0) return assetPath;
+
+                return assetPath + ":" + line;
+            }
+
+            public bool Contains(string searchText)
+            {
+                return ContainsText(key, searchText)
+                    || ContainsText(fieldName, searchText)
+                    || ContainsText(assetPath, searchText);
+            }
+        }
+
+        private sealed class KeyUsageInfo
+        {
+            public string key;
+            public string matchType;
+            public UsageLocation location;
+
+            public bool Contains(string searchText)
+            {
+                return ContainsText(key, searchText)
+                    || ContainsText(matchType, searchText)
+                    || location.Contains(searchText);
+            }
+        }
+
+        private sealed class UsageLocation
+        {
+            public UsageSourceType sourceType;
+            public string assetPath;
+            public int line;
+            public string gameObjectPath;
+            public string componentType;
+            public string globalObjectId;
+
+            public string GetDisplayLocation()
+            {
+                if (sourceType == UsageSourceType.Code)
+                {
+                    return assetPath + ":" + line;
+                }
+
+                if (!string.IsNullOrEmpty(componentType))
+                {
+                    return assetPath + " -> " + gameObjectPath + " (" + componentType + ")";
+                }
+
+                return assetPath + " -> " + gameObjectPath;
+            }
+
+            public bool Contains(string searchText)
+            {
+                return ContainsText(assetPath, searchText)
+                    || ContainsText(gameObjectPath, searchText)
+                    || ContainsText(componentType, searchText)
+                    || ContainsText(sourceType.ToString(), searchText);
+            }
+        }
+
+        private static bool ContainsText(string source, string searchText)
+        {
+            if (string.IsNullOrEmpty(searchText)) return true;
+            if (string.IsNullOrEmpty(source)) return false;
+
+            return source.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0;
+        }
+    }
+}