#! /usr/local/python

# Fix Python source files to use the new class definition syntax,
# i.e.,
#	class C(base, base, ...): ...
# instead of
#	class C() = base(), base(), ...: ...
#
# 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).
#
# Undoubtedly you can do this using find and sed, 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.
#
# Changes made are reported to stdout in a diff-like format.

import sys
import regexp
import posix
import path
import string
from stat import *

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

def main():
	bad = 0
	if not sys.argv[1:]: # No arguments
		err('usage: classfix file-or-directory ...\n')
		sys.exit(2)
	for arg in sys.argv[1:]:
		if path.isdir(arg):
			if recursedown(arg): bad = 1
		elif path.islink(arg):
			err(arg + ': will not process symbolic links\n')
			bad = 1
		else:
			if fix(arg): bad = 1
	sys.exit(bad)

ispython = regexp.compile('^[a-zA-Z0-9_]+\.py$').match # This is a method!

def recursedown(dirname):
	dbg('recursedown(' + `dirname` + ')\n')
	bad = 0
	try:
		names = posix.listdir(dirname)
	except posix.error, msg:
		err(dirname + ': cannot list directory: ' + `msg` + '\n')
		return 1
	for name in names:
		if name in ('.', '..'): continue
		fullname = path.join(dirname, name)
		if path.islink(fullname): pass
		elif path.isdir(fullname):
			if recursedown(fullname): bad = 1
		elif ispython(name):
			if fix(fullname): bad = 1
	return bad

# This expression doesn't catch *all* class definition headers,
# but it's darn pretty close.
classexpr = '^([ \t]*class +[a-zA-Z0-9_]+) *\( *\) *((=.*)?):'
findclass = regexp.compile(classexpr).match # This is a method!

baseexpr = '^ *(.*) *\( *\) *$'
findbase = regexp.compile(baseexpr).match # This is a method, too!

def fix(filename):
##	dbg('fix(' + `filename` + ')\n')
	try:
		f = open(filename, 'r')
	except IOError, msg:
		err(filename + ': cannot open: ' + `msg` + '\n')
		return 1
	head, tail = path.split(filename)
	tempname = path.join(head, '@' + tail)
	tf = None
	# If we find a match, we rewind the file and start over but
	# now copy everything to a temp file.
	while 1:
		line = f.readline()
		if not line: break
		res = findclass(line)
		if not res:
			if tf: tf.write(line)
			continue
		if not tf:
			try:
				tf = open(tempname, 'w')
			except IOError, msg:
				f.close()
				err(tempname+': cannot create: '+`msg`+'\n')
				return 1
			rep(filename + ':\n')
			# Rewind the input file and start all over:
			f.seek(0)
			continue
		a0, b0 = res[0] # Whole match (up to ':')
		a1, b1 = res[1] # First subexpression (up to classname)
		a2, b2 = res[2] # Second subexpression (=.*)
		head = line[:b1]
		tail = line[b0:] # Unmatched rest of line
		if a2 = b2: # No base classes -- easy case
			newline = head + ':' + tail
		else:
			# Get rid of leading '='
			basepart = line[a2+1:b2]
			# Extract list of base expressions
			bases = string.splitfields(basepart, ',')
			# Strip trailing '()' from each base expression
			for i in range(len(bases)):
				res = findbase(bases[i])
				if res:
					(x0, y0), (x1, y1) = res
					bases[i] = bases[i][x1:y1]
			# Join the bases back again and build the new line
			basepart = string.joinfields(bases, ', ')
			newline = head + '(' + basepart + '):' + tail
		rep('< ' + line)
		rep('> ' + newline)
		tf.write(newline)
	f.close()
	if not tf: return 0 # No changes
	
	# Finishing touch -- move files

	# First copy the file's mode to the temp file
	try:
		statbuf = posix.stat(filename)
		posix.chmod(tempname, statbuf[ST_MODE] & 0x7777)
	except posix.error, msg:
		err(tempname + ': warning: chmod failed (' + `msg` + ')\n')
	# Then make a backup of the original file as filename~
	try:
		posix.rename(filename, filename + '~')
	except posix.error, msg:
		err(filename + ': warning: backup failed (' + `msg` + ')\n')
	# Now move the temp file to the original file
	try:
		posix.rename(tempname, filename)
	except posix.error, msg:
		err(filename + ': rename failed (' + `msg` + ')\n')
		return 1
	# Return succes
	return 0

main()