upstream/mercurial-mirror Commit - r20005:22154ec6

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

import re, glob, os, sys

10

import re, glob, os, sys

11

import keyword

11

import keyword

12

import optparse

12

import optparse

13

try:

13

try:

14

import re2

14

import re2

15

except ImportError:

15

except ImportError:

16

re2 = None

16

re2 = None

17

18

def compilere(pat, multiline=False):

18

def compilere(pat, multiline=False):

19

if multiline:

19

if multiline:

20

pat = '(?m)' + pat

20

pat = '(?m)' + pat

21

if re2:

21

if re2:

22

try:

22

try:

23

return re2.compile(pat)

23

return re2.compile(pat)

24

except re2.error:

24

except re2.error:

25

pass

25

pass

26

return re.compile(pat)

26

return re.compile(pat)

27

28

def repquote(m):

28

def repquote(m):

29

fromc = '.:'

29

fromc = '.:'

30

tochr = 'pq'

30

tochr = 'pq'

31

def encodechr(i):

31

def encodechr(i):

32

if i > 255:

32

if i > 255:

33

return 'u'

33

return 'u'

34

c = chr(i)

34

c = chr(i)

35

if c in ' \n':

35

if c in ' \n':

36

return c

36

return c

37

if c.isalpha():

37

if c.isalpha():

38

return 'x'

38

return 'x'

39

if c.isdigit():

39

if c.isdigit():

40

return 'n'

40

return 'n'

41

try:

41

try:

42

return tochr[fromc.find(c)]

42

return tochr[fromc.find(c)]

43

except (ValueError, IndexError):

43

except (ValueError, IndexError):

44

return 'o'

44

return 'o'

45

t = m.group('text')

45

t = m.group('text')

46

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

46

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

47

t = t.translate(tt)

47

t = t.translate(tt)

48

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

48

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

49

50

def reppython(m):

50

def reppython(m):

51

comment = m.group('comment')

51

comment = m.group('comment')

52

if comment:

52

if comment:

53

l = len(comment.rstrip())

53

l = len(comment.rstrip())

54

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

54

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

55

return repquote(m)

55

return repquote(m)

56

57

def repcomment(m):

57

def repcomment(m):

58

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

58

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

59

60

def repccomment(m):

60

def repccomment(m):

61

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

61

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

62

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

62

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

63

64

def repcallspaces(m):

64

def repcallspaces(m):

65

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

65

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

66

return m.group(1) + t

66

return m.group(1) + t

67

68

def repinclude(m):

68

def repinclude(m):

69

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

69

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

70

71

def rephere(m):

71

def rephere(m):

72

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

72

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

73

return m.group(1) + t

73

return m.group(1) + t

74

75

76

testpats = [

76

testpats = [

77

[

77

[

78

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

78

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

79

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

79

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

80

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

80

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

81

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

81

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

82

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

82

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

83

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

83

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

84

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

84

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

85

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

85

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

86

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

86

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

87

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

87

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

88

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

88

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

89

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

89

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

90

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

90

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

91

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

91

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

92

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

92

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

93

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

93

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

94

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

94

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

95

"use egrep for extended grep syntax"),

95

"use egrep for extended grep syntax"),

96

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

96

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

97

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

97

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

98

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

98

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

99

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

99

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

100

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

100

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

101

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

101

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

102

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

102

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

103

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

103

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

104

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

104

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

105

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

105

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

106

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

106

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

107

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

107

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

108

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

108

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

109

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

109

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

110

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

110

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

111

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

111

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

112

],

112

],

113

# warnings

113

# warnings

114

[

114

[

115

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

115

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

116

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

116

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

117

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

117

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

118

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

118

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

119

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

119

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

120

]

120

]

121

]

121

]

122

123

testfilters = [

123

testfilters = [

124

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

124

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

125

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

125

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

126

]

126

]

127

128

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

128

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

129

uprefix = r"^ \$ "

129

uprefix = r"^ \$ "

130

