Add DataFolderProvider

Create a new provider for handling changing the data folder. This
shouldn't affect the functionality for r2mm, but allows tsmm to fix the
feature on their end.

As a bonus it moves the related logic from the bloated Manager
component.

Author: anttimaki

src/App.vue

@@ -30,6 +30,8 @@ import LinkProvider from './providers/components/LinkProvider';
 import LinkImpl from './r2mm/component_override/LinkImpl';
 import FsProvider from './providers/generic/file/FsProvider';
 import NodeFs from './providers/generic/file/NodeFs';
+import { DataFolderProvider } from './providers/ror2/system/DataFolderProvider';
+import { DataFolderProviderImpl } from './r2mm/system/DataFolderProviderImpl';
 import InteractionProvider from './providers/ror2/system/InteractionProvider';
 import InteractionProviderImpl from './r2mm/system/InteractionProviderImpl';
 import ZipProvider from './providers/generic/zip/ZipProvider';
@@ -117,6 +119,7 @@ export default class App extends mixins(UtilityMixin) {
         LoggerProvider.provide(() => new Logger());
         LinkProvider.provide(() => new LinkImpl());
         InteractionProvider.provide(() => new InteractionProviderImpl());
+        DataFolderProvider.provide(() => new DataFolderProviderImpl());
 
         PlatformInterceptorProvider.provide(() => new PlatformInterceptorImpl());
 

src/pages/Manager.vue

@@ -157,6 +157,7 @@ import ManifestV2 from '../model/ManifestV2';
 import ManagerSettings from '../r2mm/manager/ManagerSettings';
 import ThemeManager from '../r2mm/manager/ThemeManager';
 import ManagerInformation from '../_managerinf/ManagerInformation';
+import { DataFolderProvider } from '../providers/ror2/system/DataFolderProvider';
 import InteractionProvider from '../providers/ror2/system/InteractionProvider';
 
 import { homedir } from 'os';
@@ -504,41 +505,22 @@ import CategoryFilterModal from '../components/modals/CategoryFilterModal.vue';
             }
 		}
 
