check-code.py
696 lines
| 25.7 KiB
| text/x-python
|
PythonLexer
/ contrib / check-code.py
Matt Mackall
|
r10281 | #!/usr/bin/env python | ||
# | ||||
# check-code - a style and portability checker for Mercurial | ||||
# | ||||
Matt Mackall
|
r10290 | # Copyright 2010 Matt Mackall <mpm@selenic.com> | ||
Matt Mackall
|
r10281 | # | ||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
Simon Heimberg
|
r20241 | """style and portability checker for Mercurial | ||
when a rule triggers wrong, do one of the following (prefer one from top): | ||||
* do the work-around the rule suggests | ||||
* doublecheck that it is a false match | ||||
* improve the rule pattern | ||||
* add an ignore pattern to the rule (3rd arg) which matches your good line | ||||
timeless
|
r28700 | (you can append a short comment and match this, like: #re-raises) | ||
Simon Heimberg
|
r20241 | * change the pattern to a warning and list the exception in test-check-code-hg | ||
* ONLY use no--check-code for skipping entire files from external sources | ||||
""" | ||||
Pulkit Goyal
|
r28509 | from __future__ import absolute_import, print_function | ||
import glob | ||||
Thomas Arendsen Hein
|
r13074 | import keyword | ||
Matt Mackall
|
r10895 | import optparse | ||
Pulkit Goyal
|
r28509 | import os | ||
import re | ||||
import sys | ||||
timeless
|
r29145 | if sys.version_info[0] < 3: | ||
opentext = open | ||||
else: | ||||
def opentext(f): | ||||
return open(f, encoding='ascii') | ||||
Simon Heimberg
|
r19310 | try: | ||
timeless
|
r29143 | xrange | ||
except NameError: | ||||
xrange = range | ||||
try: | ||||
Simon Heimberg
|
r19310 | import re2 | ||
except ImportError: | ||||
re2 = None | ||||
def compilere(pat, multiline=False): | ||||
if multiline: | ||||
pat = '(?m)' + pat | ||||
if re2: | ||||
try: | ||||
return re2.compile(pat) | ||||
except re2.error: | ||||
pass | ||||
return re.compile(pat) | ||||
Matt Mackall
|
r10281 | |||
FUJIWARA Katsunori
|
r29398 | # check "rules depending on implementation of repquote()" in each | ||
# patterns (especially pypats), before changing around repquote() | ||||
_repquotefixedmap = {' ': ' ', '\n': '\n', '.': 'p', ':': 'q', | ||||
'%': '%', '\\': 'b', '*': 'A', '+': 'P', '-': 'M'} | ||||
def _repquoteencodechr(i): | ||||
if i > 255: | ||||
return 'u' | ||||
c = chr(i) | ||||
if c in _repquotefixedmap: | ||||
return _repquotefixedmap[c] | ||||
if c.isalpha(): | ||||
return 'x' | ||||
if c.isdigit(): | ||||
return 'n' | ||||
return 'o' | ||||
_repquotett = ''.join(_repquoteencodechr(i) for i in xrange(256)) | ||||
Matt Mackall
|
r10281 | def repquote(m): | ||
Simon Heimberg
|
r19999 | t = m.group('text') | ||
FUJIWARA Katsunori
|
r29398 | t = t.translate(_repquotett) | ||
Benoit Boissinot
|
r10722 | return m.group('quote') + t + m.group('quote') | ||
Matt Mackall
|
r10281 | |||
Benoit Boissinot
|
r10727 | def reppython(m): | ||
comment = m.group('comment') | ||||
if comment: | ||||
Mads Kiilerich
|
r18959 | l = len(comment.rstrip()) | ||
return "#" * l + comment[l:] | ||||
Benoit Boissinot
|
r10727 | return repquote(m) | ||
Matt Mackall
|
r10281 | |||
def repcomment(m): | ||||
return m.group(1) + "#" * len(m.group(2)) | ||||
def repccomment(m): | ||||
t = re.sub(r"((?<=\n) )|\S", "x", m.group(2)) | ||||
return m.group(1) + t + "*/" | ||||
def repcallspaces(m): | ||||
t = re.sub(r"\n\s+", "\n", m.group(2)) | ||||
return m.group(1) + t | ||||
def repinclude(m): | ||||
return m.group(1) + "<foo>" | ||||
def rephere(m): | ||||
t = re.sub(r"\S", "x", m.group(2)) | ||||
return m.group(1) + t | ||||
testpats = [ | ||||
Idan Kamara
|
r14009 | [ | ||
Mads Kiilerich
|
r16495 | (r'pushd|popd', "don't use 'pushd' or 'popd', use 'cd'"), | ||
Matt Mackall
|
r15281 | (r'\W\$?\(\([^\)\n]*\)\)', "don't use (()) or $(()), use 'expr'"), | ||
Martin Geisler
|
r10374 | (r'grep.*-q', "don't use 'grep -q', redirect to /dev/null"), | ||
Martin von Zweigbergk
|
r27989 | (r'(?<!hg )grep.* -a', "don't use 'grep -a', use in-line python"), | ||
Matt Mackall
|
r16332 | (r'sed.*-i', "don't use 'sed -i', use a temporary file"), | ||
Mads Kiilerich
|
r16965 | (r'\becho\b.*\\n', "don't use 'echo \\n', use printf"), | ||
Martin Geisler
|
r11884 | (r'echo -n', "don't use 'echo -n', use printf"), | ||
Matt Mackall
|
r23134 | (r'(^|\|\s*)\bwc\b[^|]*$\n(?!.*\(re\))', "filter wc output"), | ||
Martin Geisler
|
r10374 | (r'head -c', "don't use 'head -c', use 'dd'"), | ||
Danek Duvall
|
r19628 | (r'tail -n', "don't use the '-n' option to tail, just use '-<num>'"), | ||
Matt Mackall
|
r15389 | (r'sha1sum', "don't use sha1sum, use $TESTDIR/md5sum.py"), | ||
Martin Geisler
|
r10374 | (r'ls.*-\w*R', "don't use 'ls -R', use 'find'"), | ||
timeless
|
r29142 | (r'printf.*[^\\]\\([1-9]|0\d)', r"don't use 'printf \NNN', use Python"), | ||
Simon Heimberg
|
r19380 | (r'printf.*[^\\]\\x', "don't use printf \\x, use Python"), | ||
Matt Mackall
|
r10281 | (r'\$\(.*\)', "don't use $(expr), use `expr`"), | ||
(r'rm -rf \*', "don't use naked rm -rf, target a directory"), | ||||
Matt Mackall
|
r15372 | (r'(^|\|\s*)grep (-\w\s+)*[^|]*[(|]\w', | ||
Matt Mackall
|
r10281 | "use egrep for extended grep syntax"), | ||
(r'/bin/', "don't use explicit paths for tools"), | ||||
(r'[^\n]\Z', "no trailing newline"), | ||||
timeless
|
r27791 | (r'export .*=', "don't export and assign at once"), | ||
Matt Mackall
|
r15372 | (r'^source\b', "don't use 'source', use '.'"), | ||
Dan Villiom Podlaski Christiansen
|
r12367 | (r'touch -d', "don't use 'touch -d', use 'touch -t' instead"), | ||
Yuya Nishihara
|
r29330 | (r'\bls +[^|\n-]+ +-', "options to 'ls' must come before filenames"), | ||
Matt Mackall
|
r15281 | (r'[^>\n]>\s*\$HGRCPATH', "don't overwrite $HGRCPATH, append to it"), | ||
Matt Mackall
|
r15372 | (r'^stop\(\)', "don't use 'stop' as a shell function name"), | ||
Mads Kiilerich
|
r15282 | (r'(\[|\btest\b).*-e ', "don't use 'test -e', use 'test -f'"), | ||
Yuya Nishihara
|
r25588 | (r'\[\[\s+[^\]]*\]\]', "don't use '[[ ]]', use '[ ]'"), | ||
Mads Kiilerich
|
r16013 | (r'^alias\b.*=', "don't use alias, use a function"), | ||
Mads Kiilerich
|
r16485 | (r'if\s*!', "don't use '!' to negate exit status"), | ||
Mads Kiilerich
|
r16494 | (r'/dev/u?random', "don't use entropy, use /dev/zero"), | ||
Mads Kiilerich
|
r16496 | (r'do\s*true;\s*done', "don't use true as loop body, use sleep 0"), | ||
Mads Kiilerich
|
r16497 | (r'^( *)\t', "don't use tabs to indent"), | ||
Kevin Bullock
|
r19083 | (r'sed (-e )?\'(\d+|/[^/]*/)i(?!\\\n)', | ||
Kevin Bullock
|
r19080 | "put a backslash-escaped newline after sed 'i' command"), | ||
Danek Duvall
|
r27557 | (r'^diff *-\w*[uU].*$\n(^ \$ |^$)', "prefix diff -u/-U with cmp"), | ||
(r'^\s+(if)? diff *-\w*[uU]', "prefix diff -u/-U with cmp"), | ||||
Pierre-Yves David
|
r26588 | (r'seq ', "don't use 'seq', use $TESTDIR/seq.py"), | ||
(r'\butil\.Abort\b', "directly use error.Abort"), | ||||
timeless
|
r26777 | (r'\|&', "don't use |&, use 2>&1"), | ||
timeless
|
r27640 | (r'\w = +\w', "only one space after = allowed"), | ||
timeless
|
r28781 | (r'\bsed\b.*[^\\]\\n', "don't use 'sed ... \\n', use a \\ and a newline"), | ||
Jun Wu
|
r30557 | (r'env.*-u', "don't use 'env -u VAR', use 'unset VAR'"), | ||
(r'cp.* -r ', "don't use 'cp -r', use 'cp -R'"), | ||||
Idan Kamara
|
r14009 | ], | ||
# warnings | ||||
Mads Kiilerich
|
r16672 | [ | ||
(r'^function', "don't use 'function', use old style"), | ||||
(r'^diff.*-\w*N', "don't use 'diff -N'"), | ||||
Mads Kiilerich
|
r18508 | (r'\$PWD|\${PWD}', "don't use $PWD, use `pwd`"), | ||
Mads Kiilerich
|
r16672 | (r'^([^"\'\n]|("[^"\n]*")|(\'[^\'\n]*\'))*\^', "^ must be quoted"), | ||
Kevin Bullock
|
r18575 | (r'kill (`|\$\()', "don't use kill, use killdaemons.py") | ||
Mads Kiilerich
|
r16672 | ] | ||
Matt Mackall
|
r10281 | ] | ||
testfilters = [ | ||||
(r"( *)(#([^\n]*\S)?)", repcomment), | ||||
(r"<<(\S+)((.|\n)*?\n\1)", rephere), | ||||
] | ||||
Simon Heimberg
|
r18832 | winglobmsg = "use (glob) to match Windows paths too" | ||
Matt Mackall
|
r15372 | uprefix = r"^ \$ " | ||
Matt Mackall
|
r12364 | utestpats = [ | ||
Idan Kamara
|
r14009 | [ | ||
Matt Mackall
|
r27693 | (r'^(\S.*|| [$>] \S.*)[ \t]\n', "trailing whitespace on non-output"), | ||
Mads Kiilerich
|
r16673 | (uprefix + r'.*\|\s*sed[^|>\n]*\n', | ||
"use regex test output patterns instead of sed"), | ||||
Matt Mackall
|
r12364 | (uprefix + r'(true|exit 0)', "explicit zero exit unnecessary"), | ||
Patrick Mezard
|
r15607 | (uprefix + r'.*(?<!\[)\$\?', "explicit exit code checks unnecessary"), | ||
Matt Mackall
|
r12364 | (uprefix + r'.*\|\| echo.*(fail|error)', | ||
"explicit exit code checks unnecessary"), | ||||
(uprefix + r'set -e', "don't use set -e"), | ||||
Mads Kiilerich
|
r19873 | (uprefix + r'(\s|fi\b|done\b)', "use > for continued lines"), | ||
Simon Heimberg
|
r20423 | (uprefix + r'.*:\.\S*/', "x:.y in a path does not work on msys, rewrite " | ||
"as x://.y, or see `hg log -k msys` for alternatives", r'-\S+:\.|' #-Rxxx | ||||
Matt Mackall
|
r24205 | '# no-msys'), # in test-pull.t which is skipped on windows | ||
Simon Heimberg
|
r18832 | (r'^ saved backup bundle to \$TESTTMP.*\.hg$', winglobmsg), | ||
Bryan O'Sullivan
|
r18835 | (r'^ changeset .* references (corrupted|missing) \$TESTTMP/.*[^)]$', | ||
winglobmsg), | ||||
Simon Heimberg
|
r20014 | (r'^ pulling from \$TESTTMP/.*[^)]$', winglobmsg, | ||
'\$TESTTMP/unix-repo$'), # in test-issue1802.t which skipped on windows | ||||
FUJIWARA Katsunori
|
r23936 | (r'^ reverting (?!subrepo ).*/.*[^)]$', winglobmsg), | ||
Simon Heimberg
|
r20013 | (r'^ cloning subrepo \S+/.*[^)]$', winglobmsg), | ||
(r'^ pushing to \$TESTTMP/.*[^)]$', winglobmsg), | ||||
(r'^ pushing subrepo \S+/\S+ to.*[^)]$', winglobmsg), | ||||
Brendan Cully
|
r19133 | (r'^ moving \S+/.*[^)]$', winglobmsg), | ||
Simon Heimberg
|
r20013 | (r'^ no changes made to subrepo since.*/.*[^)]$', winglobmsg), | ||
(r'^ .*: largefile \S+ not available from file:.*/.*[^)]$', winglobmsg), | ||||
Simon Heimberg
|
r20471 | (r'^ .*file://\$TESTTMP', | ||
'write "file:/*/$TESTTMP" + (glob) to match on windows too'), | ||||
Augie Fackler
|
r29520 | (r'^ [^$>].*27\.0\.0\.1.*[^)]$', | ||
'use (glob) to match localhost IP on hosts without 127.0.0.1 too'), | ||||
Danek Duvall
|
r21930 | (r'^ (cat|find): .*: No such file or directory', | ||
'use test -f to test for file existence'), | ||||
FUJIWARA Katsunori
|
r28033 | (r'^ diff -[^ -]*p', | ||
"don't use (external) diff with -p for portability"), | ||||
FUJIWARA Katsunori
|
r28034 | (r'^ [-+][-+][-+] .* [-+]0000 \(glob\)', | ||
"glob timezone field in diff output for portability"), | ||||
FUJIWARA Katsunori
|
r28035 | (r'^ @@ -[0-9]+ [+][0-9]+,[0-9]+ @@', | ||
"use '@@ -N* +N,n @@ (glob)' style chunk header for portability"), | ||||
(r'^ @@ -[0-9]+,[0-9]+ [+][0-9]+ @@', | ||||
"use '@@ -N,n +N* @@ (glob)' style chunk header for portability"), | ||||
(r'^ @@ -[0-9]+ [+][0-9]+ @@', | ||||
"use '@@ -N* +N* @@ (glob)' style chunk header for portability"), | ||||
FUJIWARA Katsunori
|
r28053 | (uprefix + r'hg( +-[^ ]+( +[^ ]+)?)* +extdiff' | ||
r'( +(-[^ po-]+|--(?!program|option)[^ ]+|[^-][^ ]*))*$', | ||||
"use $RUNTESTDIR/pdiff via extdiff (or -o/-p for false-positives)"), | ||||
Idan Kamara
|
r14009 | ], | ||
# warnings | ||||
Simon Heimberg
|
r18683 | [ | ||
Augie Fackler
|
r29520 | (r'^ (?!.*127\.0\.0\.1)[^*?/\n]* \(glob\)$', | ||
"glob match with no glob string (?, *, /, and 127.0.0.1)"), | ||||
Simon Heimberg
|
r18683 | ] | ||
Matt Mackall
|
r12364 | ] | ||
Mads Kiilerich
|
r14203 | for i in [0, 1]: | ||
Pierre-Yves David
|
r22101 | for tp in testpats[i]: | ||
p = tp[0] | ||||
m = tp[1] | ||||
Matt Mackall
|
r15372 | if p.startswith(r'^'): | ||
Mads Kiilerich
|
r16672 | p = r"^ [$>] (%s)" % p[1:] | ||
Mads Kiilerich
|
r14203 | else: | ||
Mads Kiilerich
|
r16672 | p = r"^ [$>] .*(%s)" % p | ||
Pierre-Yves David
|
r22101 | utestpats[i].append((p, m) + tp[2:]) | ||
Matt Mackall
|
r12364 | |||
utestfilters = [ | ||||
Idan Kamara
|
r17711 | (r"<<(\S+)((.|\n)*?\n > \1)", rephere), | ||
Augie Fackler
|
r29517 | (r"( +)(#([^\n]*\S)?)", repcomment), | ||
Matt Mackall
|
r12364 | ] | ||
Matt Mackall
|
r10281 | pypats = [ | ||
Idan Kamara
|
r14009 | [ | ||
Renato Cunha
|
r11568 | (r'^\s*def\s*\w+\s*\(.*,\s*\(', | ||
"tuple parameter unpacking not available in Python 3+"), | ||||
(r'lambda\s*\(.*,.*\)', | ||||
"tuple parameter unpacking not available in Python 3+"), | ||||
Renato Cunha
|
r11764 | (r'(?<!def)\s+(cmp)\(', "cmp is not available in Python 3+"), | ||
Renato Cunha
|
r11569 | (r'\breduce\s*\(.*', "reduce is not available in Python 3+"), | ||
Yuya Nishihara
|
r29793 | (r'\bdict\(.*=', 'dict() is different in Py2 and 3 and is slower than {}', | ||
Augie Fackler
|
r20688 | 'dict-from-generator'), | ||
Martin Geisler
|
r11602 | (r'\.has_key\b', "dict.has_key is not available in Python 3+"), | ||
Augie Fackler
|
r18183 | (r'\s<>\s', '<> operator is not available in Python 3+, use !='), | ||
Matt Mackall
|
r10281 | (r'^\s*\t', "don't use tabs"), | ||
Matt Mackall
|
r10412 | (r'\S;\s*\n', "semicolon"), | ||
FUJIWARA Katsunori
|
r21097 | (r'[^_]_\([ \t\n]*(?:"[^"]+"[ \t\n+]*)+%', "don't use % inside _()"), | ||
(r"[^_]_\([ \t\n]*(?:'[^']+'[ \t\n+]*)+%", "don't use % inside _()"), | ||||
Mads Kiilerich
|
r18054 | (r'(\w|\)),\w', "missing whitespace after ,"), | ||
(r'(\w|\))[+/*\-<>]\w', "missing whitespace in expression"), | ||||
Mads Kiilerich
|
r18055 | (r'^\s+(\w|\.)+=\w[^,()\n]*$', "missing whitespace in assignment"), | ||
timeless
|
r27640 | (r'\w\s=\s\s+\w', "gratuitous whitespace after ="), | ||
Brodie Rao
|
r16702 | (r'.{81}', "line too long"), | ||
Matt Mackall
|
r10281 | (r'[^\n]\Z', "no trailing newline"), | ||
Matt Mackall
|
r15281 | (r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"), | ||
Brodie Rao
|
r16683 | # (r'^\s+[^_ \n][^_. \n]+_[^_\n]+\s*=', | ||
# "don't use underbars in identifiers"), | ||||
Matt Mackall
|
r15457 | (r'^\s+(self\.)?[A-za-z][a-z0-9]+[A-Z]\w* = ', | ||
"don't use camelcase in identifiers"), | ||||
Matt Mackall
|
r15281 | (r'^\s*(if|while|def|class|except|try)\s[^[\n]*:\s*[^\\n]#\s]+', | ||
Matt Mackall
|
r10286 | "linebreak after :"), | ||
Jun Wu
|
r28219 | (r'class\s[^( \n]+:', "old-style class, use class foo(object)", | ||
r'#.*old-style'), | ||||
Matt Mackall
|
r15281 | (r'class\s[^( \n]+\(\):', | ||
Jun Wu
|
r28219 | "class foo() creates old style object, use class foo(object)", | ||
r'#.*old-style'), | ||||
Pierre-Yves David
|
r25028 | (r'\b(%s)\(' % '|'.join(k for k in keyword.kwlist | ||
if k not in ('print', 'exec')), | ||||
Thomas Arendsen Hein
|
r13076 | "Python keyword is not a function"), | ||
Matt Mackall
|
r10412 | (r',]', "unneeded trailing ',' in list"), | ||
Matt Mackall
|
r10281 | # (r'class\s[A-Z][^\(]*\((?!Exception)', | ||
# "don't capitalize non-exception classes"), | ||||
# (r'in range\(', "use xrange"), | ||||
# (r'^\s*print\s+', "avoid using print in core and extensions"), | ||||
(r'[\x80-\xff]', "non-ASCII character literal"), | ||||
Matt Mackall
|
r25212 | (r'("\')\.format\(', "str.format() has no bytes counterpart, use %"), | ||
Thomas Arendsen Hein
|
r13074 | (r'^\s*(%s)\s\s' % '|'.join(keyword.kwlist), | ||
"gratuitous whitespace after Python keyword"), | ||||
Matt Mackall
|
r15281 | (r'([\(\[][ \t]\S)|(\S[ \t][\)\]])', "gratuitous whitespace in () or []"), | ||
Matt Mackall
|
r10281 | # (r'\s\s=', "gratuitous whitespace before ="), | ||
Pierre-Yves David
|
r17167 | (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S', | ||
Martin Geisler
|
r11345 | "missing whitespace around operator"), | ||
Pierre-Yves David
|
r17167 | (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\s', | ||
Martin Geisler
|
r11345 | "missing whitespace around operator"), | ||
Pierre-Yves David
|
r17167 | (r'\s(\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S', | ||
Martin Geisler
|
r11345 | "missing whitespace around operator"), | ||
Pierre-Yves David
|
r17167 | (r'[^^+=*/!<>&| %-](\s=|=\s)[^= ]', | ||
Martin Geisler
|
r11345 | "wrong whitespace around ="), | ||
Mads Kiilerich
|
r19872 | (r'\([^()]*( =[^=]|[^<>!=]= )', | ||
"no whitespace around = for named parameters"), | ||||
Matt Mackall
|
r10451 | (r'raise Exception', "don't raise generic exceptions"), | ||
Augie Fackler
|
r18180 | (r'raise [^,(]+, (\([^\)]+\)|[^,\(\)]+)$', | ||
"don't use old-style two-argument raise, use Exception(message)"), | ||||
Idan Kamara
|
r14009 | (r' is\s+(not\s+)?["\'0-9-]', "object comparison with literal"), | ||
(r' [=!]=\s+(True|False|None)', | ||||
"comparison with singleton, use 'is' or 'is not' instead"), | ||||
Martin Geisler
|
r14494 | (r'^\s*(while|if) [01]:', | ||
"use True/False for constant Boolean expression"), | ||||
Yuya Nishihara
|
r29796 | (r'(?:(?<!def)\s+|\()hasattr\(', | ||
Augie Fackler
|
r14978 | 'hasattr(foo, bar) is broken, use util.safehasattr(foo, bar) instead'), | ||
Dan Villiom Podlaski Christiansen
|
r14169 | (r'opener\([^)]*\).read\(', | ||
"use opener.read() instead"), | ||||
(r'opener\([^)]*\).write\(', | ||||
"use opener.write() instead"), | ||||
(r'[\s\(](open|file)\([^)]*\)\.read\(', | ||||
"use util.readfile() instead"), | ||||
(r'[\s\(](open|file)\([^)]*\)\.write\(', | ||||
Simon Heimberg
|
r19981 | "use util.writefile() instead"), | ||
Dan Villiom Podlaski Christiansen
|
r14169 | (r'^[\s\(]*(open(er)?|file)\([^)]*\)', | ||
"always assign an opened file to a variable, and close it afterwards"), | ||||
(r'[\s\(](open|file)\([^)]*\)\.', | ||||
"always assign an opened file to a variable, and close it afterwards"), | ||||
Mads Kiilerich
|
r23139 | (r'(?i)descend[e]nt', "the proper spelling is descendAnt"), | ||
Matt Mackall
|
r14709 | (r'\.debug\(\_', "don't mark debug messages for translation"), | ||
Martin Geisler
|
r16590 | (r'\.strip\(\)\.split\(\)', "no need to strip before splitting"), | ||
Simon Heimberg
|
r18762 | (r'^\s*except\s*:', "naked except clause", r'#.*re-raises'), | ||
Gregory Szorc
|
r25661 | (r'^\s*except\s([^\(,]+|\([^\)]+\))\s*,', | ||
'legacy exception syntax; use "as" instead of ","'), | ||||
Mads Kiilerich
|
r17299 | (r':\n( )*( ){1,3}[^ ]', "must indent 4 spaces"), | ||
Matt Mackall
|
r19031 | (r'release\(.*wlock, .*lock\)', "wrong lock release order"), | ||
Yuya Nishihara
|
r22448 | (r'\b__bool__\b', "__bool__ should be __nonzero__ in Python 2"), | ||
FUJIWARA Katsunori
|
r24836 | (r'os\.path\.join\(.*, *(""|\'\')\)', | ||
"use pathutil.normasprefix(path) instead of os.path.join(path, '')"), | ||||
Gregory Szorc
|
r25659 | (r'\s0[0-7]+\b', 'legacy octal syntax; use "0o" prefix instead of "0"'), | ||
Pierre-Yves David
|
r26348 | # XXX only catch mutable arguments on the first line of the definition | ||
(r'def.*[( ]\w+=\{\}', "don't use mutable default arguments"), | ||||
Pierre-Yves David
|
r26588 | (r'\butil\.Abort\b', "directly use error.Abort"), | ||
Martin von Zweigbergk
|
r30810 | (r'^@(\w*\.)?cachefunc', "module-level @cachefunc is risky, please avoid"), | ||
timeless
|
r28820 | (r'^import Queue', "don't use Queue, use util.queue + util.empty"), | ||
timeless
|
r28884 | (r'^import cStringIO', "don't use cStringIO.StringIO, use util.stringio"), | ||
(r'^import urllib', "don't use urllib, use util.urlreq/util.urlerr"), | ||||
Pulkit Goyal
|
r29434 | (r'^import SocketServer', "don't use SockerServer, use util.socketserver"), | ||
(r'^import urlparse', "don't use urlparse, use util.urlparse"), | ||||
(r'^import xmlrpclib', "don't use xmlrpclib, use util.xmlrpclib"), | ||||
(r'^import cPickle', "don't use cPickle, use util.pickle"), | ||||
(r'^import pickle', "don't use pickle, use util.pickle"), | ||||
Pulkit Goyal
|
r29455 | (r'^import httplib', "don't use httplib, use util.httplib"), | ||
Pulkit Goyal
|
r29566 | (r'^import BaseHTTPServer', "use util.httpserver instead"), | ||
timeless
|
r29217 | (r'\.next\(\)', "don't use .next(), use next(...)"), | ||
FUJIWARA Katsunori
|
r29278 | |||
# rules depending on implementation of repquote() | ||||
FUJIWARA Katsunori
|
r29279 | (r' x+[xpqo%APM][\'"]\n\s+[\'"]x', | ||
'string join across lines with no space'), | ||||
FUJIWARA Katsunori
|
r29397 | (r'''(?x)ui\.(status|progress|write|note|warn)\( | ||
[ \t\n#]* | ||||
(?# any strings/comments might precede a string, which | ||||
# contains translatable message) | ||||
((['"]|\'\'\'|""")[ \npq%bAPMxno]*(['"]|\'\'\'|""")[ \t\n#]+)* | ||||
(?# sequence consisting of below might precede translatable message | ||||
# - formatting string: "% 10s", "%05d", "% -3.2f", "%*s", "%%" ... | ||||
# - escaped character: "\\", "\n", "\0" ... | ||||
# - character other than '%', 'b' as '\', and 'x' as alphabet) | ||||
(['"]|\'\'\'|""") | ||||
((%([ n]?[PM]?([np]+|A))?x)|%%|b[bnx]|[ \nnpqAPMo])*x | ||||
(?# this regexp can't use [^...] style, | ||||
# because _preparepats forcibly adds "\n" into [^...], | ||||
# even though this regexp wants match it against "\n")''', | ||||
FUJIWARA Katsunori
|
r29278 | "missing _() in ui message (use () to hide false-positives)"), | ||
Idan Kamara
|
r14009 | ], | ||
# warnings | ||||
[ | ||||
FUJIWARA Katsunori
|
r29278 | # rules depending on implementation of repquote() | ||
Simon Heimberg
|
r19999 | (r'(^| )pp +xxxxqq[ \n][^\n]', "add two newlines after '.. note::'"), | ||
Idan Kamara
|
r14009 | ] | ||
Matt Mackall
|
r10281 | ] | ||
pyfilters = [ | ||||
Benoit Boissinot
|
r10727 | (r"""(?msx)(?P<comment>\#.*?$)| | ||
((?P<quote>('''|\"\"\"|(?<!')'(?!')|(?<!")"(?!"))) | ||||
(?P<text>(([^\\]|\\.)*?)) | ||||
(?P=quote))""", reppython), | ||||
Matt Mackall
|
r10281 | ] | ||
Mads Kiilerich
|
r18960 | txtfilters = [] | ||
txtpats = [ | ||||
[ | ||||
('\s$', 'trailing whitespace'), | ||||
Simon Heimberg
|
r20532 | ('.. note::[ \n][^\n]', 'add two newlines after note::') | ||
Mads Kiilerich
|
r18960 | ], | ||
[] | ||||
] | ||||
Matt Mackall
|
r10281 | cpats = [ | ||
Idan Kamara
|
r14009 | [ | ||
Matt Mackall
|
r10281 | (r'//', "don't use //-style comments"), | ||
(r'^ ', "don't use spaces to indent"), | ||||
(r'\S\t', "don't use tabs except for indent"), | ||||
Matt Mackall
|
r15281 | (r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"), | ||
Brodie Rao
|
r16702 | (r'.{81}', "line too long"), | ||
Matt Mackall
|
r10281 | (r'(while|if|do|for)\(', "use space after while/if/do/for"), | ||
(r'return\(', "return is not a function"), | ||||
(r' ;', "no space before ;"), | ||||
Laurent Charignon
|
r24453 | (r'[^;] \)', "no space before )"), | ||
Matt Mackall
|
r19745 | (r'[)][{]', "space between ) and {"), | ||
Matt Mackall
|
r10281 | (r'\w+\* \w+', "use int *foo, not int* foo"), | ||
Matt Mackall
|
r19731 | (r'\W\([^\)]+\) \w+', "use (int)foo, not (int) foo"), | ||
Matt Mackall
|
r16413 | (r'\w+ (\+\+|--)', "use foo++, not foo ++"), | ||
Matt Mackall
|
r10281 | (r'\w,\w', "missing whitespace after ,"), | ||
Matt Mackall
|
r13736 | (r'^[^#]\w[+/*]\w', "missing whitespace in expression"), | ||
timeless
|
r27640 | (r'\w\s=\s\s+\w', "gratuitous whitespace after ="), | ||
Matt Mackall
|
r10281 | (r'^#\s+\w', "use #foo, not # foo"), | ||
(r'[^\n]\Z', "no trailing newline"), | ||||
Dan Villiom Podlaski Christiansen
|
r13748 | (r'^\s*#import\b', "use only #include in standard C code"), | ||
Augie Fackler
|
r28594 | (r'strcpy\(', "don't use strcpy, use strlcpy or memcpy"), | ||
Augie Fackler
|
r28595 | (r'strcat\(', "don't use strcat"), | ||
FUJIWARA Katsunori
|
r29278 | |||
# rules depending on implementation of repquote() | ||||
Idan Kamara
|
r14009 | ], | ||
# warnings | ||||
FUJIWARA Katsunori
|
r29278 | [ | ||
# rules depending on implementation of repquote() | ||||
] | ||||
Matt Mackall
|
r10281 | ] | ||
cfilters = [ | ||||
(r'(/\*)(((\*(?!/))|[^*])*)\*/', repccomment), | ||||
Benoit Boissinot
|
r10722 | (r'''(?P<quote>(?<!")")(?P<text>([^"]|\\")+)"(?!")''', repquote), | ||
Matt Mackall
|
r10281 | (r'''(#\s*include\s+<)([^>]+)>''', repinclude), | ||
(r'(\()([^)]+\))', repcallspaces), | ||||
] | ||||
timeless
|
r14137 | inutilpats = [ | ||
[ | ||||
(r'\bui\.', "don't use ui in util"), | ||||
], | ||||
# warnings | ||||
[] | ||||
] | ||||
inrevlogpats = [ | ||||
[ | ||||
(r'\brepo\.', "don't use repo in revlog"), | ||||
], | ||||
# warnings | ||||
[] | ||||
] | ||||
Steven Brown
|
r21487 | webtemplatefilters = [] | ||
webtemplatepats = [ | ||||
[], | ||||
[ | ||||
(r'{desc(\|(?!websub|firstline)[^\|]*)+}', | ||||
'follow desc keyword with either firstline or websub'), | ||||
] | ||||
] | ||||
FUJIWARA Katsunori
|
r30246 | allfilesfilters = [] | ||
allfilespats = [ | ||||
[ | ||||
(r'(http|https)://[a-zA-Z0-9./]*selenic.com/', | ||||
'use mercurial-scm.org domain URL'), | ||||
FUJIWARA Katsunori
|
r30888 | (r'mercurial@selenic\.com', | ||
'use mercurial-scm.org domain for mercurial ML address'), | ||||
FUJIWARA Katsunori
|
r30890 | (r'mercurial-devel@selenic\.com', | ||
'use mercurial-scm.org domain for mercurial-devel ML address'), | ||||
FUJIWARA Katsunori
|
r30246 | ], | ||
# warnings | ||||
[], | ||||
] | ||||
Pulkit Goyal
|
r30665 | py3pats = [ | ||
[ | ||||
(r'os\.environ', "use encoding.environ instead (py3)"), | ||||
(r'os\.name', "use pycompat.osname instead (py3)"), | ||||
(r'os\.getcwd', "use pycompat.getcwd instead (py3)"), | ||||
(r'os\.sep', "use pycompat.ossep instead (py3)"), | ||||
(r'os\.pathsep', "use pycompat.ospathsep instead (py3)"), | ||||
(r'os\.altsep', "use pycompat.osaltsep instead (py3)"), | ||||
(r'sys\.platform', "use pycompat.sysplatform instead (py3)"), | ||||
(r'getopt\.getopt', "use pycompat.getoptb instead (py3)"), | ||||
Pulkit Goyal
|
r30820 | (r'os\.getenv', "use encoding.environ.get instead"), | ||
(r'os\.setenv', "modifying the environ dict is not preferred"), | ||||
Pulkit Goyal
|
r30665 | ], | ||
# warnings | ||||
[], | ||||
] | ||||
Matt Mackall
|
r10281 | checks = [ | ||
Matt Mackall
|
r21222 | ('python', r'.*\.(py|cgi)$', r'^#!.*python', pyfilters, pypats), | ||
Pulkit Goyal
|
r30665 | ('python 3', r'.*(hgext|mercurial).*(?<!pycompat)\.py', '', | ||
pyfilters, py3pats), | ||||
Matt Mackall
|
r21222 | ('test script', r'(.*/)?test-[^.~]*$', '', testfilters, testpats), | ||
('c', r'.*\.[ch]$', '', cfilters, cpats), | ||||
('unified test', r'.*\.t$', '', utestfilters, utestpats), | ||||
('layering violation repo in revlog', r'mercurial/revlog\.py', '', | ||||
pyfilters, inrevlogpats), | ||||
('layering violation ui in util', r'mercurial/util\.py', '', pyfilters, | ||||
timeless
|
r14137 | inutilpats), | ||
Matt Mackall
|
r21222 | ('txt', r'.*\.txt$', '', txtfilters, txtpats), | ||
Steven Brown
|
r21487 | ('web template', r'mercurial/templates/.*\.tmpl', '', | ||
webtemplatefilters, webtemplatepats), | ||||
FUJIWARA Katsunori
|
r30246 | ('all except for .po', r'.*(?<!\.po)$', '', | ||
allfilesfilters, allfilespats), | ||||
Matt Mackall
|
r10281 | ] | ||
Simon Heimberg
|
r19307 | def _preparepats(): | ||
for c in checks: | ||||
failandwarn = c[-1] | ||||
for pats in failandwarn: | ||||
for i, pseq in enumerate(pats): | ||||
# fix-up regexes for multi-line searches | ||||
Simon Heimberg
|
r19378 | p = pseq[0] | ||
Simon Heimberg
|
r19307 | # \s doesn't match \n | ||
p = re.sub(r'(?<!\\)\\s', r'[ \\t]', p) | ||||
# [^...] doesn't match newline | ||||
p = re.sub(r'(?<!\\)\[\^', r'[^\\n', p) | ||||
Simon Heimberg
|
r19308 | pats[i] = (re.compile(p, re.MULTILINE),) + pseq[1:] | ||
Matt Mackall
|
r21222 | filters = c[3] | ||
Simon Heimberg
|
r19309 | for i, flt in enumerate(filters): | ||
filters[i] = re.compile(flt[0]), flt[1] | ||||
Simon Heimberg
|
r19307 | |||
Pierre-Yves David
|
r10719 | class norepeatlogger(object): | ||
def __init__(self): | ||||
self._lastseen = None | ||||
Matt Mackall
|
r11604 | def log(self, fname, lineno, line, msg, blame): | ||
Pierre-Yves David
|
r10719 | """print error related a to given line of a given file. | ||
The faulty line will also be printed but only once in the case | ||||
of multiple errors. | ||||
Matt Mackall
|
r10281 | |||
Pierre-Yves David
|
r10719 | :fname: filename | ||
:lineno: line number | ||||
:line: actual content of the line | ||||
:msg: error message | ||||
""" | ||||
msgid = fname, lineno, line | ||||
if msgid != self._lastseen: | ||||
Matt Mackall
|
r11604 | if blame: | ||
Pulkit Goyal
|
r28509 | print("%s:%d (%s):" % (fname, lineno, blame)) | ||
Matt Mackall
|
r11604 | else: | ||
Pulkit Goyal
|
r28509 | print("%s:%d:" % (fname, lineno)) | ||
print(" > %s" % line) | ||||
Pierre-Yves David
|
r10719 | self._lastseen = msgid | ||
Pulkit Goyal
|
r28509 | print(" " + msg) | ||
Pierre-Yves David
|
r10719 | |||
_defaultlogger = norepeatlogger() | ||||
Matt Mackall
|
r11604 | def getblame(f): | ||
lines = [] | ||||
for l in os.popen('hg annotate -un %s' % f): | ||||
start, line = l.split(':', 1) | ||||
user, rev = start.split() | ||||
lines.append((line[1:-1], user, rev)) | ||||
return lines | ||||
def checkfile(f, logfunc=_defaultlogger.log, maxerr=None, warnings=False, | ||||
Mads Kiilerich
|
r15502 | blame=False, debug=False, lineno=True): | ||
Pierre-Yves David
|
r10719 | """checks style and portability of a given file | ||
:f: filepath | ||||
:logfunc: function used to report error | ||||
logfunc(filename, linenumber, linecontent, errormessage) | ||||
Mads Kiilerich
|
r17424 | :maxerr: number of error to display before aborting. | ||
Mads Kiilerich
|
r15873 | Set to false (default) to report all errors | ||
Pierre-Yves David
|
r10720 | |||
return True if no error is found, False otherwise. | ||||
Pierre-Yves David
|
r10719 | """ | ||
Matt Mackall
|
r11604 | blamecache = None | ||
Pierre-Yves David
|
r10720 | result = True | ||
Matt Mackall
|
r21222 | |||
try: | ||||
timeless
|
r29145 | with opentext(f) as fp: | ||
try: | ||||
pre = post = fp.read() | ||||
except UnicodeDecodeError as e: | ||||
print("%s while reading %s" % (e, f)) | ||||
return result | ||||
Gregory Szorc
|
r25660 | except IOError as e: | ||
Pulkit Goyal
|
r28509 | print("Skipping %s, %s" % (f, str(e).split(':', 1)[0])) | ||
Matt Mackall
|
r21222 | return result | ||
for name, match, magic, filters, pats in checks: | ||||
FUJIWARA Katsunori
|
r30245 | post = pre # discard filtering result of previous check | ||
timeless
|
r14135 | if debug: | ||
Pulkit Goyal
|
r28509 | print(name, f) | ||
Matt Mackall
|
r10281 | fc = 0 | ||
FUJIWARA Katsunori
|
r28050 | if not (re.match(match, f) or (magic and re.search(magic, pre))): | ||
timeless
|
r14135 | if debug: | ||
Pulkit Goyal
|
r28509 | print("Skipping %s for %s it doesn't match %s" % ( | ||
name, match, f)) | ||||
Matt Mackall
|
r10281 | continue | ||
Simon Heimberg
|
r19382 | if "no-" "check-code" in pre: | ||
timeless
|
r27560 | # If you're looking at this line, it's because a file has: | ||
# no- check- code | ||||
# but the reason to output skipping is to make life for | ||||
# tests easier. So, instead of writing it with a normal | ||||
# spelling, we write it with the expected spelling from | ||||
# tests/test-check-code.t | ||||
Pulkit Goyal
|
r28509 | print("Skipping %s it has no-che?k-code (glob)" % f) | ||
Simon Heimberg
|
r20239 | return "Skip" # skip checking this file | ||
Matt Mackall
|
r10281 | for p, r in filters: | ||
post = re.sub(p, r, post) | ||||
Simon Heimberg
|
r19422 | nerrs = len(pats[0]) # nerr elements are errors | ||
Idan Kamara
|
r14009 | if warnings: | ||
pats = pats[0] + pats[1] | ||||
else: | ||||
pats = pats[0] | ||||
Matt Mackall
|
r10281 | # print post # uncomment to show filtered version | ||
Matt Mackall
|
r15281 | |||
timeless
|
r14135 | if debug: | ||
Pulkit Goyal
|
r28509 | print("Checking %s for %s" % (name, f)) | ||
Matt Mackall
|
r15281 | |||
prelines = None | ||||
errors = [] | ||||
Simon Heimberg
|
r19422 | for i, pat in enumerate(pats): | ||
Brodie Rao
|
r16705 | if len(pat) == 3: | ||
p, msg, ignore = pat | ||||
else: | ||||
p, msg = pat | ||||
ignore = None | ||||
Simon Heimberg
|
r20005 | if i >= nerrs: | ||
msg = "warning: " + msg | ||||
Brodie Rao
|
r16705 | |||
Matt Mackall
|
r15281 | pos = 0 | ||
n = 0 | ||||
Simon Heimberg
|
r19308 | for m in p.finditer(post): | ||
Matt Mackall
|
r15281 | if prelines is None: | ||
prelines = pre.splitlines() | ||||
postlines = post.splitlines(True) | ||||
start = m.start() | ||||
while n < len(postlines): | ||||
step = len(postlines[n]) | ||||
if pos + step > start: | ||||
break | ||||
pos += step | ||||
n += 1 | ||||
l = prelines[n] | ||||
Simon Heimberg
|
r20242 | if ignore and re.search(ignore, l, re.MULTILINE): | ||
Simon Heimberg
|
r20243 | if debug: | ||
Pulkit Goyal
|
r28509 | print("Skipping %s for %s:%s (ignore pattern)" % ( | ||
name, f, n)) | ||||
Brodie Rao
|
r16705 | continue | ||
Matt Mackall
|
r15281 | bd = "" | ||
if blame: | ||||
bd = 'working directory' | ||||
if not blamecache: | ||||
blamecache = getblame(f) | ||||
if n < len(blamecache): | ||||
bl, bu, br = blamecache[n] | ||||
if bl == l: | ||||
bd = '%s@%s' % (bu, br) | ||||
Simon Heimberg
|
r20005 | |||
Mads Kiilerich
|
r15502 | errors.append((f, lineno and n + 1, l, msg, bd)) | ||
Matt Mackall
|
r15281 | result = False | ||
errors.sort() | ||||
for e in errors: | ||||
logfunc(*e) | ||||
fc += 1 | ||||
Mads Kiilerich
|
r15873 | if maxerr and fc >= maxerr: | ||
Pulkit Goyal
|
r28509 | print(" (too many errors, giving up)") | ||
Matt Mackall
|
r10281 | break | ||
Matt Mackall
|
r15281 | |||
Pierre-Yves David
|
r10720 | return result | ||
Pierre-Yves David
|
r10717 | |||
FUJIWARA Katsunori
|
r29568 | def main(): | ||
Matt Mackall
|
r10895 | parser = optparse.OptionParser("%prog [options] [files]") | ||
parser.add_option("-w", "--warnings", action="store_true", | ||||
help="include warning-level checks") | ||||
parser.add_option("-p", "--per-file", type="int", | ||||
help="max warnings per file") | ||||
Matt Mackall
|
r11604 | parser.add_option("-b", "--blame", action="store_true", | ||
help="use annotate to generate blame info") | ||||
timeless
|
r14135 | parser.add_option("", "--debug", action="store_true", | ||
help="show debug information") | ||||
Mads Kiilerich
|
r15502 | parser.add_option("", "--nolineno", action="store_false", | ||
dest='lineno', help="don't show line numbers") | ||||
Matt Mackall
|
r10895 | |||
Mads Kiilerich
|
r15502 | parser.set_defaults(per_file=15, warnings=False, blame=False, debug=False, | ||
lineno=True) | ||||
Matt Mackall
|
r10895 | (options, args) = parser.parse_args() | ||
if len(args) == 0: | ||||
Pierre-Yves David
|
r10716 | check = glob.glob("*") | ||
else: | ||||
Matt Mackall
|
r10895 | check = args | ||
Matt Mackall
|
r10281 | |||
FUJIWARA Katsunori
|
r29569 | _preparepats() | ||
Mads Kiilerich
|
r15544 | ret = 0 | ||
Pierre-Yves David
|
r10716 | for f in check: | ||
Alecs King
|
r11816 | if not checkfile(f, maxerr=options.per_file, warnings=options.warnings, | ||
Mads Kiilerich
|
r15502 | blame=options.blame, debug=options.debug, | ||
lineno=options.lineno): | ||||
Alecs King
|
r11816 | ret = 1 | ||
FUJIWARA Katsunori
|
r29568 | return ret | ||
if __name__ == "__main__": | ||||
sys.exit(main()) | ||||