discard """ outputsub: "" """ # tests for rstgen module. import ../../lib/packages/docutils/rstgen import ../../lib/packages/docutils/rst import unittest, strutils, strtabs suite "YAML syntax highlighting": test "Basics": let input = """.. code-block:: yaml %YAML 1.2 --- a string: string a list: - item 1 - item 2 a map: ? key : value ...""" let output = rstTohtml(input, {}, defaultConfig()) doAssert output == """
%YAML 1.2
---
a string: string
a list:
  - item 1
  - item 2
a map:
? key
: value
...
""" test "Block scalars": let input = """.. code-block:: yaml a literal block scalar: | some text # not a comment # a comment, since less indented # another comment a folded block scalar: >2 some text # not a comment since indented as specified # a comment another literal block scalar: |+ # comment after header allowed, since more indented than parent""" let output = rstToHtml(input, {}, defaultConfig()) doAssert output == """
a literal block scalar: |
  some text
  # not a comment
 # a comment, since less indented
  # another comment
a folded block scalar: >2
   some text
  # not a comment since indented as specified
 # a comment
another literal block scalar:
  |+ # comment after header
 allowed, since more indented than parent
""" test "Directives": let input = """.. code-block:: yaml %YAML 1.2 --- %not a directive ... %a directive ... a string % not a directive ... %TAG ! !foo:""" let output = rstToHtml(input, {}, defaultConfig()) doAssert output == """
%YAML 1.2
---
%not a directive
...
%a directive
...
a string
% not a directive
...
%TAG ! !foo:
""" test "Flow Style and Numbers": let input = """.. code-block:: yaml { "quoted string": 42, 'single quoted string': false, [ list, "with", 'entries' ]: 73.32e-73, more numbers: [-783, 11e78], not numbers: [ 42e, 0023, +32.37, 8 ball] }""" let output = rstToHtml(input, {}, defaultConfig()) doAssert output == """
{
  "quoted string": 42,
  'single quoted string': false,
  [ list, "with", 'entries' ]: 73.32e-73,
  more numbers: [-783, 11e78],
  not numbers: [ 42e, 0023, +32.37, 8 ball]
}
""" test "Anchors, Aliases, Tags": let input = """.. code-block:: yaml --- !!map !!str string: ! 42 ? &anchor !!seq []: : !localtag foo alias: *anchor """ let output = rstToHtml(input, {}, defaultConfig()) doAssert output == """
--- !!map
!!str string: !<tag:yaml.org,2002:int> 42
? &anchor !!seq []:
: !localtag foo
alias: *anchor
""" test "Edge cases": let input = """.. code-block:: yaml ... %a string: a:string:not:a:map ... not a list: -2 -3 -4 example.com/not/a#comment: ?not a map key """ let output = rstToHtml(input, {}, defaultConfig()) doAssert output == """
...
 %a string:
  a:string:not:a:map
...
not a list:
  -2
  -3
  -4
example.com/not/a#comment:
  ?not a map key
""" suite "RST/Markdown general": test "RST emphasis": doAssert rstToHtml("*Hello* **world**!", {}, newStringTable(modeStyleInsensitive)) == "Hello world!" test "Markdown links": let a = rstToHtml("(( [Nim](https://nim-lang.org/) ))", {roSupportMarkdown}, defaultConfig()) b = rstToHtml("(([Nim](https://nim-lang.org/)))", {roSupportMarkdown}, defaultConfig()) c = rstToHtml("[[Nim](https://nim-lang.org/)]", {roSupportMarkdown}, defaultConfig()) doAssert a == """(( Nim ))""" doAssert b == """((Nim))""" doAssert c == """[Nim]""" test "Markdown tables": let input1 = """ | A1 header | A2 \| not fooled | :--- | ----: | | C1 | C2 **bold** | ignored | | D1 `code \|` | D2 | also ignored | E1 \| text | | | F2 without pipe not in table""" let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) doAssert output1 == """
A1 headerA2 | not fooled
C1C2 bold
D1 code |D2
E1 | text
F2 without pipe

not in table

