chore: do not create projects in user documents dir if not needed

abose · abose · commit ff90273ee231 · 2024-05-21T16:01:57.000+05:30
diff --git a/src/assets/new-project/assets/js/code-editor.js b/src/assets/new-project/assets/js/code-editor.js
@@ -214,7 +214,10 @@ function initCodeEditor() {
     };
     document.getElementById("exploreBtn").onclick = function() {
         Metrics.countEvent(Metrics.EVENT_TYPE.NEW_PROJECT, "main.Click", "games");
-        openProject(newProjectExtension.getExploreProjectPath());
+        newProjectExtension.setupExploreProject()
+            .then(()=>{
+                openProject(newProjectExtension.getExploreProjectPath());
+            }).catch(console.error);
     };
     document.getElementById("defaultProjectButton").onclick = function() {
         Metrics.countEvent(Metrics.EVENT_TYPE.NEW_PROJECT, "main.Click", "default-project");
diff --git a/src/extensionsIntegrated/Phoenix/default-projects.js b/src/extensionsIntegrated/Phoenix/default-projects.js
@@ -45,7 +45,7 @@ define(function (require, exports, module) {
             });
         });
     }
-    async function _setupExploreProject() {
+    async function setupExploreProject() {
         let exploreProjectPath = ProjectManager.getExploreProjectPath();
         let exists = await Phoenix.VFS.existsAsync(exploreProjectPath);
         if(!exists){
@@ -54,10 +54,18 @@ define(function (require, exports, module) {
         }
     }
 
+    exports.setupExploreProject = setupExploreProject;
+
     exports.init = async function () {
         if(Phoenix.firstBoot){
             _setupStartupProject();
         }
-        _setupExploreProject();
+        if(!Phoenix.isNativeApp) {
+            // in browsers, we do this as the user wont see the explore project in documents folder anyway and will
+            // help in improved ux of fast project open. In desktop, we got complaint that users document dir is getting
+            // polluted with unwanted projects, so we dont do this on desktop and only create this when user explicitly
+            // clicks to open explore project.
+            setupExploreProject();
+        }
     };
 });
diff --git a/src/extensionsIntegrated/Phoenix/main.js b/src/extensionsIntegrated/Phoenix/main.js
@@ -32,8 +32,6 @@ define(function (require, exports, module) {
         Strings      = require("strings"),
         Dialogs      = require("widgets/Dialogs"),
         NotificationUI  = require("widgets/NotificationUI"),
-        FileSystem  = require("filesystem/FileSystem"),
-        FileViewController  = require("project/FileViewController"),
         DefaultDialogs = require("widgets/DefaultDialogs");
 
     const PERSIST_STORAGE_DIALOG_DELAY_SECS = 60000;
diff --git a/src/extensionsIntegrated/Phoenix/new-project.js b/src/extensionsIntegrated/Phoenix/new-project.js
@@ -41,6 +41,7 @@ define(function (require, exports, module) {
         createProjectDialogue = require("text!./html/create-project-dialogue.html"),
         replaceProjectDialogue = require("text!./html/replace-project-dialogue.html"),
         replaceKeepProjectDialogue = require("text!./html/replace-keep-project-dialogue.html"),
+        defaultProjects   = require("./default-projects"),
         guidedTour = require("./guided-tour");
 
     EventDispatcher.makeEventDispatcher(exports);
@@ -386,6 +387,7 @@ define(function (require, exports, module) {
     exports.downloadAndOpenProject = downloadAndOpenProject;
     exports.showFolderSelect = showFolderSelect;
     exports.showErrorDialogue = showErrorDialogue;
+    exports.setupExploreProject = defaultProjects.setupExploreProject;
     exports.alreadyExists = window.Phoenix.VFS.existsAsync;
     exports.Metrics = Metrics;
     exports.EVENT_NEW_PROJECT_DIALOGUE_CLOSED = "newProjectDlgClosed";
diff --git a/src/phoenix/init_vfs.js b/src/phoenix/init_vfs.js
@@ -95,6 +95,17 @@ function _setupVFS(fsLib, pathLib){
                 });
             });
         },
+        ensureExistsDirAsync: async function (path) {
+            return new Promise((resolve, reject)=>{
+                Phoenix.VFS.ensureExistsDir(path, (err) =>{
+                    if(err){
+                        reject(err);
+                    } else {
+                        resolve();
+                    }
+                });
+            });
+        },
         /**
          * Converts a phoenix virtual serving url to absolute path in file system or null
          * http://localhost:8000/src/phoenix/vfs/fs/app/extensions/user/themesforbrackets/requirejs-config.json
@@ -127,17 +138,6 @@ function _setupVFS(fsLib, pathLib){
             }
             return window.fsServerUrl.slice(0, -1) + fullPath;
         },
-        ensureExistsDirAsync: async function (path) {
-            return new Promise((resolve, reject)=>{
-                Phoenix.VFS.ensureExistsDir(path, (err) =>{
-                    if(err){
-                        reject(err);
-                    } else {
-                        resolve();
-                    }
-                });
-            });
-        },
         exists: function (path, cb) {
             fs.stat(path, function (err, stats){
                 if (stats && !err) {
@@ -163,41 +163,6 @@ function _setupVFS(fsLib, pathLib){
     return Phoenix.VFS;
 }
 
-const _SAMPLE_HTML = `<!DOCTYPE html>
-<html>
-    <head>
-        <title>Phoenix Editor for the web</title>
-    </head>
- 
-    <body>
-        <h1>Welcome to Phoenix</h1>
-        <p> Modern, Open-source, IDE For The Web.</p>
-    </body>
-</html>`;
-
-// always resolves even if error
-function _tryCreateDefaultProject() {
-    // Create phoenix app dirs
-    // Create Phoenix default project if it doesnt exist
-    return new Promise((resolve)=>{
-        let projectDir = Phoenix.VFS.getDefaultProjectDir();
-        Phoenix.VFS.exists(projectDir, (exists)=>{
-            if(!exists){
-                Phoenix.VFS.ensureExistsDir(projectDir, (err)=>{
-                    if(err){
-                        logger.reportError(err, "Error creating default project");
-                    }
-                    let indexFile = Phoenix.VFS.path.normalize(`${projectDir}/index.html`);
-                    Phoenix.VFS.fs.writeFile(indexFile, _SAMPLE_HTML, 'utf8', ()=>{});
-                    resolve();
-                });
-                return;
-            }
-            resolve();
-        });
-    });
-}
-
 async function setupAppSupportAndExtensionsDir() {
     if(Phoenix.isNativeApp) {
         appSupportDIR = fs.getTauriVirtualPath(window._tauriBootVars.appLocalDir);
@@ -240,7 +205,6 @@ async function setupDocumentsDir() {
         userProjectsDir = documentsDIR;
     }
     await Phoenix.VFS.ensureExistsDirAsync(documentsDIR);
-    await _tryCreateDefaultProject();
     console.log("Documents dir setup done");
 }
 
diff --git a/src/project/ProjectManager.js b/src/project/ProjectManager.js
@@ -739,7 +739,11 @@ define(function (require, exports, module) {
      * @return {!string} fullPath reference
      */
     function getWelcomeProjectPath() {
-        return ProjectModel._getWelcomeProjectPath(Urls.GETTING_STARTED, Phoenix.VFS.getDefaultProjectDir());
+        return ProjectModel._ensureTrailingSlash(Phoenix.VFS.getDefaultProjectDir());
+    }
+
+    function _getPlaceholderProjectPath() {
+        return "/no_project_loaded";
     }
 
     function getExploreProjectPath() {
@@ -1115,52 +1119,132 @@ define(function (require, exports, module) {
             });
     }
 
-    function _loadProjectInternal(rootPath) {
+    function _loadExistingProject(rootEntry) {
+        const rootPath = rootEntry.fullPath;
         const result = new $.Deferred();
-        const rootEntry = FileSystem.getDirectoryForPath(rootPath);
-        rootEntry.exists(function (err, exists) {
-            if (exists) {
-                var projectRootChanged = (!model.projectRoot || !rootEntry) ||
-                    model.projectRoot.fullPath !== rootEntry.fullPath;
+        var projectRootChanged = (!model.projectRoot || !rootEntry) ||
+            model.projectRoot.fullPath !== rootEntry.fullPath;
 
-                // Success!
-                var perfTimerName = PerfUtils.markStart("Load Project: " + rootPath);
+        // Success!
+        var perfTimerName = PerfUtils.markStart("Load Project: " + rootPath);
 
-                _projectWarnedForTooManyFiles = false;
+        _projectWarnedForTooManyFiles = false;
 
-                _setProjectRoot(rootEntry).always(function () {
-                    model.setBaseUrl(PreferencesManager.getViewState("project.baseUrl", PreferencesManager.STATE_PROJECT_CONTEXT) || "");
+        _setProjectRoot(rootEntry).always(function () {
+            model.setBaseUrl(PreferencesManager.getViewState("project.baseUrl", PreferencesManager.STATE_PROJECT_CONTEXT) || "");
 
-                    if (projectRootChanged) {
-                        _reloadProjectPreferencesScope();
-                        PreferencesManager._setCurrentFile(rootPath);
-                    }
-                    _watchProjectRoot(rootPath);
+            if (projectRootChanged) {
+                _reloadProjectPreferencesScope();
+                PreferencesManager._setCurrentFile(rootPath);
+            }
+            _watchProjectRoot(rootPath);
 
-                    // If this is the most current welcome project, record it. In future launches, we want
-                    // to substitute the latest welcome project from the current build instead of using an
-                    // outdated one (when loading recent projects or the last opened project).
-                    if (rootPath === getWelcomeProjectPath()) {
-                        addWelcomeProjectPath(rootPath);
-                    }
+            // If this is the most current welcome project, record it. In future launches, we want
+            // to substitute the latest welcome project from the current build instead of using an
+            // outdated one (when loading recent projects or the last opened project).
+            if (rootPath === getWelcomeProjectPath()) {
+                addWelcomeProjectPath(rootPath);
+            }
 
-                    if (projectRootChanged) {
-                        // Allow asynchronous event handlers to finish before resolving result by collecting promises from them
-                        exports.trigger(EVENT_PROJECT_OPEN, model.projectRoot);
-                        result.resolve();
-                        exports.trigger(EVENT_AFTER_PROJECT_OPEN, model.projectRoot);
-                    } else {
-                        exports.trigger(EVENT_PROJECT_REFRESH, model.projectRoot);
-                        result.resolve();
+            if (projectRootChanged) {
+                // Allow asynchronous event handlers to finish before resolving result by collecting promises from them
+                exports.trigger(EVENT_PROJECT_OPEN, model.projectRoot);
+                result.resolve();
+                exports.trigger(EVENT_AFTER_PROJECT_OPEN, model.projectRoot);
+            } else {
+                exports.trigger(EVENT_PROJECT_REFRESH, model.projectRoot);
+                result.resolve();
+            }
+            let projectLoadTime = PerfUtils.addMeasurement(perfTimerName);
+            Metrics.valueEvent(Metrics.EVENT_TYPE.PERFORMANCE, "projectLoad",
+                "timeMs", Number(projectLoadTime));
+        });
+        return result.promise();
+    }
+
+        const _SAMPLE_HTML = `<!DOCTYPE html>
+<html>
+    <head>
+        <title>Phoenix Editor for the web</title>
+    </head>
+
+    <body>
+        <h1>Welcome to Phoenix</h1>
+        <p> Modern, Open-source, IDE For The Web.</p>
+    </body>
+</html>`;
+
+    function _createDefaultProject() {
+        // Create phoenix app dirs
+        // Create Phoenix default project if it doesnt exist
+        return new Promise((resolve, reject)=>{
+            let projectDir = getWelcomeProjectPath();
+            Phoenix.VFS.exists(projectDir, (exists)=>{
+                if(exists) {
+                    resolve();
+                    return;
+                }
+                Phoenix.VFS.ensureExistsDir(projectDir, (err)=>{
+                    if(err){
+                        window.logger.reportError(err, "Error creating default project");
+                        reject(err);
+                        return;
                     }
-                    let projectLoadTime = PerfUtils.addMeasurement(perfTimerName);
-                    Metrics.valueEvent(Metrics.EVENT_TYPE.PERFORMANCE, "projectLoad",
-                        "timeMs", Number(projectLoadTime));
+                    let indexFile = Phoenix.VFS.path.normalize(`${projectDir}/index.html`);
+                    Phoenix.VFS.fs.writeFile(indexFile, _SAMPLE_HTML, 'utf8', ()=>{});
+                    resolve();
                 });
+            });
+        });
+    }
+
+    function _loadWelcomeProject(welcomeProjectPath) {
+        const result = new $.Deferred();
+        const rootEntry = FileSystem.getDirectoryForPath(welcomeProjectPath);
+        function _loadRootEntry() {
+            _loadExistingProject(rootEntry)
+                .done(result.resolve)
+                .fail(result.reject);
+        }
+        rootEntry.exists(function (err, exists) {
+            if (exists) {
+                _loadRootEntry();
+            } else {
+                // create the welcome project
+                _createDefaultProject()
+                    .then(_loadRootEntry)
+                    .catch(()=>{
+                        // default project could not be created. As a last ditch effort to continue boot, we will
+                        // use a vfs path `/no_project_loaded` to continue boot.
+                        Phoenix.VFS.ensureExistsDir(_getPlaceholderProjectPath(), (placeHolderErr)=>{
+                            if(placeHolderErr){
+                                window.logger.reportError(placeHolderErr, "Error creating /no_project_loaded");
+                                alert("Unrecoverable error, startup project could not be created.");
+                                return;
+                            }
+                            const placeholderProject = FileSystem.getDirectoryForPath(_getPlaceholderProjectPath());
+                            _loadExistingProject(placeholderProject)
+                                .done(result.resolve)
+                                .fail(result.reject);
+                        });
+                    });
+            }
+        });
+        return result.promise();
+    }
+
+    function _loadProjectInternal(rootPath) {
+        const result = new $.Deferred();
+        const rootEntry = FileSystem.getDirectoryForPath(rootPath);
+        rootEntry.exists(function (err, exists) {
+            if (exists) {
+                _loadExistingProject(rootEntry)
+                    .done(result.resolve)
+                    .fail(result.reject);
             } else {
                 console.error("error loading project");
                 exports.trigger(EVENT_PROJECT_OPEN_FAILED, rootPath);
-                _showErrorDialog(ERR_TYPE_LOADING_PROJECT_NATIVE, true, err || FileSystemError.NOT_FOUND, rootPath)
+                _showErrorDialog(ERR_TYPE_LOADING_PROJECT_NATIVE, true, FileSystemError.NOT_FOUND, rootPath)
                     .done(function () {
                         // Reset _projectRoot to null so that the following _loadProject call won't
                         // run the 'beforeProjectClose' event a second time on the original project,
@@ -1182,7 +1266,6 @@ define(function (require, exports, module) {
                     });
             }
         });
-
         return result.promise();
     }
 
@@ -1223,8 +1306,10 @@ define(function (require, exports, module) {
             PreferencesManager._reloadUserPrefs(model.projectRoot);
             exports.trigger(EVENT_PROJECT_CLOSE, model.projectRoot);
         }
-
-        // Point at a real folder structure on local disk
+        if(rootPath === getWelcomeProjectPath()) {
+            // welcome project path is always guaranteed to be present!
+            return _loadWelcomeProject(rootPath);
+        }
         return _loadProjectInternal(rootPath);
     }
 
@@ -1945,17 +2030,22 @@ define(function (require, exports, module) {
     function _flagProjectNotExitedSafely(projectRootPath) {
         // we store this in local storage as these checks happen in app exit/startup flows where
         // phstore is not reliable. It's ok to lose this data.
-        localStorage.setItem(UNSAFE_PROJECT_EXIT_PREFIX+projectRootPath, "true");
+        PhStore.setItem(UNSAFE_PROJECT_EXIT_PREFIX+projectRootPath, true);
+        PhStore.persistDBForReboot(); // promise is ignored here.
     }
     function _flagProjectExitedSafely(projectRootPath) {
-        localStorage.removeItem(UNSAFE_PROJECT_EXIT_PREFIX+projectRootPath);
+        PhStore.removeItem(UNSAFE_PROJECT_EXIT_PREFIX+projectRootPath);
     }
     function _isProjectSafeToStartup(projectRootPath) {
         // In some cases, For eg: user tries to open a whole drive with phcode (or any project that makes phcode crash),
         // phoenix may get stuck and never open again with the bad project as we try to open the same bad project
         // on restart. So we keep a safe exit flag with each project. We only start the project on boot if it has
         // been marked safe at previous exit or project switch. So on unsafe exit, the default project will be opened.
-        const unsafeExit = (localStorage.getItem(UNSAFE_PROJECT_EXIT_PREFIX+projectRootPath) === "true");
+        const unsafeExit = (PhStore.getItem(UNSAFE_PROJECT_EXIT_PREFIX+projectRootPath) === true);
+        if(unsafeExit){
+            console.error(`Project ${projectRootPath} marked as not safe to startup during`+
+                `previous exit. Starting default project`);
+        }
         return !unsafeExit;
     }
 
diff --git a/src/project/ProjectModel.js b/src/project/ProjectModel.js
diff --git a/src/storage.js b/src/storage.js
diff --git a/test/spec/ProjectModel-test.js b/test/spec/ProjectModel-test.js
