1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
#! /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] & 07777)
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()
|