""" let input2 = """ | A1 header | A2 | | --- | --- |""" let output2 = rstToHtml(input2, {roSupportMarkdown}, defaultConfig()) doAssert output2 == """
A1 headerA2
""" test "RST tables": let input1 = """ Test 2 column/4 rows table: ==== === H0 H1 ==== === A0 A1 ==== === A2 A3 ==== === A4 A5 ==== === """ let output1 = rstToLatex(input1, {}) doAssert "{|X|X|}" in output1 # 2 columns doAssert count(output1, "\\\\") == 4 # 4 rows for cell in ["H0", "H1", "A0", "A1", "A2", "A3", "A4", "A5"]: doAssert cell in output1 let input2 = """ Now test 3 columns / 2 rows, and also borders containing 4 =, 3 =, 1 = signs: ==== === = H0 H1 H ==== === = A0 A1 X Ax Y ==== === = """ let output2 = rstToLatex(input2, {}) doAssert "{|X|X|X|}" in output2 # 3 columns doAssert count(output2, "\\\\") == 2 # 2 rows for cell in ["H0", "H1", "H", "A0", "A1", "X", "Ax", "Y"]: doAssert cell in output2 test "RST adornments": let input1 = """ Check that a few punctuation symbols are not parsed as adornments: :word1: word2 .... word3 """ let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) discard output1 test "RST sections": let input1 = """ Long chapter name ''''''''''''''''''' """ let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) doAssert "Long chapter name" in output1 and "" in output1 test "Markdown code block": let input1 = """ ``` let x = 1 ``` """ let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) doAssert "

line block
other line

