Lib/tabnanny.py

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