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

novelwriter/text/counting.py

@@ -8,7 +8,7 @@ Rewritten: 2024-02-27 [2.4b1] preProcessText, standardCounter
 Created:   2024-02-27 [2.4b1] bodyTextCounter
 
 This file is a part of novelWriter
-Copyright 2018–2024, Veronica Berglyd Olsen
+Copyright (C) 2024 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
@@ -30,6 +30,7 @@ import re
 from novelwriter.constants import nwRegEx, nwUnicode
 
 RX_SC = re.compile(nwRegEx.FMT_SC)
+RX_SV = re.compile(nwRegEx.FMT_SV)
 RX_LO = re.compile(r"(?i)(?<!\\)(\[(?:vspace|newpage|new page)(:\d+)?)(?<!\\)(\])")
 
 
@@ -64,6 +65,7 @@ def preProcessText(text: str, keepHeaders: bool = True) -> list[str]:
                 # Strip shortcodes and special formatting
                 # RegEx is slow, so we do this only when necessary
                 line = RX_SC.sub("", line)
+                line = RX_SV.sub("", line)
                 line = RX_LO.sub("", line)
 
         result.append(line)

novelwriter/text/patterns.py

@@ -3,10 +3,11 @@ novelWriter – Text Pattern Functions
 ====================================
 
 File History:
-Created: 2024-06-01 [2.5ec1]
+Created: 2024-06-01 [2.5rc1] RegExPatterns
+Created: 2024-11-04 [2.6b1]  DialogParser
 
 This file is a part of novelWriter
-Copyright 2018–2024, Veronica Berglyd Olsen
+Copyright (C) 2024 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
@@ -23,91 +24,198 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.
 """
 from __future__ import annotations
 
-from PyQt5.QtCore import QRegularExpression
+import re
 
 from novelwriter import CONFIG
-from novelwriter.constants import nwRegEx
-from novelwriter.types import QRegExUnicode
+from novelwriter.common import compact, uniqueCompact
+from novelwriter.constants import nwRegEx, nwUnicode
 
 
 class RegExPatterns:
 
+    AMBIGUOUS = (nwUnicode.U_APOS, nwUnicode.U_RSQUO)
+
+    # Static RegExes
+    _rxUrl     = re.compile(nwRegEx.URL, re.ASCII)
+    _rxWords   = re.compile(nwRegEx.WORDS, re.UNICODE)
+    _rxBreak   = re.compile(nwRegEx.BREAK, re.UNICODE)
+    _rxItalic  = re.compile(nwRegEx.FMT_EI, re.UNICODE)
+    _rxBold    = re.compile(nwRegEx.FMT_EB, re.UNICODE)
+    _rxStrike  = re.compile(nwRegEx.FMT_ST, re.UNICODE)
+    _rxSCPlain = re.compile(nwRegEx.FMT_SC, re.UNICODE)
+    _rxSCValue = re.compile(nwRegEx.FMT_SV, re.UNICODE)
+
     @property
-    def markdownItalic(self) -> QRegularExpression:
+    def url(self) -> re.Pattern:
+        """Find URLs."""
+        return self._rxUrl
+
+    @property
+    def wordSplit(self) -> re.Pattern:
+        """Split text into words."""
+        return self._rxWords
+
+    @property
+    def lineBreak(self) -> re.Pattern:
+        """Find forced line break."""
+        return self._rxBreak
+
+    @property
+    def markdownItalic(self) -> re.Pattern:
         """Markdown italic style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_EI)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxItalic
 
     @property
-    def markdownBold(self) -> QRegularExpression:
+    def markdownBold(self) -> re.Pattern:
         """Markdown bold style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_EB)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxBold
 
     @property
-    def markdownStrike(self) -> QRegularExpression:
+    def markdownStrike(self) -> re.Pattern:
         """Markdown strikethrough style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_ST)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxStrike
 
     @property
