a Python-based replacement for svnlook

michellc

#!/usr/bin/env python
#
# svnlook.py : a Python-based replacement for svnlook
#
######################################################################
#    Licensed to the Subversion Corporation (SVN Corp.) under one
#    or more contributor license agreements.  See the NOTICE file
#    distributed with this work for additional information
#    regarding copyright ownership.  The SVN Corp. licenses this file
#    to you under the Apache License, Version 2.0 (the
#    "License"); you may not use this file except in compliance
#    with the License.  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing,
#    software distributed under the License is distributed on an
#    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#    KIND, either express or implied.  See the License for the
#    specific language governing permissions and limitations
#    under the License.
######################################################################
#
import sys
import time
import os
from svn import core, fs, delta, repos
class SVNLook:
def __init__(self, path, cmd, rev, txn):
path = core.svn_path_canonicalize(path)
repos_ptr = repos.open(path)
self.fs_ptr = repos.fs(repos_ptr)
if txn:
self.txn_ptr = fs.open_txn(self.fs_ptr, txn)
else:
self.txn_ptr = None
if rev is None:
rev = fs.youngest_rev(self.fs_ptr)
self.rev = rev
getattr(self, 'cmd_' + cmd)()
def cmd_default(self):
self.cmd_info()
self.cmd_tree()
def cmd_author(self):
# get the author property, or empty string if the property is not present
author = self._get_property(core.SVN_PROP_REVISION_AUTHOR) or ''
print(author)
def cmd_changed(self):
self._print_tree(ChangedEditor, pass_root=1)
def cmd_date(self):
if self.txn_ptr:
print("")
else:
date = self._get_property(core.SVN_PROP_REVISION_DATE)
if date:
aprtime = core.svn_time_from_cstring(date)
# ### convert to a time_t; this requires intimate knowledge of
# ### the apr_time_t type
secs = aprtime / 1000000  # aprtime is microseconds; make seconds
# assume secs in local TZ, convert to tuple, and format
### we don't really know the TZ, do we?
print(time.strftime('%Y-%m-%d %H:%M', time.localtime(secs)))
else:
print("")
def cmd_diff(self):
self._print_tree(DiffEditor, pass_root=1)
def cmd_dirs_changed(self):
self._print_tree(DirsChangedEditor)
def cmd_ids(self):
self._print_tree(Editor, base_rev=0, pass_root=1)
def cmd_info(self):
self.cmd_author()
self.cmd_date()
self.cmd_log(1)
def cmd_log(self, print_size=0):
# get the log property, or empty string if the property is not present
log = self._get_property(core.SVN_PROP_REVISION_LOG) or ''
if print_size:
print(len(log))
print(log)
def cmd_tree(self):
self._print_tree(Editor, base_rev=0)
def _get_property(self, name):
if self.txn_ptr:
return fs.txn_prop(self.txn_ptr, name)
return fs.revision_prop(self.fs_ptr, self.rev, name)
def _print_tree(self, e_factory, base_rev=None, pass_root=0):
if base_rev is None:
# a specific base rev was not provided. use the transaction base,
# or the previous revision
if self.txn_ptr:
base_rev = fs.txn_base_revision(self.txn_ptr)
else:
base_rev = self.rev - 1
# get the current root
if self.txn_ptr:
root = fs.txn_root(self.txn_ptr)
else:
root = fs.revision_root(self.fs_ptr, self.rev)
# the base of the comparison
base_root = fs.revision_root(self.fs_ptr, base_rev)
if pass_root:
editor = e_factory(root, base_root)
else:
editor = e_factory()
# construct the editor for printing these things out
e_ptr, e_baton = delta.make_editor(editor)
# compute the delta, printing as we go
def authz_cb(root, path, pool):
return 1
repos.dir_delta(base_root, '', '', root, '',
e_ptr, e_baton, authz_cb, 0, 1, 0, 0)

