def test_overwriting_template_args(self): t = Template('{{t|a|b|c}}') c = t.arguments[-1] self.assertEqual('|c', c.string) t.string = '{{t|0|a|b|c}}' self.assertEqual('', c.string) self.assertEqual('0', t.get_arg('1').value) self.assertEqual('c', t.get_arg('4').value)
def test_overwriting_template_args(): t = Template('{{t|a|b|c}}') c = t.arguments[-1] assert '|c' == c.string t.string = '{{t|0|a|b|c}}' assert '' == c.string assert '0' == t.get_arg('1').value assert 'c' == t.get_arg('4').value
def test_has_arg(self): t = Template('{{t|a|b=c}}') self.assertEqual(True, t.has_arg('1')) self.assertEqual(True, t.has_arg('1', 'a')) self.assertEqual(True, t.has_arg('b')) self.assertEqual(True, t.has_arg('b', 'c')) self.assertEqual(False, t.has_arg('2')) self.assertEqual(False, t.has_arg('1', 'b')) self.assertEqual(False, t.has_arg('c')) self.assertEqual(False, t.has_arg('b', 'd'))
def test_ancestors_and_parent(self): parsed = parse('{{a|{{#if:{{b{{c<!---->}}}}}}}}') self.assertEqual(parsed.parent(), None) self.assertEqual(parsed.ancestors(), []) c = parsed.comments[0] c_parent = c.parent() self.assertEqual(c_parent.string, '{{c<!---->}}') self.assertEqual(c_parent.parent().string, '{{b{{c<!---->}}}}') self.assertEqual(len(c.ancestors()), 4) self.assertEqual(len(c.ancestors(type_='Template')), 3) self.assertEqual(len(c.ancestors(type_='ParserFunction')), 1) t = Template('{{a}}') self.assertEqual(t.ancestors(), []) self.assertIsNone(t.parent())
def test_ancestors_and_parent(): parsed = parse('{{a|{{#if:{{b{{c<!---->}}}}}}}}') assert parsed.parent() is None assert parsed.ancestors() == [] c = parsed.comments[0] c_parent = c.parent() assert c_parent.string == '{{c<!---->}}' assert c_parent.parent().string == '{{b{{c<!---->}}}}' assert len(c.ancestors()) == 4 assert len(c.ancestors(type_='Template')) == 3 assert len(c.ancestors(type_='ParserFunction')) == 1 t = Template('{{a}}') assert t.ancestors() == [] assert t.parent() is None
def test_multiline_arg(self): t = Template('{{text|\na=\nb\nc\n}}') t.set_arg('d', 'e') self.assertEqual('{{text|\na=\nb\nc|\nd=\ne\n}}', t.string) t = Template('{{text\n\n | a = b\n\n}}') t.set_arg('c', 'd') self.assertEqual('{{text\n\n | a = b\n\n | c = d\n\n}}', t.string)
def test_multiline_arg(): t = Template('{{text|\na=\nb\nc\n}}') t.set_arg('d', 'e') assert '{{text|\na=\nb\nc|\nd=\ne\n}}' == t.string t = Template('{{text\n\n | a = b\n\n}}') t.set_arg('c', 'd') assert '{{text\n\n | a = b\n\n | c = d\n\n}}' == t.string
def test_normal_name(): normal_name = Template('{{ u |a}}').normal_name assert 'u' == normal_name() assert 'U' == normal_name(capitalize=True) warns(DeprecationWarning, normal_name, capital_links=True) assert 'u' == Template('{{ template: u |a}}').normal_name() assert 'u' == Template('{{ الگو:u |a}}').normal_name(['الگو']) assert 'a b' == Template('{{a_b}}').normal_name() assert 't' == Template('{{t#a|a}}').normal_name() t = Template('{{ : fa : Template : t # A }}') assert 't' == t.normal_name(code='fa') warns(DeprecationWarning, t.normal_name, _code='fa') assert 't' == Template('{{ : t |a}}').normal_name() assert 'A B' == Template('{{A___B}}').normal_name()
def test_pformat_tl_directly(self): self.assertEqual( '{{t\n' ' | 1 = a\n' '}}', Template('{{t|a}}').pformat(), )
def _render_template(instance: WikiTextHtml, template: wikitextparser.Template): name = template.name.strip() try: if not instance.template_exists(name): instance.add_error(f'Template "{name}" does not exist.') except InvalidTemplate as e: # Errors always end with a dot, hence the [:-1]. instance.add_error(f'{e.args[0][:-1]} (template "{{{{{name}}}}}").') return instance._templates.add(name) if instance._template_path.count(name) >= 10: instance.add_error( f'Template "{name}" was transcluded itself more than ten times (recursion depth limit reached).' ) return instance._template_path.append(name) body = instance.template_load(name) body = preprocess.begin(instance, body, is_transcluding=True) body = preprocess.hr_line(instance, body) wtp = wikitextparser.parse(body) parameter.replace(instance, wtp, template.arguments) parser_function.replace(instance, wtp) replace(instance, wtp) template.string = wtp.string instance._template_path.remove(name)
def test_normal_name(self): ae = self.assertEqual aw = self.assertWarns normal_name = Template('{{ u |a}}').normal_name ae('u', normal_name()) ae('U', normal_name(capitalize=True)) aw(DeprecationWarning, normal_name, capital_links=True) ae('u', Template('{{ template: u |a}}').normal_name()) ae('u', Template('{{ الگو:u |a}}').normal_name(['الگو'])) ae('a b', Template('{{a_b}}').normal_name()) ae('t', Template('{{t#a|a}}').normal_name()) t = Template('{{ : fa : Template : t # A }}') ae('t', t.normal_name(code='fa')) aw(DeprecationWarning, t.normal_name, _code='fa') ae('t', Template('{{ : t |a}}').normal_name()) ae('A B', Template('{{A___B}}').normal_name())
def test_has_arg(): has_arg = Template('{{t|a|b=c}}').has_arg assert has_arg('1') is True assert has_arg('1', 'a') is True assert has_arg('b') is True assert has_arg('b', 'c') is True assert has_arg('2') is False assert has_arg('1', 'b') is False assert has_arg('c') is False assert has_arg('b', 'd') is False
def test_has_arg(self): ae = self.assertEqual has_arg = Template('{{t|a|b=c}}').has_arg ae(True, has_arg('1')) ae(True, has_arg('1', 'a')) ae(True, has_arg('b')) ae(True, has_arg('b', 'c')) ae(False, has_arg('2')) ae(False, has_arg('1', 'b')) ae(False, has_arg('c')) ae(False, has_arg('b', 'd'))
def _get_template_content(template: Template, template_definitions: dict, visited_templates: set) -> Tuple[Optional[str], set]: if not template or not template.string.startswith('{{'): return None, visited_templates try: name = template.normal_name(capitalize=True) except IndexError: return '', visited_templates if name in visited_templates: return '', visited_templates visited_templates.add(name) content = wtp.parse(template_definitions[name]) content = _apply_parameters(content, _get_template_arguments(template)) for it in content.templates: it_content, _ = _get_template_content(it, template_definitions, visited_templates) if it_content is not None: content[slice(*it.span)] = it_content return content.string, visited_templates
def update_arguments(template: Template, args: dict, overwrite=False): """ Updates the arguments of the given template with the values of the given dict (args) Args: template: Template that should be updated args(dict): Dict containing the arguments that should be set. key=argument name, value=argument value overwrite(bool): If True existing values will be overwritten Returns: Nothing """ for key, value in args.items(): if template.has_arg(key): # update argument if overwrite: template.del_arg(key) template.set_arg(key, value) else: pass else: if value is not None: template.set_arg(key, value, preserve_spacing=False)
def test_rm_first_of_dup_args(self): # Remove first of duplicates, keep last t = Template('{{template|year=9999|year=2000}}') t.rm_first_of_dup_args() self.assertEqual('{{template|year=2000}}', str(t)) # Don't remove duplicate positional args in different positions s = """{{cite|{{t1}}|{{t1}}}}""" t = Template(s) t.rm_first_of_dup_args() self.assertEqual(s, str(t)) # Don't remove duplicate subargs s1 = "{{i| c = {{g}} |p={{t|h={{g}}}} |q={{t|h={{g}}}}}}" t = Template(s1) t.rm_first_of_dup_args() self.assertEqual(s1, str(t)) # test_dont_touch_empty_strings s1 = '{{template|url=||work=|accessdate=}}' s2 = '{{template|url=||work=|accessdate=}}' t = Template(s1) t.rm_first_of_dup_args() self.assertEqual(s2, str(t)) # Positional args t = Template('{{t|1=v|v}}') t.rm_first_of_dup_args() self.assertEqual('{{t|v}}', str(t)) # Triple duplicates: t = Template('{{t|1=v|v|1=v}}') t.rm_first_of_dup_args() self.assertEqual('{{t|1=v}}', str(t))
def test_keyword_and_positional_args(self): t = Template("{{t|kw=a|1=|pa|kw2=a|pa2}}") self.assertEqual('1', t.arguments[2].name)
def test_normal_name(self): t = Template('{{ u |a}}') self.assertEqual('u', t.normal_name()) self.assertEqual('U', t.normal_name(capital_links=True)) t = Template('{{ template: u |a}}') self.assertEqual('u', t.normal_name()) t = Template('{{ الگو:u |a}}') self.assertEqual('u', t.normal_name(['الگو'])) t = Template('{{a_b}}') self.assertEqual('a b', t.normal_name()) t = Template('{{t#a|a}}') self.assertEqual('t', t.normal_name()) t = Template('{{ : fa : Template : t # A }}') self.assertEqual('t', t.normal_name(code='fa')) t = Template('{{ : t |a}}') self.assertEqual('t', t.normal_name()) t = Template('{{A___B}}') self.assertEqual('A B', t.normal_name())
def test_set_name(self): t = Template("{{t|a|a}}") t.name = ' u ' self.assertEqual("{{ u |a|a}}", t.string)
def test_dont_remove_nonkeyword_argument(self): t = Template("{{t|a|a}}") self.assertEqual("{{t|a|a}}", str(t))
def test_name(self): s1 = "{{ wrapper | p1 | {{ cite | sp1 | dateformat = ymd}} }}" t = Template(s1) self.assertEqual(' wrapper ', t.name)
def test_contains_newlines(self): s = '{{template\n|s=2}}' t = Template(s) self.assertEqual(s, str(t))
def test_not_name_and_positional_is_none(self): t = Template('{{t}}') t.set_arg(None, 'v') self.assertEqual('{{t|v}}', t.string)
def test_nowiki_makes_equal_ineffective(self): t = Template('{{text|1<nowiki>=</nowiki>g}}') a = t.arguments[0] self.assertEqual(a.value, '1<nowiki>=</nowiki>g') self.assertEqual(a.name, '1')
def test_no_parameters(self): s = '{{template}}' t = Template(s) self.assertEqual("Template('{{template}}')", repr(t))
def test_force_new_to_positional_when_old_is_keyword(self): t = Template('{{t|1=v}}') t.set_arg('1', 'v', positional=True) self.assertEqual('{{t|v}}', t.string)
def test_invalid_position(self): t = Template('{{t}}') t.set_arg('2', 'a', positional=True) self.assertEqual('{{t|2=a}}', t.string)
def test_equal_sign_in_val(): a, c = Template('{{t|a==b|c}}').arguments assert a.value == '=b' assert c.name == '1'
def test_removing_last_arg_should_not_effect_the_others(): a, b, c = Template('{{t|1=v|v|1=v}}').arguments del c[:] assert '|1=v' == a.string assert '|v' == b.string
def test_multi_set_positional_args(self): t = Template('{{t}}') t.set_arg('1', 'p', positional=True) t.set_arg('2', 'q', positional=True) self.assertEqual('{{t|p|q}}', t.string)