novelWriter 2.2rc1__py3-none-any.whl → 2.3__py3-none-any.whl

novelwriter/core/storage.py

@@ -6,7 +6,7 @@ File History:
 Created: 2022-11-01 [2.0rc2] NWStorage
 
 This file is a part of novelWriter
-Copyright 2018–2023, Veronica Berglyd Olsen
+Copyright 2018–2024, Veronica Berglyd Olsen
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -26,6 +26,7 @@ from __future__ import annotations
 import json
 import logging
 
+from enum import Enum
 from time import time
 from typing import TYPE_CHECKING
 from pathlib import Path
@@ -45,6 +46,26 @@ if TYPE_CHECKING:  # pragma: no cover
 logger = logging.getLogger(__name__)
 
 
+class NWStorageOpen(Enum):
+
+    UNKOWN    = 0
+    NOT_FOUND = 1
+    LOCKED    = 2
+    FAILED    = 3
+    READY     = 4
+
+# END Enum NWStorageOpen
+
+
+class NWStorageCreate(Enum):
+
+    NOT_EMPTY = 0
+    OS_ERROR  = 1
+    READY     = 2
+
+# END Enum NWStorageCreate
+
+
 class NWStorage:
     """Core: Project Storage Class
 
@@ -60,7 +81,10 @@ class NWStorage:
         self._storagePath = None
         self._runtimePath = None
         self._lockFilePath = None
+        self._lockedBy = None
         self._openMode = self.MODE_INACTIVE
+        self._ready = False
+        self._exception = None
         return
 
     def clear(self) -> None:
@@ -69,6 +93,7 @@ class NWStorage:
         self._runtimePath = None
         self._lockFilePath = None
         self._openMode = self.MODE_INACTIVE
+        self._ready = False
         return
 
     ##
@@ -77,12 +102,12 @@ class NWStorage:
 
     @property
     def storagePath(self) -> Path | None:
-        """Get the path where the project is saved."""
+        """Return the path where the project is stored."""
         return self._storagePath
 
     @property
     def runtimePath(self) -> Path | None:
-        """Get the path where the project is saved at runtime."""
+        """Return the path where the project is stored at runtime."""
         return self._runtimePath
 
     @property
@@ -97,44 +122,127 @@ class NWStorage:
         logger.error("Content path cannot be resolved")
         return None
 
+    @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
+
+    @property
+    def exc(self) -> Exception | None:
+        """Return the latest exception of the storage instance."""
+        return self._exception
+
     ##
     #  Core Methods
     ##
 
     def isOpen(self) -> bool:
         """Check if the storage location is open."""
-        return self._runtimePath is not None
+        return self._ready and self._runtimePath is not None
 
-    def openProjectInPlace(self, path: str | Path, newProject: bool = False) -> bool:
-        """Open a novelWriter project in-place. That is, it is opened
-        directly from a project folder.
-        """
+    def createNewProject(self, path: str | Path) -> NWStorageCreate:
+        """Create a new project at the given location."""
         inPath = Path(path).resolve()
-        if inPath.is_file():
-            # The path should not point to an existing file,
-            # but it can point to a folder containing files
-            inPath = inPath.parent
-
-        if not (inPath.is_dir() or newProject):
-            # If the project is not new, the folder must already exist.
-            return False
+        if inPath.is_dir() and len(list(inPath.iterdir())) > 0:
+            logger.error("Folder is not empty: %s", inPath)
+            return NWStorageCreate.NOT_EMPTY
 
         self._storagePath = inPath
         self._runtimePath = inPath
         self._lockFilePath = inPath / nwFiles.PROJ_LOCK
         self._openMode = self.MODE_INPLACE
 
-        if not self._prepareStorage(checkLegacy=True, newProject=newProject):
+        basePath = self._runtimePath
+        metaPath = basePath / "meta"
+        contPath = basePath / "content"
+        try:
+            basePath.mkdir(exist_ok=True)
+            metaPath.mkdir(exist_ok=True)
+            contPath.mkdir(exist_ok=True)
+        except Exception as exc:
+            self._exception = exc
+            logger.error("Failed to create project folders", exc_info=exc)
             self.clear()
-            return False
+            return NWStorageCreate.OS_ERROR
 
-        return True
+        self._ready = True
 
-    def openProjectArchive(self, path: str | Path) -> bool:  # pragma: no cover
-        """Open the project from a single file.
-        Placeholder for later implementation. See #977.
-        """
-        return False
+        return NWStorageCreate.READY
+
+    def initProjectStorage(self, path: str | Path, clearLock: bool = False) -> NWStorageOpen:
+        """Initialise a novelWriter project location."""
+        inPath = Path(path).resolve()
+
+        # Initialise Storage Instance
+        # ===========================
+
+        # Check what we're opening. Only two options are allowed:
+        # 1. A folder with an nwProject.nwx file in it (not home)
+        # 2. A full path to an nwProject.nwx file
+        if inPath.is_dir() and inPath != Path.home().resolve():
+            nwxFile = inPath / nwFiles.PROJ_FILE
+        elif inPath.is_file():
+            if inPath.name == nwFiles.PROJ_FILE:
+                nwxFile = inPath
+            else:
+                logger.error("Not a novelWriter project")
+                return NWStorageOpen.UNKOWN
+        else:
+            logger.error("Not found: %s", inPath)
+            return NWStorageOpen.NOT_FOUND
+
+        if not nwxFile.exists():
+            # The .nwx file must exist to continue
+            logger.error("Not found: %s", nwxFile)
+            return NWStorageOpen.NOT_FOUND
+
+        nwxPath = nwxFile.parent
+
+        self._storagePath = nwxPath
+        self._runtimePath = nwxPath
+        self._lockFilePath = nwxPath / nwFiles.PROJ_LOCK
+        self._openMode = self.MODE_INPLACE
+
+        # Check Project Lock
+        # ==================
+
+        if clearLock:
+            self._clearLockFile()
+
+        self._readLockFile()
+        if self._lockedBy:
+            logger.error("Project is locked, so not opening")
+            return NWStorageOpen.LOCKED
+        else:
+            logger.debug("Project is not locked")
+
+        # Prepare Folder
+        # ==============
+
+        basePath = self._runtimePath
+        metaPath = basePath / "meta"
+        contPath = basePath / "content"
+        try:
+            metaPath.mkdir(exist_ok=True)
+            contPath.mkdir(exist_ok=True)
+        except Exception as exc:
+            logger.error("Failed to create project folders", exc_info=exc)
+            self.clear()
+            return NWStorageOpen.FAILED
+
+        # Check for legacy data folders
+        legacy = _LegacyStorage(self._project)
+        legacy.deprecatedFiles(basePath)
+        for child in basePath.iterdir():
+            if child.is_dir() and child.name.startswith("data_"):
+                legacy.legacyDataFolder(basePath, child)
+
+        self._writeLockFile()
+        self._ready = True
+
+        return NWStorageOpen.READY
 
     def runPostSaveTasks(self, autoSave: bool = False) -> bool:  # pragma: no cover
         """Run tasks after the project has been saved.
