methfix.py

#! /usr/bin/env python

# Fix Python source files to avoid using
# def method(self, (arg1, ..., argn)):
# instead of the more rational
# def method(self, arg1, ..., argn):
#
# Command line arguments are files or directories to be processed.
# Directories are searched recursively for files whose name looks
# like a python module.
# Symbolic links are always ignored (except as explicit directory
# arguments). Of course, the original file is kept as a back-up
# (with a "~" attached to its name).
# It complains about binaries (files containing null bytes)
# and about files that are ostensibly not Python files: if the first
# line starts with '#!' and does not contain the string 'python'.
#
# Changes made are reported to stdout in a diff-like format.
#
# Undoubtedly you can do this using find and sed or perl, but this is
# a nice example of Python code that recurses down a directory tree
# and uses regular expressions. Also note several subtleties like
# preserving the file's mode and avoiding to even write a temp file
# when no changes are needed for a file.
#
# NB: by changing only the function fixline() you can turn this
# into a program for a different change to Python programs...

importsys
importre
importos
fromstatimport*

err=sys.stderr.write
dbg=err
rep=sys.stdout.write

defmain():
bad=0
ifnotsys.argv[1:]: # No arguments
err('usage: '+sys.argv[0] +' file-or-directory ...\n')
sys.exit(2)
forarginsys.argv[1:]:
ifos.path.isdir(arg):
ifrecursedown(arg): bad=1
elifos.path.islink(arg):
err(arg+': will not process symbolic links\n')
bad=1
else:
iffix(arg): bad=1
sys.exit(bad)

ispythonprog=re.compile('^[a-zA-Z0-9_]+\.py$')
defispython(name):
returnispythonprog.match(name) >=0

defrecursedown(dirname):
dbg('recursedown(%r)\n'% (dirname,))
bad=0
try:
names=os.listdir(dirname)
exceptos.error, msg:
err('%s: cannot list directory: %r\n'% (dirname, msg))
return1
names.sort()
subdirs= []
fornameinnames:
ifnamein (os.curdir, os.pardir): continue
fullname=os.path.join(dirname, name)
ifos.path.islink(fullname): pass
elifos.path.isdir(fullname):
subdirs.append(fullname)
elifispython(name):
iffix(fullname): bad=1
forfullnameinsubdirs:
ifrecursedown(fullname): bad=1
returnbad

deffix(filename):
## dbg('fix(%r)\n' % (filename,))
try:
f=open(filename, 'r')
exceptIOError, msg:
err('%s: cannot open: %r\n'% (filename, msg))
return1
head, tail=os.path.split(filename)
tempname=os.path.join(head, '@'+tail)
g=None
# If we find a match, we rewind the file and start over but
# now copy everything to a temp file.
lineno=0
while1:
line=f.readline()
ifnotline: break
lineno=lineno+1
ifgisNoneand'\0'inline:
# Check for binary files
err(filename+': contains null bytes; not fixed\n')
f.close()
return1
iflineno==1andgisNoneandline[:2] =='#!':
# Check for non-Python scripts
words=line[2:].split()
ifwordsandre.search('[pP]ython', words[0]) <0:
msg=filename+': '+words[0]
msg=msg+' script; not fixed\n'
err(msg)
f.close()
return1
whileline[-2:] =='\\\n':
nextline=f.readline()
ifnotnextline: break
line=line+nextline
lineno=lineno+1
newline=fixline(line)
ifnewline!=line:
ifgisNone:
try:
g=open(tempname, 'w')
exceptIOError, msg:
f.close()
err('%s: cannot create: %r\n'% (tempname, msg))
return1
f.seek(0)
lineno=0
rep(filename+':\n')
continue# restart from the beginning
rep(repr(lineno) +'\n')
rep('< '+line)
rep('> '+newline)
ifgisnotNone:
g.write(newline)

# End of file
f.close()
ifnotg: return0# No changes

# Finishing touch -- move files

# First copy the file's mode to the temp file
try:
statbuf=os.stat(filename)
os.chmod(tempname, statbuf[ST_MODE] &07777)
exceptos.error, msg:
err('%s: warning: chmod failed (%r)\n'% (tempname, msg))
# Then make a backup of the original file as filename~
try:
os.rename(filename, filename+'~')
exceptos.error, msg:
err('%s: warning: backup failed (%r)\n'% (filename, msg))
# Now move the temp file to the original file
try:
os.rename(tempname, filename)
exceptos.error, msg:
err('%s: rename failed (%r)\n'% (filename, msg))
return1
# Return succes
return0


fixpat='^[ \t]+def +[a-zA-Z0-9_]+ *( *self *, *(( *(.*) *)) *) *:'
fixprog=re.compile(fixpat)

deffixline(line):
iffixprog.match(line) >=0:
 (a, b), (c, d) =fixprog.regs[1:3]
line=line[:a] +line[c:d] +line[b:]
returnline

if__name__=='__main__':
main()