upstream/mercurial-mirror Commit - r21097:e8ef59b3

1

#!/usr/bin/env python

1

#!/usr/bin/env python

2

#

2

#

3

# check-code - a style and portability checker for Mercurial

3

# check-code - a style and portability checker for Mercurial

4

#

4

#

5

6

#

6

#

7

# This software may be used and distributed according to the terms of the

7

# This software may be used and distributed according to the terms of the

8

# GNU General Public License version 2 or any later version.

8

# GNU General Public License version 2 or any later version.

9

10

"""style and portability checker for Mercurial

10

"""style and portability checker for Mercurial

11

12

when a rule triggers wrong, do one of the following (prefer one from top):

12

when a rule triggers wrong, do one of the following (prefer one from top):

13

* do the work-around the rule suggests

13

* do the work-around the rule suggests

14

* doublecheck that it is a false match

14

* doublecheck that it is a false match

15

* improve the rule pattern

15

* improve the rule pattern

16

* add an ignore pattern to the rule (3rd arg) which matches your good line

16

* add an ignore pattern to the rule (3rd arg) which matches your good line

17

(you can append a short comment and match this, like: #re-raises, # no-py24)

17

(you can append a short comment and match this, like: #re-raises, # no-py24)

18

* change the pattern to a warning and list the exception in test-check-code-hg

18

* change the pattern to a warning and list the exception in test-check-code-hg

19

* ONLY use no--check-code for skipping entire files from external sources

19

* ONLY use no--check-code for skipping entire files from external sources

20

"""

20

"""

21

22

import re, glob, os, sys

22

import re, glob, os, sys

23

import keyword

23

import keyword

24

import optparse

24

import optparse

25

try:

25

try:

26

import re2

26

import re2

27

except ImportError:

27

except ImportError:

28

re2 = None

28

re2 = None

29

30

def compilere(pat, multiline=False):

30

def compilere(pat, multiline=False):

31

if multiline:

31

if multiline:

32

pat = '(?m)' + pat

32

pat = '(?m)' + pat

33

if re2:

33

if re2:

34

try:

34

try:

35

return re2.compile(pat)

35

return re2.compile(pat)

36

except re2.error:

36

except re2.error:

37

pass

37

pass

38

return re.compile(pat)

38

return re.compile(pat)

39

40

def repquote(m):

40

def repquote(m):

41

fromc = '.:'

41

fromc = '.:'

42

tochr = 'pq'

42

tochr = 'pq'

43

def encodechr(i):

43

def encodechr(i):

44

if i > 255:

44

if i > 255:

45

return 'u'

45

return 'u'

46

c = chr(i)

46

c = chr(i)

47

if c in ' \n':

47

if c in ' \n':

48

return c

48

return c

49

if c.isalpha():

49

if c.isalpha():

50

return 'x'

50

return 'x'

51

if c.isdigit():

51

if c.isdigit():

52

return 'n'

52

return 'n'

53

try:

53

try:

54

return tochr[fromc.find(c)]

54

return tochr[fromc.find(c)]

55

except (ValueError, IndexError):

55

except (ValueError, IndexError):

56

return 'o'

56

return 'o'

57

t = m.group('text')

57

t = m.group('text')

58

tt = ''.join(encodechr(i) for i in xrange(256))

58

tt = ''.join(encodechr(i) for i in xrange(256))

59

t = t.translate(tt)

59

t = t.translate(tt)

60

return m.group('quote') + t + m.group('quote')

60

return m.group('quote') + t + m.group('quote')

61

62

def reppython(m):

62

def reppython(m):

63

comment = m.group('comment')

63

comment = m.group('comment')

64

if comment:

64

if comment:

65

l = len(comment.rstrip())

65

l = len(comment.rstrip())

66

return "#" * l + comment[l:]

66

return "#" * l + comment[l:]

67

return repquote(m)

67

return repquote(m)

68

69

def repcomment(m):

69

def repcomment(m):

70

return m.group(1) + "#" * len(m.group(2))

70

return m.group(1) + "#" * len(m.group(2))

71

72

def repccomment(m):

72

def repccomment(m):

73

t = re.sub(r"((?<=\n) )|\S", "x", m.group(2))

73

t = re.sub(r"((?<=\n) )|\S", "x", m.group(2))

74

return m.group(1) + t + "*/"

74

return m.group(1) + t + "*/"

75

76

def repcallspaces(m):

76

def repcallspaces(m):

77

t = re.sub(r"\n\s+", "\n", m.group(2))

77

t = re.sub(r"\n\s+", "\n", m.group(2))

78

return m.group(1) + t

78

return m.group(1) + t

79

80

def repinclude(m):

80

def repinclude(m):

81

return m.group(1) + "<foo>"

81

return m.group(1) + "<foo>"

82

83

def rephere(m):

83

def rephere(m):

84

t = re.sub(r"\S", "x", m.group(2))

84

t = re.sub(r"\S", "x", m.group(2))

85

return m.group(1) + t

85

return m.group(1) + t

86

87

88

testpats = [

88

testpats = [

89

[

89

[

90

(r'pushd|popd', "don't use 'pushd' or 'popd', use 'cd'"),

90

(r'pushd|popd', "don't use 'pushd' or 'popd', use 'cd'"),

91

(r'\W\$?$\([^$\n]*\)\)', "don't use (()) or $(()), use 'expr'"),

91

(r'\W\$?$\([^$\n]*\)\)', "don't use (()) or $(()), use 'expr'"),

92

(r'grep.*-q', "don't use 'grep -q', redirect to /dev/null"),

92

(r'grep.*-q', "don't use 'grep -q', redirect to /dev/null"),

93

(r'(?<!hg )grep.*-a', "don't use 'grep -a', use in-line python"),

93

(r'(?<!hg )grep.*-a', "don't use 'grep -a', use in-line python"),

94

(r'sed.*-i', "don't use 'sed -i', use a temporary file"),

94

(r'sed.*-i', "don't use 'sed -i', use a temporary file"),

95

(r'\becho\b.*\\n', "don't use 'echo \\n', use printf"),

95

(r'\becho\b.*\\n', "don't use 'echo \\n', use printf"),

96

(r'echo -n', "don't use 'echo -n', use printf"),

96

(r'echo -n', "don't use 'echo -n', use printf"),

97

(r'(^| )wc[^|]*$\n(?!.*$re$)', "filter wc output"),

97

(r'(^| )wc[^|]*$\n(?!.*$re$)', "filter wc output"),

98

(r'head -c', "don't use 'head -c', use 'dd'"),

98

(r'head -c', "don't use 'head -c', use 'dd'"),

99

(r'tail -n', "don't use the '-n' option to tail, just use '-<num>'"),

99

(r'tail -n', "don't use the '-n' option to tail, just use '-<num>'"),

100

(r'sha1sum', "don't use sha1sum, use $TESTDIR/md5sum.py"),

100

(r'sha1sum', "don't use sha1sum, use $TESTDIR/md5sum.py"),

101

(r'ls.*-\w*R', "don't use 'ls -R', use 'find'"),

101

(r'ls.*-\w*R', "don't use 'ls -R', use 'find'"),

102

(r'printf.*[^\\]\\([1-9]|0\d)', "don't use 'printf \NNN', use Python"),

102

(r'printf.*[^\\]\\([1-9]|0\d)', "don't use 'printf \NNN', use Python"),

103

(r'printf.*[^\\]\\x', "don't use printf \\x, use Python"),

103

(r'printf.*[^\\]\\x', "don't use printf \\x, use Python"),

104

(r'\$$.*$', "don't use $(expr), use `expr`"),

104

(r'\$$.*$', "don't use $(expr), use `expr`"),

105

(r'rm -rf \*', "don't use naked rm -rf, target a directory"),

105

(r'rm -rf \*', "don't use naked rm -rf, target a directory"),

106

(r'(^|\|\s*)grep (-\w\s+)*[^|]*[(|]\w',

106

(r'(^|\|\s*)grep (-\w\s+)*[^|]*[(|]\w',

107

"use egrep for extended grep syntax"),

107

"use egrep for extended grep syntax"),

108

(r'/bin/', "don't use explicit paths for tools"),

108

(r'/bin/', "don't use explicit paths for tools"),

109

(r'[^\n]\Z', "no trailing newline"),

109

(r'[^\n]\Z', "no trailing newline"),

110

(r'export.*=', "don't export and assign at once"),

110

(r'export.*=', "don't export and assign at once"),

111

(r'^source\b', "don't use 'source', use '.'"),

111

(r'^source\b', "don't use 'source', use '.'"),

112

(r'touch -d', "don't use 'touch -d', use 'touch -t' instead"),

112

(r'touch -d', "don't use 'touch -d', use 'touch -t' instead"),

113

(r'ls +[^|\n-]+ +-', "options to 'ls' must come before filenames"),

113

(r'ls +[^|\n-]+ +-', "options to 'ls' must come before filenames"),

114

(r'[^>\n]>\s*\$HGRCPATH', "don't overwrite $HGRCPATH, append to it"),

114

(r'[^>\n]>\s*\$HGRCPATH', "don't overwrite $HGRCPATH, append to it"),

115

(r'^stop', "don't use 'stop' as a shell function name"),

115

(r'^stop', "don't use 'stop' as a shell function name"),

116

(r'(\[|\btest\b).*-e ', "don't use 'test -e', use 'test -f'"),

116

(r'(\[|\btest\b).*-e ', "don't use 'test -e', use 'test -f'"),

117

(r'^alias\b.*=', "don't use alias, use a function"),

117

(r'^alias\b.*=', "don't use alias, use a function"),

118

(r'if\s*!', "don't use '!' to negate exit status"),

118

(r'if\s*!', "don't use '!' to negate exit status"),

119

(r'/dev/u?random', "don't use entropy, use /dev/zero"),

119

(r'/dev/u?random', "don't use entropy, use /dev/zero"),

120

(r'do\s*true;\s*done', "don't use true as loop body, use sleep 0"),

120

(r'do\s*true;\s*done', "don't use true as loop body, use sleep 0"),

121

(r'^( *)\t', "don't use tabs to indent"),

121

(r'^( *)\t', "don't use tabs to indent"),

122

(r'sed (-e )?\'(\d+|/[^/]*/)i(?!\\\n)',

122

(r'sed (-e )?\'(\d+|/[^/]*/)i(?!\\\n)',

123

"put a backslash-escaped newline after sed 'i' command"),

123

"put a backslash-escaped newline after sed 'i' command"),

124

(r'^diff *-\w*u.*$\n(^ \$ |^$)', "prefix diff -u with cmp"),

124

(r'^diff *-\w*u.*$\n(^ \$ |^$)', "prefix diff -u with cmp"),

125

],

125

],

126

# warnings

126

# warnings

127

[

127

[

128

(r'^function', "don't use 'function', use old style"),

128

(r'^function', "don't use 'function', use old style"),

129

(r'^diff.*-\w*N', "don't use 'diff -N'"),

129

(r'^diff.*-\w*N', "don't use 'diff -N'"),

130

(r'\$PWD|\${PWD}', "don't use $PWD, use `pwd`"),

130

(r'\$PWD|\${PWD}', "don't use $PWD, use `pwd`"),

131

(r'^([^"\'\n]|("[^"\n]*")|(\'[^\'\n]*\'))*\^', "^ must be quoted"),

131

(r'^([^"\'\n]|("[^"\n]*")|(\'[^\'\n]*\'))*\^', "^ must be quoted"),

132

(r'kill (`|\$\()', "don't use kill, use killdaemons.py")

132

(r'kill (`|\$\()', "don't use kill, use killdaemons.py")

133

]

133

]

134

]

134

]

135

136

testfilters = [

136

testfilters = [

137

(r"( *)(#([^\n]*\S)?)", repcomment),

137

(r"( *)(#([^\n]*\S)?)", repcomment),

138

(r"<<(\S+)((.|\n)*?\n\1)", rephere),

138

(r"<<(\S+)((.|\n)*?\n\1)", rephere),

139

]

139

]

140

141

winglobmsg = "use (glob) to match Windows paths too"

141

winglobmsg = "use (glob) to match Windows paths too"

142

uprefix = r"^ \$ "

142

uprefix = r"^ \$ "

143

utestpats = [

143

utestpats = [

144

[

144

[

145

(r'^(\S.*|| [$>] .*)[ \t]\n', "trailing whitespace on non-output"),

145

(r'^(\S.*|| [$>] .*)[ \t]\n', "trailing whitespace on non-output"),

146

(uprefix + r'.*\|\s*sed[^|>\n]*\n',

146

(uprefix + r'.*\|\s*sed[^|>\n]*\n',

147

"use regex test output patterns instead of sed"),

147

"use regex test output patterns instead of sed"),

148

(uprefix + r'(true|exit 0)', "explicit zero exit unnecessary"),

148

(uprefix + r'(true|exit 0)', "explicit zero exit unnecessary"),

149

(uprefix + r'.*(?<!\[)\$\?', "explicit exit code checks unnecessary"),

149

(uprefix + r'.*(?<!\[)\$\?', "explicit exit code checks unnecessary"),

150

(uprefix + r'.*\|\| echo.*(fail|error)',

150

(uprefix + r'.*\|\| echo.*(fail|error)',

151

"explicit exit code checks unnecessary"),

151

"explicit exit code checks unnecessary"),

152

(uprefix + r'set -e', "don't use set -e"),

152

(uprefix + r'set -e', "don't use set -e"),

153

(uprefix + r'(\s|fi\b|done\b)', "use > for continued lines"),

153

(uprefix + r'(\s|fi\b|done\b)', "use > for continued lines"),

154

(uprefix + r'.*:\.\S*/', "x:.y in a path does not work on msys, rewrite "

154

(uprefix + r'.*:\.\S*/', "x:.y in a path does not work on msys, rewrite "

155

"as x://.y, or see `hg log -k msys` for alternatives", r'-\S+:\.|' #-Rxxx

155

"as x://.y, or see `hg log -k msys` for alternatives", r'-\S+:\.|' #-Rxxx

156

'hg pull -q file:../test'), # in test-pull.t which is skipped on windows

156

'hg pull -q file:../test'), # in test-pull.t which is skipped on windows

157

(r'^ saved backup bundle to \$TESTTMP.*\.hg$', winglobmsg),

157

(r'^ saved backup bundle to \$TESTTMP.*\.hg$', winglobmsg),

158

(r'^ changeset .* references (corrupted|missing) \$TESTTMP/.*[^)]$',

158

(r'^ changeset .* references (corrupted|missing) \$TESTTMP/.*[^)]$',

159

winglobmsg),

159

winglobmsg),

160

(r'^ pulling from \$TESTTMP/.*[^)]$', winglobmsg,

160

(r'^ pulling from \$TESTTMP/.*[^)]$', winglobmsg,

161

'\$TESTTMP/unix-repo$'), # in test-issue1802.t which skipped on windows

161

'\$TESTTMP/unix-repo$'), # in test-issue1802.t which skipped on windows

162

(r'^ reverting .*/.*[^)]$', winglobmsg),

162

(r'^ reverting .*/.*[^)]$', winglobmsg),

163

(r'^ cloning subrepo \S+/.*[^)]$', winglobmsg),

163

(r'^ cloning subrepo \S+/.*[^)]$', winglobmsg),

164

(r'^ pushing to \$TESTTMP/.*[^)]$', winglobmsg),

164

(r'^ pushing to \$TESTTMP/.*[^)]$', winglobmsg),

165

(r'^ pushing subrepo \S+/\S+ to.*[^)]$', winglobmsg),

165

(r'^ pushing subrepo \S+/\S+ to.*[^)]$', winglobmsg),

166

(r'^ moving \S+/.*[^)]$', winglobmsg),

166

(r'^ moving \S+/.*[^)]$', winglobmsg),

167

(r'^ no changes made to subrepo since.*/.*[^)]$', winglobmsg),

167

(r'^ no changes made to subrepo since.*/.*[^)]$', winglobmsg),

168

(r'^ .*: largefile \S+ not available from file:.*/.*[^)]$', winglobmsg),

168

(r'^ .*: largefile \S+ not available from file:.*/.*[^)]$', winglobmsg),

169

(r'^ .*file://\$TESTTMP',

169

(r'^ .*file://\$TESTTMP',

170

'write "file:/*/$TESTTMP" + (glob) to match on windows too'),

170

'write "file:/*/$TESTTMP" + (glob) to match on windows too'),

171

],

171

],

172

# warnings

172

# warnings

173

[

173

[

174

(r'^ [^*?/\n]* $glob$$',

174

(r'^ [^*?/\n]* $glob$$',

175

"glob match with no glob character (?*/)"),

175

"glob match with no glob character (?*/)"),

176

]

176

]

177

]

177

]

178

179

for i in [0, 1]:

179

for i in [0, 1]:

180

for p, m in testpats[i]:

180

for p, m in testpats[i]:

181

if p.startswith(r'^'):

181

if p.startswith(r'^'):

182

p = r"^ [$>] (%s)" % p[1:]

182

p = r"^ [$>] (%s)" % p[1:]

183

else:

183

else:

184

p = r"^ [$>] .*(%s)" % p

184

p = r"^ [$>] .*(%s)" % p

185

utestpats[i].append((p, m))

185

utestpats[i].append((p, m))

186

187

utestfilters = [

187

utestfilters = [

188

(r"<<(\S+)((.|\n)*?\n > \1)", rephere),

188

(r"<<(\S+)((.|\n)*?\n > \1)", rephere),

189

(r"( *)(#([^\n]*\S)?)", repcomment),

189

(r"( *)(#([^\n]*\S)?)", repcomment),

190

]

190

]

191

192

pypats = [

192

pypats = [

193

[

193

[

194

(r'\([^)]*\*\w[^()]+\w+=', "can't pass varargs with keyword in Py2.5"),

194

(r'\([^)]*\*\w[^()]+\w+=', "can't pass varargs with keyword in Py2.5"),

195

(r'^\s*def\s*\w+\s*\(.*,\s*\(',

195

(r'^\s*def\s*\w+\s*\(.*,\s*\(',

196

"tuple parameter unpacking not available in Python 3+"),

196

"tuple parameter unpacking not available in Python 3+"),

197

(r'lambda\s*$.*,.*$',

197

(r'lambda\s*$.*,.*$',

198

"tuple parameter unpacking not available in Python 3+"),

198

"tuple parameter unpacking not available in Python 3+"),

199

(r'import (.+,[^.]+\.[^.]+|[^.]+\.[^.]+,)',

199

(r'import (.+,[^.]+\.[^.]+|[^.]+\.[^.]+,)',

200

'2to3 can\'t always rewrite "import qux, foo.bar", '

200

'2to3 can\'t always rewrite "import qux, foo.bar", '

201

'use "import foo.bar" on its own line instead.'),

201

'use "import foo.bar" on its own line instead.'),

202

(r'(?<!def)\s+(cmp)\(', "cmp is not available in Python 3+"),

202

(r'(?<!def)\s+(cmp)\(', "cmp is not available in Python 3+"),

203

(r'\breduce\s*\(.*', "reduce is not available in Python 3+"),

203

(r'\breduce\s*\(.*', "reduce is not available in Python 3+"),

204

(r'dict\(.*=', 'dict() is different in Py2 and 3 and is slower than {}',

204

(r'dict\(.*=', 'dict() is different in Py2 and 3 and is slower than {}',

205

'dict-from-generator'),

205

'dict-from-generator'),

206

(r'\.has_key\b', "dict.has_key is not available in Python 3+"),

206

(r'\.has_key\b', "dict.has_key is not available in Python 3+"),

207

(r'\s<>\s', '<> operator is not available in Python 3+, use !='),

207

(r'\s<>\s', '<> operator is not available in Python 3+, use !='),

208

(r'^\s*\t', "don't use tabs"),

208

(r'^\s*\t', "don't use tabs"),

209

(r'\S;\s*\n', "semicolon"),

209

(r'\S;\s*\n', "semicolon"),

210

(r'[^_]_\((?:"[^"]+"[ \t\n+]*)+%', "don't use % inside _()"),

210

(r'[^_]_\([ \t\n]*(?:"[^"]+"[ \t\n+]*)+%', "don't use % inside _()"),

211

(r"[^_]_\((?:'[^']+'[ \t\n+]*)+%", "don't use % inside _()"),

211

(r"[^_]_\([ \t\n]*(?:'[^']+'[ \t\n+]*)+%", "don't use % inside _()"),

212

(r'(\w|\)),\w', "missing whitespace after ,"),

212

(r'(\w|\)),\w', "missing whitespace after ,"),

213

(r'(\w|\))[+/*\-<>]\w', "missing whitespace in expression"),

213

(r'(\w|\))[+/*\-<>]\w', "missing whitespace in expression"),

214

(r'^\s+(\w|\.)+=\w[^,()\n]*$', "missing whitespace in assignment"),

214

(r'^\s+(\w|\.)+=\w[^,()\n]*$', "missing whitespace in assignment"),

215

(r'(\s+)try:\n((?:\n|\1\s.*\n)+?)\1except.*?:\n'

215

(r'(\s+)try:\n((?:\n|\1\s.*\n)+?)\1except.*?:\n'

216

r'((?:\n|\1\s.*\n)+?)\1finally:', 'no try/except/finally in Python 2.4'),

216

r'((?:\n|\1\s.*\n)+?)\1finally:', 'no try/except/finally in Python 2.4'),

217

(r'(?<!def)(\s+|^|$)next\(.+$',

217

(r'(?<!def)(\s+|^|$)next\(.+$',

218

'no next(foo) in Python 2.4 and 2.5, use foo.next() instead'),

218

'no next(foo) in Python 2.4 and 2.5, use foo.next() instead'),

219

(r'(\s+)try:\n((?:\n|\1\s.*\n)*?)\1\s*yield\b.*?'

219

(r'(\s+)try:\n((?:\n|\1\s.*\n)*?)\1\s*yield\b.*?'

220

r'((?:\n|\1\s.*\n)+?)\1finally:',

220

r'((?:\n|\1\s.*\n)+?)\1finally:',

221

'no yield inside try/finally in Python 2.4'),

221

'no yield inside try/finally in Python 2.4'),

222

(r'.{81}', "line too long"),

222

(r'.{81}', "line too long"),

223

(r' x+[xo][\'"]\n\s+[\'"]x', 'string join across lines with no space'),

223

(r' x+[xo][\'"]\n\s+[\'"]x', 'string join across lines with no space'),

224

(r'[^\n]\Z', "no trailing newline"),

224

(r'[^\n]\Z', "no trailing newline"),

225

(r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),

225

(r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),

226

# (r'^\s+[^_ \n][^_. \n]+_[^_\n]+\s*=',

226

# (r'^\s+[^_ \n][^_. \n]+_[^_\n]+\s*=',

227

# "don't use underbars in identifiers"),

227

# "don't use underbars in identifiers"),

228

(r'^\s+(self\.)?[A-za-z][a-z0-9]+[A-Z]\w* = ',

228

(r'^\s+(self\.)?[A-za-z][a-z0-9]+[A-Z]\w* = ',

229

"don't use camelcase in identifiers"),

229

"don't use camelcase in identifiers"),

230

230

231

"linebreak after :"),

231

"linebreak after :"),

232

(r'class\s[^( \n]+:', "old-style class, use class foo(object)"),

232

(r'class\s[^( \n]+:', "old-style class, use class foo(object)"),

233

(r'class\s[^( \n]+:',

233

(r'class\s[^( \n]+:',

234

"class foo() not available in Python 2.4, use class foo(object)"),

234

"class foo() not available in Python 2.4, use class foo(object)"),

235

(r'\b(%s)\(' % '|'.join(keyword.kwlist),

235

(r'\b(%s)\(' % '|'.join(keyword.kwlist),

236

"Python keyword is not a function"),

236

"Python keyword is not a function"),

237

(r',]', "unneeded trailing ',' in list"),

237

(r',]', "unneeded trailing ',' in list"),

238

# (r'class\s[A-Z][^\(]*\((?!Exception)',

238

# (r'class\s[A-Z][^\(]*\((?!Exception)',

239

# "don't capitalize non-exception classes"),

239

# "don't capitalize non-exception classes"),

240

# (r'in range\(', "use xrange"),

240

# (r'in range\(', "use xrange"),

241

# (r'^\s*print\s+', "avoid using print in core and extensions"),

241

# (r'^\s*print\s+', "avoid using print in core and extensions"),

242

(r'[\x80-\xff]', "non-ASCII character literal"),

242

(r'[\x80-\xff]', "non-ASCII character literal"),

243

(r'("\')\.format\(', "str.format() not available in Python 2.4"),

243

(r'("\')\.format\(', "str.format() not available in Python 2.4"),

244

(r'^\s*with\s+', "with not available in Python 2.4"),

244

(r'^\s*with\s+', "with not available in Python 2.4"),

245

(r'\.isdisjoint\(', "set.isdisjoint not available in Python 2.4"),

245

(r'\.isdisjoint\(', "set.isdisjoint not available in Python 2.4"),

246

(r'^\s*except.* as .*:', "except as not available in Python 2.4"),

246

(r'^\s*except.* as .*:', "except as not available in Python 2.4"),

247

(r'^\s*os\.path\.relpath', "relpath not available in Python 2.4"),

247

(r'^\s*os\.path\.relpath', "relpath not available in Python 2.4"),

248

(r'(?<!def)\s+(any|all|format)\(',

248

(r'(?<!def)\s+(any|all|format)\(',

249

"any/all/format not available in Python 2.4", 'no-py24'),

249

"any/all/format not available in Python 2.4", 'no-py24'),

250

(r'(?<!def)\s+(callable)\(',

250

(r'(?<!def)\s+(callable)\(',

251

"callable not available in Python 3, use getattr(f, '__call__', None)"),

251

"callable not available in Python 3, use getattr(f, '__call__', None)"),

252

(r'if\s.*\selse', "if ... else form not available in Python 2.4"),

252

(r'if\s.*\selse', "if ... else form not available in Python 2.4"),

253

(r'^\s*(%s)\s\s' % '|'.join(keyword.kwlist),

253

(r'^\s*(%s)\s\s' % '|'.join(keyword.kwlist),

254

"gratuitous whitespace after Python keyword"),

254

"gratuitous whitespace after Python keyword"),

255

(r'([$\[][ \t]\S)|(\S[ \t][$\]])', "gratuitous whitespace in () or []"),

255

(r'([$\[][ \t]\S)|(\S[ \t][$\]])', "gratuitous whitespace in () or []"),

256

# (r'\s\s=', "gratuitous whitespace before ="),

256

# (r'\s\s=', "gratuitous whitespace before ="),

257

(r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',

257

(r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',

258

"missing whitespace around operator"),

258

"missing whitespace around operator"),

259

(r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\s',

259

(r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\s',

260

"missing whitespace around operator"),

260

"missing whitespace around operator"),

261

(r'\s(\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',

261

(r'\s(\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',

262

"missing whitespace around operator"),

262

"missing whitespace around operator"),

263

(r'[^^+=*/!<>&| %-](\s=|=\s)[^= ]',

263

(r'[^^+=*/!<>&| %-](\s=|=\s)[^= ]',

264

"wrong whitespace around ="),

264

"wrong whitespace around ="),

265

(r'\([^()]*( =[^=]|[^<>!=]= )',

265

(r'\([^()]*( =[^=]|[^<>!=]= )',

266

"no whitespace around = for named parameters"),

266

"no whitespace around = for named parameters"),

267

(r'raise Exception', "don't raise generic exceptions"),

267

(r'raise Exception', "don't raise generic exceptions"),

268

(r'raise [^,(]+, ($[^$]+\)|[^,]+)$',

268

(r'raise [^,(]+, ($[^$]+\)|[^,]+)$',

269

"don't use old-style two-argument raise, use Exception(message)"),

269

"don't use old-style two-argument raise, use Exception(message)"),

270

(r' is\s+(not\s+)?["\'0-9-]', "object comparison with literal"),

270

(r' is\s+(not\s+)?["\'0-9-]', "object comparison with literal"),

271

(r' [=!]=\s+(True|False|None)',

271

(r' [=!]=\s+(True|False|None)',

272

"comparison with singleton, use 'is' or 'is not' instead"),

272

"comparison with singleton, use 'is' or 'is not' instead"),

273

(r'^\s*(while|if) [01]:',

273

(r'^\s*(while|if) [01]:',

274

"use True/False for constant Boolean expression"),

274

"use True/False for constant Boolean expression"),

275

(r'(?:(?<!def)\s+|\()hasattr',

275

(r'(?:(?<!def)\s+|\()hasattr',

276

'hasattr(foo, bar) is broken, use util.safehasattr(foo, bar) instead'),

276

'hasattr(foo, bar) is broken, use util.safehasattr(foo, bar) instead'),

277

(r'opener$[^)]*$.read\(',

277

(r'opener$[^)]*$.read\(',

278

"use opener.read() instead"),

278

"use opener.read() instead"),

279

(r'BaseException', 'not in Python 2.4, use Exception'),

279

(r'BaseException', 'not in Python 2.4, use Exception'),

280

(r'os\.path\.relpath', 'os.path.relpath is not in Python 2.5'),

280

(r'os\.path\.relpath', 'os.path.relpath is not in Python 2.5'),

281

(r'opener$[^)]*$.write\(',

281

(r'opener$[^)]*$.write\(',

282

"use opener.write() instead"),

282

"use opener.write() instead"),

283

(r'[\s$](open|file)\([^)]*$\.read\(',

283

(r'[\s$](open|file)\([^)]*$\.read\(',

284

"use util.readfile() instead"),

284

"use util.readfile() instead"),

285

(r'[\s$](open|file)\([^)]*$\.write\(',

285

(r'[\s$](open|file)\([^)]*$\.write\(',

286

"use util.writefile() instead"),

286

"use util.writefile() instead"),

287

(r'^[\s$]*(open(er)?|file)\([^)]*$',

287

(r'^[\s$]*(open(er)?|file)\([^)]*$',

288

"always assign an opened file to a variable, and close it afterwards"),

288

"always assign an opened file to a variable, and close it afterwards"),

289

(r'[\s$](open|file)\([^)]*$\.',

289

(r'[\s$](open|file)\([^)]*$\.',

290

"always assign an opened file to a variable, and close it afterwards"),

290

"always assign an opened file to a variable, and close it afterwards"),

291

(r'(?i)descendent', "the proper spelling is descendAnt"),

291

(r'(?i)descendent', "the proper spelling is descendAnt"),

292

(r'\.debug\(\_', "don't mark debug messages for translation"),

292

(r'\.debug\(\_', "don't mark debug messages for translation"),

293

(r'\.strip\.split', "no need to strip before splitting"),

293

(r'\.strip\.split', "no need to strip before splitting"),

294

(r'^\s*except\s*:', "naked except clause", r'#.*re-raises'),

294

(r'^\s*except\s*:', "naked except clause", r'#.*re-raises'),

295

(r':\n( )*( ){1,3}[^ ]', "must indent 4 spaces"),

295

(r':\n( )*( ){1,3}[^ ]', "must indent 4 spaces"),

296

(r'ui\.(status|progress|write|note|warn)\([\'\"]x',

296

(r'ui\.(status|progress|write|note|warn)\([\'\"]x',

297

"missing _() in ui message (use () to hide false-positives)"),

297

"missing _() in ui message (use () to hide false-positives)"),

298

(r'release$.*wlock, .*lock$', "wrong lock release order"),

298

(r'release$.*wlock, .*lock$', "wrong lock release order"),

299

],

299

],

300

# warnings

300

# warnings

301

[

301

[

302

(r'(^| )pp +xxxxqq[ \n][^\n]', "add two newlines after '.. note::'"),

302

(r'(^| )pp +xxxxqq[ \n][^\n]', "add two newlines after '.. note::'"),

303

]

303

]

304

]

304

]

