util.py
1946 lines
| 61.3 KiB
| text/x-python
|
PythonLexer
/ mercurial / util.py
|
r1082 | """ | ||
util.py - Mercurial utility functions and platform specfic implementations | ||||
Copyright 2005 K. Thananchayan <thananck@yahoo.com> | ||||
|
r4635 | Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r2859 | Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||
|
r1082 | |||
This software may be used and distributed according to the terms | ||||
of the GNU General Public License, incorporated herein by reference. | ||||
This contains helper routines that are independent of the SCM core and hide | ||||
platform-specific details from the core. | ||||
""" | ||||
|
r419 | |||
|
r3891 | from i18n import _ | ||
|
r6212 | import cStringIO, errno, getpass, re, shutil, sys, tempfile | ||
|
r5396 | import os, stat, threading, time, calendar, ConfigParser, locale, glob, osutil | ||
|
r6501 | import imp, urlparse | ||
|
r3769 | |||
|
r6470 | # Python compatibility | ||
|
r3769 | |||
|
r4057 | try: | ||
|
r4647 | set = set | ||
frozenset = frozenset | ||||
except NameError: | ||||
from sets import Set as set, ImmutableSet as frozenset | ||||
|
r6470 | _md5 = None | ||
def md5(s): | ||||
global _md5 | ||||
if _md5 is None: | ||||
try: | ||||
import hashlib | ||||
_md5 = hashlib.md5 | ||||
except ImportError: | ||||
import md5 | ||||
_md5 = md5.md5 | ||||
return _md5(s) | ||||
_sha1 = None | ||||
def sha1(s): | ||||
global _sha1 | ||||
if _sha1 is None: | ||||
try: | ||||
import hashlib | ||||
_sha1 = hashlib.sha1 | ||||
except ImportError: | ||||
import sha | ||||
_sha1 = sha.sha | ||||
return _sha1(s) | ||||
|
r4647 | try: | ||
|
r7106 | import subprocess | ||
|
r7163 | subprocess.Popen # trigger ImportError early | ||
|
r7123 | closefds = os.name == 'posix' | ||
|
r7106 | def popen2(cmd, mode='t', bufsize=-1): | ||
|
r7123 | p = subprocess.Popen(cmd, shell=True, bufsize=bufsize, | ||
close_fds=closefds, | ||||
|
r7106 | stdin=subprocess.PIPE, stdout=subprocess.PIPE) | ||
return p.stdin, p.stdout | ||||
def popen3(cmd, mode='t', bufsize=-1): | ||||
|
r7123 | p = subprocess.Popen(cmd, shell=True, bufsize=bufsize, | ||
close_fds=closefds, | ||||
|
r7106 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||
stderr=subprocess.PIPE) | ||||
return p.stdin, p.stdout, p.stderr | ||||
def Popen3(cmd, capturestderr=False, bufsize=-1): | ||||
stderr = capturestderr and subprocess.PIPE or None | ||||
|
r7123 | p = subprocess.Popen(cmd, shell=True, bufsize=bufsize, | ||
close_fds=closefds, | ||||
|
r7106 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||
stderr=stderr) | ||||
p.fromchild = p.stdout | ||||
p.tochild = p.stdin | ||||
p.childerr = p.stderr | ||||
return p | ||||
except ImportError: | ||||
subprocess = None | ||||
|
r7164 | from popen2 import Popen3 | ||
|
r7163 | popen2 = os.popen2 | ||
|
r7164 | popen3 = os.popen3 | ||
|
r7106 | |||
try: | ||||
|
r4540 | _encoding = os.environ.get("HGENCODING") | ||
if sys.platform == 'darwin' and not _encoding: | ||||
# On darwin, getpreferredencoding ignores the locale environment and | ||||
# always returns mac-roman. We override this if the environment is | ||||
# not C (has been customized by the user). | ||||
locale.setlocale(locale.LC_CTYPE, '') | ||||
_encoding = locale.getlocale()[1] | ||||
if not _encoding: | ||||
_encoding = locale.getpreferredencoding() or 'ascii' | ||||
|
r4057 | except locale.Error: | ||
_encoding = 'ascii' | ||||
|
r3770 | _encodingmode = os.environ.get("HGENCODINGMODE", "strict") | ||
|
r3835 | _fallbackencoding = 'ISO-8859-1' | ||
|
r3770 | |||
def tolocal(s): | ||||
""" | ||||
Convert a string from internal UTF-8 to local encoding | ||||
All internal strings should be UTF-8 but some repos before the | ||||
implementation of locale support may contain latin1 or possibly | ||||
other character sets. We attempt to decode everything strictly | ||||
using UTF-8, then Latin-1, and failing that, we use UTF-8 and | ||||
replace unknown characters. | ||||
""" | ||||
|
r3835 | for e in ('UTF-8', _fallbackencoding): | ||
|
r3770 | try: | ||
u = s.decode(e) # attempt strict decoding | ||||
return u.encode(_encoding, "replace") | ||||
|
r3843 | except LookupError, k: | ||
raise Abort(_("%s, please check your locale settings") % k) | ||||
|
r3770 | except UnicodeDecodeError: | ||
pass | ||||
u = s.decode("utf-8", "replace") # last ditch | ||||
return u.encode(_encoding, "replace") | ||||
def fromlocal(s): | ||||
""" | ||||
Convert a string from the local character encoding to UTF-8 | ||||
We attempt to decode strings using the encoding mode set by | ||||
|
r4876 | HGENCODINGMODE, which defaults to 'strict'. In this mode, unknown | ||
|
r3770 | characters will cause an error message. Other modes include | ||
'replace', which replaces unknown characters with a special | ||||
Unicode character, and 'ignore', which drops the character. | ||||
""" | ||||
try: | ||||
return s.decode(_encoding, _encodingmode).encode("utf-8") | ||||
except UnicodeDecodeError, inst: | ||||
sub = s[max(0, inst.start-10):inst.start+10] | ||||
|
r3843 | raise Abort("decoding near '%s': %s!" % (sub, inst)) | ||
except LookupError, k: | ||||
raise Abort(_("%s, please check your locale settings") % k) | ||||
|
r3770 | |||
def locallen(s): | ||||
"""Find the length in characters of a local string""" | ||||
return len(s.decode(_encoding, "replace")) | ||||
|
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', | ||||
'%I:%M:%SP', | ||||
'%H:%M', | ||||
'%I:%M%p', | ||||
) | ||||
|
r2609 | |||
|
r3812 | extendeddateformats = defaultdateformats + ( | ||
"%Y", | ||||
"%Y-%m", | ||||
"%b", | ||||
"%b %Y", | ||||
) | ||||
|
r2609 | |||
|
r2153 | class SignalInterrupt(Exception): | ||
"""Exception raised on SIGTERM and SIGHUP.""" | ||||
|
r4069 | # differences from SafeConfigParser: | ||
# - case-sensitive keys | ||||
# - allows values that are not strings (this means that you may not | ||||
# be able to save the configuration to a file) | ||||
|
r3425 | class configparser(ConfigParser.SafeConfigParser): | ||
def optionxform(self, optionstr): | ||||
return optionstr | ||||
|
r4069 | def set(self, section, option, value): | ||
return ConfigParser.ConfigParser.set(self, section, option, value) | ||||
def _interpolate(self, section, option, rawval, vars): | ||||
if not isinstance(rawval, basestring): | ||||
return rawval | ||||
return ConfigParser.SafeConfigParser._interpolate(self, section, | ||||
option, rawval, vars) | ||||
|
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 | ||||
|
r1293 | def pipefilter(s, cmd): | ||
'''filter string S through command CMD, returning its output''' | ||||
|
r7106 | (pin, pout) = popen2(cmd, 'b') | ||
|
r1258 | def writer(): | ||
|
r2096 | try: | ||
pin.write(s) | ||||
pin.close() | ||||
except IOError, inst: | ||||
if inst.errno != errno.EPIPE: | ||||
raise | ||||
|
r1258 | |||
# we should use select instead on UNIX, but this will work on most | ||||
# systems, including Windows | ||||
w = threading.Thread(target=writer) | ||||
w.start() | ||||
f = pout.read() | ||||
pout.close() | ||||
w.join() | ||||
return f | ||||
|
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 | ||||
|
r1402 | if code: raise Abort(_("command '%s' failed: %s") % | ||
|
r1293 | (cmd, explain_exit(code))) | ||
return open(outname, 'rb').read() | ||||
finally: | ||||
try: | ||||
if inname: os.unlink(inname) | ||||
except: pass | ||||
try: | ||||
if outname: os.unlink(outname) | ||||
except: pass | ||||
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""" | ||
if s and '\0' in s: | ||||
|
r1015 | return True | ||
return False | ||||
|
r556 | def unique(g): | ||
|
r1082 | """return the uniq elements of iterable g""" | ||
|
r5881 | return dict.fromkeys(g).keys() | ||
|
r556 | |||
|
r6762 | def sort(l): | ||
if not isinstance(l, list): | ||||
l = list(l) | ||||
l.sort() | ||||
return l | ||||
|
r870 | class Abort(Exception): | ||
"""Raised if a command needs to print an error and exit.""" | ||||
|
r508 | |||
|
r3564 | class UnexpectedOutput(Abort): | ||
"""Raised to print an error with part of output and exit.""" | ||||
|
r724 | def always(fn): return True | ||
def never(fn): return False | ||||
|
r4054 | def expand_glob(pats): | ||
'''On Windows, expand the implicit globs in a list of patterns''' | ||||
if os.name != 'nt': | ||||
return list(pats) | ||||
ret = [] | ||||
for p in pats: | ||||
kind, name = patkind(p, None) | ||||
if kind is None: | ||||
globbed = glob.glob(name) | ||||
if globbed: | ||||
ret.extend(globbed) | ||||
continue | ||||
# if we couldn't expand the glob, just keep it around | ||||
ret.append(p) | ||||
return ret | ||||
|
r6595 | def patkind(name, default): | ||
|
r1563 | """Split a string into an optional pattern kind prefix and the | ||
actual pattern.""" | ||||
for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre': | ||||
if name.startswith(prefix + ':'): return name.split(':', 1) | ||||
|
r6595 | return default, name | ||
|
r1563 | |||
|
r1062 | def globre(pat, head='^', tail='$'): | ||
|
r724 | "convert a glob pattern into a regexp" | ||
i, n = 0, len(pat) | ||||
res = '' | ||||
|
r5949 | group = 0 | ||
|
r724 | 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 == '{': | ||||
|
r5949 | group += 1 | ||
|
r724 | res += '(?:' | ||
elif c == '}' and group: | ||||
res += ')' | ||||
|
r5949 | group -= 1 | ||
|
r724 | elif c == ',' and group: | ||
res += '|' | ||||
|
r1990 | elif c == '\\': | ||
p = peek() | ||||
if p: | ||||
i += 1 | ||||
res += re.escape(p) | ||||
else: | ||||
res += re.escape(c) | ||||
|
r724 | else: | ||
res += re.escape(c) | ||||
return head + res + tail | ||||
|
r812 | _globchars = {'[': 1, '{': 1, '*': 1, '?': 1} | ||
|
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 | ''' | ||
|
r886 | 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 | |||
|
r1081 | def canonpath(root, cwd, myname): | ||
|
r1082 | """return the canonical path of myname, given cwd and root""" | ||
|
r1566 | if root == os.sep: | ||
rootsep = os.sep | ||||
|
r5843 | elif 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) | ||
|
r5158 | audit_path = path_auditor(root) | ||
|
r2278 | if name != rootsep and name.startswith(rootsep): | ||
|
r1976 | name = name[len(rootsep):] | ||
audit_path(name) | ||||
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) | ||||
audit_path(name) | ||||
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 | |||
|
r6575 | def matcher(canonroot, cwd='', names=[], inc=[], exc=[], src=None, dflt_pat='glob'): | ||
|
r1082 | """build a function to match a set of file patterns | ||
arguments: | ||||
canonroot - the canonical root of the tree you're matching against | ||||
cwd - the current working directory, if relevant | ||||
names - patterns to find | ||||
inc - patterns to include | ||||
exc - patterns to exclude | ||||
|
r4185 | dflt_pat - if a pattern in names has no explicit type, assume this one | ||
src - where these patterns came from (e.g. .hgignore) | ||||
|
r1082 | |||
a pattern is one of: | ||||
|
r4185 | 'glob:<glob>' - a glob relative to cwd | ||
're:<regexp>' - a regular expression | ||||
'path:<path>' - a path relative to canonroot | ||||
'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs) | ||||
'relpath:<path>' - a path relative to cwd | ||||
'relre:<regexp>' - a regexp that doesn't have to match the start of a name | ||||
'<something>' - one of the cases above, selected by the dflt_pat argument | ||||
|
r1082 | |||
returns: | ||||
a 3-tuple containing | ||||
|
r4185 | - list of roots (places where one should start a recursive walk of the fs); | ||
this often matches the explicit non-pattern names passed in, but also | ||||
includes the initial part of glob: patterns that has no glob characters | ||||
|
r1082 | - a bool match(filename) function | ||
- a bool indicating if any patterns were passed in | ||||
""" | ||||
|
r4198 | # a common case: no patterns at all | ||
if not names and not inc and not exc: | ||||
return [], always, False | ||||
|
r1082 | |||
|
r1413 | def contains_glob(name): | ||
|
r812 | for c in name: | ||
|
r1413 | if c in _globchars: return True | ||
return False | ||||
|
r820 | |||
|
r888 | def regex(kind, name, tail): | ||
|
r742 | '''convert a pattern into a regular expression''' | ||
|
r4190 | if not name: | ||
return '' | ||||
|
r820 | if kind == 're': | ||
return name | ||||
elif kind == 'path': | ||||
|
r888 | return '^' + re.escape(name) + '(?:/|$)' | ||
|
r1270 | elif kind == 'relglob': | ||
|
r4307 | return globre(name, '(?:|.*/)', tail) | ||
|
r888 | elif kind == 'relpath': | ||
|
r4197 | return re.escape(name) + '(?:/|$)' | ||
|
r1270 | elif kind == 'relre': | ||
if name.startswith('^'): | ||||
return name | ||||
return '.*' + name | ||||
|
r4306 | return globre(name, '', tail) | ||
|
r742 | |||
def matchfn(pats, tail): | ||||
"""build a matching function from a set of patterns""" | ||||
|
r1454 | if not pats: | ||
return | ||||
|
r4371 | try: | ||
pat = '(?:%s)' % '|'.join([regex(k, p, tail) for (k, p) in pats]) | ||||
|
r6074 | if len(pat) > 20000: | ||
raise OverflowError() | ||||
|
r4371 | return re.compile(pat).match | ||
|
r5201 | except OverflowError: | ||
# We're using a Python with a tiny regex engine and we | ||||
# made it explode, so we'll divide the pattern list in two | ||||
# until it works | ||||
l = len(pats) | ||||
if l < 2: | ||||
raise | ||||
|
r5454 | a, b = matchfn(pats[:l//2], tail), matchfn(pats[l//2:], tail) | ||
|
r5201 | return lambda s: a(s) or b(s) | ||
|
r4371 | except re.error: | ||
for k, p in pats: | ||||
try: | ||||
re.compile('(?:%s)' % regex(k, p, tail)) | ||||
except re.error: | ||||
if src: | ||||
raise Abort("%s: invalid pattern (%s): %s" % | ||||
(src, k, p)) | ||||
else: | ||||
raise Abort("invalid pattern (%s): %s" % (k, p)) | ||||
raise Abort("invalid pattern") | ||||
|
r742 | |||
|
r820 | def globprefix(pat): | ||
'''return the non-glob prefix of a path, e.g. foo/* -> foo''' | ||||
root = [] | ||||
|
r4183 | for p in pat.split('/'): | ||
|
r1413 | if contains_glob(p): break | ||
|
r820 | root.append(p) | ||
|
r4187 | return '/'.join(root) or '.' | ||
|
r820 | |||
|
r4192 | def normalizepats(names, default): | ||
pats = [] | ||||
roots = [] | ||||
anypats = False | ||||
for kind, name in [patkind(p, default) for p in names]: | ||||
if kind in ('glob', 'relpath'): | ||||
name = canonpath(canonroot, cwd, name) | ||||
elif kind in ('relglob', 'path'): | ||||
name = normpath(name) | ||||
|
r4236 | |||
pats.append((kind, name)) | ||||
|
r820 | |||
|
r4192 | if kind in ('glob', 're', 'relglob', 'relre'): | ||
anypats = True | ||||
|
r4236 | |||
|
r4192 | if kind == 'glob': | ||
root = globprefix(name) | ||||
roots.append(root) | ||||
elif kind in ('relpath', 'path'): | ||||
|
r4233 | roots.append(name or '.') | ||
|
r4192 | elif kind == 'relglob': | ||
roots.append('.') | ||||
|
r4236 | return roots, pats, anypats | ||
|
r4192 | |||
roots, pats, anypats = normalizepats(names, dflt_pat) | ||||
|
r897 | |||
|
r820 | patmatch = matchfn(pats, '$') or always | ||
|
r897 | incmatch = always | ||
if inc: | ||||
|
r4192 | dummy, inckinds, dummy = normalizepats(inc, 'glob') | ||
|
r2480 | incmatch = matchfn(inckinds, '(?:/|$)') | ||
|
r897 | excmatch = lambda fn: False | ||
if exc: | ||||
|
r4192 | dummy, exckinds, dummy = normalizepats(exc, 'glob') | ||
|
r2480 | excmatch = matchfn(exckinds, '(?:/|$)') | ||
|
r742 | |||
|
r4199 | if not names and inc and not exc: | ||
# common case: hgignore patterns | ||||
match = incmatch | ||||
else: | ||||
match = lambda fn: incmatch(fn) and not excmatch(fn) and patmatch(fn) | ||||
return (roots, match, (inc or exc or anypats) and True) | ||||
|
r742 | |||
|
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: | ||||
|
r6500 | set_hgexecutable(find_exe('hg', 'hg')) | ||
|
r5062 | return _hgexecutable | ||
|
r4686 | |||
def set_hgexecutable(path): | ||||
|
r5062 | """set location of the 'hg' executable""" | ||
|
r4686 | global _hgexecutable | ||
|
r5062 | _hgexecutable = path | ||
|
r4686 | |||
|
r1882 | def system(cmd, environ={}, cwd=None, onerr=None, errprefix=None): | ||
'''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 | ||||
exception.''' | ||||
|
r2601 | def py2shell(val): | ||
'convert python object into string that is useful to shell' | ||||
if val in (None, False): | ||||
return '0' | ||||
if val == True: | ||||
return '1' | ||||
return str(val) | ||||
|
r1880 | oldenv = {} | ||
for k in environ: | ||||
oldenv[k] = os.environ.get(k) | ||||
if cwd is not None: | ||||
oldcwd = os.getcwd() | ||||
|
r3905 | origcmd = cmd | ||
if os.name == 'nt': | ||||
cmd = '"%s"' % cmd | ||||
|
r1880 | try: | ||
for k, v in environ.iteritems(): | ||||
|
r2601 | os.environ[k] = py2shell(v) | ||
|
r5062 | os.environ['HG'] = hgexecutable() | ||
|
r1880 | if cwd is not None and oldcwd != cwd: | ||
os.chdir(cwd) | ||||
|
r1882 | rc = os.system(cmd) | ||
|
r4720 | if sys.platform == 'OpenVMS' and rc & 1: | ||
rc = 0 | ||||
|
r1882 | if rc and onerr: | ||
|
r3905 | errmsg = '%s %s' % (os.path.basename(origcmd.split(None, 1)[0]), | ||
|
r1882 | explain_exit(rc)[0]) | ||
if errprefix: | ||||
errmsg = '%s: %s' % (errprefix, errmsg) | ||||
try: | ||||
onerr.warn(errmsg + '\n') | ||||
except AttributeError: | ||||
raise onerr(errmsg) | ||||
return rc | ||||
|
r1880 | finally: | ||
for k, v in oldenv.iteritems(): | ||||
if v is None: | ||||
del os.environ[k] | ||||
else: | ||||
os.environ[k] = v | ||||
if cwd is not None and oldcwd != cwd: | ||||
os.chdir(oldcwd) | ||||
|
r4281 | # os.path.lexists is not available on python2.3 | ||
def lexists(filename): | ||||
"test whether a file with this name exists. does not follow symlinks" | ||||
try: | ||||
os.lstat(filename) | ||||
except: | ||||
return False | ||||
return True | ||||
|
r421 | def rename(src, dst): | ||
|
r1082 | """forcibly rename a file""" | ||
|
r421 | try: | ||
os.rename(src, dst) | ||||
|
r4956 | except OSError, err: # FIXME: check err (EEXIST ?) | ||
|
r2176 | # on windows, rename to existing file is not allowed, so we | ||
# must delete destination first. but if file is open, unlink | ||||
# schedules it for delete but does not delete it. rename | ||||
# happens immediately even for open files, so we create | ||||
# temporary file, delete it, rename destination to that name, | ||||
# then delete that. then rename is safe to do. | ||||
fd, temp = tempfile.mkstemp(dir=os.path.dirname(dst) or '.') | ||||
os.close(fd) | ||||
os.unlink(temp) | ||||
os.rename(dst, temp) | ||||
os.unlink(temp) | ||||
|
r421 | os.rename(src, dst) | ||
|
r1415 | def unlink(f): | ||
"""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): | ||
"copy a file, preserving mode" | ||||
|
r4271 | if os.path.islink(src): | ||
try: | ||||
os.unlink(dest) | ||||
except: | ||||
pass | ||||
os.symlink(os.readlink(src), dest) | ||||
else: | ||||
try: | ||||
shutil.copyfile(src, dest) | ||||
shutil.copymode(src, dest) | ||||
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 | |||
|
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) | ||||
|
r1241 | copyfiles(srcname, dstname, hardlink) | ||
|
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) | ||
|
r698 | |||
|
r5158 | class path_auditor(object): | ||
'''ensure that a filesystem path contains no banned components. | ||||
the following properties of a path are checked: | ||||
- under top-level .hg | ||||
- starts at the root of a windows drive | ||||
- contains ".." | ||||
- traverses a symlink (e.g. a/symlink_here/b) | ||||
- inside a nested repository''' | ||||
def __init__(self, root): | ||||
|
r5200 | self.audited = set() | ||
self.auditeddir = set() | ||||
|
r5158 | self.root = root | ||
def __call__(self, path): | ||||
if path in self.audited: | ||||
return | ||||
|
r5159 | normpath = os.path.normcase(path) | ||
|
r5844 | parts = splitpath(normpath) | ||
|
r5158 | if (os.path.splitdrive(path)[0] or parts[0] in ('.hg', '') | ||
or os.pardir in parts): | ||||
raise Abort(_("path contains illegal component: %s") % path) | ||||
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'))): | ||||
|
r5158 | raise Abort(_('path %r is inside repo %r') % | ||
(path, prefix)) | ||||
|
r5845 | parts.pop() | ||
|
r5200 | prefixes = [] | ||
|
r5845 | for n in range(len(parts)): | ||
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 | |||
|
r704 | 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): | ||||
|
r2176 | return posixfile(pathname).read() | ||
|
r704 | |||
|
r1241 | def nlinks(pathname): | ||
"""Return number of hardlinks for the given file.""" | ||||
|
r2448 | return os.lstat(pathname).st_nlink | ||
|
r1241 | |||
if hasattr(os, 'link'): | ||||
os_link = os.link | ||||
else: | ||||
def os_link(src, dst): | ||||
|
r1402 | raise OSError(0, _("Hardlinks not supported")) | ||
|
r1241 | |||
|
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) | ||||
posixfile = file | ||||
|
r5659 | def openhardlinks(): | ||
'''return true if it is safe to hold open file handles to hardlinks''' | ||||
return True | ||||
|
r2250 | |||
|
r7118 | def _statfiles(files): | ||
'Stat each file in files and yield stat or None if file does not exist.' | ||||
lstat = os.lstat | ||||
for nf in files: | ||||
try: | ||||
st = lstat(nf) | ||||
except OSError, err: | ||||
if err.errno not in (errno.ENOENT, errno.ENOTDIR): | ||||
raise | ||||
st = None | ||||
yield st | ||||
def _statfiles_clustered(files): | ||||
'''Stat each file in files and yield stat or None if file does not exist. | ||||
Cluster and cache stat per directory to minimize number of OS stat calls.''' | ||||
lstat = os.lstat | ||||
ncase = os.path.normcase | ||||
sep = os.sep | ||||
dircache = {} # dirname -> filename -> status | None if file does not exist | ||||
for nf in files: | ||||
nf = ncase(nf) | ||||
pos = nf.rfind(sep) | ||||
if pos == -1: | ||||
dir, base = '.', nf | ||||
else: | ||||
dir, base = nf[:pos], nf[pos+1:] | ||||
cache = dircache.get(dir, None) | ||||
if cache is None: | ||||
try: | ||||
dmap = dict([(ncase(n), s) | ||||
for n, k, s in osutil.listdir(dir, True)]) | ||||
except OSError, err: | ||||
# handle directory not found in Python version prior to 2.5 | ||||
# Python <= 2.4 returns native Windows code 3 in errno | ||||
# Python >= 2.5 returns ENOENT and adds winerror field | ||||
|
r7137 | # EINVAL is raised if dir is not a directory. | ||
if err.errno not in (3, errno.ENOENT, errno.EINVAL, | ||||
errno.ENOTDIR): | ||||
|
r7118 | raise | ||
dmap = {} | ||||
cache = dircache.setdefault(dir, dmap) | ||||
yield cache.get(base, None) | ||||
if sys.platform == 'win32': | ||||
statfiles = _statfiles_clustered | ||||
else: | ||||
statfiles = _statfiles | ||||
|
r3721 | getuser_fallback = None | ||
def getuser(): | ||||
'''return name of current user''' | ||||
try: | ||||
return getpass.getuser() | ||||
except ImportError: | ||||
# import of pwd will fail on windows - try fallback | ||||
if getuser_fallback: | ||||
return getuser_fallback() | ||||
# raised if win32api not available | ||||
raise Abort(_('user name not available - set USERNAME ' | ||||
'environment variable')) | ||||
|
r3551 | def username(uid=None): | ||
"""Return the name of the user with the given uid. | ||||
If uid is None, return the name of the current user.""" | ||||
try: | ||||
import pwd | ||||
if uid is None: | ||||
uid = os.getuid() | ||||
try: | ||||
return pwd.getpwuid(uid)[0] | ||||
except KeyError: | ||||
return str(uid) | ||||
except ImportError: | ||||
return None | ||||
def groupname(gid=None): | ||||
"""Return the name of the group with the given gid. | ||||
If gid is None, return the name of the current group.""" | ||||
try: | ||||
import grp | ||||
if gid is None: | ||||
gid = os.getgid() | ||||
try: | ||||
return grp.getgrgid(gid)[0] | ||||
except KeyError: | ||||
return str(gid) | ||||
except ImportError: | ||||
return None | ||||
|
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) | ||||
if name[l] == os.sep or name[l] == os.altsep: | ||||
l = l + 1 | ||||
name = name[l:] | ||||
if not os.path.exists(os.path.join(root, name)): | ||||
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() | ||||
for n in contents: | ||||
if n.lower() == lpart: | ||||
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 | ||
|
r5212 | fh, fn = tempfile.mkstemp("", "", path) | ||
|
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 | ||||
name = tempfile.mktemp(dir=path) | ||||
try: | ||||
os.symlink(".", name) | ||||
os.unlink(name) | ||||
return True | ||||
|
r4017 | except (OSError, AttributeError): | ||
|
r3998 | return False | ||
|
r4327 | _umask = os.umask(0) | ||
os.umask(_umask) | ||||
|
r4434 | def needbinarypatch(): | ||
"""return True if patches should be applied in binary mode by default.""" | ||||
return os.name == 'nt' | ||||
|
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?''' | ||||
return os.name == "nt" or os.name == "mac" or os.environ.get("DISPLAY") | ||||
|
r6132 | def lookup_reg(key, name=None, scope=None): | ||
return None | ||||
|
r1082 | # Platform specific variants | ||
|
r419 | if os.name == 'nt': | ||
|
r3877 | import msvcrt | ||
|
r461 | nulldev = 'NUL:' | ||
|
r1609 | |||
class winstdout: | ||||
'''stdout on windows misbehaves if sent through a pipe''' | ||||
def __init__(self, fp): | ||||
self.fp = fp | ||||
def __getattr__(self, key): | ||||
return getattr(self.fp, key) | ||||
def close(self): | ||||
try: | ||||
self.fp.close() | ||||
except: pass | ||||
def write(self, s): | ||||
try: | ||||
|
r5647 | # This is workaround for "Not enough space" error on | ||
# writing large size of data to console. | ||||
limit = 16000 | ||||
l = len(s) | ||||
start = 0 | ||||
while start < l: | ||||
end = start + limit | ||||
self.fp.write(s[start:end]) | ||||
start = end | ||||
|
r1609 | except IOError, inst: | ||
if inst.errno != 0: raise | ||||
self.close() | ||||
raise IOError(errno.EPIPE, 'Broken pipe') | ||||
|
r4516 | |||
|
r4129 | def flush(self): | ||
try: | ||||
return self.fp.flush() | ||||
except IOError, inst: | ||||
if inst.errno != errno.EINVAL: raise | ||||
self.close() | ||||
raise IOError(errno.EPIPE, 'Broken pipe') | ||||
|
r1609 | |||
sys.stdout = winstdout(sys.stdout) | ||||
|
r5659 | def _is_win_9x(): | ||
'''return true if run on windows 95, 98 or me.''' | ||||
try: | ||||
return sys.getwindowsversion()[3] == 1 | ||||
except AttributeError: | ||||
return 'command' in os.environ.get('comspec', '') | ||||
def openhardlinks(): | ||||
return not _is_win_9x and "win32api" in locals() | ||||
|
r2054 | def system_rcpath(): | ||
|
r2117 | try: | ||
return system_rcpath_win32() | ||||
except: | ||||
return [r'c:\mercurial\mercurial.ini'] | ||||
|
r2054 | |||
|
r4083 | def user_rcpath(): | ||
'''return os-specific hgrc search path to the user dir''' | ||||
|
r4098 | try: | ||
|
r6153 | path = user_rcpath_win32() | ||
|
r4098 | except: | ||
|
r6153 | home = os.path.expanduser('~') | ||
path = [os.path.join(home, 'mercurial.ini'), | ||||
os.path.join(home, '.hgrc')] | ||||
|
r2280 | userprofile = os.environ.get('USERPROFILE') | ||
if userprofile: | ||||
path.append(os.path.join(userprofile, 'mercurial.ini')) | ||||
|
r6153 | path.append(os.path.join(userprofile, '.hgrc')) | ||
|
r2280 | return path | ||
|
r1292 | |||
|
r1285 | def parse_patch_output(output_line): | ||
"""parses the output produced by patch and returns the file name""" | ||||
pf = output_line[14:] | ||||
if pf[0] == '`': | ||||
pf = pf[1:-1] # Remove the quotes | ||||
return pf | ||||
|
r5644 | def sshargs(sshcmd, host, user, port): | ||
'''Build argument list for ssh or Plink''' | ||||
pflag = 'plink' in sshcmd.lower() and '-P' or '-p' | ||||
args = user and ("%s@%s" % (user, host)) or host | ||||
|
r5646 | return port and ("%s %s %s" % (args, pflag, port)) or args | ||
|
r5644 | |||
|
r2054 | def testpid(pid): | ||
'''return False if pid dead, True if running or not known''' | ||||
return True | ||||
|
r1241 | |||
|
r6877 | def set_flags(f, l, x): | ||
|
r441 | pass | ||
|
r515 | |||
|
r1420 | def set_binary(fd): | ||
|
r6339 | # When run without console, pipes may expose invalid | ||
# fileno(), usually set to -1. | ||||
if hasattr(fd, 'fileno') and fd.fileno() >= 0: | ||||
|
r6330 | msvcrt.setmode(fd.fileno(), os.O_BINARY) | ||
|
r1420 | |||
|
r419 | def pconvert(path): | ||
|
r5844 | return '/'.join(splitpath(path)) | ||
|
r422 | |||
|
r886 | def localpath(path): | ||
return path.replace('/', '\\') | ||||
def normpath(path): | ||||
return pconvert(os.path.normpath(path)) | ||||
|
r704 | makelock = _makelock_file | ||
readlock = _readlock_file | ||||
|
r461 | |||
|
r2193 | def samestat(s1, s2): | ||
return False | ||||
|
r4087 | # A sequence of backslashes is special iff it precedes a double quote: | ||
# - if there's an even number of backslashes, the double quote is not | ||||
# quoted (i.e. it ends the quoted region) | ||||
# - if there's an odd number of backslashes, the double quote is quoted | ||||
# - in both cases, every pair of backslashes is unquoted into a single | ||||
# backslash | ||||
# (See http://msdn2.microsoft.com/en-us/library/a1y7w461.aspx ) | ||||
# So, to quote a string, we must surround it in double quotes, double | ||||
# the number of backslashes that preceed double quotes and add another | ||||
# backslash before every double quote (being careful with the double | ||||
# quote we've appended to the end) | ||||
_quotere = None | ||||
|
r2791 | def shellquote(s): | ||
|
r4087 | global _quotere | ||
if _quotere is None: | ||||
_quotere = re.compile(r'(\\*)("|\\$)') | ||||
return '"%s"' % _quotere.sub(r'\1\1\\\2', s) | ||||
|
r2791 | |||
|
r5292 | def quotecommand(cmd): | ||
"""Build a command string suitable for os.popen* calls.""" | ||||
# The extra quotes are needed because popen* runs the command | ||||
# through the current COMSPEC. cmd.exe suppress enclosing quotes. | ||||
return '"' + cmd + '"' | ||||
|
r6548 | def popen(command, mode='r'): | ||
|
r5481 | # Work around "popen spawned process may not write to stdout | ||
# under windows" | ||||
# http://bugs.python.org/issue1366 | ||||
command += " 2> %s" % nulldev | ||||
|
r6548 | return os.popen(quotecommand(command), mode) | ||
|
r5481 | |||
|
r782 | def explain_exit(code): | ||
|
r1402 | return _("exited with status %d") % code, code | ||
|
r782 | |||
|
r3677 | # if you change this stub into a real check, please try to implement the | ||
# username and groupname functions above, too. | ||||
def isowner(fp, st=None): | ||||
return True | ||||
|
r4516 | |||
|
r4407 | def find_in_path(name, path, default=None): | ||
'''find name in search path. path can be string (will be split | ||||
with os.pathsep), or iterable thing that returns strings. if name | ||||
found, return path to name. else return default. name is looked up | ||||
using cmd.exe rules, using PATHEXT.''' | ||||
if isinstance(path, str): | ||||
path = path.split(os.pathsep) | ||||
|
r4516 | |||
|
r4407 | pathext = os.environ.get('PATHEXT', '.COM;.EXE;.BAT;.CMD') | ||
pathext = pathext.lower().split(os.pathsep) | ||||
isexec = os.path.splitext(name)[1].lower() in pathext | ||||
|
r4516 | |||
|
r4407 | for p in path: | ||
p_name = os.path.join(p, name) | ||||
|
r4516 | |||
|
r4407 | if isexec and os.path.exists(p_name): | ||
return p_name | ||||
|
r4516 | |||
|
r4407 | for ext in pathext: | ||
p_name_ext = p_name + ext | ||||
if os.path.exists(p_name_ext): | ||||
return p_name_ext | ||||
return default | ||||
|
r3677 | |||
|
r4803 | def set_signal_handler(): | ||
try: | ||||
set_signal_handler_win32() | ||||
except NameError: | ||||
pass | ||||
|
r2054 | try: | ||
# override functions with win32 versions if possible | ||||
from util_win32 import * | ||||
|
r5659 | if not _is_win_9x(): | ||
|
r2250 | posixfile = posixfile_nt | ||
|
r2054 | except ImportError: | ||
pass | ||||
|
r419 | else: | ||
|
r461 | nulldev = '/dev/null' | ||
|
r1583 | def rcfiles(path): | ||
rcs = [os.path.join(path, 'hgrc')] | ||||
rcdir = os.path.join(path, 'hgrc.d') | ||||
try: | ||||
|
r5396 | rcs.extend([os.path.join(rcdir, f) | ||
for f, kind in osutil.listdir(rcdir) | ||||
|
r1583 | if f.endswith(".rc")]) | ||
|
r3131 | except OSError: | ||
pass | ||||
|
r1583 | return rcs | ||
|
r1951 | |||
|
r4083 | def system_rcpath(): | ||
|
r1951 | path = [] | ||
|
r2263 | # old mod_python does not set sys.argv | ||
|
r2261 | if len(getattr(sys, 'argv', [])) > 0: | ||
|
r1951 | path.extend(rcfiles(os.path.dirname(sys.argv[0]) + | ||
'/../etc/mercurial')) | ||||
path.extend(rcfiles('/etc/mercurial')) | ||||
return path | ||||
|
r1292 | |||
|
r4083 | def user_rcpath(): | ||
return [os.path.expanduser('~/.hgrc')] | ||||
|
r1285 | def parse_patch_output(output_line): | ||
"""parses the output produced by patch and returns the file name""" | ||||
|
r1593 | pf = output_line[14:] | ||
|
r4720 | if os.sys.platform == 'OpenVMS': | ||
if pf[0] == '`': | ||||
pf = pf[1:-1] # Remove the quotes | ||||
else: | ||||
if pf.startswith("'") and pf.endswith("'") and " " in pf: | ||||
pf = pf[1:-1] # Remove the quotes | ||||
|
r1593 | return pf | ||
|
r1285 | |||
|
r5644 | def sshargs(sshcmd, host, user, port): | ||
'''Build argument list for ssh''' | ||||
args = user and ("%s@%s" % (user, host)) or host | ||||
|
r5646 | return port and ("%s -p %s" % (args, port)) or args | ||
|
r5644 | |||
|
r3997 | def is_exec(f): | ||
|
r1082 | """check whether a file is executable""" | ||
|
r2448 | return (os.lstat(f).st_mode & 0100 != 0) | ||
|
r441 | |||
|
r6877 | def set_flags(f, l, x): | ||
|
r2448 | s = os.lstat(f).st_mode | ||
|
r5702 | if l: | ||
if not stat.S_ISLNK(s): | ||||
# switch file to link | ||||
data = file(f).read() | ||||
os.unlink(f) | ||||
|
r6878 | try: | ||
os.symlink(data, f) | ||||
except: | ||||
# failed to make a link, rewrite file | ||||
file(f, "w").write(data) | ||||
|
r5702 | # no chmod needed at this point | ||
|
r441 | return | ||
|
r5702 | if stat.S_ISLNK(s): | ||
# switch link to file | ||||
|
r3999 | data = os.readlink(f) | ||
os.unlink(f) | ||||
file(f, "w").write(data) | ||||
|
r5702 | s = 0666 & ~_umask # avoid restatting for chmod | ||
sx = s & 0100 | ||||
if x and not sx: | ||||
# Turn on +x for every +r bit when making a file executable | ||||
# and obey umask. | ||||
os.chmod(f, s | (s & 0444) >> 2 & ~_umask) | ||||
elif not x and sx: | ||||
# Turn off all +x bits | ||||
os.chmod(f, s & 0666) | ||||
|
r3999 | |||
|
r1420 | def set_binary(fd): | ||
pass | ||||
|
r419 | def pconvert(path): | ||
return path | ||||
|
r886 | def localpath(path): | ||
return path | ||||
normpath = os.path.normpath | ||||
|
r2193 | samestat = os.path.samestat | ||
|
r886 | |||
|
r422 | def makelock(info, pathname): | ||
|
r704 | try: | ||
os.symlink(info, pathname) | ||||
except OSError, why: | ||||
if why.errno == errno.EEXIST: | ||||
raise | ||||
else: | ||||
_makelock_file(info, pathname) | ||||
|
r422 | |||
def readlock(pathname): | ||||
|
r704 | try: | ||
return os.readlink(pathname) | ||||
except OSError, why: | ||||
|
r4720 | if why.errno in (errno.EINVAL, errno.ENOSYS): | ||
|
r704 | return _readlock_file(pathname) | ||
else: | ||||
raise | ||||
|
r782 | |||
|
r2791 | def shellquote(s): | ||
|
r4720 | if os.sys.platform == 'OpenVMS': | ||
return '"%s"' % s | ||||
else: | ||||
return "'%s'" % s.replace("'", "'\\''") | ||||
|
r2791 | |||
|
r5292 | def quotecommand(cmd): | ||
return cmd | ||||
|
r6548 | def popen(command, mode='r'): | ||
return os.popen(command, mode) | ||||
|
r5481 | |||
|
r1877 | def testpid(pid): | ||
'''return False if pid dead, True if running or not sure''' | ||||
|
r4720 | if os.sys.platform == 'OpenVMS': | ||
return True | ||||
|
r1877 | try: | ||
os.kill(pid, 0) | ||||
return True | ||||
except OSError, inst: | ||||
return inst.errno != errno.ESRCH | ||||
|
r782 | def explain_exit(code): | ||
"""return a 2-tuple (desc, code) describing a process's status""" | ||||
if os.WIFEXITED(code): | ||||
val = os.WEXITSTATUS(code) | ||||
|
r1402 | return _("exited with status %d") % val, val | ||
|
r782 | elif os.WIFSIGNALED(code): | ||
val = os.WTERMSIG(code) | ||||
|
r1402 | return _("killed by signal %d") % val, val | ||
|
r782 | elif os.WIFSTOPPED(code): | ||
|
r912 | val = os.WSTOPSIG(code) | ||
|
r1402 | return _("stopped by signal %d") % val, val | ||
raise ValueError(_("invalid exit code")) | ||||
|
r1199 | |||
|
r3677 | def isowner(fp, st=None): | ||
"""Return True if the file object f belongs to the current user. | ||||
The return value of a util.fstat(f) may be passed as the st argument. | ||||
""" | ||||
if st is None: | ||||
|
r3859 | st = fstat(fp) | ||
|
r3677 | return st.st_uid == os.getuid() | ||
|
r4516 | |||
|
r4407 | def find_in_path(name, path, default=None): | ||
'''find name in search path. path can be string (will be split | ||||
with os.pathsep), or iterable thing that returns strings. if name | ||||
found, return path to name. else return default.''' | ||||
if isinstance(path, str): | ||||
path = path.split(os.pathsep) | ||||
for p in path: | ||||
p_name = os.path.join(p, name) | ||||
if os.path.exists(p_name): | ||||
return p_name | ||||
return default | ||||
|
r3677 | |||
|
r4672 | def set_signal_handler(): | ||
pass | ||||
|
r4488 | def find_exe(name, default=None): | ||
'''find path of an executable. | ||||
if name contains a path component, return it as is. otherwise, | ||||
use normal executable search path.''' | ||||
|
r4720 | if os.sep in name or sys.platform == 'OpenVMS': | ||
|
r4488 | # don't check the executable bit. if the file isn't | ||
# executable, whoever tries to actually run it will give a | ||||
# much more useful error message. | ||||
return name | ||||
return find_in_path(name, os.environ.get('PATH', ''), default=default) | ||||
|
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: | ||||
st_mode = ~_umask | ||||
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 | |||
|
r4827 | class atomictempfile(posixfile): | ||
"""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. | ||||
""" | ||||
|
r6062 | def __init__(self, name, mode, createmode): | ||
|
r4827 | self.__name = name | ||
|
r6062 | self.temp = mktempcopy(name, emptyok=('w' in mode), | ||
createmode=createmode) | ||||
|
r4827 | posixfile.__init__(self, self.temp, mode) | ||
def rename(self): | ||||
if not self.closed: | ||||
posixfile.close(self) | ||||
rename(self.temp, localpath(self.__name)) | ||||
def __del__(self): | ||||
if not self.closed: | ||||
try: | ||||
os.unlink(self.temp) | ||||
except: pass | ||||
posixfile.close(self) | ||||
|
r6062 | def makedirs(name, mode=None): | ||
"""recursive directory creation with parent mode inheritance""" | ||||
try: | ||||
os.mkdir(name) | ||||
if mode is not None: | ||||
os.chmod(name, mode) | ||||
return | ||||
except OSError, err: | ||||
if err.errno == errno.EEXIST: | ||||
return | ||||
if err.errno != errno.ENOENT: | ||||
raise | ||||
parent = os.path.abspath(os.path.dirname(name)) | ||||
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: | ||
self.audit_path = path_auditor(base) | ||||
else: | ||||
self.audit_path = always | ||||
|
r6062 | self.createmode = None | ||
|
r2176 | |||
|
r4828 | def __getattr__(self, name): | ||
if name == '_can_symlink': | ||||
self._can_symlink = checklink(self.base) | ||||
return self._can_symlink | ||||
raise AttributeError(name) | ||||
|
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): | ||
|
r5158 | self.audit_path(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 | ||
|
r6835 | if mode not in ("r", "rb"): | ||
|
r2176 | try: | ||
nlink = nlinks(f) | ||||
except OSError: | ||||
|
r4328 | nlink = 0 | ||
|
r2176 | d = os.path.dirname(f) | ||
if not os.path.isdir(d): | ||||
|
r6062 | makedirs(d, self.createmode) | ||
|
r4508 | if atomictemp: | ||
|
r6062 | return atomictempfile(f, mode, self.createmode) | ||
|
r4328 | if nlink > 1: | ||
rename(mktempcopy(f), f) | ||||
|
r6062 | fp = posixfile(f, mode) | ||
if nlink == 0: | ||||
self._fixfilemode(f) | ||||
return fp | ||||
|
r2176 | |||
|
r4828 | def symlink(self, src, dst): | ||
|
r5158 | self.audit_path(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.""" | ||||
|
r5447 | self.iter = iter(in_iter) | ||
|
r1199 | self.buf = '' | ||
|
r5446 | self.targetsize = 2**16 | ||
|
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.""" | ||
|
r5447 | if l > len(self.buf) and self.iter: | ||
|
r1199 | # Clamp to a multiple of self.targetsize | ||
|
r5449 | targetsize = max(l, self.targetsize) | ||
|
r1199 | collector = cStringIO.StringIO() | ||
collector.write(self.buf) | ||||
collected = len(self.buf) | ||||
|
r5447 | for chunk in self.iter: | ||
|
r1199 | collector.write(chunk) | ||
collected += len(chunk) | ||||
if collected >= targetsize: | ||||
break | ||||
if collected < targetsize: | ||||
|
r5447 | self.iter = False | ||
|
r1199 | self.buf = collector.getvalue() | ||
|
r5449 | if len(self.buf) == l: | ||
|
r5450 | s, self.buf = str(self.buf), '' | ||
|
r5449 | else: | ||
s, self.buf = self.buf[:l], buffer(self.buf, l) | ||||
|
r1199 | return s | ||
|
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: | ||||
if limit is None: nbytes = size | ||||
else: nbytes = min(limit, size) | ||||
s = nbytes and f.read(nbytes) | ||||
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 | ||||
return time.mktime(lt), 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() | ||
|
r6229 | if "%1" in format or "%2" in format: | ||
sign = (tz > 0) and "-" or "+" | ||||
minutes = abs(tz) / 60 | ||||
format = format.replace("%1", "%c%02d" % (sign, minutes / 60)) | ||||
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 | ||||
|
r3809 | if tz == "GMT" or tz == "UTC": | ||
return 0 | ||||
return None | ||||
|
r2522 | |||
|
r3255 | # NOTE: unixtime = localunixtime + offset | ||
|
r3809 | offset, date = timezone(string), string | ||
if offset != None: | ||||
date = " ".join(string.split()[:-1]) | ||||
|
r3808 | |||
|
r3812 | # add missing elements from defaults | ||
for part in defaults: | ||||
found = [True for p in part if ("%"+p) in format] | ||||
if not found: | ||||
date += "@" + defaults[part] | ||||
format += "@%" + part[0] | ||||
|
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 | |||
|
r6139 | def parsedate(date, formats=None, defaults=None): | ||
"""parse a localized date/time string and return a (unixtime, offset) tuple. | ||||
|
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 | ||
if not defaults: | ||||
defaults = {} | ||||
now = makedate() | ||||
for part in "d mb yY HI M S".split(): | ||||
if part not in defaults: | ||||
if part[0] in "HMS": | ||||
defaults[part] = "00" | ||||
else: | ||||
|
r6229 | defaults[part] = datestr(now, "%" + part[0]) | ||
|
r3812 | |||
|
r2523 | for format in formats: | ||
try: | ||||
|
r6139 | when, offset = strdate(date, format, defaults) | ||
|
r6087 | except (ValueError, OverflowError): | ||
|
r2523 | pass | ||
else: | ||||
break | ||||
else: | ||||
|
r6139 | 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) | ||
|
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 | ||||
""" | ||||
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") | ||||
for days in "31 30 29".split(): | ||||
try: | ||||
d["d"] = days | ||||
return parsedate(date, extendeddateformats, d)[0] | ||||
except: | ||||
pass | ||||
d["d"] = "28" | ||||
return parsedate(date, extendeddateformats, d)[0] | ||||
if date[0] == "<": | ||||
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: | ||||
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('>') | ||||
if r == -1: r = None | ||||
return author[author.find('<')+1:r] | ||||
|
r3767 | def ellipsis(text, maxlength=400): | ||
"""Trim string to at most maxlength (default: 400) characters.""" | ||||
if len(text) <= maxlength: | ||||
return text | ||||
else: | ||||
return "%s..." % (text[:maxlength-3]) | ||||
|
r6284 | def walkrepos(path, followsym=False, seen_dirs=None): | ||
|
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): | ||||
|
r6140 | if '.hg' in dirs: | ||
dirs[:] = [] # don't descend further | ||||
yield root # found a repository | ||||
|
r6166 | qroot = os.path.join(root, '.hg', 'patches') | ||
|
r6267 | if os.path.isdir(os.path.join(qroot, '.hg')): | ||
|
r6166 | yield qroot # we have a patch queue repo here | ||
|
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): | ||||
if not p: continue | ||||
|
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 = ( | ||||
(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')), | ||||
(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 | |||
def drop_scheme(scheme, path): | ||||
sc = scheme + ':' | ||||
if path.startswith(sc): | ||||
path = path[len(sc):] | ||||
if path.startswith('//'): | ||||
path = path[2:] | ||||
return path | ||||
|
r5291 | |||
def uirepr(s): | ||||
# Avoid double backslash in Windows path repr() | ||||
return repr(s).replace('\\\\', '\\') | ||||
|
r5525 | |||
def hidepassword(url): | ||||
|
r5798 | '''hide user credential in a url string''' | ||
scheme, netloc, path, params, query, fragment = urlparse.urlparse(url) | ||||
netloc = re.sub('([^:]*):([^@]*)@(.*)', r'\1:***@\3', netloc) | ||||
return urlparse.urlunparse((scheme, netloc, path, params, query, fragment)) | ||||
|
r5525 | |||
|
r5798 | def removeauth(url): | ||
'''remove all authentication information from a url string''' | ||||
scheme, netloc, path, params, query, fragment = urlparse.urlparse(url) | ||||
netloc = netloc[netloc.find('@')+1:] | ||||
return urlparse.urlunparse((scheme, netloc, path, params, query, fragment)) | ||||