novelWriter 2.5.2__py3-none-any.whl → 2.6__py3-none-any.whl

novelwriter/core/coretools.py

@@ -9,7 +9,7 @@ Created: 2022-11-03 [2.0rc2] ProjectBuilder
 Created: 2023-07-20 [2.1b1]  DocDuplicator
 
 This file is a part of novelWriter
-Copyright 2018–2024, Veronica Berglyd Olsen
+Copyright (C) 2022 Veronica Berglyd Olsen and novelWriter contributors
 
 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
@@ -27,6 +27,7 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 
 import logging
+import re
 import shutil
 
 from collections.abc import Iterable
@@ -34,11 +35,11 @@ from functools import partial
 from pathlib import Path
 from zipfile import ZipFile, is_zipfile
 
-from PyQt5.QtCore import QCoreApplication, QRegularExpression
+from PyQt5.QtCore import QCoreApplication
 
 from novelwriter import CONFIG, SHARED
 from novelwriter.common import isHandle, minmax, simplified
-from novelwriter.constants import nwConst, nwFiles, nwItemClass
+from novelwriter.constants import nwConst, nwFiles, nwItemClass, nwStats
 from novelwriter.core.item import NWItem
 from novelwriter.core.project import NWProject
 from novelwriter.core.storage import NWStorageCreate
@@ -55,10 +56,17 @@ class DocMerger:
     def __init__(self, project: NWProject) -> None:
         self._project = project
         self._error = ""
-        self._targetDoc = None
-        self._targetText = []
+        self._target = None
+        self._text = []
         return
 
+    @property
+    def targetHandle(self) -> str | None:
+        """Get the handle of the target document."""
+        if self._target:
+            return self._target.itemHandle
+        return None
+
     ##
     #  Methods
     ##
@@ -71,63 +79,56 @@ class DocMerger:
         """Set the target document for the merging. Calling this
         function resets the class.
         """
-        self._targetDoc = tHandle
-        self._targetText = []
+        self._target = self._project.tree[tHandle]
+        self._text = []
         return
 
-    def newTargetDoc(self, srcHandle: str, docLabel: str) -> str | None:
+    def newTargetDoc(self, sHandle: str, label: str) -> None:
         """Create a brand new target document based on a source handle
         and a new doc label. Calling this function resets the class.
         """
-        srcItem = self._project.tree[srcHandle]
-        if srcItem is None or srcItem.itemParent is None:
-            return None
-
-        newHandle = self._project.newFile(docLabel, srcItem.itemParent)
-        newItem = self._project.tree[newHandle]
-        if isinstance(newItem, NWItem):
-            newItem.setLayout(srcItem.itemLayout)
-            newItem.setStatus(srcItem.itemStatus)
-            newItem.setImport(srcItem.itemImport)
-
-        self._targetDoc = newHandle
-        self._targetText = []
-
-        return newHandle
+        sItem = self._project.tree[sHandle]
+        if sItem and sItem.itemParent:
+            tHandle = self._project.newFile(label, sItem.itemParent)
+            if nwItem := self._project.tree[tHandle]:
+                nwItem.setLayout(sItem.itemLayout)
+                nwItem.setStatus(sItem.itemStatus)
+                nwItem.setImport(sItem.itemImport)
+                nwItem.notifyToRefresh()
+                self._target = nwItem
+                self._text = []
+        return
 
-    def appendText(self, srcHandle: str, addComment: bool, cmtPrefix: str) -> bool:
+    def appendText(self, sHandle: str, addComment: bool, cmtPrefix: str) -> None:
         """Append text from an existing document to the text buffer."""
-        srcItem = self._project.tree[srcHandle]
-        if srcItem is None:
-            return False
-
-        docText = self._project.storage.getDocumentText(srcHandle).rstrip("\n")
-        if addComment:
-            docInfo = srcItem.describeMe()
-            docSt, _ = srcItem.getImportStatus()
-            cmtLine = f"% {cmtPrefix} {docInfo}: {srcItem.itemName} [{docSt}]\n\n"
-            docText = cmtLine + docText
-
-        self._targetText.append(docText)
-
-        return True
+        if item := self._project.tree[sHandle]:
+            text = self._project.storage.getDocumentText(sHandle).rstrip("\n")
+            if addComment:
+                info = item.describeMe()
+                status, _ = item.getImportStatus()
+                text = f"% {cmtPrefix} {info}: {item.itemName} [{status}]\n\n{text}"
+            self._text.append(text)
+        return
 
     def writeTargetDoc(self) -> bool:
         """Write the accumulated text into the designated target
         document, appending any existing text.
         """