305

306

pyfilters = [

306

pyfilters = [

307

(r"""(?msx)(?P<comment>\#.*?$)|

307

(r"""(?msx)(?P<comment>\#.*?$)|

308

((?P<quote>('''|\"\"\"|(?<!')'(?!')|(?<!")"(?!")))

308

((?P<quote>('''|\"\"\"|(?<!')'(?!')|(?<!")"(?!")))

309

(?P<text>(([^\\]|\\.)*?))

309

(?P<text>(([^\\]|\\.)*?))

310

(?P=quote))""", reppython),

310

(?P=quote))""", reppython),

311

]

311

]

312

313

txtfilters = []

313

txtfilters = []

314

315

txtpats = [

315

txtpats = [

316

[

316

[

317

('\s$', 'trailing whitespace'),

317

('\s$', 'trailing whitespace'),

318

('.. note::[ \n][^\n]', 'add two newlines after note::')

318

('.. note::[ \n][^\n]', 'add two newlines after note::')

319

],

319

],

320

[]

320

[]

321

]

321

]

322

323

cpats = [

323

cpats = [

324

[

324

[

325

(r'//', "don't use //-style comments"),

325

(r'//', "don't use //-style comments"),

326

(r'^ ', "don't use spaces to indent"),

326

(r'^ ', "don't use spaces to indent"),

327

(r'\S\t', "don't use tabs except for indent"),

327

(r'\S\t', "don't use tabs except for indent"),

328

(r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),

328

(r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),

329

(r'.{81}', "line too long"),

329

(r'.{81}', "line too long"),

330

(r'(while|if|do|for)\(', "use space after while/if/do/for"),

330

(r'(while|if|do|for)\(', "use space after while/if/do/for"),

331

(r'return\(', "return is not a function"),

331

(r'return\(', "return is not a function"),

332

(r' ;', "no space before ;"),

332

(r' ;', "no space before ;"),

333

(r'[)][{]', "space between ) and {"),

333

(r'[)][{]', "space between ) and {"),

334

(r'\w+\* \w+', "use int *foo, not int* foo"),

334

(r'\w+\* \w+', "use int *foo, not int* foo"),

335

(r'\W$[^$]+\) \w+', "use (int)foo, not (int) foo"),

335

(r'\W$[^$]+\) \w+', "use (int)foo, not (int) foo"),

336

(r'\w+ (\+\+|--)', "use foo++, not foo ++"),

336

(r'\w+ (\+\+|--)', "use foo++, not foo ++"),

337

(r'\w,\w', "missing whitespace after ,"),

337

(r'\w,\w', "missing whitespace after ,"),

338

(r'^[^#]\w[+/*]\w', "missing whitespace in expression"),

338

(r'^[^#]\w[+/*]\w', "missing whitespace in expression"),

339

(r'^#\s+\w', "use #foo, not # foo"),

339

(r'^#\s+\w', "use #foo, not # foo"),

340

(r'[^\n]\Z', "no trailing newline"),

340

(r'[^\n]\Z', "no trailing newline"),

341

(r'^\s*#import\b', "use only #include in standard C code"),

341

(r'^\s*#import\b', "use only #include in standard C code"),

342

],

342

],

343

# warnings

343

# warnings

344

[]

344

[]

345

]

345

]