class Editor(delta.Editor):
def __init__(self, root=None, base_root=None):
self.root = root
# base_root ignored
self.indent = ''
def open_root(self, base_revision, dir_pool):
print('/' + self._get_id('/'))
self.indent = self.indent + ' '    # indent one space
def add_directory(self, path, *args):
id = self._get_id(path)
print(self.indent + _basename(path) + '/' + id)
self.indent = self.indent + ' '    # indent one space
# we cheat. one method implementation for two entry points.
open_directory = add_directory
def close_directory(self, baton):
# note: if indents are being performed, this slice just returns
# another empty string.
self.indent = self.indent[:-1]
def add_file(self, path, *args):
id = self._get_id(path)
print(self.indent + _basename(path) + id)
# we cheat. one method implementation for two entry points.
open_file = add_file
def _get_id(self, path):
if self.root:
id = fs.node_id(self.root, path)
return ' <%s>' % fs.unparse_id(id)
return ''
class DirsChangedEditor(delta.Editor):
def open_root(self, base_revision, dir_pool):
return [ 1, '' ]
def delete_entry(self, path, revision, parent_baton, pool):
self._dir_changed(parent_baton)
def add_directory(self, path, parent_baton,
copyfrom_path, copyfrom_revision, dir_pool):
self._dir_changed(parent_baton)
return [ 1, path ]
def open_directory(self, path, parent_baton, base_revision, dir_pool):
return [ 1, path ]
def change_dir_prop(self, dir_baton, name, value, pool):
self._dir_changed(dir_baton)
def add_file(self, path, parent_baton,
copyfrom_path, copyfrom_revision, file_pool):
self._dir_changed(parent_baton)
def open_file(self, path, parent_baton, base_revision, file_pool):
# some kind of change is going to happen
self._dir_changed(parent_baton)
def _dir_changed(self, baton):
if baton[0]:
# the directory hasn't been printed yet. do it.
print(baton[1] + '/')
baton[0] = 0
class ChangedEditor(delta.Editor):
def __init__(self, root, base_root):
self.root = root
self.base_root = base_root
def open_root(self, base_revision, dir_pool):
return [ 1, '' ]
def delete_entry(self, path, revision, parent_baton, pool):
### need more logic to detect 'replace'
if fs.is_dir(self.base_root, '/' + path):
print('D   ' + path + '/')
else:
print('D   ' + path)
def add_directory(self, path, parent_baton,
copyfrom_path, copyfrom_revision, dir_pool):
print('A   ' + path + '/')
return [ 0, path ]
def open_directory(self, path, parent_baton, base_revision, dir_pool):
return [ 1, path ]
def change_dir_prop(self, dir_baton, name, value, pool):
if dir_baton[0]:
# the directory hasn't been printed yet. do it.
print('_U  ' + dir_baton[1] + '/')
dir_baton[0] = 0
def add_file(self, path, parent_baton,
copyfrom_path, copyfrom_revision, file_pool):
print('A   ' + path)
return [ '_', ' ', None ]
def open_file(self, path, parent_baton, base_revision, file_pool):
return [ '_', ' ', path ]
def apply_textdelta(self, file_baton, base_checksum):
file_baton[0] = 'U'
# no handler
return None
def change_file_prop(self, file_baton, name, value, pool):
file_baton[1] = 'U'
def close_file(self, file_baton, text_checksum):
text_mod, prop_mod, path = file_baton
# test the path. it will be None if we added this file.
if path:
status = text_mod + prop_mod
# was there some kind of change?
if status != '_ ':
print(status + '  ' + path)