" let output1l = rstToLatex(input1, {}) doAssert "line block\n\n" in output1l doAssert "other line\n\n" in output1l doAssert output1l.count("\\vspace") == 2 + 2 # +2 surrounding paddings let input2 = dedent""" Paragraph1 | Paragraph2""" let output2 = rstToHtml(input2, {roSupportMarkdown}, defaultConfig()) doAssert "Paragraph1


Paragraph2

\n" == output2 let input3 = dedent""" | xxx | yyy | zzz""" let output3 = rstToHtml(input3, {roSupportMarkdown}, defaultConfig()) doAssert "xxx
" in output3 doAssert "yyy
" in output3 doAssert "zzz
" in output3 # check that '| ' with a few spaces is still parsed as new line let input4 = dedent""" | xxx | | zzz""" let output4 = rstToHtml(input4, {roSupportMarkdown}, defaultConfig()) doAssert "xxx

" in output4 doAssert "zzz
" in output4 test "RST enumerated lists": let input1 = dedent """ 1. line1 1 2. line2 2 3. line3 3 4. line4 4 5. line5 5 """ let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) for i in 1..5: doAssert ($i & ". line" & $i) notin output1 doAssert ("
  • line" & $i & " " & $i & "
  • ") in output1 let input2 = dedent """ 3. line3 4. line4 5. line5 7. line7 8. line8 """ let output2 = rstToHtml(input2, {roSupportMarkdown}, defaultConfig()) for i in [3, 4, 5, 7, 8]: doAssert ($i & ". line" & $i) notin output2 doAssert ("
  • line" & $i & "
  • ") in output2 # check that nested enumerated lists work let input3 = dedent """ 1. a) string1 2. string2 """ let output3 = rstToHtml(input3, {roSupportMarkdown}, defaultConfig()) doAssert count(output3, "
      ") == 2 doAssert "
    1. string1
    2. " in output3 and "
    3. string2
    4. " in output3 let input4 = dedent """ Check that enumeration specifiers are respected 9. string1 10. string2 12. string3 b) string4 c) string5 e) string6 """ let output4 = rstToHtml(input4, {roSupportMarkdown}, defaultConfig()) doAssert count(output4, "
        ") == 4 for enumerator in [9, 12]: doAssert "start=\"$1\"" % [$enumerator] in output4 for enumerator in [2, 5]: # 2=b, 5=e doAssert "start=\"$1\"" % [$enumerator] in output4 let input5 = dedent """ Check that auto-numbered enumeration lists work. #. string1 #. string2 #. string3 #) string5 #) string6 """ let output5 = rstToHtml(input5, {roSupportMarkdown}, defaultConfig()) doAssert count(output5, "
          ") == 2 doAssert count(output5, "
        1. ") == 5 let input5a = dedent """ Auto-numbered RST list can start with 1 even when Markdown support is on. 1. string1 #. string2 #. string3 """ let output5a = rstToHtml(input5a, {roSupportMarkdown}, defaultConfig()) doAssert count(output5a, "
            ") == 1 doAssert count(output5a, "
          1. ") == 3 let input6 = dedent """ ... And for alphabetic enumerators too! b. string1 #. string2 #. string3 """ let output6 = rstToHtml(input6, {roSupportMarkdown}, defaultConfig()) doAssert count(output6, "
              ") == 1 doAssert count(output6, "
            1. ") == 3 doAssert "start=\"2\"" in output6 and "class=\"loweralpha simple\"" in output6 let input7 = dedent """ ... And for uppercase alphabetic enumerators. C. string1 #. string2 #. string3 """ let output7 = rstToHtml(input7, {roSupportMarkdown}, defaultConfig()) doAssert count(output7, "
                ") == 1 doAssert count(output7, "
              1. ") == 3 doAssert "start=\"3\"" in output7 and "class=\"upperalpha simple\"" in output7 test "Markdown enumerated lists": let input1 = dedent """ Below are 2 enumerated lists: Markdown-style (5 items) and RST (1 item) 1. line1 1. line2 1. line3 1. line4 1. line5 #. lineA """ let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) for i in 1..5: doAssert ($i & ". line" & $i) notin output1 doAssert ("
              2. line" & $i & "
              3. ") in output1 doAssert count(output1, "
                  ") == 2 test "RST bullet lists": let input1 = dedent """ * line1 1 * line2 2 * line3 3 * line4 4 * line5 5 """ let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) for i in 1..5: doAssert ("
                1. line" & $i & " " & $i & "
                2. ") in output1 doAssert count(output1, "
                    ") == 1 test "Nim (RST extension) code-block": # check that presence of fields doesn't consume the following text as # its code (which is a literal block) let input0 = dedent """ .. code-block:: nim :number-lines: 0 Paragraph1""" let output0 = rstToHtml(input0, {roSupportMarkdown}, defaultConfig()) doAssert "

                    Paragraph1

                    " in output0 test "RST admonitions": # check that all admonitions are implemented let input0 = dedent """ .. admonition:: endOf admonition .. attention:: endOf attention .. caution:: endOf caution .. danger:: endOf danger .. error:: endOf error .. hint:: endOf hint .. important:: endOf important .. note:: endOf note .. tip:: endOf tip .. warning:: endOf warning """ let output0 = rstToHtml(input0, {roSupportMarkdown}, defaultConfig()) for a in ["admonition", "attention", "caution", "danger", "error", "hint", "important", "note", "tip", "warning" ]: doAssert "endOf " & a & "" in output0 # Test that admonition does not swallow up the next paragraph. let input1 = dedent """ .. error:: endOfError Test paragraph. """ let output1 = rstToHtml(input1, {roSupportMarkdown}, defaultConfig()) doAssert "endOfError" in output1 doAssert "

                    Test paragraph.

                    " in output1 doAssert "class=\"admonition admonition-error\"" in output1 # Test that second line is parsed as continuation of the first line. let input2 = dedent """ .. error:: endOfError Test2p. Test paragraph. """ let output2 = rstToHtml(input2, {roSupportMarkdown}, defaultConfig()) doAssert "endOfError Test2p." in output2 doAssert "

                    Test paragraph.

                    " in output2 doAssert "class=\"admonition admonition-error\"" in output2 let input3 = dedent """ .. note:: endOfNote """ let output3 = rstToHtml(input3, {roSupportMarkdown}, defaultConfig()) doAssert "endOfNote" in output3 doAssert "class=\"admonition admonition-info\"" in output3 suite "RST/Code highlight": test "Basic Python code highlight": let pythonCode = """ .. code-block:: python def f_name(arg=42): print(f"{arg}") """ let expected = """

                    def f_name(arg=42): print(f"{arg}")

                    """ check strip(rstToHtml(pythonCode, {}, newStringTable(modeCaseSensitive))) == strip(expected)