fixed template and parser function "=" semantic

docs/index.rst

@@ -41,7 +41,7 @@ SubWikiTextWithAttrs
 
 SubWikiTextWithArgs
 --------------------
-.. autoclass:: wikitextparser._parser_function.SubWikiTextWithArgs
+.. autoclass:: wikitextparser._argument.SubWikiTextWithArgs
    :members:
    :special-members:
    :show-inheritance:

tests/test_argument.py

@@ -1,45 +1,47 @@
-from pytest import raises
-
 from wikitextparser import Argument, Template, parse
 
 
 def test_basics():
     a = Argument('| a = b ')
-    assert ' a ' == a.name
-    assert ' b ' == a.value
-    assert not a.positional
+    assert ' a ' == a.get_name(False)
+    assert ' b ' == a.get_value(False)
+    assert not a.is_positional(False)
     assert repr(a) == "Argument('| a = b ')"
 
 
 def test_anonymous_parameter():
     a = Argument('| a ')
-    assert '1' == a.name
-    assert ' a ' == a.value
+    assert '1' == a.get_name(False)
+    assert ' a ' == a.get_value(False)
 
 
 def test_set_name():
     a = Argument('| a = b ')
-    a.name = ' c '
+    a.set_name(' c ', False)
     assert '| c = b ' == a.string
+    a.set_name(' c ', True)
+    assert '| c = c = b ' == a.string
 
 
 def test_set_name_at_subspan_boundary():
     a = Argument('|{{ a }}={{ b }}')
-    a.name = ' c '
+    a.set_name(' c ', False)
     assert '| c ={{ b }}' == a.string
-    assert '{{ b }}' == a.value
+    assert '{{ b }}' == a.get_value(False)
 
 
 def test_set_name_for_positional_args():
     a = Argument('| b ')
-    a.name = a.name
+    a.set_name(a.get_name(False), False)
     assert '|1= b ' == a.string
 
 
 def test_value_setter():
     a = Argument('| a = b ')
-    a.value = ' c '
+    a.set_value(' c ', ignore_equals=False)
     assert '| a = c ' == a.string
+    a.set_value(' c ', ignore_equals=True)
+    assert '| c ' == a.string
 
 
 def test_removing_last_arg_should_not_effect_the_others():
@@ -51,42 +53,40 @@ def test_removing_last_arg_should_not_effect_the_others():
 
 def test_nowikied_arg():
     a = Argument('|<nowiki>1=3</nowiki>')
-    assert a.positional is True
-    assert '1' == a.name
-    assert '<nowiki>1=3</nowiki>' == a.value
+    assert a.is_positional(False) is True
+    assert '1' == a.get_name(False)
+    assert '<nowiki>1=3</nowiki>' == a.get_value(False)
 
 
 def test_value_after_convertion_of_positional_to_keywordk():
     a = Argument("""|{{{a|{{{b}}}}}}""")
-    a.name = ' 1 '
-    assert '{{{a|{{{b}}}}}}' == a.value
+    a.set_name(' 1 ', False)
+    assert '{{{a|{{{b}}}}}}' == a.get_value(False)
 
 
 def test_name_of_positionals():
     assert ['1', '2', '3'] == [
-        a.name for a in parse('{{t|a|b|c}}').templates[0].arguments
+        a.get_name(False) for a in parse('{{t|a|b|c}}').templates[0].arguments
     ]
 
 
 def test_dont_confuse_subspan_equal_with_keyword_arg_equal():
     p = parse('{{text| {{text|1=first}} | b }}')
     a0, a1 = p.templates[0].arguments
-    assert ' {{text|1=first}} ' == a0.value
-    assert '1' == a0.name
-    assert ' b ' == a1.value
-    assert '2' == a1.name
+    assert ' {{text|1=first}} ' == a0.get_value(False)
+    assert '1' == a0.get_name(False)
+    assert ' b ' == a1.get_value(False)
+    assert '2' == a1.get_name(False)
 
 
 def test_setting_positionality():
     a = Argument('|1=v')
-    a.positional = False
+    a.make_positional(True)
     assert '|1=v' == a.string
-    a.positional = True
+    a.make_positional(False)
     assert '|v' == a.string
-    a.positional = True
+    a.make_positional(False)
     assert '|v' == a.string
-    with raises(ValueError):
-        a.positional = False
 
 
 def test_parser_functions_at_the_end():
@@ -96,12 +96,12 @@ def test_parser_functions_at_the_end():
 
 def test_section_not_keyword_arg():
     a = Argument('|1=foo\n== section ==\nbar')
-    assert (a.name, a.value) == ('1', 'foo\n== section ==\nbar')
+    assert (a.get_name(False), a.get_value(False)) == ('1', 'foo\n== section ==\nbar')
     a = Argument('|\n==t==\nx')
-    assert (a.name, a.value) == ('1', '\n==t==\nx')
+    assert (a.get_name(False), a.get_value(False)) == ('1', '\n==t==\nx')
     # Following cases is not treated as a section headings
     a = Argument('|==1==\n')
