| #! /usr/bin/env python | |
| # Released to the public domain, by Tim Peters, 03 October 2000. | |
| """reindent [-d][-r][-v] [ path ... ] | |
| -d (--dryrun) Dry run. Analyze, but don't make any changes to, files. | |
| -r (--recurse) Recurse. Search for all .py files in subdirectories too. | |
| -n (--nobackup) No backup. Does not make a ".bak" file before reindenting. | |
| -v (--verbose) Verbose. Print informative msgs; else no output. | |
| -h (--help) Help. Print this usage information and exit. | |
| Change Python (.py) files to use 4-space indents and no hard tab characters. | |
| Also trim excess spaces and tabs from ends of lines, and remove empty lines | |
| at the end of files. Also ensure the last line ends with a newline. | |
| If no paths are given on the command line, reindent operates as a filter, | |
| reading a single source file from standard input and writing the transformed | |
| source to standard output. In this case, the -d, -r and -v flags are | |
| ignored. | |
| You can pass one or more file and/or directory paths. When a directory | |
| path, all .py files within the directory will be examined, and, if the -r | |
| option is given, likewise recursively for subdirectories. | |
| If output is not to standard output, reindent overwrites files in place, | |
| renaming the originals with a .bak extension. If it finds nothing to | |
| change, the file is left alone. If reindent does change a file, the changed | |
| file is a fixed-point for future runs (i.e., running reindent on the | |
| resulting .py file won't change it again). | |
| The hard part of reindenting is figuring out what to do with comment | |
| lines. So long as the input files get a clean bill of health from | |
| tabnanny.py, reindent should do a good job. | |
| The backup file is a copy of the one that is being reindented. The ".bak" | |
| file is generated with shutil.copy(), but some corner cases regarding | |
| user/group and permissions could leave the backup file more readable that | |
| you'd prefer. You can always use the --nobackup option to prevent this. | |
| """ | |
| __version__ = "1" | |
| import tokenize | |
| import os, shutil | |
| import sys | |
| verbose = 0 | |
| recurse = 0 | |
| dryrun = 0 | |
| makebackup = True | |
| def usage(msg=None): | |
| if msg is not None: | |
| print >> sys.stderr, msg | |
| print >> sys.stderr, __doc__ | |
| def errprint(*args): | |
| sep = "" | |
| for arg in args: | |
| sys.stderr.write(sep + str(arg)) | |
| sep = " " | |
| sys.stderr.write("\n") | |
| def main(): | |
| import getopt | |
| global verbose, recurse, dryrun, makebackup | |
| try: | |
| opts, args = getopt.getopt(sys.argv[1:], "drnvh", | |
| ["dryrun", "recurse", "nobackup", "verbose", "help"]) | |
| except getopt.error, msg: | |
| usage(msg) | |
| return | |
| for o, a in opts: | |
| if o in ('-d', '--dryrun'): | |
| dryrun += 1 | |
| elif o in ('-r', '--recurse'): | |
| recurse += 1 | |
| elif o in ('-n', '--nobackup'): | |
| makebackup = False | |
| elif o in ('-v', '--verbose'): | |
| verbose += 1 | |
| elif o in ('-h', '--help'): | |
| usage() | |
| return | |
| if not args: | |
| r = Reindenter(sys.stdin) | |
| r.run() | |
| r.write(sys.stdout) | |
| return | |
| for arg in args: | |
| check(arg) | |
| def check(file): | |
| if os.path.isdir(file) and not os.path.islink(file): | |
| if verbose: | |
| print "listing directory", file | |
| names = os.listdir(file) | |
| for name in names: | |
| fullname = os.path.join(file, name) | |
| if ((recurse and os.path.isdir(fullname) and | |
| not os.path.islink(fullname) and | |
| not os.path.split(fullname)[1].startswith(".")) | |
| or name.lower().endswith(".py")): | |
| check(fullname) | |
| return | |
| if verbose: | |
| print "checking", file, "...", | |
| try: | |
| f = open(file) | |
| except IOError, msg: | |
| errprint("%s: I/O Error: %s" % (file, str(msg))) | |
| return | |
| r = Reindenter(f) | |
| f.close() | |
| if r.run(): | |
| if verbose: | |
| print "changed." | |
| if dryrun: | |
| print "But this is a dry run, so leaving it alone." | |
| if not dryrun: | |
| bak = file + ".bak" | |
| if makebackup: | |
| shutil.copyfile(file, bak) | |
| if verbose: | |
| print "backed up", file, "to", bak | |
| f = open(file, "w") | |
| r.write(f) | |
| f.close() | |
| if verbose: | |
| print "wrote new", file | |
| return True | |
| else: | |
| if verbose: | |
| print "unchanged." | |
| return False | |
| def _rstrip(line, JUNK='\n \t'): | |
| """Return line stripped of trailing spaces, tabs, newlines. | |
| Note that line.rstrip() instead also strips sundry control characters, | |
| but at least one known Emacs user expects to keep junk like that, not | |
| mentioning Barry by name or anything <wink>. | |
| """ | |
| i = len(line) | |
| while i > 0 and line[i-1] in JUNK: | |
| i -= 1 | |
| return line[:i] | |
| class Reindenter: | |
| def __init__(self, f): | |
| self.find_stmt = 1 # next token begins a fresh stmt? | |
| self.level = 0 # current indent level | |
| # Raw file lines. | |
| self.raw = f.readlines() | |
| # File lines, rstripped & tab-expanded. Dummy at start is so | |
| # that we can use tokenize's 1-based line numbering easily. | |
| # Note that a line is all-blank iff it's "\n". | |
| self.lines = [_rstrip(line).expandtabs() + "\n" | |
| for line in self.raw] | |
| self.lines.insert(0, None) | |
| self.index = 1 # index into self.lines of next line | |
| # List of (lineno, indentlevel) pairs, one for each stmt and | |
| # comment line. indentlevel is -1 for comment lines, as a | |
| # signal that tokenize doesn't know what to do about them; | |
| # indeed, they're our headache! | |
| self.stats = [] | |
| def run(self): | |
| tokenize.tokenize(self.getline, self.tokeneater) | |
| # Remove trailing empty lines. | |
| lines = self.lines | |
| while lines and lines[-1] == "\n": | |
| lines.pop() | |
| # Sentinel. | |
| stats = self.stats | |
| stats.append((len(lines), 0)) | |
| # Map count of leading spaces to # we want. | |
| have2want = {} | |
| # Program after transformation. | |
| after = self.after = [] | |
| # Copy over initial empty lines -- there's nothing to do until | |
| # we see a line with *something* on it. | |
| i = stats[0][0] | |
| after.extend(lines[1:i]) | |
| for i in range(len(stats)-1): | |
| thisstmt, thislevel = stats[i] | |
| nextstmt = stats[i+1][0] | |
| have = getlspace(lines[thisstmt]) | |
| want = thislevel * 4 | |
| if want < 0: | |
| # A comment line. | |
| if have: | |
| # An indented comment line. If we saw the same | |
| # indentation before, reuse what it most recently | |
| # mapped to. | |
| want = have2want.get(have, -1) | |
| if want < 0: | |
| # Then it probably belongs to the next real stmt. | |
| for j in xrange(i+1, len(stats)-1): | |
| jline, jlevel = stats[j] | |
| if jlevel >= 0: | |
| if have == getlspace(lines[jline]): | |
| want = jlevel * 4 | |
| break | |
| if want < 0: # Maybe it's a hanging | |
| # comment like this one, | |
| # in which case we should shift it like its base | |
| # line got shifted. | |
| for j in xrange(i-1, -1, -1): | |
| jline, jlevel = stats[j] | |
| if jlevel >= 0: | |
| want = have + getlspace(after[jline-1]) - \ | |
| getlspace(lines[jline]) | |
| break | |
| if want < 0: | |
| # Still no luck -- leave it alone. | |
| want = have | |
| else: | |
| want = 0 | |
| assert want >= 0 | |
| have2want[have] = want | |
| diff = want - have | |
| if diff == 0 or have == 0: | |
| after.extend(lines[thisstmt:nextstmt]) | |
| else: | |
| for line in lines[thisstmt:nextstmt]: | |
| if diff > 0: | |
| if line == "\n": | |
| after.append(line) | |
| else: | |
| after.append(" " * diff + line) | |
| else: | |
| remove = min(getlspace(line), -diff) | |
| after.append(line[remove:]) | |
| return self.raw != self.after | |
| def write(self, f): | |
| f.writelines(self.after) | |
| # Line-getter for tokenize. | |
| def getline(self): | |
| if self.index >= len(self.lines): | |
| line = "" | |
| else: | |
| line = self.lines[self.index] | |
| self.index += 1 | |
| return line | |
| # Line-eater for tokenize. | |
| def tokeneater(self, type, token, (sline, scol), end, line, | |
| INDENT=tokenize.INDENT, | |
| DEDENT=tokenize.DEDENT, | |
| NEWLINE=tokenize.NEWLINE, | |
| COMMENT=tokenize.COMMENT, | |
| NL=tokenize.NL): | |
| 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+)? | |
| self.find_stmt = 1 | |
| elif type == INDENT: | |
| self.find_stmt = 1 | |
| self.level += 1 | |
| elif type == DEDENT: | |
| self.find_stmt = 1 | |
| self.level -= 1 | |
| elif type == COMMENT: | |
| if self.find_stmt: | |
| self.stats.append((sline, -1)) | |
| # but we're still looking for a new stmt, so leave | |
| # find_stmt alone | |
| elif type == NL: | |
| pass | |
| elif self.find_stmt: | |
| # This is the first "real token" following a NEWLINE, so it | |
| # must be the first token of the next program statement, or an | |
| # ENDMARKER. | |
| self.find_stmt = 0 | |
| if line: # not endmarker | |
| self.stats.append((sline, self.level)) | |
| # Count number of leading blanks. | |
| def getlspace(line): | |
| i, n = 0, len(line) | |
| while i < n and line[i] == " ": | |
| i += 1 | |
| return i | |
| if __name__ == '__main__': | |
| main() |