346

347

cfilters = [

347

cfilters = [

348

(r'(/\*)(((\*(?!/))|[^*])*)\*/', repccomment),

348

(r'(/\*)(((\*(?!/))|[^*])*)\*/', repccomment),

349

(r'''(?P<quote>(?<!")")(?P<text>([^"]|\\")+)"(?!")''', repquote),

349

(r'''(?P<quote>(?<!")")(?P<text>([^"]|\\")+)"(?!")''', repquote),

350

(r'''(#\s*include\s+<)([^>]+)>''', repinclude),

350

(r'''(#\s*include\s+<)([^>]+)>''', repinclude),

351

(r'($)([^)]+$)', repcallspaces),

351

(r'($)([^)]+$)', repcallspaces),

352

]

352

]

353

354

inutilpats = [

354

inutilpats = [

355

[

355

[

356

(r'\bui\.', "don't use ui in util"),

356

(r'\bui\.', "don't use ui in util"),

357

],

357

],

358

# warnings

358

# warnings

359

[]

359

[]

360

]

360

]

361

362

inrevlogpats = [

362

inrevlogpats = [

363

[

363

[

364

(r'\brepo\.', "don't use repo in revlog"),

364

(r'\brepo\.', "don't use repo in revlog"),

365

],

365

],

366

# warnings

366

# warnings

367

[]

367

[]

368

]

368

]

