Refactor folder state to be managed by a service

Author: chrisgregan

app/Celbridge.Tests/ResourceRegistryTests.cs

@@ -1,7 +1,9 @@
+using Celbridge.Explorer.Services;
 using Celbridge.Messaging.Services;
 using Celbridge.Resources.Models;
 using Celbridge.Resources.Services;
 using Celbridge.UserInterface.Services;
+using Celbridge.Workspace;
 
 namespace Celbridge.Tests;
 
@@ -109,23 +111,23 @@ public void ICanExpandAFolderResource()
         var resourceRegistry = new ResourceRegistry(messengerService, fileIconService);
         resourceRegistry.ProjectFolderPath = _resourceFolderPath;
 
-        resourceRegistry.SetFolderIsExpanded(FolderNameA, true);
+        var workspaceWrapper = Substitute.For<IWorkspaceWrapper>();
+        var folderStateService = new FolderStateService(workspaceWrapper);
+        folderStateService.SetExpanded(FolderNameA, true);
 
         var updateResult = resourceRegistry.UpdateResourceRegistry();
         updateResult.IsSuccess.Should().BeTrue();
 
         //
-        // Check that the folder resource is expanded.
+        // Check that the folder resource expanded state is tracked correctly.
         //
 
-        var folderResource = (resourceRegistry.RootFolder.Children[0] as FolderResource)!;
-        folderResource.IsExpanded.Should().BeTrue();
-
-        var expandedFoldersOut = resourceRegistry.ExpandedFolders;
+        var expandedFoldersOut = folderStateService.ExpandedFolders;
         expandedFoldersOut.Count.Should().Be(1);
         expandedFoldersOut[0].Should().Be(FolderNameA);
 
+        var folderResource = (resourceRegistry.RootFolder.Children[0] as FolderResource)!;
         var folderPath = resourceRegistry.GetResourceKey(folderResource);
-        resourceRegistry.IsFolderExpanded(folderPath).Should().BeTrue();
+        folderStateService.IsExpanded(folderPath).Should().BeTrue();
     }
 }

app/Core/Celbridge.Foundation/Explorer/IExplorerService.cs

@@ -17,6 +17,11 @@ public interface IExplorerService
     /// </summary>
     IResourceTreeView ResourceTreeView { get; }
 
+    /// <summary>
+    /// Returns the Folder State Service that manages folder expanded state in the resource tree.
+    /// </summary>
+    IFolderStateService FolderStateService { get; }
+
     /// <summary>
     /// The currenlty selected resource in the Explorer Panel.
     /// </summary>

app/Core/Celbridge.Foundation/Explorer/IFolderStateService.cs

@@ -0,0 +1,37 @@
+namespace Celbridge.Explorer;
+
+/// <summary>
+/// Manages the expanded folder state in the resource tree.
+/// </summary>
+public interface IFolderStateService
+{
+    /// <summary>
+    /// Returns the list of expanded folders in the resource tree.
+    /// </summary>
+    List<string> ExpandedFolders { get; }
+
+    /// <summary>
+    /// Mark a folder resource as expanded or collapsed in the resource tree.
+    /// </summary>
+    void SetExpanded(ResourceKey folderResource, bool isExpanded);
+
+    /// <summary>
+    /// Returns true if the folder with the specified resource key is expanded.
+    /// </summary>
+    bool IsExpanded(ResourceKey folderResource);
+
+    /// <summary>
+    /// Removes expanded folder entries that no longer exist in the resource registry.
+    /// </summary>
+    void Cleanup();
+
+    /// <summary>
+    /// Loads the folder state from workspace settings.
+    /// </summary>
+    Task LoadAsync();
+
+    /// <summary>
+    /// Saves the folder state to workspace settings.
+    /// </summary>
+    Task SaveAsync();
+}

app/Core/Celbridge.Foundation/Resources/IResourceRegistry.cs

@@ -77,22 +77,6 @@ public interface IResourceRegistry
     /// </summary>
     Result UpdateResourceRegistry();
 
