1 #! /usr/bin/env python 2 3 """The Tab Nanny despises ambiguous indentation. She knows no mercy. 4 5 tabnanny -- Detection of ambiguous indentation 6 7 For the time being this module is intended to be called as a script. 8 However it is possible to import it into an IDE and use the function 9 check() described below. 10 11 Warning: The API provided by this module is likely to change in future 12 releases; such changes may not be backward compatible. 13 """ 14 15 # Released to the public domain, by Tim Peters, 15 April 1998. 16 17 # XXX Note: this is now a standard library module. 18 # XXX The API needs to undergo changes however; the current code is too 19 # XXX script-like. This will be addressed later. 20 21 __version__ = "6" 22 23 import os 24 import sys 25 import getopt 26 import tokenize 27 if not hasattr(tokenize, 'NL'): 28 raise ValueError("tokenize.NL doesn't exist -- tokenize module too old") 29 30 __all__ = ["check", "NannyNag", "process_tokens"] 31 32 verbose = 0 33 filename_only = 0 34 35 def errprint(*args): 36 sep = "" 37 for arg in args: 38 sys.stderr.write(sep + str(arg)) 39 sep = " " 40 sys.stderr.write("\n") 41 42 def main(): 43 global verbose, filename_only 44 try: 45 opts, args = getopt.getopt(sys.argv[1:], "qv") 46 except getopt.error, msg: 47 errprint(msg) 48 return 49 for o, a in opts: 50 if o == '-q': 51 filename_only = filename_only + 1 52 if o == '-v': 53 verbose = verbose + 1 54 if not args: 55 errprint("Usage:", sys.argv[0], "[-v] file_or_directory ...") 56 return 57 for arg in args: 58 check(arg) 59 60 class NannyNag(Exception): 61 """ 62 Raised by tokeneater() if detecting an ambiguous indent. 63 Captured and handled in check(). 64 """ 65 def __init__(self, lineno, msg, line): 66 self.lineno, self.msg, self.line = lineno, msg, line 67 def get_lineno(self): 68 return self.lineno 69 def get_msg(self): 70 return self.msg 71 def get_line(self): 72 return self.line 73 74 def check(file): 75 """check(file_or_dir) 76 77 If file_or_dir is a directory and not a symbolic link, then recursively 78 descend the directory tree named by file_or_dir, checking all .py files 79 along the way. If file_or_dir is an ordinary Python source file, it is 80 checked for whitespace related problems. The diagnostic messages are 81 written to standard output using the print statement. 82 """ 83 84 if os.path.isdir(file) and not os.path.islink(file): 85 if verbose: 86 print "%r: listing directory" % (file,) 87 names = os.listdir(file) 88 for name in names: 89 fullname = os.path.join(file, name) 90 if (os.path.isdir(fullname) and 91 not os.path.islink(fullname) or 92 os.path.normcase(name[-3:]) == ".py"): 93 check(fullname) 94 return 95 96 try: 97 f = open(file) 98 except IOError, msg: 99 errprint("%r: I/O Error: %s" % (file, msg)) 100 return 101 102 if verbose > 1: 103 print "checking %r ..." % file 104 105 try: 106 process_tokens(tokenize.generate_tokens(f.readline)) 107 108 except tokenize.TokenError, msg: 109 errprint("%r: Token Error: %s" % (file, msg)) 110 return 111 112 except IndentationError, msg: 113 errprint("%r: Indentation Error: %s" % (file, msg)) 114 return 115 116 except NannyNag, nag: 117 badline = nag.get_lineno() 118 line = nag.get_line() 119 if verbose: 120 print "%r: *** Line %d: trouble in tab city! ***" % (file, badline) 121 print "offending line: %r" % (line,) 122 print nag.get_msg() 123 else: 124 if ' ' in file: file = '"' + file + '"' 125 if filename_only: print file 126 else: print file, badline, repr(line) 127 return 128 129 if verbose: 130 print "%r: Clean bill of health." % (file,) 131 132 class Whitespace: 133 # the characters used for space and tab 134 S, T = ' \t' 135 136 # members: 137 # raw 138 # the original string 139 # n 140 # the number of leading whitespace characters in raw 141 # nt 142 # the number of tabs in raw[:n] 143 # norm 144 # the normal form as a pair (count, trailing), where: 145 # count 146 # a tuple such that raw[:n] contains count[i] 147 # instances of S * i + T 148 # trailing 149 # the number of trailing spaces in raw[:n] 150 # It's A Theorem that m.indent_level(t) == 151 # n.indent_level(t) for all t >= 1 iff m.norm == n.norm. 152 # is_simple 153 # true iff raw[:n] is of the form (T*)(S*) 154 155 def __init__(self, ws): 156 self.raw = ws 157 S, T = Whitespace.S, Whitespace.T 158 count = [] 159 b = n = nt = 0 160 for ch in self.raw: 161 if ch == S: 162 n = n + 1 163 b = b + 1 164 elif ch == T: 165 n = n + 1 166 nt = nt + 1 167 if b >= len(count): 168 count = count + [0] * (b - len(count) + 1) 169 count[b] = count[b] + 1 170 b = 0 171 else: 172 break 173 self.n = n 174 self.nt = nt 175 self.norm = tuple(count), b 176 self.is_simple = len(count) <= 1 177 178 # return length of longest contiguous run of spaces (whether or not 179 # preceding a tab) 180 def longest_run_of_spaces(self): 181 count, trailing = self.norm 182 return max(len(count)-1, trailing) 183 184 def indent_level(self, tabsize): 185 # count, il = self.norm 186 # for i in range(len(count)): 187 # if count[i]: 188 # il = il + (i/tabsize + 1)*tabsize * count[i] 189 # return il 190 191 # quicker: 192 # il = trailing + sum (i/ts + 1)*ts*count[i] = 193 # trailing + ts * sum (i/ts + 1)*count[i] = 194 # trailing + ts * sum i/ts*count[i] + count[i] = 195 # trailing + ts * [(sum i/ts*count[i]) + (sum count[i])] = 196 # trailing + ts * [(sum i/ts*count[i]) + num_tabs] 197 # and note that i/ts*count[i] is 0 when i < ts 198 199 count, trailing = self.norm 200 il = 0 201 for i in range(tabsize, len(count)): 202 il = il + i/tabsize * count[i] 203 return trailing + tabsize * (il + self.nt) 204 205 # return true iff self.indent_level(t) == other.indent_level(t) 206 # for all t >= 1 207 def equal(self, other): 208 return self.norm == other.norm 209 210 # return a list of tuples (ts, i1, i2) such that 211 # i1 == self.indent_level(ts) != other.indent_level(ts) == i2. 212 # Intended to be used after not self.equal(other) is known, in which 213 # case it will return at least one witnessing tab size. 214 def not_equal_witness(self, other): 215 n = max(self.longest_run_of_spaces(), 216 other.longest_run_of_spaces()) + 1 217 a = [] 218 for ts in range(1, n+1): 219 if self.indent_level(ts) != other.indent_level(ts): 220 a.append( (ts, 221 self.indent_level(ts), 222 other.indent_level(ts)) ) 223 return a 224 225 # Return True iff self.indent_level(t) < other.indent_level(t) 226 # for all t >= 1. 227 # The algorithm is due to Vincent Broman. 228 # Easy to prove it's correct. 229 # XXXpost that. 230 # Trivial to prove n is sharp (consider T vs ST). 231 # Unknown whether there's a faster general way. I suspected so at 232 # first, but no longer. 233 # For the special (but common!) case where M and N are both of the 234 # form (T*)(S*), M.less(N) iff M.len() < N.len() and 235 # M.num_tabs() <= N.num_tabs(). Proof is easy but kinda long-winded. 236 # XXXwrite that up. 237 # Note that M is of the form (T*)(S*) iff len(M.norm[0]) <= 1. 238 def less(self, other): 239 if self.n >= other.n: 240 return False 241 if self.is_simple and other.is_simple: 242 return self.nt <= other.nt 243 n = max(self.longest_run_of_spaces(), 244 other.longest_run_of_spaces()) + 1 245 # the self.n >= other.n test already did it for ts=1 246 for ts in range(2, n+1): 247 if self.indent_level(ts) >= other.indent_level(ts): 248 return False 249 return True 250 251 # return a list of tuples (ts, i1, i2) such that 252 # i1 == self.indent_level(ts) >= other.indent_level(ts) == i2. 253 # Intended to be used after not self.less(other) is known, in which 254 # case it will return at least one witnessing tab size. 255 def not_less_witness(self, other): 256 n = max(self.longest_run_of_spaces(), 257 other.longest_run_of_spaces()) + 1 258 a = [] 259 for ts in range(1, n+1): 260 if self.indent_level(ts) >= other.indent_level(ts): 261 a.append( (ts, 262 self.indent_level(ts), 263 other.indent_level(ts)) ) 264 return a 265 266 def format_witnesses(w): 267 firsts = map(lambda tup: str(tup[0]), w) 268 prefix = "at tab size" 269 if len(w) > 1: 270 prefix = prefix + "s" 271 return prefix + " " + ', '.join(firsts) 272 273 def process_tokens(tokens): 274 INDENT = tokenize.INDENT 275 DEDENT = tokenize.DEDENT 276 NEWLINE = tokenize.NEWLINE 277 JUNK = tokenize.COMMENT, tokenize.NL 278 indents = [Whitespace("")] 279 check_equal = 0 280 281 for (type, token, start, end, line) in tokens: 282 if type == NEWLINE: 283 # a program statement, or ENDMARKER, will eventually follow, 284 # after some (possibly empty) run of tokens of the form 285 # (NL | COMMENT)* (INDENT | DEDENT+)? 286 # If an INDENT appears, setting check_equal is wrong, and will 287 # be undone when we see the INDENT. 288 check_equal = 1 289 290 elif type == INDENT: 291 check_equal = 0 292 thisguy = Whitespace(token) 293 if not indents[-1].less(thisguy): 294 witness = indents[-1].not_less_witness(thisguy) 295 msg = "indent not greater e.g. " + format_witnesses(witness) 296 raise NannyNag(start[0], msg, line) 297 indents.append(thisguy) 298 299 elif type == DEDENT: 300 # there's nothing we need to check here! what's important is 301 # that when the run of DEDENTs ends, the indentation of the 302 # program statement (or ENDMARKER) that triggered the run is 303 # equal to what's left at the top of the indents stack 304 305 # Ouch! This assert triggers if the last line of the source 306 # is indented *and* lacks a newline -- then DEDENTs pop out 307 # of thin air. 308 # assert check_equal # else no earlier NEWLINE, or an earlier INDENT 309 check_equal = 1 310 311 del indents[-1] 312 313 elif check_equal and type not in JUNK: 314 # this is the first "real token" following a NEWLINE, so it 315 # must be the first token of the next program statement, or an 316 # ENDMARKER; the "line" argument exposes the leading whitespace 317 # for this statement; in the case of ENDMARKER, line is an empty 318 # string, so will properly match the empty string with which the 319 # "indents" stack was seeded 320 check_equal = 0 321 thisguy = Whitespace(line) 322 if not indents[-1].equal(thisguy): 323 witness = indents[-1].not_equal_witness(thisguy) 324 msg = "indent not equal e.g. " + format_witnesses(witness) 325 raise NannyNag(start[0], msg, line) 326 327 328 if __name__ == '__main__': 329 main() 330
