Tools/scripts/methfix.py

   1 #! /usr/bin/env python
   2
   3 # Fix Python source files to avoid using
   4 #       def method(self, (arg1, ..., argn)):
   5 # instead of the more rational
   6 #       def method(self, arg1, ..., argn):
   7 #
   8 # Command line arguments are files or directories to be processed.
   9 # Directories are searched recursively for files whose name looks
  10 # like a python module.
  11 # Symbolic links are always ignored (except as explicit directory
  12 # arguments).  Of course, the original file is kept as a back-up
  13 # (with a "~" attached to its name).
  14 # It complains about binaries (files containing null bytes)
  15 # and about files that are ostensibly not Python files: if the first
  16 # line starts with '#!' and does not contain the string 'python'.
  17 #
  18 # Changes made are reported to stdout in a diff-like format.
  19 #
  20 # Undoubtedly you can do this using find and sed or perl, but this is
  21 # a nice example of Python code that recurses down a directory tree
  22 # and uses regular expressions.  Also note several subtleties like
  23 # preserving the file's mode and avoiding to even write a temp file
  24 # when no changes are needed for a file.
  25 #
  26 # NB: by changing only the function fixline() you can turn this
  27 # into a program for a different change to Python programs...
  28
  29 import sys
  30 import re
  31 import os
  32 from stat import *
  33
  34 err = sys.stderr.write
  35 dbg = err
  36 rep = sys.stdout.write
  37
  38 def main():
  39     bad = 0
  40     if not sys.argv[1:]: # No arguments
  41         err('usage: ' + sys.argv[0] + ' file-or-directory ...\n')
  42         sys.exit(2)
  43     for arg in sys.argv[1:]:
  44         if os.path.isdir(arg):
  45             if recursedown(arg): bad = 1
  46         elif os.path.islink(arg):
  47             err(arg + ': will not process symbolic links\n')
  48             bad = 1
  49         else:
  50             if fix(arg): bad = 1
  51     sys.exit(bad)
  52
  53 ispythonprog = re.compile('^[a-zA-Z0-9_]+\.py$')
  54 def ispython(name):
  55     return ispythonprog.match(name) >= 0
  56
  57 def recursedown(dirname):
  58     dbg('recursedown(%r)\n' % (dirname,))
  59     bad = 0
  60     try:
  61         names = os.listdir(dirname)
  62     except os.error, msg:
  63         err('%s: cannot list directory: %r\n' % (dirname, msg))
  64         return 1
  65     names.sort()
  66     subdirs = []
  67     for name in names:
  68         if name in (os.curdir, os.pardir): continue
  69         fullname = os.path.join(dirname, name)
  70         if os.path.islink(fullname): pass
  71         elif os.path.isdir(fullname):
  72             subdirs.append(fullname)
  73         elif ispython(name):
  74             if fix(fullname): bad = 1
  75     for fullname in subdirs:
  76         if recursedown(fullname): bad = 1
  77     return bad
  78
  79 def fix(filename):
  80 ##  dbg('fix(%r)\n' % (filename,))
  81     try:
  82         f = open(filename, 'r')
  83     except IOError, msg:
  84         err('%s: cannot open: %r\n' % (filename, msg))
  85         return 1
  86     head, tail = os.path.split(filename)
  87     tempname = os.path.join(head, '@' + tail)
  88     g = None
  89     # If we find a match, we rewind the file and start over but
  90     # now copy everything to a temp file.
  91     lineno = 0
  92     while 1:
  93         line = f.readline()
  94         if not line: break
  95         lineno = lineno + 1
  96         if g is None and '\0' in line:
  97             # Check for binary files
  98             err(filename + ': contains null bytes; not fixed\n')
  99             f.close()
 100             return 1
 101         if lineno == 1 and g is None and line[:2] == '#!':
 102             # Check for non-Python scripts
 103             words = line[2:].split()
 104             if words and re.search('[pP]ython', words[0]) < 0:
 105                 msg = filename + ': ' + words[0]
 106                 msg = msg + ' script; not fixed\n'
 107                 err(msg)
 108                 f.close()
 109                 return 1
 110         while line[-2:] == '\\\n':
 111             nextline = f.readline()
 112             if not nextline: break
 113             line = line + nextline
 114             lineno = lineno + 1
 115         newline = fixline(line)
 116         if newline != line:
 117             if g is None:
 118                 try:
 119                     g = open(tempname, 'w')
 120                 except IOError, msg:
 121                     f.close()
 122                     err('%s: cannot create: %r\n' % (tempname, msg))
 123                     return 1
 124                 f.seek(0)
 125                 lineno = 0
 126                 rep(filename + ':\n')
 127                 continue # restart from the beginning
 128             rep(repr(lineno) + '\n')
 129             rep('< ' + line)
 130             rep('> ' + newline)
 131         if g is not None:
 132             g.write(newline)
 133
 134     # End of file
 135     f.close()
 136     if not g: return 0 # No changes
 137
 138     # Finishing touch -- move files
 139
 140     # First copy the file's mode to the temp file
 141     try:
 142         statbuf = os.stat(filename)
 143         os.chmod(tempname, statbuf[ST_MODE] & 07777)
 144     except os.error, msg:
 145         err('%s: warning: chmod failed (%r)\n' % (tempname, msg))
 146     # Then make a backup of the original file as filename~
 147     try:
 148         os.rename(filename, filename + '~')
 149     except os.error, msg:
 150         err('%s: warning: backup failed (%r)\n' % (filename, msg))
 151     # Now move the temp file to the original file
 152     try:
 153         os.rename(tempname, filename)
 154     except os.error, msg:
 155         err('%s: rename failed (%r)\n' % (filename, msg))
 156         return 1
 157     # Return succes
 158     return 0
 159
 160
 161 fixpat = '^[ \t]+def +[a-zA-Z0-9_]+ *( *self *, *(( *(.*) *)) *) *:'
 162 fixprog = re.compile(fixpat)
 163
 164 def fixline(line):
 165     if fixprog.match(line) >= 0:
 166         (a, b), (c, d) = fixprog.regs[1:3]
 167         line = line[:a] + line[c:d] + line[b:]
 168     return line
 169
 170 if __name__ == '__main__':
 171     main()