369

370

checks = [

370

checks = [

371

('python', r'.*\.(py|cgi)$', pyfilters, pypats),

371

('python', r'.*\.(py|cgi)$', pyfilters, pypats),

372

('test script', r'(.*/)?test-[^.~]*$', testfilters, testpats),

372

('test script', r'(.*/)?test-[^.~]*$', testfilters, testpats),

373

('c', r'.*\.[ch]$', cfilters, cpats),

373

('c', r'.*\.[ch]$', cfilters, cpats),

374

('unified test', r'.*\.t$', utestfilters, utestpats),

374

('unified test', r'.*\.t$', utestfilters, utestpats),

375

('layering violation repo in revlog', r'mercurial/revlog\.py', pyfilters,

375

('layering violation repo in revlog', r'mercurial/revlog\.py', pyfilters,

376

inrevlogpats),

376

inrevlogpats),

377

('layering violation ui in util', r'mercurial/util\.py', pyfilters,

377

('layering violation ui in util', r'mercurial/util\.py', pyfilters,

378

inutilpats),

378

inutilpats),

379

('txt', r'.*\.txt$', txtfilters, txtpats),

379

('txt', r'.*\.txt$', txtfilters, txtpats),

380

]

380

]

381

382

def _preparepats():

382

def _preparepats():

383

for c in checks:

383

for c in checks:

384

failandwarn = c[-1]

384

failandwarn = c[-1]

385

for pats in failandwarn:

385

for pats in failandwarn:

386

for i, pseq in enumerate(pats):

386

for i, pseq in enumerate(pats):

387

# fix-up regexes for multi-line searches

387

# fix-up regexes for multi-line searches

388

p = pseq[0]

388

p = pseq[0]

389

# \s doesn't match \n

389

# \s doesn't match \n

390

p = re.sub(r'(?<!\\)\\s', r'[ \\t]', p)

390

p = re.sub(r'(?<!\\)\\s', r'[ \\t]', p)

391

# [^...] doesn't match newline

391

# [^...] doesn't match newline

392

p = re.sub(r'(?<!\\)\[\^', r'[^\\n', p)

392