@@ -147,7 +255,7 @@ class NWStorage:
 
     def closeSession(self) -> None:
         """Run tasks related to closing the session."""
-        self.clearLockFile()
+        self._clearLockFile()
         self.clear()
         return
 
@@ -157,26 +265,25 @@ class NWStorage:
 
     def getXmlReader(self) -> ProjectXMLReader | None:
         """Return a properly configured ProjectXMLReader instance."""
-        if isinstance(self._runtimePath, Path):
-            projFile = self._runtimePath / nwFiles.PROJ_FILE
-            return ProjectXMLReader(projFile)
+        if isinstance(self._runtimePath, Path) and self._ready:
+            return ProjectXMLReader(self._runtimePath / nwFiles.PROJ_FILE)
         return None
 
     def getXmlWriter(self) -> ProjectXMLWriter | None:
         """Return a properly configured ProjectXMLWriter instance."""
-        if isinstance(self._runtimePath, Path):
-            return ProjectXMLWriter(self._runtimePath)
+        if isinstance(self._runtimePath, Path) and self._ready:
+            return ProjectXMLWriter(self._runtimePath / nwFiles.PROJ_FILE)
         return None
 
     def getDocument(self, tHandle: str | None) -> NWDocument:
         """Return a document wrapper object."""
-        if isinstance(self._runtimePath, Path):
+        if isinstance(self._runtimePath, Path) and self._ready:
             return NWDocument(self._project, tHandle)
         return NWDocument(self._project, None)
 
     def getMetaFile(self, fileName: str) -> Path | None:
         """Return the path to a file in the project meta folder."""
-        if isinstance(self._runtimePath, Path):
+        if isinstance(self._runtimePath, Path) and self._ready:
             return self._runtimePath / "meta" / fileName
         return None
 
@@ -190,59 +297,6 @@ class NWStorage:
             if item.suffix == ".nwd" and isHandle(item.stem)
         ] if contentPath else []
 
