novelWriter 2.4.2__py3-none-any.whl → 2.5b1__py3-none-any.whl

novelwriter/core/{tomd.py → tomarkdown.py}

@@ -29,11 +29,50 @@ from pathlib import Path
 
 from novelwriter.constants import nwHeadFmt, nwLabels, nwUnicode
 from novelwriter.core.project import NWProject
-from novelwriter.core.tokenizer import Tokenizer
+from novelwriter.core.tokenizer import T_Formats, Tokenizer
 
 logger = logging.getLogger(__name__)
 
 
+# Standard Markdown
+STD_MD = {
+    Tokenizer.FMT_B_B: "**",
+    Tokenizer.FMT_B_E: "**",
+    Tokenizer.FMT_I_B: "_",
+    Tokenizer.FMT_I_E: "_",
+    Tokenizer.FMT_D_B: "",
+    Tokenizer.FMT_D_E: "",
+    Tokenizer.FMT_U_B: "",
+    Tokenizer.FMT_U_E: "",
+    Tokenizer.FMT_M_B: "",
+    Tokenizer.FMT_M_E: "",
+    Tokenizer.FMT_SUP_B: "",
+    Tokenizer.FMT_SUP_E: "",
+    Tokenizer.FMT_SUB_B: "",
+    Tokenizer.FMT_SUB_E: "",
+    Tokenizer.FMT_STRIP: "",
+}
+
+# Extended Markdown
+EXT_MD = {
+    Tokenizer.FMT_B_B: "**",
+    Tokenizer.FMT_B_E: "**",
+    Tokenizer.FMT_I_B: "_",
+    Tokenizer.FMT_I_E: "_",
+    Tokenizer.FMT_D_B: "~~",
+    Tokenizer.FMT_D_E: "~~",
+    Tokenizer.FMT_U_B: "",
+    Tokenizer.FMT_U_E: "",
+    Tokenizer.FMT_M_B: "==",
+    Tokenizer.FMT_M_E: "==",
+    Tokenizer.FMT_SUP_B: "^",
+    Tokenizer.FMT_SUP_E: "^",
+    Tokenizer.FMT_SUB_B: "~",
+    Tokenizer.FMT_SUB_E: "~",
+    Tokenizer.FMT_STRIP: "",
+}
+
+
 class ToMarkdown(Tokenizer):
     """Core: Markdown Document Writer
 
@@ -42,14 +81,11 @@ class ToMarkdown(Tokenizer):
     supports concatenating novelWriter markup files.
     """
 
-    M_STD = 0  # Standard Markdown
-    M_EXT = 1  # Extended Markdown
-
     def __init__(self, project: NWProject) -> None:
         super().__init__(project)
-        self._genMode = self.M_STD
         self._fullMD: list[str] = []
-        self._preserveBreaks = True
+        self._usedNotes: dict[str, int] = {}
+        self._extended = True
         return
 
     ##
@@ -65,19 +101,9 @@ class ToMarkdown(Tokenizer):
     #  Setters
     ##
 
-    def setStandardMarkdown(self) -> None:
-        """Set the converter to use standard Markdown formatting."""
-        self._genMode = self.M_STD
-        return
-
-    def setExtendedMarkdown(self) -> None:
+    def setExtendedMarkdown(self, state: bool) -> None:
         """Set the converter to use Extended Markdown formatting."""
-        self._genMode = self.M_EXT
-        return
-
-    def setPreserveBreaks(self, state: bool) -> None:
-        """Preserve line breaks in paragraphs."""
-        self._preserveBreaks = state
+        self._extended = state
         return
 
     ##
@@ -90,58 +116,21 @@ class ToMarkdown(Tokenizer):
 
     def doConvert(self) -> None:
         """Convert the list of text tokens into a Markdown document."""
-        if self._genMode == self.M_STD:
-            # Standard Markdown
-            mdTags = {
-                self.FMT_B_B: "**",
-                self.FMT_B_E: "**",
-                self.FMT_I_B: "_",
-                self.FMT_I_E: "_",
-                self.FMT_D_B: "",
-                self.FMT_D_E: "",
-                self.FMT_U_B: "",
-                self.FMT_U_E: "",
-                self.FMT_M_B: "",
-                self.FMT_M_E: "",
-                self.FMT_SUP_B: "",
-                self.FMT_SUP_E: "",
-                self.FMT_SUB_B: "",
-                self.FMT_SUB_E: "",
-            }
-            cSkip = ""
-        else:
-            # Extended Markdown
-            mdTags = {
-                self.FMT_B_B: "**",
-                self.FMT_B_E: "**",
-                self.FMT_I_B: "_",
-                self.FMT_I_E: "_",
-                self.FMT_D_B: "~~",
-                self.FMT_D_E: "~~",
-                self.FMT_U_B: "",
-                self.FMT_U_E: "",
-                self.FMT_M_B: "==",
-                self.FMT_M_E: "==",
-                self.FMT_SUP_B: "^",
-                self.FMT_SUP_E: "^",
-                self.FMT_SUB_B: "~",
-                self.FMT_SUB_E: "~",
-            }
-            cSkip = nwUnicode.U_MMSP
-
         self._result = ""
 