-    assert (a.name, a.value) == ('', '=1==\n')
+    assert (a.get_name(False), a.get_value(False)) == ('', '=1==\n')
     # Todo: Prevents forming a template!
     # a = Argument('|\n==1==')
     # assert
@@ -112,9 +112,9 @@ def test_argument_name_not_external_link():
     # MediaWiki parses template parameters before external links,
     # so it goes with the named parameter in both cases.
     a = Argument('|[http://example.com?foo=bar]')
-    assert (a.name, a.value) == ('[http://example.com?foo', 'bar]')
+    assert (a.get_name(False), a.get_value(False)) == ('[http://example.com?foo', 'bar]')
     a = Argument('|http://example.com?foo=bar')
-    assert (a.name, a.value) == ('http://example.com?foo', 'bar')
+    assert (a.get_name(False), a.get_value(False)) == ('http://example.com?foo', 'bar')
 
 
 def test_lists():
@@ -128,13 +128,13 @@ def test_lists():
 
 def test_equal_sign_in_val():
     a, c = Template('{{t|a==b|c}}').arguments
-    assert a.value == '=b'
-    assert c.name == '1'
+    assert a.get_value(False) == '=b'
+    assert c.get_name(False) == '1'
 
 
 def test_tag_with_equal_sign():
-    assert Argument('|a<ref name="abc">R</ref>').name == '1'
+    assert Argument('|a<ref name="abc">R</ref>').get_name(False) == '1'
 
 
 def test_section_heading_with_carriage_return_in_name():
-    assert Argument('|a\r== heading ==\rb=c').name == 'a\r== heading ==\rb'
+    assert Argument('|a\r== heading ==\rb=c').get_name(False) == 'a\r== heading ==\rb'

tests/test_cell.py

@@ -81,7 +81,7 @@ def test_update_match_from_shadow():
     assert c is not None
     assert c.value == '{{text|s}}'
     t = c.templates[0]
-    t.arguments[0].value = 't'
+    t.arguments[0].set_value('t', False)
     assert c.value == '{{text|t}}'
 
 

tests/test_parser_function.py

@@ -1,4 +1,4 @@
-from pytest import mark
+from pytest import mark, raises
 
 from wikitextparser import ParserFunction, WikiText
 
@@ -28,8 +28,8 @@ def test_name_and_args():
     assert ' #if' == f.name
     args = f.arguments
     assert [': test ', '| true ', '| false '] == [a.string for a in args]
-    assert args[0].name == '1'
-    assert args[2].name == '3'
+    assert args[0].get_name(True) == '1'
+    assert args[2].get_name(True) == '3'
 
 
 def test_set_name():
@@ -38,6 +38,15 @@ def test_set_name():
     assert '{{#if: test | true | false }}' == pf.string
 
 
+def test_normal_name():
+    assert '#u ' == ParserFunction('{{ #u :a}}').normal_name()
+    assert '#u ' == ParserFunction('{{ #U :a}}').normal_name()
+    assert '#a_b' == ParserFunction('{{#a_b:}}').normal_name()
+    assert '#t#a' == ParserFunction('{{#t#a:a}}').normal_name()
+    assert '#a___b' == ParserFunction('{{#A___B:}}').normal_name()
+    assert '#t' == ParserFunction('{{<!---->\n #T<!---->:}}').normal_name()
+
+
 def test_pipes_inside_params_or_templates():
     pf = ParserFunction('{{ #if: test | {{ text | aaa }} }}')
     assert [] == pf.parameters
@@ -68,19 +77,94 @@ def test_parser_function_alias_without_hash_sign():
 def test_argument_with_existing_span():
     """Test when the span is already in type_to_spans."""
     pf = WikiText('{{formatnum:text}}').parser_functions[0]
-    assert pf.arguments[0].value == 'text'
-    assert pf.arguments[0].value == 'text'
+    assert pf.arguments[0].get_value(True) == 'text'
+    assert pf.arguments[0].get_value(True) == 'text'
     assert pf.string == '{{formatnum:text}}'
 
 
 def test_tag_containing_pipe():
     assert len(ParserFunction('{{text|a<s |>b</s>c}}').arguments) == 1
 
 
-@mark.skip(
-    reason='ParserFunction arguments currently inherit Template "=" semantics'
-)
 def test_equal_in_if_expression():
     pf = ParserFunction('{{#if: 2==2 | yes | no }}')