-    def readLockFile(self) -> list[str]:
-        """Read the project lock file."""
-        if self._lockFilePath is None:
-            return ["ERROR"]
-
-        if not self._lockFilePath.exists():
-            return []
-
-        try:
-            lines = self._lockFilePath.read_text(encoding="utf-8").strip().split(";")
-        except Exception:
-            logger.error("Failed to read project lockfile")
-            logException()
-            return ["ERROR"]
-
-        if len(lines) != 4:
-            return ["ERROR"]
-
-        return lines
-
-    def writeLockFile(self) -> bool:
-        """Write the project lock file."""
-        if self._lockFilePath is None:
-            return False
-
-        data = [
-            CONFIG.hostName, CONFIG.osType,
-            CONFIG.kernelVer, str(int(time()))
-        ]
-        try:
-            self._lockFilePath.write_text(";".join(data), encoding="utf-8")
-        except Exception:
-            logger.error("Failed to write project lockfile")
-            logException()
-            return False
-
-        return True
-
-    def clearLockFile(self) -> bool:
-        """Remove the lock file, if it exists."""
-        if self._lockFilePath is None:
-            return False
-
-        if self._lockFilePath.exists():
-            try:
-                self._lockFilePath.unlink()
-            except Exception:
-                logger.error("Failed to remove project lockfile")
-                logException()
-                return False
-
-        return True
-
     def zipIt(self, target: str | Path, compression: int | None = None) -> bool:
         """Zip the content of the project at its runtime location into a
         zip file. This process will only grab files that are supposed to
@@ -257,7 +311,6 @@ class NWStorage:
         baseCont = basePath / "content"
         files = [
             (basePath / nwFiles.PROJ_FILE,   nwFiles.PROJ_FILE),
-            (basePath / nwFiles.PROJ_BACKUP, nwFiles.PROJ_BACKUP),
             (baseMeta / nwFiles.BUILDS_FILE, f"meta/{nwFiles.BUILDS_FILE}"),
             (baseMeta / nwFiles.INDEX_FILE,  f"meta/{nwFiles.INDEX_FILE}"),
             (baseMeta / nwFiles.OPTS_FILE,   f"meta/{nwFiles.OPTS_FILE}"),
@@ -279,7 +332,7 @@ class NWStorage:
                         zipObj.write(srcPath, zipPath)
                         logger.debug("Added: %s", zipPath)
         except Exception:
-            logger.error("Failed to create acrhive")
+            logger.error("Failed to create archive")
             logException()
             return False
 
@@ -289,59 +342,48 @@ class NWStorage:
     #  Internal Functions
     ##
 
-    def _prepareStorage(self, checkLegacy: bool = True, newProject: bool = False) -> bool:
-        """Prepare the storage area for the project."""
-        path = self._runtimePath
-        if not isinstance(path, Path):
-            logger.error("No path set")
-            self.clear()
-            return False
+    def _readLockFile(self) -> None:
+        """Read the project lock file."""
+        self._lockedBy = None
+        path = self._lockFilePath
+        if isinstance(path, Path) and path.exists():
+            try:
+                self._lockedBy = path.read_text(encoding="utf-8").strip().split(";")
+            except Exception:
+                logger.error("Failed to read project lockfile")
+                logException()
+                self._lockedBy = ["ERROR", "ERROR", "ERROR", "ERROR"]
+                return
+        return
 
-        if path == Path.home().absolute():
-            logger.error("Cannot use the user's home path as the root of a project")
-            self.clear()
+    def _writeLockFile(self) -> bool:
+        """Write the project lock file."""
+        if self._lockFilePath is None:
             return False
-
-        if newProject:
-            # If it's a new project, we check that there is no existing
-            # project in the selected path.
-            if path.exists() and len(list(path.iterdir())) > 0:
-                logger.error("The new project folder is not empty")
-                self.clear()
-                return False
-
-        # The folder is not required to exist, as it could be a new
-        # project, so we make sure it does. Then we add subfolders.
         try:
-            path.mkdir(exist_ok=True)
-            (path / "content").mkdir(exist_ok=True)
-            (path / "meta").mkdir(exist_ok=True)
-        except Exception as exc:
-            logger.error("Failed to create required project folders", exc_info=exc)
-            self.clear()
+            self._lockFilePath.write_text(
+                f"{CONFIG.hostName};{CONFIG.osType};{CONFIG.kernelVer};{int(time())}",
+                encoding="utf-8"
+            )
+        except Exception:
+            logger.error("Failed to write project lockfile")
+            logException()
             return False
-
-        if not checkLegacy:
-            # The legacy content check is only needed for project folder
-            # storage, so if it is not expected to be that, there's no
-            # need for the remaining checks.
-            return True
-
-        legacy = _LegacyStorage(self._project)
-
-        # Check for legacy data folders
-        for child in path.iterdir():
-            if child.is_dir() and child.name.startswith("data_"):
-                legacy.legacyDataFolder(path, child)
-
-        # Check for no longer used files, and delete them
-        legacy.deprecatedFiles(path)
-
         return True
 
-    ##
-    #  Legacy Project Data Handlers
-    ##
+    def _clearLockFile(self) -> bool:
+        """Remove the lock file, if it exists."""
+        if self._lockFilePath is None:
+            return False
+        if self._lockFilePath.exists():
+            try:
+                self._lockFilePath.unlink()
+            except Exception:
+                logger.error("Failed to remove project lockfile")
+                logException()
+                return False
+        self._lockedBy = None
+        return True
 
 # END Class NWStorage
 
@@ -350,7 +392,7 @@ class _LegacyStorage:
     """Core: Legacy Storage Converter Utils
 
     A class with various functions to convert old file formats and
