Merge pull request #24 from tsgcpp/feature/fix_cache_collections_in_editor

fix: Use CacheListConverter to return "StringTableCollection"s

Author: tsgcpp

Assets/Plugins/LocalizationExtension/Editor/Google/StringTableCollection/StringTableCollectionBundleEditor.cs

@@ -15,19 +15,16 @@ public sealed class StringTableCollectionBundleEditor : UnityEditor.Editor
 
         public override void OnInspectorGUI()
         {
-            using (var changeCheck = new EditorGUI.ChangeCheckScope())
-            {
-                DrawDefaultInspector();
-                EditorGUILayout.Space(16);
+            DrawDefaultInspector();
+            EditorGUILayout.Space(16);
 
-                DrawToolsWithSheetsServiceProvider();
-                EditorGUILayout.Space(8);
+            DrawToolsWithSheetsServiceProvider();
+            EditorGUILayout.Space(8);
 
-                DrawToolsWithServiceAccount();
-                EditorGUILayout.Space(8);
+            DrawToolsWithServiceAccount();
+            EditorGUILayout.Space(8);
 
-                DrawStringTableCollections(changeCheck.changed);
-            }
+            DrawStringTableCollections();
         }
 
         private void DrawToolsWithSheetsServiceProvider()
@@ -63,28 +60,20 @@ private void DrawToolsWithServiceAccount()
         }
 
         private bool _showStringTableCollections = true;
-        private IReadOnlyList<StringTableCollection> _stringTableCollectionsCache = new List<StringTableCollection>();
+        private readonly CacheListConverter<DefaultAsset, StringTableCollection> _stringTableCollectionsConverter =
+            new CacheListConverter<DefaultAsset, StringTableCollection>(
+                actualConverter: new FolderToCollectionConverter());
 
-        private void DrawStringTableCollections(bool guiChanged)
+        private void DrawStringTableCollections()
         {
             var foldoutStyle = new GUIStyle(EditorStyles.foldout)
             {
                 fontStyle = FontStyle.Bold,
             };
 
             _showStringTableCollections = EditorGUILayout.Foldout(_showStringTableCollections, "Target \"StringTableCollection\"s", foldoutStyle);
-            if (!_showStringTableCollections)
-            {
-                _stringTableCollectionsCache = null;
-                return;
-            }
-
-            if (_stringTableCollectionsCache == null || guiChanged)
-            {
-                _stringTableCollectionsCache = Bundle.StringTableCollections;
-            }
 
-            var stringTableCollections = Bundle.StringTableCollections;
+            var stringTableCollections = _stringTableCollectionsConverter.Convert(Bundle.TargetFolders);
             using var h = new EditorGUILayout.VerticalScope(GUI.skin.box);
             using var g = new EditorGUI.DisabledGroupScope(true);
             foreach (var collection in stringTableCollections)
@@ -139,5 +128,13 @@ private ServiceAccountSheetsServiceProvider CreateServiceAccountSheetsServicePro
                 applicationName: sheetsSesrvicesProvider.ApplicationName);
             return provider;
         }
+
+        private sealed class FolderToCollectionConverter : IListConverter<DefaultAsset, StringTableCollection>
+        {
+            public IReadOnlyList<StringTableCollection> Convert(IReadOnlyList<DefaultAsset> list)
+            {
+                return AssetFinding.FindAssetsInFolders<StringTableCollection>(list);
+            }
+        }
     }
 }

Assets/Plugins/LocalizationExtension/Editor/ListConverter.meta

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Tsgcpp.Localization.Extension.Editor
+{
+    public sealed class CacheListConverter<T, TResult> : IListConverter<T, TResult>
+        where T : class
+        where TResult : class
+    {
+        private readonly IListConverter<T, TResult> _actualConverter;
+        private readonly List<T> _listCache = new List<T>(capacity: 32);
+        private IReadOnlyList<TResult> _resultListCache = null;
+
+        public CacheListConverter(IListConverter<T, TResult> actualConverter)
+        {
+            _actualConverter = actualConverter;
+        }
+
+        public IReadOnlyList<TResult> Convert(IReadOnlyList<T> list)
+        {
+            if (list == null)
+            {
+                throw new NullReferenceException("list is null");
+            }
+
+            if (_resultListCache != null && CompareArgListEquality(list))
+            {
+                return _resultListCache;
+            }
+
+            return CreateAndHoldCache(list);
+        }
+
+        private IReadOnlyList<TResult> CreateAndHoldCache(IReadOnlyList<T> list)
+        {
+            _listCache.Clear();
+            _listCache.AddRange(list);
+            _resultListCache = _actualConverter.Convert(list);
+            return _resultListCache;
+        }
+
+        private bool CompareArgListEquality(IReadOnlyList<T> list)
+        {
+            if (list.Count != _listCache.Count)
+            {
+                return false;
+            }
+
+            return _listCache.SequenceEqual(list);
+        }
+    }
+}

