Merge pull request #253 from transifex/support-rtl-on-docx

Support RTL in ms formats

Author: igavriil

openformats/formats/customizable_xml.py

@@ -173,7 +173,9 @@ def parse(self, content, **kwargs):
         template = transcriber.get_destination()
         return template, stringset
 
-    def compile(self, template, stringset, is_source=True, language_info=None):
+    def compile(
+        self, template, stringset, is_source=True, language_info=None, **kwargs
+    ):
         """Compile the given `template` by replacing all hash placeholders
         with the translations found in `stringset`.
 

openformats/formats/docx.py

@@ -12,6 +12,7 @@
 from openformats.handlers import Handler
 from openformats.formats.office_open_xml.parser import OfficeOpenXmlHandler
 
+
 class DocxFile(object):
     """
     A class used to wrap and expose the internals of a .docx file
@@ -81,6 +82,7 @@ class DocxFile(object):
     </Relationships>
     ```
     """
+
     def __init__(self, content):
         self.__tmp_folder = "{}/{}".format(
             tempfile.gettempdir(), uuid.uuid4().hex
@@ -230,6 +232,24 @@ def remove_text_element(cls, text_element):
         else:
             text_element.decompose()
 
+    @classmethod
+    def set_rtl_orientation(cls, paragraph):
+        soup = BeautifulSoup("", "xml")
+        ppr_tags = paragraph.find_all("w:pPr")
+        for ppr_tag in ppr_tags:
+            if ppr_tag.bidi is not None:
+                ppr_tag.bidi.decompose()
+            bidi_tag = soup.new_tag("w:bidi", **{"w:val": "1"})
+            ppr_tag.append(bidi_tag)
+
+
+        rpr_tags = paragraph.find_all("w:rPr")
+        for rpr_tag in rpr_tags:
+            if rpr_tag.rtl is not None:
+                rpr_tag.rtl.decompose()
+            rtl = soup.new_tag("w:rtl", **{"w:val": "1"})
+            rpr_tag.append(rtl)
+
     def parse(self, content, **kwargs):
         """
         We will segment the text by paragraph `<w:p>` as this
@@ -272,9 +292,12 @@ def compile(self, template, stringset, **kwargs):
         docx = DocxFile(template)
         soup = BeautifulSoup(docx.get_document(), 'xml')
         rels_soup = BeautifulSoup(docx.get_document_rels(), 'xml')
+        is_rtl = kwargs.get('is_rtl', False)
 
         for paragraph in soup.find_all('w:p'):
-            self.compile_paragraph(paragraph, rels_soup, stringset)
+            self.compile_paragraph(
+                paragraph, rels_soup, stringset, is_rtl=is_rtl
+            )
 
         docx.set_document(six.text_type(soup))
         docx.set_document_rels(six.text_type(rels_soup))

openformats/formats/office_open_xml/parser.py

@@ -28,6 +28,10 @@ def remove_hyperlink(cls, text_element):
     def remove_text_element(cls, text_element):
         raise NotImplementedError
 
+    @classmethod
+    def set_rtl_orientation(cls, paragraph):
+        raise NotImplementedError
+
     @classmethod
     def swap_hyperlink_elements(
         cls, added_hl_text_elements, deleted_hl_text_elements
@@ -158,7 +162,7 @@ def parse_paragraph(cls, paragraph, rels_soup):
 
         return open_string
 
-    def compile_paragraph(cls, paragraph, rels_soup, stringset):
+    def compile_paragraph(cls, paragraph, rels_soup, stringset, is_rtl=False):
         text_elements = paragraph.find_all(cls.TEXT_ELEMENT_TAG)
         if not text_elements:
             return
@@ -188,6 +192,9 @@ def compile_paragraph(cls, paragraph, rels_soup, stringset):
 
         # First of all try to replace each element translation
         # this is the happiest path
+        if is_rtl:
+            cls.set_rtl_orientation(paragraph)
+
         for index, text_element in enumerate(text_elements):
             text = six.text_type(text_element.text)
 

openformats/formats/pptx.py

@@ -288,6 +288,14 @@ def remove_hyperlink(cls, text_element):
     def remove_text_element(cls, text_element):
         text_element.decompose()
 
+    @classmethod
+    def set_rtl_orientation(cls, paragraph):
+        ppr_tags = paragraph.find_all("a:pPr")
+        for ppr_tag in ppr_tags:
+            ppr_tag["rtl"] = "1"
+            if ppr_tag.get("algn") == "l":
+                ppr_tag["algn"] = "r"
+
     def parse(self, content, **kwargs):
         """
         We will segment the text by paragraph `<w:p>` as this
@@ -334,14 +342,16 @@ def compile(self, template, stringset, **kwargs):
             string.string_hash: string for string in stringset
         }
         pptx = PptxFile(template)
-
+        is_rtl = kwargs.get('is_rtl', False)
         for slide in pptx.get_slides():
             soup = BeautifulSoup(pptx.get_slide(slide), 'xml')
             rels_soup = BeautifulSoup(pptx.get_slide_rels(slide), 'xml')
 
             for parent in soup.find_all('p:sp'):
                 for paragraph in parent.find_all('a:p'):
-                    self.compile_paragraph(paragraph, rels_soup, stringset)
+                    self.compile_paragraph(
+                        paragraph, rels_soup, stringset, is_rtl=is_rtl
+                    )
 
             pptx.set_slide(slide, six.text_type(soup))
             pptx.set_slide_rels(slide, six.text_type(rels_soup))

openformats/handlers.py

@@ -74,7 +74,7 @@ def parse(self, content, is_source=False):
 
         raise NotImplementedError('Abstract method')  # pragma: no cover
 
-    def compile(self, template, stringset):
+    def compile(self, template, stringset, **kwargs):
         """
         Parses the template, finds the hashes, replaces them with strings from
         the stringset and returns the compiled file. If a hash in the template

openformats/tests/formats/docx/test_docx.py

@@ -221,8 +221,10 @@ def test_hyperlink_reorder(self):
         paragraph = soup.find_all('w:p')[0]
         text_elements = paragraph.find_all('w:t')
 
-        self.assertEqual(text_elements[3].parent.rPr.color, text_elements_bf_reorder[1].parent.rPr.color)
-        self.assertEqual(text_elements[3].parent.rPr.u, text_elements_bf_reorder[1].parent.rPr.u)
+        self.assertEqual(text_elements[3].parent.rPr.color,
+                         text_elements_bf_reorder[1].parent.rPr.color)
+        self.assertEqual(text_elements[3].parent.rPr.u,
+                         text_elements_bf_reorder[1].parent.rPr.u)
         self.assertEqual(text_elements[1].parent.rPr.color, None)
         self.assertEqual(text_elements[1].parent.rPr.u, None)
 
@@ -865,3 +867,33 @@ def test_lt(self):
         self.assertEqual(openstring.order, 0)
         self.assertEqual(openstring.string, translation)
         self.assertEqual(openstring.string, openstring.key)
+
+    def test_rtl(self):
+        path = '{}/hello_world.docx'.format(self.TESTFILE_BASE)
+        with open(path, 'rb') as f:
+            content = f.read()
+        handler = DocxHandler()
+        template, stringset = handler.parse(content)
+        openstring = stringset[0]
+
+        # Compile with altered translation
+        translation = u'<tx>Καλημέρα κόσμε </tx><tx href="https://el.transifex.com/">αυτός είναι ένας κρίκος</tx>'  # noqa
+        stringset = [
+            OpenString(openstring.key, translation, order=1)
+        ]
+
+        content = handler.compile(template, stringset, is_rtl=True)
+        docx = DocxFile(content)
+        soup = BeautifulSoup(docx.get_document(), 'xml')
+        self.assertEqual(len(stringset), 1)
+        self.assertEqual(len(soup.find_all("w:bidi")), 1)
+        for pPr in soup.find_all("w:pPr"):
+            self.assertEqual(len(pPr.findChildren("w:bidi")), 1)
+            for bidi in pPr.findChildren("w:bidi"):
+                self.assertEqual(bidi["w:val"], "1")
+
+        self.assertTrue(len(soup.find_all("w:rtl")), 1)
+        for rPr in soup.find_all("w:rPr"):
+            self.assertEqual(len(rPr.findChildren("w:rtl")), 1)
+            for rtl in rPr.findChildren("w:rtl"):
+                self.assertEqual(rtl["w:val"], "1")

openformats/tests/formats/pptx/files/rtl.pptx

@@ -594,3 +594,46 @@ def test_pptx_file_with_autofield(self):
         slide = u'/ppt/slides/slide1.xml'
         for text in [u'Title', u'text']:
             self.assertTrue(text in pptx.get_slide(slide))
+
+    def test_rtl(self):
+        path = '{}/rtl.pptx'.format(self.TESTFILE_BASE)
+        with open(path, 'rb') as f:
+            content = f.read()
+
+        slide = u'/ppt/slides/slide1.xml'
+
+        pptx = PptxFile(content)
+        soup = BeautifulSoup(pptx.get_slide(slide), 'xml')
+        l_algn = []
+        r_algn = []
+        ctr_algn = []
+        just_algn = []
+        for index, pPr in enumerate(soup.find_all("a:pPr")):
+            self.assertTrue(pPr["algn"] in ["just", "r", "l", "ctr"])
+            if pPr["algn"] == "l":
+                l_algn.append(index)
+            if pPr["algn"] == "r":
+                r_algn.append(index)
+            if pPr["algn"] == "ctr":
+                ctr_algn.append(index)
+            if pPr["algn"] == "just":
+                just_algn.append(index)
+
+        handler = PptxHandler()
+        template, stringset = handler.parse(content)
+
+        content = handler.compile(template, stringset, is_rtl=True)
+
+        pptx = PptxFile(content)
+        soup = BeautifulSoup(pptx.get_slide(slide), 'xml')
+        for index, pPr in enumerate(soup.find_all("a:pPr")):
+            self.assertEqual(pPr["rtl"], "1")
+            self.assertTrue(pPr["algn"] in ["just", "r", "ctr"])
+            if index in l_algn:
+                self.assertEqual(pPr["algn"], "r")
+            if index in r_algn:
+                self.assertEqual(pPr["algn"], "r")
+            if index in ctr_algn:
+                self.assertEqual(pPr["algn"], "ctr")
+            if index in just_algn:
+                self.assertEqual(pPr["algn"], "just")