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()