class DiffEditor(delta.Editor):
def __init__(self, root, base_root):
self.root = root
self.base_root = base_root
self.target_revision = 0
def _do_diff(self, base_path, path):
if base_path is None:
print("Added: " + path)
label = path
elif path is None:
print("Removed: " + base_path)
label = base_path
else:
print("Modified: " + path)
label = path
print("===============================================================" + \
"===============")
args = []
args.append("-L")
args.append(label + "\t(original)")
args.append("-L")
args.append(label + "\t(new)")
args.append("-u")
differ = fs.FileDiff(self.base_root, base_path, self.root,
path, diffoptions=args)
pobj = differ.get_pipe()
while True:
line = pobj.readline()
if not line:
break
sys.stdout.write("%s " % line)
print("")
def _do_prop_diff(self, path, prop_name, prop_val, pool):
print("Property changes on: " + path)
print("_______________________________________________________________" + \
"_______________")
old_prop_val = None
try:
old_prop_val = fs.node_prop(self.base_root, path, prop_name, pool)
except core.SubversionException:
pass # Must be a new path
if old_prop_val:
if prop_val:
print("Modified: " + prop_name)
print("   - " + str(old_prop_val))
print("   + " + str(prop_val))
else:
print("Deleted: " + prop_name)
print("   - " + str(old_prop_val))
else:
print("Added: " + prop_name)
print("   + " + str(prop_val))
print("")
def delete_entry(self, path, revision, parent_baton, pool):
### need more logic to detect 'replace'
if not fs.is_dir(self.base_root, '/' + path):
self._do_diff(path, None)
def add_directory(self, path, parent_baton, copyfrom_path,
copyfrom_revision, dir_pool):
return [ 1, path ]
def add_file(self, path, parent_baton,
copyfrom_path, copyfrom_revision, file_pool):
self._do_diff(None, path)
return [ '_', ' ', None ]
def open_root(self, base_revision, dir_pool):
return [ 1, '' ]
def open_directory(self, path, parent_baton, base_revision, dir_pool):
return [ 1, path ]
def open_file(self, path, parent_baton, base_revision, file_pool):
return [ '_', ' ', path ]
def apply_textdelta(self, file_baton, base_checksum):
if file_baton[2] is not None:
self._do_diff(file_baton[2], file_baton[2])
return None
def change_file_prop(self, file_baton, name, value, pool):
if file_baton[2] is not None:
self._do_prop_diff(file_baton[2], name, value, pool)
return None
def change_dir_prop(self, dir_baton, name, value, pool):
if dir_baton[1] is not None:
self._do_prop_diff(dir_baton[1], name, value, pool)
return None
def set_target_revision(self, target_revision):
self.target_revision = target_revision
def _basename(path):
"Return the basename for a '/'-separated path."
idx = path.rfind('/')
if idx == -1:
return path
return path[idx+1:]

def usage(exit):
if exit:
output = sys.stderr
else:
output = sys.stdout
output.write(
"usage: %s REPOS_PATH rev REV [COMMAND] - inspect revision REV\n"
"       %s REPOS_PATH txn TXN [COMMAND] - inspect transaction TXN\n"
"       %s REPOS_PATH [COMMAND] - inspect the youngest revision\n"
"\n"
"REV is a revision number > 0.\n"
"TXN is a transaction name.\n"
"\n"
"If no command is given, the default output (which is the same as\n"
"running the subcommands `info' then `tree') will be printed.\n"
"\n"
"COMMAND can be one of: \n"
"\n"
"   author:        print author.\n"
"   changed:       print full change summary: all dirs & files changed.\n"
"   date:          print the timestamp (revisions only).\n"
"   diff:          print GNU-style diffs of changed files and props.\n"
"   dirs-changed:  print changed directories.\n"
"   ids:           print the tree, with nodes ids.\n"
"   info:          print the author, data, log_size, and log message.\n"
"   log:           print log message.\n"
"   tree:          print the tree.\n"
"\n"
% (sys.argv[0], sys.argv[0], sys.argv[0]))
sys.exit(exit)
def main():
if len(sys.argv) < 2:
usage(1)
rev = txn = None
args = sys.argv[2:]
if args:
cmd = args[0]
if cmd == 'rev':
if len(args) == 1:
usage(1)
try:
rev = int(args[1])
except ValueError:
usage(1)
del args[:2]
elif cmd == 'txn':
if len(args) == 1:
usage(1)
txn = args[1]
del args[:2]
if args:
if len(args) > 1:
usage(1)
cmd = args[0].replace('-', '_')
else:
cmd = 'default'
if not hasattr(SVNLook, 'cmd_' + cmd):
usage(1)
SVNLook(sys.argv[1], cmd, rev, txn)
if __name__ == '__main__':
main()