-    file/folder layout to the current project format.
+    file/folder layouts to the current project format.
     """
 
     def __init__(self, project: NWProject) -> None:
@@ -359,7 +401,8 @@ class _LegacyStorage:
 
     def legacyDataFolder(self, path: Path, child: Path) -> None:
         """Handle the content of a legacy data folder from a version 1.0
-        project.
+        project. This format had 16 data folders where there now is only
+        one content folder.
         """
         logger.info("Processing legacy data folder: %s", path)
 
@@ -411,6 +454,7 @@ class _LegacyStorage:
             path / "meta" / nwFiles.OPTS_FILE
         )
 
+        # Delete removed files
         remove = [
             path / "meta" / "tagsIndex.json",          # Renamed in 2.1 Beta 1
             path / "meta" / "mainOptions.json",        # Replaced in 0.5
@@ -422,6 +466,7 @@ class _LegacyStorage:
             path / "cache" / "prevBuild.json",         # Dropped in 2.1 Beta 1
             path / "cache",                            # Dropped in 2.1 Beta 1
             path / "ToC.json",                         # Dropped in 1.0 RC 1
+            path / "nwProject.bak",                    # Dropped in 2.3 Beta 1
         ]
         for item in remove:
             if item.exists():
@@ -457,7 +502,6 @@ class _LegacyStorage:
 
             # Save dictionary and clean up old file
             userDict.save()
-            assert wordJson.exists()
             wordList.unlink()
 
         except Exception:
@@ -467,9 +511,7 @@ class _LegacyStorage:
         return
 
     def _convertOldLogFile(self, sessLog: Path, sessJson: Path) -> None:
-        """Convert the old text log file format to the new JSON Lines
-        format.
-        """
+        """Convert the old text log file format to JSON Lines."""
         if sessJson.exists() or not sessLog.exists():
             # If the new file already exists, we won't overwrite it
             return
@@ -508,7 +550,7 @@ class _LegacyStorage:
         return
 
     def _convertOldOptionsFile(self, optsOld: Path, optsNew: Path) -> None:
-        """Convert the old options state file format to the format."""
+        """Convert the old options state file format to new format."""
         if optsNew.exists() or not optsOld.exists():
             # If the new file already exists, we won't overwrite it
             return

novelwriter/core/tohtml.py

@@ -3,10 +3,10 @@ novelWriter – HTML Text Converter
 =================================
 
 File History:
-Created: 2019-05-07 [0.0.1]
+Created: 2019-05-07 [0.0.1] ToHtml
 
 This file is a part of novelWriter
-Copyright 2018–2023, Veronica Berglyd Olsen
+Copyright 2018–2024, Veronica Berglyd Olsen
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -338,7 +338,6 @@ class ToHtml(Tokenizer):
         data = {
             "meta": {
                 "projectName": self._project.data.name,
-                "novelTitle": self._project.data.title,
                 "novelAuthor": self._project.data.author,
                 "buildTime": int(timeStamp),
                 "buildTimeStr": formatTimeStamp(timeStamp),
@@ -485,7 +484,10 @@ class ToHtml(Tokenizer):
         result = f"<span class='tags'>{self._localLookup(nwLabels.KEY_NAME[bits[0]])}:</span> "
         if len(bits) > 1:
             if bits[0] == nwKeyWords.TAG_KEY:
-                result += f"<a name='tag_{bits[1]}'>{bits[1]}</a>"
+                one, two = self._project.index.parseValue(bits[1])
+                result += f"<a name='tag_{one}'>{one}</a>"
+                if two:
+                    result += f" | <span class='optional'>{two}</a>"
             else:
                 if self._genMode == self.M_PREVIEW:
                     result += ", ".join(f"<a href='#{bits[0][1:]}={t}'>{t}</a>" for t in bits[1:])