-        changeDataFolder() {
-            const fs = FsProvider.instance;
-            const dir: string = PathResolver.ROOT;
-            InteractionProvider.instance.selectFolder({
-                title: `Select a new folder to store ${ManagerInformation.APP_NAME} data`,
-                defaultPath: dir,
-                buttonLabel: 'Select Data Folder'
-            }).then(async files => {
-                if (files.length === 1) {
-                    const dataDirectoryOverrideFile = ".ddir.mm";
-                    const filesInDirectory = await fs.readdir(files[0]);
-
-                    const hasOverrideFile = filesInDirectory.find(value => value.toLowerCase() === dataDirectoryOverrideFile) != undefined;
-                    const directoryHasContents = filesInDirectory.length > 0;
-                    const isDefaultDataDirectory = files[0] === PathResolver.APPDATA_DIR;
-
-                    if (hasOverrideFile || !directoryHasContents || isDefaultDataDirectory) {
-                        // Write dataDirectoryOverrideFile to allow re-selection of directory if changed at a later point.
-                        await fs.writeFile(path.join(files[0], dataDirectoryOverrideFile), "");
-                        await this.settings.setDataDirectory(files[0]);
-                        InteractionProvider.instance.restartApp();
-                    } else {
-                        this.$store.commit('error/handleError', new R2Error(
-                            "Selected directory is not empty",
-                            `Directory is not empty: ${files[0]}. Contains ${filesInDirectory.length} files.`,
-                            "Select an empty directory or create a new one."
-                        ));
-                    }
+        async changeDataFolder() {
+            try {
+                const folder = await DataFolderProvider.instance.showSelectionDialog();
+
+                if (folder === null) {
+                    return;
                 }
-            }).catch((err) => {
-                this.$store.commit(
-                    "error/handleError",
-                    R2Error.fromThrownValue(err, "Failed to change Data Folder")
-                );
-            });
+
+                await DataFolderProvider.instance.throwForInvalidFolder(folder);
+                await DataFolderProvider.instance.writeOverrideFile(folder);
+                await this.settings.setDataDirectory(folder);
+                InteractionProvider.instance.restartApp();
+            } catch(err) {
+                this.$store.commit("error/handleError", R2Error.fromThrownValue(err));
+                return
+            }
         }
 
         async handleSettingsCallbacks(invokedSetting: any) {
@@ -613,7 +595,7 @@ import CategoryFilterModal from '../components/modals/CategoryFilterModal.vue';
                     this.showDependencyStrings = true;
                     break;
                 case "ChangeDataFolder":
-                    this.changeDataFolder();
+                    await this.changeDataFolder();
                     break;
                 case "CleanCache":
                     CacheUtil.clean();

src/providers/ror2/system/DataFolderProvider.ts

@@ -0,0 +1,25 @@
+import ProviderUtils from '../../generic/ProviderUtils';
+
+export abstract class DataFolderProvider {
+    public abstract readonly overrideFile: string;
+
+    private static provider: () => DataFolderProvider;
+
+    static provide(provided: () => DataFolderProvider): void {
+        this.provider = provided;
+    }
+
+    public static get instance(): DataFolderProvider {
+        if (DataFolderProvider.provider === undefined) {
+            ProviderUtils.throwNotProvidedError('DataFolderProvider');
+        }
+        return DataFolderProvider.provider();
+    }
+
+    public abstract showSelectionDialog(): Promise<string|null>;
+
+    public abstract throwForInvalidFolder(folderPath: string): Promise<void>;
+
+    public abstract writeOverrideFile(folderPath: string): Promise<void>;
+
+}

src/r2mm/system/DataFolderProviderImpl.ts

@@ -0,0 +1,73 @@
+import path from "path";
+
+import ManagerInformation from "../../_managerinf/ManagerInformation";
+import R2Error from "../../model/errors/R2Error";
+import FsProvider from "../../providers/generic/file/FsProvider";
+import { DataFolderProvider } from "../../providers/ror2/system/DataFolderProvider";
+import InteractionProvider from "../../providers/ror2/system/InteractionProvider";
+import PathResolver from "../../r2mm/manager/PathResolver";
+
+export class DataFolderProviderImpl extends DataFolderProvider {
+    readonly overrideFile: string = ".ddir.mm"
+
+    /***
+     * @returns folder path as string, null if user cancelled selection.
+     */
+    async showSelectionDialog(): Promise<string|null> {
+        const files = await InteractionProvider.instance.selectFolder({
+            title: `Select a new folder to store ${ManagerInformation.APP_NAME} data`,
+            defaultPath: PathResolver.ROOT,
+            buttonLabel: "Select data folder"
+        });
+
+        // User closed the dialog without selecting a folder.
+        if (files.length === 0) {
+            return null;
+        }
+
+        if (files.length === 1) {
+            return files[0];
+        }
+
+        // Shouldn't be possible to select multiple folders but someone always finds a way.
+        throw new R2Error("Select exactly one folder", `${files.length} items were selected.`);
+    }
+
+    async throwForInvalidFolder(folderPath: string): Promise<void> {
+        // Default DataFolder is always valid.
+        if (folderPath === PathResolver.APPDATA_DIR) {
+            return;
+        }
+
+        const filesInFolder = await FsProvider.instance.readdir(folderPath);
+        const hasOverrideFile = filesInFolder.some(
+            file => file.toLowerCase() === this.overrideFile
+        );
+
+        // Previously used DataFolders are valid.
+        if (hasOverrideFile) {
+            return;
+        }
+
+        // Empty folders are valid.
+        if (filesInFolder.length === 0) {
+            return;
+        }
+
+        throw new R2Error(
+            "Selected folder is not empty",
+            `${folderPath} contains ${filesInFolder.length} files.`,
+            "Select an empty folder or create a new one."
+        );
+    }
+
+    async writeOverrideFile(folderPath: string): Promise<void> {
+        const filePath = path.join(folderPath, this.overrideFile);
+
+        try {
+            await FsProvider.instance.writeFile(filePath, "");
+        } catch (err) {
+            throw R2Error.fromThrownValue(err, "Failed to change data folder");
+        }
+    }
+}