-    pf.arguments[0].value = '3'
-    assert pf.string == '{{#if: 3 | yes | no }}'
+    pf.arguments[0].set_value('3', ignore_equals=True)
+    assert pf.string == '{{#if:3| yes | no }}'
+
+
+def test_has_arg():
+    has_arg = ParserFunction('{{#pf:a|b=c}}').has_arg
+    assert has_arg('1', ignore_equals=True) is True
+    assert has_arg('1', 'a', ignore_equals=True) is True
+    assert has_arg('b', ignore_equals=True) is False
+    assert has_arg('b', 'c', ignore_equals=True) is False
+    assert has_arg('2', ignore_equals=True) is True
+    assert has_arg('2', 'b=c', ignore_equals=True) is True
+    assert has_arg('c', ignore_equals=True) is False
+    assert has_arg('b', 'd', ignore_equals=True) is False
+
+
+def test_get_arg():
+    get_arg = ParserFunction('{{#pf:a|b=c}}').get_arg
+    assert ':a' == get_arg('1', ignore_equals=True).string  # type: ignore
+    assert get_arg('c', ignore_equals=True) is None
+
+
+def test_name_contains_a_param_with_default():
+    t = ParserFunction('{{#pf {{{p1|d1}}} : {{{p2|d2}}} }}')
+    assert '#pf {{{p1|d1}}} ' == t.name
+    assert ': {{{p2|d2}}} ' == t.arguments[0].string
+    t.name = 'g'
+    assert 'g' == t.name
+
+
+def test_set_arg():
+    t = ParserFunction('{{#pf}}')
+    t.set_arg('1', 'b', ignore_equals=True)
+    assert '{{#pf:b}}' == t.string
+    t = ParserFunction('{{#pf:a}}')
+    t.set_arg('1', 'b', ignore_equals=True)
+    assert '{{#pf:b}}' == t.string
+    t = ParserFunction('{{#pf:a|b}}')
+    t.set_arg('2', 'c', ignore_equals=True)
+    assert '{{#pf:a|c}}' == t.string
+    with raises(ValueError):
+        t = ParserFunction('{{#pf:a|b}}')
+        t.set_arg('4', 'c', ignore_equals=True)
+    with raises(ValueError):
+        t = ParserFunction('{{#pf:a|b}}')
+        t.set_arg('xd', 'c', ignore_equals=True)
+    t = ParserFunction('{{#pf:a|b}}')
+    t.set_arg('4', 'c', ignore_equals=False)
+    assert '{{#pf:a|b|4=c}}' == t.string
+    t = ParserFunction('{{#pf:a|b}}')
+    t.set_arg('xd', 'c', ignore_equals=False)
+    assert '{{#pf:a|b|xd=c}}' == t.string
+    with raises(ValueError):
+        t = ParserFunction('{{#pf:a|b}}')
+        t.set_arg('2', 'c', False, ignore_equals=False)
+
+
+def test_del_arg():
+    t = ParserFunction('{{#pf:a}}')
+    t.del_arg('1', ignore_equals=True)
+    assert '{{#pf}}' == t.string
+    t = ParserFunction('{{#pf:a|b}}')
+    t.del_arg('2', ignore_equals=True)
+    assert '{{#pf:a}}' == t.string
+
+
+def test_lists():
+    l1, l2 = ParserFunction('{{#pf:*a\n*b|*c\n*d}}').get_lists()
+    assert l1.items == ['a', 'b']
+    assert l2.items == ['c', 'd']
+    assert ParserFunction('{{#pf:;https://a.b :d}}').get_lists('[;:]')[0].items == [
+        'https://a.b ',
+        'd',
+    ]
+
+
+def test_get_last_positional_index():
+    t = ParserFunction('{{#pf:a|b|c=d}}')
+    assert t.get_last_positional_index(ignore_equals=False) == 2
+    assert t.get_last_positional_index(ignore_equals=True) == 3

tests/test_spans.py

@@ -208,29 +208,29 @@ def test_keyword_and_positional_args_removal():
     t1, t2 = wt.templates
     t1_args = t1.arguments
     t2_args = t2.arguments
-    assert '1' == t1_args[2].name
-    assert 'kw2' == t1_args[3].name
-    assert '2' == t1_args[4].name
-    assert '1' == t2_args[0].name
-    assert '2' == t2_args[1].name
-    assert '1' == t2_args[2].name
+    assert '1' == t1_args[2].get_name(False)
+    assert 'kw2' == t1_args[3].get_name(False)
+    assert '2' == t1_args[4].get_name(False)
+    assert '1' == t2_args[0].get_name(False)
+    assert '2' == t2_args[1].get_name(False)
+    assert '1' == t2_args[2].get_name(False)
     del t1_args[0][:]
     t1_args = t1.arguments
     t2_args = t2.arguments
-    assert '1' == t1_args[0].name
-    assert 'kw2' == t1_args[2].name
+    assert '1' == t1_args[0].get_name(False)
+    assert 'kw2' == t1_args[2].get_name(False)
     assert '|pa2' == t1_args[3].string
-    assert '1' == t2_args[0].name
-    assert '2' == t2_args[1].name
-    assert '1' == t2_args[2].name
+    assert '1' == t2_args[0].get_name(False)
+    assert '2' == t2_args[1].get_name(False)
+    assert '1' == t2_args[2].get_name(False)
     del t1_args[1][:]
     t1_args = t1.arguments
     t2_args = t2.arguments
     assert 'text{{t1|1=|kw2=a|pa2}}{{t2|a|1|1=}}text' == wt.string
-    assert 'pa2' == t1_args[2].value
-    assert '1' == t1_args[2].name
-    assert 'a' == t2_args[0].value
-    assert '1' == t2_args[0].name
+    assert 'pa2' == t1_args[2].get_value(False)
+    assert '1' == t1_args[2].get_name(False)
+    assert 'a' == t2_args[0].get_value(False)
+    assert '1' == t2_args[0].get_name(False)
 
 
 def test_parser_function_regex():