HTML de-encapsulation works

Author: Sven Siegmund

src/rtfparse/entities.py

@@ -178,11 +178,15 @@ def __init__(self, config: config_loader.Config, file: io.BufferedReader) -> Non
                 self.structure.append(Control_Symbol(self.config, file))
             else:
                 self.structure.append(Plain_Text(self.config, file))
+        # name the group like its first Control Word
+        # this way the renderer will be able to ignore entire groups
+        try:
+            if isinstance(self.structure[0], Control_Word):
+                self.name = self.structure[0].control_name
+        except IndexError:
+            pass
     def __repr__(self) -> str:
-        cwinfo = ""
-        if isinstance(self.structure[0], Control_Word):
-            cwinfo = f" {self.structure[0].control_name}"
-        return f"<Group{cwinfo}>"
+        return f"<Group {self.name}>"
 
 
 if __name__ == "__main__":

src/rtfparse/entry.py

@@ -60,6 +60,9 @@ def run(config: config_loader.Config) -> None:
         import extract_msg as em
         import compressed_rtf as cr
         msg = em.openMsg(f"{config.cli_args.msg}")
+        for attachment in msg.attachments:
+            with open(config.html / f"{attachment.longFilename}", mode="wb") as att_file:
+                att_file.write(attachment.data)
         decompressed_rtf = cr.decompress(msg.compressedRtf)
         with open((config.email_rtf / config.cli_args.msg.name).with_suffix(".rtf"), mode="wb") as email_rtf:
             email_rtf.write(decompressed_rtf)
@@ -68,7 +71,7 @@ def run(config: config_loader.Config) -> None:
             rp.parse_file(config, rtf_file)
         from rtfparse.renderers import encapsulated_html
         renderer = encapsulated_html.Encapsulated_HTML()
-        with open((config.html / config.cli_args.msg.name).with_suffix(".html"), mode="w") as htmlfile:
+        with open((config.html / config.cli_args.msg.name).with_suffix(".html"), mode="w", encoding="utf-8") as htmlfile:
             logger.info(f"Rendering the encapsulated HTML")
             renderer.render(rp.parsed, htmlfile)
             logger.info(f"Encapsulated HTML rendered")

src/rtfparse/renderers/encapsulated_html.py

@@ -14,20 +14,81 @@
 
 
 class Encapsulated_HTML(Renderer):
-    def __init__(self) -> None:
+    def __init__(self, ) -> None:
         super().__init__()
-        self.render_func = dict((
-            ("par", lambda x: "\n"),
+        self.ignore_rtf = False
+        self.render_word_func = dict((
+            ("par", self.newline),
+            ("line", self.newline),
+            ("tab", self.tab),
+            ("fromhtml", self.check_fromhtml),
+            ("htmlrtf", self.ignore_rtf_toggle),
             ))
+        self.ignore_groups = (
+                "fonttbl",
+                "colortbl",
+            )
+    def ignore_rtf_toggle(self, cw: entities.Control_Word) -> str:
+        if cw.parameter == "" or cw.parameter == 1:
+            self.ignore_rtf = True
+        elif cw.parameter == 0:
+            self.ignore_rtf = False
+        return ""
+    def check_fromhtml(self, cw: entities.Control_Word) -> str:
+        if cw.parameter == 1:
+            logger.info(f"Confirming that RTF was indeed generated from HTML")
+        else:
+            logger.warning(utils.warn(f"Encountered a part of RTF which was not generated from HTML"))
+            logger.warning(utils.warn(f"This might not be the right renderer for it."))
+        return ""
+    def newline(self, cw: entities.Control_Word) -> str:
+        if self.ignore_rtf:
+            return ""
+        else:
+            return "\n"
+    def tab(self, cw: entities.Control_Word) -> str:
+        if self.ignore_rtf:
+            return ""
+        else:
+            return "\t"
+    def render_symbol(self, item: entities.Control_Symbol, file: io.TextIOWrapper) -> None:
+        if not self.ignore_rtf:
+            # Obsolete formula character used by Word 5.1 for Macintosh
+            if item.text == "|":
+                pass
+            # Non-breaking space
+            elif item.text == "~":
+                file.write("\u00a0")
+            # Optional hyphen
+            elif item.text == "-":
+                pass
+            # Non-breaking hyphen
+            elif item.text == "_":
+                file.write("\u2011")
+            # Subentry in an index entry
+            elif item.text == ":":
+                pass
+            # Ignorable outside of Group
+            elif item.text == "*":
+                logger.warning(utils.warn(f"Found an IGNORABLE control symbol which is not a group start!"))
+            # Probably any symbol converted from a hex code: \'hh
+            else:
+                file.write(item.text)
     def render(self, parsed: entities.Group, file: io.TextIOWrapper) -> None:
         for item in parsed.structure:
             if isinstance(item, entities.Group):
-                self.render(item, file)
+                if item.name not in self.ignore_groups:
+                    self.render(item, file)
             elif isinstance(item, entities.Control_Word):
                 try:
-                    file.write(self.render_func[item.control_name](item))
+                    file.write(self.render_word_func[item.control_name](item))
                 except KeyError:
                     pass
+            elif isinstance(item, entities.Control_Symbol):
+                self.render_symbol(item, file)
+            elif isinstance(item, entities.Plain_Text):
+                if not self.ignore_rtf:
+                    file.write(item.text)
             else:
                 pass
 

src/rtfparse/version.py

@@ -1,4 +1,4 @@
 #!/usr/bin/env python
 
 
-version = "0.5.1"
+version = "0.6.1"