Zendesk helpcenter components diff

sdiff/__init__.py

@@ -1,11 +1,13 @@
-from .parser import parse
+from typing import Type
+
+from .parser import parse, MdParser, ZendeskHelpMdParser  # noqa
 from .renderer import TextRenderer
 from .compare import diff_struct, diff_links  # noqa
 
 
-def diff(md1, md2, renderer=TextRenderer()):
-    tree1 = parse(md1)
-    tree2 = parse(md2)
+def diff(md1, md2, renderer=TextRenderer(), parser_cls: Type[MdParser] = MdParser):
+    tree1 = parse(md1, parser_cls)
+    tree2 = parse(md2, parser_cls)
 
     tree1, tree2, struct_errors = diff_struct(tree1, tree2)
     # tree1, tree2, links_errors = diff_links(tree1, tree2)

sdiff/model.py

@@ -1,5 +1,12 @@
+from abc import ABC
 from enum import Enum
 
+import typing
+from typing import Union
+
+if typing.TYPE_CHECKING:
+    from sdiff.renderer import HtmlRenderer, TextRenderer  # noqa
+
 
 class Symbols(Enum):
     null = ''
@@ -14,12 +21,18 @@ class Symbols(Enum):
     new_line = 'n'
 
 
+class ZendeskArtSymbols(Enum):
+    steps = 'S'
+    tabs = 'T'
+    callout = 'C'
+
+
 class Node(object):
     symbol = Symbols.null.value
     name = ''
 
     def __init__(self, nodes=None):
-        self.nodes = nodes or []
+        self.nodes: typing.List[Node] = nodes or []
         self.meta = {}
 
     def __str__(self):
@@ -110,6 +123,14 @@ def __init__(self, ordered, nodes=None):
         super().__init__(nodes)
         self.ordered = ordered
 
+    def __hash__(self):
+        return hash((self.symbol, self.ordered))
+
+    def __eq__(self, other):
+        if not isinstance(other, List):
+            return False
+        return self.ordered == other.ordered
+
     def __repr__(self):
         return repr({'type': self.name, 'meta': self.meta, 'nodes': self.nodes, 'ordered': self.ordered})
 
@@ -202,3 +223,58 @@ def __repr__(self):
 
     def original(self, renderer):
         return renderer.render_node(self, u'  \u00B6\n')
+
+
+class ZendeskHelpNode(Node, ABC):
+    def wrap(self, content: str) -> str:
+        return f'<{self.name}>\n\n{content}</{self.name}>\n'
+
+    def original(self, renderer: Union['HtmlRenderer', 'TextRenderer']) -> str:
+        nested_content = ''.join(node.original(renderer) for node in self.nodes)
+        result = self.wrap(nested_content)
+        return renderer.render_node(self, result)
+
+
+class ZendeskHelpSteps(ZendeskHelpNode):
+    symbol = ZendeskArtSymbols.steps.value
+    name = 'steps'
+
+    def wrap(self, content: str) -> str:
+        return f'<{self.name}>\n\n{content}</{self.name}>\n'
+
+    def original(self, renderer: Union['HtmlRenderer', 'TextRenderer']) -> str:
+        nested_content = ''.join(node.original(renderer) for node in self.nodes)
+        result = self.wrap(nested_content)
+        return renderer.render_node(self, result)
+
+
+class ZendeskHelpTabs(ZendeskHelpNode):
+    symbol = ZendeskArtSymbols.tabs.value
+    name = 'tabs'
+
+
+class ZendeskHelpCallout(ZendeskHelpNode):
+    symbol = ZendeskArtSymbols.callout.value
+    name = 'callout'
+
+    def __init__(self, style: str = None, nodes: typing.List[Node] = None):
+        super().__init__(nodes)
+        self.style = style
+
+    def __repr__(self):
+        return repr({'type': self.name, 'meta': self.meta, 'nodes': self.nodes, 'style': self.style})
+
+    def __hash__(self):
+        return hash((self.name, self.style))
+
+    def __eq__(self, other):
+        if not isinstance(other, ZendeskHelpCallout):
+            return False
+        return self.style == other.style
+
+    def wrap(self, content: str) -> str:
+        if self.style:
+            attr = f' {self.style}'
+        else:
+            attr = ''
+        return f'<{self.name}{attr}>\n\n{content}</{self.name}>\n'

sdiff/parser.py

@@ -1,3 +1,5 @@
+from typing import Match, Type
+
 import mistune
 import re
 
@@ -55,7 +57,7 @@ def parse_text(self, m):
             self.tokens.append(node)
 
 
-class BlockLexer(mistune.BlockLexer):
+class MdParser(mistune.BlockLexer):
     default_rules = [
         'newline', 'list_block', 'block_html',
         'heading', 'lheading',
@@ -67,6 +69,10 @@ class BlockLexer(mistune.BlockLexer):
         'hrule', 'list_block', 'text',
     )
 
