a Python-based replacement for svnlook

jahson

#!/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 sysimport timeimport 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()