utestpats = [

130

utestpats = [

131

[

131

[

132

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

132

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

133

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

133

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

134

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

134

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

135

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

135

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

136

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

136

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

137

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

137

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

138

"explicit exit code checks unnecessary"),

138

"explicit exit code checks unnecessary"),

139

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

139

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

140

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

140

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

141

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

141

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

142

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

142

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

143

winglobmsg),

143

winglobmsg),

144

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

144

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

145

(r'^ reverting .*/.*[^)]$', winglobmsg, '\$TESTTMP/unix-repo$'),

145

(r'^ reverting .*/.*[^)]$', winglobmsg, '\$TESTTMP/unix-repo$'),

146

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

146

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

147

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

147

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

148

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

148

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

149

'\$TESTTMP/unix-repo$'),

149

'\$TESTTMP/unix-repo$'),

150

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

150

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

151

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

151

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

152

winglobmsg, '\$TESTTMP/unix-repo$'),

152

winglobmsg, '\$TESTTMP/unix-repo$'),

153

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

153

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

154

winglobmsg, '\$TESTTMP/unix-repo$'),

154

winglobmsg, '\$TESTTMP/unix-repo$'),

155

],

155

],

156

# warnings

156

# warnings

157

[

157

[

158

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

158

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

159

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

159

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

160

]

160

]

161

]

161

]

162

163

for i in [0, 1]:

163

for i in [0, 1]:

164

for p, m in testpats[i]:

164

for p, m in testpats[i]:

165

if p.startswith(r'^'):

165

if p.startswith(r'^'):

166

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

166

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

167

else:

167

else:

168

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

168

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

169

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

169

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

170

171

utestfilters = [

171

utestfilters = [

172

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

172

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

173

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

173

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

174

]

174

]

175

176

pypats = [

176

pypats = [

177

[

177

[

178

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

178

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

179

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

179

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

180

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

180

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

181

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

181

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

182

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

182

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

183

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

183

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

184

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

184

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

185

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

185

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

186

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

186

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

187

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

187

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

188

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

188

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

189

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

189

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

190

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

190

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

191

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

191

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

192

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

192

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

193

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

193

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

194

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

194

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

195

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

195

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

196

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

196

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

197

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

197

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

198

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

198

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

199

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

199

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

200

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

200

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

201

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

201

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

202

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

202

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

203

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

203

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

204

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

204

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

205

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

205

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

206

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

206

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

207

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

207

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

208

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

208

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

209

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

209

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

210

"don't use camelcase in identifiers"),

210

"don't use camelcase in identifiers"),

211

211

212

"linebreak after :"),

212

"linebreak after :"),

213

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

213

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

214

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

214

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

215

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

215

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

216

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

216

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

217

"Python keyword is not a function"),

217

"Python keyword is not a function"),

218

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

218

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

219

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

219

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

220

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

220

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

221

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

221

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

222

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

222

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

223

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

223

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

224

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

224

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

225

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

225

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

226

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

226

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

227

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

227

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

228

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

228

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

229

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

229

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

230

"any/all/format not available in Python 2.4"),

230

"any/all/format not available in Python 2.4"),

231

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

231

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

232

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

232

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

233

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

233

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

234

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

234

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

235

"gratuitous whitespace after Python keyword"),

235

"gratuitous whitespace after Python keyword"),

236

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

236

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

237

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

237

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

238

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

238

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

239

"missing whitespace around operator"),

239

"missing whitespace around operator"),

240

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

240

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

241

"missing whitespace around operator"),

241

"missing whitespace around operator"),

242

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

242

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

243

"missing whitespace around operator"),

243

"missing whitespace around operator"),

244

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

244

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

245

"wrong whitespace around ="),

245

"wrong whitespace around ="),

246

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

246

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

247

"no whitespace around = for named parameters"),

247

"no whitespace around = for named parameters"),

248

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

248

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

249

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

249

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

250

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

250

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

251

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

251

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

252

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

252

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

253

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

253

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

254

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

254

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

255

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

255

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

256

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

256

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

257

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

257

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

258

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

258

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

259

"use opener.read() instead"),

259

"use opener.read() instead"),

260

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

260

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

261

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

261

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

262

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

262

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

263

"use opener.write() instead"),

263

"use opener.write() instead"),

