Mirror
/
zulip
mirror of https://github.com/zulip/zulip.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
zulip/tools/tests/test_pretty_print.py

306 lines
6.3 KiB
Python
Raw Permalink Normal View History

tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
import unittest
from tools.lib.pretty_print import pretty_print_html
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
from tools.lib.template_parser import validate
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
# Note that GOOD_HTML isn't necessarily beautiful HTML. Apart
# from adjusting indentation, we mostly leave things alone to
# respect whatever line-wrapping styles were in place before.
BAD_HTML = """
<!-- test -->
<!DOCTYPE html>
<html>
<!-- test -->
<head>
<title>Test</title>
<meta charset="utf-8" />
<link rel="stylesheet" href="style.css" />
</head>
<body>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
<div><p>Hello<br />world!</p></div>
<p>Goodbye<!-- test -->world!</p>
<table>
<tr>
<td>5</td>
</tr>
</table>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
<pre>
print 'hello world'
</pre>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
<div class = "foo"
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
id = "bar"
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
role = "whatever">{{ bla }}
</div>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</body>
</html>
<!-- test -->
"""
GOOD_HTML = """
<!-- test -->
<!DOCTYPE html>
<html>
<!-- test -->
<head>
<title>Test</title>
<meta charset="utf-8" />
<link rel="stylesheet" href="style.css" />
</head>
<body>
templates: Mark all void tags as self-closing. This reverses the policy that was set, but incompletely enforced, by commit 951514dd7dd2fafb67e9e9c6930d31b9295741c0. The self-closing tag syntax is clearer, more consistent, simpler to parse, compatible with XML, preferred by Prettier, and (most importantly now) required by FormatJS. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-04-21 00:46:14 +02:00
<div><p>Hello<br />world!</p></div>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
<p>Goodbye<!-- test -->world!</p>
<table>
<tr>
<td>5</td>
</tr>
</table>
Enhance template parser for comments, Fix deep nesting in Jinja2. In this commit we add the ability of recognizing comments in handlebar and Jinja2 templates to the template parser. This fixes issue of template parser picking up code tags which are commented out in files. Also we fix the problem of too much deep nesting in the Jinja2 logic statement. Now only nested Jinja2 logic statements will get a deeper indentation level.With this another fix was introduced relating with the tags before a nested handlebar or django tag getting wrong indent. We also fix the issue with wrong offsets with closing tags in cases if they were not matching indent level of the starting tag intially. Also we also start to ignore any tags occuring in between 'pre' tags for deeper indent levels. As well we start to filter out django non block tags from getting deeper indent level.
2017-02-23 18:12:52 +01:00
<pre>
print 'hello world'
</pre>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
<div class = "foo"
linter: Enforce 2 space indents on tags spread over multiple lines. We make some specific cases of tags use 2 space indents. The case description: * A tag with opening tag spread over multiple lines and closing tag on the same line as of the closing angle bracket of the opening tag. * A tag with opening tag spread over multiple lines and closing tag not on the same line as of the closing angle bracket of the opening tag. Example: Case 1: Not linted: <button type="button" class="btn btn-primary btn-small">{{t "Yes" }}</button> After linting: <button type="button" class="btn btn-primary btn-small">{{t "Yes" }}</button> Case 2: Before linting: <div class = "foo" id = "bar" role = "whatever"> {{ bla }} </div> After linting: <div class = "foo" id = "bar" role = "whatever"> {{ bla }} </div>
2018-04-05 08:38:46 +02:00
id = "bar"
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
role = "whatever">{{ bla }}
</div>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</body>
</html>
<!-- test -->
"""
BAD_HTML1 = """
<html>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
<body>
foobarfoobarfoo<b>bar</b>
</body>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</html>
"""
GOOD_HTML1 = """
<html>
<body>
foobarfoobarfoo<b>bar</b>
</body>
</html>
"""
BAD_HTML2 = """
<html>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
<body>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
{{# foobar area}}
foobarfoobarfoo<b>bar</b>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
{{/ foobar}}
</body>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</html>
"""
GOOD_HTML2 = """
<html>
<body>
{{# foobar area}}
foobarfoobarfoo<b>bar</b>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
{{/ foobar}}
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</body>
</html>
"""
check-templates: Complain about stray text. We disallow this HTML: junk-text-before-open-tag<p> This is a paragraph. </p> We rarely see the above mistake, but we want to eliminate the possibility to be somewhat rigorous, and so that we can eliminate a pretty-printer mis-feature.
2021-11-23 18:56:11 +01:00
# The old GOOD_HTML3 test was flawed.
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
BAD_HTML4 = """
<div>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
foo
<p>hello</p>
bar
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</div>
"""
GOOD_HTML4 = """
<div>
foo
<p>hello</p>
bar
</div>
"""
BAD_HTML5 = """
<div>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
foo
{{#if foobar}}
hello
{{else}}
bye
{{/if}}
bar
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</div>
"""
GOOD_HTML5 = """
<div>
foo
{{#if foobar}}
hello
{{else}}
bye
{{/if}}
bar
</div>
"""
BAD_HTML6 = """
<div>
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
<p> <strong> <span class = "whatever">foobar </span> </strong></p>
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
</div>
"""
GOOD_HTML6 = """
<div>
<p> <strong> <span class = "whatever">foobar </span> </strong></p>
</div>
"""
Add Django and html singleton tags support to pretty print. In this commit we are modifying pretty print tool to support Django and html singleton tags. For Addition of html singleton tags template parser was modified to emit psudeo html singleton end tags to accompany html singleton tags and token class was updated to have line_span field.
2017-02-16 20:25:53 +01:00
BAD_HTML7 = """
<div class="foobar">
<input type="foobar" name="temp" value="{{dyn_name}}"
{{#unless invite_only}}checked="checked"{{/unless}} /> {{dyn_name}}
stream_privacy: Use new lock and hashtag icons. This commit doesn't modify the lock and hashtag icon in settings.
2023-04-08 02:49:01 +02:00
{{#if invite_only}}<i class="zulip-icon zulip-icon-lock"></i>{{/if}}
Add Django and html singleton tags support to pretty print. In this commit we are modifying pretty print tool to support Django and html singleton tags. For Addition of html singleton tags template parser was modified to emit psudeo html singleton end tags to accompany html singleton tags and token class was updated to have line_span field.
2017-02-16 20:25:53 +01:00
</div>
"""
GOOD_HTML7 = """
<div class="foobar">
<input type="foobar" name="temp" value="{{dyn_name}}"
linter: Make html singleton tags use 2 space indentation.
2018-04-03 10:07:23 +02:00
{{#unless invite_only}}checked="checked"{{/unless}} /> {{dyn_name}}
stream_privacy: Use new lock and hashtag icons. This commit doesn't modify the lock and hashtag icon in settings.
2023-04-08 02:49:01 +02:00
{{#if invite_only}}<i class="zulip-icon zulip-icon-lock"></i>{{/if}}
Add Django and html singleton tags support to pretty print. In this commit we are modifying pretty print tool to support Django and html singleton tags. For Addition of html singleton tags template parser was modified to emit psudeo html singleton end tags to accompany html singleton tags and token class was updated to have line_span field.
2017-02-16 20:25:53 +01:00
</div>
"""
BAD_HTML8 = """
{{#each test}}
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
{{#with this}}
{{#if foobar}}
<div class="anything">{{{test}}}</div>
{{/if}}
{{#if foobar2}}
{{> teststuff}}
{{/if}}
{{/with}}
Add Django and html singleton tags support to pretty print. In this commit we are modifying pretty print tool to support Django and html singleton tags. For Addition of html singleton tags template parser was modified to emit psudeo html singleton end tags to accompany html singleton tags and token class was updated to have line_span field.
2017-02-16 20:25:53 +01:00
{{/each}}
"""
GOOD_HTML8 = """
{{#each test}}
{{#with this}}
linters: Rewrite check-templates. I rewrote most of tools/lib/pretty-printer.py, which was fairly easy due to being able to crib some important details from the previous implementation. The main motivation for the rewrite was that we weren't handling else/elif blocks correctly, and it was difficult to modify the previous code. The else/elif shortcomings were somewhat historical in nature--the original parser didn't recognize them (since they weren't in any Zulip templates at the time), and then the pretty printer was mostly able to hack around that due to the "nudge" strategy. Eventually the nudge strategy became too brittle. The "nudge" strategy was that we would mostly trust the existing templates, and we would just nudge over some lines in cases of obviously faulty indentation. Now we are bit more opinionated and rigorous, and we basically set the indentation explicitly for any line that is not in a code/script block. This leads to this diff touching several templates for mostly minor fix-ups. We aren't completely opinionated, as we respect the author's line wrapping decisions in many cases, and we also allow authors not to indent blocks within the template language's block constructs.
2021-11-20 13:25:41 +01:00
{{#if foobar}}
Add Django and html singleton tags support to pretty print. In this commit we are modifying pretty print tool to support Django and html singleton tags. For Addition of html singleton tags template parser was modified to emit psudeo html singleton end tags to accompany html singleton tags and token class was updated to have line_span field.
2017-02-16 20:25:53 +01:00
<div class="anything">{{{test}}}</div>
linters: Rewrite check-templates. I rewrote most of tools/lib/pretty-printer.py, which was fairly easy due to being able to crib some important details from the previous implementation. The main motivation for the rewrite was that we weren't handling else/elif blocks correctly, and it was difficult to modify the previous code. The else/elif shortcomings were somewhat historical in nature--the original parser didn't recognize them (since they weren't in any Zulip templates at the time), and then the pretty printer was mostly able to hack around that due to the "nudge" strategy. Eventually the nudge strategy became too brittle. The "nudge" strategy was that we would mostly trust the existing templates, and we would just nudge over some lines in cases of obviously faulty indentation. Now we are bit more opinionated and rigorous, and we basically set the indentation explicitly for any line that is not in a code/script block. This leads to this diff touching several templates for mostly minor fix-ups. We aren't completely opinionated, as we respect the author's line wrapping decisions in many cases, and we also allow authors not to indent blocks within the template language's block constructs.
2021-11-20 13:25:41 +01:00
{{/if}}
{{#if foobar2}}
{{> teststuff}}
{{/if}}
Add Django and html singleton tags support to pretty print. In this commit we are modifying pretty print tool to support Django and html singleton tags. For Addition of html singleton tags template parser was modified to emit psudeo html singleton end tags to accompany html singleton tags and token class was updated to have line_span field.
2017-02-16 20:25:53 +01:00
{{/with}}
{{/each}}
"""
Enhance template parser for comments, Fix deep nesting in Jinja2. In this commit we add the ability of recognizing comments in handlebar and Jinja2 templates to the template parser. This fixes issue of template parser picking up code tags which are commented out in files. Also we fix the problem of too much deep nesting in the Jinja2 logic statement. Now only nested Jinja2 logic statements will get a deeper indentation level.With this another fix was introduced relating with the tags before a nested handlebar or django tag getting wrong indent. We also fix the issue with wrong offsets with closing tags in cases if they were not matching indent level of the starting tag intially. Also we also start to ignore any tags occuring in between 'pre' tags for deeper indent levels. As well we start to filter out django non block tags from getting deeper indent level.
2017-02-23 18:12:52 +01:00
BAD_HTML9 = """
<form id="foobar" class="whatever">
{{! <div class="anothertest"> }}
<input value="test" />
<button type="button"><i class="test"></i></button>
<button type="button"><i class="test"></i></button>
{{! </div> }}
<div class="test"></div>
</form>
"""
GOOD_HTML9 = """
<form id="foobar" class="whatever">
{{! <div class="anothertest"> }}
<input value="test" />
<button type="button"><i class="test"></i></button>
<button type="button"><i class="test"></i></button>
{{! </div> }}
<div class="test"></div>
</form>
"""
BAD_HTML10 = """
{% block portico_content %}
<div class="test">
<i class='test'></i> foobar
</div>
<div class="test1">
{% for row in data %}
<div class="test2">
{% for group in (row[0:2], row[2:4]) %}
<div class="test2">
</div>
{% endfor %}
</div>
{% endfor %}
</div>
{% endblock %}
"""
GOOD_HTML10 = """
{% block portico_content %}
<div class="test">
<i class='test'></i> foobar
</div>
<div class="test1">
{% for row in data %}
<div class="test2">
{% for group in (row[0:2], row[2:4]) %}
<div class="test2">
</div>
{% endfor %}
</div>
{% endfor %}
</div>
{% endblock %}
"""
BAD_HTML11 = """
<div class="test1">
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
<div class="test2">
Enhance template parser for comments, Fix deep nesting in Jinja2. In this commit we add the ability of recognizing comments in handlebar and Jinja2 templates to the template parser. This fixes issue of template parser picking up code tags which are commented out in files. Also we fix the problem of too much deep nesting in the Jinja2 logic statement. Now only nested Jinja2 logic statements will get a deeper indentation level.With this another fix was introduced relating with the tags before a nested handlebar or django tag getting wrong indent. We also fix the issue with wrong offsets with closing tags in cases if they were not matching indent level of the starting tag intially. Also we also start to ignore any tags occuring in between 'pre' tags for deeper indent levels. As well we start to filter out django non block tags from getting deeper indent level.
2017-02-23 18:12:52 +01:00
foobar
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
<div class="test2">
</div>
Enhance template parser for comments, Fix deep nesting in Jinja2. In this commit we add the ability of recognizing comments in handlebar and Jinja2 templates to the template parser. This fixes issue of template parser picking up code tags which are commented out in files. Also we fix the problem of too much deep nesting in the Jinja2 logic statement. Now only nested Jinja2 logic statements will get a deeper indentation level.With this another fix was introduced relating with the tags before a nested handlebar or django tag getting wrong indent. We also fix the issue with wrong offsets with closing tags in cases if they were not matching indent level of the starting tag intially. Also we also start to ignore any tags occuring in between 'pre' tags for deeper indent levels. As well we start to filter out django non block tags from getting deeper indent level.
2017-02-23 18:12:52 +01:00
</div>
</div>
"""
GOOD_HTML11 = """
<div class="test1">
<div class="test2">
foobar
<div class="test2">
</div>
</div>
</div>
"""
linter: Make html singleton tags use 2 space indentation.
2018-04-03 10:07:23 +02:00
ruff: Fix UP007 Use `X | Y` for type annotations. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2024-07-12 02:30:23 +02:00
def pretty_print(html: str, template_format: str | None = None) -> str:
check-templates: Rewrite pretty_print (again). It now does everything based on the tokens, rather than walking the lines and trying to match up tokens to lines.
2021-12-02 17:10:42 +01:00
fn = "<test str>"
check-templates: Check Django/Handlebars templates differently. This is a bit hacky, but avoids incorrectly checking Handlebars templates for Django style templates, which in particular interacts poorly with ICU Message plural syntax.
2023-10-12 01:56:46 +02:00
tokens = validate(fn=fn, text=html, template_format=template_format)
check-templates: Rewrite pretty_print (again). It now does everything based on the tokens, rather than walking the lines and trying to match up tokens to lines.
2021-12-02 17:10:42 +01:00
return pretty_print_html(tokens, fn=fn)
linter: Enforce 2 space indents on tags spread over multiple lines. We make some specific cases of tags use 2 space indents. The case description: * A tag with opening tag spread over multiple lines and closing tag on the same line as of the closing angle bracket of the opening tag. * A tag with opening tag spread over multiple lines and closing tag not on the same line as of the closing angle bracket of the opening tag. Example: Case 1: Not linted: <button type="button" class="btn btn-primary btn-small">{{t "Yes" }}</button> After linting: <button type="button" class="btn btn-primary btn-small">{{t "Yes" }}</button> Case 2: Before linting: <div class = "foo" id = "bar" role = "whatever"> {{ bla }} </div> After linting: <div class = "foo" id = "bar" role = "whatever"> {{ bla }} </div>
2018-04-05 08:38:46 +02:00
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
class TestPrettyPrinter(unittest.TestCase):
tools/tests: Use Python 3 syntax for typing.
2017-12-13 06:45:46 +01:00
def compare(self, a: str, b: str) -> None:
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
self.assertEqual(a.split("\n"), b.split("\n"))
tools: Create HTML pretty printer. In This commit we extend the work being done by @showell in PR#1778 to develop a tool to pretty print html and our handlebar templates in order to enforce our style convention of 4 Space indentation in templates. This commit introduces following changes: * Fix Py3 Compatibility. * Add ability to prettify in cases when html tags are not the starting of a line and addition of test cases for it. * Add ability to lint handlebar tags and add test cases for it. * Add {{else}} as special case of indent. * Add test cases in general to testing new tool. @showell Helped me throughout and reviewed this commit. Fixes #1778
2017-02-15 05:39:42 +01:00
tools/tests: Use Python 3 syntax for typing.
2017-12-13 06:45:46 +01:00
def test_pretty_print(self) -> None:
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
self.compare(pretty_print(GOOD_HTML), GOOD_HTML)
self.compare(pretty_print(BAD_HTML), GOOD_HTML)
self.compare(pretty_print(BAD_HTML1), GOOD_HTML1)
check-templates: Check Django/Handlebars templates differently. This is a bit hacky, but avoids incorrectly checking Handlebars templates for Django style templates, which in particular interacts poorly with ICU Message plural syntax.
2023-10-12 01:56:46 +02:00
self.compare(pretty_print(BAD_HTML2, template_format="handlebars"), GOOD_HTML2)
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
self.compare(pretty_print(BAD_HTML4), GOOD_HTML4)
check-templates: Check Django/Handlebars templates differently. This is a bit hacky, but avoids incorrectly checking Handlebars templates for Django style templates, which in particular interacts poorly with ICU Message plural syntax.
2023-10-12 01:56:46 +02:00
self.compare(pretty_print(BAD_HTML5, template_format="handlebars"), GOOD_HTML5)
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
self.compare(pretty_print(BAD_HTML6), GOOD_HTML6)
check-templates: Check Django/Handlebars templates differently. This is a bit hacky, but avoids incorrectly checking Handlebars templates for Django style templates, which in particular interacts poorly with ICU Message plural syntax.
2023-10-12 01:56:46 +02:00
self.compare(pretty_print(BAD_HTML7, template_format="handlebars"), GOOD_HTML7)
self.compare(pretty_print(BAD_HTML8, template_format="handlebars"), GOOD_HTML8)
self.compare(pretty_print(BAD_HTML9, template_format="handlebars"), GOOD_HTML9)
self.compare(pretty_print(BAD_HTML10, template_format="django"), GOOD_HTML10)
check-templates: Avoid duplicate tokenizing step. Now we only tokenize the file once, and we pass **validated** tokens to the pretty printer. There are a few reasons for this: * It obviously saves a lot of extra computation just in terms of tokenization. * It allows our validator to add fields to the Token objects that help the pretty printer. I also removed/tweaked a lot of legacy tests for pretty_print.py that were exercising bizarrely formatted HTML that we now simply ban during the validation phase.
2021-12-02 13:19:19 +01:00
self.compare(pretty_print(BAD_HTML11), GOOD_HTML11)