#! /usr/bin/env python | |
"""The Tab Nanny despises ambiguous indentation. She knows no mercy. | |
tabnanny -- Detection of ambiguous indentation | |
For the time being this module is intended to be called as a script. | |
However it is possible to import it into an IDE and use the function | |
check() described below. | |
Warning: The API provided by this module is likely to change in future | |
releases; such changes may not be backward compatible. | |
""" | |
# Released to the public domain, by Tim Peters, 15 April 1998. | |
# XXX Note: this is now a standard library module. | |
# XXX The API needs to undergo changes however; the current code is too | |
# XXX script-like. This will be addressed later. | |
__version__ = "6" | |
import os | |
import sys | |
import getopt | |
import tokenize | |
if not hasattr(tokenize, 'NL'): | |
raise ValueError("tokenize.NL doesn't exist -- tokenize module too old") | |
__all__ = ["check", "NannyNag", "process_tokens"] | |
verbose = 0 | |
filename_only = 0 | |
def errprint(*args): | |
sep = "" | |
for arg in args: | |
sys.stderr.write(sep + str(arg)) | |
sep = " " | |
sys.stderr.write("\n") | |
def main(): | |
global verbose, filename_only | |
try: | |
opts, args = getopt.getopt(sys.argv[1:], "qv") | |
except getopt.error, msg: | |
errprint(msg) | |
return | |
for o, a in opts: | |
if o == '-q': | |
filename_only = filename_only + 1 | |
if o == '-v': | |
verbose = verbose + 1 | |
if not args: | |
errprint("Usage:", sys.argv[0], "[-v] file_or_directory ...") | |
return | |
for arg in args: | |
check(arg) | |
class NannyNag(Exception): | |
""" | |
Raised by tokeneater() if detecting an ambiguous indent. | |
Captured and handled in check(). | |
""" | |
def __init__(self, lineno, msg, line): | |
self.lineno, self.msg, self.line = lineno, msg, line | |
def get_lineno(self): | |
return self.lineno | |
def get_msg(self): | |
return self.msg | |
def get_line(self): | |
return self.line | |
def check(file): | |
"""check(file_or_dir) | |
If file_or_dir is a directory and not a symbolic link, then recursively | |
descend the directory tree named by file_or_dir, checking all .py files | |
along the way. If file_or_dir is an ordinary Python source file, it is | |
checked for whitespace related problems. The diagnostic messages are | |
written to standard output using the print statement. | |
""" | |
if os.path.isdir(file) and not os.path.islink(file): | |
if verbose: | |
print "%r: listing directory" % (file,) | |
names = os.listdir(file) | |
for name in names: | |
fullname = os.path.join(file, name) | |
if (os.path.isdir(fullname) and | |
not os.path.islink(fullname) or | |
os.path.normcase(name[-3:]) == ".py"): | |
check(fullname) | |
return | |
try: | |
f = open(file) | |
except IOError, msg: | |
errprint("%r: I/O Error: %s" % (file, msg)) | |
return | |
if verbose > 1: | |
print "checking %r ..." % file | |
try: | |
process_tokens(tokenize.generate_tokens(f.readline)) | |
except tokenize.TokenError, msg: | |
errprint("%r: Token Error: %s" % (file, msg)) | |
return | |
except IndentationError, msg: | |
errprint("%r: Indentation Error: %s" % (file, msg)) | |
return | |
except NannyNag, nag: | |
badline = nag.get_lineno() | |
line = nag.get_line() | |
if verbose: | |
print "%r: *** Line %d: trouble in tab city! ***" % (file, badline) | |
print "offending line: %r" % (line,) | |
print nag.get_msg() | |
else: | |
if ' ' in file: file = '"' + file + '"' | |
if filename_only: print file | |
else: print file, badline, repr(line) | |
return | |
if verbose: | |
print "%r: Clean bill of health." % (file,) | |
class Whitespace: | |
# the characters used for space and tab | |
S, T = ' \t' | |
# members: | |
# raw | |
# the original string | |
# n | |
# the number of leading whitespace characters in raw | |
# nt | |
# the number of tabs in raw[:n] | |
# norm | |
# the normal form as a pair (count, trailing), where: | |
# count | |
# a tuple such that raw[:n] contains count[i] | |
# instances of S * i + T | |
# trailing | |
# the number of trailing spaces in raw[:n] | |
# It's A Theorem that m.indent_level(t) == | |
# n.indent_level(t) for all t >= 1 iff m.norm == n.norm. | |
# is_simple | |
# true iff raw[:n] is of the form (T*)(S*) | |
def __init__(self, ws): | |
self.raw = ws | |
S, T = Whitespace.S, Whitespace.T | |
count = [] | |
b = n = nt = 0 | |
for ch in self.raw: | |
if ch == S: | |
n = n + 1 | |
b = b + 1 | |
elif ch == T: | |
n = n + 1 | |
nt = nt + 1 | |
if b >= len(count): | |
count = count + [0] * (b - len(count) + 1) | |
count[b] = count[b] + 1 | |
b = 0 | |
else: | |
break | |
self.n = n | |
self.nt = nt | |
self.norm = tuple(count), b | |
self.is_simple = len(count) <= 1 | |
# return length of longest contiguous run of spaces (whether or not | |
# preceding a tab) | |
def longest_run_of_spaces(self): | |
count, trailing = self.norm | |
return max(len(count)-1, trailing) | |
def indent_level(self, tabsize): | |
# count, il = self.norm | |
# for i in range(len(count)): | |
# if count[i]: | |
# il = il + (i/tabsize + 1)*tabsize * count[i] | |
# return il | |
# quicker: | |
# il = trailing + sum (i/ts + 1)*ts*count[i] = | |
# trailing + ts * sum (i/ts + 1)*count[i] = | |
# trailing + ts * sum i/ts*count[i] + count[i] = | |
# trailing + ts * [(sum i/ts*count[i]) + (sum count[i])] = | |
# trailing + ts * [(sum i/ts*count[i]) + num_tabs] | |
# and note that i/ts*count[i] is 0 when i < ts | |
count, trailing = self.norm | |
il = 0 | |
for i in range(tabsize, len(count)): | |
il = il + i/tabsize * count[i] | |
return trailing + tabsize * (il + self.nt) | |
# return true iff self.indent_level(t) == other.indent_level(t) | |
# for all t >= 1 | |
def equal(self, other): | |
return self.norm == other.norm | |
# return a list of tuples (ts, i1, i2) such that | |
# i1 == self.indent_level(ts) != other.indent_level(ts) == i2. | |
# Intended to be used after not self.equal(other) is known, in which | |
# case it will return at least one witnessing tab size. | |
def not_equal_witness(self, other): | |
n = max(self.longest_run_of_spaces(), | |
other.longest_run_of_spaces()) + 1 | |
a = [] | |
for ts in range(1, n+1): | |
if self.indent_level(ts) != other.indent_level(ts): | |
a.append( (ts, | |
self.indent_level(ts), | |
other.indent_level(ts)) ) | |
return a | |
# Return True iff self.indent_level(t) < other.indent_level(t) | |
# for all t >= 1. | |
# The algorithm is due to Vincent Broman. | |
# Easy to prove it's correct. | |
# XXXpost that. | |
# Trivial to prove n is sharp (consider T vs ST). | |
# Unknown whether there's a faster general way. I suspected so at | |
# first, but no longer. | |
# For the special (but common!) case where M and N are both of the | |
# form (T*)(S*), M.less(N) iff M.len() < N.len() and | |
# M.num_tabs() <= N.num_tabs(). Proof is easy but kinda long-winded. | |
# XXXwrite that up. | |
# Note that M is of the form (T*)(S*) iff len(M.norm[0]) <= 1. | |
def less(self, other): | |
if self.n >= other.n: | |
return False | |
if self.is_simple and other.is_simple: | |
return self.nt <= other.nt | |
n = max(self.longest_run_of_spaces(), | |
other.longest_run_of_spaces()) + 1 | |
# the self.n >= other.n test already did it for ts=1 | |
for ts in range(2, n+1): | |
if self.indent_level(ts) >= other.indent_level(ts): | |
return False | |
return True | |
# return a list of tuples (ts, i1, i2) such that | |
# i1 == self.indent_level(ts) >= other.indent_level(ts) == i2. | |
# Intended to be used after not self.less(other) is known, in which | |
# case it will return at least one witnessing tab size. | |
def not_less_witness(self, other): | |
n = max(self.longest_run_of_spaces(), | |
other.longest_run_of_spaces()) + 1 | |
a = [] | |
for ts in range(1, n+1): | |
if self.indent_level(ts) >= other.indent_level(ts): | |
a.append( (ts, | |
self.indent_level(ts), | |
other.indent_level(ts)) ) | |
return a | |
def format_witnesses(w): | |
firsts = map(lambda tup: str(tup[0]), w) | |
prefix = "at tab size" | |
if len(w) > 1: | |
prefix = prefix + "s" | |
return prefix + " " + ', '.join(firsts) | |
def process_tokens(tokens): | |
INDENT = tokenize.INDENT | |
DEDENT = tokenize.DEDENT | |
NEWLINE = tokenize.NEWLINE | |
JUNK = tokenize.COMMENT, tokenize.NL | |
indents = [Whitespace("")] | |
check_equal = 0 | |
for (type, token, start, end, line) in tokens: | |
if type == NEWLINE: | |
# a program statement, or ENDMARKER, will eventually follow, | |
# after some (possibly empty) run of tokens of the form | |
# (NL | COMMENT)* (INDENT | DEDENT+)? | |
# If an INDENT appears, setting check_equal is wrong, and will | |
# be undone when we see the INDENT. | |
check_equal = 1 | |
elif type == INDENT: | |
check_equal = 0 | |
thisguy = Whitespace(token) | |
if not indents[-1].less(thisguy): | |
witness = indents[-1].not_less_witness(thisguy) | |
msg = "indent not greater e.g. " + format_witnesses(witness) | |
raise NannyNag(start[0], msg, line) | |
indents.append(thisguy) | |
elif type == DEDENT: | |
# there's nothing we need to check here! what's important is | |
# that when the run of DEDENTs ends, the indentation of the | |
# program statement (or ENDMARKER) that triggered the run is | |
# equal to what's left at the top of the indents stack | |
# Ouch! This assert triggers if the last line of the source | |
# is indented *and* lacks a newline -- then DEDENTs pop out | |
# of thin air. | |
# assert check_equal # else no earlier NEWLINE, or an earlier INDENT | |
check_equal = 1 | |
del indents[-1] | |
elif check_equal and type not in JUNK: | |
# this is the first "real token" following a NEWLINE, so it | |
# must be the first token of the next program statement, or an | |
# ENDMARKER; the "line" argument exposes the leading whitespace | |
# for this statement; in the case of ENDMARKER, line is an empty | |
# string, so will properly match the empty string with which the | |
# "indents" stack was seeded | |
check_equal = 0 | |
thisguy = Whitespace(line) | |
if not indents[-1].equal(thisguy): | |
witness = indents[-1].not_equal_witness(thisguy) | |
msg = "indent not equal e.g. " + format_witnesses(witness) | |
raise NannyNag(start[0], msg, line) | |
if __name__ == '__main__': | |
main() |