Assets/Plugins/LocalizationExtension/Editor/ListConverter/CacheListConverter.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Tsgcpp.Localization.Extension.Editor
+{
+    public interface IListConverter<T, TResult>
+        where T : class
+        where TResult : class
+    {
+        IReadOnlyList<TResult> Convert(IReadOnlyList<T> list);
+    }
+}

Assets/Plugins/LocalizationExtension/Editor/ListConverter/CacheListConverter.cs.meta

@@ -0,0 +1,148 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Tsgcpp.Localization.Extension.Editor;
+
+namespace Tests.Tsgcpp.Localization.Extension.Editor
+{
+    public class TestCacheListConverter
+    {
+        CacheListConverter<string, object> _target;
+        ListConverterMock _listConverterMock;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _listConverterMock = new ListConverterMock();
+            _target = new CacheListConverter<string, object>(_listConverterMock);
+        }
+
+        [Test]
+        public void Convert_ReturnsNewResultList_IfFirstCall()
+        {
+            // setup
+            var list = new List<string> { "a", "b", "c" };
+
+            // when
+            var actual = _target.Convert(list);
+
+            // then
+            Assert.That(actual, Is.SameAs(_listConverterMock.ResultList));
+            Assert.That(_listConverterMock.LastArg, Is.SameAs(list));
+            Assert.That(_listConverterMock.ConvertCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void Convert_ReturnsNewResultList_IfSecondCallWithAnother()
+        {
+            // setup
+            var list = new List<string> { "a", "b", "c" };
+            var list2 = new List<string> { "a", "c" };
+            _target.Convert(list);
+
+            var resultList2 = new List<object> { 2, "b" };
+            _listConverterMock.ResultList = resultList2;
+
+            // when
+            var actual = _target.Convert(list2);
+
+            // then
+            Assert.That(actual, Is.SameAs(resultList2));
+            Assert.That(_listConverterMock.ConvertCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void Convert_ReturnsCachedResultList_IfSecondCallWithTheSameList()
+        {
+            // setup
+            var list = new List<string> { "a", "b", "c" };
+            _target.Convert(list);
+
+            // when
+            var actual = _target.Convert(list);
+
+            // then
+            Assert.That(actual, Is.SameAs(_listConverterMock.ResultList));
+            // Not call ListConverterMock.Convert() because the cache is already created.
+            Assert.That(_listConverterMock.ConvertCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void Convert_ReturnsCachedResultList_IfSecondCallWithTheSameValues()
+        {
+            // setup
+            var list = new List<string> { "a", "b", "c" };
+            var list2 = new List<string> { "a", "b", "c" };
+            _target.Convert(list);
+
+            // when
+            var actual = _target.Convert(list2);
+
+            // then
+            Assert.That(actual, Is.SameAs(_listConverterMock.ResultList));
+            // Not call ListConverterMock.Convert() because the cache is already created.
+            Assert.That(_listConverterMock.ConvertCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void Convert_ReturnsNewResultList_IfSecondCallWithAnotherValuesOfSameCount()
+        {
+            // setup
+            var list = new List<string> { "a", "b", "c" };
+            var list2 = new List<string> { "a", "c", "d" };
+            _target.Convert(list);
+
+            var resultList2 = new List<object> { 2, "b" };
+            _listConverterMock.ResultList = resultList2;
+
+            // when
+            var actual = _target.Convert(list2);
+
+            // then
+            Assert.That(actual, Is.SameAs(resultList2));
+            Assert.That(_listConverterMock.ConvertCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void Convert_ReturnsNewResultList_IfSecondCallWithAnotherValuesOfDifferentCount()
+        {
+            // setup
+            var list = new List<string> { "a", "b", "c" };
+            var list2 = new List<string> { "a", "b" };
+            _target.Convert(list);
+
+            var resultList2 = new List<object> { 2, "b" };
+            _listConverterMock.ResultList = resultList2;
+
+            // when
+            var actual = _target.Convert(list2);
+
+            // then
+            Assert.That(actual, Is.SameAs(resultList2));
+            Assert.That(_listConverterMock.ConvertCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void Convert_ThrowsNullReferenceException_IfListIsNull()
+        {
+            Assert.Throws<NullReferenceException>(() => _target.Convert(null));
+        }
+
+        public class ListConverterMock : IListConverter<string, object>
+        {
+            public IReadOnlyList<object> ResultList { get; set; } = new List<object> { 1, "a", null };
+            public IReadOnlyList<string> LastArg { get; set; } = null;
+            public int ConvertCount { get; set; } = 0;
+
+            public IReadOnlyList<object> Convert(IReadOnlyList<string> list)
+            {
+                LastArg = list;
+                ConvertCount += 1;
+                return ResultList;
+            }
+        }
+    }
+}