-        if self._targetDoc is None:
-            return False
+        if self._target:
+            outDoc = self._project.storage.getDocument(self._target.itemHandle)
+            if text := (outDoc.readDocument() or "").rstrip("\n"):
+                self._text.insert(0, text)
+
+            status = outDoc.writeDocument("\n\n".join(self._text) + "\n\n")
+            if not status:
+                self._error = outDoc.getError()
 
-        outDoc = self._project.storage.getDocument(self._targetDoc)
-        if text := (outDoc.readDocument() or "").rstrip("\n"):
-            self._targetText.insert(0, text)
+            self._project.index.reIndexHandle(self._target.itemHandle)
+            self._target.notifyToRefresh()
 
-        status = outDoc.writeDocument("\n\n".join(self._targetText) + "\n\n")
-        if not status:
-            self._error = outDoc.getError()
+            return status
 
-        return status
+        return False
 
 
 class DocSplitter:
@@ -171,23 +172,19 @@ class DocSplitter:
         self._inFolder = False
         return
 
-    def newParentFolder(self, pHandle: str, folderLabel: str) -> str | None:
+    def newParentFolder(self, pHandle: str, folderLabel: str) -> None:
         """Create a new folder that will be the top level parent item
         for the new documents.
         """
-        if self._srcItem is None:
-            return None
-
-        newHandle = self._project.newFolder(folderLabel, pHandle)
-        newItem = self._project.tree[newHandle]
-        if isinstance(newItem, NWItem):
-            newItem.setStatus(self._srcItem.itemStatus)
-            newItem.setImport(self._srcItem.itemImport)
-
-        self._parHandle = newHandle
-        self._inFolder = True
-
-        return newHandle
+        if self._srcItem:
+            nHandle = self._project.newFolder(folderLabel, pHandle)
+            if nwItem := self._project.tree[nHandle]:
+                nwItem.setStatus(self._srcItem.itemStatus)
+                nwItem.setImport(self._srcItem.itemImport)
+                nwItem.notifyToRefresh()
+            self._parHandle = nHandle
+            self._inFolder = True
+        return
 
     def splitDocument(self, splitData: list, splitText: list[str]) -> None:
         """Loop through the split data record and perform the split job
@@ -201,58 +198,50 @@ class DocSplitter:
             self._rawData.insert(0, (chunk, hLevel, hLabel))
         return
 
-    def writeDocuments(self, docHierarchy: bool) -> Iterable[tuple[bool, str | None, str | None]]:
+    def writeDocuments(self, docHierarchy: bool) -> Iterable[bool]:
         """An iterator that will write each document in the buffer, and
         return its new handle, parent handle, and sibling handle.
         """
-        if self._srcHandle is None or self._srcItem is None or self._parHandle is None:
-            return
-
-        pHandle = self._parHandle
-        nHandle = self._parHandle if self._inFolder else self._srcHandle
-        hHandle = [self._parHandle, None, None, None, None]
-
-        pLevel = 0
-        for docText, hLevel, docLabel in self._rawData:
-
-            hLevel = minmax(hLevel, 1, 4)
-            if pLevel == 0:
-                pLevel = hLevel
-
-            if docHierarchy:
-                if hLevel == 1:
-                    pHandle = self._parHandle
-                elif hLevel == 2:
-                    pHandle = hHandle[1] or hHandle[0]
-                elif hLevel == 3:
-                    pHandle = hHandle[2] or hHandle[1] or hHandle[0]
-                elif hLevel == 4:
-                    pHandle = hHandle[3] or hHandle[2] or hHandle[1] or hHandle[0]
-
-                if hLevel < pLevel:
-                    nHandle = hHandle[hLevel] or hHandle[0]
-                elif hLevel > pLevel:
-                    nHandle = pHandle
-
-            dHandle = self._project.newFile(docLabel, pHandle)
-            hHandle[hLevel] = dHandle
-
-            newItem = self._project.tree[dHandle]
-            if isinstance(newItem, NWItem):
-                newItem.setStatus(self._srcItem.itemStatus)
-                newItem.setImport(self._srcItem.itemImport)
-
-            outDoc = self._project.storage.getDocument(dHandle)
-            status = outDoc.writeDocument("\n".join(docText))
-            if not status:
-                self._error = outDoc.getError()
-
-            yield status, dHandle, nHandle
-
-            hHandle[hLevel] = dHandle
-            nHandle = dHandle
-            pLevel = hLevel
-
+        if self._srcHandle and self._srcItem and self._parHandle:
+            pHandle = self._parHandle
+            hHandle = [self._parHandle, None, None, None, None]
+            pLevel = 0
+            for docText, hLevel, docLabel in self._rawData:
+
+                hLevel = minmax(hLevel, 1, 4)
+                if pLevel == 0:
+                    pLevel = hLevel
+
+                if docHierarchy:
+                    if hLevel == 1:
+                        pHandle = self._parHandle
+                    elif hLevel == 2:
+                        pHandle = hHandle[1] or hHandle[0]
+                    elif hLevel == 3:
+                        pHandle = hHandle[2] or hHandle[1] or hHandle[0]
+                    elif hLevel == 4:
+                        pHandle = hHandle[3] or hHandle[2] or hHandle[1] or hHandle[0]
+
+                if (
+                    (dHandle := self._project.newFile(docLabel, pHandle))
+                    and (nwItem := self._project.tree[dHandle])
+                ):
+                    hHandle[hLevel] = dHandle
+                    nwItem.setStatus(self._srcItem.itemStatus)
+                    nwItem.setImport(self._srcItem.itemImport)
+
+                    outDoc = self._project.storage.getDocument(dHandle)
+                    status = outDoc.writeDocument("\n".join(docText))
+                    if not status:
+                        self._error = outDoc.getError()
+
+                    self._project.index.reIndexHandle(dHandle)
+                    nwItem.notifyToRefresh()
+
+                    yield status
+
+                    hHandle[hLevel] = dHandle
+                    pLevel = hLevel
         return
 
 
@@ -269,36 +258,34 @@ class DocDuplicator:
     #  Methods
     ##
 
-    def duplicate(self, items: list[str]) -> Iterable[tuple[str, str | None]]:
+    def duplicate(self, items: list[str]) -> list[str]:
         """Run through a list of items, duplicate them, and copy the
         text content if they are documents.
         """
+        result = []
+        after = True
         if items:
-            nHandle = items[0]
             hMap: dict[str, str | None] = {t: None for t in items}
             for tHandle in items:
-                newItem = self._project.tree.duplicate(tHandle)
-                if newItem is None:
-                    return
-                hMap[tHandle] = newItem.itemHandle
-                if newItem.itemParent in hMap:
-                    newItem.setParent(hMap[newItem.itemParent])
-                    self._project.tree.updateItemData(newItem.itemHandle)
-                if newItem.isFileType():
-                    newDoc = self._project.storage.getDocument(newItem.itemHandle)
-                    if newDoc.fileExists():
-                        return
-                    newDoc.writeDocument(self._project.storage.getDocumentText(tHandle))
-                yield newItem.itemHandle, nHandle
-                nHandle = None
-        return
+                if oldItem := self._project.tree[tHandle]:
+                    pHandle = hMap.get(oldItem.itemParent or "") or oldItem.itemParent
+                    if newItem := self._project.tree.duplicate(tHandle, pHandle, after):
+                        hMap[tHandle] = newItem.itemHandle
+                        if newItem.isFileType():
+                            self._project.copyFileContent(newItem.itemHandle, tHandle)
+                        newItem.notifyToRefresh()
+                        result.append(newItem.itemHandle)
+                    after = False
+                else:
+                    break
+        return result
 
 
 class DocSearch:
 
     def __init__(self) -> None:
-        self._regEx = QRegularExpression()
-        self.setCaseSensitive(False)
+        self._regEx = re.compile("")
+        self._opts = re.UNICODE | re.IGNORECASE
         self._words = False
         self._escape = True
         return
@@ -309,10 +296,9 @@ class DocSearch:
 
     def setCaseSensitive(self, state: bool) -> None:
         """Set the case sensitive search flag."""
-        opts = QRegularExpression.PatternOption.UseUnicodePropertiesOption
+        self._opts = re.UNICODE
         if not state:
-            opts |= QRegularExpression.PatternOption.CaseInsensitiveOption
-        self._regEx.setPatternOptions(opts)
+            self._opts |= re.IGNORECASE
         return
 
     def setWholeWords(self, state: bool) -> None:
@@ -329,8 +315,8 @@ class DocSearch:
         self, project: NWProject, search: str
     ) -> Iterable[tuple[NWItem, list[tuple[int, int, str]], bool]]:
         """Iteratively search through documents in a project."""
-        self._regEx.setPattern(self._buildPattern(search))
-        logger.debug("Searching with pattern '%s'", self._regEx.pattern())
+        self._regEx = re.compile(self._buildPattern(search), self._opts)
+        logger.debug("Searching with pattern '%s'", self._regEx.pattern)
         storage = project.storage
         for item in project.tree:
             if item.isFileType():
@@ -340,14 +326,12 @@ class DocSearch:
 
     def searchText(self, text: str) -> tuple[list[tuple[int, int, str]], bool]:
         """Search a piece of text for RegEx matches."""
-        rxItt = self._regEx.globalMatch(text)
         count = 0
         capped = False
         results = []
-        while rxItt.hasNext():
-            rxMatch = rxItt.next()
-            pos = rxMatch.capturedStart()
-            num = rxMatch.capturedLength()
+        for res in self._regEx.finditer(text):
+            pos = res.start(0)
+            num = len(res.group(0))
             lim = text[:pos].rfind("\n") + 1
             cut = text[lim:pos].rfind(" ") + lim + 1
             context = text[cut:cut+100].partition("\n")[0]
@@ -366,7 +350,7 @@ class DocSearch:
     def _buildPattern(self, search: str) -> str:
         """Build the search pattern string."""
         if self._escape:
-            search = QRegularExpression.escape(search)
+            search = re.escape(search)
         if self._words:
             search = f"(?:^|\\b){search}(?:$|\\b)"
         return search
@@ -430,7 +414,6 @@ class ProjectBuilder:
 
         lblNewProject = self.tr("New Project")
         lblTitlePage  = self.tr("Title Page")
-        lblByAuthors  = self.tr("By")
 
         # Settings
         project.data.setUuid(None)
@@ -443,14 +426,29 @@ class ProjectBuilder:
         # Add Root Folders
         hNovelRoot = project.newRoot(nwItemClass.NOVEL)
         hTitlePage = project.newFile(lblTitlePage, hNovelRoot)
-        novelTitle = project.data.name
-
-        titlePage = f"#! {novelTitle}\n\n"
-        if project.data.author:
-            titlePage += f">> {lblByAuthors} {project.data.author} <<\n\n"
 
+        # Generate Title Page
         aDoc = project.storage.getDocument(hTitlePage)
-        aDoc.writeDocument(titlePage)
+        aDoc.writeDocument((
+            "{author}[br]\n"
+            "{address} 1[br]\n"
+            "{address} 2 <<\n"
+            "\n"
+            "[vspace:5]\n"
+            "\n"
+            "#! {title}\n"
+            "\n"
+            ">> **{by} {author}** <<\n"
+            "\n"
+            ">> {count}: [field:{field}] <<\n"
+        ).format(
+            author=project.data.author or "None",
+            address=self.tr("Address"),
+            title=project.data.name or "None",
+            by=self.tr("By"),
+            count=self.tr("Word Count"),
+            field=nwStats.WORDS_TEXT,
+        ))
 
         # Create a project structure based on selected root folders
         # and a number of chapters and scenes selected in the
@@ -511,7 +509,7 @@ class ProjectBuilder:
 
         # Also add the archive and trash folders
         project.newRoot(nwItemClass.ARCHIVE)
-        project.trashFolder()
+        project.tree.trash  # Triggers the creation of Trash
 
         project.saveProject()
         project.closeProject()