+    @classmethod
+    def get_lexer(cls):
+        return cls()
+
     def __init__(self):
         super().__init__()
         self.grammar_class.block_html = re.compile(
@@ -156,13 +162,48 @@ def _process_list_item(self, cap, bull):
                     loose = _next
 
             node = ListItem()
-            block_lexer = BlockLexer()
+            block_lexer = self.get_lexer()
             nodes = block_lexer.parse(item, self.list_rules)
             node.add_nodes(nodes)
             result.append(node)
         return result
 
 
+class ZendeskHelpMdParser(MdParser):
+    TAG_CONTENT_GROUP = 'tag_content'
+    TAG_PATTERN = r'^\s*(<{tag_name}{attr_re}>(?P<%s>[\s\S]+?)</{tag_name}>)\s*$' % TAG_CONTENT_GROUP
+    CALLOUT_STYLE_GROUP = 'style'
+    CALLOUT_ATTR_PATTERN = r'( (?P<%s>green|red|yellow))*' % CALLOUT_STYLE_GROUP
+
+    def __init__(self):
+        super().__init__()
+        self.grammar_class.callout = re.compile(self.TAG_PATTERN.format(tag_name='callout',
+                                                                        attr_re=self.CALLOUT_ATTR_PATTERN))
+        self.default_rules.insert(0, 'callout')
+
+        self.grammar_class.steps = re.compile(self.TAG_PATTERN.format(tag_name='steps', attr_re=''))
+        self.default_rules.insert(0, 'steps')
+
+        self.grammar_class.tabs = re.compile(self.TAG_PATTERN.format(tag_name='tabs', attr_re=''))
+        self.default_rules.insert(0, 'tabs')
+
+    def parse_callout(self, m: Match[str]) -> None:
+        style = m.group(self.CALLOUT_STYLE_GROUP)
+        self._parse_nested(ZendeskHelpCallout(style), m)
+
+    def parse_steps(self, m: Match[str]) -> None:
+        self._parse_nested(ZendeskHelpSteps(), m)
+
+    def parse_tabs(self, m: Match[str]) -> None:
+        self._parse_nested(ZendeskHelpTabs(), m)
+
+    def _parse_nested(self, node: Node, m: Match[str]) -> None:
+        nested_content = m.group(self.TAG_CONTENT_GROUP)
+        nested_nodes = self.get_lexer().parse(nested_content)
+        node.add_nodes(nested_nodes)
+        self.tokens.append(node)
+
+
 def _remove_spaces_from_empty_lines(text):
     return '\n'.join([re.sub(r'^( {1,}|\t{1,})$', '\n', line) for line in text.splitlines()])
 
@@ -171,9 +212,9 @@ def _remove_ltr_rtl_marks(text):
     return re.sub(r'(\u200e|\u200f)', '', text)
 
 
-def parse(text):
+def parse(text, parser_cls: Type[MdParser] = MdParser):
     # HACK dirty hack to be consistent with Markdown list_block
     text = _remove_spaces_from_empty_lines(text)
     text = _remove_ltr_rtl_marks(text)
-    block_lexer = BlockLexer()
+    block_lexer = parser_cls()
     return Root(block_lexer.parse(text))

sdiff/renderer.py

@@ -1,6 +1,9 @@
+from sdiff.model import Root, Node
+
+
 class HtmlRenderer(object):
 
-    def render(self, tree):
+    def render(self, tree: Root):
         result = tree.original(self)
         return '<pre>\n%s\n</pre>' % result.strip()
 
@@ -14,9 +17,9 @@ def render_node(self, node, text):
 
 class TextRenderer(object):
 
-    def render(self, tree):
+    def render(self, tree: Root):
         result = tree.original(self)
         return result.strip()
 
-    def render_node(self, node, text):
+    def render_node(self, node: Node, text):
         return text

setup.py

@@ -2,7 +2,7 @@
 from setuptools import setup, find_packages
 
 
-version = '0.3.0'
+version = '0.4.0'
 
 
 def read(f):

tests/fixtures/different/zendesk_callout_in_tabs.de.md

@@ -0,0 +1,12 @@
+<tabs>
+
+#  Hallo
+
+<callout green>
+
+1. ein 
+2. zwei 
+
+</callout>
+
+</tabs>

tests/fixtures/different/zendesk_callout_in_tabs.en.md

@@ -0,0 +1,12 @@
+<tabs>
+
+#  Hello 
+
+<callout red>
+
+1. one 
+2. two 
+
+</callout>
+
+</tabs>

tests/fixtures/different/zendesk_steps.de.md

@@ -0,0 +1,6 @@
+<steps>
+
+* ein 
+* zwei 
+
+</steps>

tests/fixtures/different/zendesk_steps.en.md

@@ -0,0 +1,7 @@
+<steps>
+
+1. one 
+2. two 
+
+</steps>
+

tests/fixtures/same/zendesk_steps_in_tabs.de.md

@@ -0,0 +1,16 @@
+<tabs>
+
+#  Hallo
+
+<steps>
+
+1. ein 
+2. zwei 
+
+</steps>
+
+#  Zwei tab 
+
+content 
+
+</tabs>

tests/fixtures/same/zendesk_steps_in_tabs.en.md

@@ -0,0 +1,16 @@
+<tabs>
+
+#  Steps tab 
+
+<steps>
+
+1. one 
+2. two 
+
+</steps>
+
+#  Second tab 
+
+content 
+
+</tabs>

tests/fixtures/trees.py

@@ -29,9 +29,9 @@ def r4t():
     ])
 
 
-def lm2tm2t():
+def lm2tm2t(ordered=False):
     return Root([
-        List([
+        List(ordered, [
             ListItem([
                 Header(2, [
                     Text('dummy text')
@@ -93,3 +93,44 @@ def pta2t():
             Text('heading')
         ])
     ])
+
+
+def Slmtmt():  # noqa
+    return Root([
+        ZendeskHelpSteps([
+            List(True, [
+                ListItem([
+                    Text('one')
+                ]),
+                ListItem([
+                    Text('two')
+                ])
+            ])
+        ])
+    ])
+
+
+def T1tpt():  # noqa
+    return Root([
+        ZendeskHelpTabs([
+            Header(1, [
+                Text('tab title')
+            ]),
+            Paragraph([
+                Text('tab content')
+            ])
+        ])
+    ])
+
+
+def C1tpt(style=None):  # noqa
+    return Root([
+        ZendeskHelpCallout(style, [
+            Header(1, [
+                Text('callout title')
+            ]),
+            Paragraph([
+                Text('callout content')
+            ])
+        ])
+    ])