Rewrite log command. New version is faster and more featureful.
The original implementation of log walked backwards through history,
which had terrible behaviour. It took several minutes to view
complete kernel change history on a fast machine, for example.
The rewrite uses a windowed approach to walk hunks of history
forwards, while still giving results in reverse order. This reduces
run time from five minutes to five seconds on my system.
In addition, the rewrite uses our normal name handling mechanisms, so
you can run a command like "hg log net/ipv4/**.c" and get a useful
answer. It optimises for three different cases (no arguments, only
files, and anything goes), so it performs well in all circumstances
I've tested.
# util.py - utility functions and platform specfic implementations
#
# Copyright 2005 K. Thananchayan <thananck@yahoo.com>
#
# This software may be used and distributed according to the terms
# of the GNU General Public License, incorporated herein by reference.
import os, errno
from demandload import *
demandload(globals(), "re")
def binary(s):
if s and '\0' in s[:4096]:
return True
return False
def unique(g):
seen = {}
for f in g:
if f not in seen:
seen[f] = 1
yield f
class Abort(Exception):
"""Raised if a command needs to print an error and exit."""
def always(fn): return True
def never(fn): return False
def globre(pat, head = '^', tail = '$'):
"convert a glob pattern into a regexp"
i, n = 0, len(pat)
res = ''
group = False
def peek(): return i < n and pat[i]
while i < n:
c = pat[i]
i = i+1
if c == '*':
if peek() == '*':
i += 1
res += '.*'
else:
res += '[^/]*'
elif c == '?':
res += '.'
elif c == '[':
j = i
if j < n and pat[j] in '!]':
j += 1
while j < n and pat[j] != ']':
j += 1
if j >= n:
res += '\\['
else:
stuff = pat[i:j].replace('\\','\\\\')
i = j + 1
if stuff[0] == '!':
stuff = '^' + stuff[1:]
elif stuff[0] == '^':
stuff = '\\' + stuff
res = '%s[%s]' % (res, stuff)
elif c == '{':
group = True
res += '(?:'
elif c == '}' and group:
res += ')'
group = False
elif c == ',' and group:
res += '|'
else:
res += re.escape(c)
return head + res + tail
_globchars = {'[': 1, '{': 1, '*': 1, '?': 1}
def pathto(n1, n2):
'''return the relative path from one place to another.
this returns a path in the form used by the local filesystem, not hg.'''
if not n1: return localpath(n2)
a, b = n1.split('/'), n2.split('/')
a.reverse(), b.reverse()
while a and b and a[-1] == b[-1]:
a.pop(), b.pop()
b.reverse()
return os.sep.join((['..'] * len(a)) + b)
def canonpath(repo, cwd, myname):
rootsep = repo.root + os.sep
name = myname
if not name.startswith(os.sep):
name = os.path.join(repo.root, cwd, name)
name = os.path.normpath(name)
if name.startswith(rootsep):
return pconvert(name[len(rootsep):])
elif name == repo.root:
return ''
else:
raise Abort('%s not under repository root' % myname)
def matcher(repo, cwd, names, inc, exc, head = ''):
def patkind(name):
for prefix in 're:', 'glob:', 'path:', 'relpath:':
if name.startswith(prefix): return name.split(':', 1)
for c in name:
if c in _globchars: return 'glob', name
return 'relpath', name
def regex(kind, name, tail):
'''convert a pattern into a regular expression'''
if kind == 're':
return name
elif kind == 'path':
return '^' + re.escape(name) + '(?:/|$)'
elif kind == 'relpath':
return head + re.escape(name) + tail
return head + globre(name, '', tail)
def matchfn(pats, tail):
"""build a matching function from a set of patterns"""
if pats:
pat = '(?:%s)' % '|'.join([regex(k, p, tail) for (k, p) in pats])
return re.compile(pat).match
def globprefix(pat):
'''return the non-glob prefix of a path, e.g. foo/* -> foo'''
root = []
for p in pat.split(os.sep):
if patkind(p)[0] == 'glob': break
root.append(p)
return '/'.join(root)
pats = []
files = []
roots = []
for kind, name in map(patkind, names):
if kind in ('glob', 'relpath'):
name = canonpath(repo, cwd, name)
if name == '':
kind, name = 'glob', '**'
if kind in ('glob', 'path', 're'):
pats.append((kind, name))
if kind == 'glob':
root = globprefix(name)
if root: roots.append(root)
elif kind == 'relpath':
files.append((kind, name))
roots.append(name)
patmatch = matchfn(pats, '$') or always
filematch = matchfn(files, '(?:/|$)') or always
incmatch = always
if inc:
incmatch = matchfn(map(patkind, inc), '(?:/|$)')
excmatch = lambda fn: False
if exc:
excmatch = matchfn(map(patkind, exc), '(?:/|$)')
return (roots,
lambda fn: (incmatch(fn) and not excmatch(fn) and
(fn.endswith('/') or
(not pats and not files) or
(pats and patmatch(fn)) or
(files and filematch(fn)))),
(inc or exc or (pats and pats != [('glob', '**')])) and True)
def system(cmd, errprefix=None):
"""execute a shell command that must succeed"""
rc = os.system(cmd)
if rc:
errmsg = "%s %s" % (os.path.basename(cmd.split(None, 1)[0]),
explain_exit(rc)[0])
if errprefix:
errmsg = "%s: %s" % (errprefix, errmsg)
raise Abort(errmsg)
def rename(src, dst):
try:
os.rename(src, dst)
except:
os.unlink(dst)
os.rename(src, dst)
def copytree(src, dst, copyfile):
"""Copy a directory tree, files are copied using 'copyfile'."""
names = os.listdir(src)
os.mkdir(dst)
for name in names:
srcname = os.path.join(src, name)
dstname = os.path.join(dst, name)
if os.path.isdir(srcname):
copytree(srcname, dstname, copyfile)
elif os.path.isfile(srcname):
copyfile(srcname, dstname)
else:
pass
def _makelock_file(info, pathname):
ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
os.write(ld, info)
os.close(ld)
def _readlock_file(pathname):
return file(pathname).read()
# Platfor specific varients
if os.name == 'nt':
nulldev = 'NUL:'
def is_exec(f, last):
return last
def set_exec(f, mode):
pass
def pconvert(path):
return path.replace("\\", "/")
def localpath(path):
return path.replace('/', '\\')
def normpath(path):
return pconvert(os.path.normpath(path))
makelock = _makelock_file
readlock = _readlock_file
def explain_exit(code):
return "exited with status %d" % code, code
else:
nulldev = '/dev/null'
def is_exec(f, last):
return (os.stat(f).st_mode & 0100 != 0)
def set_exec(f, mode):
s = os.stat(f).st_mode
if (s & 0100 != 0) == mode:
return
if mode:
# Turn on +x for every +r bit when making a file executable
# and obey umask.
umask = os.umask(0)
os.umask(umask)
os.chmod(f, s | (s & 0444) >> 2 & ~umask)
else:
os.chmod(f, s & 0666)
def pconvert(path):
return path
def localpath(path):
return path
normpath = os.path.normpath
def makelock(info, pathname):
try:
os.symlink(info, pathname)
except OSError, why:
if why.errno == errno.EEXIST:
raise
else:
_makelock_file(info, pathname)
def readlock(pathname):
try:
return os.readlink(pathname)
except OSError, why:
if why.errno == errno.EINVAL:
return _readlock_file(pathname)
else:
raise
def explain_exit(code):
"""return a 2-tuple (desc, code) describing a process's status"""
if os.WIFEXITED(code):
val = os.WEXITSTATUS(code)
return "exited with status %d" % val, val
elif os.WIFSIGNALED(code):
val = os.WTERMSIG(code)
return "killed by signal %d" % val, val
elif os.WIFSTOPPED(code):
val = os.WSTOPSIG(code)
return "stopped by signal %d" % val, val
raise ValueError("invalid exit code")