#! /usr/bin/env python
# A window-oriented recursive diff utility.
# NB: This uses undocumented window classing modules.
# TO DO:
# - faster update after moving/copying one file
# - diff flags (-b, etc.) should be global or maintained per window
# - use a few fixed windows instead of creating new ones all the time
# - ways to specify patterns to skip
# (best by pointing at a file and clicking a special menu entry!)
# - add rcsdiff menu commands
# - add a way to view status of selected files without opening them
# - add a way to diff two files with different names
# - add a way to rename files
# - keep backups of overwritten/deleted files
# - a way to mark specified files as uninteresting for dircmp
import sys
import os
import rand
import commands
import dircache
import statcache
import cmp
import cmpcache
import stdwin
import gwin
import textwin
import filewin
import tablewin
import anywin
mkarg = commands.mkarg
mk2arg = commands.mk2arg
# List of names to ignore in dircmp()
#
skiplist = ['RCS', 'CVS', '.Amake', 'tags', 'TAGS', '.', '..']
# Function to determine whether a name should be ignored in dircmp().
#
def skipthis(file):
return file[-1:] == '~' or file in skiplist
def anydiff(a, b, flags): # Display differences between any two objects
print 'diff', flags, a, b
if os.path.isdir(a) and os.path.isdir(b):
w = dirdiff(a, b, flags)
else:
w = filediff(a, b, flags)
addstatmenu(w, [a, b])
w.original_close = w.close
w.close = close_dirwin
return w
def close_dirwin(w):
close_subwindows(w, (), 0)
w.original_close(w)
def filediff(a, b, flags): # Display differences between two text files
diffcmd = 'diff'
if flags: diffcmd = diffcmd + mkarg(flags)
diffcmd = diffcmd + mkarg(a) + mkarg(b)
difftext = commands.getoutput(diffcmd)
return textwin.open_readonly(mktitle(a, b), difftext)
def dirdiff(a, b, flags): # Display differences between two directories
data = diffdata(a, b, flags)
w = tablewin.open(mktitle(a, b), data)
w.flags = flags
w.a = a
w.b = b
addviewmenu(w)
addactionmenu(w)
return w
def diffdata(a, b, flags): # Compute directory differences.
#
a_only = [('A only:', header_action), ('', header_action)]
b_only = [('B only:', header_action), ('', header_action)]
ab_diff = [('A <> B:', header_action), ('', header_action)]
ab_same = [('A == B:', header_action), ('', header_action)]
data = [a_only, b_only, ab_diff, ab_same]
#
a_list = dircache.listdir(a)[:]
b_list = dircache.listdir(b)[:]
dircache.annotate(a, a_list)
dircache.annotate(b, b_list)
a_list.sort()
b_list.sort()
#
for x in a_list:
if x in ['./', '../']:
pass
elif x not in b_list:
a_only.append((x, a_only_action))
else:
ax = os.path.join(a, x)
bx = os.path.join(b, x)
if os.path.isdir(ax) and os.path.isdir(bx):
if flags == '-r':
same = dircmp(ax, bx)
else:
same = 0
else:
try:
same = cmp.cmp(ax, bx)
except (RuntimeError, os.error):
same = 0
if same:
ab_same.append((x, ab_same_action))
else:
ab_diff.append((x, ab_diff_action))
#
for x in b_list:
if x in ['./', '../']:
pass
elif x not in a_list:
b_only.append((x, b_only_action))
#
return data
# Re-read the directory.
# Attempt to find the selected item back.
def update(w):
setbusy(w)
icol, irow = w.selection
if 0 <= icol < len(w.data) and 2 <= irow < len(w.data[icol]):
selname = w.data[icol][irow][0]
else:
selname = ''
statcache.forget_dir(w.a)
statcache.forget_dir(w.b)
tablewin.select(w, (-1, -1))
tablewin.update(w, diffdata(w.a, w.b, w.flags))
if selname:
for icol in range(len(w.data)):
for irow in range(2, len(w.data[icol])):
if w.data[icol][irow][0] == selname:
tablewin.select(w, (icol, irow))
break
# Action functions for table items in directory diff windows
def header_action(w, string, (icol, irow), (pos, clicks, button, mask)):
tablewin.select(w, (-1, -1))
def a_only_action(w, string, (icol, irow), (pos, clicks, button, mask)):
tablewin.select(w, (icol, irow))
if clicks == 2:
w2 = anyopen(os.path.join(w.a, string))
if w2:
w2.parent = w
def b_only_action(w, string, (icol, irow), (pos, clicks, button, mask)):
tablewin.select(w, (icol, irow))
if clicks == 2:
w2 = anyopen(os.path.join(w.b, string))
if w2:
w2.parent = w
def ab_diff_action(w, string, (icol, irow), (pos, clicks, button, mask)):
tablewin.select(w, (icol, irow))
if clicks == 2:
w2 = anydiff(os.path.join(w.a, string), os.path.join(w.b, string),'')
w2.parent = w
def ab_same_action(w, string, sel, detail):
ax = os.path.join(w.a, string)
if os.path.isdir(ax):
ab_diff_action(w, string, sel, detail)
else:
a_only_action(w, string, sel, detail)
def anyopen(name): # Open any kind of document, ignore errors
try:
w = anywin.open(name)
except (RuntimeError, os.error):
stdwin.message('Can\'t open ' + name)
return 0
addstatmenu(w, [name])
return w
def dircmp(a, b): # Compare whether two directories are the same
# To make this as fast as possible, it uses the statcache
print ' dircmp', a, b
a_list = dircache.listdir(a)
b_list = dircache.listdir(b)
for x in a_list:
if skipthis(x):
pass
elif x not in b_list:
return 0
else:
ax = os.path.join(a, x)
bx = os.path.join(b, x)
if statcache.isdir(ax) and statcache.isdir(bx):
if not dircmp(ax, bx): return 0
else:
try:
if not cmpcache.cmp(ax, bx): return 0
except (RuntimeError, os.error):
return 0
for x in b_list:
if skipthis(x):
pass
elif x not in a_list:
return 0
return 1
# View menu (for dir diff windows only)
def addviewmenu(w):
w.viewmenu = m = w.menucreate('View')
m.action = []
add(m, 'diff -r A B', diffr_ab)
add(m, 'diff A B', diff_ab)
add(m, 'diff -b A B', diffb_ab)
add(m, 'diff -c A B', diffc_ab)
add(m, 'gdiff A B', gdiff_ab)
add(m, ('Open A ', 'A'), open_a)
add(m, ('Open B ', 'B'), open_b)
add(m, 'Rescan', rescan)
add(m, 'Rescan -r', rescan_r)
# Action menu (for dir diff windows only)
def addactionmenu(w):
w.actionmenu = m = w.menucreate('Action')
m.action = []
add(m, 'cp A B', cp_ab)
add(m, 'rm B', rm_b)
add(m, '', nop)
add(m, 'cp B A', cp_ba)
add(m, 'rm A', rm_a)
# Main menu (global):
def mainmenu():
m = stdwin.menucreate('Wdiff')
m.action = []
add(m, ('Quit wdiff', 'Q'), quit_wdiff)
add(m, 'Close subwindows', close_subwindows)
return m
def add(m, text, action):
m.additem(text)
m.action.append(action)
def quit_wdiff(w, m, item):
if askyesno('Really quit wdiff altogether?', 1):
sys.exit(0)
def close_subwindows(w, m, item):
while 1:
for w2 in gwin.windows:
if w2.parent == w:
close_subwindows(w2, m, item)
w2.close(w2)
break # inner loop, continue outer loop
else:
break # outer loop
def diffr_ab(w, m, item):
dodiff(w, '-r')
def diff_ab(w, m, item):
dodiff(w, '')
def diffb_ab(w, m, item):
dodiff(w, '-b')
def diffc_ab(w, m, item):
dodiff(w, '-c')
def gdiff_ab(w, m, item): # Call SGI's gdiff utility
x = getselection(w)
if x:
a, b = os.path.join(w.a, x), os.path.join(w.b, x)
if os.path.isdir(a) or os.path.isdir(b):
stdwin.fleep() # This is for files only
else:
diffcmd = 'gdiff'
diffcmd = diffcmd + mkarg(a) + mkarg(b) + ' &'
print diffcmd
sts = os.system(diffcmd)
if sts: print 'Exit status', sts
def dodiff(w, flags):
x = getselection(w)
if x:
w2 = anydiff(os.path.join(w.a, x), os.path.join(w.b, x), flags)
w2.parent = w
def open_a(w, m, item):
x = getselection(w)
if x:
w2 = anyopen(os.path.join(w.a, x))
if w2:
w2.parent = w
def open_b(w, m, item):
x = getselection(w)
if x:
w2 = anyopen(os.path.join(w.b, x))
if w2:
w2.parent = w
def rescan(w, m, item):
w.flags = ''
update(w)
def rescan_r(w, m, item):
w.flags = '-r'
update(w)
def rm_a(w, m, item):
x = getselection(w)
if x:
if x[-1:] == '/': x = x[:-1]
x = os.path.join(w.a, x)
if os.path.isdir(x):
if askyesno('Recursively remove A directory ' + x, 1):
runcmd('rm -rf' + mkarg(x))
else:
runcmd('rm -f' + mkarg(x))
update(w)
def rm_b(w, m, item):
x = getselection(w)
if x:
if x[-1:] == '/': x = x[:-1]
x = os.path.join(w.b, x)
if os.path.isdir(x):
if askyesno('Recursively remove B directory ' + x, 1):
runcmd('rm -rf' + mkarg(x))
else:
runcmd('rm -f' + mkarg(x))
update(w)
def cp_ab(w, m, item):
x = getselection(w)
if x:
if x[-1:] == '/': x = x[:-1]
ax = os.path.join(w.a, x)
bx = os.path.join(w.b, x)
if os.path.isdir(ax):
if os.path.exists(bx):
m = 'Can\'t copy directory to existing target'
stdwin.message(m)
return
runcmd('cp -r' + mkarg(ax) + mkarg(w.b))
else:
runcmd('cp' + mkarg(ax) + mk2arg(w.b, x))
update(w)
def cp_ba(w, m, item):
x = getselection(w)
if x:
if x[-1:] == '/': x = x[:-1]
ax = os.path.join(w.a, x)
bx = os.path.join(w.b, x)
if os.path.isdir(bx):
if os.path.exists(ax):
m = 'Can\'t copy directory to existing target'
stdwin.message(m)
return
runcmd('cp -r' + mkarg(bx) + mkarg(w.a))
else:
runcmd('cp' + mk2arg(w.b, x) + mkarg(ax))
update(w)
def nop(args):
pass
def getselection(w):
icol, irow = w.selection
if 0 <= icol < len(w.data):
if 0 <= irow < len(w.data[icol]):
return w.data[icol][irow][0]
stdwin.message('no selection')
return ''
def runcmd(cmd):
print cmd
sts, output = commands.getstatusoutput(cmd)
if sts or output:
if not output:
output = 'Exit status ' + `sts`
stdwin.message(output)
# Status menu (for all kinds of windows)
def addstatmenu(w, files):
w.statmenu = m = w.menucreate('Stat')
m.files = files
m.action = []
for file in files:
m.additem(commands.getstatus(file))
m.action.append(stataction)
def stataction(w, m, item): # Menu item action for stat menu
file = m.files[item]
try:
m.setitem(item, commands.getstatus(file))
except os.error:
stdwin.message('Can\'t get status for ' + file)
# Compute a suitable window title from two paths
def mktitle(a, b):
if a == b: return a
i = 1
while a[-i:] == b[-i:]: i = i+1
i = i-1
if not i:
return a + ' ' + b
else:
return '{' + a[:-i] + ',' + b[:-i] + '}' + a[-i:]
# Ask a confirmation question
def askyesno(prompt, default):
try:
return stdwin.askync(prompt, default)
except KeyboardInterrupt:
return 0
# Display a message "busy" in a window, and mark it for updating
def setbusy(w):
left, top = w.getorigin()
width, height = w.getwinsize()
right, bottom = left + width, top + height
d = w.begindrawing()
d.erase((0, 0), (10000, 10000))
text = 'Busy...'
textwidth = d.textwidth(text)
textheight = d.lineheight()
h, v = left + (width-textwidth)/2, top + (height-textheight)/2
d.text((h, v), text)
del d
w.change((0, 0), (10000, 10000))
# Main function
def main():
print 'wdiff: warning: this program does NOT make backups'
argv = sys.argv
flags = ''
if len(argv) >= 2 and argv[1][:1] == '-':
flags = argv[1]
del argv[1]
stdwin.setdefscrollbars(0, 1)
m = mainmenu() # Create menu earlier than windows
if len(argv) == 2: # 1 argument
w = anyopen(argv[1])
if not w: return
elif len(argv) == 3: # 2 arguments
w = anydiff(argv[1], argv[2], flags)
w.parent = ()
else:
sys.stdout = sys.stderr
print 'usage:', argv[0], '[diff-flags] dir-1 [dir-2]'
sys.exit(2)
del w # It's preserved in gwin.windows
while 1:
try:
gwin.mainloop()
break
except KeyboardInterrupt:
pass # Just continue...
# Start the main function (this is a script)
main()
|