novelWriter 2.7.5__py3-none-any.whl → 2.8b1__py3-none-any.whl

novelwriter/formats/tokenizer.py

@@ -21,7 +21,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import logging
@@ -55,6 +55,7 @@ logger = logging.getLogger(__name__)
 
 
 class ComStyle(NamedTuple):
+    """Comment style info."""
 
     label: str = ""
     labelClass: str = ""
@@ -71,16 +72,28 @@ COMMENT_STYLE = {
     nwComment.COMMENT:  ComStyle(),
     nwComment.STORY:    ComStyle("Story Structure", "modifier", "note"),
 }
-HEADINGS = [
+COMMENT_TYPE = {
+    nwComment.PLAIN:    BlockTyp.COMMENT,
+    nwComment.IGNORE:   BlockTyp.COMMENT,
+    nwComment.SYNOPSIS: BlockTyp.SUMMARY,
+    nwComment.SHORT:    BlockTyp.SUMMARY,
+    nwComment.NOTE:     BlockTyp.NOTE,
+    nwComment.FOOTNOTE: BlockTyp.COMMENT,
+    nwComment.COMMENT:  BlockTyp.COMMENT,
+    nwComment.STORY:    BlockTyp.NOTE,
+}
+HEADING_BLOCKS = [
     BlockTyp.TITLE, BlockTyp.PART, BlockTyp.HEAD1,
     BlockTyp.HEAD2, BlockTyp.HEAD3, BlockTyp.HEAD4,
 ]
-SKIP_INDENT = [*HEADINGS, BlockTyp.SEP, BlockTyp.SKIP]
+COMMENT_BLOCKS = (BlockTyp.COMMENT, BlockTyp.SUMMARY, BlockTyp.NOTE)
+META_BLOCKS = (BlockTyp.COMMENT, BlockTyp.SUMMARY, BlockTyp.NOTE, BlockTyp.KEYWORD)
+SKIP_INDENT = [*HEADING_BLOCKS, BlockTyp.SEP, BlockTyp.SKIP]
 B_EMPTY: T_Block = (BlockTyp.EMPTY, "", "", [], BlockFmt.NONE)
 
 
 class Tokenizer(ABC):
-    """Core: Text Tokenizer Abstract Base Class
+    """Core: Text Tokenizer Abstract Base Class.
 
     This is the base class for all document build classes. It parses the
     novelWriter markup format and generates a registry of tokens and
@@ -189,6 +202,7 @@ class Tokenizer(ABC):
             (REGEX_PATTERNS.markdownItalic, [0, TextFmt.I_B, 0, TextFmt.I_E]),
             (REGEX_PATTERNS.markdownBold,   [0, TextFmt.B_B, 0, TextFmt.B_E]),
             (REGEX_PATTERNS.markdownStrike, [0, TextFmt.D_B, 0, TextFmt.D_E]),
+            (REGEX_PATTERNS.markdownMark,   [0, TextFmt.M_B, 0, TextFmt.M_E]),
         ]
 
         self._shortCodeFmt = {
@@ -211,8 +225,6 @@ class Tokenizer(ABC):
         self._dialogParser = DialogParser()
         self._dialogParser.initParser()
 
-        return
-
     ##
     #  Properties
     ##
@@ -240,94 +252,78 @@ class Tokenizer(ABC):
         """Set language for the document."""
         if language:
             self._dLocale = QLocale(language)
-        return
 
     def setTheme(self, theme: TextDocumentTheme) -> None:
         """Set the document colour theme."""
         self._theme = theme
-        return
 
     def setPartitionFormat(self, hFormat: str, hide: bool = False) -> None:
         """Set the partition format pattern."""
         self._fmtPart = hFormat.strip()
         self._hidePart = hide
-        return
 
     def setChapterFormat(self, hFormat: str, hide: bool = False) -> None:
         """Set the chapter format pattern."""
         self._fmtChapter = hFormat.strip()
         self._hideChapter = hide
-        return
 
     def setUnNumberedFormat(self, hFormat: str, hide: bool = False) -> None:
         """Set the unnumbered format pattern."""
         self._fmtUnNum = hFormat.strip()
         self._hideUnNum = hide
-        return
 
     def setSceneFormat(self, hFormat: str, hide: bool = False) -> None:
         """Set the scene format pattern and hidden status."""
         self._fmtScene = hFormat.strip()
         self._hideScene = hide
-        return
 
     def setHardSceneFormat(self, hFormat: str, hide: bool = False) -> None:
         """Set the hard scene format pattern and hidden status."""
         self._fmtHScene = hFormat.strip()
         self._hideHScene = hide
-        return
 
     def setSectionFormat(self, hFormat: str, hide: bool = False) -> None:
         """Set the section format pattern and hidden status."""
         self._fmtSection = hFormat.strip()
         self._hideSection = hide
-        return
 
     def setTitleStyle(self, center: bool, pageBreak: bool) -> None:
         """Set the title heading style."""
         self._titleStyle = BlockFmt.CENTRE if center else BlockFmt.NONE
         self._titleStyle |= BlockFmt.PBB if pageBreak else BlockFmt.NONE
-        return
 
     def setPartitionStyle(self, center: bool, pageBreak: bool) -> None:
         """Set the partition heading style."""
         self._partStyle = BlockFmt.CENTRE if center else BlockFmt.NONE
         self._partStyle |= BlockFmt.PBB if pageBreak else BlockFmt.NONE
-        return
 
     def setChapterStyle(self, center: bool, pageBreak: bool) -> None:
         """Set the chapter heading style."""
         self._chapterStyle = BlockFmt.CENTRE if center else BlockFmt.NONE
         self._chapterStyle |= BlockFmt.PBB if pageBreak else BlockFmt.NONE
-        return
 
     def setSceneStyle(self, center: bool, pageBreak: bool) -> None:
         """Set the scene heading style."""
         self._sceneStyle = BlockFmt.CENTRE if center else BlockFmt.NONE
         self._sceneStyle |= BlockFmt.PBB if pageBreak else BlockFmt.NONE
-        return
 
     def setTextFont(self, font: QFont) -> None:
         """Set the build font."""
         self._textFont = fontMatcher(font)
-        return
 
     def setLineHeight(self, height: float) -> None:
         """Set the line height between 0.5 and 5.0."""
         self._lineHeight = min(max(float(height), 0.5), 5.0)
-        return
 
     def setHeadingStyles(self, color: bool, scale: bool, bold: bool) -> None:
         """Set text style for headings."""
         self._colorHeads = color
         self._scaleHeads = scale
         self._boldHeads = bold
-        return
 
     def setBlockIndent(self, indent: float) -> None:
         """Set the block indent between 0.0 and 10.0."""
         self._blockIndent = min(max(float(indent), 0.0), 10.0)
-        return
 
     def setFirstLineIndent(self, state: bool, indent: float, first: bool) -> None:
         """Set first line indent and whether to also indent first
@@ -336,67 +332,54 @@ class Tokenizer(ABC):
         self._firstIndent = state
         self._firstWidth = indent
         self._indentFirst = first
-        return
 
     def setJustify(self, state: bool) -> None:
         """Enable or disable text justification."""
         self._doJustify = state
-        return
 
     def setDialogHighlight(self, state: bool) -> None:
         """Enable or disable dialogue highlighting."""
         self._hlightDialog = state
-        return
 
     def setTitleMargins(self, upper: float, lower: float) -> None:
         """Set the upper and lower title margin."""
         self._marginTitle = (float(upper), float(lower))
-        return
 
     def setHead1Margins(self, upper: float, lower: float) -> None:
         """Set the upper and lower heading 1 margin."""
         self._marginHead1 = (float(upper), float(lower))
-        return
 
     def setHead2Margins(self, upper: float, lower: float) -> None:
         """Set the upper and lower heading 2 margin."""
         self._marginHead2 = (float(upper), float(lower))
-        return
 
     def setHead3Margins(self, upper: float, lower: float) -> None:
         """Set the upper and lower heading 3 margin."""
         self._marginHead3 = (float(upper), float(lower))
-        return
 
     def setHead4Margins(self, upper: float, lower: float) -> None:
         """Set the upper and lower heading 4 margin."""
         self._marginHead4 = (float(upper), float(lower))
-        return
 
     def setTextMargins(self, upper: float, lower: float) -> None:
         """Set the upper and lower text margin."""
         self._marginText = (float(upper), float(lower))
-        return
 
     def setMetaMargins(self, upper: float, lower: float) -> None:
         """Set the upper and lower meta text margin."""
         self._marginMeta = (float(upper), float(lower))
-        return
 
     def setSeparatorMargins(self, upper: float, lower: float) -> None:
         """Set the upper and lower meta text margin."""
         self._marginSep = (float(upper), float(lower))
-        return
 
     def setLinkHeadings(self, state: bool) -> None:
         """Enable or disable adding an anchor before headings."""
         self._linkHeadings = state
-        return
 
     def setBodyText(self, state: bool) -> None:
         """Include body text in build."""
         self._doBodyText = state
-        return
 
     def setCommentType(self, comment: nwComment, state: bool) -> None:
         """Toggle the inclusion og certain comment types."""
@@ -404,22 +387,18 @@ class Tokenizer(ABC):
             self._doComments.add(comment)
         else:
             self._doComments.discard(comment)
-        return
 
     def setKeywords(self, state: bool) -> None:
         """Include keywords in build."""
         self._doKeywords = state
-        return
 
     def setIgnoredKeywords(self, keywords: str) -> None:
         """Comma separated string of keywords to ignore."""
         self._skipKeywords = set(x.lower().strip() for x in keywords.split(","))
-        return
 
     def setKeepLineBreaks(self, state: bool) -> None:
         """Keep line breaks in paragraphs."""
         self._keepBreaks = state
-        return
 
     ##
     #  Class Methods
@@ -447,12 +426,10 @@ class Tokenizer(ABC):
         self._classes["tag"] = self._theme.tag
         self._classes["keyword"] = self._theme.keyword
         self._classes["optional"] = self._theme.optional
-        return
 
     def setBreakNext(self) -> None:
         """Set a page break for next block."""
         self._breakNext = True
-        return
 
     def addRootHeading(self, tHandle: str) -> None:
         """Add a heading at the start of a new root folder."""
@@ -478,8 +455,6 @@ class Tokenizer(ABC):
             if self._keepRaw:
                 self._raw.append(f"#! {title}\n\n")
 
-        return
-
     def setText(self, tHandle: str, text: str | None = None) -> None:
         """Set the text for the tokenizer from a handle. If text is not
         set, it's is loaded from the file.
@@ -490,7 +465,6 @@ class Tokenizer(ABC):
             self._text = text or self._project.storage.getDocumentText(tHandle)
             self._handle = tHandle
             self._isNovel = nwItem.itemLayout == nwItemLayout.DOCUMENT
-        return
 
     def doPreProcessing(self) -> None:
         """Run pre-processing jobs before the text is tokenized."""
@@ -499,7 +473,6 @@ class Tokenizer(ABC):
             replace = {f"<{k}>": v for k, v in entry.items()}
             rxRep = re.compile("|".join([re.escape(k) for k in replace]), flags=re.DOTALL)
             self._text = rxRep.sub(lambda x: replace[x.group(0)], self._text)
-        return
 
     def tokenizeText(self) -> None:
         """Scan the text for either lines starting with specific
@@ -577,13 +550,13 @@ class Tokenizer(ABC):
                     self._breakNext = True
                     continue
 
-                elif sLine == "[vspace]":
+                if sLine == "[vspace]":
                     tBlocks.append(
                         (BlockTyp.SKIP, "", "", [], tStyle)
                     )
                     continue
 
-                elif sLine.startswith("[vspace:") and sLine.endswith("]"):
+                if sLine.startswith("[vspace:") and sLine.endswith("]"):
                     nSkip = checkInt(sLine[8:-1], 0)
                     if nSkip >= 1:
                         tBlocks.append(
@@ -618,7 +591,7 @@ class Tokenizer(ABC):
                     bStyle = COMMENT_STYLE[cStyle]
                     tLine, tFmt = self._formatComment(bStyle, cKey, cText)
                     tBlocks.append((
-                        BlockTyp.COMMENT, "", tLine, tFmt, tStyle
+                        COMMENT_TYPE[cStyle], "", tLine, tFmt, tStyle
                     ))
 
                 elif cStyle == nwComment.FOOTNOTE:
@@ -862,12 +835,12 @@ class Tokenizer(ABC):
                 # We don't need to keep the empty lines after this pass
                 pass
 
-            elif cBlock[0] == BlockTyp.KEYWORD:
-                # Adjust margins for lines in a list of keyword lines
+            elif cBlock[0] in (BlockTyp.KEYWORD, BlockTyp.NOTE):
+                # Adjust margins for lines in repeated meta blocks
                 aStyle = cBlock[4]
-                if pBlock[0] == BlockTyp.KEYWORD:
+                if pBlock[0] == cBlock[0]:
                     aStyle |= BlockFmt.Z_TOP
-                if nBlock[0] == BlockTyp.KEYWORD:
+                if nBlock[0] == cBlock[0]:
                     aStyle |= BlockFmt.Z_BTM
                 sBlocks.append((
                     cBlock[0], cBlock[1], cBlock[2], cBlock[3], aStyle
@@ -949,8 +922,6 @@ class Tokenizer(ABC):
             text = tText.replace(nwHeadFmt.BR, " ").replace("&amp;", "&")
             self._outline[tKey] = f"{prefix}|{text}"
 
-        return
-
     def countStats(self) -> None:
         """Count stats on the tokenized text."""
         titleCount = self._counts.get(nwStats.TITLES, 0)
@@ -991,7 +962,7 @@ class Tokenizer(ABC):
                 allWordChars += nPWChars
                 textWordChars += nPWChars
 
-            elif tType in HEADINGS:
+            elif tType in HEADING_BLOCKS:
                 titleCount += 1
                 allWords += nWords
                 titleWords += nWords
@@ -1005,7 +976,7 @@ class Tokenizer(ABC):
                 allChars += nChars
                 allWordChars += nWChars
 
-            elif tType in (BlockTyp.COMMENT, BlockTyp.KEYWORD):
+            elif tType in META_BLOCKS:
                 words = tText.split()
                 allWords += len(words)
                 allChars += len(tText)
@@ -1026,8 +997,6 @@ class Tokenizer(ABC):
         self._counts[nwStats.WCHARS_TEXT] = textWordChars
         self._counts[nwStats.WCHARS_TITLE] = titleWordChars
 
-        return
-
     ##
     #  Internal Functions
     ##
@@ -1169,6 +1138,12 @@ class Tokenizer(ABC):
 
 
 class HeadingFormatter:
+    """Core: Format Text Headings.
+
+    This class holds the various chapter and scene counters and can
+    apply the Build Settings header format settings based on internal
+    counter state.
+    """
 
     def __init__(
         self,
@@ -1182,35 +1157,29 @@ class HeadingFormatter:
         self._chapter = chapter
         self._scene = scene
         self._absolute = absolute
-        return
 
     def setHandle(self, tHandle: str | None) -> None:
         """Set the handle currently being processed."""
         self._handle = tHandle
-        return
 
     def incChapter(self) -> None:
         """Increment the chapter counter."""
         self._chapter += 1
-        return
 
     def incScene(self) -> None:
         """Increment the scene counters."""
         self._scene += 1
         self._absolute += 1
-        return
 
     def resetAll(self) -> None:
         """Reset all counters."""
         self._chapter = 0
         self._scene = 0
         self._absolute = 0
-        return
 
     def resetScene(self) -> None:
         """Reset the chapter scene counter."""
         self._scene = 0
-        return
 
     def apply(self, hFormat: str, text: str, nHead: int) -> str:
         """Apply formatting to a specific heading."""

novelwriter/formats/tomarkdown.py

@@ -20,7 +20,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <https://www.gnu.org/licenses/>.
-"""
+"""  # noqa
 from __future__ import annotations
 
 import logging
@@ -29,7 +29,7 @@ from typing import TYPE_CHECKING
 
 from novelwriter.constants import nwUnicode
 from novelwriter.formats.shared import BlockFmt, BlockTyp, T_Formats, TextFmt
-from novelwriter.formats.tokenizer import Tokenizer
+from novelwriter.formats.tokenizer import COMMENT_BLOCKS, Tokenizer
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -79,7 +79,7 @@ EXT_MD = {
 
 
 class ToMarkdown(Tokenizer):
-    """Core: Markdown Document Writer
+    """Core: Markdown Document Writer.
 
     Extend the Tokenizer class to writer Markdown output. It supports
     both Standard Markdown and Extended Markdown. The class also
@@ -91,7 +91,6 @@ class ToMarkdown(Tokenizer):
         self._extended = extended
         self._usedNotes: dict[str, int] = {}
         self._usedFields: list[tuple[int, str]] = []
-        return
 
     ##
     #  Class Methods
@@ -144,7 +143,7 @@ class ToMarkdown(Tokenizer):
             elif tType == BlockTyp.SKIP:
                 lines.append(f"{cSkip}\n\n")
 
-            elif tType == BlockTyp.COMMENT:
+            elif tType in COMMENT_BLOCKS:
                 lines.append(f"{self._formatText(tText, tFormat, mTags)}\n\n")
 
             elif tType == BlockTyp.KEYWORD:
@@ -153,8 +152,6 @@ class ToMarkdown(Tokenizer):
 
         self._pages.append("".join(lines))
 
-        return
-
     def closeDocument(self) -> None:
         """Run close document tasks."""
         # Replace fields if there are stats available
@@ -181,20 +178,16 @@ class ToMarkdown(Tokenizer):
             lines.append("\n")
             self._pages.append("".join(lines))
 
-        return
-
     def saveDocument(self, path: Path) -> None:
         """Save the data to a plain text file."""
         with open(path, mode="w", encoding="utf-8") as outFile:
             outFile.write("".join(self._pages))
         logger.info("Wrote file: %s", path)
-        return
 
     def replaceTabs(self, nSpaces: int = 8, spaceChar: str = " ") -> None:
         """Replace tabs with spaces."""
         spaces = spaceChar*nSpaces
         self._pages = [p.replace("\t", spaces) for p in self._pages]
-        return
 
     ##
     #  Internal Functions