264

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

264

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

265

"use util.readfile() instead"),

265

"use util.readfile() instead"),

266

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

266

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

267

"use util.readfile() instead"),

267

"use util.readfile() instead"),

268

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

268

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

269

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

269

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

270

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

270

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

271

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

271

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

272

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

272

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

273

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

273

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

274

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

274

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

275

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

275

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

276

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

276

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

277

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

277

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

278

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

278

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

279

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

279

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

280

],

280

],

281

# warnings

281

# warnings

282

[

282

[

283

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

283

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

284

]

284

]

285

]

285

]

286

287

pyfilters = [

287

pyfilters = [

288

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

288

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

289

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

289

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

290

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

290

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

291

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

291

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

292

]

292

]

293

294

txtfilters = []

294

txtfilters = []

295

296

txtpats = [

296

txtpats = [

297

[

297

[

298

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

298

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

299

],

299

],

300

[]

300

[]

301

]

301

]

302

303

cpats = [

303

cpats = [

304

[

304

[

305

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

305

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

306

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

306

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

307

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

307

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

308

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

308

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

309

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

309

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

310

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

310

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

311

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

311

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

312

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

312

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

313

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

313

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

314

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

314

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

315

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

315

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

316

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

316

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

317

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

317

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

318

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

318

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

319

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

319

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

320

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

320

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

321

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

321

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

322

],

322

],

323

# warnings

323

# warnings

324

[]

324

[]

325

]

325

]

326

327

cfilters = [

327

cfilters = [

328

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

328

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

329

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

329

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

330

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

330

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

331

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

331

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

332

]

332

]

333

334

inutilpats = [

334

inutilpats = [

335

[

335

[

336

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

336

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

337

],

337

],

338

# warnings

338

# warnings

339

[]

339

[]

340

]

340

]

341

342

inrevlogpats = [

342

inrevlogpats = [

343

[

343

[

344

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

344

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

345

],

345

],

346

# warnings

346

# warnings

347

[]

347

[]

348

]

348

]

349

350

checks = [

350

checks = [

351

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

351

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

352

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

352

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

353

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

353

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

354

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

354

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

355

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

355

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

356

inrevlogpats),

356

inrevlogpats),

357

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

357

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

358

inutilpats),

358

inutilpats),

359

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

359

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

360

]

360

]

361

362

def _preparepats():

362

def _preparepats():

363

for c in checks:

363

for c in checks:

364

failandwarn = c[-1]

364

failandwarn = c[-1]

365

for pats in failandwarn:

365

for pats in failandwarn:

366

for i, pseq in enumerate(pats):

366

for i, pseq in enumerate(pats):

367

# fix-up regexes for multi-line searches

367

# fix-up regexes for multi-line searches

368

p = pseq[0]

368

p = pseq[0]

369

# \s doesn't match \n

369

# \s doesn't match \n

370

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

370

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

371

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

371

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

372

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

372

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

373

374

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

374

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

375

filters = c[2]

375

filters = c[2]

376

for i, flt in enumerate(filters):

376

for i, flt in enumerate(filters):

377

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

377

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

378

_preparepats()

378

_preparepats()

379

380

class norepeatlogger(object):

380

class norepeatlogger(object):

381

def __init__(self):

381

def __init__(self):

382

self._lastseen = None

382

self._lastseen = None

383

384

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

384

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

385

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

385

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

386

387

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

387

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

388

of multiple errors.

388

of multiple errors.

389

390

:fname: filename

390

:fname: filename

391

:lineno: line number

391

:lineno: line number

392

:line: actual content of the line

392

:line: actual content of the line

393

:msg: error message

393

:msg: error message

394

"""

394

"""

395

msgid = fname, lineno, line

395

msgid = fname, lineno, line

396

if msgid != self._lastseen:

396

if msgid != self._lastseen:

397

if blame:

397

if blame:

398

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

398

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

399

else:

399

else:

400

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

400

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

401

print " > %s" % line

401

print " > %s" % line

402

self._lastseen = msgid

402

self._lastseen = msgid

403

print " " + msg

403

print " " + msg

404

405