-    def shortcodePlain(self) -> QRegularExpression:
+    def shortcodePlain(self) -> re.Pattern:
         """Plain shortcode style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_SC)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxSCPlain
 
     @property
-    def shortcodeValue(self) -> QRegularExpression:
+    def shortcodeValue(self) -> re.Pattern:
         """Plain shortcode style."""
-        rxRule = QRegularExpression(nwRegEx.FMT_SV)
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        return self._rxSCValue
 
     @property
-    def dialogStyle(self) -> QRegularExpression:
+    def dialogStyle(self) -> re.Pattern | None:
         """Dialogue detection rule based on user settings."""
-        symO = ""
-        symC = ""
-        if CONFIG.dialogStyle in (1, 3):
-            symO += CONFIG.fmtSQuoteOpen
-            symC += CONFIG.fmtSQuoteClose
-        if CONFIG.dialogStyle in (2, 3):
-            symO += CONFIG.fmtDQuoteOpen
-            symC += CONFIG.fmtDQuoteClose
-
-        rxEnd = "|$" if CONFIG.allowOpenDial else ""
-        rxRule = QRegularExpression(f"\\B[{symO}].*?(?:[{symC}]\\B{rxEnd})")
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
-
-    @property
-    def dialogLine(self) -> QRegularExpression:
-        """Dialogue line rule based on user settings."""
-        sym = QRegularExpression.escape(CONFIG.dialogLine)
-        rxRule = QRegularExpression(f"^{sym}.*?$")
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
-
-    @property
-    def narratorBreak(self) -> QRegularExpression:
-        """Dialogue narrator break rule based on user settings."""
-        sym = QRegularExpression.escape(CONFIG.narratorBreak)
-        rxRule = QRegularExpression(f"\\B{sym}\\S.*?\\S{sym}\\B")
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        if CONFIG.dialogStyle > 0:
+            rx = []
+            if CONFIG.dialogStyle in (1, 3):
+                qO = CONFIG.fmtSQuoteOpen.strip()[:1]
+                qC = CONFIG.fmtSQuoteClose.strip()[:1]
+                if qO == qC:
+                    rx.append(f"(?:\\B{qO}.+?{qC}\\B)")
+                else:
+                    rx.append(f"(?:{qO}[^{qO}]+{qC})")
+                if CONFIG.allowOpenDial:
+                    rx.append(f"(?:{qO}.+?$)")
+            if CONFIG.dialogStyle in (2, 3):
+                qO = CONFIG.fmtDQuoteOpen.strip()[:1]
+                qC = CONFIG.fmtDQuoteClose.strip()[:1]
+                if qO == qC:
+                    rx.append(f"(?:\\B{qO}.+?{qC}\\B)")
+                else:
+                    rx.append(f"(?:{qO}[^{qO}]+{qC})")
+                if CONFIG.allowOpenDial:
+                    rx.append(f"(?:{qO}.+?$)")
+            return re.compile("|".join(rx), re.UNICODE)
+        return None
 
     @property
-    def altDialogStyle(self) -> QRegularExpression:
+    def altDialogStyle(self) -> re.Pattern | None:
         """Dialogue alternative rule based on user settings."""
-        symO = QRegularExpression.escape(CONFIG.altDialogOpen)
-        symC = QRegularExpression.escape(CONFIG.altDialogClose)
-        rxRule = QRegularExpression(f"\\B{symO}.*?{symC}\\B")
-        rxRule.setPatternOptions(QRegExUnicode)
-        return rxRule
+        if CONFIG.altDialogOpen and CONFIG.altDialogClose:
+            qO = re.escape(compact(CONFIG.altDialogOpen))
+            qC = re.escape(compact(CONFIG.altDialogClose))
+            qB = r"\B" if (qO == qC or qC in self.AMBIGUOUS) else ""
+            return re.compile(f"{qO}.*?{qC}{qB}", re.UNICODE)
+        return None
 
 
 REGEX_PATTERNS = RegExPatterns()
+
+
+class DialogParser:
+
+    __slots__ = (
+        "_quotes", "_dialog", "_alternate", "_enabled",
+        "_narrator", "_breakD", "_breakQ", "_mode",
+    )
+
+    def __init__(self) -> None:
+        self._quotes = None
+        self._dialog = ""
+        self._alternate = ""
+        self._enabled = False
+        self._narrator = ""
+        self._breakD = None
+        self._breakQ = None
+        self._mode = ""
+        return
+
+    @property
+    def enabled(self) -> bool:
+        """Return True if there are any settings to parse."""
+        return self._enabled
+
+    def initParser(self) -> None:
+        """Init parser settings. This method must also be called when
+        the config changes.
+        """
+        self._quotes = REGEX_PATTERNS.dialogStyle
+        self._dialog = uniqueCompact(CONFIG.dialogLine)
+        self._alternate = CONFIG.narratorDialog.strip()[:1]
+
+        # One of the three modes are needed for the class to have
+        # anything to do
+        self._enabled = bool(self._quotes or self._dialog or self._alternate)
+
+        # Build narrator break RegExes
+        if narrator := CONFIG.narratorBreak.strip()[:1]:
+            punct = re.escape(".,:;!?")
+            self._breakD = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?|$)", re.UNICODE)
+            self._breakQ = re.compile(f"{narrator}.*?(?:{narrator}[{punct}]?)", re.UNICODE)
+            self._narrator = narrator
+            self._mode = f" {narrator}"
+
+        return
+
+    def __call__(self, text: str) -> list[tuple[int, int]]:
+        """Caller wrapper for dialogue processing."""
+        temp: list[int] = []
+        result: list[tuple[int, int]] = []
+        if text:
+            plain = True
+            if self._dialog and text[0] in self._dialog:
+                # The whole line is dialogue
+                plain = False
+                temp.append(0)
+                temp.append(len(text))
+                if self._breakD:
+                    # Process narrator breaks in the dialogue
+                    for res in self._breakD.finditer(text, 1):
+                        temp.append(res.start(0))
+                        temp.append(res.end(0))
+            elif self._quotes:
+                # Quoted dialogue is enabled, so we look for them
+                for res in self._quotes.finditer(text):
+                    plain = False
+                    temp.append(res.start(0))
+                    temp.append(res.end(0))
+                    if self._breakQ:
+                        for sub in self._breakQ.finditer(text, res.start(0), res.end(0)):
+                            temp.append(sub.start(0))
+                            temp.append(sub.end(0))
+
+            if plain and self._alternate:
+                # The main rules found no dialogue, so we check for
+                # alternating dialogue sections, if enabled
+                pos = 0
+                for num, bit in enumerate(text.split(self._alternate)):
+                    length = len(bit) + (1 if num > 0 else 0)
+                    if num%2:
+                        temp.append(pos)
+                        temp.append(pos + length)
+                    pos += length
+
+            if temp:
+                # Sort unique edges in increasing order, and add them in pairs
+                start = None
+                for pos in sorted(set(temp)):
+                    if start is None:
+                        start = pos
+                    else:
+                        result.append((start, pos))
+                        start = None
+
+        return result

novelwriter/tools/dictionaries.py

@@ -6,7 +6,7 @@ File History:
 Created: 2023-11-19 [2.2rc1] GuiDictionaries
 
 This file is a part of novelWriter
-Copyright 2018–2024, Veronica Berglyd Olsen
+Copyright (C) 2023 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
@@ -65,12 +65,12 @@ class GuiDictionaries(NNonBlockingDialog):
         self.setMinimumHeight(CONFIG.pxInt(300))
 
         # Hunspell Dictionaries
-        foUrl = "https://www.freeoffice.com/en/download/dictionaries"
         loUrl = "https://extensions.libreoffice.org"
+        ooUrl = "https://extensions.openoffice.org"
         self.huInfo = QLabel("<br>".join([
             self.tr("Download a dictionary from one of the links, and add it below."),
-            f"&nbsp;\u203a <a href='{foUrl}'>{foUrl}</a>",
             f"&nbsp;\u203a <a href='{loUrl}'>{loUrl}</a>",
+            f"&nbsp;\u203a <a href='{ooUrl}'>{ooUrl}</a>",
         ]), self)
         self.huInfo.setOpenExternalLinks(True)
         self.huInfo.setWordWrap(True)

novelwriter/tools/lipsum.py

@@ -6,7 +6,7 @@ File History:
 Created: 2022-04-02 [2.0rc1] GuiLipsum
 
 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

novelwriter/tools/manusbuild.py

@@ -6,7 +6,7 @@ File History:
 Created: 2023-05-24 [2.1b1] GuiManuscriptBuild
 
 This file is a part of novelWriter
-Copyright 2018–2024, Veronica Berglyd Olsen
+Copyright (C) 2023 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
@@ -179,14 +179,20 @@ class GuiManuscriptBuild(NDialog):
         self.buildBox.setVerticalSpacing(sp4)
 
         # Dialog Buttons
+        self.buttonBox = QDialogButtonBox(self)
+
         self.btnOpen = QPushButton(SHARED.theme.getIcon("browse"), self.tr("Open Folder"), self)
         self.btnOpen.setIconSize(bSz)
+        self.btnOpen.setAutoDefault(False)
+        self.buttonBox.addButton(self.btnOpen, QtRoleAction)
+
         self.btnBuild = QPushButton(SHARED.theme.getIcon("export"), self.tr("&Build"), self)
         self.btnBuild.setIconSize(bSz)
+        self.btnBuild.setAutoDefault(True)
+        self.buttonBox.addButton(self.btnBuild, QtRoleAction)
 
-        self.dlgButtons = QDialogButtonBox(QtDialogClose, self)
-        self.dlgButtons.addButton(self.btnOpen, QtRoleAction)
-        self.dlgButtons.addButton(self.btnBuild, QtRoleAction)
+        self.btnClose = self.buttonBox.addButton(QtDialogClose)
+        self.btnClose.setAutoDefault(False)
 
         # Assemble GUI
         # ============
@@ -213,7 +219,7 @@ class GuiManuscriptBuild(NDialog):
         self.outerBox.addSpacing(sp4)
         self.outerBox.addLayout(self.buildBox, 0)
         self.outerBox.addSpacing(sp16)
-        self.outerBox.addWidget(self.dlgButtons, 0)
+        self.outerBox.addWidget(self.buttonBox, 0)
         self.outerBox.setSpacing(0)
 
         self.setLayout(self.outerBox)
@@ -229,7 +235,7 @@ class GuiManuscriptBuild(NDialog):
         # Signals
         self.btnReset.clicked.connect(self._doResetBuildName)
         self.btnBrowse.clicked.connect(self._doSelectPath)
-        self.dlgButtons.clicked.connect(self._dialogButtonClicked)
+        self.buttonBox.clicked.connect(self._dialogButtonClicked)
         self.listFormats.itemSelectionChanged.connect(self._resetProgress)
 
         logger.debug("Ready: GuiManuscriptBuild")
@@ -260,7 +266,7 @@ class GuiManuscriptBuild(NDialog):
     @pyqtSlot("QAbstractButton*")
     def _dialogButtonClicked(self, button: QAbstractButton) -> None:
         """Handle button clicks from the dialog button box."""
-        role = self.dlgButtons.buttonRole(button)
+        role = self.buttonBox.buttonRole(button)
         if role == QtRoleAction:
             if button == self.btnBuild:
                 self._runBuild()
@@ -333,7 +339,7 @@ class GuiManuscriptBuild(NDialog):
         docBuild.queueAll()
 
         self.buildProgress.setMaximum(len(docBuild))
-        for i, _ in docBuild.iterBuild(buildPath, bFormat):
+        for i, _ in docBuild.iterBuildDocument(buildPath, bFormat):
             self.buildProgress.setValue(i+1)
 
         self._build.setLastBuildPath(bPath)
@@ -388,13 +394,9 @@ class GuiManuscriptBuild(NDialog):
                     if isinstance(rItem, NWItem):
                         rootMap[rHandle] = rItem.itemName
 
-                itemIcon = SHARED.theme.getItemIcon(
-                    nwItem.itemType, nwItem.itemClass,
-                    nwItem.itemLayout, nwItem.mainHeading
-                )
                 rootName = rootMap.get(rHandle, "??????")
                 item = QListWidgetItem(f"{rootName}: {nwItem.itemName}")
-                item.setIcon(itemIcon)
+                item.setIcon(nwItem.getMainIcon())
                 self.listContent.addItem(item)
 
         return