-    /// <summary>
-    /// Returns the list of expanded folders in the resource tree.
-    /// </summary>
-    List<string> ExpandedFolders { get; }
-
-    /// <summary>
-    /// Mark a folder resource as expanded or collapsed in the resource tree.
-    /// This does not affect the IsExpanded property of the folder resource itself.
-    /// </summary>
-    void SetFolderIsExpanded(ResourceKey folderResource, bool isExpanded);
-
-    /// <summary>
-    /// Returns true if the folder with the specified resource key is expanded.
-    /// </summary>
-    bool IsFolderExpanded(ResourceKey folderResource);
-
     /// <summary>
     /// Returns all file resources in the registry with their resource keys and absolute paths.
     /// The results are sorted by path for stable ordering.

app/Workspace/Celbridge.Explorer/Commands/DuplicateResourceDialogCommand.cs

@@ -91,8 +91,9 @@ private async Task<Result> ShowDuplicateResourceDialogAsync()
             bool isFolderResource = resource is IFolderResource;
 
             // Maintain the expanded state of folders after rename
+            var folderStateService = _workspaceWrapper.WorkspaceService.ExplorerService.FolderStateService;
             bool isExpandedFolder = isFolderResource &&
-                resourceRegistry.IsFolderExpanded(Resource);
+                folderStateService.IsExpanded(Resource);
 
             // Execute a command to move the folder resource to perform the rename
             _commandService.Execute<ICopyResourceCommand>(command =>

app/Workspace/Celbridge.Explorer/Commands/ExpandFolderCommand.cs

@@ -11,7 +11,8 @@ public class ExpandFolderCommand : CommandBase, IExpandFolderCommand
     public ResourceKey FolderResource { get; set; }
     public bool Expanded { get; set; } = true;
 
-    public ExpandFolderCommand(IWorkspaceWrapper workspaceWrapper)
+    public ExpandFolderCommand(
+        IWorkspaceWrapper workspaceWrapper)
     {
         _workspaceWrapper = workspaceWrapper;
     }
@@ -33,9 +34,11 @@ public override async Task<Result> ExecuteAsync()
             return Result.Fail($"Resource is not a folder. {FolderResource}");
         }
 
-        if (resourceRegistry.IsFolderExpanded(FolderResource) != Expanded)
+        var folderStateService = _workspaceWrapper.WorkspaceService.ExplorerService.FolderStateService;
+
+        if (folderStateService.IsExpanded(FolderResource) != Expanded)
         {
-            resourceRegistry.SetFolderIsExpanded(FolderResource, Expanded);
+            folderStateService.SetExpanded(FolderResource, Expanded);
         }
 
         if (folderResource.IsExpanded != Expanded)

app/Workspace/Celbridge.Explorer/Commands/RenameResourceDialogCommand.cs

@@ -86,8 +86,9 @@ private async Task<Result> ShowRenameResourceDialogAsync()
             bool isFolderResource = resource is IFolderResource;
 
             // Maintain the expanded state of folders after rename
+            var folderStateService = _workspaceWrapper.WorkspaceService.ExplorerService.FolderStateService;
             bool isExpandedFolder = isFolderResource &&
