support different newline encodings

Author: clouless

lib/macro_storage_format_parser.py

@@ -14,6 +14,21 @@ def __init__(
         self.forceUUIDsZeroed = forceUUIDsZeroed
         self.util = Util(forceUUIDsZeroed)
 
+    def _split_macro_body_on_content_block(self, macro_body: str) -> tuple[str, str]:
+        if "[content]\r\n" in macro_body:
+            splitted = macro_body.split("[content]\r\n", 1)
+            return (splitted[0], splitted[1])
+        if "[content]\r" in macro_body:
+            splitted = macro_body.split("[content]\r", 1)
+            return (splitted[0], splitted[1])
+        if "[content]\n\r" in macro_body:
+            splitted = macro_body.split("[content]\n\r", 1)
+            return (splitted[0], splitted[1])
+        if "[content]\n" in macro_body:
+            splitted = macro_body.split("[content]\n", 1)
+            return (splitted[0], splitted[1])
+        return ("ERROR SPLITTING AT [CONTENT]", "ERROR: INVALID NEWLINE")
+
     def transform(self):
         builder = MacroStorageFormatBuilder(self.extensionkey, self.forceUUIDsZeroed)
         print("START > reading storage format file from: " + self.inputfile)
@@ -70,14 +85,16 @@ def transform(self):
                             macro_code = child.text
                             macro_config = ""
                         elif macro_name == "advanced-codeblock-macro":
-                            if "[content]\n" not in child.text:
+                            if "[content]" not in child.text:
                                 print(
                                     ">> ERROR: no [content] element in macro body found!"
                                 )
                                 macro_code = "ERROR - COULD NOT PARSE"
                                 macro_config = "ERROR - COULD NOT PARSE"
                             else:
-                                config_and_code = child.text.split("[content]\n", 1)
+                                config_and_code = (
+                                    self._split_macro_body_on_content_block(child.text)
+                                )
                                 macro_code = config_and_code[1]
                                 macro_config = config_and_code[0]
                         elif macro_name == "advanced-remote-codeblock-macro":

lib/test_macro_storage_format_parser.py

@@ -67,3 +67,57 @@ def test_transform___valid_remote(self):
         parser.transform()
         # THEN
         self.assertListEqual(list(open(output_file)), list(open(expected_output_file)))
+
+    def test_transform___newlines(self):
+        self.maxDiff = None
+        # INIT
+        input_file = "./lib/input/ac-remote-test1.input.storage"
+        output_file = "./lib/output/ac-remote-test1.output.storage"
+        extension_key = (
+            "9a81c16f-31e6-4be7-be6e-dfc872fe4155/35d2082a-431b-46b7-90da-75a526882f2f"
+        )
+        parser = MacroStorageFormatParser(input_file, output_file, extension_key, True)
+        # ###########################################################################
+        # CASE1: \r\n
+        #
+        # GIVEN
+        macro_body1 = "foo\n[content]\r\nbar"
+        # WHEN
+        result1 = parser._split_macro_body_on_content_block(macro_body1)
+        # THEN
+        self.assertTrue(isinstance(result1, tuple))
+        self.assertEqual(result1[0], "foo\n")
+        self.assertEqual(result1[1], "bar")
+        # ###########################################################################
+        # CASE2: \r
+        #
+        # GIVEN
+        macro_body2 = "foo\r[content]\rbar"
+        # WHEN
+        result2 = parser._split_macro_body_on_content_block(macro_body2)
+        # THEN
+        self.assertTrue(isinstance(result2, tuple))
+        self.assertEqual(result2[0], "foo\r")
+        self.assertEqual(result2[1], "bar")
+        # ###########################################################################
+        # CASE3: \r\n
+        #
+        # GIVEN
+        macro_body3 = "foo\r[content]\r\nbar"
+        # WHEN
+        result3 = parser._split_macro_body_on_content_block(macro_body3)
+        # THEN
+        self.assertTrue(isinstance(result3, tuple))
+        self.assertEqual(result3[0], "foo\r")
+        self.assertEqual(result3[1], "bar")
+        # ###########################################################################
+        # CASE4: \n
+        #
+        # GIVEN
+        macro_body4 = "foo\n[content]\nbar"
+        # WHEN
+        result4 = parser._split_macro_body_on_content_block(macro_body4)
+        # THEN
+        self.assertTrue(isinstance(result4, tuple))
+        self.assertEqual(result4[0], "foo\n")
+        self.assertEqual(result4[1], "bar")