ben
/
mwparserfromhell
mirror of https://github.com/earwig/mwparserfromhell
1
1
Fork 0
Code Releases 24 Activity
A Python parser for MediaWiki wikicode https://mwparserfromhell.readthedocs.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
876 Commits
1 Branch
8.1 MiB
 
 
 
 
Tree: 1c983d3738
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1c983d3738'
${ noResults }
mwparserfromhell/tests/test_wikicode.py

522 lines
25 KiB
Raw Blame History 

  1. #

  2. # Copyright (C) 2012-2020 Ben Kurtovic <ben.kurtovic@gmail.com>

  3. #

  4. # Permission is hereby granted, free of charge, to any person obtaining a copy

  5. # of this software and associated documentation files (the "Software"), to deal

  6. # in the Software without restriction, including without limitation the rights

  7. # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  8. # copies of the Software, and to permit persons to whom the Software is

  9. # furnished to do so, subject to the following conditions:

  10. #

  11. # The above copyright notice and this permission notice shall be included in

  12. # all copies or substantial portions of the Software.

  13. #

  14. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  15. # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  16. # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  17. # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  18. # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  19. # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  20. # SOFTWARE.

  21. 

  22. from functools import partial

  23. import re

  24. from types import GeneratorType

  25. import unittest

  26. 

  27. from mwparserfromhell.nodes import Argument, Heading, Template, Text

  28. from mwparserfromhell.smart_list import SmartList

  29. from mwparserfromhell.wikicode import Wikicode

  30. from mwparserfromhell import parse

  31. 

  32. from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext

  33. 

  34. class TestWikicode(TreeEqualityTestCase):

  35.     """Tests for the Wikicode class, which manages a list of nodes."""

  36. 

  37.     def test_str(self):

  38.         """test Wikicode.__str__()"""

  39.         code1 = parse("foobar")

  40.         code2 = parse("Have a {{template}} and a [[page|link]]")

  41.         self.assertEqual("foobar", str(code1))

  42.         self.assertEqual("Have a {{template}} and a [[page|link]]", str(code2))

  43. 

  44.     def test_nodes(self):

  45.         """test getter/setter for the nodes attribute"""

  46.         code = parse("Have a {{template}}")

  47.         self.assertEqual(["Have a ", "{{template}}"], code.nodes)

  48.         L1 = SmartList([Text("foobar"), Template(wraptext("abc"))])

  49.         L2 = [Text("barfoo"), Template(wraptext("cba"))]

  50.         L3 = "abc{{def}}"

  51.         code.nodes = L1

  52.         self.assertIs(L1, code.nodes)

  53.         code.nodes = L2

  54.         self.assertIs(L2, code.nodes)

  55.         code.nodes = L3

  56.         self.assertEqual(["abc", "{{def}}"], code.nodes)

  57.         self.assertRaises(ValueError, setattr, code, "nodes", object)

  58. 

  59.     def test_get(self):

  60.         """test Wikicode.get()"""

  61.         code = parse("Have a {{template}} and a [[page|link]]")

  62.         self.assertIs(code.nodes[0], code.get(0))

  63.         self.assertIs(code.nodes[2], code.get(2))

  64.         self.assertRaises(IndexError, code.get, 4)

  65. 

  66.     def test_set(self):

  67.         """test Wikicode.set()"""

  68.         code = parse("Have a {{template}} and a [[page|link]]")

  69.         code.set(1, "{{{argument}}}")

  70.         self.assertEqual("Have a {{{argument}}} and a [[page|link]]", code)

  71.         self.assertIsInstance(code.get(1), Argument)

  72.         code.set(2, None)

  73.         self.assertEqual("Have a {{{argument}}}[[page|link]]", code)

  74.         code.set(-3, "This is an ")

  75.         self.assertEqual("This is an {{{argument}}}[[page|link]]", code)

  76.         self.assertRaises(ValueError, code.set, 1, "foo {{bar}}")

  77.         self.assertRaises(IndexError, code.set, 3, "{{baz}}")

  78.         self.assertRaises(IndexError, code.set, -4, "{{baz}}")

  79. 

  80.     def test_contains(self):

  81.         """test Wikicode.contains()"""

  82.         code = parse("Here is {{aaa|{{bbb|xyz{{ccc}}}}}} and a [[page|link]]")

  83.         tmpl1, tmpl2, tmpl3 = code.filter_templates()

  84.         tmpl4 = parse("{{ccc}}").filter_templates()[0]

  85.         self.assertTrue(code.contains(tmpl1))

  86.         self.assertTrue(code.contains(tmpl3))

  87.         self.assertFalse(code.contains(tmpl4))

  88.         self.assertTrue(code.contains(str(tmpl4)))

  89.         self.assertTrue(code.contains(tmpl2.params[0].value))

  90. 

  91.     def test_index(self):

  92.         """test Wikicode.index()"""

  93.         code = parse("Have a {{template}} and a [[page|link]]")

  94.         self.assertEqual(0, code.index("Have a "))

  95.         self.assertEqual(3, code.index("[[page|link]]"))

  96.         self.assertEqual(1, code.index(code.get(1)))

  97.         self.assertRaises(ValueError, code.index, "foo")

  98. 

  99.         code = parse("{{foo}}{{bar|{{baz}}}}")

  100.         self.assertEqual(1, code.index("{{bar|{{baz}}}}"))

  101.         self.assertEqual(1, code.index("{{baz}}", recursive=True))

  102.         self.assertEqual(1, code.index(code.get(1).get(1).value,

  103.                                        recursive=True))

  104.         self.assertRaises(ValueError, code.index, "{{baz}}", recursive=False)

  105.         self.assertRaises(ValueError, code.index,

  106.                           code.get(1).get(1).value, recursive=False)

  107. 

  108.     def test_get_ancestors_parent(self):

  109.         """test Wikicode.get_ancestors() and Wikicode.get_parent()"""

  110.         code = parse("{{a|{{b|{{d|{{e}}{{f}}}}{{g}}}}}}{{c}}")

  111.         tmpl = code.filter_templates(matches=lambda n: n.name == "f")[0]

  112.         parent1 = code.filter_templates(matches=lambda n: n.name == "d")[0]

  113.         parent2 = code.filter_templates(matches=lambda n: n.name == "b")[0]

  114.         parent3 = code.filter_templates(matches=lambda n: n.name == "a")[0]

  115.         fake = parse("{{f}}").get(0)

  116. 

  117.         self.assertEqual([parent3, parent2, parent1], code.get_ancestors(tmpl))

  118.         self.assertIs(parent1, code.get_parent(tmpl))

  119.         self.assertEqual([], code.get_ancestors(parent3))

  120.         self.assertIs(None, code.get_parent(parent3))

  121.         self.assertRaises(ValueError, code.get_ancestors, fake)

  122.         self.assertRaises(ValueError, code.get_parent, fake)

  123. 

  124.     def test_insert(self):

  125.         """test Wikicode.insert()"""

  126.         code = parse("Have a {{template}} and a [[page|link]]")

  127.         code.insert(1, "{{{argument}}}")

  128.         self.assertEqual(

  129.             "Have a {{{argument}}}{{template}} and a [[page|link]]", code)

  130.         self.assertIsInstance(code.get(1), Argument)

  131.         code.insert(2, None)

  132.         self.assertEqual(

  133.             "Have a {{{argument}}}{{template}} and a [[page|link]]", code)

  134.         code.insert(-3, Text("foo"))

  135.         self.assertEqual(

  136.             "Have a {{{argument}}}foo{{template}} and a [[page|link]]", code)

  137. 

  138.         code2 = parse("{{foo}}{{bar}}{{baz}}")

  139.         code2.insert(1, "abc{{def}}ghi[[jk]]")

  140.         self.assertEqual("{{foo}}abc{{def}}ghi[[jk]]{{bar}}{{baz}}", code2)

  141.         self.assertEqual(["{{foo}}", "abc", "{{def}}", "ghi", "[[jk]]",

  142.                           "{{bar}}", "{{baz}}"], code2.nodes)

  143. 

  144.         code3 = parse("{{foo}}bar")

  145.         code3.insert(1000, "[[baz]]")

  146.         code3.insert(-1000, "derp")

  147.         self.assertEqual("derp{{foo}}bar[[baz]]", code3)

  148. 

  149.     def _test_search(self, meth, expected):

  150.         """Base test for insert_before(), insert_after(), and replace()."""

  151.         code = parse("{{a}}{{b}}{{c}}{{d}}{{e}}")

  152.         func = partial(meth, code)

  153.         func("{{b}}", "x", recursive=True)

  154.         func("{{d}}", "[[y]]", recursive=False)

  155.         func(code.get(2), "z")

  156.         self.assertEqual(expected[0], code)

  157.         self.assertRaises(ValueError, func, "{{r}}", "n", recursive=True)

  158.         self.assertRaises(ValueError, func, "{{r}}", "n", recursive=False)

  159.         fake = parse("{{a}}").get(0)

  160.         self.assertRaises(ValueError, func, fake, "n", recursive=True)

  161.         self.assertRaises(ValueError, func, fake, "n", recursive=False)

  162. 

  163.         code2 = parse("{{a}}{{a}}{{a}}{{b}}{{b}}{{b}}")

  164.         func = partial(meth, code2)

  165.         func(code2.get(1), "c", recursive=False)

  166.         func("{{a}}", "d", recursive=False)

  167.         func(code2.get(-1), "e", recursive=True)

  168.         func("{{b}}", "f", recursive=True)

  169.         self.assertEqual(expected[1], code2)

  170. 

  171.         code3 = parse("{{a|{{b}}|{{c|d={{f}}}}}}")

  172.         func = partial(meth, code3)

  173.         obj = code3.get(0).params[0].value.get(0)

  174.         self.assertRaises(ValueError, func, obj, "x", recursive=False)

  175.         func(obj, "x", recursive=True)

  176.         self.assertRaises(ValueError, func, "{{f}}", "y", recursive=False)

  177.         func("{{f}}", "y", recursive=True)

  178.         self.assertEqual(expected[2], code3)

  179. 

  180.         code4 = parse("{{a}}{{b}}{{c}}{{d}}{{e}}{{f}}{{g}}{{h}}{{i}}{{j}}")

  181.         func = partial(meth, code4)

  182.         fake = parse("{{b}}{{c}}")

  183.         self.assertRaises(ValueError, func, fake, "q", recursive=False)

  184.         self.assertRaises(ValueError, func, fake, "q", recursive=True)

  185.         func("{{b}}{{c}}", "w", recursive=False)

  186.         func("{{d}}{{e}}", "x", recursive=True)

  187.         func(Wikicode(code4.nodes[-2:]), "y", recursive=False)

  188.         func(Wikicode(code4.nodes[-2:]), "z", recursive=True)

  189.         self.assertEqual(expected[3], code4)

  190.         self.assertRaises(ValueError, func, "{{c}}{{d}}", "q", recursive=False)

  191.         self.assertRaises(ValueError, func, "{{c}}{{d}}", "q", recursive=True)

  192. 

  193.         code5 = parse("{{a|{{b}}{{c}}|{{f|{{g}}={{h}}{{i}}}}}}")

  194.         func = partial(meth, code5)

  195.         self.assertRaises(ValueError, func, "{{b}}{{c}}", "x", recursive=False)

  196.         func("{{b}}{{c}}", "x", recursive=True)

  197.         obj = code5.get(0).params[1].value.get(0).params[0].value

  198.         self.assertRaises(ValueError, func, obj, "y", recursive=False)

  199.         func(obj, "y", recursive=True)

  200.         self.assertEqual(expected[4], code5)

  201. 

  202.         code6 = parse("here is {{some text and a {{template}}}}")

  203.         func = partial(meth, code6)

  204.         self.assertRaises(ValueError, func, "text and", "ab", recursive=False)

  205.         func("text and", "ab", recursive=True)

  206.         self.assertRaises(ValueError, func, "is {{some", "cd", recursive=False)

  207.         func("is {{some", "cd", recursive=True)

  208.         self.assertEqual(expected[5], code6)

  209. 

  210.         code7 = parse("{{foo}}{{bar}}{{baz}}{{foo}}{{baz}}")

  211.         func = partial(meth, code7)

  212.         obj = wrap([code7.get(0), code7.get(2)])

  213.         self.assertRaises(ValueError, func, obj, "{{lol}}")

  214.         func("{{foo}}{{baz}}", "{{lol}}")

  215.         self.assertEqual(expected[6], code7)

  216. 

  217.         code8 = parse("== header ==")

  218.         func = partial(meth, code8)

  219.         sec1, sec2 = code8.get_sections(include_headings=False)

  220.         func(sec1, "lead\n")

  221.         func(sec2, "\nbody")

  222.         self.assertEqual(expected[7], code8)

  223. 

  224.         code9 = parse("{{foo}}")

  225.         meth(code9.get_sections()[0], code9.get_sections()[0], "{{bar}}")

  226.         meth(code9.get_sections()[0], code9, "{{baz}}")

  227.         meth(code9, code9, "{{qux}}")

  228.         meth(code9, code9.get_sections()[0], "{{quz}}")

  229.         self.assertEqual(expected[8], code9)

  230. 

  231.     def test_insert_before(self):

  232.         """test Wikicode.insert_before()"""

  233.         meth = lambda code, *args, **kw: code.insert_before(*args, **kw)

  234.         expected = [

  235.             "{{a}}xz{{b}}{{c}}[[y]]{{d}}{{e}}",

  236.             "d{{a}}cd{{a}}d{{a}}f{{b}}f{{b}}ef{{b}}",

  237.             "{{a|x{{b}}|{{c|d=y{{f}}}}}}",

  238.             "{{a}}w{{b}}{{c}}x{{d}}{{e}}{{f}}{{g}}{{h}}yz{{i}}{{j}}",

  239.             "{{a|x{{b}}{{c}}|{{f|{{g}}=y{{h}}{{i}}}}}}",

  240.             "here cdis {{some abtext and a {{template}}}}",

  241.             "{{foo}}{{bar}}{{baz}}{{lol}}{{foo}}{{baz}}",

  242.             "lead\n== header ==\nbody",

  243.             "{{quz}}{{qux}}{{baz}}{{bar}}{{foo}}",

  244.         ]

  245.         self._test_search(meth, expected)

  246. 

  247.     def test_insert_after(self):

  248.         """test Wikicode.insert_after()"""

  249.         meth = lambda code, *args, **kw: code.insert_after(*args, **kw)

  250.         expected = [

  251.             "{{a}}{{b}}xz{{c}}{{d}}[[y]]{{e}}",

  252.             "{{a}}d{{a}}dc{{a}}d{{b}}f{{b}}f{{b}}fe",

  253.             "{{a|{{b}}x|{{c|d={{f}}y}}}}",

  254.             "{{a}}{{b}}{{c}}w{{d}}{{e}}x{{f}}{{g}}{{h}}{{i}}{{j}}yz",

  255.             "{{a|{{b}}{{c}}x|{{f|{{g}}={{h}}{{i}}y}}}}",

  256.             "here is {{somecd text andab a {{template}}}}",

  257.             "{{foo}}{{bar}}{{baz}}{{foo}}{{baz}}{{lol}}",

  258.             "lead\n== header ==\nbody",

  259.             "{{foo}}{{bar}}{{baz}}{{qux}}{{quz}}",

  260.         ]

  261.         self._test_search(meth, expected)

  262. 

  263.     def test_replace(self):

  264.         """test Wikicode.replace()"""

  265.         meth = lambda code, *args, **kw: code.replace(*args, **kw)

  266.         expected = [

  267.             "{{a}}xz[[y]]{{e}}",

  268.             "dcdffe",

  269.             "{{a|x|{{c|d=y}}}}",

  270.             "{{a}}wx{{f}}{{g}}z",

  271.             "{{a|x|{{f|{{g}}=y}}}}",

  272.             "here cd ab a {{template}}}}",

  273.             "{{foo}}{{bar}}{{baz}}{{lol}}",

  274.             "lead\n== header ==\nbody",

  275.             "{{quz}}",

  276.         ]

  277.         self._test_search(meth, expected)

  278. 

  279.     def test_append(self):

  280.         """test Wikicode.append()"""

  281.         code = parse("Have a {{template}}")

  282.         code.append("{{{argument}}}")

  283.         self.assertEqual("Have a {{template}}{{{argument}}}", code)

  284.         self.assertIsInstance(code.get(2), Argument)

  285.         code.append(None)

  286.         self.assertEqual("Have a {{template}}{{{argument}}}", code)

  287.         code.append(Text(" foo"))

  288.         self.assertEqual("Have a {{template}}{{{argument}}} foo", code)

  289.         self.assertRaises(ValueError, code.append, slice(0, 1))

  290. 

  291.     def test_remove(self):

  292.         """test Wikicode.remove()"""

  293.         meth = lambda code, obj, value, **kw: code.remove(obj, **kw)

  294.         expected = [

  295.             "{{a}}{{c}}",

  296.             "",

  297.             "{{a||{{c|d=}}}}",

  298.             "{{a}}{{f}}",

  299.             "{{a||{{f|{{g}}=}}}}",

  300.             "here   a {{template}}}}",

  301.             "{{foo}}{{bar}}{{baz}}",

  302.             "== header ==",

  303.             "",

  304.         ]

  305.         self._test_search(meth, expected)

  306. 

  307.     def test_matches(self):

  308.         """test Wikicode.matches()"""

  309.         code1 = parse("Cleanup")

  310.         code2 = parse("\nstub<!-- TODO: make more specific -->")

  311.         code3 = parse("Hello world!")

  312.         code4 = parse("World,_hello?")

  313.         code5 = parse("")

  314.         self.assertTrue(code1.matches("Cleanup"))

  315.         self.assertTrue(code1.matches("cleanup"))

  316.         self.assertTrue(code1.matches("  cleanup\n"))

  317.         self.assertFalse(code1.matches("CLEANup"))

  318.         self.assertFalse(code1.matches("Blah"))

  319.         self.assertTrue(code2.matches("stub"))

  320.         self.assertTrue(code2.matches("Stub<!-- no, it's fine! -->"))

  321.         self.assertFalse(code2.matches("StuB"))

  322.         self.assertTrue(code1.matches(("cleanup", "stub")))

  323.         self.assertTrue(code2.matches(("cleanup", "stub")))

  324.         self.assertFalse(code2.matches(("StuB", "sTUb", "foobar")))

  325.         self.assertFalse(code2.matches(["StuB", "sTUb", "foobar"]))

  326.         self.assertTrue(code2.matches(("StuB", "sTUb", "foo", "bar", "Stub")))

  327.         self.assertTrue(code2.matches(["StuB", "sTUb", "foo", "bar", "Stub"]))

  328.         self.assertTrue(code3.matches("hello world!"))

  329.         self.assertTrue(code3.matches("hello_world!"))

  330.         self.assertFalse(code3.matches("hello__world!"))

  331.         self.assertTrue(code4.matches("World,_hello?"))

  332.         self.assertTrue(code4.matches("World, hello?"))

  333.         self.assertFalse(code4.matches("World,  hello?"))

  334.         self.assertTrue(code5.matches(""))

  335.         self.assertTrue(code5.matches("<!-- nothing -->"))

  336.         self.assertTrue(code5.matches(("a", "b", "")))

  337. 

  338.     def test_filter_family(self):

  339.         """test the Wikicode.i?filter() family of functions"""

  340.         def genlist(gen):

  341.             self.assertIsInstance(gen, GeneratorType)

  342.             return list(gen)

  343.         ifilter = lambda code: (lambda *a, **k: genlist(code.ifilter(*a, **k)))

  344. 

  345.         code = parse("a{{b}}c[[d]]{{{e}}}{{f}}[[g]]")

  346.         for func in (code.filter, ifilter(code)):

  347.             self.assertEqual(["a", "{{b}}", "b", "c", "[[d]]", "d", "{{{e}}}",

  348.                               "e", "{{f}}", "f", "[[g]]", "g"], func())

  349.             self.assertEqual(["{{{e}}}"], func(forcetype=Argument))

  350.             self.assertIs(code.get(4), func(forcetype=Argument)[0])

  351.             self.assertEqual(list("abcdefg"), func(forcetype=Text))

  352.             self.assertEqual([], func(forcetype=Heading))

  353.             self.assertRaises(TypeError, func, forcetype=True)

  354. 

  355.         funcs = [

  356.             lambda name, **kw: getattr(code, "filter_" + name)(**kw),

  357.             lambda name, **kw: genlist(getattr(code, "ifilter_" + name)(**kw))

  358.         ]

  359.         for get_filter in funcs:

  360.             self.assertEqual(["{{{e}}}"], get_filter("arguments"))

  361.             self.assertIs(code.get(4), get_filter("arguments")[0])

  362.             self.assertEqual([], get_filter("comments"))

  363.             self.assertEqual([], get_filter("external_links"))

  364.             self.assertEqual([], get_filter("headings"))

  365.             self.assertEqual([], get_filter("html_entities"))

  366.             self.assertEqual([], get_filter("tags"))

  367.             self.assertEqual(["{{b}}", "{{f}}"], get_filter("templates"))

  368.             self.assertEqual(list("abcdefg"), get_filter("text"))

  369.             self.assertEqual(["[[d]]", "[[g]]"], get_filter("wikilinks"))

  370. 

  371.         code2 = parse("{{a|{{b}}|{{c|d={{f}}{{h}}}}}}")

  372.         for func in (code2.filter, ifilter(code2)):

  373.             self.assertEqual(["{{a|{{b}}|{{c|d={{f}}{{h}}}}}}"],

  374.                              func(recursive=False, forcetype=Template))

  375.             self.assertEqual(["{{a|{{b}}|{{c|d={{f}}{{h}}}}}}", "{{b}}",

  376.                               "{{c|d={{f}}{{h}}}}", "{{f}}", "{{h}}"],

  377.                              func(recursive=True, forcetype=Template))

  378. 

  379.         code3 = parse("{{foobar}}{{FOO}}{{baz}}{{bz}}{{barfoo}}")

  380.         for func in (code3.filter, ifilter(code3)):

  381.             self.assertEqual(["{{foobar}}", "{{barfoo}}"],

  382.                              func(False, matches=lambda node: "foo" in node))

  383.             self.assertEqual(["{{foobar}}", "{{FOO}}", "{{barfoo}}"],

  384.                              func(False, matches=r"foo"))

  385.             self.assertEqual(["{{foobar}}", "{{FOO}}"],

  386.                              func(matches=r"^{{foo.*?}}"))

  387.             self.assertEqual(["{{foobar}}"],

  388.                              func(matches=r"^{{foo.*?}}", flags=re.UNICODE))

  389.             self.assertEqual(["{{baz}}", "{{bz}}"], func(matches=r"^{{b.*?z"))

  390.             self.assertEqual(["{{baz}}"], func(matches=r"^{{b.+?z}}"))

  391. 

  392.         exp_rec = ["{{a|{{b}}|{{c|d={{f}}{{h}}}}}}", "{{b}}",

  393.                         "{{c|d={{f}}{{h}}}}", "{{f}}", "{{h}}"]

  394.         exp_unrec = ["{{a|{{b}}|{{c|d={{f}}{{h}}}}}}"]

  395.         self.assertEqual(exp_rec, code2.filter_templates())

  396.         self.assertEqual(exp_unrec, code2.filter_templates(recursive=False))

  397.         self.assertEqual(exp_rec, code2.filter_templates(recursive=True))

  398.         self.assertEqual(exp_rec, code2.filter_templates(True))

  399.         self.assertEqual(exp_unrec, code2.filter_templates(False))

  400. 

  401.         self.assertEqual(["{{foobar}}"], code3.filter_templates(

  402.             matches=lambda node: node.name.matches("Foobar")))

  403.         self.assertEqual(["{{baz}}", "{{bz}}"],

  404.                          code3.filter_templates(matches=r"^{{b.*?z"))

  405.         self.assertEqual([], code3.filter_tags(matches=r"^{{b.*?z"))

  406.         self.assertEqual([], code3.filter_tags(matches=r"^{{b.*?z", flags=0))

  407. 

  408.         self.assertRaises(TypeError, code.filter_templates, a=42)

  409.         self.assertRaises(TypeError, code.filter_templates, forcetype=Template)

  410.         self.assertRaises(TypeError, code.filter_templates, 1, 0, 0, Template)

  411. 

  412.         code4 = parse("{{foo}}<b>{{foo|{{bar}}}}</b>")

  413.         actual1 = code4.filter_templates(recursive=code4.RECURSE_OTHERS)

  414.         actual2 = code4.filter_templates(code4.RECURSE_OTHERS)

  415.         self.assertEqual(["{{foo}}", "{{foo|{{bar}}}}"], actual1)

  416.         self.assertEqual(["{{foo}}", "{{foo|{{bar}}}}"], actual2)

  417. 

  418.     def test_get_sections(self):

  419.         """test Wikicode.get_sections()"""

  420.         page1 = parse("")

  421.         page2 = parse("==Heading==")

  422.         page3 = parse("===Heading===\nFoo bar baz\n====Gnidaeh====\n")

  423. 

  424.         p4_lead = "This is a lead.\n"

  425.         p4_IA = "=== Section I.A ===\nSection I.A [[body]].\n"

  426.         p4_IB1 = "==== Section I.B.1 ====\nSection I.B.1 body.\n\n&bull;Some content.\n\n"

  427.         p4_IB = "=== Section I.B ===\n" + p4_IB1

  428.         p4_I = "== Section I ==\nSection I body. {{and a|template}}\n" + p4_IA + p4_IB

  429.         p4_II = "== Section II ==\nSection II body.\n\n"

  430.         p4_IIIA1a = "===== Section III.A.1.a =====\nMore text.\n"

  431.         p4_IIIA2ai1 = "======= Section III.A.2.a.i.1 =======\nAn invalid section!"

  432.         p4_IIIA2 = "==== Section III.A.2 ====\nEven more text.\n" + p4_IIIA2ai1

  433.         p4_IIIA = "=== Section III.A ===\nText.\n" + p4_IIIA1a + p4_IIIA2

  434.         p4_III = "== Section III ==\n" + p4_IIIA

  435.         page4 = parse(p4_lead + p4_I + p4_II + p4_III)

  436. 

  437.         self.assertEqual([""], page1.get_sections())

  438.         self.assertEqual(["", "==Heading=="], page2.get_sections())

  439.         self.assertEqual(["", "===Heading===\nFoo bar baz\n====Gnidaeh====\n",

  440.                           "====Gnidaeh====\n"], page3.get_sections())

  441.         self.assertEqual([p4_lead, p4_I, p4_IA, p4_IB, p4_IB1, p4_II,

  442.                           p4_III, p4_IIIA, p4_IIIA1a, p4_IIIA2, p4_IIIA2ai1],

  443.                          page4.get_sections())

  444. 

  445.         self.assertEqual(["====Gnidaeh====\n"], page3.get_sections(levels=[4]))

  446.         self.assertEqual(["===Heading===\nFoo bar baz\n====Gnidaeh====\n"],

  447.                          page3.get_sections(levels=(2, 3)))

  448.         self.assertEqual(["===Heading===\nFoo bar baz\n"],

  449.                          page3.get_sections(levels=(2, 3), flat=True))

  450.         self.assertEqual([], page3.get_sections(levels=[0]))

  451.         self.assertEqual(["", "====Gnidaeh====\n"],

  452.                          page3.get_sections(levels=[4], include_lead=True))

  453.         self.assertEqual(["===Heading===\nFoo bar baz\n====Gnidaeh====\n",

  454.                           "====Gnidaeh====\n"],

  455.                          page3.get_sections(include_lead=False))

  456.         self.assertEqual(["===Heading===\nFoo bar baz\n", "====Gnidaeh====\n"],

  457.                          page3.get_sections(flat=True, include_lead=False))

  458. 

  459.         self.assertEqual([p4_IB1, p4_IIIA2], page4.get_sections(levels=[4]))

  460.         self.assertEqual([p4_IA, p4_IB, p4_IIIA], page4.get_sections(levels=[3]))

  461.         self.assertEqual([p4_IA, "=== Section I.B ===\n",

  462.                           "=== Section III.A ===\nText.\n"],

  463.                          page4.get_sections(levels=[3], flat=True))

  464.         self.assertEqual(["", ""], page2.get_sections(include_headings=False))

  465.         self.assertEqual(["\nSection I.B.1 body.\n\n&bull;Some content.\n\n",

  466.                           "\nEven more text.\n" + p4_IIIA2ai1],

  467.                          page4.get_sections(levels=[4],

  468.                                             include_headings=False))

  469. 

  470.         self.assertEqual([], page4.get_sections(matches=r"body"))

  471.         self.assertEqual([p4_I, p4_IA, p4_IB, p4_IB1],

  472.                          page4.get_sections(matches=r"Section\sI[.\s].*?"))

  473.         self.assertEqual([p4_IA, p4_IIIA, p4_IIIA1a, p4_IIIA2, p4_IIIA2ai1],

  474.                          page4.get_sections(matches=r".*?a.*?"))

  475.         self.assertEqual([p4_IIIA1a, p4_IIIA2ai1],

  476.                          page4.get_sections(matches=r".*?a.*?", flags=re.U))

  477.         self.assertEqual(["\nMore text.\n", "\nAn invalid section!"],

  478.                          page4.get_sections(matches=r".*?a.*?", flags=re.U,

  479.                                             include_headings=False))

  480. 

  481.         sections = page2.get_sections(include_headings=False)

  482.         sections[0].append("Lead!\n")

  483.         sections[1].append("\nFirst section!")

  484.         self.assertEqual("Lead!\n==Heading==\nFirst section!", page2)

  485. 

  486.         page5 = parse("X\n== Foo ==\nBar\n== Baz ==\nBuzz")

  487.         section = page5.get_sections(matches="Foo")[0]

  488.         section.replace("\nBar\n", "\nBarf ")

  489.         section.append("{{Haha}}\n")

  490.         self.assertEqual("== Foo ==\nBarf {{Haha}}\n", section)

  491.         self.assertEqual("X\n== Foo ==\nBarf {{Haha}}\n== Baz ==\nBuzz", page5)

  492. 

  493.     def test_strip_code(self):

  494.         """test Wikicode.strip_code()"""

  495.         # Since individual nodes have test cases for their __strip__ methods,

  496.         # we're only going to do an integration test:

  497.         code = parse("Foo [[bar]]\n\n{{baz|hello}}\n\n[[a|b]] &Sigma;")

  498.         self.assertEqual("Foo bar\n\nb Σ",

  499.                          code.strip_code(normalize=True, collapse=True))

  500.         self.assertEqual("Foo bar\n\n\n\nb Σ",

  501.                          code.strip_code(normalize=True, collapse=False))

  502.         self.assertEqual("Foo bar\n\nb &Sigma;",

  503.                          code.strip_code(normalize=False, collapse=True))

  504.         self.assertEqual("Foo bar\n\n\n\nb &Sigma;",

  505.                          code.strip_code(normalize=False, collapse=False))

  506.         self.assertEqual("Foo bar\n\nhello\n\nb Σ",

  507.                          code.strip_code(normalize=True, collapse=True,

  508.                                          keep_template_params=True))

  509. 

  510.     def test_get_tree(self):

  511.         """test Wikicode.get_tree()"""

  512.         # Since individual nodes have test cases for their __showtree___

  513.         # methods, and the docstring covers all possibilities for the output of

  514.         # __showtree__, we'll test it only:

  515.         code = parse("Lorem ipsum {{foo|bar|{{baz}}|spam=eggs}}")

  516.         expected = "Lorem ipsum \n{{\n\t  foo\n\t| 1\n\t= bar\n\t| 2\n\t= " + \

  517.                    "{{\n\t\t\tbaz\n\t  }}\n\t| spam\n\t= eggs\n}}"

  518.         self.assertEqual(expected.expandtabs(4), code.get_tree())

  519. 

  520. if __name__ == "__main__":

  521.     unittest.main(verbosity=2)