util.py
1563 lines
| 48.3 KiB
| text/x-python
|
PythonLexer
/ mercurial / util.py
|
r8226 | # util.py - Mercurial utility functions and platform specfic implementations | ||
# | ||||
# Copyright 2005 K. Thananchayan <thananck@yahoo.com> | ||||
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||||
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r1082 | |||
|
r8227 | """Mercurial utility functions and platform specfic implementations. | ||
|
r1082 | |||
|
r8227 | This contains helper routines that are independent of the SCM core and | ||
hide platform-specific details from the core. | ||||
|
r1082 | """ | ||
|
r419 | |||
|
r3891 | from i18n import _ | ||
|
r9480 | import error, osutil, encoding | ||
|
r11758 | import errno, re, shutil, sys, tempfile, traceback | ||
|
r11297 | import os, stat, time, calendar, textwrap, unicodedata, signal | ||
|
r12076 | import imp, socket | ||
|
r3769 | |||
|
r6470 | # Python compatibility | ||
|
r3769 | |||
|
r6470 | def sha1(s): | ||
|
r8297 | return _fastsha1(s) | ||
def _fastsha1(s): | ||||
# This function will import sha1 from hashlib or sha (whichever is | ||||
# available) and overwrite itself with it on the first call. | ||||
# Subsequent calls will go directly to the imported function. | ||||
|
r12051 | if sys.version_info >= (2, 5): | ||
|
r8297 | from hashlib import sha1 as _sha1 | ||
|
r12051 | else: | ||
|
r8295 | from sha import sha as _sha1 | ||
|
r8309 | global _fastsha1, sha1 | ||
_fastsha1 = sha1 = _sha1 | ||||
|
r6470 | return _sha1(s) | ||
|
r10756 | import __builtin__ | ||
|
r11566 | if sys.version_info[0] < 3: | ||
def fakebuffer(sliceable, offset=0): | ||||
return sliceable[offset:] | ||||
else: | ||||
def fakebuffer(sliceable, offset=0): | ||||
return memoryview(sliceable)[offset:] | ||||
|
r11565 | try: | ||
buffer | ||||
except NameError: | ||||
|
r10756 | __builtin__.buffer = fakebuffer | ||
|
r8280 | import subprocess | ||
closefds = os.name == 'posix' | ||||
|
r10197 | |||
|
r10199 | def popen2(cmd, env=None, newlines=False): | ||
|
r9089 | # Setting bufsize to -1 lets the system decide the buffer size. | ||
# The default for bufsize is 0, meaning unbuffered. This leads to | ||||
# poor performance on Mac OS X: http://bugs.python.org/issue4194 | ||||
p = subprocess.Popen(cmd, shell=True, bufsize=-1, | ||||
|
r9083 | close_fds=closefds, | ||
|
r10197 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||
|
r10199 | universal_newlines=newlines, | ||
env=env) | ||||
|
r8280 | return p.stdin, p.stdout | ||
|
r10197 | |||
|
r10199 | def popen3(cmd, env=None, newlines=False): | ||
|
r9089 | p = subprocess.Popen(cmd, shell=True, bufsize=-1, | ||
|
r9083 | close_fds=closefds, | ||
|
r8280 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||
|
r10197 | stderr=subprocess.PIPE, | ||
|
r10199 | universal_newlines=newlines, | ||
env=env) | ||||
|
r8280 | return p.stdin, p.stdout, p.stderr | ||
|
r7106 | |||
|
r7632 | def version(): | ||
"""Return version information if available.""" | ||||
try: | ||||
import __version__ | ||||
return __version__.version | ||||
except ImportError: | ||||
return 'unknown' | ||||
|
r2609 | # used by parsedate | ||
|
r3808 | defaultdateformats = ( | ||
'%Y-%m-%d %H:%M:%S', | ||||
'%Y-%m-%d %I:%M:%S%p', | ||||
'%Y-%m-%d %H:%M', | ||||
'%Y-%m-%d %I:%M%p', | ||||
'%Y-%m-%d', | ||||
'%m-%d', | ||||
'%m/%d', | ||||
'%m/%d/%y', | ||||
'%m/%d/%Y', | ||||
'%a %b %d %H:%M:%S %Y', | ||||
'%a %b %d %I:%M:%S%p %Y', | ||||
|
r4708 | '%a, %d %b %Y %H:%M:%S', # GNU coreutils "/bin/date --rfc-2822" | ||
|
r3808 | '%b %d %H:%M:%S %Y', | ||
|
r3812 | '%b %d %I:%M:%S%p %Y', | ||
'%b %d %H:%M:%S', | ||||
|
r3808 | '%b %d %I:%M:%S%p', | ||
'%b %d %H:%M', | ||||
'%b %d %I:%M%p', | ||||
'%b %d %Y', | ||||
'%b %d', | ||||
'%H:%M:%S', | ||||
|
r9383 | '%I:%M:%S%p', | ||
|
r3808 | '%H:%M', | ||
'%I:%M%p', | ||||
) | ||||
|
r2609 | |||
|
r3812 | extendeddateformats = defaultdateformats + ( | ||
"%Y", | ||||
"%Y-%m", | ||||
"%b", | ||||
"%b %Y", | ||||
) | ||||
|
r2609 | |||
|
r3145 | def cachefunc(func): | ||
'''cache the result of function calls''' | ||||
|
r3147 | # XXX doesn't handle keywords args | ||
|
r3145 | cache = {} | ||
if func.func_code.co_argcount == 1: | ||||
|
r3147 | # we gain a small amount of time because | ||
# we don't need to pack/unpack the list | ||||
|
r3145 | def f(arg): | ||
if arg not in cache: | ||||
cache[arg] = func(arg) | ||||
return cache[arg] | ||||
else: | ||||
def f(*args): | ||||
if args not in cache: | ||||
cache[args] = func(*args) | ||||
return cache[args] | ||||
return f | ||||
|
r9097 | def lrucachefunc(func): | ||
'''cache most recent results of function calls''' | ||||
cache = {} | ||||
order = [] | ||||
if func.func_code.co_argcount == 1: | ||||
def f(arg): | ||||
if arg not in cache: | ||||
if len(cache) > 20: | ||||
del cache[order.pop(0)] | ||||
cache[arg] = func(arg) | ||||
else: | ||||
order.remove(arg) | ||||
order.append(arg) | ||||
return cache[arg] | ||||
else: | ||||
def f(*args): | ||||
if args not in cache: | ||||
if len(cache) > 20: | ||||
del cache[order.pop(0)] | ||||
cache[args] = func(*args) | ||||
else: | ||||
order.remove(args) | ||||
order.append(args) | ||||
return cache[args] | ||||
return f | ||||
|
r8207 | class propertycache(object): | ||
def __init__(self, func): | ||||
self.func = func | ||||
self.name = func.__name__ | ||||
def __get__(self, obj, type=None): | ||||
result = self.func(obj) | ||||
setattr(obj, self.name, result) | ||||
return result | ||||
|
r1293 | def pipefilter(s, cmd): | ||
'''filter string S through command CMD, returning its output''' | ||||
|
r8302 | p = subprocess.Popen(cmd, shell=True, close_fds=closefds, | ||
stdin=subprocess.PIPE, stdout=subprocess.PIPE) | ||||
pout, perr = p.communicate(s) | ||||
return pout | ||||
|
r419 | |||
|
r1293 | def tempfilter(s, cmd): | ||
'''filter string S through a pair of temporary files with CMD. | ||||
CMD is used as a template to create the real command to be run, | ||||
with the strings INFILE and OUTFILE replaced by the real names of | ||||
the temporary files generated.''' | ||||
inname, outname = None, None | ||||
try: | ||||
|
r2165 | infd, inname = tempfile.mkstemp(prefix='hg-filter-in-') | ||
|
r1293 | fp = os.fdopen(infd, 'wb') | ||
fp.write(s) | ||||
fp.close() | ||||
|
r2165 | outfd, outname = tempfile.mkstemp(prefix='hg-filter-out-') | ||
|
r1293 | os.close(outfd) | ||
cmd = cmd.replace('INFILE', inname) | ||||
cmd = cmd.replace('OUTFILE', outname) | ||||
code = os.system(cmd) | ||||
|
r4720 | if sys.platform == 'OpenVMS' and code & 1: | ||
code = 0 | ||||
|
r10282 | if code: | ||
raise Abort(_("command '%s' failed: %s") % | ||||
(cmd, explain_exit(code))) | ||||
|
r13400 | fp = open(outname, 'rb') | ||
r = fp.read() | ||||
fp.close() | ||||
return r | ||||
|
r1293 | finally: | ||
try: | ||||
|
r10282 | if inname: | ||
os.unlink(inname) | ||||
except: | ||||
pass | ||||
|
r1293 | try: | ||
|
r10282 | if outname: | ||
os.unlink(outname) | ||||
except: | ||||
pass | ||||
|
r1293 | |||
filtertable = { | ||||
'tempfile:': tempfilter, | ||||
'pipe:': pipefilter, | ||||
} | ||||
def filter(s, cmd): | ||||
"filter a string through a command that transforms its input to its output" | ||||
for name, fn in filtertable.iteritems(): | ||||
if cmd.startswith(name): | ||||
return fn(s, cmd[len(name):].lstrip()) | ||||
return pipefilter(s, cmd) | ||||
|
r1015 | def binary(s): | ||
|
r6507 | """return true if a string is binary data""" | ||
|
r8118 | return bool(s and '\0' in s) | ||
|
r6762 | |||
|
r7396 | def increasingchunks(source, min=1024, max=65536): | ||
'''return no less than min bytes per chunk while data remains, | ||||
doubling min after each chunk until it reaches max''' | ||||
def log2(x): | ||||
if not x: | ||||
return 0 | ||||
i = 0 | ||||
while x: | ||||
x >>= 1 | ||||
i += 1 | ||||
return i - 1 | ||||
buf = [] | ||||
blen = 0 | ||||
for chunk in source: | ||||
buf.append(chunk) | ||||
blen += len(chunk) | ||||
if blen >= min: | ||||
if min < max: | ||||
min = min << 1 | ||||
nmin = 1 << log2(blen) | ||||
if nmin > min: | ||||
min = nmin | ||||
if min > max: | ||||
min = max | ||||
yield ''.join(buf) | ||||
blen = 0 | ||||
buf = [] | ||||
if buf: | ||||
yield ''.join(buf) | ||||
|
r7947 | Abort = error.Abort | ||
|
r508 | |||
|
r10282 | def always(fn): | ||
return True | ||||
def never(fn): | ||||
return False | ||||
|
r724 | |||
|
r4229 | def pathto(root, n1, n2): | ||
|
r886 | '''return the relative path from one place to another. | ||
|
r4229 | root should use os.sep to separate directories | ||
|
r3669 | n1 should use os.sep to separate directories | ||
n2 should use "/" to separate directories | ||||
returns an os.sep-separated path. | ||||
|
r4229 | |||
If n1 is a relative path, it's assumed it's | ||||
relative to root. | ||||
n2 should always be relative to root. | ||||
|
r3669 | ''' | ||
|
r10282 | if not n1: | ||
return localpath(n2) | ||||
|
r4230 | if os.path.isabs(n1): | ||
if os.path.splitdrive(root)[0] != os.path.splitdrive(n1)[0]: | ||||
return os.path.join(root, localpath(n2)) | ||||
n2 = '/'.join((pconvert(root), n2)) | ||||
|
r5844 | a, b = splitpath(n1), n2.split('/') | ||
|
r1541 | a.reverse() | ||
b.reverse() | ||||
|
r884 | while a and b and a[-1] == b[-1]: | ||
|
r1541 | a.pop() | ||
b.pop() | ||||
|
r884 | b.reverse() | ||
|
r6111 | return os.sep.join((['..'] * len(a)) + b) or '.' | ||
|
r884 | |||
|
r12078 | def canonpath(root, cwd, myname, auditor=None): | ||
|
r1082 | """return the canonical path of myname, given cwd and root""" | ||
|
r9386 | if endswithsep(root): | ||
|
r2271 | rootsep = root | ||
|
r1566 | else: | ||
|
r1810 | rootsep = root + os.sep | ||
|
r870 | name = myname | ||
|
r2090 | if not os.path.isabs(name): | ||
|
r1081 | name = os.path.join(root, cwd, name) | ||
|
r870 | name = os.path.normpath(name) | ||
|
r12078 | if auditor is None: | ||
auditor = path_auditor(root) | ||||
|
r2278 | if name != rootsep and name.startswith(rootsep): | ||
|
r1976 | name = name[len(rootsep):] | ||
|
r12078 | auditor(name) | ||
|
r1976 | return pconvert(name) | ||
|
r1081 | elif name == root: | ||
|
r870 | return '' | ||
else: | ||||
|
r2115 | # Determine whether `name' is in the hierarchy at or beneath `root', | ||
# by iterating name=dirname(name) until that causes no change (can't | ||||
# check name == '/', because that doesn't work on windows). For each | ||||
# `name', compare dev/inode numbers. If they match, the list `rel' | ||||
# holds the reversed list of components making up the relative file | ||||
# name we want. | ||||
root_st = os.stat(root) | ||||
rel = [] | ||||
while True: | ||||
try: | ||||
name_st = os.stat(name) | ||||
except OSError: | ||||
break | ||||
|
r2193 | if samestat(name_st, root_st): | ||
|
r4086 | if not rel: | ||
# name was actually the same as root (maybe a symlink) | ||||
return '' | ||||
|
r2115 | rel.reverse() | ||
name = os.path.join(*rel) | ||||
|
r12078 | auditor(name) | ||
|
r2115 | return pconvert(name) | ||
dirname, basename = os.path.split(name) | ||||
rel.append(basename) | ||||
if dirname == name: | ||||
break | ||||
name = dirname | ||||
|
r1081 | raise Abort('%s not under root' % myname) | ||
|
r897 | |||
|
r5062 | _hgexecutable = None | ||
|
r6499 | def main_is_frozen(): | ||
"""return True if we are a frozen executable. | ||||
The code supports py2exe (most common, Windows only) and tools/freeze | ||||
(portable, not much used). | ||||
""" | ||||
return (hasattr(sys, "frozen") or # new py2exe | ||||
hasattr(sys, "importers") or # old py2exe | ||||
imp.is_frozen("__main__")) # tools/freeze | ||||
|
r5062 | def hgexecutable(): | ||
"""return location of the 'hg' executable. | ||||
Defaults to $HG or 'hg' in the search path. | ||||
""" | ||||
if _hgexecutable is None: | ||||
|
r6500 | hg = os.environ.get('HG') | ||
if hg: | ||||
set_hgexecutable(hg) | ||||
|
r6499 | elif main_is_frozen(): | ||
set_hgexecutable(sys.executable) | ||||
else: | ||||
|
r9632 | exe = find_exe('hg') or os.path.basename(sys.argv[0]) | ||
set_hgexecutable(exe) | ||||
|
r5062 | return _hgexecutable | ||
|
r4686 | |||
def set_hgexecutable(path): | ||||
|
r5062 | """set location of the 'hg' executable""" | ||
|
r4686 | global _hgexecutable | ||
|
r5062 | _hgexecutable = path | ||
|
r4686 | |||
|
r11469 | def system(cmd, environ={}, cwd=None, onerr=None, errprefix=None, out=None): | ||
|
r1882 | '''enhanced shell command execution. | ||
run with environment maybe modified, maybe in different dir. | ||||
|
r508 | |||
|
r1882 | if command fails and onerr is None, return status. if ui object, | ||
print error message and return status, else raise onerr object as | ||||
|
r11469 | exception. | ||
if out is specified, it is assumed to be a file-like object that has a | ||||
write() method. stdout and stderr will be redirected to out.''' | ||||
|
r13439 | try: | ||
sys.stdout.flush() | ||||
except Exception: | ||||
pass | ||||
|
r2601 | def py2shell(val): | ||
'convert python object into string that is useful to shell' | ||||
|
r8534 | if val is None or val is False: | ||
|
r2601 | return '0' | ||
|
r8534 | if val is True: | ||
|
r2601 | return '1' | ||
return str(val) | ||||
|
r3905 | origcmd = cmd | ||
|
r13188 | cmd = quotecommand(cmd) | ||
|
r9517 | env = dict(os.environ) | ||
env.update((k, py2shell(v)) for k, v in environ.iteritems()) | ||||
env['HG'] = hgexecutable() | ||||
|
r11469 | if out is None: | ||
rc = subprocess.call(cmd, shell=True, close_fds=closefds, | ||||
env=env, cwd=cwd) | ||||
else: | ||||
proc = subprocess.Popen(cmd, shell=True, close_fds=closefds, | ||||
env=env, cwd=cwd, stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT) | ||||
for line in proc.stdout: | ||||
out.write(line) | ||||
proc.wait() | ||||
rc = proc.returncode | ||||
|
r9517 | if sys.platform == 'OpenVMS' and rc & 1: | ||
rc = 0 | ||||
if rc and onerr: | ||||
errmsg = '%s %s' % (os.path.basename(origcmd.split(None, 1)[0]), | ||||
explain_exit(rc)[0]) | ||||
if errprefix: | ||||
errmsg = '%s: %s' % (errprefix, errmsg) | ||||
try: | ||||
onerr.warn(errmsg + '\n') | ||||
except AttributeError: | ||||
raise onerr(errmsg) | ||||
return rc | ||||
|
r1880 | |||
|
r7388 | def checksignature(func): | ||
'''wrap a function with code to check for calling errors''' | ||||
def check(*args, **kwargs): | ||||
try: | ||||
return func(*args, **kwargs) | ||||
except TypeError: | ||||
if len(traceback.extract_tb(sys.exc_info()[2])) == 1: | ||||
|
r7646 | raise error.SignatureError | ||
|
r7388 | raise | ||
return check | ||||
|
r13795 | def makedir(path, notindexed): | ||
os.mkdir(path) | ||||
|
r13235 | def unlinkpath(f): | ||
|
r1415 | """unlink and remove the directory if it is empty""" | ||
os.unlink(f) | ||||
# try removing directories that might now be empty | ||||
|
r2064 | try: | ||
os.removedirs(os.path.dirname(f)) | ||||
except OSError: | ||||
pass | ||||
|
r1415 | |||
|
r3629 | def copyfile(src, dest): | ||
|
r7767 | "copy a file, preserving mode and atime/mtime" | ||
|
r4271 | if os.path.islink(src): | ||
try: | ||||
os.unlink(dest) | ||||
except: | ||||
pass | ||||
os.symlink(os.readlink(src), dest) | ||||
else: | ||||
try: | ||||
shutil.copyfile(src, dest) | ||||
|
r13099 | shutil.copymode(src, dest) | ||
|
r4271 | except shutil.Error, inst: | ||
raise Abort(str(inst)) | ||||
|
r3629 | |||
|
r1241 | def copyfiles(src, dst, hardlink=None): | ||
"""Copy a directory tree using hardlinks if possible""" | ||||
if hardlink is None: | ||||
hardlink = (os.stat(src).st_dev == | ||||
os.stat(os.path.dirname(dst)).st_dev) | ||||
|
r698 | |||
|
r11251 | num = 0 | ||
|
r1207 | if os.path.isdir(src): | ||
os.mkdir(dst) | ||||
|
r5396 | for name, kind in osutil.listdir(src): | ||
|
r1207 | srcname = os.path.join(src, name) | ||
dstname = os.path.join(dst, name) | ||||
|
r11251 | hardlink, n = copyfiles(srcname, dstname, hardlink) | ||
num += n | ||||
|
r1207 | else: | ||
|
r1241 | if hardlink: | ||
try: | ||||
os_link(src, dst) | ||||
|
r2050 | except (IOError, OSError): | ||
|
r1241 | hardlink = False | ||
|
r1591 | shutil.copy(src, dst) | ||
|
r1241 | else: | ||
|
r1591 | shutil.copy(src, dst) | ||
|
r11251 | num += 1 | ||
|
r698 | |||
|
r11251 | return hardlink, num | ||
|
r11254 | |||
|
r5158 | class path_auditor(object): | ||
'''ensure that a filesystem path contains no banned components. | ||||
the following properties of a path are checked: | ||||
|
r13197 | - ends with a directory separator | ||
|
r5158 | - under top-level .hg | ||
- starts at the root of a windows drive | ||||
- contains ".." | ||||
- traverses a symlink (e.g. a/symlink_here/b) | ||||
|
r12079 | - inside a nested repository (a callback can be used to approve | ||
some nested repositories, e.g., subrepositories) | ||||
''' | ||||
|
r5158 | |||
|
r12079 | def __init__(self, root, callback=None): | ||
|
r5200 | self.audited = set() | ||
self.auditeddir = set() | ||||
|
r5158 | self.root = root | ||
|
r12079 | self.callback = callback | ||
|
r5158 | |||
def __call__(self, path): | ||||
if path in self.audited: | ||||
return | ||||
|
r13197 | # AIX ignores "/" at end of path, others raise EISDIR. | ||
if endswithsep(path): | ||||
raise Abort(_("path ends in directory separator: %s") % path) | ||||
|
r5159 | normpath = os.path.normcase(path) | ||
|
r5844 | parts = splitpath(normpath) | ||
|
r7784 | if (os.path.splitdrive(path)[0] | ||
or parts[0].lower() in ('.hg', '.hg.', '') | ||||
|
r5158 | or os.pardir in parts): | ||
raise Abort(_("path contains illegal component: %s") % path) | ||||
|
r7784 | if '.hg' in path.lower(): | ||
lparts = [p.lower() for p in parts] | ||||
|
r7553 | for p in '.hg', '.hg.': | ||
|
r7820 | if p in lparts[1:]: | ||
|
r7784 | pos = lparts.index(p) | ||
|
r7553 | base = os.path.join(*parts[:pos]) | ||
raise Abort(_('path %r is inside repo %r') % (path, base)) | ||||
|
r5158 | def check(prefix): | ||
curpath = os.path.join(self.root, prefix) | ||||
try: | ||||
st = os.lstat(curpath) | ||||
except OSError, err: | ||||
|
r5162 | # EINVAL can be raised as invalid path syntax under win32. | ||
# They must be ignored for patterns can be checked too. | ||||
|
r5487 | if err.errno not in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL): | ||
|
r5158 | raise | ||
else: | ||||
if stat.S_ISLNK(st.st_mode): | ||||
raise Abort(_('path %r traverses symbolic link %r') % | ||||
(path, prefix)) | ||||
|
r5159 | elif (stat.S_ISDIR(st.st_mode) and | ||
os.path.isdir(os.path.join(curpath, '.hg'))): | ||||
|
r12079 | if not self.callback or not self.callback(curpath): | ||
raise Abort(_('path %r is inside repo %r') % | ||||
(path, prefix)) | ||||
|
r5845 | parts.pop() | ||
|
r5200 | prefixes = [] | ||
|
r8631 | while parts: | ||
|
r5845 | prefix = os.sep.join(parts) | ||
|
r5200 | if prefix in self.auditeddir: | ||
break | ||||
check(prefix) | ||||
prefixes.append(prefix) | ||||
|
r5845 | parts.pop() | ||
|
r5200 | |||
self.audited.add(path) | ||||
# only add prefixes to the cache after checking everything: we don't | ||||
# want to add "foo/bar/baz" before checking if there's a "foo/.hg" | ||||
self.auditeddir.update(prefixes) | ||||
|
r1835 | |||
|
r8011 | def lookup_reg(key, name=None, scope=None): | ||
return None | ||||
|
r10240 | def hidewindow(): | ||
"""Hide current shell window. | ||||
Used to hide the window opened when starting asynchronous | ||||
child process under Windows, unneeded on other systems. | ||||
""" | ||||
pass | ||||
|
r7890 | if os.name == 'nt': | ||
from windows import * | ||||
else: | ||||
from posix import * | ||||
def makelock(info, pathname): | ||||
try: | ||||
return os.symlink(info, pathname) | ||||
except OSError, why: | ||||
if why.errno == errno.EEXIST: | ||||
raise | ||||
except AttributeError: # no symlink in os | ||||
pass | ||||
|
r704 | ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL) | ||
os.write(ld, info) | ||||
os.close(ld) | ||||
|
r7890 | def readlock(pathname): | ||
try: | ||||
return os.readlink(pathname) | ||||
except OSError, why: | ||||
if why.errno not in (errno.EINVAL, errno.ENOSYS): | ||||
raise | ||||
except AttributeError: # no symlink in os | ||||
pass | ||||
|
r13400 | fp = posixfile(pathname) | ||
r = fp.read() | ||||
fp.close() | ||||
return r | ||||
|
r704 | |||
|
r2176 | def fstat(fp): | ||
'''stat file object that may not have fileno method.''' | ||||
try: | ||||
return os.fstat(fp.fileno()) | ||||
except AttributeError: | ||||
return os.stat(fp.name) | ||||
|
r3784 | # File system features | ||
|
r6746 | def checkcase(path): | ||
|
r3784 | """ | ||
Check whether the given path is on a case-sensitive filesystem | ||||
Requires a path (like /foo/.hg) ending with a foldable final | ||||
directory component. | ||||
""" | ||||
s1 = os.stat(path) | ||||
d, b = os.path.split(path) | ||||
p2 = os.path.join(d, b.upper()) | ||||
if path == p2: | ||||
p2 = os.path.join(d, b.lower()) | ||||
try: | ||||
s2 = os.stat(p2) | ||||
if s2 == s1: | ||||
return False | ||||
return True | ||||
except: | ||||
return True | ||||
|
r6676 | _fspathcache = {} | ||
def fspath(name, root): | ||||
'''Get name in the case stored in the filesystem | ||||
The name is either relative to root, or it is an absolute path starting | ||||
with root. Note that this function is unnecessary, and should not be | ||||
called, for case-sensitive filesystems (simply because it's expensive). | ||||
''' | ||||
# If name is absolute, make it relative | ||||
if name.lower().startswith(root.lower()): | ||||
l = len(root) | ||||
|
r12401 | if name[l] == os.sep or name[l] == os.altsep: | ||
|
r6676 | l = l + 1 | ||
name = name[l:] | ||||
|
r12344 | if not os.path.lexists(os.path.join(root, name)): | ||
|
r6676 | return None | ||
seps = os.sep | ||||
if os.altsep: | ||||
seps = seps + os.altsep | ||||
# Protect backslashes. This gets silly very quickly. | ||||
seps.replace('\\','\\\\') | ||||
pattern = re.compile(r'([^%s]+)|([%s]+)' % (seps, seps)) | ||||
dir = os.path.normcase(os.path.normpath(root)) | ||||
result = [] | ||||
for part, sep in pattern.findall(name): | ||||
if sep: | ||||
result.append(sep) | ||||
continue | ||||
if dir not in _fspathcache: | ||||
_fspathcache[dir] = os.listdir(dir) | ||||
contents = _fspathcache[dir] | ||||
lpart = part.lower() | ||||
|
r9397 | lenp = len(part) | ||
|
r6676 | for n in contents: | ||
|
r9397 | if lenp == len(n) and n.lower() == lpart: | ||
|
r6676 | result.append(n) | ||
break | ||||
else: | ||||
# Cannot happen, as the file exists! | ||||
result.append(part) | ||||
dir = os.path.join(dir, lpart) | ||||
return ''.join(result) | ||||
|
r3994 | def checkexec(path): | ||
""" | ||||
Check whether the given path is on a filesystem with UNIX-like exec flags | ||||
Requires a directory (like /foo/.hg) | ||||
""" | ||||
|
r5739 | |||
# VFAT on some Linux versions can flip mode but it doesn't persist | ||||
# a FS remount. Frequently we can detect it if files are created | ||||
# with exec bit on. | ||||
|
r5212 | try: | ||
|
r5420 | EXECFLAGS = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH | ||
|
r10896 | fh, fn = tempfile.mkstemp(dir=path, prefix='hg-checkexec-') | ||
|
r5739 | try: | ||
os.close(fh) | ||||
m = os.stat(fn).st_mode & 0777 | ||||
new_file_has_exec = m & EXECFLAGS | ||||
os.chmod(fn, m ^ EXECFLAGS) | ||||
|
r5759 | exec_flags_cannot_flip = ((os.stat(fn).st_mode & 0777) == m) | ||
|
r5739 | finally: | ||
os.unlink(fn) | ||||
except (IOError, OSError): | ||||
|
r5212 | # we don't care, the user probably won't be able to commit anyway | ||
return False | ||||
|
r5420 | return not (new_file_has_exec or exec_flags_cannot_flip) | ||
|
r3994 | |||
|
r4002 | def checklink(path): | ||
|
r3998 | """check whether the given path is on a symlink-capable filesystem""" | ||
# mktemp is not racy because symlink creation will fail if the | ||||
# file already exists | ||||
|
r10901 | name = tempfile.mktemp(dir=path, prefix='hg-checklink-') | ||
|
r3998 | try: | ||
os.symlink(".", name) | ||||
os.unlink(name) | ||||
return True | ||||
|
r4017 | except (OSError, AttributeError): | ||
|
r3998 | return False | ||
|
r12938 | def checknlink(testfile): | ||
'''check whether hardlink count reporting works properly''' | ||||
|
r13204 | # testfile may be open, so we need a separate file for checking to | ||
# work around issue2543 (or testfile may get lost on Samba shares) | ||||
f1 = testfile + ".hgtmp1" | ||||
if os.path.lexists(f1): | ||||
return False | ||||
|
r12938 | try: | ||
|
r13204 | posixfile(f1, 'w').close() | ||
except IOError: | ||||
|
r12938 | return False | ||
|
r13204 | f2 = testfile + ".hgtmp2" | ||
fd = None | ||||
|
r12938 | try: | ||
|
r13204 | try: | ||
os_link(f1, f2) | ||||
except OSError: | ||||
return False | ||||
|
r12938 | # nlinks() may behave differently for files on Windows shares if | ||
# the file is open. | ||||
|
r13342 | fd = posixfile(f2) | ||
|
r13204 | return nlinks(f2) > 1 | ||
|
r12938 | finally: | ||
|
r13204 | if fd is not None: | ||
fd.close() | ||||
for f in (f1, f2): | ||||
try: | ||||
os.unlink(f) | ||||
except OSError: | ||||
pass | ||||
|
r12938 | |||
return False | ||||
|
r5843 | def endswithsep(path): | ||
'''Check path ends with os.sep or os.altsep.''' | ||||
return path.endswith(os.sep) or os.altsep and path.endswith(os.altsep) | ||||
|
r5844 | def splitpath(path): | ||
'''Split path by os.sep. | ||||
Note that this function does not use os.altsep because this is | ||||
an alternative of simple "xxx.split(os.sep)". | ||||
It is recommended to use os.path.normpath() before using this | ||||
function if need.''' | ||||
return path.split(os.sep) | ||||
|
r6007 | def gui(): | ||
'''Are we running in a GUI?''' | ||||
|
r13734 | if sys.platform == 'darwin': | ||
if 'SSH_CONNECTION' in os.environ: | ||||
# handle SSH access to a box where the user is logged in | ||||
return False | ||||
elif getattr(osutil, 'isgui', None): | ||||
# check if a CoreGraphics session is available | ||||
return osutil.isgui() | ||||
else: | ||||
# pure build; use a safe default | ||||
return True | ||||
else: | ||||
return os.name == "nt" or os.environ.get("DISPLAY") | ||||
|
r6007 | |||
|
r6062 | def mktempcopy(name, emptyok=False, createmode=None): | ||
|
r4827 | """Create a temporary file with the same contents from name | ||
The permission bits are copied from the original file. | ||||
If the temporary file is going to be truncated immediately, you | ||||
can use emptyok=True as an optimization. | ||||
Returns the name of the temporary file. | ||||
|
r2176 | """ | ||
|
r4827 | d, fn = os.path.split(name) | ||
fd, temp = tempfile.mkstemp(prefix='.%s-' % fn, dir=d) | ||||
os.close(fd) | ||||
# Temporary files are created with mode 0600, which is usually not | ||||
# what we want. If the original file already exists, just copy | ||||
# its mode. Otherwise, manually obey umask. | ||||
try: | ||||
|
r5740 | st_mode = os.lstat(name).st_mode & 0777 | ||
|
r4827 | except OSError, inst: | ||
if inst.errno != errno.ENOENT: | ||||
raise | ||||
|
r6062 | st_mode = createmode | ||
if st_mode is None: | ||||
|
r7890 | st_mode = ~umask | ||
|
r6062 | st_mode &= 0666 | ||
|
r4827 | os.chmod(temp, st_mode) | ||
if emptyok: | ||||
return temp | ||||
try: | ||||
try: | ||||
ifp = posixfile(name, "rb") | ||||
except IOError, inst: | ||||
if inst.errno == errno.ENOENT: | ||||
return temp | ||||
if not getattr(inst, 'filename', None): | ||||
inst.filename = name | ||||
raise | ||||
ofp = posixfile(temp, "wb") | ||||
for chunk in filechunkiter(ifp): | ||||
ofp.write(chunk) | ||||
ifp.close() | ||||
ofp.close() | ||||
except: | ||||
try: os.unlink(temp) | ||||
except: pass | ||||
raise | ||||
return temp | ||||
|
r2176 | |||
|
r8778 | class atomictempfile(object): | ||
|
r4827 | """file-like object that atomically updates a file | ||
All writes will be redirected to a temporary copy of the original | ||||
file. When rename is called, the copy is renamed to the original | ||||
name, making the changes visible. | ||||
""" | ||||
|
r11212 | def __init__(self, name, mode='w+b', createmode=None): | ||
|
r4827 | self.__name = name | ||
|
r8420 | self._fp = None | ||
|
r6062 | self.temp = mktempcopy(name, emptyok=('w' in mode), | ||
createmode=createmode) | ||||
|
r8327 | self._fp = posixfile(self.temp, mode) | ||
def __getattr__(self, name): | ||||
return getattr(self._fp, name) | ||||
|
r4827 | |||
def rename(self): | ||||
|
r8785 | if not self._fp.closed: | ||
|
r8327 | self._fp.close() | ||
|
r4827 | rename(self.temp, localpath(self.__name)) | ||
|
r13098 | def close(self): | ||
|
r8785 | if not self._fp: | ||
return | ||||
if not self._fp.closed: | ||||
|
r4827 | try: | ||
os.unlink(self.temp) | ||||
except: pass | ||||
|
r8327 | self._fp.close() | ||
|
r4827 | |||
|
r13098 | def __del__(self): | ||
self.close() | ||||
|
r6062 | def makedirs(name, mode=None): | ||
"""recursive directory creation with parent mode inheritance""" | ||||
|
r13068 | parent = os.path.abspath(os.path.dirname(name)) | ||
|
r6062 | try: | ||
os.mkdir(name) | ||||
if mode is not None: | ||||
os.chmod(name, mode) | ||||
return | ||||
except OSError, err: | ||||
if err.errno == errno.EEXIST: | ||||
return | ||||
|
r13068 | if not name or parent == name or err.errno != errno.ENOENT: | ||
|
r6062 | raise | ||
makedirs(parent, mode) | ||||
makedirs(name, mode) | ||||
|
r4827 | class opener(object): | ||
"""Open files relative to a base directory | ||||
This class is used to hide the details of COW semantics and | ||||
|
r2176 | remote file access from higher level code. | ||
""" | ||||
|
r4827 | def __init__(self, base, audit=True): | ||
self.base = base | ||||
|
r5158 | if audit: | ||
|
r12078 | self.auditor = path_auditor(base) | ||
|
r5158 | else: | ||
|
r12078 | self.auditor = always | ||
|
r6062 | self.createmode = None | ||
|
r12938 | self._trustnlink = None | ||
|
r2176 | |||
|
r9112 | @propertycache | ||
def _can_symlink(self): | ||||
return checklink(self.base) | ||||
|
r4828 | |||
|
r6062 | def _fixfilemode(self, name): | ||
if self.createmode is None: | ||||
return | ||||
os.chmod(name, self.createmode & 0666) | ||||
|
r4827 | def __call__(self, path, mode="r", text=False, atomictemp=False): | ||
|
r12078 | self.auditor(path) | ||
|
r4827 | f = os.path.join(self.base, path) | ||
|
r2176 | |||
|
r4720 | if not text and "b" not in mode: | ||
|
r2176 | mode += "b" # for that other OS | ||
|
r6062 | nlink = -1 | ||
|
r12927 | dirname, basename = os.path.split(f) | ||
# If basename is empty, then the path is malformed because it points | ||||
# to a directory. Let the posixfile() call below raise IOError. | ||||
if basename and mode not in ('r', 'rb'): | ||||
if atomictemp: | ||||
if not os.path.isdir(dirname): | ||||
makedirs(dirname, self.createmode) | ||||
return atomictempfile(f, mode, self.createmode) | ||||
|
r2176 | try: | ||
|
r12927 | if 'w' in mode: | ||
|
r13282 | unlink(f) | ||
|
r12927 | nlink = 0 | ||
else: | ||||
|
r12938 | # nlinks() may behave differently for files on Windows | ||
# shares if the file is open. | ||||
|
r13342 | fd = posixfile(f) | ||
|
r12927 | nlink = nlinks(f) | ||
|
r13305 | if nlink < 1: | ||
nlink = 2 # force mktempcopy (issue1922) | ||||
|
r12938 | fd.close() | ||
|
r13279 | except (OSError, IOError), e: | ||
if e.errno != errno.ENOENT: | ||||
raise | ||||
|
r4328 | nlink = 0 | ||
|
r12927 | if not os.path.isdir(dirname): | ||
|
r12877 | makedirs(dirname, self.createmode) | ||
|
r12938 | if nlink > 0: | ||
if self._trustnlink is None: | ||||
self._trustnlink = nlink > 1 or checknlink(f) | ||||
if nlink > 1 or not self._trustnlink: | ||||
rename(mktempcopy(f), f) | ||||
|
r6062 | fp = posixfile(f, mode) | ||
if nlink == 0: | ||||
|
r13112 | self._fixfilemode(f) | ||
|
r6062 | return fp | ||
|
r2176 | |||
|
r4828 | def symlink(self, src, dst): | ||
|
r12078 | self.auditor(dst) | ||
|
r4828 | linkname = os.path.join(self.base, dst) | ||
try: | ||||
os.unlink(linkname) | ||||
except OSError: | ||||
pass | ||||
dirname = os.path.dirname(linkname) | ||||
if not os.path.exists(dirname): | ||||
|
r6062 | makedirs(dirname, self.createmode) | ||
|
r4828 | |||
if self._can_symlink: | ||||
|
r4948 | try: | ||
os.symlink(src, linkname) | ||||
except OSError, err: | ||||
raise OSError(err.errno, _('could not symlink to %r: %s') % | ||||
(src, err.strerror), linkname) | ||||
|
r4828 | else: | ||
|
r5077 | f = self(dst, "w") | ||
|
r4828 | f.write(src) | ||
f.close() | ||||
|
r6062 | self._fixfilemode(dst) | ||
|
r4828 | |||
|
r1199 | class chunkbuffer(object): | ||
"""Allow arbitrary sized chunks of data to be efficiently read from an | ||||
iterator over chunks of arbitrary size.""" | ||||
|
r1200 | |||
|
r5446 | def __init__(self, in_iter): | ||
|
r1199 | """in_iter is the iterator that's iterating over the input chunks. | ||
targetsize is how big a buffer to try to maintain.""" | ||||
|
r11670 | def splitbig(chunks): | ||
for chunk in chunks: | ||||
if len(chunk) > 2**20: | ||||
pos = 0 | ||||
while pos < len(chunk): | ||||
end = pos + 2 ** 18 | ||||
yield chunk[pos:end] | ||||
pos = end | ||||
else: | ||||
yield chunk | ||||
self.iter = splitbig(in_iter) | ||||
|
r11758 | self._queue = [] | ||
|
r1200 | |||
|
r1199 | def read(self, l): | ||
|
r1200 | """Read L bytes of data from the iterator of chunks of data. | ||
|
r1308 | Returns less than L bytes if the iterator runs dry.""" | ||
|
r11758 | left = l | ||
buf = '' | ||||
queue = self._queue | ||||
while left > 0: | ||||
# refill the queue | ||||
if not queue: | ||||
target = 2**18 | ||||
for chunk in self.iter: | ||||
queue.append(chunk) | ||||
target -= len(chunk) | ||||
if target <= 0: | ||||
break | ||||
if not queue: | ||||
|
r1199 | break | ||
|
r11758 | |||
chunk = queue.pop(0) | ||||
left -= len(chunk) | ||||
if left < 0: | ||||
queue.insert(0, chunk[left:]) | ||||
buf += chunk[:left] | ||||
else: | ||||
buf += chunk | ||||
return buf | ||||
|
r2462 | def filechunkiter(f, size=65536, limit=None): | ||
"""Create a generator that produces the data in the file size | ||||
(default 65536) bytes at a time, up to optional limit (default is | ||||
to read all data). Chunks may be less than size bytes if the | ||||
chunk is the last chunk in the file, or the file is a socket or | ||||
some other type of file that sometimes reads less data than is | ||||
requested.""" | ||||
assert size >= 0 | ||||
assert limit is None or limit >= 0 | ||||
while True: | ||||
|
r10282 | if limit is None: | ||
nbytes = size | ||||
else: | ||||
nbytes = min(limit, size) | ||||
|
r2462 | s = nbytes and f.read(nbytes) | ||
|
r10282 | if not s: | ||
break | ||||
if limit: | ||||
limit -= len(s) | ||||
|
r1199 | yield s | ||
|
r1320 | |||
|
r1321 | def makedate(): | ||
|
r1482 | lt = time.localtime() | ||
if lt[8] == 1 and time.daylight: | ||||
tz = time.altzone | ||||
else: | ||||
tz = time.timezone | ||||
|
r13063 | t = time.mktime(lt) | ||
if t < 0: | ||||
hint = _("check your clock") | ||||
raise Abort(_("negative timestamp: %d") % t, hint=hint) | ||||
return t, tz | ||||
|
r1329 | |||
|
r6229 | def datestr(date=None, format='%a %b %d %H:%M:%S %Y %1%2'): | ||
|
r1321 | """represent a (unixtime, offset) tuple as a localized time. | ||
unixtime is seconds since the epoch, and offset is the time zone's | ||||
|
r1987 | number of seconds away from UTC. if timezone is false, do not | ||
append time zone to string.""" | ||||
|
r1321 | t, tz = date or makedate() | ||
|
r13039 | if t < 0: | ||
t = 0 # time.gmtime(lt) fails on Windows for lt < -43200 | ||||
tz = 0 | ||||
|
r6229 | if "%1" in format or "%2" in format: | ||
sign = (tz > 0) and "-" or "+" | ||||
|
r9029 | minutes = abs(tz) // 60 | ||
format = format.replace("%1", "%c%02d" % (sign, minutes // 60)) | ||||
|
r6229 | format = format.replace("%2", "%02d" % (minutes % 60)) | ||
|
r1987 | s = time.strftime(format, time.gmtime(float(t) - tz)) | ||
return s | ||||
|
r1829 | |||
|
r6134 | def shortdate(date=None): | ||
"""turn (timestamp, tzoff) tuple into iso 8631 date.""" | ||||
|
r6229 | return datestr(date, format='%Y-%m-%d') | ||
|
r6134 | |||
|
r5357 | def strdate(string, format, defaults=[]): | ||
|
r2522 | """parse a localized time string and return a (unixtime, offset) tuple. | ||
if the string cannot be parsed, ValueError is raised.""" | ||||
|
r3809 | def timezone(string): | ||
tz = string.split()[-1] | ||||
if tz[0] in "+-" and len(tz) == 5 and tz[1:].isdigit(): | ||||
|
r6229 | sign = (tz[0] == "+") and 1 or -1 | ||
hours = int(tz[1:3]) | ||||
minutes = int(tz[3:5]) | ||||
return -sign * (hours * 60 + minutes) * 60 | ||||
|
r12401 | if tz == "GMT" or tz == "UTC": | ||
|
r3809 | return 0 | ||
return None | ||||
|
r2522 | |||
|
r3255 | # NOTE: unixtime = localunixtime + offset | ||
|
r3809 | offset, date = timezone(string), string | ||
|
r13031 | if offset is not None: | ||
|
r3809 | date = " ".join(string.split()[:-1]) | ||
|
r3808 | |||
|
r3812 | # add missing elements from defaults | ||
|
r13212 | usenow = False # default to using biased defaults | ||
for part in ("S", "M", "HI", "d", "mb", "yY"): # decreasing specificity | ||||
|
r3812 | found = [True for p in part if ("%"+p) in format] | ||
if not found: | ||||
|
r13212 | date += "@" + defaults[part][usenow] | ||
|
r3812 | format += "@%" + part[0] | ||
|
r13212 | else: | ||
# We've found a specific time element, less specific time | ||||
# elements are relative to today | ||||
usenow = True | ||||
|
r3808 | |||
|
r3256 | timetuple = time.strptime(date, format) | ||
localunixtime = int(calendar.timegm(timetuple)) | ||||
if offset is None: | ||||
# local timezone | ||||
unixtime = int(time.mktime(timetuple)) | ||||
offset = unixtime - localunixtime | ||||
else: | ||||
unixtime = localunixtime + offset | ||||
|
r3255 | return unixtime, offset | ||
|
r2522 | |||
|
r13212 | def parsedate(date, formats=None, bias={}): | ||
"""parse a localized date/time and return a (unixtime, offset) tuple. | ||||
|
r6139 | |||
|
r2522 | The date may be a "unixtime offset" string or in one of the specified | ||
|
r6139 | formats. If the date already is a (unixtime, offset) tuple, it is returned. | ||
""" | ||||
if not date: | ||||
|
r3807 | return 0, 0 | ||
|
r6230 | if isinstance(date, tuple) and len(date) == 2: | ||
|
r6139 | return date | ||
|
r2609 | if not formats: | ||
formats = defaultdateformats | ||||
|
r6139 | date = date.strip() | ||
|
r2522 | try: | ||
|
r6139 | when, offset = map(int, date.split(' ')) | ||
|
r2523 | except ValueError: | ||
|
r3812 | # fill out defaults | ||
now = makedate() | ||||
|
r13212 | defaults = {} | ||
nowmap = {} | ||||
|
r13200 | for part in ("d", "mb", "yY", "HI", "M", "S"): | ||
|
r13212 | # this piece is for rounding the specific end of unknowns | ||
b = bias.get(part) | ||||
if b is None: | ||||
|
r3812 | if part[0] in "HMS": | ||
|
r13212 | b = "00" | ||
|
r3812 | else: | ||
|
r13212 | b = "0" | ||
# this piece is for matching the generic end to today's date | ||||
n = datestr(now, "%" + part[0]) | ||||
defaults[part] = (b, n) | ||||
|
r3812 | |||
|
r2523 | for format in formats: | ||
try: | ||||
|
r6139 | when, offset = strdate(date, format, defaults) | ||
|
r6087 | except (ValueError, OverflowError): | ||
|
r2523 | pass | ||
else: | ||||
break | ||||
else: | ||||
|
r12105 | raise Abort(_('invalid date: %r') % date) | ||
|
r2523 | # validate explicit (probably user-specified) date and | ||
# time zone offset. values must fit in signed 32 bits for | ||||
# current 32-bit linux runtimes. timezones go from UTC-12 | ||||
# to UTC+14 | ||||
if abs(when) > 0x7fffffff: | ||||
|
r3806 | raise Abort(_('date exceeds 32 bits: %d') % when) | ||
|
r13062 | if when < 0: | ||
raise Abort(_('negative date value: %d') % when) | ||||
|
r2523 | if offset < -50400 or offset > 43200: | ||
|
r3806 | raise Abort(_('impossible time zone offset: %d') % offset) | ||
|
r2523 | return when, offset | ||
|
r2522 | |||
|
r3812 | def matchdate(date): | ||
"""Return a function that matches a given date match specifier | ||||
Formats include: | ||||
'{date}' match a given date to the accuracy provided | ||||
'<{date}' on or before a given date | ||||
'>{date}' on or after a given date | ||||
|
r13212 | >>> p1 = parsedate("10:29:59") | ||
>>> p2 = parsedate("10:30:00") | ||||
>>> p3 = parsedate("10:30:59") | ||||
>>> p4 = parsedate("10:31:00") | ||||
>>> p5 = parsedate("Sep 15 10:30:00 1999") | ||||
>>> f = matchdate("10:30") | ||||
>>> f(p1[0]) | ||||
False | ||||
>>> f(p2[0]) | ||||
True | ||||
>>> f(p3[0]) | ||||
True | ||||
>>> f(p4[0]) | ||||
False | ||||
>>> f(p5[0]) | ||||
False | ||||
|
r3812 | """ | ||
def lower(date): | ||||
|
r6230 | d = dict(mb="1", d="1") | ||
return parsedate(date, extendeddateformats, d)[0] | ||||
|
r3812 | |||
def upper(date): | ||||
d = dict(mb="12", HI="23", M="59", S="59") | ||||
|
r13200 | for days in ("31", "30", "29"): | ||
|
r3812 | try: | ||
d["d"] = days | ||||
return parsedate(date, extendeddateformats, d)[0] | ||||
except: | ||||
pass | ||||
d["d"] = "28" | ||||
return parsedate(date, extendeddateformats, d)[0] | ||||
|
r7953 | date = date.strip() | ||
|
r13780 | |||
if not date: | ||||
raise Abort(_("dates cannot consist entirely of whitespace")) | ||||
elif date[0] == "<": | ||||
|
r3812 | when = upper(date[1:]) | ||
return lambda x: x <= when | ||||
elif date[0] == ">": | ||||
when = lower(date[1:]) | ||||
return lambda x: x >= when | ||||
elif date[0] == "-": | ||||
try: | ||||
days = int(date[1:]) | ||||
except ValueError: | ||||
raise Abort(_("invalid day spec: %s") % date[1:]) | ||||
when = makedate()[0] - days * 3600 * 24 | ||||
|
r3813 | return lambda x: x >= when | ||
|
r3812 | elif " to " in date: | ||
a, b = date.split(" to ") | ||||
start, stop = lower(a), upper(b) | ||||
return lambda x: x >= start and x <= stop | ||||
else: | ||||
start, stop = lower(date), upper(date) | ||||
return lambda x: x >= start and x <= stop | ||||
|
r1903 | def shortuser(user): | ||
"""Return a short representation of a user name or email address.""" | ||||
f = user.find('@') | ||||
if f >= 0: | ||||
user = user[:f] | ||||
f = user.find('<') | ||||
if f >= 0: | ||||
|
r10282 | user = user[f + 1:] | ||
|
r3176 | f = user.find(' ') | ||
if f >= 0: | ||||
user = user[:f] | ||||
|
r3533 | f = user.find('.') | ||
if f >= 0: | ||||
user = user[:f] | ||||
|
r1903 | return user | ||
|
r1920 | |||
|
r5975 | def email(author): | ||
'''get email of author.''' | ||||
r = author.find('>') | ||||
|
r10282 | if r == -1: | ||
r = None | ||||
return author[author.find('<') + 1:r] | ||||
|
r5975 | |||
|
r13225 | def _ellipsis(text, maxlength): | ||
if len(text) <= maxlength: | ||||
return text, False | ||||
else: | ||||
return "%s..." % (text[:maxlength - 3]), True | ||||
|
r3767 | def ellipsis(text, maxlength=400): | ||
"""Trim string to at most maxlength (default: 400) characters.""" | ||||
|
r13225 | try: | ||
# use unicode not to split at intermediate multi-byte sequence | ||||
utext, truncated = _ellipsis(text.decode(encoding.encoding), | ||||
maxlength) | ||||
if not truncated: | ||||
return text | ||||
return utext.encode(encoding.encoding) | ||||
except (UnicodeDecodeError, UnicodeEncodeError): | ||||
return _ellipsis(text, maxlength)[0] | ||||
|
r3767 | |||
|
r7523 | def walkrepos(path, followsym=False, seen_dirs=None, recurse=False): | ||
|
r1829 | '''yield every hg repository under path, recursively.''' | ||
def errhandler(err): | ||||
if err.filename == path: | ||||
raise err | ||||
|
r6284 | if followsym and hasattr(os.path, 'samestat'): | ||
def _add_dir_if_not_there(dirlst, dirname): | ||||
match = False | ||||
samestat = os.path.samestat | ||||
dirstat = os.stat(dirname) | ||||
for lstdirstat in dirlst: | ||||
if samestat(dirstat, lstdirstat): | ||||
match = True | ||||
break | ||||
if not match: | ||||
dirlst.append(dirstat) | ||||
return not match | ||||
else: | ||||
|
r6317 | followsym = False | ||
|
r1829 | |||
|
r6284 | if (seen_dirs is None) and followsym: | ||
seen_dirs = [] | ||||
_add_dir_if_not_there(seen_dirs, path) | ||||
for root, dirs, files in os.walk(path, topdown=True, onerror=errhandler): | ||||
|
r9732 | dirs.sort() | ||
|
r6140 | if '.hg' in dirs: | ||
yield root # found a repository | ||||
|
r7525 | qroot = os.path.join(root, '.hg', 'patches') | ||
if os.path.isdir(os.path.join(qroot, '.hg')): | ||||
yield qroot # we have a patch queue repo here | ||||
|
r7523 | if recurse: | ||
# avoid recursing inside the .hg directory | ||||
dirs.remove('.hg') | ||||
else: | ||||
dirs[:] = [] # don't descend further | ||||
|
r6284 | elif followsym: | ||
newdirs = [] | ||||
for d in dirs: | ||||
fname = os.path.join(root, d) | ||||
if _add_dir_if_not_there(seen_dirs, fname): | ||||
if os.path.islink(fname): | ||||
for hgname in walkrepos(fname, True, seen_dirs): | ||||
yield hgname | ||||
else: | ||||
newdirs.append(d) | ||||
dirs[:] = newdirs | ||||
|
r1951 | |||
_rcpath = None | ||||
|
r4097 | def os_rcpath(): | ||
'''return default os-specific hgrc search path''' | ||||
path = system_rcpath() | ||||
path.extend(user_rcpath()) | ||||
path = [os.path.normpath(f) for f in path] | ||||
return path | ||||
|
r1951 | def rcpath(): | ||
'''return hgrc search path. if env var HGRCPATH is set, use it. | ||||
for each item in path, if directory, use files ending in .rc, | ||||
else use item. | ||||
make HGRCPATH empty to only look in .hg/hgrc of current repo. | ||||
if no HGRCPATH, use default os-specific path.''' | ||||
global _rcpath | ||||
if _rcpath is None: | ||||
if 'HGRCPATH' in os.environ: | ||||
_rcpath = [] | ||||
for p in os.environ['HGRCPATH'].split(os.pathsep): | ||||
|
r10282 | if not p: | ||
continue | ||||
|
r9610 | p = expandpath(p) | ||
|
r1956 | if os.path.isdir(p): | ||
|
r5396 | for f, kind in osutil.listdir(p): | ||
|
r1951 | if f.endswith('.rc'): | ||
_rcpath.append(os.path.join(p, f)) | ||||
|
r1956 | else: | ||
_rcpath.append(p) | ||||
|
r1951 | else: | ||
_rcpath = os_rcpath() | ||||
return _rcpath | ||||
|
r2612 | |||
def bytecount(nbytes): | ||||
'''return byte count formatted as readable string, with units''' | ||||
units = ( | ||||
|
r10282 | (100, 1 << 30, _('%.0f GB')), | ||
(10, 1 << 30, _('%.1f GB')), | ||||
(1, 1 << 30, _('%.2f GB')), | ||||
(100, 1 << 20, _('%.0f MB')), | ||||
(10, 1 << 20, _('%.1f MB')), | ||||
(1, 1 << 20, _('%.2f MB')), | ||||
(100, 1 << 10, _('%.0f KB')), | ||||
(10, 1 << 10, _('%.1f KB')), | ||||
(1, 1 << 10, _('%.2f KB')), | ||||
|
r2612 | (1, 1, _('%.0f bytes')), | ||
) | ||||
for multiplier, divisor, format in units: | ||||
if nbytes >= divisor * multiplier: | ||||
return format % (nbytes / float(divisor)) | ||||
return units[-1][2] % nbytes | ||||
|
r2740 | |||
|
r5291 | def uirepr(s): | ||
# Avoid double backslash in Windows path repr() | ||||
return repr(s).replace('\\\\', '\\') | ||||
|
r7547 | |||
|
r13316 | # delay import of textwrap | ||
def MBTextWrapper(**kwargs): | ||||
class tw(textwrap.TextWrapper): | ||||
""" | ||||
Extend TextWrapper for double-width characters. | ||||
|
r12957 | |||
|
r13316 | Some Asian characters use two terminal columns instead of one. | ||
A good example of this behavior can be seen with u'\u65e5\u672c', | ||||
the two Japanese characters for "Japan": | ||||
len() returns 2, but when printed to a terminal, they eat 4 columns. | ||||
|
r12957 | |||
|
r13316 | (Note that this has nothing to do whatsoever with unicode | ||
representation, or encoding of the underlying string) | ||||
""" | ||||
def __init__(self, **kwargs): | ||||
textwrap.TextWrapper.__init__(self, **kwargs) | ||||
|
r11297 | |||
|
r13316 | def _cutdown(self, str, space_left): | ||
l = 0 | ||||
ucstr = unicode(str, encoding.encoding) | ||||
colwidth = unicodedata.east_asian_width | ||||
for i in xrange(len(ucstr)): | ||||
l += colwidth(ucstr[i]) in 'WFA' and 2 or 1 | ||||
if space_left < l: | ||||
return (ucstr[:i].encode(encoding.encoding), | ||||
ucstr[i:].encode(encoding.encoding)) | ||||
return str, '' | ||||
|
r11297 | |||
|
r13316 | # overriding of base class | ||
def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width): | ||||
space_left = max(width - cur_len, 1) | ||||
|
r11297 | |||
|
r13316 | if self.break_long_words: | ||
cut, res = self._cutdown(reversed_chunks[-1], space_left) | ||||
cur_line.append(cut) | ||||
reversed_chunks[-1] = res | ||||
elif not cur_line: | ||||
cur_line.append(reversed_chunks.pop()) | ||||
|
r11297 | |||
|
r13316 | global MBTextWrapper | ||
MBTextWrapper = tw | ||||
return tw(**kwargs) | ||||
|
r11297 | |||
|
r12698 | def wrap(line, width, initindent='', hangindent=''): | ||
|
r11297 | maxindent = max(len(hangindent), len(initindent)) | ||
if width <= maxindent: | ||||
|
r9417 | # adjust for weird terminal size | ||
|
r11297 | width = max(78, maxindent + 1) | ||
wrapper = MBTextWrapper(width=width, | ||||
initial_indent=initindent, | ||||
subsequent_indent=hangindent) | ||||
return wrapper.fill(line) | ||||
|
r8938 | |||
|
r7879 | def iterlines(iterator): | ||
for chunk in iterator: | ||||
for line in chunk.splitlines(): | ||||
yield line | ||||
|
r9610 | |||
def expandpath(path): | ||||
return os.path.expanduser(os.path.expandvars(path)) | ||||
|
r10239 | |||
def hgcmd(): | ||||
"""Return the command used to execute current hg | ||||
This is different from hgexecutable() because on Windows we want | ||||
to avoid things opening new shell windows like batch files, so we | ||||
get either the python call or current executable. | ||||
""" | ||||
if main_is_frozen(): | ||||
return [sys.executable] | ||||
return gethgcmd() | ||||
|
r10344 | |||
def rundetached(args, condfn): | ||||
"""Execute the argument list in a detached process. | ||||
|
r10422 | |||
|
r10344 | condfn is a callable which is called repeatedly and should return | ||
True once the child process is known to have started successfully. | ||||
At this point, the child process PID is returned. If the child | ||||
process fails to start or finishes before condfn() evaluates to | ||||
True, return -1. | ||||
""" | ||||
# Windows case is easier because the child process is either | ||||
# successfully starting and validating the condition or exiting | ||||
# on failure. We just poll on its PID. On Unix, if the child | ||||
# process fails to start, it will be left in a zombie state until | ||||
# the parent wait on it, which we cannot do since we expect a long | ||||
# running process on success. Instead we listen for SIGCHLD telling | ||||
# us our child process terminated. | ||||
terminated = set() | ||||
def handler(signum, frame): | ||||
terminated.add(os.wait()) | ||||
prevhandler = None | ||||
if hasattr(signal, 'SIGCHLD'): | ||||
prevhandler = signal.signal(signal.SIGCHLD, handler) | ||||
try: | ||||
pid = spawndetached(args) | ||||
while not condfn(): | ||||
if ((pid in terminated or not testpid(pid)) | ||||
and not condfn()): | ||||
return -1 | ||||
time.sleep(0.1) | ||||
return pid | ||||
finally: | ||||
if prevhandler is not None: | ||||
signal.signal(signal.SIGCHLD, prevhandler) | ||||
|
r10438 | |||
|
r10487 | try: | ||
any, all = any, all | ||||
except NameError: | ||||
def any(iterable): | ||||
for i in iterable: | ||||
if i: | ||||
return True | ||||
return False | ||||
|
r10438 | |||
|
r10487 | def all(iterable): | ||
for i in iterable: | ||||
if not i: | ||||
return False | ||||
return True | ||||
|
r11010 | |||
|
r13392 | def interpolate(prefix, mapping, s, fn=None, escape_prefix=False): | ||
|
r11988 | """Return the result of interpolating items in the mapping into string s. | ||
prefix is a single character string, or a two character string with | ||||
a backslash as the first character if the prefix needs to be escaped in | ||||
a regular expression. | ||||
fn is an optional function that will be applied to the replacement text | ||||
just before replacement. | ||||
|
r13392 | |||
escape_prefix is an optional flag that allows using doubled prefix for | ||||
its escaping. | ||||
|
r11988 | """ | ||
fn = fn or (lambda s: s) | ||||
|
r13392 | patterns = '|'.join(mapping.keys()) | ||
if escape_prefix: | ||||
patterns += '|' + prefix | ||||
if len(prefix) > 1: | ||||
prefix_char = prefix[1:] | ||||
else: | ||||
prefix_char = prefix | ||||
mapping[prefix_char] = prefix_char | ||||
r = re.compile(r'%s(%s)' % (prefix, patterns)) | ||||
|
r11988 | return r.sub(lambda x: fn(mapping[x.group()[1:]]), s) | ||
|
r12076 | def getport(port): | ||
"""Return the port for a given network service. | ||||
If port is an integer, it's returned as is. If it's a string, it's | ||||
looked up using socket.getservbyname(). If there's no matching | ||||
service, util.Abort is raised. | ||||
""" | ||||
try: | ||||
return int(port) | ||||
except ValueError: | ||||
pass | ||||
try: | ||||
return socket.getservbyname(port) | ||||
except socket.error: | ||||
raise Abort(_("no port number associated with service '%s'") % port) | ||||
|
r12087 | |||
|
r12088 | _booleans = {'1': True, 'yes': True, 'true': True, 'on': True, 'always': True, | ||
'0': False, 'no': False, 'false': False, 'off': False, | ||||
'never': False} | ||||
|
r12087 | |||
def parsebool(s): | ||||
"""Parse s into a boolean. | ||||
If s is not a valid boolean, returns None. | ||||
""" | ||||
return _booleans.get(s.lower(), None) | ||||