mirror of https://github.com/zulip/zulip.git
277 lines
8.8 KiB
Python
Executable File
277 lines
8.8 KiB
Python
Executable File
#!/usr/bin/env python
|
|
from __future__ import absolute_import
|
|
from __future__ import print_function
|
|
import optparse
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
from six.moves import filter
|
|
from six.moves import map
|
|
from six.moves import range
|
|
try:
|
|
import lister
|
|
from typing import cast, Callable, Dict, Iterable, List
|
|
except ImportError as e:
|
|
print("ImportError: {}".format(e))
|
|
print("You need to run the Zulip linters inside a Zulip dev environment.")
|
|
print("If you are using Vagrant, you can `vagrant ssh` to enter the Vagrant guest.")
|
|
sys.exit(1)
|
|
|
|
class Record(object):
|
|
def __init__(self, func):
|
|
# type: (Callable[[str], None]) -> None
|
|
self.depth = 0
|
|
self.i = 0
|
|
self.line = 1
|
|
self.col = 1
|
|
self.matcher = func
|
|
|
|
def validate(fn, check_indent=True):
|
|
# type: (str, bool) -> None
|
|
text = open(fn).read()
|
|
|
|
def NoStartTag(end_tag):
|
|
# type: (str) -> None
|
|
raise Exception('''
|
|
No start tag
|
|
fn: %s
|
|
end tag:
|
|
%s
|
|
line %d, col %d
|
|
''' % (fn, end_tag, state.line, state.col))
|
|
|
|
def start_tag_matcher(s, start_tag):
|
|
# type: (str, str) -> None
|
|
start_line = state.line
|
|
start_col = state.col
|
|
state.depth += 1
|
|
|
|
old_matcher = state.matcher
|
|
def f(end_tag):
|
|
# type: (str) -> None
|
|
problem = None
|
|
if start_tag != end_tag:
|
|
problem = 'Mismatched tag.'
|
|
elif check_indent and state.line > start_line + 1 and state.col != start_col:
|
|
problem = 'Bad indentation.'
|
|
if problem:
|
|
raise Exception('''
|
|
fn: %s
|
|
%s
|
|
start:
|
|
%s
|
|
line %d, col %d
|
|
end tag:
|
|
%s
|
|
line %d, col %d
|
|
''' % (fn, problem, s, start_line, start_col, end_tag, state.line, state.col))
|
|
state.matcher = old_matcher
|
|
state.depth -= 1
|
|
state.matcher = f
|
|
|
|
state = Record(NoStartTag)
|
|
|
|
def advance(n):
|
|
# type: (int) -> None
|
|
for _ in range(n):
|
|
state.i += 1
|
|
if state.i >= 0 and text[state.i - 1] == '\n':
|
|
state.line += 1
|
|
state.col = 1
|
|
else:
|
|
state.col += 1
|
|
|
|
def looking_at(s):
|
|
# type: (str) -> bool
|
|
return text[state.i:state.i+len(s)] == s
|
|
|
|
while state.i < len(text):
|
|
|
|
# HTML tags
|
|
if looking_at("<") and not looking_at("</"):
|
|
s = get_html_tag(text, state.i)
|
|
tag = s[1:-1].split()[0]
|
|
ignore = (s.startswith('<!--') or
|
|
s.endswith('/>') or
|
|
tag in ['link', 'meta', '!DOCTYPE'])
|
|
if not ignore:
|
|
start_tag_matcher(s, tag)
|
|
advance(len(s))
|
|
continue
|
|
|
|
if looking_at("</"):
|
|
s = get_html_tag(text, state.i)
|
|
end_tag = s[2:-1]
|
|
state.matcher(end_tag)
|
|
advance(len(s))
|
|
continue
|
|
|
|
# Handlebar tags
|
|
if looking_at("{{#") or looking_at("{{^"):
|
|
s = get_handlebars_tag(text, state.i)
|
|
tag = s[3:-2].split()[0]
|
|
start_tag_matcher(s, tag)
|
|
advance(len(s))
|
|
continue
|
|
|
|
if looking_at("{{/"):
|
|
s = get_handlebars_tag(text, state.i)
|
|
end_tag = s[3:-2]
|
|
state.matcher(end_tag)
|
|
advance(len(s))
|
|
continue
|
|
|
|
# Django tags
|
|
if looking_at("{% ") and not looking_at("{% end"):
|
|
s = get_django_tag(text, state.i)
|
|
tag = s[3:-2].split()[0]
|
|
if is_django_block_tag(tag):
|
|
start_tag_matcher(s, tag)
|
|
advance(len(s))
|
|
continue
|
|
|
|
if looking_at("{% end"):
|
|
s = get_django_tag(text, state.i)
|
|
end_tag = s[6:-3]
|
|
state.matcher(end_tag)
|
|
advance(len(s))
|
|
continue
|
|
|
|
advance(1)
|
|
|
|
if state.depth != 0:
|
|
state.matcher("(NO TAG)")
|
|
|
|
def is_django_block_tag(tag):
|
|
# type: (str) -> bool
|
|
return tag in [
|
|
'autoescape',
|
|
'block',
|
|
'comment',
|
|
'for',
|
|
'if',
|
|
'ifequal',
|
|
'verbatim',
|
|
'blocktrans',
|
|
'trans',
|
|
'raw',
|
|
]
|
|
|
|
def get_handlebars_tag(text, i):
|
|
# type: (str, int) -> str
|
|
end = i + 2
|
|
while end < len(text) -1 and text[end] != '}':
|
|
end += 1
|
|
if text[end] != '}' or text[end+1] != '}':
|
|
raise Exception('Tag missing }}')
|
|
s = text[i:end+2]
|
|
return s
|
|
|
|
def get_django_tag(text, i):
|
|
# type: (str, int) -> str
|
|
end = i + 2
|
|
while end < len(text) -1 and text[end] != '%':
|
|
end += 1
|
|
if text[end] != '%' or text[end+1] != '}':
|
|
raise Exception('Tag missing %}')
|
|
s = text[i:end+2]
|
|
return s
|
|
|
|
def get_html_tag(text, i):
|
|
# type: (str, int) -> str
|
|
quote_count = 0
|
|
end = i + 1
|
|
while end < len(text) and (text[end] != '>' or quote_count % 2 != 0):
|
|
if text[end] == '"':
|
|
quote_count += 1
|
|
end += 1
|
|
if end == len(text) or text[end] != '>':
|
|
raise Exception('Tag missing >')
|
|
s = text[i:end+1]
|
|
return s
|
|
|
|
def check_our_files():
|
|
# type: () -> None
|
|
parser = optparse.OptionParser()
|
|
parser.add_option('--modified', '-m',
|
|
action='store_true', default=False,
|
|
help='Only check modified files')
|
|
(options, _) = parser.parse_args()
|
|
|
|
by_lang = cast(
|
|
Dict[str, List[str]],
|
|
lister.list_files(
|
|
modified_only=options.modified,
|
|
ftypes=['handlebars', 'html'],
|
|
group_by_ftype=True))
|
|
|
|
check_handlebar_templates(by_lang['handlebars'], options.modified)
|
|
check_html_templates(by_lang['html'], options.modified)
|
|
|
|
def check_handlebar_templates(templates, modified_only):
|
|
# type: (Iterable[str], bool) -> None
|
|
# Check all our handlebars templates.
|
|
templates = [fn for fn in templates if fn.endswith('.handlebars')]
|
|
if not modified_only:
|
|
assert len(templates) >= 10 # sanity check that we are actually doing work
|
|
for fn in templates:
|
|
validate(fn, check_indent=True)
|
|
|
|
def check_html_templates(templates, modified_only):
|
|
# type: (Iterable[str], bool) -> None
|
|
# Our files with .html extensions are usually for Django, but we also
|
|
# have a few static .html files.
|
|
# The file base.html has a bit of funny HTML that we can't parse here yet.
|
|
#
|
|
# We also have .html files that we vendored from Casper.
|
|
# The casperjs files use HTML5 (whereas Zulip prefers XHTML), and
|
|
# there are also cases where Casper deliberately uses invalid HTML,
|
|
# so we exclude them from our linter.
|
|
templates = filter(
|
|
lambda fn: ('base.html' not in fn) and ('casperjs' not in fn),
|
|
templates)
|
|
templates = sorted(list(templates))
|
|
|
|
if not modified_only:
|
|
assert len(templates) >= 10 # sanity check that we are actually doing work
|
|
for fn in templates:
|
|
# Many of our Django templates have strange indentation. The
|
|
# indentation errors are often harmless, even stylistically
|
|
# harmless, but they tend to be in files that might be old
|
|
# and might eventually require more scrutiny for things like
|
|
# localization. See github #1236.
|
|
bad_files = [
|
|
'static/html/5xx.html',
|
|
'templates/500.html',
|
|
'templates/confirmation/confirm.html',
|
|
'templates/corporate/mit.html',
|
|
'templates/corporate/privacy.html',
|
|
'templates/corporate/terms-enterprise.html',
|
|
'templates/corporate/terms.html',
|
|
'templates/corporate/zephyr-mirror.html',
|
|
'templates/corporate/zephyr.html',
|
|
'templates/zerver/accounts_home.html',
|
|
'templates/zerver/accounts_send_confirm.html',
|
|
'templates/zerver/api.html',
|
|
'templates/zerver/api_endpoints.html',
|
|
'templates/zerver/apps.html',
|
|
'templates/zerver/create_realm.html',
|
|
'templates/zerver/emails/followup/day1.html',
|
|
'templates/zerver/emails/followup/day2.html',
|
|
'templates/zerver/features.html',
|
|
'templates/zerver/hello.html',
|
|
'templates/zerver/home.html',
|
|
'templates/zerver/integrations.html',
|
|
'templates/zerver/invite_user.html',
|
|
'templates/zerver/left-sidebar.html',
|
|
'templates/zerver/login.html',
|
|
'templates/zerver/markdown_help.html',
|
|
'templates/zerver/register.html',
|
|
'templates/zerver/right-sidebar.html',
|
|
'templates/zerver/search_operators.html',
|
|
]
|
|
validate(fn, check_indent=(fn not in bad_files))
|
|
|
|
if __name__ == '__main__':
|
|
check_our_files()
|