p = re.sub(r'(?<!\\)\[\^', r'[^\\n', p)

393

394

pats[i] = (re.compile(p, re.MULTILINE),) + pseq[1:]

394

pats[i] = (re.compile(p, re.MULTILINE),) + pseq[1:]

395

filters = c[2]

395

filters = c[2]

396

for i, flt in enumerate(filters):

396

for i, flt in enumerate(filters):

397

filters[i] = re.compile(flt[0]), flt[1]

397

filters[i] = re.compile(flt[0]), flt[1]

398

_preparepats()

398

_preparepats()

399

400

class norepeatlogger(object):

400

class norepeatlogger(object):

401

def __init__(self):

401

def __init__(self):

402

self._lastseen = None

402

self._lastseen = None

403

404

def log(self, fname, lineno, line, msg, blame):

404

def log(self, fname, lineno, line, msg, blame):

405

"""print error related a to given line of a given file.

405

"""print error related a to given line of a given file.

406

407

The faulty line will also be printed but only once in the case

407

The faulty line will also be printed but only once in the case

408

of multiple errors.

408

of multiple errors.

409

410

:fname: filename

410

:fname: filename

411

:lineno: line number

411

:lineno: line number

412

:line: actual content of the line

412

:line: actual content of the line

413

:msg: error message

413

:msg: error message

414

"""

414

"""

415

msgid = fname, lineno, line

415

msgid = fname, lineno, line

416

if msgid != self._lastseen:

416

if msgid != self._lastseen:

417

if blame:

417

if blame:

418

print "%s:%d (%s):" % (fname, lineno, blame)

418

print "%s:%d (%s):" % (fname, lineno, blame)

419

else:

419

else:

420

print "%s:%d:" % (fname, lineno)

420

print "%s:%d:" % (fname, lineno)

421

print " > %s" % line

421

print " > %s" % line

422

self._lastseen = msgid

422

self._lastseen = msgid

423

print " " + msg

423

print " " + msg

424

425

_defaultlogger = norepeatlogger()

425

_defaultlogger = norepeatlogger()

426

427

def getblame(f):

427

def getblame(f):

428

lines = []

428

lines = []

429

for l in os.popen('hg annotate -un %s' % f):

429

for l in os.popen('hg annotate -un %s' % f):

430

start, line = l.split(':', 1)

430

start, line = l.split(':', 1)

431

user, rev = start.split()

431

user, rev = start.split()

432

lines.append((line[1:-1], user, rev))

432

lines.append((line[1:-1], user, rev))

433

return lines

433

return lines

434

435

def checkfile(f, logfunc=_defaultlogger.log, maxerr=None, warnings=False,

435

def checkfile(f, logfunc=_defaultlogger.log, maxerr=None, warnings=False,

436

blame=False, debug=False, lineno=True):

436

blame=False, debug=False, lineno=True):

437

"""checks style and portability of a given file

437

"""checks style and portability of a given file

438

439

:f: filepath

439

:f: filepath

440

:logfunc: function used to report error

440

:logfunc: function used to report error

441

logfunc(filename, linenumber, linecontent, errormessage)

441

logfunc(filename, linenumber, linecontent, errormessage)

442

:maxerr: number of error to display before aborting.

442

:maxerr: number of error to display before aborting.

443

Set to false (default) to report all errors

443

Set to false (default) to report all errors

444

445

return True if no error is found, False otherwise.

445

return True if no error is found, False otherwise.

446

"""

446

"""

447

blamecache = None

447

blamecache = None

448

result = True

448

result = True

449

for name, match, filters, pats in checks:

449

for name, match, filters, pats in checks:

450

if debug:

450

if debug:

451

print name, f

451

print name, f

452

fc = 0

452

fc = 0

453

if not re.match(match, f):

453

if not re.match(match, f):

454

if debug:

454

if debug:

455

print "Skipping %s for %s it doesn't match %s" % (

455

print "Skipping %s for %s it doesn't match %s" % (

456

name, match, f)

456

name, match, f)

457

continue

457

continue

458

try:

458

try:

459

fp = open(f)

459

fp = open(f)

460

except IOError, e:

460

except IOError, e:

461

print "Skipping %s, %s" % (f, str(e).split(':', 1)[0])

461

print "Skipping %s, %s" % (f, str(e).split(':', 1)[0])

462

continue

462

continue

463

pre = post = fp.read()

463

pre = post = fp.read()

464

fp.close()

464

fp.close()

465

if "no-" "check-code" in pre:

465

if "no-" "check-code" in pre:

466

print "Skipping %s it has no-" "check-code" % f

466

print "Skipping %s it has no-" "check-code" % f

467

return "Skip" # skip checking this file

467

return "Skip" # skip checking this file

468

for p, r in filters:

468

for p, r in filters:

469

post = re.sub(p, r, post)

469

post = re.sub(p, r, post)

470

nerrs = len(pats[0]) # nerr elements are errors

470

nerrs = len(pats[0]) # nerr elements are errors

471

if warnings:

471

if warnings:

472

pats = pats[0] + pats[1]

472

pats = pats[0] + pats[1]

473

else:

473

else:

474

pats = pats[0]

474

pats = pats[0]

475

# print post # uncomment to show filtered version

475

# print post # uncomment to show filtered version

476

477

if debug:

477

if debug:

478

print "Checking %s for %s" % (name, f)

478

print "Checking %s for %s" % (name, f)

479

480

prelines = None

480

prelines = None

481

errors = []

481

errors = []

482

for i, pat in enumerate(pats):

482

for i, pat in enumerate(pats):

483

if len(pat) == 3:

483

if len(pat) == 3:

484

p, msg, ignore = pat

484

p, msg, ignore = pat

485

else:

485

else:

486

p, msg = pat

486

p, msg = pat

487

ignore = None

487

ignore = None

488

if i >= nerrs:

488

if i >= nerrs:

489

msg = "warning: " + msg

489

msg = "warning: " + msg

490

491

pos = 0

491

pos = 0

492

n = 0

492

n = 0

493

for m in p.finditer(post):

493

for m in p.finditer(post):

494

if prelines is None:

494

if prelines is None:

495

prelines = pre.splitlines()

495

prelines = pre.splitlines()

496

postlines = post.splitlines(True)

496

postlines = post.splitlines(True)

497

498

start = m.start()

498

start = m.start()

499

while n < len(postlines):

499

while n < len(postlines):

500

step = len(postlines[n])

500

step = len(postlines[n])

501

if pos + step > start:

501

if pos + step > start:

502

break

502

break

503

pos += step

503

pos += step

504

n += 1

504

n += 1

505

l = prelines[n]

505

l = prelines[n]

506

507

if ignore and re.search(ignore, l, re.MULTILINE):

507

if ignore and re.search(ignore, l, re.MULTILINE):

508

if debug:

508

if debug:

509

print "Skipping %s for %s:%s (ignore pattern)" % (

509

print "Skipping %s for %s:%s (ignore pattern)" % (

510

name, f, n)

510

name, f, n)

511

continue

511

continue

512

bd = ""

512

bd = ""

513

if blame:

513

if blame:

514

bd = 'working directory'

514

bd = 'working directory'

515

if not blamecache:

515

if not blamecache:

516

blamecache = getblame(f)

516

blamecache = getblame(f)

517

if n < len(blamecache):

517

if n < len(blamecache):

518

bl, bu, br = blamecache[n]

518

bl, bu, br = blamecache[n]

519

if bl == l:

519

if bl == l:

520

bd = '%s@%s' % (bu, br)

520

bd = '%s@%s' % (bu, br)

521

522

errors.append((f, lineno and n + 1, l, msg, bd))

522

errors.append((f, lineno and n + 1, l, msg, bd))

523

result = False

523

result = False

524

525

errors.sort()

525

errors.sort()

526

for e in errors:

526

for e in errors:

527

logfunc(*e)

527

logfunc(*e)

528

fc += 1

528

fc += 1

529

if maxerr and fc >= maxerr:

529

if maxerr and fc >= maxerr:

530

print " (too many errors, giving up)"

530

print " (too many errors, giving up)"

531

break

531

break

532

533

return result

533

return result

534

535

if __name__ == "__main__":

535

if __name__ == "__main__":

536

parser = optparse.OptionParser("%prog [options] [files]")

536

parser = optparse.OptionParser("%prog [options] [files]")

537

parser.add_option("-w", "--warnings", action="store_true",

537

parser.add_option("-w", "--warnings", action="store_true",

538

help="include warning-level checks")

538

help="include warning-level checks")

539

parser.add_option("-p", "--per-file", type="int",

539

parser.add_option("-p", "--per-file", type="int",

540

help="max warnings per file")

540

help="max warnings per file")

541

parser.add_option("-b", "--blame", action="store_true",

541

parser.add_option("-b", "--blame", action="store_true",

542

help="use annotate to generate blame info")

542

help="use annotate to generate blame info")

543

parser.add_option("", "--debug", action="store_true",

543

parser.add_option("", "--debug", action="store_true",

544

help="show debug information")

544

help="show debug information")

545

parser.add_option("", "--nolineno", action="store_false",

545

parser.add_option("", "--nolineno", action="store_false",

546

dest='lineno', help="don't show line numbers")

546

dest='lineno', help="don't show line numbers")

547

548

parser.set_defaults(per_file=15, warnings=False, blame=False, debug=False,

548

parser.set_defaults(per_file=15, warnings=False, blame=False, debug=False,

549

lineno=True)

549

lineno=True)

550

(options, args) = parser.parse_args()

550

(options, args) = parser.parse_args()

551

552

if len(args) == 0:

552

if len(args) == 0:

553

check = glob.glob("*")

553

check = glob.glob("*")

554

else:

554

else:

555

check = args

555

check = args

556