-        para = []
-        lines = []
-        lineSep = "  \n" if self._preserveBreaks else " "
+        if self._extended:
+            mTags = EXT_MD
+            cSkip = nwUnicode.U_MMSP
+        else:
+            mTags = STD_MD
+            cSkip = ""
 
+        lines = []
         for tType, _, tText, tFormat, tStyle in self._tokens:
 
-            if tType == self.T_EMPTY:
-                if para:
-                    tTemp = (lineSep.join(para)).rstrip(" ")
-                    lines.append(f"{tTemp}\n\n")
-                para = []
+            if tType == self.T_TEXT:
+                tTemp = self._formatText(tText, tFormat, mTags).replace("\n", "  \n")
+                lines.append(f"{tTemp}\n\n")
 
             elif tType == self.T_TITLE:
                 tHead = tText.replace(nwHeadFmt.BR, "\n")
@@ -169,23 +158,17 @@ class ToMarkdown(Tokenizer):
             elif tType == self.T_SKIP:
                 lines.append(f"{cSkip}\n\n")
 
-            elif tType == self.T_TEXT:
-                tTemp = tText
-                for pos, fmt in reversed(tFormat):
-                    tTemp = f"{tTemp[:pos]}{mdTags[fmt]}{tTemp[pos:]}"
-                para.append(tTemp.rstrip())
-
             elif tType == self.T_SYNOPSIS and self._doSynopsis:
                 label = self._localLookup("Synopsis")
-                lines.append(f"**{label}:** {tText}\n\n")
+                lines.append(f"**{label}:** {self._formatText(tText, tFormat, mTags)}\n\n")
 
             elif tType == self.T_SHORT and self._doSynopsis:
                 label = self._localLookup("Short Description")
-                lines.append(f"**{label}:** {tText}\n\n")
+                lines.append(f"**{label}:** {self._formatText(tText, tFormat, mTags)}\n\n")
 
             elif tType == self.T_COMMENT and self._doComments:
                 label = self._localLookup("Comment")
-                lines.append(f"**{label}:** {tText}\n\n")
+                lines.append(f"**{label}:** {self._formatText(tText, tFormat, mTags)}\n\n")
 
             elif tType == self.T_KEYWORD and self._doKeywords:
                 lines.append(self._formatKeywords(tText, tStyle))
@@ -195,6 +178,27 @@ class ToMarkdown(Tokenizer):
 
         return
 
+    def appendFootnotes(self) -> None:
+        """Append the footnotes in the buffer."""
+        if self._usedNotes:
+            tags = EXT_MD if self._extended else STD_MD
+            footnotes = self._localLookup("Footnotes")
+
+            lines = []
+            lines.append(f"### {footnotes}\n\n")
+            for key, index in self._usedNotes.items():
+                if content := self._footnotes.get(key):
+                    marker = f"{index}. "
+                    text = self._formatText(*content, tags)
+                    lines.append(f"{marker}{text}\n")
+            lines.append("\n")
+
+            result = "".join(lines)
+            self._result += result
+            self._fullMD.append(result)
+
+        return
+
     def saveMarkdown(self, path: str | Path) -> None:
         """Save the data to a plain text file."""
         with open(path, mode="w", encoding="utf-8") as outFile:
@@ -206,14 +210,31 @@ class ToMarkdown(Tokenizer):
         """Replace tabs with spaces."""
         spaces = spaceChar*nSpaces
         self._fullMD = [p.replace("\t", spaces) for p in self._fullMD]
-        if self._keepMarkdown:
-            self._allMarkdown = [p.replace("\t", spaces) for p in self._allMarkdown]
+        if self._keepMD:
+            self._markdown = [p.replace("\t", spaces) for p in self._markdown]
         return
 
     ##
     #  Internal Functions
     ##
 
+    def _formatText(self, text: str, tFmt: T_Formats, tags: dict[int, str]) -> str:
+        """Apply formatting tags to text."""
+        temp = text
+        for pos, fmt, data in reversed(tFmt):
+            md = ""
+            if fmt == self.FMT_FNOTE:
+                if data in self._footnotes:
+                    index = len(self._usedNotes) + 1
+                    self._usedNotes[data] = index
+                    md = f"[{index}]"
+                else:
+                    md = "[ERR]"
+            else:
+                md = tags.get(fmt, "")
+            temp = f"{temp[:pos]}{md}{temp[pos:]}"
+        return temp
+
     def _formatKeywords(self, text: str, style: int) -> str:
         """Apply Markdown formatting to keywords."""
         valid, bits, _ = self._project.index.scanThis("@"+text)
@@ -229,5 +250,3 @@ class ToMarkdown(Tokenizer):
         result += "  \n" if style & self.A_Z_BTMMRG else "\n\n"
 
         return result
-
-# END Class ToMarkdown