_defaultlogger = norepeatlogger()

405

_defaultlogger = norepeatlogger()

406

407

def getblame(f):

407

def getblame(f):

408

lines = []

408

lines = []

409

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

409

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

410

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

410

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

411

user, rev = start.split()

411

user, rev = start.split()

412

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

412

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

413

return lines

413

return lines

414

415

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

415

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

416

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

416

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

417

"""checks style and portability of a given file

417

"""checks style and portability of a given file

418

419

:f: filepath

419

:f: filepath

420

:logfunc: function used to report error

420

:logfunc: function used to report error

421

logfunc(filename, linenumber, linecontent, errormessage)

421

logfunc(filename, linenumber, linecontent, errormessage)

422

:maxerr: number of error to display before aborting.

422

:maxerr: number of error to display before aborting.

423

Set to false (default) to report all errors

423

Set to false (default) to report all errors

424

425

return True if no error is found, False otherwise.

425

return True if no error is found, False otherwise.

426

"""

426

"""

427

blamecache = None

427

blamecache = None

428

result = True

428

result = True

429

for name, match, filters, pats in checks:

429

for name, match, filters, pats in checks:

430

if debug:

430

if debug:

431

print name, f

431

print name, f

432

fc = 0

432

fc = 0

433

if not re.match(match, f):

433

if not re.match(match, f):

434

if debug:

434

if debug:

435

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

435

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

436

name, match, f)

436

name, match, f)

437

continue

437

continue

438

try:

438

try:

439

fp = open(f)

439

fp = open(f)

440

except IOError, e:

440

except IOError, e:

441

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

441

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

442

continue

442

continue

443

pre = post = fp.read()

443

pre = post = fp.read()

444

fp.close()

444

fp.close()

445

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

445

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

446

if debug:

446

if debug:

447

print "Skipping %s for %s it has no-" "check-code" % (

447

print "Skipping %s for %s it has no-" "check-code" % (

448

name, f)

448

name, f)

449

break

449

break

450

for p, r in filters:

450

for p, r in filters:

451

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

451

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

452

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

452

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

453

if warnings:

453

if warnings:

454

pats = pats[0] + pats[1]

454

pats = pats[0] + pats[1]

455

else:

455

else:

456

pats = pats[0]

456

pats = pats[0]

457

# print post # uncomment to show filtered version

457

# print post # uncomment to show filtered version

458

459

if debug:

459

if debug:

460

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

460

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

461

462

prelines = None

462

prelines = None

463

errors = []

463

errors = []

464

for i, pat in enumerate(pats):

464

for i, pat in enumerate(pats):

465

if len(pat) == 3:

465

if len(pat) == 3:

466

p, msg, ignore = pat

466

p, msg, ignore = pat

467

else:

467

else:

468

p, msg = pat

468

p, msg = pat

469

ignore = None

469

ignore = None

470

if i >= nerrs:

471

msg = "warning: " + msg

470

472

471

pos = 0

473

pos = 0

472

n = 0

474

n = 0

473

for m in p.finditer(post):

475

for m in p.finditer(post):

474

if prelines is None:

476

if prelines is None:

475

prelines = pre.splitlines()

477

prelines = pre.splitlines()

476

postlines = post.splitlines(True)

478

postlines = post.splitlines(True)

477

479

478

start = m.start()

480

start = m.start()

479

while n < len(postlines):

481

while n < len(postlines):

480

step = len(postlines[n])

482

step = len(postlines[n])

481

if pos + step > start:

483

if pos + step > start:

482

break

484

break

483

pos += step

485

pos += step

484

n += 1

486

n += 1

485

l = prelines[n]

487

l = prelines[n]

486

488

487

if "check-code" "-ignore" in l:

489

if "check-code" "-ignore" in l:

488

if debug:

490

if debug:

489

print "Skipping %s for %s:%s (check-code" "-ignore)" % (

491

print "Skipping %s for %s:%s (check-code" "-ignore)" % (

490

name, f, n)

492

name, f, n)

491

continue

493

continue

492

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

494

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

493

continue

495

continue

494

bd = ""

496

bd = ""

495

if blame:

497