557

ret = 0

557

ret = 0

558

for f in check:

558

for f in check:

559

if not checkfile(f, maxerr=options.per_file, warnings=options.warnings,

559

if not checkfile(f, maxerr=options.per_file, warnings=options.warnings,

560

blame=options.blame, debug=options.debug,

560

blame=options.blame, debug=options.debug,

561

lineno=options.lineno):

561

lineno=options.lineno):

562

ret = 1

562

ret = 1

563

sys.exit(ret)

563

sys.exit(ret)

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             #!/usr/bin/env python
             #
             # check-code - a style and portability checker for Mercurial
             #
             # Copyright 2010 Matt Mackall <mpm@selenic.com>
             #
             # This software may be used and distributed according to the terms of the
             # GNU General Public License version 2 or any later version.
             """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
                (you can append a short comment and match this, like: #re-raises, # no-py24)
              * 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
             """
             import re, glob, os, sys
             import keyword
             import optparse
             try:
                 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)
             def repquote(m):
                 fromc = '.:'
                 tochr = 'pq'
                 def encodechr(i):
                     if i > 255:
                         return 'u'
                     c = chr(i)
                     if c in ' \n':
                         return c
                     if c.isalpha():
                         return 'x'
                     if c.isdigit():
                         return 'n'
                     try:
                         return tochr[fromc.find(c)]
                     except (ValueError, IndexError):
                         return 'o'
                 t = m.group('text')
                 tt = ''.join(encodechr(i) for i in xrange(256))
                 t = t.translate(tt)
                 return m.group('quote') + t + m.group('quote')
             def reppython(m):
                 comment = m.group('comment')
                 if comment:
                     l = len(comment.rstrip())
                     return "#" * l + comment[l:]
                 return repquote(m)
             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 = [
               [
                 (r'pushd|popd', "don't use 'pushd' or 'popd', use 'cd'"),
                 (r'\W\$?\(\([^\)\n]*\)\)', "don't use (()) or $(()), use 'expr'"),
                 (r'grep.*-q', "don't use 'grep -q', redirect to /dev/null"),
                 (r'(?<!hg )grep.*-a', "don't use 'grep -a', use in-line python"),
                 (r'sed.*-i', "don't use 'sed -i', use a temporary file"),
                 (r'\becho\b.*\\n', "don't use 'echo \\n', use printf"),
                 (r'echo -n', "don't use 'echo -n', use printf"),
                 (r'(^| )wc[^|]*$\n(?!.*\(re\))', "filter wc output"),
                 (r'head -c', "don't use 'head -c', use 'dd'"),
                 (r'tail -n', "don't use the '-n' option to tail, just use '-<num>'"),
                 (r'sha1sum', "don't use sha1sum, use $TESTDIR/md5sum.py"),
                 (r'ls.*-\w*R', "don't use 'ls -R', use 'find'"),
                 (r'printf.*[^\\]\\([1-9]|0\d)', "don't use 'printf \NNN', use Python"),
                 (r'printf.*[^\\]\\x', "don't use printf \\x, use Python"),
                 (r'\$\(.*\)', "don't use $(expr), use `expr`"),
                 (r'rm -rf \*', "don't use naked rm -rf, target a directory"),
                 (r'(^|\|\s*)grep (-\w\s+)*[^|]*[(|]\w',
                  "use egrep for extended grep syntax"),
                 (r'/bin/', "don't use explicit paths for tools"),
                 (r'[^\n]\Z', "no trailing newline"),
                 (r'export.*=', "don't export and assign at once"),
                 (r'^source\b', "don't use 'source', use '.'"),
                 (r'touch -d', "don't use 'touch -d', use 'touch -t' instead"),
                 (r'ls +[^|\n-]+ +-', "options to 'ls' must come before filenames"),
                 (r'[^>\n]>\s*\$HGRCPATH', "don't overwrite $HGRCPATH, append to it"),
                 (r'^stop\(\)', "don't use 'stop' as a shell function name"),
                 (r'(\[|\btest\b).*-e ', "don't use 'test -e', use 'test -f'"),
                 (r'^alias\b.*=', "don't use alias, use a function"),
                 (r'if\s*!', "don't use '!' to negate exit status"),
                 (r'/dev/u?random', "don't use entropy, use /dev/zero"),
                 (r'do\s*true;\s*done', "don't use true as loop body, use sleep 0"),
                 (r'^( *)\t', "don't use tabs to indent"),
                 (r'sed (-e )?\'(\d+|/[^/]*/)i(?!\\\n)',
                  "put a backslash-escaped newline after sed 'i' command"),
                 (r'^diff *-\w*u.*$\n(^  \$ |^$)', "prefix diff -u with cmp"),
               ],
               # warnings
               [
                 (r'^function', "don't use 'function', use old style"),
                 (r'^diff.*-\w*N', "don't use 'diff -N'"),
                 (r'\$PWD|\${PWD}', "don't use $PWD, use `pwd`"),
                 (r'^([^"\'\n]|("[^"\n]*")|(\'[^\'\n]*\'))*\^', "^ must be quoted"),
                 (r'kill (`|\$\()', "don't use kill, use killdaemons.py")
               ]
             ]
             testfilters = [
                 (r"( *)(#([^\n]*\S)?)", repcomment),
                 (r"<<(\S+)((.|\n)*?\n\1)", rephere),
             ]
             winglobmsg = "use (glob) to match Windows paths too"
             uprefix = r"^  \$ "
             utestpats = [
               [
                 (r'^(\S.*||  [$>] .*)[ \t]\n', "trailing whitespace on non-output"),
                 (uprefix + r'.*\|\s*sed[^|>\n]*\n',
                  "use regex test output patterns instead of sed"),
                 (uprefix + r'(true|exit 0)', "explicit zero exit unnecessary"),
                 (uprefix + r'.*(?<!\[)\$\?', "explicit exit code checks unnecessary"),
                 (uprefix + r'.*\|\| echo.*(fail|error)',
                  "explicit exit code checks unnecessary"),
                 (uprefix + r'set -e', "don't use set -e"),
                 (uprefix + r'(\s|fi\b|done\b)', "use > for continued lines"),
                 (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
                  'hg pull -q file:../test'), # in test-pull.t which is skipped on windows
                 (r'^  saved backup bundle to \$TESTTMP.*\.hg$', winglobmsg),
                 (r'^  changeset .* references (corrupted|missing) \$TESTTMP/.*[^)]$',
                  winglobmsg),
                 (r'^  pulling from \$TESTTMP/.*[^)]$', winglobmsg,
                  '\$TESTTMP/unix-repo$'), # in test-issue1802.t which skipped on windows
                 (r'^  reverting .*/.*[^)]$', winglobmsg),
                 (r'^  cloning subrepo \S+/.*[^)]$', winglobmsg),
                 (r'^  pushing to \$TESTTMP/.*[^)]$', winglobmsg),
                 (r'^  pushing subrepo \S+/\S+ to.*[^)]$', winglobmsg),
                 (r'^  moving \S+/.*[^)]$', winglobmsg),
                 (r'^  no changes made to subrepo since.*/.*[^)]$', winglobmsg),
                 (r'^  .*: largefile \S+ not available from file:.*/.*[^)]$', winglobmsg),
                 (r'^  .*file://\$TESTTMP',
                  'write "file:/*/$TESTTMP" + (glob) to match on windows too'),
               ],
               # warnings
               [
                 (r'^  [^*?/\n]* \(glob\)$',
                  "glob match with no glob character (?*/)"),
               ]
             ]
             for i in [0, 1]:
                 for p, m in testpats[i]:
                     if p.startswith(r'^'):
                         p = r"^  [$>] (%s)" % p[1:]
                     else:
                         p = r"^  [$>] .*(%s)" % p
                     utestpats[i].append((p, m))
             utestfilters = [
                 (r"<<(\S+)((.|\n)*?\n  > \1)", rephere),
                 (r"( *)(#([^\n]*\S)?)", repcomment),
             ]
             pypats = [
               [
                 (r'\([^)]*\*\w[^()]+\w+=', "can't pass varargs with keyword in Py2.5"),
                 (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+"),
                 (r'import (.+,[^.]+\.[^.]+|[^.]+\.[^.]+,)',
                  '2to3 can\'t always rewrite "import qux, foo.bar", '
                  'use "import foo.bar" on its own line instead.'),
                 (r'(?<!def)\s+(cmp)\(', "cmp is not available in Python 3+"),
                 (r'\breduce\s*\(.*', "reduce is not available in Python 3+"),
                 (r'dict\(.*=', 'dict() is different in Py2 and 3 and is slower than {}',
                  'dict-from-generator'),
                 (r'\.has_key\b', "dict.has_key is not available in Python 3+"),
                 (r'\s<>\s', '<> operator is not available in Python 3+, use !='),
                 (r'^\s*\t', "don't use tabs"),
                 (r'\S;\s*\n', "semicolon"),
-                (r'[^_]_\((?:"[^"]+"[ \t\n+]*)+%', "don't use % inside _()"),
+                (r'[^_]_\([ \t\n]*(?:"[^"]+"[ \t\n+]*)+%', "don't use % inside _()"),
-                (r"[^_]_\((?:'[^']+'[ \t\n+]*)+%", "don't use % inside _()"),
+                (r"[^_]_\([ \t\n]*(?:'[^']+'[ \t\n+]*)+%", "don't use % inside _()"),
                 (r'(\w|\)),\w', "missing whitespace after ,"),
                 (r'(\w|\))[+/*\-<>]\w', "missing whitespace in expression"),
                 (r'^\s+(\w|\.)+=\w[^,()\n]*$', "missing whitespace in assignment"),
                 (r'(\s+)try:\n((?:\n|\1\s.*\n)+?)\1except.*?:\n'
                  r'((?:\n|\1\s.*\n)+?)\1finally:', 'no try/except/finally in Python 2.4'),
                 (r'(?<!def)(\s+|^|\()next\(.+\)',
                  'no next(foo) in Python 2.4 and 2.5, use foo.next() instead'),
                 (r'(\s+)try:\n((?:\n|\1\s.*\n)*?)\1\s*yield\b.*?'
                  r'((?:\n|\1\s.*\n)+?)\1finally:',
                  'no yield inside try/finally in Python 2.4'),
                 (r'.{81}', "line too long"),
                 (r' x+[xo][\'"]\n\s+[\'"]x', 'string join across lines with no space'),
                 (r'[^\n]\Z', "no trailing newline"),
                 (r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),
             #    (r'^\s+[^_ \n][^_. \n]+_[^_\n]+\s*=',
             #     "don't use underbars in identifiers"),
                 (r'^\s+(self\.)?[A-za-z][a-z0-9]+[A-Z]\w* = ',
                  "don't use camelcase in identifiers"),
                 (r'^\s*(if|while|def|class|except|try)\s[^[\n]*:\s*[^\\n]#\s]+',
                  "linebreak after :"),
                 (r'class\s[^( \n]+:', "old-style class, use class foo(object)"),
                 (r'class\s[^( \n]+\(\):',
                  "class foo() not available in Python 2.4, use class foo(object)"),
                 (r'\b(%s)\(' % '|'.join(keyword.kwlist),
                  "Python keyword is not a function"),
                 (r',]', "unneeded trailing ',' in list"),
             #    (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"),
                 (r'("\')\.format\(', "str.format() not available in Python 2.4"),
                 (r'^\s*with\s+', "with not available in Python 2.4"),
                 (r'\.isdisjoint\(', "set.isdisjoint not available in Python 2.4"),
                 (r'^\s*except.* as .*:', "except as not available in Python 2.4"),
                 (r'^\s*os\.path\.relpath', "relpath not available in Python 2.4"),
                 (r'(?<!def)\s+(any|all|format)\(',
                  "any/all/format not available in Python 2.4", 'no-py24'),
                 (r'(?<!def)\s+(callable)\(',
                  "callable not available in Python 3, use getattr(f, '__call__', None)"),
                 (r'if\s.*\selse', "if ... else form not available in Python 2.4"),
                 (r'^\s*(%s)\s\s' % '|'.join(keyword.kwlist),
                  "gratuitous whitespace after Python keyword"),
                 (r'([\(\[][ \t]\S)|(\S[ \t][\)\]])', "gratuitous whitespace in () or []"),
             #    (r'\s\s=', "gratuitous whitespace before ="),
                 (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
                  "missing whitespace around operator"),
                 (r'[^>< ](\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\s',
                  "missing whitespace around operator"),
                 (r'\s(\+=|-=|!=|<>|<=|>=|<<=|>>=|%=)\S',
                  "missing whitespace around operator"),
                 (r'[^^+=*/!<>&| %-](\s=|=\s)[^= ]',
                  "wrong whitespace around ="),
                 (r'\([^()]*( =[^=]|[^<>!=]= )',
                  "no whitespace around = for named parameters"),
                 (r'raise Exception', "don't raise generic exceptions"),
                 (r'raise [^,(]+, (\([^\)]+\)|[^,\(\)]+)$',
                  "don't use old-style two-argument raise, use Exception(message)"),
                 (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"),
                 (r'^\s*(while|if) [01]:',
                  "use True/False for constant Boolean expression"),
                 (r'(?:(?<!def)\s+|\()hasattr',
                  'hasattr(foo, bar) is broken, use util.safehasattr(foo, bar) instead'),
                 (r'opener\([^)]*\).read\(',
                  "use opener.read() instead"),
                 (r'BaseException', 'not in Python 2.4, use Exception'),
                 (r'os\.path\.relpath', 'os.path.relpath is not in Python 2.5'),
                 (r'opener\([^)]*\).write\(',
                  "use opener.write() instead"),
                 (r'[\s\(](open|file)\([^)]*\)\.read\(',
                  "use util.readfile() instead"),
                 (r'[\s\(](open|file)\([^)]*\)\.write\(',
                  "use util.writefile() instead"),
                 (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"),
                 (r'(?i)descendent', "the proper spelling is descendAnt"),
                 (r'\.debug\(\_', "don't mark debug messages for translation"),
                 (r'\.strip\(\)\.split\(\)', "no need to strip before splitting"),
                 (r'^\s*except\s*:', "naked except clause", r'#.*re-raises'),
                 (r':\n(    )*( ){1,3}[^ ]', "must indent 4 spaces"),
                 (r'ui\.(status|progress|write|note|warn)\([\'\"]x',
                  "missing _() in ui message (use () to hide false-positives)"),
                 (r'release\(.*wlock, .*lock\)', "wrong lock release order"),
               ],
               # warnings
               [
                 (r'(^| )pp +xxxxqq[ \n][^\n]', "add two newlines after '.. note::'"),
               ]
             ]
             pyfilters = [
                 (r"""(?msx)(?P<comment>\#.*?$)|
                      ((?P<quote>('''|\"\"\"|(?<!')'(?!')|(?<!")"(?!")))
                       (?P<text>(([^\\]|\\.)*?))
                       (?P=quote))""", reppython),
             ]
             txtfilters = []
             txtpats = [
               [
                 ('\s$', 'trailing whitespace'),
                 ('.. note::[ \n][^\n]', 'add two newlines after note::')
               ],
               []
             ]
             cpats = [
               [
                 (r'//', "don't use //-style comments"),
                 (r'^  ', "don't use spaces to indent"),
                 (r'\S\t', "don't use tabs except for indent"),
                 (r'(\S[ \t]+|^[ \t]+)\n', "trailing whitespace"),
                 (r'.{81}', "line too long"),
                 (r'(while|if|do|for)\(', "use space after while/if/do/for"),
                 (r'return\(', "return is not a function"),
                 (r' ;', "no space before ;"),
                 (r'[)][{]', "space between ) and {"),
                 (r'\w+\* \w+', "use int *foo, not int* foo"),
                 (r'\W\([^\)]+\) \w+', "use (int)foo, not (int) foo"),
                 (r'\w+ (\+\+|--)', "use foo++, not foo ++"),
                 (r'\w,\w', "missing whitespace after ,"),
                 (r'^[^#]\w[+/*]\w', "missing whitespace in expression"),
                 (r'^#\s+\w', "use #foo, not # foo"),
                 (r'[^\n]\Z', "no trailing newline"),
                 (r'^\s*#import\b', "use only #include in standard C code"),
               ],
               # warnings
               []
             ]
             cfilters = [
                 (r'(/\*)(((\*(?!/))|[^*])*)\*/', repccomment),
                 (r'''(?P<quote>(?<!")")(?P<text>([^"]|\\")+)"(?!")''', repquote),
                 (r'''(#\s*include\s+<)([^>]+)>''', repinclude),
                 (r'(\()([^)]+\))', repcallspaces),
             ]
             inutilpats = [
               [
                 (r'\bui\.', "don't use ui in util"),
               ],
               # warnings
               []
             ]
             inrevlogpats = [
               [
                 (r'\brepo\.', "don't use repo in revlog"),
               ],
               # warnings
               []
             ]
             checks = [
                 ('python', r'.*\.(py|cgi)$', pyfilters, pypats),
                 ('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,
                  inutilpats),
                 ('txt', r'.*\.txt$', txtfilters, txtpats),
             ]
             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
                             p = pseq[0]
                             # \s doesn't match \n
                             p = re.sub(r'(?<!\\)\\s', r'[ \\t]', p)
                             # [^...] doesn't match newline
                             p = re.sub(r'(?<!\\)\[\^', r'[^\\n', p)
                             pats[i] = (re.compile(p, re.MULTILINE),) + pseq[1:]
                     filters = c[2]
                     for i, flt in enumerate(filters):
                         filters[i] = re.compile(flt[0]), flt[1]
             _preparepats()
             class norepeatlogger(object):
                 def __init__(self):
                     self._lastseen = None
                 def log(self, fname, lineno, line, msg, blame):
                     """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.
                     :fname: filename
                     :lineno: line number
                     :line: actual content of the line
                     :msg: error message
                     """
                     msgid = fname, lineno, line
                     if msgid != self._lastseen:
                         if blame:
                             print "%s:%d (%s):" % (fname, lineno, blame)
                         else:
                             print "%s:%d:" % (fname, lineno)
                         print " > %s" % line
                         self._lastseen = msgid
                     print " " + msg
             _defaultlogger = norepeatlogger()
             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,
                           blame=False, debug=False, lineno=True):
                 """checks style and portability of a given file
                 :f: filepath
                 :logfunc: function used to report error
                           logfunc(filename, linenumber, linecontent, errormessage)
                 :maxerr: number of error to display before aborting.
                          Set to false (default) to report all errors
                 return True if no error is found, False otherwise.
                 """
                 blamecache = None
                 result = True
                 for name, match, filters, pats in checks:
                     if debug:
                         print name, f
                     fc = 0
                     if not re.match(match, f):
                         if debug:
                             print "Skipping %s for %s it doesn't match %s" % (
                                    name, match, f)
                         continue
                     try:
                         fp = open(f)
                     except IOError, e:
                         print "Skipping %s, %s" % (f, str(e).split(':', 1)[0])
                         continue
                     pre = post = fp.read()
                     fp.close()
                     if "no-" "check-code" in pre:
                         print "Skipping %s it has no-" "check-code" % f
                         return "Skip" # skip checking this file
                     for p, r in filters:
                         post = re.sub(p, r, post)
                     nerrs = len(pats[0]) # nerr elements are errors
                     if warnings:
                         pats = pats[0] + pats[1]
                     else:
                         pats = pats[0]
                     # print post # uncomment to show filtered version
                     if debug:
                         print "Checking %s for %s" % (name, f)
                     prelines = None
                     errors = []
                     for i, pat in enumerate(pats):
                         if len(pat) == 3:
                             p, msg, ignore = pat
                         else:
                             p, msg = pat
                             ignore = None
                         if i >= nerrs:
                             msg = "warning: " + msg
                         pos = 0
                         n = 0
                         for m in p.finditer(post):
                             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]
                             if ignore and re.search(ignore, l, re.MULTILINE):
                                 if debug:
                                     print "Skipping %s for %s:%s (ignore pattern)" % (
                                         name, f, n)
                                 continue
                             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)
                             errors.append((f, lineno and n + 1, l, msg, bd))
                             result = False
                     errors.sort()
                     for e in errors:
                         logfunc(*e)
                         fc += 1
                         if maxerr and fc >= maxerr:
                             print " (too many errors, giving up)"
                             break
                 return result
             if __name__ == "__main__":
                 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")
                 parser.add_option("-b", "--blame", action="store_true",
                                   help="use annotate to generate blame info")
                 parser.add_option("", "--debug", action="store_true",
                                   help="show debug information")
                 parser.add_option("", "--nolineno", action="store_false",
                                   dest='lineno', help="don't show line numbers")
                 parser.set_defaults(per_file=15, warnings=False, blame=False, debug=False,
                                     lineno=True)
                 (options, args) = parser.parse_args()
                 if len(args) == 0:
                     check = glob.glob("*")
                 else:
                     check = args
                 ret = 0
                 for f in check:
                     if not checkfile(f, maxerr=options.per_file, warnings=options.warnings,
                                      blame=options.blame, debug=options.debug,
                                      lineno=options.lineno):
                         ret = 1
                 sys.exit(ret)

               $ cat > correct.py <<EOF
               > def toto(arg1, arg2):
               >     del arg2
               >     return (5 + 6, 9)
               > EOF
               $ cat > wrong.py <<EOF
               > def toto( arg1, arg2):
               >     del(arg2)
               >     return ( 5+6, 9)
               > EOF
               $ cat > quote.py <<EOF
               > # let's use quote in comments
               > (''' ( 4x5 )
               > but """\\''' and finally''',
               > """let's fool checkpatch""", '1+2',
               > '"""', 42+1, """and
               > ( 4-1 ) """, "( 1+1 )\" and ")
               > a, '\\\\\\\\', "\\\\\\" x-2", "c-1"
               > EOF
               $ cat > non-py24.py <<EOF
               > # Using builtins that does not exist in Python 2.4
               > if any():
               >     x = all()
               >     y = format(x)
               >     # next(generator) is new in 2.6
               >     z = next(x)
               >     # but generator.next() is okay
               >     x.next()
               >     # and we can make our own next
               >     def next(stuff):
               >         pass
               >
               > # Do not complain about our own definition
               > def any(x):
               >     pass
               >
               > # try/except/finally block does not exist in Python 2.4
               >     try:
               >         pass
               >     except StandardError, inst:
               >         pass
               >     finally:
               >         pass
               >
               > # nested try/finally+try/except is allowed
               >     try:
               >         try:
               >             pass
               >         except StandardError, inst:
               >             pass
               >     finally:
               >         pass
               >
               > # yield inside a try/finally block is not allowed in Python 2.4
               >     try:
               >         pass
               >         yield 1
               >     finally:
               >         pass
               >     try:
               >         yield
               >         pass
               >     finally:
               >         pass
               >
               > EOF
               $ cat > classstyle.py <<EOF
               > class newstyle_class(object):
               >     pass
               >
               > class oldstyle_class:
               >     pass
               >
               > class empty():
               >     pass
               >
               > no_class = 1:
               >     pass
               > EOF
               $ check_code="$TESTDIR"/../contrib/check-code.py
               $ "$check_code" ./wrong.py ./correct.py ./quote.py ./non-py24.py ./classstyle.py
               ./wrong.py:1:
                > def toto( arg1, arg2):
                gratuitous whitespace in () or []
               ./wrong.py:2:
                >     del(arg2)
                Python keyword is not a function
               ./wrong.py:3:
                >     return ( 5+6, 9)
                gratuitous whitespace in () or []
                missing whitespace in expression
               ./quote.py:5:
                > '"""', 42+1, """and
                missing whitespace in expression
               ./non-py24.py:2:
                > if any():
                any/all/format not available in Python 2.4
               ./non-py24.py:3:
                >     x = all()
                any/all/format not available in Python 2.4
               ./non-py24.py:4:
                >     y = format(x)
                any/all/format not available in Python 2.4
               ./non-py24.py:6:
                >     z = next(x)
                no next(foo) in Python 2.4 and 2.5, use foo.next() instead
               ./non-py24.py:18:
                >     try:
                no try/except/finally in Python 2.4
               ./non-py24.py:35:
                >     try:
                no yield inside try/finally in Python 2.4
               ./non-py24.py:40:
                >     try:
                no yield inside try/finally in Python 2.4
               ./classstyle.py:4:
                > class oldstyle_class:
                old-style class, use class foo(object)
               ./classstyle.py:7:
                > class empty():
                class foo() not available in Python 2.4, use class foo(object)
               [1]
               $ cat > python3-compat.py << EOF
               > foo <> bar
               > reduce(lambda a, b: a + b, [1, 2, 3, 4])
               > dict(key=value)
               > EOF
               $ "$check_code" python3-compat.py
               python3-compat.py:1:
                > foo <> bar
                <> operator is not available in Python 3+, use !=
               python3-compat.py:2:
                > reduce(lambda a, b: a + b, [1, 2, 3, 4])
                reduce is not available in Python 3+
               python3-compat.py:3:
                > dict(key=value)
                dict() is different in Py2 and 3 and is slower than {}
               [1]
               $ cat > is-op.py <<EOF
               > # is-operator comparing number or string literal
               > x = None
               > y = x is 'foo'
               > y = x is "foo"
               > y = x is 5346
               > y = x is -6
               > y = x is not 'foo'
               > y = x is not "foo"
               > y = x is not 5346
               > y = x is not -6
               > EOF
               $ "$check_code" ./is-op.py
               ./is-op.py:3:
                > y = x is 'foo'
                object comparison with literal
               ./is-op.py:4:
                > y = x is "foo"
                object comparison with literal
               ./is-op.py:5:
                > y = x is 5346
                object comparison with literal
               ./is-op.py:6:
                > y = x is -6
                object comparison with literal
               ./is-op.py:7:
                > y = x is not 'foo'
                object comparison with literal
               ./is-op.py:8:
                > y = x is not "foo"
                object comparison with literal
               ./is-op.py:9:
                > y = x is not 5346
                object comparison with literal
               ./is-op.py:10:
                > y = x is not -6
                object comparison with literal
               [1]
               $ cat > for-nolineno.py <<EOF
               > except:
               > EOF
               $ "$check_code" for-nolineno.py --nolineno
               for-nolineno.py:0:
                > except:
                naked except clause
               [1]
               $ cat > warning.t <<EOF
               >   $ function warnonly {
               >   > }
               >   $ diff -N aaa
               >   $ function onwarn {}
               > EOF
               $ "$check_code" warning.t
               $ "$check_code" --warn warning.t
               warning.t:1:
                >   $ function warnonly {
                warning: don't use 'function', use old style
               warning.t:3:
                >   $ diff -N aaa
                warning: don't use 'diff -N'
               warning.t:4:
                >   $ function onwarn {}
                warning: don't use 'function', use old style
               [1]
               $ cat > raise-format.py <<EOF
               > raise SomeException, message
               > # this next line is okay
               > raise SomeException(arg1, arg2)
               > EOF
               $ "$check_code" not-existing.py raise-format.py
               Skipping*not-existing.py* (glob)
               raise-format.py:1:
                > raise SomeException, message
                don't use old-style two-argument raise, use Exception(message)
               [1]
               $ cat > rst.py <<EOF
               > """problematic rst text
               >
               > .. note::
               >     wrong
               > """
               >
               > '''
               >
               > .. note::
               >
               >     valid
               >
               > new text
               >
               >     .. note::
               >
               >         also valid
               > '''
               >
               > """mixed
               >
               > .. note::
               >
               >   good
               >
               >     .. note::
               >         plus bad
               > """
               > EOF
               $ $check_code -w rst.py
               rst.py:3:
                > .. note::
                warning: add two newlines after '.. note::'
               rst.py:26:
                >     .. note::
                warning: add two newlines after '.. note::'
               [1]
+              $ cat > ./map-inside-gettext.py <<EOF
+              > print _("map inside gettext %s" % v)
+              >
+              > print _("concatenating " " by " " space %s" % v)
+              > print _("concatenating " + " by " + " '+' %s" % v)
+              >
+              > print _("maping operation in different line %s"
+              >         % v)
+              >
+              > print _(
+              >         "leading spaces inside of '(' %s" % v)
+              > EOF
+              $ "$check_code" ./map-inside-gettext.py
+              ./map-inside-gettext.py:1:
+               > print _("map inside gettext %s" % v)
+               don't use % inside _()
+              ./map-inside-gettext.py:3:
+               > print _("concatenating " " by " " space %s" % v)
+               don't use % inside _()
+              ./map-inside-gettext.py:4:
+               > print _("concatenating " + " by " + " '+' %s" % v)
+               don't use % inside _()
+              ./map-inside-gettext.py:6:
+               > print _("maping operation in different line %s"
+               don't use % inside _()
+              ./map-inside-gettext.py:9:
+               > print _(
+               don't use % inside _()
+              [1]