Single file format

novelwriter/config.py

@@ -26,6 +26,7 @@
 
 import sys
 import json
+import uuid
 import logging
 
 from time import time
@@ -45,6 +46,15 @@
 logger = logging.getLogger(__name__)
 
 
+def _ensureFolder(path: Path) -> None:
+    """Ensure a folder exists and handle name conflicts."""
+    if not path.is_dir():
+        if path.exists():
+            path.rename(path.with_stem(f"{path.stem}-{uuid.uuid4()}"))
+        path.mkdir()
+    return
+
+
 class Config:
 
     LANG_NW   = 1
@@ -379,10 +389,13 @@ def rpxInt(self, value: int) -> int:
         """Un-scale fixed gui sizes by the screen scale factor."""
         return int(value/self.guiScale)
 
-    def dataPath(self, target: str | None = None) -> Path:
+    def dataPath(self, target: str | None = None, mkdir: bool = False) -> Path:
         """Return a path in the data folder."""
         if isinstance(target, str):
-            return self._dataPath / target
+            targetPath = self._dataPath / target
+            if mkdir:
+                _ensureFolder(targetPath)
+            return targetPath
         return self._dataPath
 
     def assetPath(self, target: str | None = None) -> Path:
@@ -466,15 +479,17 @@ def initConfig(self, confPath: str | Path | None = None,
 
         # If the config and data folders don't exist, create them
         # This assumes that the os config and data folders exist
-        self._confPath.mkdir(exist_ok=True)
-        self._dataPath.mkdir(exist_ok=True)
+        _ensureFolder(self._confPath)
+        _ensureFolder(self._dataPath)
 
         # Also create the syntax, themes and icons folders if possible
         if self._dataPath.is_dir():
-            (self._dataPath / "cache").mkdir(exist_ok=True)
-            (self._dataPath / "icons").mkdir(exist_ok=True)
-            (self._dataPath / "syntax").mkdir(exist_ok=True)
-            (self._dataPath / "themes").mkdir(exist_ok=True)
+            _ensureFolder(self._dataPath / "temp")
+            _ensureFolder(self._dataPath / "cache")
+            _ensureFolder(self._dataPath / "icons")
+            _ensureFolder(self._dataPath / "syntax")
+            _ensureFolder(self._dataPath / "themes")
+            _ensureFolder(self._dataPath / "projects")
 
         # Check if config file exists, and load it. If not, we save defaults
         if (self._confPath / nwFiles.CONF_FILE).is_file():

novelwriter/constants.py

@@ -103,8 +103,8 @@ class nwFiles:
     RECENT_FILE = "recentProjects.json"
 
     # Project Root Files
+    PROJ_ARCH   = "project.xml"
     PROJ_FILE   = "nwProject.nwx"
-    PROJ_BACKUP = "nwProject.bak"
     PROJ_LOCK   = "nwProject.lock"
     TOC_TXT     = "ToC.txt"
 

novelwriter/core/coretools.py

@@ -29,6 +29,7 @@
 import logging
 
 from typing import Iterable
+from pathlib import Path
 from functools import partial
 
 from PyQt5.QtCore import QCoreApplication
@@ -310,8 +311,14 @@ class ProjectBuilder:
 
     def __init__(self) -> None:
         self.tr = partial(QCoreApplication.translate, "NWProject")
+        self._path = None
         return
 
+    @property
+    def projPath(self) -> Path | None:
+        """The actual path of the project."""
+        return self._path
+
     ##
     #  Methods
     ##
@@ -327,6 +334,7 @@ def buildProject(self, data: dict) -> bool:
         popMinimal = data.get("popMinimal", True)
         popCustom = data.get("popCustom", False)
         popSample = data.get("popSample", False)
+        asArchive = data.get("asArchive", False)
 
         # Check if we're extracting the sample project. This is handled
         # differently as it isn't actually a new project, so we forward
@@ -340,9 +348,11 @@ def buildProject(self, data: dict) -> bool:
             return False
 
         project = NWProject()
-        if not project.storage.openProjectInPlace(projPath, newProject=True):
+        if not project.storage.createNewProject(projPath, asArchive):
             return False
 
+        self._path = project.storage.storagePath
+
         lblNewProject = self.tr("New Project")
         lblNewChapter = self.tr("New Chapter")
         lblNewScene   = self.tr("New Scene")
@@ -470,10 +480,17 @@ def _extractSampleProject(self, data: dict) -> bool:
             logger.error("No project path set for the example project")
             return False
 
+        projPath = Path(projPath).resolve()
         pkgSample = CONFIG.assetPath("sample.zip")
         if pkgSample.is_file():
             try:
-                shutil.unpack_archive(pkgSample, projPath)
+                if data.get("asArchive", False):
+                    targetPath = projPath.with_suffix(".nwproj")
+                    shutil.copy(pkgSample, targetPath)
+                    self._path = targetPath
+                else:
+                    shutil.unpack_archive(pkgSample, projPath)
+                    self._path = projPath
             except Exception as exc:
                 SHARED.error(self.tr(
                     "Failed to create a new example project."

novelwriter/core/project.py

@@ -26,6 +26,7 @@
 import json
 import logging
 
+from enum import Enum
 from time import time
 from typing import TYPE_CHECKING, Iterator
 from pathlib import Path
@@ -40,7 +41,7 @@
 from novelwriter.core.tree import NWTree
 from novelwriter.core.index import NWIndex
 from novelwriter.core.options import OptionState
-from novelwriter.core.storage import NWStorage
+from novelwriter.core.storage import NWStorage, NWStorageOpen
 from novelwriter.core.sessions import NWSessionLog
 from novelwriter.core.projectxml import ProjectXMLReader, ProjectXMLWriter, XMLReadState
 from novelwriter.core.projectdata import NWProjectData
@@ -55,6 +56,16 @@
 logger = logging.getLogger(__name__)
 
 
+class NWProjectState(Enum):
+
+    UNKNOWN  = 0
+    LOCKED   = 1
+    RECOVERY = 2
+    READY    = 3
+
+# END Enum NWProjectState
+
+
 class NWProject:
 
     def __init__(self) -> None:
@@ -69,9 +80,9 @@ def __init__(self) -> None:
 
         # Project Status
         self._langData = {}     # Localisation data
-        self._lockedBy = None   # Data on which computer has the project open
         self._changed  = False  # The project has unsaved changes
         self._valid    = False  # The project was successfully loaded
+        self._state    = NWProjectState.UNKNOWN
 
         # Internal Mapping
         self.tr = partial(QCoreApplication.translate, "NWProject")
@@ -125,12 +136,15 @@ def isValid(self) -> bool:
         """Return True if a project is loaded."""
         return self._valid
 
+    @property
+    def state(self) -> NWProjectState:
+        """Return the current project state."""
+        return self._state
+
     @property
     def lockStatus(self) -> list | None:
         """Return the project lock information."""
-        if isinstance(self._lockedBy, list) and len(self._lockedBy) == 4:
-            return self._lockedBy
-        return None
+        return self._storage.lockStatus
 
     @property
     def currentEditTime(self) -> int:
@@ -219,29 +233,24 @@ def openProject(self, projPath: str | Path, clearLock: bool = False) -> bool:
         build the tree of project items.
         """
         logger.info("Opening project: %s", projPath)
-        if not self._storage.openProjectInPlace(projPath):
-            SHARED.error(self.tr("Could not open project with path: {0}").format(projPath))
-            return False
 
-        # Project Lock
-        # ============
+        status = self._storage.initProjectLocation(projPath, clearLock)
+        if status != NWStorageOpen.READY:
+            if status == NWStorageOpen.UNKOWN:
+                SHARED.error(self.tr("Not a known project file format."))
+            elif status == NWStorageOpen.NOT_FOUND:
+                SHARED.error(self.tr("Project file not found."))
+            elif status == NWStorageOpen.LOCKED:
+                self._state = NWProjectState.LOCKED
+            elif status == NWStorageOpen.RECOVERY:
+                self._state = NWProjectState.RECOVERY
+            elif status == NWStorageOpen.FAILED:
+                SHARED.error(self.tr("Failed to open project."), exc=self._storage.exc)
+            print("oops", status)
+            return False
 
-        if clearLock:
-            self._storage.clearLockFile()
-
-        lockStatus = self._storage.readLockFile()
-        if len(lockStatus) > 0:
-            if lockStatus[0] == "ERROR":
-                logger.warning("Failed to check lock file")
-            else:
-                logger.error("Project is locked, so not opening")
-                self._lockedBy = lockStatus
-                return False
-        else:
-            logger.debug("Project is not locked")
-
-        # Open The Project XML File
-        # =========================
+        # Read Project XML
+        # ================
 
         xmlReader = self._storage.getXmlReader()
         if not isinstance(xmlReader, ProjectXMLReader):
@@ -250,9 +259,7 @@ def openProject(self, projPath: str | Path, clearLock: bool = False) -> bool:
         self._data = NWProjectData(self)
         projContent = []
         xmlParsed = xmlReader.read(self._data, projContent)
-
         appVersion = xmlReader.appVersion or self.tr("Unknown")
-
         if not xmlParsed:
             if xmlReader.state == XMLReadState.NOT_NWX_FILE:
                 SHARED.error(self.tr(
@@ -323,9 +330,9 @@ def openProject(self, projPath: str | Path, clearLock: bool = False) -> bool:
 
         self.updateWordCounts()
         self._session.startSession()
-        self._storage.writeLockFile()
         self.setProjectChanged(False)
         self._valid = True
+        self._state = NWProjectState.READY
 
         SHARED.newStatusMessage(self.tr("Opened Project: {0}").format(self._data.name))
 
@@ -367,29 +374,30 @@ def saveProject(self, autoSave: bool = False) -> bool:
         # Save other project data
         self._options.saveSettings()
         self._index.saveIndex()
-        self._storage.runPostSaveTasks(autoSave=autoSave)
+        self._storage.runPostSaveTasks()
 
         # Update recent projects
-        storePath = self._storage.storagePath
-        if storePath:
+        if storagePath := self._storage.storagePath:
             CONFIG.recentProjects.update(
-                storePath, self._data.name, sum(self._data.currCounts), saveTime
+                storagePath, self._data.name, sum(self._data.currCounts), saveTime
             )
 
-        self._storage.writeLockFile()
         SHARED.newStatusMessage(self.tr("Saved Project: {0}").format(self._data.name))
         self.setProjectChanged(False)
 
         return True
 
-    def closeProject(self, idleTime: float = 0.0) -> None:
-        """Close the project."""
-        logger.info("Closing project")
-        self._options.saveSettings()
+    def saveProjectMeta(self, idleTime: float) -> None:
+        """Save project meta data. Needed before closing the project."""
         self._tree.writeToCFile()
+        self._options.saveSettings()
         self._session.appendSession(idleTime)
+        return
+
+    def closeProject(self) -> None:
+        """Close the project."""
+        logger.info("Closing project")
         self._storage.closeSession()
-        self._lockedBy = None
         return
 
     def backupProject(self, doNotify: bool) -> bool:
@@ -418,10 +426,13 @@ def backupProject(self, doNotify: bool) -> bool:
             return False
 
         timeStamp = formatTimeStamp(time(), fileSafe=True)
-        archName = baseDir / f"{cleanName} {timeStamp}.zip"
-        if self._storage.zipIt(archName, compression=2):
-            size = formatInt(archName.stat().st_size)
+        archName = baseDir / f"{cleanName} {timeStamp}.nwproj"
+        if self._storage.zipIt(archName, compression=2, isBackup=True):
             if doNotify:
+                try:
+                    size = formatInt(archName.stat().st_size)
+                except Exception:
+                    size = -1
                 SHARED.info(
                     self.tr("Created a backup of your project of size {0}B.").format(size),
                     info=self.tr("Path: {0}").format(str(backupPath))

novelwriter/core/projectxml.py

@@ -38,7 +38,6 @@
     checkBool, checkInt, checkString, checkStringNone, formatTimeStamp,
     hexToInt, simplified, xmlIndent, yesNo
 )
-from novelwriter.constants import nwFiles
 
 if TYPE_CHECKING:  # pragma: no cover
     from novelwriter.core.status import NWStatus
@@ -558,9 +557,8 @@ def write(self, data: NWProjectData, content: list, saveTime: float, editTime: i
             xName.text = item["name"]
 
         # Write the XML tree to file
-        saveFile = self._path / nwFiles.PROJ_FILE
-        tempFile = saveFile.with_suffix(".tmp")
-        backFile = saveFile.with_suffix(".bak")
+        tempFile = self._path.with_suffix(".tmp")
+        backFile = self._path.with_suffix(".bak")
         try:
             xml = ET.ElementTree(xRoot)
             xmlIndent(xml)
@@ -572,9 +570,9 @@ def write(self, data: NWProjectData, content: list, saveTime: float, editTime: i
         # If we're here, the file was successfully saved,
         # so let's sort out the temps and backups
         try:
-            if saveFile.exists():
-                saveFile.replace(backFile)
-            tempFile.replace(saveFile)
+            if self._path.exists():
+                self._path.replace(backFile)
+            tempFile.replace(self._path)
         except Exception as exc:
             self._error = exc
             return False