if blame:

496

bd = 'working directory'

498

bd = 'working directory'

497

if not blamecache:

499

if not blamecache:

498

blamecache = getblame(f)

500

blamecache = getblame(f)

499

if n < len(blamecache):

501

if n < len(blamecache):

500

bl, bu, br = blamecache[n]

502

bl, bu, br = blamecache[n]

501

if bl == l:

503

if bl == l:

502

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

504

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

503

if i >= nerrs:

505

504

msg = "warning: " + msg

505

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

506

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

506

result = False

507

result = False

507

508

errors.sort()

509

errors.sort()

509

for e in errors:

510

for e in errors:

510

logfunc(*e)

511

logfunc(*e)

511

fc += 1

512

fc += 1

512

if maxerr and fc >= maxerr:

513

if maxerr and fc >= maxerr:

513

print " (too many errors, giving up)"

514

print " (too many errors, giving up)"

514

break

515

break

515

516

return result

517

return result

517

518

if __name__ == "__main__":

519

if __name__ == "__main__":

519

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

520

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

520

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

521

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

521

help="include warning-level checks")

522

help="include warning-level checks")

522

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

523

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

523

help="max warnings per file")

524

help="max warnings per file")

524

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

525

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

525

help="use annotate to generate blame info")

526

help="use annotate to generate blame info")

526

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

527

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

527

help="show debug information")

528

help="show debug information")

528

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

529

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

529

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

530

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

530

531

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

532

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

532

lineno=True)

533

lineno=True)

533

(options, args) = parser.parse_args()

534

(options, args) = parser.parse_args()

534

535

if len(args) == 0:

536

if len(args) == 0:

536

check = glob.glob("*")

537

check = glob.glob("*")

537

else:

538

else:

538

check = args

539

check = args

539

540

ret = 0

541

ret = 0

541

for f in check:

542

for f in check:

542

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

543

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

543

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

544

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

544

lineno=options.lineno):

545

lineno=options.lineno):

545

ret = 1

546

ret = 1

546

sys.exit(ret)

547

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.
             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"),
               ],
               # 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"),
                 (r'^  saved backup bundle to \$TESTTMP.*\.hg$', winglobmsg),
                 (r'^  changeset .* references (corrupted|missing) \$TESTTMP/.*[^)]$',
                  winglobmsg),
                 (r'^  pulling from \$TESTTMP/.*[^)]$', winglobmsg, '\$TESTTMP/unix-repo$'),
                 (r'^  reverting .*/.*[^)]$', winglobmsg, '\$TESTTMP/unix-repo$'),
                 (r'^  cloning subrepo \S+/.*[^)]$', winglobmsg, '\$TESTTMP/unix-repo$'),
                 (r'^  pushing to \$TESTTMP/.*[^)]$', winglobmsg, '\$TESTTMP/unix-repo$'),
                 (r'^  pushing subrepo \S+/\S+ to.*[^)]$', winglobmsg,
                  '\$TESTTMP/unix-repo$'),
                 (r'^  moving \S+/.*[^)]$', winglobmsg),
                 (r'^  no changes made to subrepo since.*/.*[^)]$',
                  winglobmsg, '\$TESTTMP/unix-repo$'),
                 (r'^  .*: largefile \S+ not available from file:.*/.*[^)]$',
                  winglobmsg, '\$TESTTMP/unix-repo$'),
               ],
               # 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'^\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'\.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'[^_]_\("[^"]+"\s*%', "don't use % inside _()"),
                 (r"[^_]_\('[^']+'\s*%", "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"),
                 (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.readfile() 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'),
               ],
               []
             ]
             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:
                         if debug:
                             print "Skipping %s for %s it has no-" "check-code" % (
                                    name, f)
                         break
                     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 "check-code" "-ignore" in l:
                                 if debug:
                                     print "Skipping %s for %s:%s (check-code" "-ignore)" % (
                                         name, f, n)
                                 continue
                             elif ignore and re.search(ignore, l, re.MULTILINE):
                                 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)
-                            if i >= nerrs:
-                                msg = "warning: " + msg
                             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])
               > 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+
               [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]