-                resourceRegistry.IsFolderExpanded(Resource);
+                folderStateService.IsExpanded(Resource);
 
             // Execute a command to move the resource to perform the rename
             _commandService.Execute<ICopyResourceCommand>(command =>

app/Workspace/Celbridge.Explorer/ServiceConfiguration.cs

@@ -14,6 +14,7 @@ public static void ConfigureServices(IServiceCollection services)
         //
 
         services.AddTransient<IExplorerService, ExplorerService>();
+        services.AddTransient<IFolderStateService, FolderStateService>();
 
         //
         // Register views

app/Workspace/Celbridge.Explorer/Services/ExplorerService.cs

@@ -1,7 +1,7 @@
 using Celbridge.Commands;
+using Celbridge.Logging;
 using Celbridge.UserInterface;
 using Celbridge.Workspace;
-using Celbridge.Logging;
 
 namespace Celbridge.Explorer.Services;
 
@@ -17,25 +17,27 @@ public class ExplorerService : IExplorerService, IDisposable
     private readonly IWorkspaceWrapper _workspaceWrapper;
 
     private IResourceRegistry? _resourceRegistry;
-    private IResourceRegistry ResourceRegistry => 
+    private IResourceRegistry ResourceRegistry =>
         _resourceRegistry ??= _workspaceWrapper.WorkspaceService.ResourceService.Registry;
 
     private IExplorerPanel? _explorerPanel;
     public IExplorerPanel ExplorerPanel => _explorerPanel!;
 
     private IResourceTreeView? _resourceTreeView;
-    public IResourceTreeView ResourceTreeView 
+    public IResourceTreeView ResourceTreeView
     {
         get
         {
             return _resourceTreeView ?? throw new NullReferenceException("ResourceTreeView is null.");
         }
-        set 
-        { 
-            _resourceTreeView = value; 
+        set
+        {
+            _resourceTreeView = value;
         }
     }
 
+    public IFolderStateService FolderStateService { get; }
+
     public ResourceKey SelectedResource { get; private set; }
 
     private bool _isWorkspaceLoaded;
@@ -58,6 +60,8 @@ public ExplorerService(
         _fileIconService = fileIconService;
         _workspaceWrapper = workspaceWrapper;
 
+        FolderStateService = serviceProvider.GetRequiredService<IFolderStateService>();
+
         _messengerService.Register<WorkspaceWillPopulatePanelsMessage>(this, OnWorkspaceWillPopulatePanelsMessage);
         _messengerService.Register<WorkspaceLoadedMessage>(this, OnWorkspaceLoadedMessage);
         _messengerService.Register<SelectedResourceChangedMessage>(this, OnSelectedResourceChangedMessage);
@@ -82,12 +86,15 @@ private void OnSelectedResourceChangedMessage(object recipient, SelectedResource
         if (_isWorkspaceLoaded)
         {
             // Ignore change events that happen while loading the workspace
-            _ = StoreSelectedResource();            
+            _ = StoreSelectedResource();
         }
     }
 
     private async void OnResourceRegistryUpdatedMessage(object recipient, ResourceRegistryUpdatedMessage message)
     {
+        // Clean up expanded folders that no longer exist in the registry
+        FolderStateService.Cleanup();
+
         var result = await PopulateTreeViewAsync();
         if (result.IsFailure)
         {

app/Workspace/Celbridge.Explorer/Services/FolderStateService.cs

@@ -0,0 +1,69 @@
+using Celbridge.Workspace;
+
+namespace Celbridge.Explorer.Services;
+
+/// <summary>
+/// Manages folder UI state, such as expanded folder state in the resource tree.
+/// </summary>
+public class FolderStateService : IFolderStateService
+{
+    private const string ExpandedFoldersKey = "ExpandedFolders";
+
+    private readonly IWorkspaceWrapper _workspaceWrapper;
+
+    public List<string> ExpandedFolders { get; } = [];
+
+    public FolderStateService(IWorkspaceWrapper workspaceWrapper)
+    {
+        _workspaceWrapper = workspaceWrapper;
+    }
+
+    public void SetExpanded(ResourceKey folderResource, bool isExpanded)
+    {
+        if (isExpanded)
+        {
+            if (!folderResource.IsEmpty &&
+                !ExpandedFolders.Contains(folderResource))
+            {
+                ExpandedFolders.Add(folderResource);
+                ExpandedFolders.Sort();
+            }
+        }
+        else
+        {
+            ExpandedFolders.Remove(folderResource);
+        }
+    }
+
+    public bool IsExpanded(ResourceKey folderResource)
+    {
+        return ExpandedFolders.Contains(folderResource);
+    }
+
+    public void Cleanup()
+    {
+        var resourceRegistry = _workspaceWrapper.WorkspaceService.ResourceService.Registry;
+        ExpandedFolders.Remove(string.Empty);
+        ExpandedFolders.RemoveAll(expandedFolder => resourceRegistry.GetResource(expandedFolder).IsFailure);
+    }
+
+    public async Task LoadAsync()
+    {
+        var workspaceSettings = _workspaceWrapper.WorkspaceService.WorkspaceSettings;
+        var expandedFolders = await workspaceSettings.GetPropertyAsync<List<string>>(ExpandedFoldersKey);
+        if (expandedFolders is not null &&
+            expandedFolders.Count > 0)
+        {
+            foreach (var expandedFolder in expandedFolders)
+            {
+                SetExpanded(expandedFolder, true);
+            }
+        }
+    }
+
+    public async Task SaveAsync()
+    {
+        var workspaceSettings = _workspaceWrapper.WorkspaceService.WorkspaceSettings;
+        await workspaceSettings.SetPropertyAsync(ExpandedFoldersKey, ExpandedFolders);
+    }
+}