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