From 8db40689edf51d6febfaae3340fc6af6d34329ad Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 20 Apr 2013 17:59:20 -0400 Subject: [PATCH 01/15] Improve a few things about nodes; simply a method in Wikicode. --- mwparserfromhell/nodes/html_entity.py | 47 ++++++++++++++++++++++++++++------- mwparserfromhell/nodes/wikilink.py | 5 +++- mwparserfromhell/wikicode.py | 8 +----- 3 files changed, 43 insertions(+), 17 deletions(-) diff --git a/mwparserfromhell/nodes/html_entity.py b/mwparserfromhell/nodes/html_entity.py index 5b7607c..1bf1c78 100644 --- a/mwparserfromhell/nodes/html_entity.py +++ b/mwparserfromhell/nodes/html_entity.py @@ -63,7 +63,8 @@ class HTMLEntity(Node): return self.normalize() return self - def _unichr(self, value): + @staticmethod + def _unichr(value): """Implement the builtin unichr() with support for non-BMP code points. On wide Python builds, this functions like the normal unichr(). On @@ -119,19 +120,47 @@ class HTMLEntity(Node): @value.setter def value(self, newval): newval = str(newval) - if newval not in htmlentities.entitydefs: - test = int(self.value, 16) - if test < 0 or (test > 0x10FFFF and int(self.value) > 0x10FFFF): - raise ValueError(newval) + try: + int(newval) + except ValueError: + try: + int(newval, 16) + except ValueError: + if newval not in htmlentities.entitydefs: + raise ValueError("entity value is not a valid name") + self._named = True + self._hexadecimal = False + else: + if int(newval, 16) < 0 or int(newval, 16) > 0x10FFFF: + raise ValueError("entity value is not in range(0x110000)") + self._named = False + self._hexadecimal = True + else: + test = int(newval, 16 if self.hexadecimal else 10) + if test < 0 or test > 0x10FFFF: + raise ValueError("entity value is not in range(0x110000)") + self._named = False self._value = newval @named.setter def named(self, newval): - self._named = bool(newval) + newval = bool(newval) + if newval and self.value not in htmlentities.entitydefs: + raise ValueError("entity value is not a valid name") + if not newval: + try: + int(self.value, 16) + except ValueError: + err = "current entity value is not a valid Unicode codepoint" + raise ValueError(err) + self._named = newval @hexadecimal.setter def hexadecimal(self, newval): - self._hexadecimal = bool(newval) + newval = bool(newval) + if newval and self.named: + raise ValueError("a named entity cannot be hexadecimal") + self._hexadecimal = newval @hex_char.setter def hex_char(self, newval): @@ -145,5 +174,5 @@ class HTMLEntity(Node): if self.named: return unichr(htmlentities.name2codepoint[self.value]) if self.hexadecimal: - return self._unichr(int(self.value, 16)) - return self._unichr(int(self.value)) + return HTMLEntity._unichr(int(self.value, 16)) + return HTMLEntity._unichr(int(self.value)) diff --git a/mwparserfromhell/nodes/wikilink.py b/mwparserfromhell/nodes/wikilink.py index 6fea468..527e9bb 100644 --- a/mwparserfromhell/nodes/wikilink.py +++ b/mwparserfromhell/nodes/wikilink.py @@ -79,4 +79,7 @@ class Wikilink(Node): @text.setter def text(self, value): - self._text = parse_anything(value) + if value is None: + self._text = None + else: + self._text = parse_anything(value) diff --git a/mwparserfromhell/wikicode.py b/mwparserfromhell/wikicode.py index 8d8ebe2..f2d9c89 100644 --- a/mwparserfromhell/wikicode.py +++ b/mwparserfromhell/wikicode.py @@ -88,13 +88,7 @@ class Wikicode(StringMixIn): If *obj* is a ``Node``, the function will test whether they are the same object, otherwise it will compare them with ``==``. """ - if isinstance(obj, Node): - if node is obj: - return True - else: - if node == obj: - return True - return False + return (node is obj) if isinstance(obj, Node) else (node == obj) def _contains(self, nodes, obj): """Return ``True`` if *obj* is inside of *nodes*, else ``False``. From 5cf451eb22aa47b119183eb25de141627d0e1ef7 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 20 Apr 2013 18:01:39 -0400 Subject: [PATCH 02/15] Adding a bunch of tests for different nodes. --- tests/test_argument.py | 99 ++++++++++++++++++++++++++ tests/test_comment.py | 62 +++++++++++++++++ tests/test_heading.py | 88 ++++++++++++++++++++++++ tests/test_html_entity.py | 172 ++++++++++++++++++++++++++++++++++++++++++++++ tests/test_text.py | 69 +++++++++++++++++++ tests/test_wikilink.py | 99 ++++++++++++++++++++++++++ 6 files changed, 589 insertions(+) create mode 100644 tests/test_argument.py create mode 100644 tests/test_comment.py create mode 100644 tests/test_heading.py create mode 100644 tests/test_html_entity.py create mode 100644 tests/test_text.py create mode 100644 tests/test_wikilink.py diff --git a/tests/test_argument.py b/tests/test_argument.py new file mode 100644 index 0000000..e0524c4 --- /dev/null +++ b/tests/test_argument.py @@ -0,0 +1,99 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import Argument, Text +from mwparserfromhell.smart_list import SmartList +from mwparserfromhell.wikicode import Wikicode + +from ._test_tree_equality import TreeEqualityTestCase + +wrap = lambda L: Wikicode(SmartList(L)) + +class TestArgument(TreeEqualityTestCase): + """Test cases for the Argument node.""" + + def test_unicode(self): + """test Argument.__unicode__()""" + node = Argument(wrap([Text("foobar")])) + self.assertEqual("{{{foobar}}}", str(node)) + node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + self.assertEqual("{{{foo|bar}}}", str(node2)) + + def test_strip(self): + """test Argument.__strip__()""" + node = Argument(wrap([Text("foobar")])) + self.assertIs(None, node.__strip__(True, True)) + self.assertIs(None, node.__strip__(True, False)) + self.assertIs(None, node.__strip__(False, True)) + self.assertIs(None, node.__strip__(False, False)) + + node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + self.assertEqual("bar", node2.__strip__(True, True)) + self.assertEqual("bar", node2.__strip__(True, False)) + self.assertEqual("bar", node2.__strip__(False, True)) + self.assertEqual("bar", node2.__strip__(False, False)) + + def test_showtree(self): + """test Argument.__showtree__()""" + output = [] + getter, marker = object(), object() + get = lambda code: output.append((getter, code)) + mark = lambda: output.append(marker) + node1 = Argument(wrap([Text("foobar")])) + node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + node1.__showtree__(output.append, get, mark) + node2.__showtree__(output.append, get, mark) + valid = [ + "{{{", (getter, node1.name), "}}}", "{{{", (getter, node2.name), + " | ", marker, (getter, node2.default), "}}}"] + self.assertEqual(valid, output) + + def test_name(self): + """test getter/setter for the name attribute""" + name = wrap([Text("foobar")]) + node1 = Argument(name) + node2 = Argument(name, wrap([Text("baz")])) + self.assertIs(name, node1.name) + self.assertIs(name, node2.name) + node1.name = "héhehé" + node2.name = "héhehé" + self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.name) + self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.name) + + def test_default(self): + """test getter/setter for the default attribute""" + default = wrap([Text("baz")]) + node1 = Argument(wrap([Text("foobar")])) + node2 = Argument(wrap([Text("foobar")]), default) + self.assertIs(None, node1.default) + self.assertIs(default, node2.default) + node1.default = "buzz" + node2.default = None + self.assertWikicodeEqual(wrap([Text("buzz")]), node1.default) + self.assertIs(None, node2.default) + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_comment.py b/tests/test_comment.py new file mode 100644 index 0000000..980f594 --- /dev/null +++ b/tests/test_comment.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import Comment + +from ._test_tree_equality import TreeEqualityTestCase + +class TestComment(TreeEqualityTestCase): + """Test cases for the Comment node.""" + + def test_unicode(self): + """test Comment.__unicode__()""" + node = Comment("foobar") + self.assertEqual("", str(node)) + + def test_strip(self): + """test Comment.__strip__()""" + node = Comment("foobar") + self.assertIs(None, node.__strip__(True, True)) + self.assertIs(None, node.__strip__(True, False)) + self.assertIs(None, node.__strip__(False, True)) + self.assertIs(None, node.__strip__(False, False)) + + def test_showtree(self): + """test Comment.__showtree__()""" + output = [] + node = Comment("foobar") + node.__showtree__(output.append, None, None) + self.assertEqual([""], output) + + def test_contents(self): + """test getter/setter for the contents attribute""" + node = Comment("foobar") + self.assertEqual("foobar", node.contents) + node.contents = "barfoo" + self.assertEqual("barfoo", node.contents) + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_heading.py b/tests/test_heading.py new file mode 100644 index 0000000..a0e78e5 --- /dev/null +++ b/tests/test_heading.py @@ -0,0 +1,88 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import Heading, Text +from mwparserfromhell.smart_list import SmartList +from mwparserfromhell.wikicode import Wikicode + +from ._test_tree_equality import TreeEqualityTestCase + +wrap = lambda L: Wikicode(SmartList(L)) + +class TestHeading(TreeEqualityTestCase): + """Test cases for the Heading node.""" + + def test_unicode(self): + """test Heading.__unicode__()""" + node = Heading(wrap([Text("foobar")]), 2) + self.assertEqual("==foobar==", str(node)) + node2 = Heading(wrap([Text(" zzz ")]), 5) + self.assertEqual("===== zzz =====", str(node2)) + + def test_strip(self): + """test Heading.__strip__()""" + node = Heading(wrap([Text("foobar")]), 3) + self.assertEqual("foobar", node.__strip__(True, True)) + self.assertEqual("foobar", node.__strip__(True, False)) + self.assertEqual("foobar", node.__strip__(False, True)) + self.assertEqual("foobar", node.__strip__(False, False)) + + def test_showtree(self): + """test Heading.__showtree__()""" + output = [] + getter = object() + get = lambda code: output.append((getter, code)) + node1 = Heading(wrap([Text("foobar")]), 3) + node2 = Heading(wrap([Text(" baz ")]), 4) + node1.__showtree__(output.append, get, None) + node2.__showtree__(output.append, get, None) + valid = ["===", (getter, node1.title), "===", + "====", (getter, node2.title), "===="] + self.assertEqual(valid, output) + + def test_title(self): + """test getter/setter for the title attribute""" + title = wrap([Text("foobar")]) + node = Heading(title, 3) + self.assertIs(title, node.title) + node.title = "héhehé" + self.assertWikicodeEqual(wrap([Text("héhehé")]), node.title) + + def test_level(self): + """test getter/setter for the level attribute""" + node = Heading(wrap([Text("foobar")]), 3) + self.assertEqual(3, node.level) + node.level = 5 + self.assertEqual(5, node.level) + node.level = True + self.assertEqual(1, node.level) + self.assertRaises(ValueError, setattr, node, "level", 0) + self.assertRaises(ValueError, setattr, node, "level", 7) + self.assertRaises(ValueError, setattr, node, "level", "abc") + self.assertRaises(ValueError, setattr, node, "level", False) + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_html_entity.py b/tests/test_html_entity.py new file mode 100644 index 0000000..20c8fc0 --- /dev/null +++ b/tests/test_html_entity.py @@ -0,0 +1,172 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import HTMLEntity +from mwparserfromhell.smart_list import SmartList +from mwparserfromhell.wikicode import Wikicode + +from ._test_tree_equality import TreeEqualityTestCase + +wrap = lambda L: Wikicode(SmartList(L)) + +class TestHTMLEntity(TreeEqualityTestCase): + """Test cases for the HTMLEntity node.""" + + def test_unicode(self): + """test HTMLEntity.__unicode__()""" + node1 = HTMLEntity("nbsp", named=True, hexadecimal=False) + node2 = HTMLEntity("107", named=False, hexadecimal=False) + node3 = HTMLEntity("6b", named=False, hexadecimal=True) + node4 = HTMLEntity("6C", named=False, hexadecimal=True, hex_char="X") + self.assertEqual(" ", str(node1)) + self.assertEqual("k", str(node2)) + self.assertEqual("k", str(node3)) + self.assertEqual("l", str(node4)) + + def test_strip(self): + """test HTMLEntity.__strip__()""" + node1 = HTMLEntity("nbsp", named=True, hexadecimal=False) + node2 = HTMLEntity("107", named=False, hexadecimal=False) + node3 = HTMLEntity("e9", named=False, hexadecimal=True) + + self.assertEqual("\xa0", node1.__strip__(True, True)) + self.assertEqual("\xa0", node1.__strip__(True, False)) + self.assertEqual(" ", node1.__strip__(False, True)) + self.assertEqual(" ", node1.__strip__(False, False)) + self.assertEqual("k", node2.__strip__(True, True)) + self.assertEqual("k", node2.__strip__(True, False)) + self.assertEqual("k", node2.__strip__(False, True)) + self.assertEqual("k", node2.__strip__(False, False)) + self.assertEqual("é", node3.__strip__(True, True)) + self.assertEqual("é", node3.__strip__(True, False)) + self.assertEqual("é", node3.__strip__(False, True)) + self.assertEqual("é", node3.__strip__(False, False)) + + def test_showtree(self): + """test HTMLEntity.__showtree__()""" + output = [] + node1 = HTMLEntity("nbsp", named=True, hexadecimal=False) + node2 = HTMLEntity("107", named=False, hexadecimal=False) + node3 = HTMLEntity("e9", named=False, hexadecimal=True) + node1.__showtree__(output.append, None, None) + node2.__showtree__(output.append, None, None) + node3.__showtree__(output.append, None, None) + res = [" ", "k", "é"] + self.assertEqual(res, output) + + def test_value(self): + """test HTMLEntity.value()""" + node1 = HTMLEntity("nbsp") + node2 = HTMLEntity("107") + node3 = HTMLEntity("e9") + self.assertEquals("nbsp", node1.value) + self.assertEquals("107", node2.value) + self.assertEquals("e9", node3.value) + + node1.value = "ffa4" + node2.value = 72 + node3.value = "Sigma" + self.assertEquals("ffa4", node1.value) + self.assertFalse(node1.named) + self.assertTrue(node1.hexadecimal) + self.assertEquals("72", node2.value) + self.assertFalse(node2.named) + self.assertFalse(node2.hexadecimal) + self.assertEquals("Sigma", node3.value) + self.assertTrue(node3.named) + self.assertFalse(node3.hexadecimal) + + node1.value = "10FFFF" + node2.value = 110000 + node2.value = 1114111 + self.assertRaises(ValueError, setattr, node3, "value", "") + self.assertRaises(ValueError, setattr, node3, "value", "foobar") + self.assertRaises(ValueError, setattr, node3, "value", True) + self.assertRaises(ValueError, setattr, node3, "value", -1) + self.assertRaises(ValueError, setattr, node1, "value", 110000) + self.assertRaises(ValueError, setattr, node1, "value", "1114112") + + def test_named(self): + """test HTMLEntity.named()""" + node1 = HTMLEntity("nbsp") + node2 = HTMLEntity("107") + node3 = HTMLEntity("e9") + self.assertTrue(node1.named) + self.assertFalse(node2.named) + self.assertFalse(node3.named) + node1.named = 1 + node2.named = 0 + node3.named = 0 + self.assertTrue(node1.named) + self.assertFalse(node2.named) + self.assertFalse(node3.named) + self.assertRaises(ValueError, setattr, node1, "named", False) + self.assertRaises(ValueError, setattr, node2, "named", True) + self.assertRaises(ValueError, setattr, node3, "named", True) + + def test_hexadecimal(self): + """test HTMLEntity.hexadecimal()""" + node1 = HTMLEntity("nbsp") + node2 = HTMLEntity("107") + node3 = HTMLEntity("e9") + self.assertFalse(node1.hexadecimal) + self.assertFalse(node2.hexadecimal) + self.assertTrue(node3.hexadecimal) + node1.hexadecimal = False + node2.hexadecimal = True + node3.hexadecimal = False + self.assertFalse(node1.hexadecimal) + self.assertTrue(node2.hexadecimal) + self.assertFalse(node3.hexadecimal) + self.assertRaises(ValueError, setattr, node1, "hexadecimal", True) + + def test_hex_char(self): + """test HTMLEntity.hex_char()""" + node1 = HTMLEntity("e9") + node2 = HTMLEntity("e9", hex_char="X") + self.assertEquals("x", node1.hex_char) + self.assertEquals("X", node2.hex_char) + node1.hex_char = "X" + node2.hex_char = "x" + self.assertEquals("X", node1.hex_char) + self.assertEquals("x", node2.hex_char) + self.assertRaises(ValueError, setattr, node1, "hex_char", 123) + self.assertRaises(ValueError, setattr, node1, "hex_char", "foobar") + self.assertRaises(ValueError, setattr, node1, "hex_char", True) + + def test_normalize(self): + """test HTMLEntity.normalize()""" + node1 = HTMLEntity("nbsp") + node2 = HTMLEntity("107") + node3 = HTMLEntity("e9") + node4 = HTMLEntity("1f648") + self.assertEquals("\xa0", node1.normalize()) + self.assertEquals("k", node2.normalize()) + self.assertEquals("é", node3.normalize()) + self.assertEquals("\U0001F648", node4.normalize()) + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_text.py b/tests/test_text.py new file mode 100644 index 0000000..13636bf --- /dev/null +++ b/tests/test_text.py @@ -0,0 +1,69 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import Text + +class TestText(unittest.TestCase): + """Test cases for the Text node.""" + + def test_unicode(self): + """test Text.__unicode__()""" + node = Text("foobar") + self.assertEqual("foobar", str(node)) + node2 = Text("fóóbar") + self.assertEqual("fóóbar", str(node2)) + + def test_strip(self): + """test Text.__strip__()""" + node = Text("foobar") + self.assertIs(node, node.__strip__(True, True)) + self.assertIs(node, node.__strip__(True, False)) + self.assertIs(node, node.__strip__(False, True)) + self.assertIs(node, node.__strip__(False, False)) + + def test_showtree(self): + """test Text.__showtree__()""" + output = [] + node1 = Text("foobar") + node2 = Text("fóóbar") + node3 = Text("𐌲𐌿𐍄") + node1.__showtree__(output.append, None, None) + node2.__showtree__(output.append, None, None) + node3.__showtree__(output.append, None, None) + res = ["foobar", r"f\xf3\xf3bar", "\\U00010332\\U0001033f\\U00010344"] + self.assertEqual(res, output) + + def test_value(self): + """test getter/setter for the value attribute""" + node = Text("foobar") + self.assertEqual("foobar", node.value) + self.assertIsInstance(node.value, str) + node.value = "héhéhé" + self.assertEqual("héhéhé", node.value) + self.assertIsInstance(node.value, str) + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_wikilink.py b/tests/test_wikilink.py new file mode 100644 index 0000000..422489f --- /dev/null +++ b/tests/test_wikilink.py @@ -0,0 +1,99 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import Text, Wikilink +from mwparserfromhell.smart_list import SmartList +from mwparserfromhell.wikicode import Wikicode + +from ._test_tree_equality import TreeEqualityTestCase + +wrap = lambda L: Wikicode(SmartList(L)) + +class TestWikilink(TreeEqualityTestCase): + """Test cases for the Wikilink node.""" + + def test_unicode(self): + """test Wikilink.__unicode__()""" + node = Wikilink(wrap([Text("foobar")])) + self.assertEqual("[[foobar]]", str(node)) + node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + self.assertEqual("[[foo|bar]]", str(node2)) + + def test_strip(self): + """test Wikilink.__strip__()""" + node = Wikilink(wrap([Text("foobar")])) + self.assertEqual("foobar", node.__strip__(True, True)) + self.assertEqual("foobar", node.__strip__(True, False)) + self.assertEqual("foobar", node.__strip__(False, True)) + self.assertEqual("foobar", node.__strip__(False, False)) + + node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + self.assertEqual("bar", node2.__strip__(True, True)) + self.assertEqual("bar", node2.__strip__(True, False)) + self.assertEqual("bar", node2.__strip__(False, True)) + self.assertEqual("bar", node2.__strip__(False, False)) + + def test_showtree(self): + """test Wikilink.__showtree__()""" + output = [] + getter, marker = object(), object() + get = lambda code: output.append((getter, code)) + mark = lambda: output.append(marker) + node1 = Wikilink(wrap([Text("foobar")])) + node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + node1.__showtree__(output.append, get, mark) + node2.__showtree__(output.append, get, mark) + valid = [ + "[[", (getter, node1.title), "]]", "[[", (getter, node2.title), + " | ", marker, (getter, node2.text), "]]"] + self.assertEqual(valid, output) + + def test_title(self): + """test getter/setter for the title attribute""" + title = wrap([Text("foobar")]) + node1 = Wikilink(title) + node2 = Wikilink(title, wrap([Text("baz")])) + self.assertIs(title, node1.title) + self.assertIs(title, node2.title) + node1.title = "héhehé" + node2.title = "héhehé" + self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.title) + self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.title) + + def test_text(self): + """test getter/setter for the text attribute""" + text = wrap([Text("baz")]) + node1 = Wikilink(wrap([Text("foobar")])) + node2 = Wikilink(wrap([Text("foobar")]), text) + self.assertIs(None, node1.text) + self.assertIs(text, node2.text) + node1.text = "buzz" + node2.text = None + self.assertWikicodeEqual(wrap([Text("buzz")]), node1.text) + self.assertIs(None, node2.text) + +if __name__ == "__main__": + unittest.main(verbosity=2) From 6bf8cfd2adcf536113f3a9ace3901b08540d7ff9 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 20 Apr 2013 18:09:34 -0400 Subject: [PATCH 03/15] Fix tests for Python 3. --- mwparserfromhell/nodes/html_entity.py | 55 ++++++++++++++++++----------------- tests/test_html_entity.py | 28 +++++++++--------- 2 files changed, 43 insertions(+), 40 deletions(-) diff --git a/mwparserfromhell/nodes/html_entity.py b/mwparserfromhell/nodes/html_entity.py index 1bf1c78..b51bd92 100644 --- a/mwparserfromhell/nodes/html_entity.py +++ b/mwparserfromhell/nodes/html_entity.py @@ -23,7 +23,7 @@ from __future__ import unicode_literals from . import Node -from ..compat import htmlentities, str +from ..compat import htmlentities, py3k, str __all__ = ["HTMLEntity"] @@ -63,29 +63,31 @@ class HTMLEntity(Node): return self.normalize() return self - @staticmethod - def _unichr(value): - """Implement the builtin unichr() with support for non-BMP code points. + if not py3k: + @staticmethod + def _unichr(value): + """Implement builtin unichr() with support for non-BMP code points. - On wide Python builds, this functions like the normal unichr(). On - narrow builds, this returns the value's corresponding surrogate pair. - """ - try: - return unichr(value) - except ValueError: - # Test whether we're on the wide or narrow Python build. Check the - # length of a non-BMP code point (U+1F64A, SPEAK-NO-EVIL MONKEY): - if len("\U0001F64A") == 2: - # Ensure this is within the range we can encode: - if value > 0x10FFFF: - raise ValueError("unichr() arg not in range(0x110000)") - code = value - 0x10000 - if value < 0: # Invalid code point - raise - lead = 0xD800 + (code >> 10) - trail = 0xDC00 + (code % (1 << 10)) - return unichr(lead) + unichr(trail) - raise + On wide Python builds, this functions like the normal unichr(). On + narrow builds, this returns the value's encoded surrogate pair. + """ + try: + return unichr(value) + except ValueError: + # Test whether we're on the wide or narrow Python build. Check + # the length of a non-BMP code point + # (U+1F64A, SPEAK-NO-EVIL MONKEY): + if len("\U0001F64A") == 2: + # Ensure this is within the range we can encode: + if value > 0x10FFFF: + raise ValueError("unichr() arg not in range(0x110000)") + code = value - 0x10000 + if value < 0: # Invalid code point + raise + lead = 0xD800 + (code >> 10) + trail = 0xDC00 + (code % (1 << 10)) + return unichr(lead) + unichr(trail) + raise @property def value(self): @@ -171,8 +173,9 @@ class HTMLEntity(Node): def normalize(self): """Return the unicode character represented by the HTML entity.""" + chrfunc = chr if py3k else HTMLEntity._unichr if self.named: - return unichr(htmlentities.name2codepoint[self.value]) + return chrfunc(htmlentities.name2codepoint[self.value]) if self.hexadecimal: - return HTMLEntity._unichr(int(self.value, 16)) - return HTMLEntity._unichr(int(self.value)) + return chrfunc(int(self.value, 16)) + return chrfunc(int(self.value)) diff --git a/tests/test_html_entity.py b/tests/test_html_entity.py index 20c8fc0..4bf32e8 100644 --- a/tests/test_html_entity.py +++ b/tests/test_html_entity.py @@ -82,20 +82,20 @@ class TestHTMLEntity(TreeEqualityTestCase): node1 = HTMLEntity("nbsp") node2 = HTMLEntity("107") node3 = HTMLEntity("e9") - self.assertEquals("nbsp", node1.value) - self.assertEquals("107", node2.value) - self.assertEquals("e9", node3.value) + self.assertEqual("nbsp", node1.value) + self.assertEqual("107", node2.value) + self.assertEqual("e9", node3.value) node1.value = "ffa4" node2.value = 72 node3.value = "Sigma" - self.assertEquals("ffa4", node1.value) + self.assertEqual("ffa4", node1.value) self.assertFalse(node1.named) self.assertTrue(node1.hexadecimal) - self.assertEquals("72", node2.value) + self.assertEqual("72", node2.value) self.assertFalse(node2.named) self.assertFalse(node2.hexadecimal) - self.assertEquals("Sigma", node3.value) + self.assertEqual("Sigma", node3.value) self.assertTrue(node3.named) self.assertFalse(node3.hexadecimal) @@ -147,12 +147,12 @@ class TestHTMLEntity(TreeEqualityTestCase): """test HTMLEntity.hex_char()""" node1 = HTMLEntity("e9") node2 = HTMLEntity("e9", hex_char="X") - self.assertEquals("x", node1.hex_char) - self.assertEquals("X", node2.hex_char) + self.assertEqual("x", node1.hex_char) + self.assertEqual("X", node2.hex_char) node1.hex_char = "X" node2.hex_char = "x" - self.assertEquals("X", node1.hex_char) - self.assertEquals("x", node2.hex_char) + self.assertEqual("X", node1.hex_char) + self.assertEqual("x", node2.hex_char) self.assertRaises(ValueError, setattr, node1, "hex_char", 123) self.assertRaises(ValueError, setattr, node1, "hex_char", "foobar") self.assertRaises(ValueError, setattr, node1, "hex_char", True) @@ -163,10 +163,10 @@ class TestHTMLEntity(TreeEqualityTestCase): node2 = HTMLEntity("107") node3 = HTMLEntity("e9") node4 = HTMLEntity("1f648") - self.assertEquals("\xa0", node1.normalize()) - self.assertEquals("k", node2.normalize()) - self.assertEquals("é", node3.normalize()) - self.assertEquals("\U0001F648", node4.normalize()) + self.assertEqual("\xa0", node1.normalize()) + self.assertEqual("k", node2.normalize()) + self.assertEqual("é", node3.normalize()) + self.assertEqual("\U0001F648", node4.normalize()) if __name__ == "__main__": unittest.main(verbosity=2) From 6a385b392190d9c4ce89c8cc8777efcb587972f5 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 20 Apr 2013 21:44:44 -0400 Subject: [PATCH 04/15] TestParameter and a fair chunk of TestTemplate. --- mwparserfromhell/nodes/template.py | 9 ++- tests/test_html_entity.py | 10 +-- tests/test_parameter.py | 79 +++++++++++++++++++++ tests/test_template.py | 140 +++++++++++++++++++++++++++++++++++++ 4 files changed, 228 insertions(+), 10 deletions(-) create mode 100644 tests/test_parameter.py create mode 100644 tests/test_template.py diff --git a/mwparserfromhell/nodes/template.py b/mwparserfromhell/nodes/template.py index e34ba7a..eb7f3a8 100644 --- a/mwparserfromhell/nodes/template.py +++ b/mwparserfromhell/nodes/template.py @@ -183,11 +183,10 @@ class Template(Node): def get(self, name): """Get the parameter whose name is *name*. - The returned object is a - :py:class:`~.Parameter` instance. Raises :py:exc:`ValueError` if no - parameter has this name. Since multiple parameters can have the same - name, we'll return the last match, since the last parameter is the only - one read by the MediaWiki parser. + The returned object is a :py:class:`~.Parameter` instance. Raises + :py:exc:`ValueError` if no parameter has this name. Since multiple + parameters can have the same name, we'll return the last match, since + the last parameter is the only one read by the MediaWiki parser. """ name = name.strip() if isinstance(name, basestring) else str(name) for param in reversed(self.params): diff --git a/tests/test_html_entity.py b/tests/test_html_entity.py index 4bf32e8..a7a9669 100644 --- a/tests/test_html_entity.py +++ b/tests/test_html_entity.py @@ -78,7 +78,7 @@ class TestHTMLEntity(TreeEqualityTestCase): self.assertEqual(res, output) def test_value(self): - """test HTMLEntity.value()""" + """test getter/setter for the value attribute""" node1 = HTMLEntity("nbsp") node2 = HTMLEntity("107") node3 = HTMLEntity("e9") @@ -110,7 +110,7 @@ class TestHTMLEntity(TreeEqualityTestCase): self.assertRaises(ValueError, setattr, node1, "value", "1114112") def test_named(self): - """test HTMLEntity.named()""" + """test getter/setter for the named attribute""" node1 = HTMLEntity("nbsp") node2 = HTMLEntity("107") node3 = HTMLEntity("e9") @@ -128,7 +128,7 @@ class TestHTMLEntity(TreeEqualityTestCase): self.assertRaises(ValueError, setattr, node3, "named", True) def test_hexadecimal(self): - """test HTMLEntity.hexadecimal()""" + """test getter/setter for the hexadecimal attribute""" node1 = HTMLEntity("nbsp") node2 = HTMLEntity("107") node3 = HTMLEntity("e9") @@ -144,7 +144,7 @@ class TestHTMLEntity(TreeEqualityTestCase): self.assertRaises(ValueError, setattr, node1, "hexadecimal", True) def test_hex_char(self): - """test HTMLEntity.hex_char()""" + """test getter/setter for the hex_char attribute""" node1 = HTMLEntity("e9") node2 = HTMLEntity("e9", hex_char="X") self.assertEqual("x", node1.hex_char) @@ -158,7 +158,7 @@ class TestHTMLEntity(TreeEqualityTestCase): self.assertRaises(ValueError, setattr, node1, "hex_char", True) def test_normalize(self): - """test HTMLEntity.normalize()""" + """test getter/setter for the normalize attribute""" node1 = HTMLEntity("nbsp") node2 = HTMLEntity("107") node3 = HTMLEntity("e9") diff --git a/tests/test_parameter.py b/tests/test_parameter.py new file mode 100644 index 0000000..b46ad71 --- /dev/null +++ b/tests/test_parameter.py @@ -0,0 +1,79 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import Text +from mwparserfromhell.nodes.extras import Parameter +from mwparserfromhell.smart_list import SmartList +from mwparserfromhell.wikicode import Wikicode + +from ._test_tree_equality import TreeEqualityTestCase + +wrap = lambda L: Wikicode(SmartList(L)) + +class TestParameter(TreeEqualityTestCase): + """Test cases for the Parameter node extra.""" + + def test_unicode(self): + """test Parameter.__unicode__()""" + node = Parameter(wrap([Text("1")]), wrap([Text("foo")]), showkey=False) + self.assertEqual("foo", str(node)) + node2 = Parameter(wrap([Text("foo")]), wrap([Text("bar")])) + self.assertEqual("foo=bar", str(node2)) + + def test_name(self): + """test getter/setter for the name attribute""" + name1 = wrap([Text("1")]) + name2 = wrap([Text("foobar")]) + node1 = Parameter(name1, wrap([Text("foobar")]), showkey=False) + node2 = Parameter(name2, wrap([Text("baz")])) + self.assertIs(name1, node1.name) + self.assertIs(name2, node2.name) + node1.name = "héhehé" + node2.name = "héhehé" + self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.name) + self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.name) + + def test_value(self): + """test getter/setter for the value attribute""" + value = wrap([Text("bar")]) + node = Parameter(wrap([Text("foo")]), value) + self.assertIs(value, node.value) + node.value = "héhehé" + self.assertWikicodeEqual(wrap([Text("héhehé")]), node.value) + + def test_showkey(self): + """test getter/setter for the showkey attribute""" + node1 = Parameter(wrap([Text("1")]), wrap([Text("foo")]), showkey=False) + node2 = Parameter(wrap([Text("foo")]), wrap([Text("bar")])) + self.assertFalse(node1.showkey) + self.assertTrue(node2.showkey) + node1.showkey = True + node2.showkey = "" + self.assertTrue(node1.showkey) + self.assertFalse(node2.showkey) + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_template.py b/tests/test_template.py new file mode 100644 index 0000000..fde7522 --- /dev/null +++ b/tests/test_template.py @@ -0,0 +1,140 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Ben Kurtovic +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import unicode_literals +import unittest + +from mwparserfromhell.compat import str +from mwparserfromhell.nodes import Template, Text +from mwparserfromhell.nodes.extras import Parameter +from mwparserfromhell.smart_list import SmartList +from mwparserfromhell.wikicode import Wikicode +from ._test_tree_equality import TreeEqualityTestCase + +wrap = lambda L: Wikicode(SmartList(L)) +pgens = lambda k, v: Parameter(wrap([Text(k)]), wrap([Text(v)]), True) +pgenh = lambda k, v: Parameter(wrap([Text(k)]), wrap([Text(v)]), False) + +class TestTemplate(TreeEqualityTestCase): + """Test cases for the Template node.""" + + def test_unicode(self): + """test Template.__unicode__()""" + node = Template(wrap([Text("foobar")])) + self.assertEqual("{{foobar}}", str(node)) + node2 = Template(wrap([Text("foo")]), + [pgenh("1", "bar"), pgens("abc", "def")]) + self.assertEqual("{{foo|bar|abc=def}}", str(node2)) + + def test_strip(self): + """test Template.__strip__()""" + node1 = Template(wrap([Text("foobar")])) + node2 = Template(wrap([Text("foo")]), + [pgenh("1", "bar"), pgens("abc", "def")]) + for a in (True, False): + for b in (True, False): + self.assertEqual(None, node1.__strip__(a, b)) + self.assertEqual(None, node2.__strip__(a, b)) + + def test_showtree(self): + """test Template.__showtree__()""" + output = [] + getter, marker = object(), object() + get = lambda code: output.append((getter, code)) + mark = lambda: output.append(marker) + node1 = Template(wrap([Text("foobar")])) + node2 = Template(wrap([Text("foo")]), + [pgenh("1", "bar"), pgens("abc", "def")]) + node1.__showtree__(output.append, get, mark) + node2.__showtree__(output.append, get, mark) + valid = [ + "{{", (getter, node1.name), "}}", "{{", (getter, node2.name), + " | ", marker, (getter, node2.params[0].name), " = ", marker, + (getter, node2.params[0].value), " | ", marker, + (getter, node2.params[1].name), " = ", marker, + (getter, node2.params[1].value), "}}"] + self.assertEqual(valid, output) + + def test_name(self): + """test getter/setter for the name attribute""" + name = wrap([Text("foobar")]) + node1 = Template(name) + node2 = Template(name, [pgenh("1", "bar")]) + self.assertIs(name, node1.name) + self.assertIs(name, node2.name) + node1.name = "asdf" + node2.name = "téstïng" + self.assertWikicodeEqual(wrap([Text("asdf")]), node1.name) + self.assertWikicodeEqual(wrap([Text("téstïng")]), node2.name) + + def test_params(self): + """test getter for the params attribute""" + node1 = Template(wrap([Text("foobar")])) + plist = [pgenh("1", "bar"), pgens("abc", "def")] + node2 = Template(wrap([Text("foo")]), plist) + self.assertEqual([], node1.params) + self.assertIs(plist, node2.params) + + def test_has_param(self): + """test Template.has_param()""" + node1 = Template(wrap([Text("foobar")])) + node2 = Template(wrap([Text("foo")]), + [pgenh("1", "bar"), pgens("abc", "def")]) + node3 = Template(wrap([Text("foo")]), + [pgenh("1", "a"), pgens("b", "c"), pgens("1", "d")]) + node4 = Template(wrap([Text("foo")]), + [pgenh("1", "a"), pgens("b", " ")]) + self.assertFalse(node1.has_param("foobar")) + self.assertTrue(node2.has_param(1)) + self.assertTrue(node2.has_param("abc")) + self.assertFalse(node2.has_param("def")) + self.assertTrue(node3.has_param("1")) + self.assertTrue(node3.has_param("b")) + self.assertFalse(node4.has_param("b")) + self.assertTrue(node3.has_param("b", False)) + self.assertTrue(node4.has_param("b", False)) + + def test_get(self): + """test Template.get()""" + node1 = Template(wrap([Text("foobar")])) + node2p1 = pgenh("1", "bar") + node2p2 = pgens("abc", "def") + node2 = Template(wrap([Text("foo")]), [node2p1, node2p2]) + node3p1 = pgens("b", "c") + node3p2 = pgens("1", "d") + node3 = Template(wrap([Text("foo")]), + [pgenh("1", "a"), node3p1, node3p2]) + node4p1 = pgens("b", " ") + node4 = Template(wrap([Text("foo")]), [pgenh("1", "a"), node4p1]) + self.assertRaises(ValueError, node1.get, "foobar") + self.assertIs(node2p1, node2.get(1)) + self.assertIs(node2p2, node2.get("abc")) + self.assertRaises(ValueError, node2.get, "def") + self.assertIs(node3p1, node3.get("b")) + self.assertIs(node3p2, node3.get("1")) + self.assertIs(node4p1, node4.get("b")) + + # add + # remove + +if __name__ == "__main__": + unittest.main(verbosity=2) From 786d6192746284ef19c166c4d9eb95050c661b1c Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Wed, 24 Apr 2013 10:28:17 -0400 Subject: [PATCH 05/15] Drop force_no_field in template.remove(); implement test_remove(). - Also add tests for spacing in param names. --- mwparserfromhell/nodes/template.py | 27 ++++++++++-------- tests/test_template.py | 56 ++++++++++++++++++++++++++++++++++---- 2 files changed, 66 insertions(+), 17 deletions(-) diff --git a/mwparserfromhell/nodes/template.py b/mwparserfromhell/nodes/template.py index eb7f3a8..751c2b1 100644 --- a/mwparserfromhell/nodes/template.py +++ b/mwparserfromhell/nodes/template.py @@ -142,9 +142,9 @@ class Template(Node): return False return True - def _remove_without_field(self, param, i, force_no_field): + def _remove_without_field(self, param, i): """Return False if a parameter name should be kept, otherwise True.""" - if not param.showkey and not force_no_field: + if not param.showkey: dependents = [not after.showkey for after in self.params[i+1:]] if any(dependents): return False @@ -266,22 +266,23 @@ class Template(Node): self.params.append(param) return param - def remove(self, name, keep_field=False, force_no_field=False): + def remove(self, name, keep_field=False): """Remove a parameter from the template whose name is *name*. If *keep_field* is ``True``, we will keep the parameter's name, but blank its value. Otherwise, we will remove the parameter completely *unless* other parameters are dependent on it (e.g. removing ``bar`` from ``{{foo|bar|baz}}`` is unsafe because ``{{foo|baz}}`` is not what - we expected, so ``{{foo||baz}}`` will be produced instead), unless - *force_no_field* is also ``True``. If the parameter shows up multiple - times in the template, we will remove all instances of it (and keep - one if *keep_field* is ``True`` - that being the first instance if - none of the instances have dependents, otherwise that instance will be - kept). + we expected, so ``{{foo||baz}}`` will be produced instead). + + If the parameter shows up multiple times in the template, we will + remove all instances of it (and keep one if *keep_field* is ``True`` - + the first instance if none have dependents, otherwise the one with + dependents will be kept). """ name = name.strip() if isinstance(name, basestring) else str(name) removed = False + to_remove =[] for i, param in enumerate(self.params): if param.name.strip() == name: if keep_field: @@ -289,13 +290,15 @@ class Template(Node): self._blank_param_value(param.value) keep_field = False else: - self.params.remove(param) + to_remove.append(param) else: - if self._remove_without_field(param, i, force_no_field): - self.params.remove(param) + if self._remove_without_field(param, i): + to_remove.append(param) else: self._blank_param_value(param.value) if not removed: removed = True if not removed: raise ValueError(name) + for param in to_remove: + self.params.remove(param) diff --git a/tests/test_template.py b/tests/test_template.py index fde7522..ecac917 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -98,7 +98,7 @@ class TestTemplate(TreeEqualityTestCase): """test Template.has_param()""" node1 = Template(wrap([Text("foobar")])) node2 = Template(wrap([Text("foo")]), - [pgenh("1", "bar"), pgens("abc", "def")]) + [pgenh("1", "bar"), pgens("\nabc ", "def")]) node3 = Template(wrap([Text("foo")]), [pgenh("1", "a"), pgens("b", "c"), pgens("1", "d")]) node4 = Template(wrap([Text("foo")]), @@ -108,7 +108,7 @@ class TestTemplate(TreeEqualityTestCase): self.assertTrue(node2.has_param("abc")) self.assertFalse(node2.has_param("def")) self.assertTrue(node3.has_param("1")) - self.assertTrue(node3.has_param("b")) + self.assertTrue(node3.has_param(" b ")) self.assertFalse(node4.has_param("b")) self.assertTrue(node3.has_param("b", False)) self.assertTrue(node4.has_param("b", False)) @@ -123,7 +123,7 @@ class TestTemplate(TreeEqualityTestCase): node3p2 = pgens("1", "d") node3 = Template(wrap([Text("foo")]), [pgenh("1", "a"), node3p1, node3p2]) - node4p1 = pgens("b", " ") + node4p1 = pgens(" b", " ") node4 = Template(wrap([Text("foo")]), [pgenh("1", "a"), node4p1]) self.assertRaises(ValueError, node1.get, "foobar") self.assertIs(node2p1, node2.get(1)) @@ -131,10 +131,56 @@ class TestTemplate(TreeEqualityTestCase): self.assertRaises(ValueError, node2.get, "def") self.assertIs(node3p1, node3.get("b")) self.assertIs(node3p2, node3.get("1")) - self.assertIs(node4p1, node4.get("b")) + self.assertIs(node4p1, node4.get("b ")) # add - # remove + + def test_remove(self): + """test Template.remove()""" + node1 = Template(wrap([Text("foobar")])) + node2 = Template(wrap([Text("foo")]), [pgenh("1", "bar"), + pgens("abc", "def")]) + node3 = Template(wrap([Text("foo")]), [pgenh("1", "bar"), + pgens("abc", "def")]) + node4 = Template(wrap([Text("foo")]), [pgenh("1", "bar"), + pgenh("2", "baz")]) + node5 = Template(wrap([Text("foo")]), [ + pgens(" a", "b"), pgens("b", "c"), pgens("a ", "d")]) + node6 = Template(wrap([Text("foo")]), [ + pgens(" a", "b"), pgens("b", "c"), pgens("a ", "d")]) + node7 = Template(wrap([Text("foo")]), [ + pgens("1 ", "a"), pgens(" 1", "b"), pgens("2", "c")]) + node8 = Template(wrap([Text("foo")]), [ + pgens("1 ", "a"), pgens(" 1", "b"), pgens("2", "c")]) + node9 = Template(wrap([Text("foo")]), [ + pgens("1 ", "a"), pgenh("1", "b"), pgenh("2", "c")]) + node10 = Template(wrap([Text("foo")]), [ + pgens("1 ", "a"), pgenh("1", "b"), pgenh("2", "c")]) + + node2.remove("1") + node2.remove("abc") + node3.remove(1, keep_field=True) + node3.remove("abc", keep_field=True) + node4.remove("1", keep_field=False) + node5.remove("a", keep_field=False) + node6.remove("a", keep_field=True) + node7.remove(1, keep_field=True) + node8.remove(1, keep_field=False) + node9.remove(1, keep_field=True) + node10.remove(1, keep_field=False) + + self.assertRaises(ValueError, node1.remove, 1) + self.assertRaises(ValueError, node1.remove, "a") + self.assertRaises(ValueError, node2.remove, "1") + self.assertEquals("{{foo}}", node2) + self.assertEquals("{{foo||abc=}}", node3) + self.assertEquals("{{foo||baz}}", node4) + self.assertEquals("{{foo|b=c}}", node5) + self.assertEquals("{{foo| a=|b=c}}", node6) + self.assertEquals("{{foo|1 =|2=c}}", node7) + self.assertEquals("{{foo|2=c}}", node8) + self.assertEquals("{{foo||c}}", node9) + self.assertEquals("{{foo||c}}", node10) if __name__ == "__main__": unittest.main(verbosity=2) From 6af2f3b0639ea515a343cbb36a38daff661f8e62 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Wed, 24 Apr 2013 17:46:53 -0400 Subject: [PATCH 06/15] assertEquals -> assertEqual --- tests/test_template.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/tests/test_template.py b/tests/test_template.py index ecac917..0895219 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -172,15 +172,15 @@ class TestTemplate(TreeEqualityTestCase): self.assertRaises(ValueError, node1.remove, 1) self.assertRaises(ValueError, node1.remove, "a") self.assertRaises(ValueError, node2.remove, "1") - self.assertEquals("{{foo}}", node2) - self.assertEquals("{{foo||abc=}}", node3) - self.assertEquals("{{foo||baz}}", node4) - self.assertEquals("{{foo|b=c}}", node5) - self.assertEquals("{{foo| a=|b=c}}", node6) - self.assertEquals("{{foo|1 =|2=c}}", node7) - self.assertEquals("{{foo|2=c}}", node8) - self.assertEquals("{{foo||c}}", node9) - self.assertEquals("{{foo||c}}", node10) + self.assertEqual("{{foo}}", node2) + self.assertEqual("{{foo||abc=}}", node3) + self.assertEqual("{{foo||baz}}", node4) + self.assertEqual("{{foo|b=c}}", node5) + self.assertEqual("{{foo| a=|b=c}}", node6) + self.assertEqual("{{foo|1 =|2=c}}", node7) + self.assertEqual("{{foo|2=c}}", node8) + self.assertEqual("{{foo||c}}", node9) + self.assertEqual("{{foo||c}}", node10) if __name__ == "__main__": unittest.main(verbosity=2) From b46c98b0121d6b9bbb13720a658a3a8b0237932e Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Thu, 25 Apr 2013 10:22:20 -0400 Subject: [PATCH 07/15] Clean up template.add(); add a before param but do not implement yet. --- mwparserfromhell/nodes/template.py | 47 +++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/mwparserfromhell/nodes/template.py b/mwparserfromhell/nodes/template.py index 751c2b1..4b74971 100644 --- a/mwparserfromhell/nodes/template.py +++ b/mwparserfromhell/nodes/template.py @@ -194,20 +194,30 @@ class Template(Node): return param raise ValueError(name) - def add(self, name, value, showkey=None, force_nonconformity=False): + def add(self, name, value, showkey=None, before=None, + preserve_spacing=True): """Add a parameter to the template with a given *name* and *value*. *name* and *value* can be anything parasable by - :py:func:`.utils.parse_anything`; pipes (and equal signs, if - appropriate) are automatically escaped from *value* where applicable. + :py:func:`.utils.parse_anything`; pipes and equal signs are + automatically escaped from *value* when appropriate. + If *showkey* is given, this will determine whether or not to show the parameter's name (e.g., ``{{foo|bar}}``'s parameter has a name of ``"1"`` but it is hidden); otherwise, we'll make a safe and intelligent guess. If *name* is already a parameter, we'll replace its value while - keeping the same spacing rules unless *force_nonconformity* is - ``True``. We will also try to guess the dominant spacing convention - when adding a new parameter using :py:meth:`_get_spacing_conventions` - unless *force_nonconformity* is ``True``. + keeping the same spacing rules. We will also try to guess the dominant + spacing convention when adding a new parameter using + :py:meth:`_get_spacing_conventions`. + + If *before* is given (either a :py:class:`~.Parameter` object or a + name), then we will place the parameter immediately before this one. + Otherwise, it will be added at the end. This is ignored if the + parameter already exists. + + If *preserve_spacing* is ``False``, we will avoid preserving spacing + conventions when changing the value of an existing parameter or when + adding a new one. """ name, value = parse_anything(name), parse_anything(value) self._surface_escape(value, "|") @@ -220,10 +230,10 @@ class Template(Node): self._surface_escape(value, "=") existing.showkey = showkey nodes = existing.value.nodes - if force_nonconformity: - existing.value = value - else: + if preserve_spacing: existing.value = parse_anything([nodes[0], value, nodes[1]]) + else: + existing.value = value return existing if showkey is None: @@ -245,22 +255,11 @@ class Template(Node): if not showkey: self._surface_escape(value, "=") - if not force_nonconformity: + if preserve_spacing: before_n, after_n = self._get_spacing_conventions(use_names=True) - if before_n and after_n: - name = parse_anything([before_n, name, after_n]) - elif before_n: - name = parse_anything([before_n, name]) - elif after_n: - name = parse_anything([name, after_n]) - before_v, after_v = self._get_spacing_conventions(use_names=False) - if before_v and after_v: - value = parse_anything([before_v, value, after_v]) - elif before_v: - value = parse_anything([before_v, value]) - elif after_v: - value = parse_anything([value, after_v]) + name = parse_anything([before_n, name, after_n]) + value = parse_anything([before_v, value, after_v]) param = Parameter(name, value, showkey) self.params.append(param) From 2ca3b2805e5a346600508e3e622bddad6be38f93 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Fri, 26 Apr 2013 10:39:53 -0400 Subject: [PATCH 08/15] Implement 'before' parameter for Template.add() (closes #21) --- mwparserfromhell/nodes/template.py | 11 ++++++++--- tests/test_template.py | 22 +++++++++++++++++++++- 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/mwparserfromhell/nodes/template.py b/mwparserfromhell/nodes/template.py index 4b74971..9d28be4 100644 --- a/mwparserfromhell/nodes/template.py +++ b/mwparserfromhell/nodes/template.py @@ -226,9 +226,9 @@ class Template(Node): self.remove(name, keep_field=True) existing = self.get(name) if showkey is not None: - if not showkey: - self._surface_escape(value, "=") existing.showkey = showkey + if not existing.showkey: + self._surface_escape(value, "=") nodes = existing.value.nodes if preserve_spacing: existing.value = parse_anything([nodes[0], value, nodes[1]]) @@ -262,7 +262,12 @@ class Template(Node): value = parse_anything([before_v, value, after_v]) param = Parameter(name, value, showkey) - self.params.append(param) + if before: + if not isinstance(before, Parameter): + before = self.get(before) + self.params.insert(self.params.index(before), param) + else: + self.params.append(param) return param def remove(self, name, keep_field=False): diff --git a/tests/test_template.py b/tests/test_template.py index 0895219..a1661f2 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -133,7 +133,27 @@ class TestTemplate(TreeEqualityTestCase): self.assertIs(node3p2, node3.get("1")) self.assertIs(node4p1, node4.get("b ")) - # add + def test_add(self): + """test Template.add()""" + # add new param with showkey to end + # add new param without showkey to end + # add new param to end with an escapable | + # add new param with showkey to end with an escapable = + # add new param without showkey to end with an escapable = + # add new param with showkey to end preserving spacing (x3) + # add new param without showkey to end not preserving spacing + # add new param guessing showkey where key is to be shown + # add new param guessing showkey where key is to be shown with an escapable = + # add new param guessing showkey where key is not to be shown + # add new param guessing showkey where key is not to be shown with an escapable = + # add existing parameter without modifying showkey + # add existing parameter without modifying showkey with an escapable = + # add existing parameter with modifying showkey + # add existing parameter with modifying showkey with an escapable = + # add existing parameter preserving spacing (x3) + # add existing parameter not preserving spacing + # add existing parameter when there are multiple params involved + # add existing parameter when there are multiple params involved; params with dependencies def test_remove(self): """test Template.remove()""" From 81849013bc31b12b1a82a98ff0b4a25ccb597822 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Thu, 2 May 2013 11:01:13 -0400 Subject: [PATCH 09/15] Finishing tests for Templates; some fixes. --- mwparserfromhell/nodes/template.py | 21 ++- tests/test_template.py | 262 +++++++++++++++++++++++++++++-------- 2 files changed, 220 insertions(+), 63 deletions(-) diff --git a/mwparserfromhell/nodes/template.py b/mwparserfromhell/nodes/template.py index 9d28be4..3834d41 100644 --- a/mwparserfromhell/nodes/template.py +++ b/mwparserfromhell/nodes/template.py @@ -81,7 +81,7 @@ class Template(Node): in parameter names or values so they are not mistaken for new parameters. """ - replacement = HTMLEntity(value=ord(char)) + replacement = str(HTMLEntity(value=ord(char))) for node in code.filter_text(recursive=False): if char in node: code.replace(node, node.replace(char, replacement)) @@ -107,7 +107,7 @@ class Template(Node): values = tuple(theories.values()) best = max(values) confidence = float(best) / sum(values) - if confidence > 0.75: + if confidence >= 0.75: return tuple(theories.keys())[values.index(best)] def _get_spacing_conventions(self, use_names): @@ -205,15 +205,19 @@ class Template(Node): If *showkey* is given, this will determine whether or not to show the parameter's name (e.g., ``{{foo|bar}}``'s parameter has a name of ``"1"`` but it is hidden); otherwise, we'll make a safe and intelligent - guess. If *name* is already a parameter, we'll replace its value while - keeping the same spacing rules. We will also try to guess the dominant - spacing convention when adding a new parameter using + guess. + + If *name* is already a parameter in the template, we'll replace its + value while keeping the same whitespace around it. We will also try to + guess the dominant spacing convention when adding a new parameter using :py:meth:`_get_spacing_conventions`. If *before* is given (either a :py:class:`~.Parameter` object or a name), then we will place the parameter immediately before this one. - Otherwise, it will be added at the end. This is ignored if the - parameter already exists. + Otherwise, it will be added at the end. If *before* is a name and + exists multiple times in the template, we will place it before the last + occurance. If *before* is not in the template, :py:exc:`ValueError` is + raised. The argument is ignored if the new parameter already exists. If *preserve_spacing* is ``False``, we will avoid preserving spacing conventions when changing the value of an existing parameter or when @@ -231,6 +235,9 @@ class Template(Node): self._surface_escape(value, "=") nodes = existing.value.nodes if preserve_spacing: + for i in range(2): # Ignore empty text nodes + if not nodes[i]: + nodes[i] = None existing.value = parse_anything([nodes[0], value, nodes[1]]) else: existing.value = value diff --git a/tests/test_template.py b/tests/test_template.py index a1661f2..3eb88ad 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -24,31 +24,32 @@ from __future__ import unicode_literals import unittest from mwparserfromhell.compat import str -from mwparserfromhell.nodes import Template, Text +from mwparserfromhell.nodes import HTMLEntity, Template, Text from mwparserfromhell.nodes.extras import Parameter from mwparserfromhell.smart_list import SmartList from mwparserfromhell.wikicode import Wikicode from ._test_tree_equality import TreeEqualityTestCase wrap = lambda L: Wikicode(SmartList(L)) -pgens = lambda k, v: Parameter(wrap([Text(k)]), wrap([Text(v)]), True) -pgenh = lambda k, v: Parameter(wrap([Text(k)]), wrap([Text(v)]), False) +wraptext = lambda t: wrap([Text(t)]) +pgens = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=True) +pgenh = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=False) class TestTemplate(TreeEqualityTestCase): """Test cases for the Template node.""" def test_unicode(self): """test Template.__unicode__()""" - node = Template(wrap([Text("foobar")])) + node = Template(wraptext("foobar")) self.assertEqual("{{foobar}}", str(node)) - node2 = Template(wrap([Text("foo")]), + node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("abc", "def")]) self.assertEqual("{{foo|bar|abc=def}}", str(node2)) def test_strip(self): """test Template.__strip__()""" - node1 = Template(wrap([Text("foobar")])) - node2 = Template(wrap([Text("foo")]), + node1 = Template(wraptext("foobar")) + node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("abc", "def")]) for a in (True, False): for b in (True, False): @@ -61,8 +62,8 @@ class TestTemplate(TreeEqualityTestCase): getter, marker = object(), object() get = lambda code: output.append((getter, code)) mark = lambda: output.append(marker) - node1 = Template(wrap([Text("foobar")])) - node2 = Template(wrap([Text("foo")]), + node1 = Template(wraptext("foobar")) + node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("abc", "def")]) node1.__showtree__(output.append, get, mark) node2.__showtree__(output.append, get, mark) @@ -76,33 +77,32 @@ class TestTemplate(TreeEqualityTestCase): def test_name(self): """test getter/setter for the name attribute""" - name = wrap([Text("foobar")]) + name = wraptext("foobar") node1 = Template(name) node2 = Template(name, [pgenh("1", "bar")]) self.assertIs(name, node1.name) self.assertIs(name, node2.name) node1.name = "asdf" node2.name = "téstïng" - self.assertWikicodeEqual(wrap([Text("asdf")]), node1.name) - self.assertWikicodeEqual(wrap([Text("téstïng")]), node2.name) + self.assertWikicodeEqual(wraptext("asdf"), node1.name) + self.assertWikicodeEqual(wraptext("téstïng"), node2.name) def test_params(self): """test getter for the params attribute""" - node1 = Template(wrap([Text("foobar")])) + node1 = Template(wraptext("foobar")) plist = [pgenh("1", "bar"), pgens("abc", "def")] - node2 = Template(wrap([Text("foo")]), plist) + node2 = Template(wraptext("foo"), plist) self.assertEqual([], node1.params) self.assertIs(plist, node2.params) def test_has_param(self): """test Template.has_param()""" - node1 = Template(wrap([Text("foobar")])) - node2 = Template(wrap([Text("foo")]), + node1 = Template(wraptext("foobar")) + node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("\nabc ", "def")]) - node3 = Template(wrap([Text("foo")]), + node3 = Template(wraptext("foo"), [pgenh("1", "a"), pgens("b", "c"), pgens("1", "d")]) - node4 = Template(wrap([Text("foo")]), - [pgenh("1", "a"), pgens("b", " ")]) + node4 = Template(wraptext("foo"), [pgenh("1", "a"), pgens("b", " ")]) self.assertFalse(node1.has_param("foobar")) self.assertTrue(node2.has_param(1)) self.assertTrue(node2.has_param("abc")) @@ -115,16 +115,15 @@ class TestTemplate(TreeEqualityTestCase): def test_get(self): """test Template.get()""" - node1 = Template(wrap([Text("foobar")])) + node1 = Template(wraptext("foobar")) node2p1 = pgenh("1", "bar") node2p2 = pgens("abc", "def") - node2 = Template(wrap([Text("foo")]), [node2p1, node2p2]) + node2 = Template(wraptext("foo"), [node2p1, node2p2]) node3p1 = pgens("b", "c") node3p2 = pgens("1", "d") - node3 = Template(wrap([Text("foo")]), - [pgenh("1", "a"), node3p1, node3p2]) + node3 = Template(wraptext("foo"), [pgenh("1", "a"), node3p1, node3p2]) node4p1 = pgens(" b", " ") - node4 = Template(wrap([Text("foo")]), [pgenh("1", "a"), node4p1]) + node4 = Template(wraptext("foo"), [pgenh("1", "a"), node4p1]) self.assertRaises(ValueError, node1.get, "foobar") self.assertIs(node2p1, node2.get(1)) self.assertIs(node2p2, node2.get("abc")) @@ -135,46 +134,197 @@ class TestTemplate(TreeEqualityTestCase): def test_add(self): """test Template.add()""" - # add new param with showkey to end - # add new param without showkey to end - # add new param to end with an escapable | - # add new param with showkey to end with an escapable = - # add new param without showkey to end with an escapable = - # add new param with showkey to end preserving spacing (x3) - # add new param without showkey to end not preserving spacing - # add new param guessing showkey where key is to be shown - # add new param guessing showkey where key is to be shown with an escapable = - # add new param guessing showkey where key is not to be shown - # add new param guessing showkey where key is not to be shown with an escapable = - # add existing parameter without modifying showkey - # add existing parameter without modifying showkey with an escapable = - # add existing parameter with modifying showkey - # add existing parameter with modifying showkey with an escapable = - # add existing parameter preserving spacing (x3) - # add existing parameter not preserving spacing - # add existing parameter when there are multiple params involved - # add existing parameter when there are multiple params involved; params with dependencies + node1 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")]) + node2 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")]) + node3 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")]) + node4 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")]) + node5 = Template(wraptext("a"), [pgens("b", "c"), + pgens(" d ", "e")]) + node6 = Template(wraptext("a"), [pgens("b", "c"), pgens("b", "d"), + pgens("b", "e")]) + node7 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")]) + node8p = pgenh("1", "d") + node8 = Template(wraptext("a"), [pgens("b", "c"), node8p]) + node9 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "d")]) + node10 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "e")]) + node11 = Template(wraptext("a"), [pgens("b", "c")]) + node12 = Template(wraptext("a"), [pgens("b", "c")]) + node13 = Template(wraptext("a"), [pgens("\nb ", " c"), + pgens("\nd ", " e"), + pgens("\nf ", " g")]) + node14 = Template(wraptext("a\n"), [pgens("b ", "c\n"), + pgens("d ", " e"), + pgens("f ", "g\n"), + pgens("h ", " i\n")]) + node15 = Template(wraptext("a"), [pgens("b ", " c\n"), + pgens("\nd ", " e"), + pgens("\nf ", "g ")]) + node16 = Template(wraptext("a"), [pgens("\nb ", " c"), + pgens("\nd ", " e"), + pgens("\nf ", " g")]) + node17 = Template(wraptext("a"), [pgens("\nb ", " c"), + pgens("\nd ", " e"), + pgens("\nf ", " g")]) + node18 = Template(wraptext("a\n"), [pgens("b ", "c\n"), + pgens("d ", " e"), + pgens("f ", "g\n"), + pgens("h ", " i\n")]) + node19 = Template(wraptext("a"), [pgens("b ", " c\n"), + pgens("\nd ", " e"), + pgens("\nf ", "g ")]) + node20 = Template(wraptext("a"), [pgens("\nb ", " c"), + pgens("\nd ", " e"), + pgens("\nf ", " g")]) + node21 = Template(wraptext("a"), [pgenh("1", "b")]) + node22 = Template(wraptext("a"), [pgenh("1", "b")]) + node23 = Template(wraptext("a"), [pgenh("1", "b")]) + node24 = Template(wraptext("a"), [pgenh("1", "b"), pgenh("2", "c"), + pgenh("3", "d"), pgenh("4", "e")]) + node25 = Template(wraptext("a"), [pgenh("1", "b"), pgenh("2", "c"), + pgens("4", "d"), pgens("5", "e")]) + node26 = Template(wraptext("a"), [pgenh("1", "b"), pgenh("2", "c"), + pgens("4", "d"), pgens("5", "e")]) + node27 = Template(wraptext("a"), [pgenh("1", "b")]) + node28 = Template(wraptext("a"), [pgenh("1", "b")]) + node29 = Template(wraptext("a"), [pgens("b", "c")]) + node30 = Template(wraptext("a"), [pgenh("1", "b")]) + node31 = Template(wraptext("a"), [pgenh("1", "b")]) + node32 = Template(wraptext("a"), [pgens("1", "b")]) + node33 = Template(wraptext("a"), [pgens("\nb ", " c"), + pgens("\nd ", " e"), + pgens("\nf ", " g")]) + node34 = Template(wraptext("a\n"), [pgens("b ", "c\n"), + pgens("d ", " e"), + pgens("f ", "g\n"), + pgens("h ", " i\n")]) + node35 = Template(wraptext("a"), [pgens("b ", " c\n"), + pgens("\nd ", " e"), + pgens("\nf ", "g ")]) + node36 = Template(wraptext("a"), [pgens("\nb ", " c "), + pgens("\nd ", " e "), + pgens("\nf ", " g ")]) + node37 = Template(wraptext("a"), [pgens("b", "c"), pgens("d", "e"), + pgens("b", "f"), pgens("b", "h"), + pgens("i", "j")]) + node37 = Template(wraptext("a"), [pgens("b", "c"), pgens("d", "e"), + pgens("b", "f"), pgens("b", "h"), + pgens("i", "j")]) + node38 = Template(wraptext("a"), [pgens("1", "b"), pgens("x", "y"), + pgens("1", "c"), pgens("2", "d")]) + node39 = Template(wraptext("a"), [pgens("1", "b"), pgens("x", "y"), + pgenh("1", "c"), pgenh("2", "d")]) + node40 = Template(wraptext("a"), [pgens("b", "c"), pgens("d", "e"), + pgens("f", "g")]) + + node1.add("e", "f", showkey=True) + node2.add(2, "g", showkey=False) + node3.add("e", "foo|bar", showkey=True) + node4.add("e", "f", showkey=True, before="b") + node5.add("f", "g", showkey=True, before=" d ") + node6.add("f", "g", showkey=True, before="b") + self.assertRaises(ValueError, node7.add, "e", "f", showkey=True, + before="q") + node8.add("e", "f", showkey=True, before=node8p) + node9.add("e", "f", showkey=True, before=pgenh("1", "d")) + self.assertRaises(ValueError, node10.add, "e", "f", showkey=True, + before=pgenh("1", "d")) + node11.add("d", "foo=bar", showkey=True) + node12.add("1", "foo=bar", showkey=False) + node13.add("h", "i", showkey=True) + node14.add("j", "k", showkey=True) + node15.add("h", "i", showkey=True) + node16.add("h", "i", showkey=True, preserve_spacing=False) + node17.add("h", "i", showkey=False) + node18.add("j", "k", showkey=False) + node19.add("h", "i", showkey=False) + node20.add("h", "i", showkey=False, preserve_spacing=False) + node21.add("2", "c") + node22.add("3", "c") + node23.add("c", "d") + node24.add("5", "f") + node25.add("3", "f") + node26.add("6", "f") + node27.add("c", "foo=bar") + node28.add("2", "foo=bar") + node29.add("b", "d") + node30.add("1", "foo=bar") + node31.add("1", "foo=bar", showkey=True) + node32.add("1", "foo=bar", showkey=False) + node33.add("d", "foo") + node34.add("f", "foo") + node35.add("f", "foo") + node36.add("d", "foo", preserve_spacing=False) + node37.add("b", "k") + node38.add("1", "e") + node39.add("1", "e") + node40.add("d", "h", before="b") + + self.assertEquals("{{a|b=c|d|e=f}}", node1) + self.assertEquals("{{a|b=c|d|g}}", node2) + self.assertEquals("{{a|b=c|d|e=foo|bar}}", node3) + self.assertIsInstance(node3.params[2].value.get(1), HTMLEntity) + self.assertEquals("{{a|e=f|b=c|d}}", node4) + self.assertEquals("{{a|b=c|f=g| d =e}}", node5) + self.assertEquals("{{a|b=c|b=d|f=g|b=e}}", node6) + self.assertEquals("{{a|b=c|d}}", node7) + self.assertEquals("{{a|b=c|e=f|d}}", node8) + self.assertEquals("{{a|b=c|e=f|d}}", node9) + self.assertEquals("{{a|b=c|e}}", node10) + self.assertEquals("{{a|b=c|d=foo=bar}}", node11) + self.assertEquals("{{a|b=c|foo=bar}}", node12) + self.assertIsInstance(node12.params[1].value.get(1), HTMLEntity) + self.assertEquals("{{a|\nb = c|\nd = e|\nf = g|\nh = i}}", node13) + self.assertEquals("{{a\n|b =c\n|d = e|f =g\n|h = i\n|j =k\n}}", node14) + self.assertEquals("{{a|b = c\n|\nd = e|\nf =g |h =i}}", node15) + self.assertEquals("{{a|\nb = c|\nd = e|\nf = g|h=i}}", node16) + self.assertEquals("{{a|\nb = c|\nd = e|\nf = g| i}}", node17) + self.assertEquals("{{a\n|b =c\n|d = e|f =g\n|h = i\n|k\n}}", node18) + self.assertEquals("{{a|b = c\n|\nd = e|\nf =g |i}}", node19) + self.assertEquals("{{a|\nb = c|\nd = e|\nf = g|i}}", node20) + self.assertEquals("{{a|b|c}}", node21) + self.assertEquals("{{a|b|3=c}}", node22) + self.assertEquals("{{a|b|c=d}}", node23) + self.assertEquals("{{a|b|c|d|e|f}}", node24) + self.assertEquals("{{a|b|c|4=d|5=e|f}}", node25) + self.assertEquals("{{a|b|c|4=d|5=e|6=f}}", node26) + self.assertEquals("{{a|b|c=foo=bar}}", node27) + self.assertEquals("{{a|b|foo=bar}}", node28) + self.assertIsInstance(node28.params[1].value.get(1), HTMLEntity) + self.assertEquals("{{a|b=d}}", node29) + self.assertEquals("{{a|foo=bar}}", node30) + self.assertIsInstance(node30.params[0].value.get(1), HTMLEntity) + self.assertEquals("{{a|1=foo=bar}}", node31) + self.assertEquals("{{a|foo=bar}}", node32) + self.assertIsInstance(node32.params[0].value.get(1), HTMLEntity) + self.assertEquals("{{a|\nb = c|\nd = foo|\nf = g}}", node33) + self.assertEquals("{{a\n|b =c\n|d = e|f =foo\n|h = i\n}}", node34) + self.assertEquals("{{a|b = c\n|\nd = e|\nf =foo }}", node35) + self.assertEquals("{{a|\nb = c |\nd =foo|\nf = g }}", node36) + self.assertEquals("{{a|b=k|d=e|i=j}}", node37) + self.assertEquals("{{a|1=e|x=y|2=d}}", node38) + self.assertEquals("{{a|x=y|e|d}}", node39) + self.assertEquals("{{a|b=c|d=h|f=g}}", node40) def test_remove(self): """test Template.remove()""" - node1 = Template(wrap([Text("foobar")])) - node2 = Template(wrap([Text("foo")]), [pgenh("1", "bar"), - pgens("abc", "def")]) - node3 = Template(wrap([Text("foo")]), [pgenh("1", "bar"), - pgens("abc", "def")]) - node4 = Template(wrap([Text("foo")]), [pgenh("1", "bar"), - pgenh("2", "baz")]) - node5 = Template(wrap([Text("foo")]), [ + node1 = Template(wraptext("foobar")) + node2 = Template(wraptext("foo"), [pgenh("1", "bar"), + pgens("abc", "def")]) + node3 = Template(wraptext("foo"), [pgenh("1", "bar"), + pgens("abc", "def")]) + node4 = Template(wraptext("foo"), [pgenh("1", "bar"), + pgenh("2", "baz")]) + node5 = Template(wraptext("foo"), [ pgens(" a", "b"), pgens("b", "c"), pgens("a ", "d")]) - node6 = Template(wrap([Text("foo")]), [ + node6 = Template(wraptext("foo"), [ pgens(" a", "b"), pgens("b", "c"), pgens("a ", "d")]) - node7 = Template(wrap([Text("foo")]), [ + node7 = Template(wraptext("foo"), [ pgens("1 ", "a"), pgens(" 1", "b"), pgens("2", "c")]) - node8 = Template(wrap([Text("foo")]), [ + node8 = Template(wraptext("foo"), [ pgens("1 ", "a"), pgens(" 1", "b"), pgens("2", "c")]) - node9 = Template(wrap([Text("foo")]), [ + node9 = Template(wraptext("foo"), [ pgens("1 ", "a"), pgenh("1", "b"), pgenh("2", "c")]) - node10 = Template(wrap([Text("foo")]), [ + node10 = Template(wraptext("foo"), [ pgens("1 ", "a"), pgenh("1", "b"), pgenh("2", "c")]) node2.remove("1") From 1d26c4b312207f956c29c224f34814e486607757 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Thu, 2 May 2013 22:40:35 -0400 Subject: [PATCH 10/15] Why do I always make this mistake? --- tests/test_template.py | 80 +++++++++++++++++++++++++------------------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/tests/test_template.py b/tests/test_template.py index 3eb88ad..b9fd6e8 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -259,51 +259,51 @@ class TestTemplate(TreeEqualityTestCase): node39.add("1", "e") node40.add("d", "h", before="b") - self.assertEquals("{{a|b=c|d|e=f}}", node1) - self.assertEquals("{{a|b=c|d|g}}", node2) - self.assertEquals("{{a|b=c|d|e=foo|bar}}", node3) + self.assertEqual("{{a|b=c|d|e=f}}", node1) + self.assertEqual("{{a|b=c|d|g}}", node2) + self.assertEqual("{{a|b=c|d|e=foo|bar}}", node3) self.assertIsInstance(node3.params[2].value.get(1), HTMLEntity) - self.assertEquals("{{a|e=f|b=c|d}}", node4) - self.assertEquals("{{a|b=c|f=g| d =e}}", node5) - self.assertEquals("{{a|b=c|b=d|f=g|b=e}}", node6) - self.assertEquals("{{a|b=c|d}}", node7) - self.assertEquals("{{a|b=c|e=f|d}}", node8) - self.assertEquals("{{a|b=c|e=f|d}}", node9) - self.assertEquals("{{a|b=c|e}}", node10) - self.assertEquals("{{a|b=c|d=foo=bar}}", node11) - self.assertEquals("{{a|b=c|foo=bar}}", node12) + self.assertEqual("{{a|e=f|b=c|d}}", node4) + self.assertEqual("{{a|b=c|f=g| d =e}}", node5) + self.assertEqual("{{a|b=c|b=d|f=g|b=e}}", node6) + self.assertEqual("{{a|b=c|d}}", node7) + self.assertEqual("{{a|b=c|e=f|d}}", node8) + self.assertEqual("{{a|b=c|e=f|d}}", node9) + self.assertEqual("{{a|b=c|e}}", node10) + self.assertEqual("{{a|b=c|d=foo=bar}}", node11) + self.assertEqual("{{a|b=c|foo=bar}}", node12) self.assertIsInstance(node12.params[1].value.get(1), HTMLEntity) - self.assertEquals("{{a|\nb = c|\nd = e|\nf = g|\nh = i}}", node13) - self.assertEquals("{{a\n|b =c\n|d = e|f =g\n|h = i\n|j =k\n}}", node14) - self.assertEquals("{{a|b = c\n|\nd = e|\nf =g |h =i}}", node15) - self.assertEquals("{{a|\nb = c|\nd = e|\nf = g|h=i}}", node16) - self.assertEquals("{{a|\nb = c|\nd = e|\nf = g| i}}", node17) - self.assertEquals("{{a\n|b =c\n|d = e|f =g\n|h = i\n|k\n}}", node18) - self.assertEquals("{{a|b = c\n|\nd = e|\nf =g |i}}", node19) - self.assertEquals("{{a|\nb = c|\nd = e|\nf = g|i}}", node20) - self.assertEquals("{{a|b|c}}", node21) - self.assertEquals("{{a|b|3=c}}", node22) - self.assertEquals("{{a|b|c=d}}", node23) - self.assertEquals("{{a|b|c|d|e|f}}", node24) - self.assertEquals("{{a|b|c|4=d|5=e|f}}", node25) - self.assertEquals("{{a|b|c|4=d|5=e|6=f}}", node26) - self.assertEquals("{{a|b|c=foo=bar}}", node27) - self.assertEquals("{{a|b|foo=bar}}", node28) + self.assertEqual("{{a|\nb = c|\nd = e|\nf = g|\nh = i}}", node13) + self.assertEqual("{{a\n|b =c\n|d = e|f =g\n|h = i\n|j =k\n}}", node14) + self.assertEqual("{{a|b = c\n|\nd = e|\nf =g |h =i}}", node15) + self.assertEqual("{{a|\nb = c|\nd = e|\nf = g|h=i}}", node16) + self.assertEqual("{{a|\nb = c|\nd = e|\nf = g| i}}", node17) + self.assertEqual("{{a\n|b =c\n|d = e|f =g\n|h = i\n|k\n}}", node18) + self.assertEqual("{{a|b = c\n|\nd = e|\nf =g |i}}", node19) + self.assertEqual("{{a|\nb = c|\nd = e|\nf = g|i}}", node20) + self.assertEqual("{{a|b|c}}", node21) + self.assertEqual("{{a|b|3=c}}", node22) + self.assertEqual("{{a|b|c=d}}", node23) + self.assertEqual("{{a|b|c|d|e|f}}", node24) + self.assertEqual("{{a|b|c|4=d|5=e|f}}", node25) + self.assertEqual("{{a|b|c|4=d|5=e|6=f}}", node26) + self.assertEqual("{{a|b|c=foo=bar}}", node27) + self.assertEqual("{{a|b|foo=bar}}", node28) self.assertIsInstance(node28.params[1].value.get(1), HTMLEntity) - self.assertEquals("{{a|b=d}}", node29) - self.assertEquals("{{a|foo=bar}}", node30) + self.assertEqual("{{a|b=d}}", node29) + self.assertEqual("{{a|foo=bar}}", node30) self.assertIsInstance(node30.params[0].value.get(1), HTMLEntity) - self.assertEquals("{{a|1=foo=bar}}", node31) - self.assertEquals("{{a|foo=bar}}", node32) + self.assertEqual("{{a|1=foo=bar}}", node31) + self.assertEqual("{{a|foo=bar}}", node32) self.assertIsInstance(node32.params[0].value.get(1), HTMLEntity) - self.assertEquals("{{a|\nb = c|\nd = foo|\nf = g}}", node33) - self.assertEquals("{{a\n|b =c\n|d = e|f =foo\n|h = i\n}}", node34) - self.assertEquals("{{a|b = c\n|\nd = e|\nf =foo }}", node35) - self.assertEquals("{{a|\nb = c |\nd =foo|\nf = g }}", node36) - self.assertEquals("{{a|b=k|d=e|i=j}}", node37) - self.assertEquals("{{a|1=e|x=y|2=d}}", node38) - self.assertEquals("{{a|x=y|e|d}}", node39) - self.assertEquals("{{a|b=c|d=h|f=g}}", node40) + self.assertEqual("{{a|\nb = c|\nd = foo|\nf = g}}", node33) + self.assertEqual("{{a\n|b =c\n|d = e|f =foo\n|h = i\n}}", node34) + self.assertEqual("{{a|b = c\n|\nd = e|\nf =foo }}", node35) + self.assertEqual("{{a|\nb = c |\nd =foo|\nf = g }}", node36) + self.assertEqual("{{a|b=k|d=e|i=j}}", node37) + self.assertEqual("{{a|1=e|x=y|2=d}}", node38) + self.assertEqual("{{a|x=y|e|d}}", node39) + self.assertEqual("{{a|b=c|d=h|f=g}}", node40) def test_remove(self): """test Template.remove()""" From 3b78541eeb19cf0cb528cd856e8f3048d354fb4e Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Fri, 3 May 2013 10:57:30 -0400 Subject: [PATCH 11/15] Clean up indentation. --- tests/test_template.py | 66 +++++++++++++++++++++----------------------------- 1 file changed, 27 insertions(+), 39 deletions(-) diff --git a/tests/test_template.py b/tests/test_template.py index b9fd6e8..31ed33b 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -149,32 +149,24 @@ class TestTemplate(TreeEqualityTestCase): node10 = Template(wraptext("a"), [pgens("b", "c"), pgenh("1", "e")]) node11 = Template(wraptext("a"), [pgens("b", "c")]) node12 = Template(wraptext("a"), [pgens("b", "c")]) - node13 = Template(wraptext("a"), [pgens("\nb ", " c"), - pgens("\nd ", " e"), - pgens("\nf ", " g")]) - node14 = Template(wraptext("a\n"), [pgens("b ", "c\n"), - pgens("d ", " e"), - pgens("f ", "g\n"), - pgens("h ", " i\n")]) - node15 = Template(wraptext("a"), [pgens("b ", " c\n"), - pgens("\nd ", " e"), - pgens("\nf ", "g ")]) - node16 = Template(wraptext("a"), [pgens("\nb ", " c"), - pgens("\nd ", " e"), - pgens("\nf ", " g")]) - node17 = Template(wraptext("a"), [pgens("\nb ", " c"), - pgens("\nd ", " e"), - pgens("\nf ", " g")]) - node18 = Template(wraptext("a\n"), [pgens("b ", "c\n"), - pgens("d ", " e"), - pgens("f ", "g\n"), - pgens("h ", " i\n")]) - node19 = Template(wraptext("a"), [pgens("b ", " c\n"), - pgens("\nd ", " e"), - pgens("\nf ", "g ")]) - node20 = Template(wraptext("a"), [pgens("\nb ", " c"), - pgens("\nd ", " e"), - pgens("\nf ", " g")]) + node13 = Template(wraptext("a"), [ + pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")]) + node14 = Template(wraptext("a\n"), [ + pgens("b ", "c\n"), pgens("d ", " e"), pgens("f ", "g\n"), + pgens("h ", " i\n")]) + node15 = Template(wraptext("a"), [ + pgens("b ", " c\n"), pgens("\nd ", " e"), pgens("\nf ", "g ")]) + node16 = Template(wraptext("a"), [ + pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")]) + node17 = Template(wraptext("a"), [ + pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")]) + node18 = Template(wraptext("a\n"), [ + pgens("b ", "c\n"), pgens("d ", " e"), pgens("f ", "g\n"), + pgens("h ", " i\n")]) + node19 = Template(wraptext("a"), [ + pgens("b ", " c\n"), pgens("\nd ", " e"), pgens("\nf ", "g ")]) + node20 = Template(wraptext("a"), [ + pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")]) node21 = Template(wraptext("a"), [pgenh("1", "b")]) node22 = Template(wraptext("a"), [pgenh("1", "b")]) node23 = Template(wraptext("a"), [pgenh("1", "b")]) @@ -190,19 +182,15 @@ class TestTemplate(TreeEqualityTestCase): node30 = Template(wraptext("a"), [pgenh("1", "b")]) node31 = Template(wraptext("a"), [pgenh("1", "b")]) node32 = Template(wraptext("a"), [pgens("1", "b")]) - node33 = Template(wraptext("a"), [pgens("\nb ", " c"), - pgens("\nd ", " e"), - pgens("\nf ", " g")]) - node34 = Template(wraptext("a\n"), [pgens("b ", "c\n"), - pgens("d ", " e"), - pgens("f ", "g\n"), - pgens("h ", " i\n")]) - node35 = Template(wraptext("a"), [pgens("b ", " c\n"), - pgens("\nd ", " e"), - pgens("\nf ", "g ")]) - node36 = Template(wraptext("a"), [pgens("\nb ", " c "), - pgens("\nd ", " e "), - pgens("\nf ", " g ")]) + node33 = Template(wraptext("a"), [ + pgens("\nb ", " c"), pgens("\nd ", " e"), pgens("\nf ", " g")]) + node34 = Template(wraptext("a\n"), [ + pgens("b ", "c\n"), pgens("d ", " e"), pgens("f ", "g\n"), + pgens("h ", " i\n")]) + node35 = Template(wraptext("a"), [ + pgens("b ", " c\n"), pgens("\nd ", " e"), pgens("\nf ", "g ")]) + node36 = Template(wraptext("a"), [ + pgens("\nb ", " c "), pgens("\nd ", " e "), pgens("\nf ", " g ")]) node37 = Template(wraptext("a"), [pgens("b", "c"), pgens("d", "e"), pgens("b", "f"), pgens("b", "h"), pgens("i", "j")]) From 7853e207451a69081573624856025f2a3f750f83 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Fri, 3 May 2013 23:43:57 -0400 Subject: [PATCH 12/15] Move wrap() and wraptext() TO _test_tree_equality. --- tests/_test_tree_equality.py | 4 ++++ tests/test_argument.py | 6 +----- tests/test_builder.py | 6 +----- tests/test_heading.py | 6 +----- tests/test_html_entity.py | 6 +----- tests/test_parameter.py | 6 +----- tests/test_template.py | 6 +----- tests/test_wikilink.py | 6 +----- 8 files changed, 11 insertions(+), 35 deletions(-) diff --git a/tests/_test_tree_equality.py b/tests/_test_tree_equality.py index 758a72e..a12bd68 100644 --- a/tests/_test_tree_equality.py +++ b/tests/_test_tree_equality.py @@ -26,8 +26,12 @@ from unittest import TestCase from mwparserfromhell.nodes import (Argument, Comment, Heading, HTMLEntity, Tag, Template, Text, Wikilink) from mwparserfromhell.nodes.extras import Attribute, Parameter +from mwparserfromhell.smart_list import SmartList from mwparserfromhell.wikicode import Wikicode +wrap = lambda L: Wikicode(SmartList(L)) +wraptext = lambda t: wrap([Text(t)]) + class TreeEqualityTestCase(TestCase): """A base test case with support for comparing the equality of node trees. diff --git a/tests/test_argument.py b/tests/test_argument.py index e0524c4..ae5ae62 100644 --- a/tests/test_argument.py +++ b/tests/test_argument.py @@ -25,12 +25,8 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Argument, Text -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase - -wrap = lambda L: Wikicode(SmartList(L)) +from ._test_tree_equality import TreeEqualityTestCase, wrap class TestArgument(TreeEqualityTestCase): """Test cases for the Argument node.""" diff --git a/tests/test_builder.py b/tests/test_builder.py index 1e578ed..76917e8 100644 --- a/tests/test_builder.py +++ b/tests/test_builder.py @@ -28,12 +28,8 @@ from mwparserfromhell.nodes import (Argument, Comment, Heading, HTMLEntity, from mwparserfromhell.nodes.extras import Attribute, Parameter from mwparserfromhell.parser import tokens from mwparserfromhell.parser.builder import Builder -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase - -wrap = lambda L: Wikicode(SmartList(L)) +from ._test_tree_equality import TreeEqualityTestCase, wrap class TestBuilder(TreeEqualityTestCase): """Tests for the builder, which turns tokens into Wikicode objects.""" diff --git a/tests/test_heading.py b/tests/test_heading.py index a0e78e5..88603a8 100644 --- a/tests/test_heading.py +++ b/tests/test_heading.py @@ -25,12 +25,8 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Heading, Text -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase - -wrap = lambda L: Wikicode(SmartList(L)) +from ._test_tree_equality import TreeEqualityTestCase, wrap class TestHeading(TreeEqualityTestCase): """Test cases for the Heading node.""" diff --git a/tests/test_html_entity.py b/tests/test_html_entity.py index a7a9669..b6b4394 100644 --- a/tests/test_html_entity.py +++ b/tests/test_html_entity.py @@ -25,12 +25,8 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import HTMLEntity -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase - -wrap = lambda L: Wikicode(SmartList(L)) +from ._test_tree_equality import TreeEqualityTestCase, wrap class TestHTMLEntity(TreeEqualityTestCase): """Test cases for the HTMLEntity node.""" diff --git a/tests/test_parameter.py b/tests/test_parameter.py index b46ad71..8e85eda 100644 --- a/tests/test_parameter.py +++ b/tests/test_parameter.py @@ -26,12 +26,8 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Text from mwparserfromhell.nodes.extras import Parameter -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase - -wrap = lambda L: Wikicode(SmartList(L)) +from ._test_tree_equality import TreeEqualityTestCase, wrap class TestParameter(TreeEqualityTestCase): """Test cases for the Parameter node extra.""" diff --git a/tests/test_template.py b/tests/test_template.py index 31ed33b..81b7382 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -26,12 +26,8 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import HTMLEntity, Template, Text from mwparserfromhell.nodes.extras import Parameter -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext -wrap = lambda L: Wikicode(SmartList(L)) -wraptext = lambda t: wrap([Text(t)]) pgens = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=True) pgenh = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=False) diff --git a/tests/test_wikilink.py b/tests/test_wikilink.py index 422489f..7c02744 100644 --- a/tests/test_wikilink.py +++ b/tests/test_wikilink.py @@ -25,12 +25,8 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Text, Wikilink -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase - -wrap = lambda L: Wikicode(SmartList(L)) +from ._test_tree_equality import TreeEqualityTestCase, wrap class TestWikilink(TreeEqualityTestCase): """Test cases for the Wikilink node.""" From eea5c774e342752dae016d79782bf755ca48de53 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Fri, 3 May 2013 23:52:10 -0400 Subject: [PATCH 13/15] Clean up some repetitive lines. --- tests/test_argument.py | 13 ++++--------- tests/test_comment.py | 7 +++---- tests/test_heading.py | 7 +++---- tests/test_html_entity.py | 20 +++++++------------- tests/test_text.py | 7 +++---- tests/test_wikilink.py | 13 ++++--------- 6 files changed, 24 insertions(+), 43 deletions(-) diff --git a/tests/test_argument.py b/tests/test_argument.py index ae5ae62..3a959b6 100644 --- a/tests/test_argument.py +++ b/tests/test_argument.py @@ -41,16 +41,11 @@ class TestArgument(TreeEqualityTestCase): def test_strip(self): """test Argument.__strip__()""" node = Argument(wrap([Text("foobar")])) - self.assertIs(None, node.__strip__(True, True)) - self.assertIs(None, node.__strip__(True, False)) - self.assertIs(None, node.__strip__(False, True)) - self.assertIs(None, node.__strip__(False, False)) - node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) - self.assertEqual("bar", node2.__strip__(True, True)) - self.assertEqual("bar", node2.__strip__(True, False)) - self.assertEqual("bar", node2.__strip__(False, True)) - self.assertEqual("bar", node2.__strip__(False, False)) + for a in (True, False): + for b in (True, False): + self.assertIs(None, node.__strip__(a, b)) + self.assertEqual("bar", node2.__strip__(a, b)) def test_showtree(self): """test Argument.__showtree__()""" diff --git a/tests/test_comment.py b/tests/test_comment.py index 980f594..a7a3c4d 100644 --- a/tests/test_comment.py +++ b/tests/test_comment.py @@ -39,10 +39,9 @@ class TestComment(TreeEqualityTestCase): def test_strip(self): """test Comment.__strip__()""" node = Comment("foobar") - self.assertIs(None, node.__strip__(True, True)) - self.assertIs(None, node.__strip__(True, False)) - self.assertIs(None, node.__strip__(False, True)) - self.assertIs(None, node.__strip__(False, False)) + for a in (True, False): + for b in (True, False): + self.assertIs(None, node.__strip__(a, b)) def test_showtree(self): """test Comment.__showtree__()""" diff --git a/tests/test_heading.py b/tests/test_heading.py index 88603a8..79b0ebf 100644 --- a/tests/test_heading.py +++ b/tests/test_heading.py @@ -41,10 +41,9 @@ class TestHeading(TreeEqualityTestCase): def test_strip(self): """test Heading.__strip__()""" node = Heading(wrap([Text("foobar")]), 3) - self.assertEqual("foobar", node.__strip__(True, True)) - self.assertEqual("foobar", node.__strip__(True, False)) - self.assertEqual("foobar", node.__strip__(False, True)) - self.assertEqual("foobar", node.__strip__(False, False)) + for a in (True, False): + for b in (True, False): + self.assertEqual("foobar", node.__strip__(a, b)) def test_showtree(self): """test Heading.__showtree__()""" diff --git a/tests/test_html_entity.py b/tests/test_html_entity.py index b6b4394..d3d23bf 100644 --- a/tests/test_html_entity.py +++ b/tests/test_html_entity.py @@ -47,19 +47,13 @@ class TestHTMLEntity(TreeEqualityTestCase): node1 = HTMLEntity("nbsp", named=True, hexadecimal=False) node2 = HTMLEntity("107", named=False, hexadecimal=False) node3 = HTMLEntity("e9", named=False, hexadecimal=True) - - self.assertEqual("\xa0", node1.__strip__(True, True)) - self.assertEqual("\xa0", node1.__strip__(True, False)) - self.assertEqual(" ", node1.__strip__(False, True)) - self.assertEqual(" ", node1.__strip__(False, False)) - self.assertEqual("k", node2.__strip__(True, True)) - self.assertEqual("k", node2.__strip__(True, False)) - self.assertEqual("k", node2.__strip__(False, True)) - self.assertEqual("k", node2.__strip__(False, False)) - self.assertEqual("é", node3.__strip__(True, True)) - self.assertEqual("é", node3.__strip__(True, False)) - self.assertEqual("é", node3.__strip__(False, True)) - self.assertEqual("é", node3.__strip__(False, False)) + for a in (True, False): + self.assertEqual("\xa0", node1.__strip__(True, a)) + self.assertEqual(" ", node1.__strip__(False, a)) + self.assertEqual("k", node2.__strip__(True, a)) + self.assertEqual("k", node2.__strip__(False, a)) + self.assertEqual("é", node3.__strip__(True, a)) + self.assertEqual("é", node3.__strip__(False, a)) def test_showtree(self): """test HTMLEntity.__showtree__()""" diff --git a/tests/test_text.py b/tests/test_text.py index 13636bf..f3649dd 100644 --- a/tests/test_text.py +++ b/tests/test_text.py @@ -39,10 +39,9 @@ class TestText(unittest.TestCase): def test_strip(self): """test Text.__strip__()""" node = Text("foobar") - self.assertIs(node, node.__strip__(True, True)) - self.assertIs(node, node.__strip__(True, False)) - self.assertIs(node, node.__strip__(False, True)) - self.assertIs(node, node.__strip__(False, False)) + for a in (True, False): + for b in (True, False): + self.assertIs(node, node.__strip__(a, b)) def test_showtree(self): """test Text.__showtree__()""" diff --git a/tests/test_wikilink.py b/tests/test_wikilink.py index 7c02744..09ca5b3 100644 --- a/tests/test_wikilink.py +++ b/tests/test_wikilink.py @@ -41,16 +41,11 @@ class TestWikilink(TreeEqualityTestCase): def test_strip(self): """test Wikilink.__strip__()""" node = Wikilink(wrap([Text("foobar")])) - self.assertEqual("foobar", node.__strip__(True, True)) - self.assertEqual("foobar", node.__strip__(True, False)) - self.assertEqual("foobar", node.__strip__(False, True)) - self.assertEqual("foobar", node.__strip__(False, False)) - node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) - self.assertEqual("bar", node2.__strip__(True, True)) - self.assertEqual("bar", node2.__strip__(True, False)) - self.assertEqual("bar", node2.__strip__(False, True)) - self.assertEqual("bar", node2.__strip__(False, False)) + for a in (True, False): + for b in (True, False): + self.assertEqual("foobar", node.__strip__(a, b)) + self.assertEqual("bar", node2.__strip__(a, b)) def test_showtree(self): """test Wikilink.__showtree__()""" From 06873ee6edcc88b6ee57d5ad57296655f2fb85c8 Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 4 May 2013 15:50:48 -0400 Subject: [PATCH 14/15] Add tests for __iternodes__(); add a getnodes() function. --- tests/_test_tree_equality.py | 9 +++++++++ tests/test_argument.py | 19 ++++++++++++++++++- tests/test_comment.py | 7 +++++++ tests/test_heading.py | 12 +++++++++++- tests/test_html_entity.py | 7 +++++++ tests/test_template.py | 26 +++++++++++++++++++++++++- tests/test_text.py | 7 +++++++ tests/test_wikilink.py | 19 ++++++++++++++++++- 8 files changed, 102 insertions(+), 4 deletions(-) diff --git a/tests/_test_tree_equality.py b/tests/_test_tree_equality.py index a12bd68..6d9b26a 100644 --- a/tests/_test_tree_equality.py +++ b/tests/_test_tree_equality.py @@ -32,6 +32,15 @@ from mwparserfromhell.wikicode import Wikicode wrap = lambda L: Wikicode(SmartList(L)) wraptext = lambda t: wrap([Text(t)]) +def getnodes(code): + """Iterate over all child nodes of a given parent node. + + Imitates Wikicode._get_all_nodes(). + """ + for node in code.nodes: + for context, child in node.__iternodes__(getnodes): + yield child + class TreeEqualityTestCase(TestCase): """A base test case with support for comparing the equality of node trees. diff --git a/tests/test_argument.py b/tests/test_argument.py index 3a959b6..a9469d4 100644 --- a/tests/test_argument.py +++ b/tests/test_argument.py @@ -26,7 +26,7 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Argument, Text -from ._test_tree_equality import TreeEqualityTestCase, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap class TestArgument(TreeEqualityTestCase): """Test cases for the Argument node.""" @@ -38,6 +38,23 @@ class TestArgument(TreeEqualityTestCase): node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) self.assertEqual("{{{foo|bar}}}", str(node2)) + def test_iternodes(self): + """test Argument.__iternodes__()""" + node1n1 = Text("foobar") + node2n1, node2n2, node2n3 = Text("foo"), Text("bar"), Text("baz") + node1 = Argument(wrap([node1n1])) + node2 = Argument(wrap([node2n1]), wrap([node2n2, node2n3])) + gen1 = node1.__iternodes__(getnodes) + gen2 = node2.__iternodes__(getnodes) + self.assertEqual((None, node1), next(gen1)) + self.assertEqual((None, node2), next(gen2)) + self.assertEqual((node1.name, node1n1), next(gen1)) + self.assertEqual((node2.name, node2n1), next(gen2)) + self.assertEqual((node2.default, node2n2), next(gen2)) + self.assertEqual((node2.default, node2n3), next(gen2)) + self.assertRaises(StopIteration, next, gen1) + self.assertRaises(StopIteration, next, gen2) + def test_strip(self): """test Argument.__strip__()""" node = Argument(wrap([Text("foobar")])) diff --git a/tests/test_comment.py b/tests/test_comment.py index a7a3c4d..44225a2 100644 --- a/tests/test_comment.py +++ b/tests/test_comment.py @@ -36,6 +36,13 @@ class TestComment(TreeEqualityTestCase): node = Comment("foobar") self.assertEqual("", str(node)) + def test_iternodes(self): + """test Comment.__iternodes__()""" + node = Comment("foobar") + gen = node.__iternodes__(None) + self.assertEqual((None, node), next(gen)) + self.assertRaises(StopIteration, next, gen) + def test_strip(self): """test Comment.__strip__()""" node = Comment("foobar") diff --git a/tests/test_heading.py b/tests/test_heading.py index 79b0ebf..38f6545 100644 --- a/tests/test_heading.py +++ b/tests/test_heading.py @@ -26,7 +26,7 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Heading, Text -from ._test_tree_equality import TreeEqualityTestCase, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap class TestHeading(TreeEqualityTestCase): """Test cases for the Heading node.""" @@ -38,6 +38,16 @@ class TestHeading(TreeEqualityTestCase): node2 = Heading(wrap([Text(" zzz ")]), 5) self.assertEqual("===== zzz =====", str(node2)) + def test_iternodes(self): + """test Heading.__iternodes__()""" + text1, text2 = Text("foo"), Text("bar") + node = Heading(wrap([text1, text2]), 3) + gen = node.__iternodes__(getnodes) + self.assertEqual((None, node), next(gen)) + self.assertEqual((node.title, text1), next(gen)) + self.assertEqual((node.title, text2), next(gen)) + self.assertRaises(StopIteration, next, gen) + def test_strip(self): """test Heading.__strip__()""" node = Heading(wrap([Text("foobar")]), 3) diff --git a/tests/test_html_entity.py b/tests/test_html_entity.py index d3d23bf..d38e5ec 100644 --- a/tests/test_html_entity.py +++ b/tests/test_html_entity.py @@ -42,6 +42,13 @@ class TestHTMLEntity(TreeEqualityTestCase): self.assertEqual("k", str(node3)) self.assertEqual("l", str(node4)) + def test_iternodes(self): + """test HTMLEntity.__iternodes__()""" + node = HTMLEntity("nbsp", named=True, hexadecimal=False) + gen = node.__iternodes__(None) + self.assertEqual((None, node), next(gen)) + self.assertRaises(StopIteration, next, gen) + def test_strip(self): """test HTMLEntity.__strip__()""" node1 = HTMLEntity("nbsp", named=True, hexadecimal=False) diff --git a/tests/test_template.py b/tests/test_template.py index 81b7382..28592df 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -26,7 +26,7 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import HTMLEntity, Template, Text from mwparserfromhell.nodes.extras import Parameter -from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap, wraptext pgens = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=True) pgenh = lambda k, v: Parameter(wraptext(k), wraptext(v), showkey=False) @@ -42,6 +42,30 @@ class TestTemplate(TreeEqualityTestCase): [pgenh("1", "bar"), pgens("abc", "def")]) self.assertEqual("{{foo|bar|abc=def}}", str(node2)) + def test_iternodes(self): + """test Template.__iternodes__()""" + node1n1 = Text("foobar") + node2n1, node2n2, node2n3 = Text("foo"), Text("bar"), Text("abc") + node2n4, node2n5 = Text("def"), Text("ghi") + node2p1 = Parameter(wraptext("1"), wrap([node2n2]), showkey=False) + node2p2 = Parameter(wrap([node2n3]), wrap([node2n4, node2n5]), + showkey=True) + node1 = Template(wrap([node1n1])) + node2 = Template(wrap([node2n1]), [node2p1, node2p2]) + + gen1 = node1.__iternodes__(getnodes) + gen2 = node2.__iternodes__(getnodes) + self.assertEqual((None, node1), next(gen1)) + self.assertEqual((None, node2), next(gen2)) + self.assertEqual((node1.name, node1n1), next(gen1)) + self.assertEqual((node2.name, node2n1), next(gen2)) + self.assertEqual((node2.params[0].value, node2n2), next(gen2)) + self.assertEqual((node2.params[1].name, node2n3), next(gen2)) + self.assertEqual((node2.params[1].value, node2n4), next(gen2)) + self.assertEqual((node2.params[1].value, node2n5), next(gen2)) + self.assertRaises(StopIteration, next, gen1) + self.assertRaises(StopIteration, next, gen2) + def test_strip(self): """test Template.__strip__()""" node1 = Template(wraptext("foobar")) diff --git a/tests/test_text.py b/tests/test_text.py index f3649dd..35ac340 100644 --- a/tests/test_text.py +++ b/tests/test_text.py @@ -36,6 +36,13 @@ class TestText(unittest.TestCase): node2 = Text("fóóbar") self.assertEqual("fóóbar", str(node2)) + def test_iternodes(self): + """test Text.__iternodes__()""" + node = Text("foobar") + gen = node.__iternodes__(None) + self.assertEqual((None, node), next(gen)) + self.assertRaises(StopIteration, next, gen) + def test_strip(self): """test Text.__strip__()""" node = Text("foobar") diff --git a/tests/test_wikilink.py b/tests/test_wikilink.py index 09ca5b3..d4319c1 100644 --- a/tests/test_wikilink.py +++ b/tests/test_wikilink.py @@ -26,7 +26,7 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Text, Wikilink -from ._test_tree_equality import TreeEqualityTestCase, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap class TestWikilink(TreeEqualityTestCase): """Test cases for the Wikilink node.""" @@ -38,6 +38,23 @@ class TestWikilink(TreeEqualityTestCase): node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) self.assertEqual("[[foo|bar]]", str(node2)) + def test_iternodes(self): + """test Wikilink.__iternodes__()""" + node1n1 = Text("foobar") + node2n1, node2n2, node2n3 = Text("foo"), Text("bar"), Text("baz") + node1 = Wikilink(wrap([node1n1])) + node2 = Wikilink(wrap([node2n1]), wrap([node2n2, node2n3])) + gen1 = node1.__iternodes__(getnodes) + gen2 = node2.__iternodes__(getnodes) + self.assertEqual((None, node1), next(gen1)) + self.assertEqual((None, node2), next(gen2)) + self.assertEqual((node1.title, node1n1), next(gen1)) + self.assertEqual((node2.title, node2n1), next(gen2)) + self.assertEqual((node2.text, node2n2), next(gen2)) + self.assertEqual((node2.text, node2n3), next(gen2)) + self.assertRaises(StopIteration, next, gen1) + self.assertRaises(StopIteration, next, gen2) + def test_strip(self): """test Wikilink.__strip__()""" node = Wikilink(wrap([Text("foobar")])) From 3fe629f54188a0f5ffde439811aab656a0418f0c Mon Sep 17 00:00:00 2001 From: Ben Kurtovic Date: Sat, 4 May 2013 16:18:14 -0400 Subject: [PATCH 15/15] Condense usage of wrap([Text("foo")]) to just wraptext("foo"). --- tests/_test_tree_equality.py | 2 +- tests/test_argument.py | 30 ++++++++-------- tests/test_builder.py | 85 +++++++++++++++++++++----------------------- tests/test_heading.py | 20 +++++------ tests/test_parameter.py | 28 +++++++-------- tests/test_parser.py | 21 +++++------ tests/test_utils.py | 27 ++++++-------- tests/test_wikilink.py | 30 ++++++++-------- 8 files changed, 114 insertions(+), 129 deletions(-) diff --git a/tests/_test_tree_equality.py b/tests/_test_tree_equality.py index 6d9b26a..52130ed 100644 --- a/tests/_test_tree_equality.py +++ b/tests/_test_tree_equality.py @@ -30,7 +30,7 @@ from mwparserfromhell.smart_list import SmartList from mwparserfromhell.wikicode import Wikicode wrap = lambda L: Wikicode(SmartList(L)) -wraptext = lambda t: wrap([Text(t)]) +wraptext = lambda *args: wrap([Text(t) for t in args]) def getnodes(code): """Iterate over all child nodes of a given parent node. diff --git a/tests/test_argument.py b/tests/test_argument.py index a9469d4..8191804 100644 --- a/tests/test_argument.py +++ b/tests/test_argument.py @@ -26,16 +26,16 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Argument, Text -from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap, wraptext class TestArgument(TreeEqualityTestCase): """Test cases for the Argument node.""" def test_unicode(self): """test Argument.__unicode__()""" - node = Argument(wrap([Text("foobar")])) + node = Argument(wraptext("foobar")) self.assertEqual("{{{foobar}}}", str(node)) - node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + node2 = Argument(wraptext("foo"), wraptext("bar")) self.assertEqual("{{{foo|bar}}}", str(node2)) def test_iternodes(self): @@ -57,8 +57,8 @@ class TestArgument(TreeEqualityTestCase): def test_strip(self): """test Argument.__strip__()""" - node = Argument(wrap([Text("foobar")])) - node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + node = Argument(wraptext("foobar")) + node2 = Argument(wraptext("foo"), wraptext("bar")) for a in (True, False): for b in (True, False): self.assertIs(None, node.__strip__(a, b)) @@ -70,8 +70,8 @@ class TestArgument(TreeEqualityTestCase): getter, marker = object(), object() get = lambda code: output.append((getter, code)) mark = lambda: output.append(marker) - node1 = Argument(wrap([Text("foobar")])) - node2 = Argument(wrap([Text("foo")]), wrap([Text("bar")])) + node1 = Argument(wraptext("foobar")) + node2 = Argument(wraptext("foo"), wraptext("bar")) node1.__showtree__(output.append, get, mark) node2.__showtree__(output.append, get, mark) valid = [ @@ -81,26 +81,26 @@ class TestArgument(TreeEqualityTestCase): def test_name(self): """test getter/setter for the name attribute""" - name = wrap([Text("foobar")]) + name = wraptext("foobar") node1 = Argument(name) - node2 = Argument(name, wrap([Text("baz")])) + node2 = Argument(name, wraptext("baz")) self.assertIs(name, node1.name) self.assertIs(name, node2.name) node1.name = "héhehé" node2.name = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.name) - self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.name) + self.assertWikicodeEqual(wraptext("héhehé"), node1.name) + self.assertWikicodeEqual(wraptext("héhehé"), node2.name) def test_default(self): """test getter/setter for the default attribute""" - default = wrap([Text("baz")]) - node1 = Argument(wrap([Text("foobar")])) - node2 = Argument(wrap([Text("foobar")]), default) + default = wraptext("baz") + node1 = Argument(wraptext("foobar")) + node2 = Argument(wraptext("foobar"), default) self.assertIs(None, node1.default) self.assertIs(default, node2.default) node1.default = "buzz" node2.default = None - self.assertWikicodeEqual(wrap([Text("buzz")]), node1.default) + self.assertWikicodeEqual(wraptext("buzz"), node1.default) self.assertIs(None, node2.default) if __name__ == "__main__": diff --git a/tests/test_builder.py b/tests/test_builder.py index 76917e8..903d144 100644 --- a/tests/test_builder.py +++ b/tests/test_builder.py @@ -29,7 +29,7 @@ from mwparserfromhell.nodes.extras import Attribute, Parameter from mwparserfromhell.parser import tokens from mwparserfromhell.parser.builder import Builder -from ._test_tree_equality import TreeEqualityTestCase, wrap +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext class TestBuilder(TreeEqualityTestCase): """Tests for the builder, which turns tokens into Wikicode objects.""" @@ -40,10 +40,10 @@ class TestBuilder(TreeEqualityTestCase): def test_text(self): """tests for building Text nodes""" tests = [ - ([tokens.Text(text="foobar")], wrap([Text("foobar")])), - ([tokens.Text(text="fóóbar")], wrap([Text("fóóbar")])), + ([tokens.Text(text="foobar")], wraptext("foobar")), + ([tokens.Text(text="fóóbar")], wraptext("fóóbar")), ([tokens.Text(text="spam"), tokens.Text(text="eggs")], - wrap([Text("spam"), Text("eggs")])), + wraptext("spam", "eggs")), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -53,25 +53,24 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.TemplateOpen(), tokens.Text(text="foobar"), tokens.TemplateClose()], - wrap([Template(wrap([Text("foobar")]))])), + wrap([Template(wraptext("foobar"))])), ([tokens.TemplateOpen(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.TemplateClose()], - wrap([Template(wrap([Text("spam"), Text("eggs")]))])), + wrap([Template(wraptext("spam", "eggs"))])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), tokens.TemplateClose()], - wrap([Template(wrap([Text("foo")]), params=[ - Parameter(wrap([Text("1")]), wrap([Text("bar")]), - showkey=False)])])), + wrap([Template(wraptext("foo"), params=[ + Parameter(wraptext("1"), wraptext("bar"), showkey=False)])])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), tokens.TemplateParamEquals(), tokens.Text(text="baz"), tokens.TemplateClose()], - wrap([Template(wrap([Text("foo")]), params=[ - Parameter(wrap([Text("bar")]), wrap([Text("baz")]))])])), + wrap([Template(wraptext("foo"), params=[ + Parameter(wraptext("bar"), wraptext("baz"))])])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), @@ -82,14 +81,12 @@ class TestBuilder(TreeEqualityTestCase): tokens.TemplateParamEquals(), tokens.Text(text="buff"), tokens.TemplateParamSeparator(), tokens.Text(text="baff"), tokens.TemplateClose()], - wrap([Template(wrap([Text("foo")]), params=[ - Parameter(wrap([Text("bar")]), wrap([Text("baz")])), - Parameter(wrap([Text("1")]), wrap([Text("biz")]), - showkey=False), - Parameter(wrap([Text("2")]), wrap([Text("buzz")]), - showkey=False), - Parameter(wrap([Text("3")]), wrap([Text("buff")])), - Parameter(wrap([Text("3")]), wrap([Text("baff")]), + wrap([Template(wraptext("foo"), params=[ + Parameter(wraptext("bar"), wraptext("baz")), + Parameter(wraptext("1"), wraptext("biz"), showkey=False), + Parameter(wraptext("2"), wraptext("buzz"), showkey=False), + Parameter(wraptext("3"), wraptext("buff")), + Parameter(wraptext("3"), wraptext("baff"), showkey=False)])])), ] for test, valid in tests: @@ -100,23 +97,22 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.ArgumentOpen(), tokens.Text(text="foobar"), tokens.ArgumentClose()], - wrap([Argument(wrap([Text("foobar")]))])), + wrap([Argument(wraptext("foobar"))])), ([tokens.ArgumentOpen(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.ArgumentClose()], - wrap([Argument(wrap([Text("spam"), Text("eggs")]))])), + wrap([Argument(wraptext("spam", "eggs"))])), ([tokens.ArgumentOpen(), tokens.Text(text="foo"), tokens.ArgumentSeparator(), tokens.Text(text="bar"), tokens.ArgumentClose()], - wrap([Argument(wrap([Text("foo")]), wrap([Text("bar")]))])), + wrap([Argument(wraptext("foo"), wraptext("bar"))])), ([tokens.ArgumentOpen(), tokens.Text(text="foo"), tokens.Text(text="bar"), tokens.ArgumentSeparator(), tokens.Text(text="baz"), tokens.Text(text="biz"), tokens.ArgumentClose()], - wrap([Argument(wrap([Text("foo"), Text("bar")]), - wrap([Text("baz"), Text("biz")]))])), + wrap([Argument(wraptext("foo", "bar"), wraptext("baz", "biz"))])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -126,23 +122,22 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.WikilinkOpen(), tokens.Text(text="foobar"), tokens.WikilinkClose()], - wrap([Wikilink(wrap([Text("foobar")]))])), + wrap([Wikilink(wraptext("foobar"))])), ([tokens.WikilinkOpen(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.WikilinkClose()], - wrap([Wikilink(wrap([Text("spam"), Text("eggs")]))])), + wrap([Wikilink(wraptext("spam", "eggs"))])), ([tokens.WikilinkOpen(), tokens.Text(text="foo"), tokens.WikilinkSeparator(), tokens.Text(text="bar"), tokens.WikilinkClose()], - wrap([Wikilink(wrap([Text("foo")]), wrap([Text("bar")]))])), + wrap([Wikilink(wraptext("foo"), wraptext("bar"))])), ([tokens.WikilinkOpen(), tokens.Text(text="foo"), tokens.Text(text="bar"), tokens.WikilinkSeparator(), tokens.Text(text="baz"), tokens.Text(text="biz"), tokens.WikilinkClose()], - wrap([Wikilink(wrap([Text("foo"), Text("bar")]), - wrap([Text("baz"), Text("biz")]))])), + wrap([Wikilink(wraptext("foo", "bar"), wraptext("baz", "biz"))])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -172,11 +167,11 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.HeadingStart(level=2), tokens.Text(text="foobar"), tokens.HeadingEnd()], - wrap([Heading(wrap([Text("foobar")]), 2)])), + wrap([Heading(wraptext("foobar"), 2)])), ([tokens.HeadingStart(level=4), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.HeadingEnd()], - wrap([Heading(wrap([Text("spam"), Text("eggs")]), 4)])), + wrap([Heading(wraptext("spam", "eggs"), 4)])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -186,11 +181,11 @@ class TestBuilder(TreeEqualityTestCase): tests = [ ([tokens.CommentStart(), tokens.Text(text="foobar"), tokens.CommentEnd()], - wrap([Comment(wrap([Text("foobar")]))])), + wrap([Comment(wraptext("foobar"))])), ([tokens.CommentStart(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.CommentEnd()], - wrap([Comment(wrap([Text("spam"), Text("eggs")]))])), + wrap([Comment(wraptext("spam", "eggs"))])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -214,10 +209,10 @@ class TestBuilder(TreeEqualityTestCase): tokens.TemplateOpen(), tokens.Text(text="bin"), tokens.TemplateClose(), tokens.TemplateClose()] valid = wrap( - [Template(wrap([Template(wrap([Template(wrap([Template(wrap([Text( - "foo")])), Text("bar")]), params=[Parameter(wrap([Text("baz")]), - wrap([Text("biz")]))]), Text("buzz")])), Text("usr")]), params=[ - Parameter(wrap([Text("1")]), wrap([Template(wrap([Text("bin")]))]), + [Template(wrap([Template(wrap([Template(wrap([Template(wraptext( + "foo")), Text("bar")]), params=[Parameter(wraptext("baz"), + wraptext("biz"))]), Text("buzz")])), Text("usr")]), params=[ + Parameter(wraptext("1"), wrap([Template(wraptext("bin"))]), showkey=False)])]) self.assertWikicodeEqual(valid, self.builder.build(test)) @@ -243,14 +238,14 @@ class TestBuilder(TreeEqualityTestCase): tokens.Text(text="nbsp"), tokens.HTMLEntityEnd(), tokens.TemplateClose()] valid = wrap( - [Template(wrap([Text("a")]), params=[Parameter(wrap([Text("1")]), - wrap([Text("b")]), showkey=False), Parameter(wrap([Text("2")]), - wrap([Template(wrap([Text("c")]), params=[Parameter(wrap([Text("1") - ]), wrap([Wikilink(wrap([Text("d")])), Argument(wrap([Text("e")]))] - ), showkey=False)])]), showkey=False)]), Wikilink(wrap([Text("f")] - ), wrap([Argument(wrap([Text("g")])), Comment(wrap([Text("h")]))]) - ), Template(wrap([Text("i")]), params=[Parameter(wrap([Text("j")]), - wrap([HTMLEntity("nbsp", named=True)]))])]) + [Template(wraptext("a"), params=[Parameter(wraptext("1"), wraptext( + "b"), showkey=False), Parameter(wraptext("2"), wrap([Template( + wraptext("c"), params=[Parameter(wraptext("1"), wrap([Wikilink( + wraptext("d")), Argument(wraptext("e"))]), showkey=False)])]), + showkey=False)]), Wikilink(wraptext("f"), wrap([Argument(wraptext( + "g")), Comment(wraptext("h"))])), Template(wraptext("i"), params=[ + Parameter(wraptext("j"), wrap([HTMLEntity("nbsp", + named=True)]))])]) self.assertWikicodeEqual(valid, self.builder.build(test)) if __name__ == "__main__": diff --git a/tests/test_heading.py b/tests/test_heading.py index 38f6545..7a65872 100644 --- a/tests/test_heading.py +++ b/tests/test_heading.py @@ -26,16 +26,16 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Heading, Text -from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap, wraptext class TestHeading(TreeEqualityTestCase): """Test cases for the Heading node.""" def test_unicode(self): """test Heading.__unicode__()""" - node = Heading(wrap([Text("foobar")]), 2) + node = Heading(wraptext("foobar"), 2) self.assertEqual("==foobar==", str(node)) - node2 = Heading(wrap([Text(" zzz ")]), 5) + node2 = Heading(wraptext(" zzz "), 5) self.assertEqual("===== zzz =====", str(node2)) def test_iternodes(self): @@ -50,7 +50,7 @@ class TestHeading(TreeEqualityTestCase): def test_strip(self): """test Heading.__strip__()""" - node = Heading(wrap([Text("foobar")]), 3) + node = Heading(wraptext("foobar"), 3) for a in (True, False): for b in (True, False): self.assertEqual("foobar", node.__strip__(a, b)) @@ -60,8 +60,8 @@ class TestHeading(TreeEqualityTestCase): output = [] getter = object() get = lambda code: output.append((getter, code)) - node1 = Heading(wrap([Text("foobar")]), 3) - node2 = Heading(wrap([Text(" baz ")]), 4) + node1 = Heading(wraptext("foobar"), 3) + node2 = Heading(wraptext(" baz "), 4) node1.__showtree__(output.append, get, None) node2.__showtree__(output.append, get, None) valid = ["===", (getter, node1.title), "===", @@ -70,20 +70,18 @@ class TestHeading(TreeEqualityTestCase): def test_title(self): """test getter/setter for the title attribute""" - title = wrap([Text("foobar")]) + title = wraptext("foobar") node = Heading(title, 3) self.assertIs(title, node.title) node.title = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node.title) + self.assertWikicodeEqual(wraptext("héhehé"), node.title) def test_level(self): """test getter/setter for the level attribute""" - node = Heading(wrap([Text("foobar")]), 3) + node = Heading(wraptext("foobar"), 3) self.assertEqual(3, node.level) node.level = 5 self.assertEqual(5, node.level) - node.level = True - self.assertEqual(1, node.level) self.assertRaises(ValueError, setattr, node, "level", 0) self.assertRaises(ValueError, setattr, node, "level", 7) self.assertRaises(ValueError, setattr, node, "level", "abc") diff --git a/tests/test_parameter.py b/tests/test_parameter.py index 8e85eda..4786e12 100644 --- a/tests/test_parameter.py +++ b/tests/test_parameter.py @@ -27,43 +27,43 @@ from mwparserfromhell.compat import str from mwparserfromhell.nodes import Text from mwparserfromhell.nodes.extras import Parameter -from ._test_tree_equality import TreeEqualityTestCase, wrap +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext class TestParameter(TreeEqualityTestCase): """Test cases for the Parameter node extra.""" def test_unicode(self): """test Parameter.__unicode__()""" - node = Parameter(wrap([Text("1")]), wrap([Text("foo")]), showkey=False) + node = Parameter(wraptext("1"), wraptext("foo"), showkey=False) self.assertEqual("foo", str(node)) - node2 = Parameter(wrap([Text("foo")]), wrap([Text("bar")])) + node2 = Parameter(wraptext("foo"), wraptext("bar")) self.assertEqual("foo=bar", str(node2)) def test_name(self): """test getter/setter for the name attribute""" - name1 = wrap([Text("1")]) - name2 = wrap([Text("foobar")]) - node1 = Parameter(name1, wrap([Text("foobar")]), showkey=False) - node2 = Parameter(name2, wrap([Text("baz")])) + name1 = wraptext("1") + name2 = wraptext("foobar") + node1 = Parameter(name1, wraptext("foobar"), showkey=False) + node2 = Parameter(name2, wraptext("baz")) self.assertIs(name1, node1.name) self.assertIs(name2, node2.name) node1.name = "héhehé" node2.name = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.name) - self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.name) + self.assertWikicodeEqual(wraptext("héhehé"), node1.name) + self.assertWikicodeEqual(wraptext("héhehé"), node2.name) def test_value(self): """test getter/setter for the value attribute""" - value = wrap([Text("bar")]) - node = Parameter(wrap([Text("foo")]), value) + value = wraptext("bar") + node = Parameter(wraptext("foo"), value) self.assertIs(value, node.value) node.value = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node.value) + self.assertWikicodeEqual(wraptext("héhehé"), node.value) def test_showkey(self): """test getter/setter for the showkey attribute""" - node1 = Parameter(wrap([Text("1")]), wrap([Text("foo")]), showkey=False) - node2 = Parameter(wrap([Text("foo")]), wrap([Text("bar")])) + node1 = Parameter(wraptext("1"), wraptext("foo"), showkey=False) + node2 = Parameter(wraptext("foo"), wraptext("bar")) self.assertFalse(node1.showkey) self.assertTrue(node2.showkey) node1.showkey = True diff --git a/tests/test_parser.py b/tests/test_parser.py index 9d2c969..ec5f065 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -26,10 +26,8 @@ import unittest from mwparserfromhell import parser from mwparserfromhell.nodes import Template, Text, Wikilink from mwparserfromhell.nodes.extras import Parameter -from mwparserfromhell.smart_list import SmartList -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext from .compat import range class TestParser(TreeEqualityTestCase): @@ -45,18 +43,17 @@ class TestParser(TreeEqualityTestCase): def test_parsing(self): """integration test for parsing overall""" text = "this is text; {{this|is=a|template={{with|[[links]]|in}}it}}" - wrap = lambda L: Wikicode(SmartList(L)) expected = wrap([ Text("this is text; "), - Template(wrap([Text("this")]), [ - Parameter(wrap([Text("is")]), wrap([Text("a")])), - Parameter(wrap([Text("template")]), wrap([ - Template(wrap([Text("with")]), [ - Parameter(wrap([Text("1")]), - wrap([Wikilink(wrap([Text("links")]))]), + Template(wraptext("this"), [ + Parameter(wraptext("is"), wraptext("a")), + Parameter(wraptext("template"), wrap([ + Template(wraptext("with"), [ + Parameter(wraptext("1"), + wrap([Wikilink(wraptext("links"))]), showkey=False), - Parameter(wrap([Text("2")]), - wrap([Text("in")]), showkey=False) + Parameter(wraptext("2"), + wraptext("in"), showkey=False) ]), Text("it") ])) diff --git a/tests/test_utils.py b/tests/test_utils.py index c088530..80a0e5e 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -24,33 +24,28 @@ from __future__ import unicode_literals import unittest from mwparserfromhell.nodes import Template, Text -from mwparserfromhell.smart_list import SmartList from mwparserfromhell.utils import parse_anything -from mwparserfromhell.wikicode import Wikicode -from ._test_tree_equality import TreeEqualityTestCase +from ._test_tree_equality import TreeEqualityTestCase, wrap, wraptext class TestUtils(TreeEqualityTestCase): """Tests for the utils module, which provides parse_anything().""" def test_parse_anything_valid(self): """tests for valid input to utils.parse_anything()""" - wrap = lambda L: Wikicode(SmartList(L)) - textify = lambda L: wrap([Text(item) for item in L]) tests = [ - (wrap([Text("foobar")]), textify(["foobar"])), - (Template(wrap([Text("spam")])), - wrap([Template(textify(["spam"]))])), - ("fóóbar", textify(["fóóbar"])), - (b"foob\xc3\xa1r", textify(["foobár"])), - (123, textify(["123"])), - (True, textify(["True"])), + (wraptext("foobar"), wraptext("foobar")), + (Template(wraptext("spam")), wrap([Template(wraptext("spam"))])), + ("fóóbar", wraptext("fóóbar")), + (b"foob\xc3\xa1r", wraptext("foobár")), + (123, wraptext("123")), + (True, wraptext("True")), (None, wrap([])), ([Text("foo"), Text("bar"), Text("baz")], - textify(["foo", "bar", "baz"])), - ([wrap([Text("foo")]), Text("bar"), "baz", 123, 456], - textify(["foo", "bar", "baz", "123", "456"])), - ([[[([[((("foo",),),)], "bar"],)]]], textify(["foo", "bar"])) + wraptext("foo", "bar", "baz")), + ([wraptext("foo"), Text("bar"), "baz", 123, 456], + wraptext("foo", "bar", "baz", "123", "456")), + ([[[([[((("foo",),),)], "bar"],)]]], wraptext("foo", "bar")) ] for test, valid in tests: self.assertWikicodeEqual(valid, parse_anything(test)) diff --git a/tests/test_wikilink.py b/tests/test_wikilink.py index d4319c1..7851032 100644 --- a/tests/test_wikilink.py +++ b/tests/test_wikilink.py @@ -26,16 +26,16 @@ import unittest from mwparserfromhell.compat import str from mwparserfromhell.nodes import Text, Wikilink -from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap +from ._test_tree_equality import TreeEqualityTestCase, getnodes, wrap, wraptext class TestWikilink(TreeEqualityTestCase): """Test cases for the Wikilink node.""" def test_unicode(self): """test Wikilink.__unicode__()""" - node = Wikilink(wrap([Text("foobar")])) + node = Wikilink(wraptext("foobar")) self.assertEqual("[[foobar]]", str(node)) - node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + node2 = Wikilink(wraptext("foo"), wraptext("bar")) self.assertEqual("[[foo|bar]]", str(node2)) def test_iternodes(self): @@ -57,8 +57,8 @@ class TestWikilink(TreeEqualityTestCase): def test_strip(self): """test Wikilink.__strip__()""" - node = Wikilink(wrap([Text("foobar")])) - node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + node = Wikilink(wraptext("foobar")) + node2 = Wikilink(wraptext("foo"), wraptext("bar")) for a in (True, False): for b in (True, False): self.assertEqual("foobar", node.__strip__(a, b)) @@ -70,8 +70,8 @@ class TestWikilink(TreeEqualityTestCase): getter, marker = object(), object() get = lambda code: output.append((getter, code)) mark = lambda: output.append(marker) - node1 = Wikilink(wrap([Text("foobar")])) - node2 = Wikilink(wrap([Text("foo")]), wrap([Text("bar")])) + node1 = Wikilink(wraptext("foobar")) + node2 = Wikilink(wraptext("foo"), wraptext("bar")) node1.__showtree__(output.append, get, mark) node2.__showtree__(output.append, get, mark) valid = [ @@ -81,26 +81,26 @@ class TestWikilink(TreeEqualityTestCase): def test_title(self): """test getter/setter for the title attribute""" - title = wrap([Text("foobar")]) + title = wraptext("foobar") node1 = Wikilink(title) - node2 = Wikilink(title, wrap([Text("baz")])) + node2 = Wikilink(title, wraptext("baz")) self.assertIs(title, node1.title) self.assertIs(title, node2.title) node1.title = "héhehé" node2.title = "héhehé" - self.assertWikicodeEqual(wrap([Text("héhehé")]), node1.title) - self.assertWikicodeEqual(wrap([Text("héhehé")]), node2.title) + self.assertWikicodeEqual(wraptext("héhehé"), node1.title) + self.assertWikicodeEqual(wraptext("héhehé"), node2.title) def test_text(self): """test getter/setter for the text attribute""" - text = wrap([Text("baz")]) - node1 = Wikilink(wrap([Text("foobar")])) - node2 = Wikilink(wrap([Text("foobar")]), text) + text = wraptext("baz") + node1 = Wikilink(wraptext("foobar")) + node2 = Wikilink(wraptext("foobar"), text) self.assertIs(None, node1.text) self.assertIs(text, node2.text) node1.text = "buzz" node2.text = None - self.assertWikicodeEqual(wrap([Text("buzz")]), node1.text) + self.assertWikicodeEqual(wraptext("buzz"), node1.text) self.assertIs(None, node2.text) if __name__ == "__main__":