scmutil.py
2021 lines
| 71.1 KiB
| text/x-python
|
PythonLexer
/ mercurial / scmutil.py
|
r13962 | # scmutil.py - Mercurial core utility functions | ||
# | ||||
# Copyright Matt Mackall <mpm@selenic.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
|
r27482 | from __future__ import absolute_import | ||
import errno | ||||
import glob | ||||
|
r29341 | import hashlib | ||
|
r27482 | import os | ||
|
r41799 | import posixpath | ||
|
r27482 | import re | ||
|
r34462 | import subprocess | ||
r33249 | import weakref | |||
|
r27482 | |||
from .i18n import _ | ||||
|
r32656 | from .node import ( | ||
|
r37546 | bin, | ||
|
r33088 | hex, | ||
nullid, | ||||
|
r39930 | nullrev, | ||
|
r34328 | short, | ||
|
r32656 | wdirid, | ||
wdirrev, | ||||
) | ||||
|
r27482 | from . import ( | ||
|
r42103 | copies as copiesmod, | ||
|
r27482 | encoding, | ||
error, | ||||
match as matchmod, | ||||
|
r33088 | obsolete, | ||
r33249 | obsutil, | |||
|
r27482 | pathutil, | ||
phases, | ||||
|
r39262 | policy, | ||
|
r30305 | pycompat, | ||
|
r31024 | revsetlang, | ||
|
r27482 | similar, | ||
|
r39933 | smartset, | ||
|
r34457 | url, | ||
|
r27482 | util, | ||
|
r34544 | vfs, | ||
|
r27482 | ) | ||
|
r18690 | |||
|
r37102 | from .utils import ( | ||
|
r37138 | procutil, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r34646 | if pycompat.iswindows: | ||
|
r27482 | from . import scmwindows as scmplatform | ||
|
r18690 | else: | ||
|
r27482 | from . import scmposix as scmplatform | ||
|
r18690 | |||
|
r39262 | parsers = policy.importmod(r'parsers') | ||
|
r30314 | termsize = scmplatform.termsize | ||
|
r13962 | |||
|
r22913 | class status(tuple): | ||
'''Named tuple with a list of files per status. The 'deleted', 'unknown' | ||||
and 'ignored' properties are only relevant to the working copy. | ||||
''' | ||||
__slots__ = () | ||||
def __new__(cls, modified, added, removed, deleted, unknown, ignored, | ||||
clean): | ||||
return tuple.__new__(cls, (modified, added, removed, deleted, unknown, | ||||
ignored, clean)) | ||||
@property | ||||
def modified(self): | ||||
|
r22915 | '''files that have been modified''' | ||
|
r22913 | return self[0] | ||
@property | ||||
def added(self): | ||||
|
r22915 | '''files that have been added''' | ||
|
r22913 | return self[1] | ||
@property | ||||
def removed(self): | ||||
|
r22915 | '''files that have been removed''' | ||
|
r22913 | return self[2] | ||
@property | ||||
def deleted(self): | ||||
|
r22915 | '''files that are in the dirstate, but have been deleted from the | ||
working copy (aka "missing") | ||||
''' | ||||
|
r22913 | return self[3] | ||
@property | ||||
def unknown(self): | ||||
|
r22915 | '''files not in the dirstate that are not ignored''' | ||
|
r22913 | return self[4] | ||
@property | ||||
def ignored(self): | ||||
|
r22915 | '''files not in the dirstate that are ignored (by _dirignore())''' | ||
|
r22913 | return self[5] | ||
@property | ||||
def clean(self): | ||||
|
r22915 | '''files that have not been modified''' | ||
|
r22913 | return self[6] | ||
def __repr__(self, *args, **kwargs): | ||||
|
r37940 | return ((r'<status modified=%s, added=%s, removed=%s, deleted=%s, ' | ||
r'unknown=%s, ignored=%s, clean=%s>') % | ||||
|
r37961 | tuple(pycompat.sysstr(stringutil.pprint(v)) for v in self)) | ||
|
r22913 | |||
|
r20392 | def itersubrepos(ctx1, ctx2): | ||
"""find subrepos in ctx1 or ctx2""" | ||||
# Create a (subpath, ctx) mapping where we prefer subpaths from | ||||
# ctx1. The subpaths from ctx2 are important when the .hgsub file | ||||
# has been modified (in ctx2) but not yet committed (in ctx1). | ||||
subpaths = dict.fromkeys(ctx2.substate, ctx2) | ||||
subpaths.update(dict.fromkeys(ctx1.substate, ctx1)) | ||||
|
r25418 | |||
missing = set() | ||||
for subpath in ctx2.substate: | ||||
if subpath not in ctx1.substate: | ||||
del subpaths[subpath] | ||||
missing.add(subpath) | ||||
|
r20392 | for subpath, ctx in sorted(subpaths.iteritems()): | ||
yield subpath, ctx.sub(subpath) | ||||
|
r25418 | # Yield an empty subrepo based on ctx1 for anything only in ctx2. That way, | ||
# status and diff will have an accurate result when it does | ||||
# 'sub.{status|diff}(rev2)'. Otherwise, the ctx2 subrepo is compared | ||||
# against itself. | ||||
for subpath in missing: | ||||
yield subpath, ctx2.nullsub(subpath, ctx1) | ||||
|
r17248 | def nochangesfound(ui, repo, excluded=None): | ||
'''Report no changes for push/pull, excluded is None or a list of | ||||
nodes excluded from the push/pull. | ||||
''' | ||||
secretlist = [] | ||||
if excluded: | ||||
for n in excluded: | ||||
ctx = repo[n] | ||||
if ctx.phase() >= phases.secret and not ctx.extinct(): | ||||
secretlist.append(n) | ||||
|
r15993 | if secretlist: | ||
ui.status(_("no changes found (ignored %d secret changesets)\n") | ||||
% len(secretlist)) | ||||
else: | ||||
ui.status(_("no changes found\n")) | ||||
|
r30520 | def callcatch(ui, func): | ||
"""call func() with global exception handling | ||||
return func() if no exception happens. otherwise do some error handling | ||||
and return an exit code accordingly. does not handle all exceptions. | ||||
""" | ||||
try: | ||||
|
r32041 | try: | ||
return func() | ||||
except: # re-raises | ||||
ui.traceback() | ||||
raise | ||||
|
r30520 | # Global exception handling, alphabetically | ||
# Mercurial-specific first, followed by built-in and library exceptions | ||||
except error.LockHeld as inst: | ||||
if inst.errno == errno.ETIMEDOUT: | ||||
|
r40203 | reason = _('timed out waiting for lock held by %r') % ( | ||
pycompat.bytestr(inst.locker)) | ||||
|
r30520 | else: | ||
|
r32089 | reason = _('lock held by %r') % inst.locker | ||
|
r38791 | ui.error(_("abort: %s: %s\n") % ( | ||
inst.desc or stringutil.forcebytestr(inst.filename), reason)) | ||||
|
r32089 | if not inst.locker: | ||
|
r38791 | ui.error(_("(lock might be very busy)\n")) | ||
|
r30520 | except error.LockUnavailable as inst: | ||
|
r38791 | ui.error(_("abort: could not lock %s: %s\n") % | ||
(inst.desc or stringutil.forcebytestr(inst.filename), | ||||
encoding.strtolocal(inst.strerror))) | ||||
|
r30520 | except error.OutOfBandError as inst: | ||
if inst.args: | ||||
msg = _("abort: remote error:\n") | ||||
else: | ||||
msg = _("abort: remote error\n") | ||||
|
r38791 | ui.error(msg) | ||
|
r30520 | if inst.args: | ||
|
r38791 | ui.error(''.join(inst.args)) | ||
|
r30520 | if inst.hint: | ||
|
r38791 | ui.error('(%s)\n' % inst.hint) | ||
|
r30520 | except error.RepoError as inst: | ||
|
r38791 | ui.error(_("abort: %s!\n") % inst) | ||
|
r30520 | if inst.hint: | ||
|
r38791 | ui.error(_("(%s)\n") % inst.hint) | ||
|
r30520 | except error.ResponseError as inst: | ||
|
r38791 | ui.error(_("abort: %s") % inst.args[0]) | ||
|
r36679 | msg = inst.args[1] | ||
if isinstance(msg, type(u'')): | ||||
msg = pycompat.sysbytes(msg) | ||||
|
r36713 | if not isinstance(msg, bytes): | ||
|
r38791 | ui.error(" %r\n" % (msg,)) | ||
|
r36713 | elif not msg: | ||
|
r38791 | ui.error(_(" empty string\n")) | ||
|
r30520 | else: | ||
|
r38791 | ui.error("\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg))) | ||
|
r30520 | except error.CensoredNodeError as inst: | ||
|
r38791 | ui.error(_("abort: file censored %s!\n") % inst) | ||
|
r39813 | except error.StorageError as inst: | ||
|
r38791 | ui.error(_("abort: %s!\n") % inst) | ||
|
r40694 | if inst.hint: | ||
ui.error(_("(%s)\n") % inst.hint) | ||||
|
r30520 | except error.InterventionRequired as inst: | ||
|
r38791 | ui.error("%s\n" % inst) | ||
|
r30520 | if inst.hint: | ||
|
r38791 | ui.error(_("(%s)\n") % inst.hint) | ||
|
r30520 | return 1 | ||
|
r32657 | except error.WdirUnsupported: | ||
|
r38791 | ui.error(_("abort: working directory revision cannot be specified\n")) | ||
|
r30520 | except error.Abort as inst: | ||
|
r38791 | ui.error(_("abort: %s\n") % inst) | ||
|
r30520 | if inst.hint: | ||
|
r38791 | ui.error(_("(%s)\n") % inst.hint) | ||
|
r30520 | except ImportError as inst: | ||
|
r38791 | ui.error(_("abort: %s!\n") % stringutil.forcebytestr(inst)) | ||
|
r37102 | m = stringutil.forcebytestr(inst).split()[-1] | ||
|
r30520 | if m in "mpatch bdiff".split(): | ||
|
r38791 | ui.error(_("(did you forget to compile extensions?)\n")) | ||
|
r30520 | elif m in "zlib".split(): | ||
|
r38791 | ui.error(_("(is your Python install correct?)\n")) | ||
|
r41466 | except (IOError, OSError) as inst: | ||
|
r41464 | if util.safehasattr(inst, "code"): # HTTPError | ||
|
r38791 | ui.error(_("abort: %s\n") % stringutil.forcebytestr(inst)) | ||
|
r41464 | elif util.safehasattr(inst, "reason"): # URLError or SSLError | ||
|
r30520 | try: # usually it is in the form (errno, strerror) | ||
reason = inst.reason.args[1] | ||||
except (AttributeError, IndexError): | ||||
# it might be anything, for example a string | ||||
reason = inst.reason | ||||
|
r38332 | if isinstance(reason, pycompat.unicode): | ||
|
r30520 | # SSLError of Python 2.7.9 contains a unicode | ||
|
r32152 | reason = encoding.unitolocal(reason) | ||
|
r38791 | ui.error(_("abort: error: %s\n") % reason) | ||
|
r30520 | elif (util.safehasattr(inst, "args") | ||
and inst.args and inst.args[0] == errno.EPIPE): | ||||
pass | ||||
|
r41466 | elif getattr(inst, "strerror", None): # common IOError or OSError | ||
|
r41465 | if getattr(inst, "filename", None) is not None: | ||
ui.error(_("abort: %s: '%s'\n") % ( | ||||
|
r36659 | encoding.strtolocal(inst.strerror), | ||
|
r37102 | stringutil.forcebytestr(inst.filename))) | ||
|
r30520 | else: | ||
|
r38791 | ui.error(_("abort: %s\n") % encoding.strtolocal(inst.strerror)) | ||
|
r41464 | else: # suspicious IOError | ||
|
r30520 | raise | ||
except MemoryError: | ||||
|
r38791 | ui.error(_("abort: out of memory\n")) | ||
|
r30520 | except SystemExit as inst: | ||
# Commands shouldn't sys.exit directly, but give a return code. | ||||
# Just in case catch this and and pass exit code to caller. | ||||
return inst.code | ||||
return -1 | ||||
|
r17821 | def checknewlabel(repo, lbl, kind): | ||
|
r19070 | # Do not use the "kind" parameter in ui output. | ||
# It makes strings difficult to translate. | ||||
|
r17817 | if lbl in ['tip', '.', 'null']: | ||
|
r26587 | raise error.Abort(_("the name '%s' is reserved") % lbl) | ||
|
r17821 | for c in (':', '\0', '\n', '\r'): | ||
if c in lbl: | ||||
|
r36587 | raise error.Abort( | ||
_("%r cannot be used in a name") % pycompat.bytestr(c)) | ||||
|
r18566 | try: | ||
int(lbl) | ||||
|
r26587 | raise error.Abort(_("cannot use an integer as a name")) | ||
|
r18566 | except ValueError: | ||
pass | ||||
|
r36162 | if lbl.strip() != lbl: | ||
raise error.Abort(_("leading or trailing whitespace in name %r") % lbl) | ||||
|
r17817 | |||
|
r13974 | def checkfilename(f): | ||
'''Check that the filename f is an acceptable filename for a tracked file''' | ||||
if '\r' in f or '\n' in f: | ||||
|
r38353 | raise error.Abort(_("'\\n' and '\\r' disallowed in filenames: %r") | ||
% pycompat.bytestr(f)) | ||||
|
r13974 | |||
|
r13962 | def checkportable(ui, f): | ||
'''Check if filename f is portable and warn or abort depending on config''' | ||||
|
r13974 | checkfilename(f) | ||
|
r14138 | abort, warn = checkportabilityalert(ui) | ||
if abort or warn: | ||||
|
r13962 | msg = util.checkwinfilename(f) | ||
if msg: | ||||
|
r37138 | msg = "%s: %s" % (msg, procutil.shellquote(f)) | ||
|
r14138 | if abort: | ||
|
r26587 | raise error.Abort(msg) | ||
|
r14138 | ui.warn(_("warning: %s\n") % msg) | ||
|
r14068 | |||
|
r14067 | def checkportabilityalert(ui): | ||
'''check if the user's config requests nothing, a warning, or abort for | ||||
non-portable filenames''' | ||||
|
r33499 | val = ui.config('ui', 'portablefilenames') | ||
|
r14067 | lval = val.lower() | ||
|
r37102 | bval = stringutil.parsebool(val) | ||
|
r34646 | abort = pycompat.iswindows or lval == 'abort' | ||
|
r14067 | warn = bval or lval == 'warn' | ||
if bval is None and not (warn or abort or lval == 'ignore'): | ||||
|
r13962 | raise error.ConfigError( | ||
_("ui.portablefilenames value is invalid ('%s')") % val) | ||||
|
r14067 | return abort, warn | ||
|
r14138 | class casecollisionauditor(object): | ||
|
r17201 | def __init__(self, ui, abort, dirstate): | ||
|
r14138 | self._ui = ui | ||
self._abort = abort | ||||
|
r43196 | allfiles = '\0'.join(dirstate) | ||
|
r17201 | self._loweredfiles = set(encoding.lower(allfiles).split('\0')) | ||
self._dirstate = dirstate | ||||
# The purpose of _newfiles is so that we don't complain about | ||||
# case collisions if someone were to call this object with the | ||||
# same filename twice. | ||||
self._newfiles = set() | ||||
|
r14067 | |||
|
r14138 | def __call__(self, f): | ||
|
r20006 | if f in self._newfiles: | ||
return | ||||
|
r14980 | fl = encoding.lower(f) | ||
|
r20006 | if fl in self._loweredfiles and f not in self._dirstate: | ||
|
r14138 | msg = _('possible case-folding collision for %s') % f | ||
if self._abort: | ||||
|
r26587 | raise error.Abort(msg) | ||
|
r14138 | self._ui.warn(_("warning: %s\n") % msg) | ||
|
r17201 | self._loweredfiles.add(fl) | ||
self._newfiles.add(f) | ||||
|
r13970 | |||
|
r24723 | def filteredhash(repo, maxrev): | ||
"""build hash of filtered revisions in the current repoview. | ||||
Multiple caches perform up-to-date validation by checking that the | ||||
tiprev and tipnode stored in the cache file match the current repository. | ||||
However, this is not sufficient for validating repoviews because the set | ||||
of revisions in the view may change without the repository tiprev and | ||||
tipnode changing. | ||||
This function hashes all the revs filtered from the view and returns | ||||
that SHA-1 digest. | ||||
""" | ||||
cl = repo.changelog | ||||
if not cl.filteredrevs: | ||||
return None | ||||
key = None | ||||
revs = sorted(r for r in cl.filteredrevs if r <= maxrev) | ||||
if revs: | ||||
|
r29341 | s = hashlib.sha1() | ||
|
r24723 | for rev in revs: | ||
|
r31349 | s.update('%d;' % rev) | ||
|
r24723 | key = s.digest() | ||
return key | ||||
|
r13975 | def walkrepos(path, followsym=False, seen_dirs=None, recurse=False): | ||
|
r17104 | '''yield every hg repository under path, always recursively. | ||
The recurse flag will only control recursion into repo working dirs''' | ||||
|
r13975 | def errhandler(err): | ||
if err.filename == path: | ||||
raise err | ||||
|
r14961 | samestat = getattr(os.path, 'samestat', None) | ||
if followsym and samestat is not None: | ||||
|
r14227 | def adddir(dirlst, dirname): | ||
|
r13975 | dirstat = os.stat(dirname) | ||
|
r36356 | match = any(samestat(dirstat, lstdirstat) for lstdirstat in dirlst) | ||
|
r13975 | if not match: | ||
dirlst.append(dirstat) | ||||
return not match | ||||
else: | ||||
followsym = False | ||||
if (seen_dirs is None) and followsym: | ||||
seen_dirs = [] | ||||
|
r14227 | adddir(seen_dirs, path) | ||
|
r13975 | for root, dirs, files in os.walk(path, topdown=True, onerror=errhandler): | ||
dirs.sort() | ||||
if '.hg' in dirs: | ||||
yield root # found a repository | ||||
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 | ||||
if recurse: | ||||
# avoid recursing inside the .hg directory | ||||
dirs.remove('.hg') | ||||
else: | ||||
dirs[:] = [] # don't descend further | ||||
elif followsym: | ||||
newdirs = [] | ||||
for d in dirs: | ||||
fname = os.path.join(root, d) | ||||
|
r14227 | if adddir(seen_dirs, fname): | ||
|
r13975 | if os.path.islink(fname): | ||
for hgname in walkrepos(fname, True, seen_dirs): | ||||
yield hgname | ||||
else: | ||||
newdirs.append(d) | ||||
dirs[:] = newdirs | ||||
|
r13984 | |||
|
r32656 | def binnode(ctx): | ||
"""Return binary node id for a given basectx""" | ||||
node = ctx.node() | ||||
if node is None: | ||||
return wdirid | ||||
return node | ||||
|
r32654 | def intrev(ctx): | ||
"""Return integer for a given basectx that can be used in comparison or | ||||
|
r24582 | arithmetic operation""" | ||
|
r32654 | rev = ctx.rev() | ||
|
r24582 | if rev is None: | ||
|
r25739 | return wdirrev | ||
|
r24582 | return rev | ||
|
r34328 | def formatchangeid(ctx): | ||
"""Format changectx as '{rev}:{node|formatnode}', which is the default | ||||
|
r35906 | template provided by logcmdutil.changesettemplater""" | ||
|
r34328 | repo = ctx.repo() | ||
return formatrevnode(repo.ui, intrev(ctx), binnode(ctx)) | ||||
def formatrevnode(ui, rev, node): | ||||
"""Format given revision and node depending on the current verbosity""" | ||||
if ui.debugflag: | ||||
hexfunc = hex | ||||
else: | ||||
hexfunc = short | ||||
return '%d:%s' % (rev, hexfunc(node)) | ||||
|
r37696 | def resolvehexnodeidprefix(repo, prefix): | ||
|
r38891 | if (prefix.startswith('x') and | ||
repo.ui.configbool('experimental', 'revisions.prefixhexnode')): | ||||
prefix = prefix[1:] | ||||
|
r38878 | try: | ||
# Uses unfiltered repo because it's faster when prefix is ambiguous/ | ||||
# This matches the shortesthexnodeidprefix() function below. | ||||
node = repo.unfiltered().changelog._partialmatch(prefix) | ||||
except error.AmbiguousPrefixLookupError: | ||||
revset = repo.ui.config('experimental', 'revisions.disambiguatewithin') | ||||
if revset: | ||||
# Clear config to avoid infinite recursion | ||||
configoverrides = {('experimental', | ||||
'revisions.disambiguatewithin'): None} | ||||
with repo.ui.configoverride(configoverrides): | ||||
revs = repo.anyrevs([revset], user=True) | ||||
matches = [] | ||||
for rev in revs: | ||||
node = repo.changelog.node(rev) | ||||
if hex(node).startswith(prefix): | ||||
matches.append(node) | ||||
if len(matches) == 1: | ||||
return matches[0] | ||||
raise | ||||
|
r37522 | if node is None: | ||
return | ||||
repo.changelog.rev(node) # make sure node isn't filtered | ||||
return node | ||||
|
r38890 | def mayberevnum(repo, prefix): | ||
"""Checks if the given prefix may be mistaken for a revision number""" | ||||
try: | ||||
i = int(prefix) | ||||
# if we are a pure int, then starting with zero will not be | ||||
# confused as a rev; or, obviously, if the int is larger | ||||
|
r40377 | # than the value of the tip rev. We still need to disambiguate if | ||
# prefix == '0', since that *is* a valid revnum. | ||||
if (prefix != b'0' and prefix[0:1] == b'0') or i >= len(repo): | ||||
|
r38890 | return False | ||
return True | ||||
except ValueError: | ||||
return False | ||||
|
r38889 | def shortesthexnodeidprefix(repo, node, minlength=1, cache=None): | ||
"""Find the shortest unambiguous prefix that matches hexnode. | ||||
If "cache" is not None, it must be a dictionary that can be used for | ||||
caching between calls to this method. | ||||
""" | ||||
|
r37726 | # _partialmatch() of filtered changelog could take O(len(repo)) time, | ||
# which would be unacceptably slow. so we look for hash collision in | ||||
# unfiltered space, which means some hashes may be slightly longer. | ||||
|
r37990 | |||
|
r40439 | minlength=max(minlength, 1) | ||
|
r37990 | def disambiguate(prefix): | ||
"""Disambiguate against revnums.""" | ||||
|
r38892 | if repo.ui.configbool('experimental', 'revisions.prefixhexnode'): | ||
if mayberevnum(repo, prefix): | ||||
return 'x' + prefix | ||||
else: | ||||
return prefix | ||||
|
r37990 | hexnode = hex(node) | ||
|
r38000 | for length in range(len(prefix), len(hexnode) + 1): | ||
|
r37990 | prefix = hexnode[:length] | ||
|
r38890 | if not mayberevnum(repo, prefix): | ||
|
r37990 | return prefix | ||
|
r38890 | cl = repo.unfiltered().changelog | ||
|
r38879 | revset = repo.ui.config('experimental', 'revisions.disambiguatewithin') | ||
if revset: | ||||
|
r38889 | revs = None | ||
if cache is not None: | ||||
revs = cache.get('disambiguationrevset') | ||||
if revs is None: | ||||
revs = repo.anyrevs([revset], user=True) | ||||
if cache is not None: | ||||
cache['disambiguationrevset'] = revs | ||||
|
r38879 | if cl.rev(node) in revs: | ||
hexnode = hex(node) | ||||
|
r39262 | nodetree = None | ||
if cache is not None: | ||||
nodetree = cache.get('disambiguationnodetree') | ||||
if not nodetree: | ||||
try: | ||||
nodetree = parsers.nodetree(cl.index, len(revs)) | ||||
except AttributeError: | ||||
# no native nodetree | ||||
pass | ||||
else: | ||||
for r in revs: | ||||
nodetree.insert(r) | ||||
if cache is not None: | ||||
cache['disambiguationnodetree'] = nodetree | ||||
if nodetree is not None: | ||||
length = max(nodetree.shortest(node), minlength) | ||||
prefix = hexnode[:length] | ||||
return disambiguate(prefix) | ||||
|
r38879 | for length in range(minlength, len(hexnode) + 1): | ||
matches = [] | ||||
prefix = hexnode[:length] | ||||
for rev in revs: | ||||
otherhexnode = repo[rev].hex() | ||||
if prefix == otherhexnode[:length]: | ||||
matches.append(otherhexnode) | ||||
if len(matches) == 1: | ||||
return disambiguate(prefix) | ||||
|
r37882 | try: | ||
|
r37990 | return disambiguate(cl.shortest(node, minlength)) | ||
|
r37882 | except error.LookupError: | ||
raise error.RepoLookupError() | ||||
|
r37698 | |||
|
r37368 | def isrevsymbol(repo, symbol): | ||
|
r37695 | """Checks if a symbol exists in the repo. | ||
|
r38877 | See revsymbol() for details. Raises error.AmbiguousPrefixLookupError if the | ||
symbol is an ambiguous nodeid prefix. | ||||
|
r37695 | """ | ||
|
r37368 | try: | ||
revsymbol(repo, symbol) | ||||
return True | ||||
except error.RepoLookupError: | ||||
return False | ||||
|
r37289 | def revsymbol(repo, symbol): | ||
"""Returns a context given a single revision symbol (as string). | ||||
This is similar to revsingle(), but accepts only a single revision symbol, | ||||
i.e. things like ".", "tip", "1234", "deadbeef", "my-bookmark" work, but | ||||
not "max(public())". | ||||
""" | ||||
if not isinstance(symbol, bytes): | ||||
msg = ("symbol (%s of type %s) was not a string, did you mean " | ||||
"repo[symbol]?" % (symbol, type(symbol))) | ||||
raise error.ProgrammingError(msg) | ||||
|
r37403 | try: | ||
|
r37545 | if symbol in ('.', 'tip', 'null'): | ||
return repo[symbol] | ||||
try: | ||||
r = int(symbol) | ||||
if '%d' % r != symbol: | ||||
raise ValueError | ||||
l = len(repo.changelog) | ||||
if r < 0: | ||||
r += l | ||||
if r < 0 or r >= l and r != wdirrev: | ||||
raise ValueError | ||||
return repo[r] | ||||
except error.FilteredIndexError: | ||||
raise | ||||
except (ValueError, OverflowError, IndexError): | ||||
pass | ||||
|
r37546 | if len(symbol) == 40: | ||
try: | ||||
node = bin(symbol) | ||||
rev = repo.changelog.rev(node) | ||||
return repo[rev] | ||||
except error.FilteredLookupError: | ||||
raise | ||||
except (TypeError, LookupError): | ||||
pass | ||||
|
r37547 | # look up bookmarks through the name interface | ||
try: | ||||
node = repo.names.singlenode(repo, symbol) | ||||
rev = repo.changelog.rev(node) | ||||
return repo[rev] | ||||
except KeyError: | ||||
pass | ||||
|
r37697 | node = resolvehexnodeidprefix(repo, symbol) | ||
|
r37548 | if node is not None: | ||
rev = repo.changelog.rev(node) | ||||
return repo[rev] | ||||
|
r37549 | raise error.RepoLookupError(_("unknown revision '%s'") % symbol) | ||
|
r37545 | |||
|
r37546 | except error.WdirUnsupported: | ||
return repo[None] | ||||
|
r37403 | except (error.FilteredIndexError, error.FilteredLookupError, | ||
error.FilteredRepoLookupError): | ||||
raise _filterederror(repo, symbol) | ||||
def _filterederror(repo, changeid): | ||||
"""build an exception to be raised about a filtered changeid | ||||
This is extracted in a function to help extensions (eg: evolve) to | ||||
experiment with various message variants.""" | ||||
if repo.filtername.startswith('visible'): | ||||
# Check if the changeset is obsolete | ||||
unfilteredrepo = repo.unfiltered() | ||||
ctx = revsymbol(unfilteredrepo, changeid) | ||||
# If the changeset is obsolete, enrich the message with the reason | ||||
# that made this changeset not visible | ||||
if ctx.obsolete(): | ||||
msg = obsutil._getfilteredreason(repo, changeid, ctx) | ||||
else: | ||||
msg = _("hidden revision '%s'") % changeid | ||||
hint = _('use --hidden to access hidden revisions') | ||||
return error.FilteredRepoLookupError(msg, hint=hint) | ||||
msg = _("filtered revision '%s' (not in '%s' subset)") | ||||
msg %= (changeid, repo.filtername) | ||||
return error.FilteredRepoLookupError(msg) | ||||
|
r37289 | |||
|
r34007 | def revsingle(repo, revspec, default='.', localalias=None): | ||
|
r19509 | if not revspec and revspec != 0: | ||
|
r14319 | return repo[default] | ||
|
r34007 | l = revrange(repo, [revspec], localalias=localalias) | ||
|
r22814 | if not l: | ||
|
r26587 | raise error.Abort(_('empty revision set')) | ||
|
r22815 | return repo[l.last()] | ||
|
r14319 | |||
|
r26020 | def _pairspec(revspec): | ||
|
r31024 | tree = revsetlang.parse(revspec) | ||
|
r26020 | return tree and tree[0] in ('range', 'rangepre', 'rangepost', 'rangeall') | ||
|
r14319 | def revpair(repo, revs): | ||
if not revs: | ||||
|
r37269 | return repo['.'], repo[None] | ||
|
r14319 | |||
l = revrange(repo, revs) | ||||
|
r41415 | if not l: | ||
raise error.Abort(_('empty revision range')) | ||||
|
r41414 | first = l.first() | ||
second = l.last() | ||||
|
r20862 | |||
|
r26836 | if (first == second and len(revs) >= 2 | ||
and not all(revrange(repo, [r]) for r in revs)): | ||||
raise error.Abort(_('empty revision on one side of range')) | ||||
|
r14319 | |||
|
r26020 | # if top-level is range expression, the result must always be a pair | ||
if first == second and len(revs) == 1 and not _pairspec(revs[0]): | ||||
|
r37269 | return repo[first], repo[None] | ||
|
r14319 | |||
|
r37269 | return repo[first], repo[second] | ||
|
r14319 | |||
|
r34007 | def revrange(repo, specs, localalias=None): | ||
|
r29417 | """Execute 1 to many revsets and return the union. | ||
This is the preferred mechanism for executing revsets using user-specified | ||||
config options, such as revset aliases. | ||||
The revsets specified by ``specs`` will be executed via a chained ``OR`` | ||||
expression. If ``specs`` is empty, an empty result is returned. | ||||
``specs`` can contain integers, in which case they are assumed to be | ||||
revision numbers. | ||||
It is assumed the revsets are already formatted. If you have arguments | ||||
|
r31024 | that need to be expanded in the revset, call ``revsetlang.formatspec()`` | ||
|
r29417 | and pass the result as an element of ``specs``. | ||
Specifying a single revset is allowed. | ||||
Returns a ``revset.abstractsmartset`` which is a list-like interface over | ||||
integer revisions. | ||||
""" | ||||
|
r25928 | allspecs = [] | ||
|
r29417 | for spec in specs: | ||
|
r25904 | if isinstance(spec, int): | ||
|
r41254 | spec = revsetlang.formatspec('%d', spec) | ||
|
r25928 | allspecs.append(spec) | ||
|
r34007 | return repo.anyrevs(allspecs, user=True, localalias=localalias) | ||
|
r14320 | |||
|
r26433 | def meaningfulparents(repo, ctx): | ||
"""Return list of meaningful (or all if debug) parentrevs for rev. | ||||
For merges (two non-nullrev revisions) both parents are meaningful. | ||||
Otherwise the first parent revision is considered meaningful if it | ||||
is not the preceding revision. | ||||
""" | ||||
parents = ctx.parents() | ||||
if len(parents) > 1: | ||||
return parents | ||||
if repo.ui.debugflag: | ||||
|
r39930 | return [parents[0], repo[nullrev]] | ||
|
r32654 | if parents[0].rev() >= intrev(ctx) - 1: | ||
|
r26433 | return [] | ||
return parents | ||||
|
r41716 | def getuipathfn(repo, legacyrelativevalue=False, forcerelativevalue=None): | ||
"""Return a function that produced paths for presenting to the user. | ||||
The returned function takes a repo-relative path and produces a path | ||||
that can be presented in the UI. | ||||
Depending on the value of ui.relative-paths, either a repo-relative or | ||||
cwd-relative path will be produced. | ||||
legacyrelativevalue is the value to use if ui.relative-paths=legacy | ||||
If forcerelativevalue is not None, then that value will be used regardless | ||||
of what ui.relative-paths is set to. | ||||
""" | ||||
if forcerelativevalue is not None: | ||||
relative = forcerelativevalue | ||||
else: | ||||
config = repo.ui.config('ui', 'relative-paths') | ||||
if config == 'legacy': | ||||
relative = legacyrelativevalue | ||||
else: | ||||
relative = stringutil.parsebool(config) | ||||
if relative is None: | ||||
raise error.ConfigError( | ||||
_("ui.relative-paths is not a boolean ('%s')") % config) | ||||
|
r41632 | if relative: | ||
cwd = repo.getcwd() | ||||
pathto = repo.pathto | ||||
return lambda f: pathto(f, cwd) | ||||
|
r41833 | elif repo.ui.configbool('ui', 'slash'): | ||
return lambda f: f | ||||
|
r41632 | else: | ||
|
r41833 | return util.localpath | ||
|
r41632 | |||
|
r41799 | def subdiruipathfn(subpath, uipathfn): | ||
'''Create a new uipathfn that treats the file as relative to subpath.''' | ||||
return lambda f: uipathfn(posixpath.join(subpath, f)) | ||||
|
r41801 | def anypats(pats, opts): | ||
'''Checks if any patterns, including --include and --exclude were given. | ||||
Some commands (e.g. addremove) use this condition for deciding whether to | ||||
print absolute or relative paths. | ||||
''' | ||||
return bool(pats or opts.get('include') or opts.get('exclude')) | ||||
|
r14320 | def expandpats(pats): | ||
|
r21111 | '''Expand bare globs when running on windows. | ||
On posix we assume it already has already been done by sh.''' | ||||
|
r14320 | if not util.expandglobs: | ||
return list(pats) | ||||
ret = [] | ||||
|
r21111 | for kindpat in pats: | ||
kind, pat = matchmod._patsplit(kindpat, None) | ||||
|
r14320 | if kind is None: | ||
try: | ||||
|
r21111 | globbed = glob.glob(pat) | ||
|
r14320 | except re.error: | ||
|
r21111 | globbed = [pat] | ||
|
r14320 | if globbed: | ||
ret.extend(globbed) | ||||
continue | ||||
|
r21111 | ret.append(kindpat) | ||
|
r14320 | return ret | ||
|
r26326 | def matchandpats(ctx, pats=(), opts=None, globbed=False, default='relpath', | ||
|
r25467 | badfn=None): | ||
|
r21111 | '''Return a matcher and the patterns that were used. | ||
|
r25467 | The matcher will warn about bad matches, unless an alternate badfn callback | ||
is provided.''' | ||||
|
r26326 | if opts is None: | ||
opts = {} | ||||
|
r14320 | if not globbed and default == 'relpath': | ||
pats = expandpats(pats or []) | ||||
|
r14670 | |||
|
r41814 | uipathfn = getuipathfn(ctx.repo(), legacyrelativevalue=True) | ||
|
r25467 | def bad(f, msg): | ||
|
r41814 | ctx.repo().ui.warn("%s: %s\n" % (uipathfn(f), msg)) | ||
|
r25466 | |||
|
r25467 | if badfn is None: | ||
badfn = bad | ||||
|
r25466 | m = ctx.match(pats, opts.get('include'), opts.get('exclude'), | ||
default, listsubrepos=opts.get('subrepos'), badfn=badfn) | ||||
|
r24447 | if m.always(): | ||
pats = [] | ||||
|
r16171 | return m, pats | ||
|
r26328 | def match(ctx, pats=(), opts=None, globbed=False, default='relpath', | ||
badfn=None): | ||||
|
r21111 | '''Return a matcher that will warn about bad matches.''' | ||
|
r25467 | return matchandpats(ctx, pats, opts, globbed, default, badfn=badfn)[0] | ||
|
r14320 | |||
def matchall(repo): | ||||
|
r21111 | '''Return a matcher that will efficiently match everything.''' | ||
|
r41825 | return matchmod.always() | ||
|
r14320 | |||
|
r25467 | def matchfiles(repo, files, badfn=None): | ||
|
r21111 | '''Return a matcher that will efficiently match exactly these files.''' | ||
|
r41825 | return matchmod.exact(files, badfn=badfn) | ||
|
r14320 | |||
|
r34855 | def parsefollowlinespattern(repo, rev, pat, msg): | ||
"""Return a file name from `pat` pattern suitable for usage in followlines | ||||
logic. | ||||
""" | ||||
if not matchmod.patkind(pat): | ||||
return pathutil.canonpath(repo.root, repo.getcwd(), pat) | ||||
else: | ||||
ctx = repo[rev] | ||||
m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=ctx) | ||||
files = [f for f in ctx if m(f)] | ||||
if len(files) != 1: | ||||
raise error.ParseError(msg) | ||||
return files[0] | ||||
|
r40783 | def getorigvfs(ui, repo): | ||
"""return a vfs suitable to save 'orig' file | ||||
return None if no special directory is configured""" | ||||
origbackuppath = ui.config('ui', 'origbackuppath') | ||||
if not origbackuppath: | ||||
return None | ||||
return vfs.vfs(repo.wvfs.join(origbackuppath)) | ||||
|
r41735 | def backuppath(ui, repo, filepath): | ||
'''customize where working copy backup files (.orig files) are created | ||||
Fetch user defined path from config file: [ui] origbackuppath = <path> | ||||
Fall back to default (filepath with .orig suffix) if not specified | ||||
filepath is repo-relative | ||||
Returns an absolute path | ||||
''' | ||||
origvfs = getorigvfs(ui, repo) | ||||
if origvfs is None: | ||||
return repo.wjoin(filepath + ".orig") | ||||
origbackupdir = origvfs.dirname(filepath) | ||||
if not origvfs.isdir(origbackupdir) or origvfs.islink(origbackupdir): | ||||
ui.note(_('creating directory: %s\n') % origvfs.join(origbackupdir)) | ||||
# Remove any files that conflict with the backup file's path | ||||
for f in reversed(list(util.finddirs(filepath))): | ||||
if origvfs.isfileorlink(f): | ||||
ui.note(_('removing conflicting file: %s\n') | ||||
% origvfs.join(f)) | ||||
origvfs.unlink(f) | ||||
break | ||||
origvfs.makedirs(origbackupdir) | ||||
if origvfs.isdir(filepath) and not origvfs.islink(filepath): | ||||
ui.note(_('removing conflicting directory: %s\n') | ||||
% origvfs.join(filepath)) | ||||
origvfs.rmtree(filepath, forcibly=True) | ||||
return origvfs.join(filepath) | ||||
|
r33331 | class _containsnode(object): | ||
"""proxy __contains__(node) to container.__contains__ which accepts revs""" | ||||
def __init__(self, repo, revcontainer): | ||||
self._torev = repo.changelog.rev | ||||
self._revcontains = revcontainer.__contains__ | ||||
def __contains__(self, node): | ||||
return self._revcontains(self._torev(node)) | ||||
|
r38442 | def cleanupnodes(repo, replacements, operation, moves=None, metadata=None, | ||
|
r38835 | fixphase=False, targetphase=None, backup=True): | ||
|
r33088 | """do common cleanups when old nodes are replaced by new nodes | ||
That includes writing obsmarkers or stripping nodes, and moving bookmarks. | ||||
(we might also want to move working directory parent in the future) | ||||
|
r34364 | By default, bookmark moves are calculated automatically from 'replacements', | ||
but 'moves' can be used to override that. Also, 'moves' may include | ||||
additional bookmark moves that should not have associated obsmarkers. | ||||
|
r34363 | replacements is {oldnode: [newnode]} or a iterable of nodes if they do not | ||
have replacements. operation is a string, like "rebase". | ||||
|
r34794 | |||
metadata is dictionary containing metadata to be stored in obsmarker if | ||||
obsolescence is enabled. | ||||
|
r33088 | """ | ||
|
r38442 | assert fixphase or targetphase is None | ||
|
r34364 | if not replacements and not moves: | ||
return | ||||
# translate mapping's other forms | ||||
|
r34363 | if not util.safehasattr(replacements, 'items'): | ||
|
r39927 | replacements = {(n,): () for n in replacements} | ||
else: | ||||
# upgrading non tuple "source" to tuple ones for BC | ||||
repls = {} | ||||
for key, value in replacements.items(): | ||||
if not isinstance(key, tuple): | ||||
key = (key,) | ||||
repls[key] = value | ||||
replacements = repls | ||||
|
r33088 | |||
|
r40890 | # Unfiltered repo is needed since nodes in replacements might be hidden. | ||
unfi = repo.unfiltered() | ||||
|
r34362 | # Calculate bookmark movements | ||
|
r34364 | if moves is None: | ||
moves = {} | ||||
|
r40890 | for oldnodes, newnodes in replacements.items(): | ||
for oldnode in oldnodes: | ||||
if oldnode in moves: | ||||
continue | ||||
if len(newnodes) > 1: | ||||
# usually a split, take the one with biggest rev number | ||||
newnode = next(unfi.set('max(%ln)', newnodes)).node() | ||||
elif len(newnodes) == 0: | ||||
# move bookmark backwards | ||||
allreplaced = [] | ||||
for rep in replacements: | ||||
allreplaced.extend(rep) | ||||
roots = list(unfi.set('max((::%n) - %ln)', oldnode, | ||||
allreplaced)) | ||||
if roots: | ||||
newnode = roots[0].node() | ||||
else: | ||||
newnode = nullid | ||||
|
r39927 | else: | ||
|
r40890 | newnode = newnodes[0] | ||
moves[oldnode] = newnode | ||||
|
r34362 | |||
|
r38442 | allnewnodes = [n for ns in replacements.values() for n in ns] | ||
toretract = {} | ||||
toadvance = {} | ||||
if fixphase: | ||||
precursors = {} | ||||
|
r39927 | for oldnodes, newnodes in replacements.items(): | ||
for oldnode in oldnodes: | ||||
for newnode in newnodes: | ||||
precursors.setdefault(newnode, []).append(oldnode) | ||||
|
r38442 | |||
allnewnodes.sort(key=lambda n: unfi[n].rev()) | ||||
newphases = {} | ||||
def phase(ctx): | ||||
return newphases.get(ctx.node(), ctx.phase()) | ||||
for newnode in allnewnodes: | ||||
ctx = unfi[newnode] | ||||
|
r38451 | parentphase = max(phase(p) for p in ctx.parents()) | ||
|
r38442 | if targetphase is None: | ||
oldphase = max(unfi[oldnode].phase() | ||||
for oldnode in precursors[newnode]) | ||||
newphase = max(oldphase, parentphase) | ||||
else: | ||||
|
r38451 | newphase = max(targetphase, parentphase) | ||
|
r38442 | newphases[newnode] = newphase | ||
if newphase > ctx.phase(): | ||||
toretract.setdefault(newphase, []).append(newnode) | ||||
elif newphase < ctx.phase(): | ||||
toadvance.setdefault(newphase, []).append(newnode) | ||||
|
r33088 | with repo.transaction('cleanup') as tr: | ||
# Move bookmarks | ||||
bmarks = repo._bookmarks | ||||
|
r33511 | bmarkchanges = [] | ||
|
r34362 | for oldnode, newnode in moves.items(): | ||
|
r33088 | oldbmarks = repo.nodebookmarks(oldnode) | ||
if not oldbmarks: | ||||
continue | ||||
|
r33331 | from . import bookmarks # avoid import cycle | ||
|
r33088 | repo.ui.debug('moving bookmarks %r from %s to %s\n' % | ||
|
r38594 | (pycompat.rapply(pycompat.maybebytestr, oldbmarks), | ||
|
r36854 | hex(oldnode), hex(newnode))) | ||
|
r33331 | # Delete divergent bookmarks being parents of related newnodes | ||
deleterevs = repo.revs('parents(roots(%ln & (::%n))) - parents(%n)', | ||||
allnewnodes, newnode, oldnode) | ||||
deletenodes = _containsnode(repo, deleterevs) | ||||
|
r33088 | for name in oldbmarks: | ||
|
r33511 | bmarkchanges.append((name, newnode)) | ||
for b in bookmarks.divergent2delete(repo, deletenodes, name): | ||||
bmarkchanges.append((b, None)) | ||||
if bmarkchanges: | ||||
bmarks.applychanges(repo, tr, bmarkchanges) | ||||
|
r33088 | |||
|
r38442 | for phase, nodes in toretract.items(): | ||
phases.retractboundary(repo, tr, phase, nodes) | ||||
for phase, nodes in toadvance.items(): | ||||
phases.advanceboundary(repo, tr, phase, nodes) | ||||
|
r41961 | mayusearchived = repo.ui.config('experimental', 'cleanup-as-archived') | ||
|
r33088 | # Obsolete or strip nodes | ||
if obsolete.isenabled(repo, obsolete.createmarkersopt): | ||||
# If a node is already obsoleted, and we want to obsolete it | ||||
# without a successor, skip that obssolete request since it's | ||||
# unnecessary. That's the "if s or not isobs(n)" check below. | ||||
# Also sort the node in topology order, that might be useful for | ||||
# some obsstore logic. | ||||
|
r40077 | # NOTE: the sorting might belong to createmarkers. | ||
|
r33330 | torev = unfi.changelog.rev | ||
|
r39927 | sortfunc = lambda ns: torev(ns[0][0]) | ||
|
r39926 | rels = [] | ||
|
r39927 | for ns, s in sorted(replacements.items(), key=sortfunc): | ||
|
r39959 | rel = (tuple(unfi[n] for n in ns), tuple(unfi[m] for m in s)) | ||
rels.append(rel) | ||||
|
r34364 | if rels: | ||
|
r34794 | obsolete.createmarkers(repo, rels, operation=operation, | ||
metadata=metadata) | ||||
|
r41961 | elif phases.supportinternal(repo) and mayusearchived: | ||
# this assume we do not have "unstable" nodes above the cleaned ones | ||||
allreplaced = set() | ||||
for ns in replacements.keys(): | ||||
allreplaced.update(ns) | ||||
if backup: | ||||
from . import repair # avoid import cycle | ||||
node = min(allreplaced, key=repo.changelog.rev) | ||||
repair.backupbundle(repo, allreplaced, allreplaced, node, | ||||
operation) | ||||
phases.retractboundary(repo, tr, phases.archived, allreplaced) | ||||
|
r33088 | else: | ||
from . import repair # avoid import cycle | ||||
|
r39927 | tostrip = list(n for ns in replacements for n in ns) | ||
|
r34364 | if tostrip: | ||
|
r38835 | repair.delayedstrip(repo.ui, repo, tostrip, operation, | ||
backup=backup) | ||||
|
r33088 | |||
|
r41801 | def addremove(repo, matcher, prefix, uipathfn, opts=None): | ||
|
r26329 | if opts is None: | ||
opts = {} | ||||
|
r23533 | m = matcher | ||
|
r37286 | dry_run = opts.get('dry_run') | ||
|
r37322 | try: | ||
similarity = float(opts.get('similarity') or 0) | ||||
except ValueError: | ||||
raise error.Abort(_('similarity must be a number')) | ||||
if similarity < 0 or similarity > 100: | ||||
raise error.Abort(_('similarity must be between 0 and 100')) | ||||
similarity /= 100.0 | ||||
|
r23533 | |||
|
r23537 | ret = 0 | ||
wctx = repo[None] | ||||
for subpath in sorted(wctx.substate): | ||||
|
r29802 | submatch = matchmod.subdirmatcher(subpath, m) | ||
if opts.get('subrepos') or m.exact(subpath) or any(submatch.files()): | ||||
|
r23537 | sub = wctx.sub(subpath) | ||
|
r41778 | subprefix = repo.wvfs.reljoin(prefix, subpath) | ||
|
r41801 | subuipathfn = subdiruipathfn(subpath, uipathfn) | ||
|
r23537 | try: | ||
|
r41801 | if sub.addremove(submatch, subprefix, subuipathfn, opts): | ||
|
r23537 | ret = 1 | ||
except error.LookupError: | ||||
repo.ui.status(_("skipping missing subrepository: %s\n") | ||||
|
r41801 | % uipathfn(subpath)) | ||
|
r23537 | |||
|
r16167 | rejected = [] | ||
|
r23534 | def badfn(f, msg): | ||
if f in m.files(): | ||||
|
r25434 | m.bad(f, msg) | ||
|
r23534 | rejected.append(f) | ||
|
r16167 | |||
|
r25434 | badmatch = matchmod.badmatch(m, badfn) | ||
added, unknown, deleted, removed, forgotten = _interestingfiles(repo, | ||||
badmatch) | ||||
|
r18863 | |||
|
r23259 | unknownset = set(unknown + forgotten) | ||
|
r18863 | toprint = unknownset.copy() | ||
toprint.update(deleted) | ||||
for abs in sorted(toprint): | ||||
if repo.ui.verbose or not m.exact(abs): | ||||
if abs in unknownset: | ||||
|
r41801 | status = _('adding %s\n') % uipathfn(abs) | ||
|
r40403 | label = 'ui.addremove.added' | ||
|
r18863 | else: | ||
|
r41801 | status = _('removing %s\n') % uipathfn(abs) | ||
|
r40403 | label = 'ui.addremove.removed' | ||
|
r39123 | repo.ui.status(status, label=label) | ||
|
r18863 | |||
|
r19152 | renames = _findrenames(repo, m, added + unknown, removed + deleted, | ||
|
r41811 | similarity, uipathfn) | ||
|
r14320 | |||
if not dry_run: | ||||
|
r23259 | _markchanges(repo, unknown + forgotten, deleted, renames) | ||
|
r14320 | |||
|
r16167 | for f in rejected: | ||
if f in m.files(): | ||||
return 1 | ||||
|
r23537 | return ret | ||
|
r16167 | |||
|
r19154 | def marktouched(repo, files, similarity=0.0): | ||
'''Assert that files have somehow been operated upon. files are relative to | ||||
the repo root.''' | ||||
|
r25467 | m = matchfiles(repo, files, badfn=lambda x, y: rejected.append(x)) | ||
|
r19154 | rejected = [] | ||
|
r23259 | added, unknown, deleted, removed, forgotten = _interestingfiles(repo, m) | ||
|
r19154 | |||
if repo.ui.verbose: | ||||
|
r23259 | unknownset = set(unknown + forgotten) | ||
|
r19154 | toprint = unknownset.copy() | ||
toprint.update(deleted) | ||||
for abs in sorted(toprint): | ||||
if abs in unknownset: | ||||
status = _('adding %s\n') % abs | ||||
else: | ||||
status = _('removing %s\n') % abs | ||||
repo.ui.status(status) | ||||
|
r41811 | # TODO: We should probably have the caller pass in uipathfn and apply it to | ||
|
r41846 | # the messages above too. legacyrelativevalue=True is consistent with how | ||
|
r41811 | # it used to work. | ||
|
r41834 | uipathfn = getuipathfn(repo, legacyrelativevalue=True) | ||
|
r19154 | renames = _findrenames(repo, m, added + unknown, removed + deleted, | ||
|
r41811 | similarity, uipathfn) | ||
|
r19154 | |||
|
r23259 | _markchanges(repo, unknown + forgotten, deleted, renames) | ||
|
r19154 | |||
for f in rejected: | ||||
if f in m.files(): | ||||
return 1 | ||||
return 0 | ||||
|
r19150 | def _interestingfiles(repo, matcher): | ||
'''Walk dirstate with matcher, looking for files that addremove would care | ||||
about. | ||||
This is different from dirstate.status because it doesn't care about | ||||
whether files are modified or clean.''' | ||||
|
r23259 | added, unknown, deleted, removed, forgotten = [], [], [], [], [] | ||
|
r33722 | audit_path = pathutil.pathauditor(repo.root, cached=True) | ||
|
r19150 | |||
ctx = repo[None] | ||||
dirstate = repo.dirstate | ||||
|
r40123 | matcher = repo.narrowmatch(matcher, includeexact=True) | ||
|
r34344 | walkresults = dirstate.walk(matcher, subrepos=sorted(ctx.substate), | ||
unknown=True, ignored=False, full=False) | ||||
|
r19150 | for abs, st in walkresults.iteritems(): | ||
dstate = dirstate[abs] | ||||
if dstate == '?' and audit_path.check(abs): | ||||
unknown.append(abs) | ||||
elif dstate != 'r' and not st: | ||||
deleted.append(abs) | ||||
|
r23259 | elif dstate == 'r' and st: | ||
forgotten.append(abs) | ||||
|
r19150 | # for finding renames | ||
|
r23259 | elif dstate == 'r' and not st: | ||
|
r19150 | removed.append(abs) | ||
elif dstate == 'a': | ||||
added.append(abs) | ||||
|
r23259 | return added, unknown, deleted, removed, forgotten | ||
|
r19150 | |||
|
r41811 | def _findrenames(repo, matcher, added, removed, similarity, uipathfn): | ||
|
r19152 | '''Find renames from removed files to added ones.''' | ||
renames = {} | ||||
if similarity > 0: | ||||
for old, new, score in similar.findrenames(repo, added, removed, | ||||
similarity): | ||||
if (repo.ui.verbose or not matcher.exact(old) | ||||
or not matcher.exact(new)): | ||||
repo.ui.status(_('recording removal of %s as rename to %s ' | ||||
'(%d%% similar)\n') % | ||||
|
r41811 | (uipathfn(old), uipathfn(new), | ||
|
r19152 | score * 100)) | ||
renames[new] = old | ||||
return renames | ||||
|
r19153 | def _markchanges(repo, unknown, deleted, renames): | ||
'''Marks the files in unknown as added, the files in deleted as removed, | ||||
and the files in renames as copied.''' | ||||
wctx = repo[None] | ||||
|
r27851 | with repo.wlock(): | ||
|
r19153 | wctx.forget(deleted) | ||
wctx.add(unknown) | ||||
for new, old in renames.iteritems(): | ||||
wctx.copy(old, new) | ||||
|
r41947 | def getrenamedfn(repo, endrev=None): | ||
|
r42284 | if copiesmod.usechangesetcentricalgo(repo): | ||
|
r42283 | def getrenamed(fn, rev): | ||
ctx = repo[rev] | ||||
p1copies = ctx.p1copies() | ||||
if fn in p1copies: | ||||
return p1copies[fn] | ||||
p2copies = ctx.p2copies() | ||||
if fn in p2copies: | ||||
return p2copies[fn] | ||||
return None | ||||
return getrenamed | ||||
|
r41947 | rcache = {} | ||
if endrev is None: | ||||
endrev = len(repo) | ||||
def getrenamed(fn, rev): | ||||
'''looks up all renames for a file (up to endrev) the first | ||||
time the file is given. It indexes on the changerev and only | ||||
parses the manifest if linkrev != changerev. | ||||
Returns rename info for fn at changerev rev.''' | ||||
if fn not in rcache: | ||||
rcache[fn] = {} | ||||
fl = repo.file(fn) | ||||
for i in fl: | ||||
lr = fl.linkrev(i) | ||||
renamed = fl.renamed(fl.node(i)) | ||||
rcache[fn][lr] = renamed and renamed[0] | ||||
if lr >= endrev: | ||||
break | ||||
if rev in rcache[fn]: | ||||
return rcache[fn][rev] | ||||
# If linkrev != rev (i.e. rev not found in rcache) fallback to | ||||
# filectx logic. | ||||
try: | ||||
return repo[rev][fn].copysource() | ||||
except error.LookupError: | ||||
return None | ||||
return getrenamed | ||||
|
r42703 | def getcopiesfn(repo, endrev=None): | ||
if copiesmod.usechangesetcentricalgo(repo): | ||||
def copiesfn(ctx): | ||||
if ctx.p2copies(): | ||||
allcopies = ctx.p1copies().copy() | ||||
# There should be no overlap | ||||
allcopies.update(ctx.p2copies()) | ||||
return sorted(allcopies.items()) | ||||
else: | ||||
return sorted(ctx.p1copies().items()) | ||||
else: | ||||
getrenamed = getrenamedfn(repo, endrev) | ||||
def copiesfn(ctx): | ||||
copies = [] | ||||
for fn in ctx.files(): | ||||
rename = getrenamed(fn, ctx.rev()) | ||||
if rename: | ||||
copies.append((fn, rename)) | ||||
return copies | ||||
return copiesfn | ||||
|
r14320 | def dirstatecopy(ui, repo, wctx, src, dst, dryrun=False, cwd=None): | ||
"""Update the dirstate to reflect the intent of copying src to dst. For | ||||
different reasons it might not end with dst being marked as copied from src. | ||||
""" | ||||
origsrc = repo.dirstate.copied(src) or src | ||||
if dst == origsrc: # copying back a copy? | ||||
if repo.dirstate[dst] not in 'mn' and not dryrun: | ||||
repo.dirstate.normallookup(dst) | ||||
else: | ||||
if repo.dirstate[origsrc] == 'a' and origsrc == src: | ||||
if not ui.quiet: | ||||
ui.warn(_("%s has not been committed yet, so no copy " | ||||
"data will be stored for %s.\n") | ||||
% (repo.pathto(origsrc, cwd), repo.pathto(dst, cwd))) | ||||
if repo.dirstate[dst] in '?r' and not dryrun: | ||||
wctx.add([dst]) | ||||
elif not dryrun: | ||||
wctx.copy(origsrc, dst) | ||||
|
r14482 | |||
|
r42103 | def movedirstate(repo, newctx, match=None): | ||
|
r42104 | """Move the dirstate to newctx and adjust it as necessary. | ||
A matcher can be provided as an optimization. It is probably a bug to pass | ||||
a matcher that doesn't match all the differences between the parent of the | ||||
working copy and newctx. | ||||
""" | ||||
|
r42103 | oldctx = repo['.'] | ||
ds = repo.dirstate | ||||
ds.setparents(newctx.node(), nullid) | ||||
copies = dict(ds.copies()) | ||||
s = newctx.status(oldctx, match=match) | ||||
for f in s.modified: | ||||
if ds[f] == 'r': | ||||
# modified + removed -> removed | ||||
continue | ||||
ds.normallookup(f) | ||||
for f in s.added: | ||||
if ds[f] == 'r': | ||||
# added + removed -> unknown | ||||
ds.drop(f) | ||||
elif ds[f] != 'a': | ||||
ds.add(f) | ||||
for f in s.removed: | ||||
if ds[f] == 'a': | ||||
# removed + added -> normal | ||||
ds.normallookup(f) | ||||
elif ds[f] != 'r': | ||||
ds.remove(f) | ||||
# Merge old parent and old working dir copies | ||||
oldcopies = copiesmod.pathcopies(newctx, oldctx, match) | ||||
oldcopies.update(copies) | ||||
copies = dict((dst, oldcopies.get(src, src)) | ||||
for dst, src in oldcopies.iteritems()) | ||||
# Adjust the dirstate copies | ||||
for dst, src in copies.iteritems(): | ||||
if (src not in newctx or dst in newctx or ds[dst] != 'a'): | ||||
src = None | ||||
ds.copy(src, dst) | ||||
|
r24934 | def writerequires(opener, requirements): | ||
|
r40669 | with opener('requires', 'w', atomictemp=True) as fp: | ||
|
r27706 | for r in sorted(requirements): | ||
fp.write("%s\n" % r) | ||||
|
r24934 | |||
|
r20043 | class filecachesubentry(object): | ||
|
r20042 | def __init__(self, path, stat): | ||
|
r14928 | self.path = path | ||
|
r18315 | self.cachestat = None | ||
self._cacheable = None | ||||
|
r14928 | |||
|
r18315 | if stat: | ||
|
r20043 | self.cachestat = filecachesubentry.stat(self.path) | ||
|
r18315 | |||
if self.cachestat: | ||||
self._cacheable = self.cachestat.cacheable() | ||||
else: | ||||
# None means we don't know yet | ||||
self._cacheable = None | ||||
|
r14928 | |||
def refresh(self): | ||||
if self.cacheable(): | ||||
|
r20043 | self.cachestat = filecachesubentry.stat(self.path) | ||
|
r14928 | |||
def cacheable(self): | ||||
if self._cacheable is not None: | ||||
return self._cacheable | ||||
# we don't know yet, assume it is for now | ||||
return True | ||||
def changed(self): | ||||
# no point in going further if we can't cache it | ||||
if not self.cacheable(): | ||||
return True | ||||
|
r20043 | newstat = filecachesubentry.stat(self.path) | ||
|
r14928 | |||
# we may not know if it's cacheable yet, check again now | ||||
if newstat and self._cacheable is None: | ||||
self._cacheable = newstat.cacheable() | ||||
# check again | ||||
if not self._cacheable: | ||||
return True | ||||
if self.cachestat != newstat: | ||||
self.cachestat = newstat | ||||
return True | ||||
else: | ||||
return False | ||||
@staticmethod | ||||
def stat(path): | ||||
try: | ||||
return util.cachestat(path) | ||||
|
r25660 | except OSError as e: | ||
|
r14928 | if e.errno != errno.ENOENT: | ||
raise | ||||
|
r20044 | class filecacheentry(object): | ||
def __init__(self, paths, stat=True): | ||||
self._entries = [] | ||||
for path in paths: | ||||
self._entries.append(filecachesubentry(path, stat)) | ||||
def changed(self): | ||||
'''true if any entry has changed''' | ||||
for entry in self._entries: | ||||
if entry.changed(): | ||||
return True | ||||
return False | ||||
def refresh(self): | ||||
for entry in self._entries: | ||||
entry.refresh() | ||||
|
r14928 | class filecache(object): | ||
|
r38698 | """A property like decorator that tracks files under .hg/ for updates. | ||
|
r14928 | |||
|
r38698 | On first access, the files defined as arguments are stat()ed and the | ||
results cached. The decorated function is called. The results are stashed | ||||
away in a ``_filecache`` dict on the object whose method is decorated. | ||||
|
r14928 | |||
|
r40454 | On subsequent access, the cached result is used as it is set to the | ||
instance dictionary. | ||||
|
r38698 | |||
|
r40454 | On external property set/delete operations, the caller must update the | ||
corresponding _filecache entry appropriately. Use __class__.<attr>.set() | ||||
instead of directly setting <attr>. | ||||
|
r14928 | |||
|
r40454 | When using the property API, the cached data is always used if available. | ||
No stat() is performed to check if the file has changed. | ||||
|
r20045 | |||
|
r38698 | Others can muck about with the state of the ``_filecache`` dict. e.g. they | ||
can populate an entry before the property's getter is called. In this case, | ||||
entries in ``_filecache`` will be used during property operations, | ||||
if available. If the underlying file changes, it is up to external callers | ||||
to reflect this by e.g. calling ``delattr(obj, attr)`` to remove the cached | ||||
method result as well as possibly calling ``del obj._filecache[attr]`` to | ||||
remove the ``filecacheentry``. | ||||
""" | ||||
|
r20045 | def __init__(self, *paths): | ||
self.paths = paths | ||||
|
r16198 | |||
def join(self, obj, fname): | ||||
|
r20045 | """Used to compute the runtime path of a cached file. | ||
|
r16198 | |||
Users should subclass filecache and provide their own version of this | ||||
function to call the appropriate join function on 'obj' (an instance | ||||
of the class that its member function was decorated). | ||||
""" | ||||
|
r31285 | raise NotImplementedError | ||
|
r14928 | |||
def __call__(self, func): | ||||
self.func = func | ||||
|
r37886 | self.sname = func.__name__ | ||
self.name = pycompat.sysbytes(self.sname) | ||||
|
r14928 | return self | ||
def __get__(self, obj, type=None): | ||||
|
r29373 | # if accessed on the class, return the descriptor itself. | ||
if obj is None: | ||||
return self | ||||
|
r40454 | |||
assert self.sname not in obj.__dict__ | ||||
|
r16115 | |||
|
r14928 | entry = obj._filecache.get(self.name) | ||
if entry: | ||||
if entry.changed(): | ||||
entry.obj = self.func(obj) | ||||
else: | ||||
|
r20045 | paths = [self.join(obj, path) for path in self.paths] | ||
|
r14928 | |||
# We stat -before- creating the object so our cache doesn't lie if | ||||
# a writer modified between the time we read and stat | ||||
|
r20045 | entry = filecacheentry(paths, True) | ||
|
r14928 | entry.obj = self.func(obj) | ||
obj._filecache[self.name] = entry | ||||
|
r37886 | obj.__dict__[self.sname] = entry.obj | ||
|
r14928 | return entry.obj | ||
|
r16115 | |||
|
r40454 | # don't implement __set__(), which would make __dict__ lookup as slow as | ||
# function call. | ||||
def set(self, obj, value): | ||||
|
r18316 | if self.name not in obj._filecache: | ||
# we add an entry for the missing value because X in __dict__ | ||||
# implies X in _filecache | ||||
|
r20045 | paths = [self.join(obj, path) for path in self.paths] | ||
ce = filecacheentry(paths, False) | ||||
|
r18316 | obj._filecache[self.name] = ce | ||
else: | ||||
ce = obj._filecache[self.name] | ||||
ce.obj = value # update cached copy | ||||
|
r37886 | obj.__dict__[self.sname] = value # update copy returned by obj.x | ||
|
r16115 | |||
|
r34457 | def extdatasource(repo, source): | ||
"""Gather a map of rev -> value dict from the specified source | ||||
A source spec is treated as a URL, with a special case shell: type | ||||
for parsing the output from a shell command. | ||||
The data is parsed as a series of newline-separated records where | ||||
each record is a revision specifier optionally followed by a space | ||||
and a freeform string value. If the revision is known locally, it | ||||
is converted to a rev, otherwise the record is skipped. | ||||
Note that both key and value are treated as UTF-8 and converted to | ||||
the local encoding. This allows uniformity between local and | ||||
remote data sources. | ||||
""" | ||||
spec = repo.ui.config("extdata", source) | ||||
if not spec: | ||||
raise error.Abort(_("unknown extdata source '%s'") % source) | ||||
data = {} | ||||
|
r34462 | src = proc = None | ||
|
r34457 | try: | ||
|
r34462 | if spec.startswith("shell:"): | ||
# external commands should be run relative to the repo root | ||||
cmd = spec[6:] | ||||
|
r39868 | proc = subprocess.Popen(procutil.tonativestr(cmd), | ||
|
r39851 | shell=True, bufsize=-1, | ||
|
r37138 | close_fds=procutil.closefds, | ||
|
r39851 | stdout=subprocess.PIPE, | ||
cwd=procutil.tonativestr(repo.root)) | ||||
|
r34462 | src = proc.stdout | ||
else: | ||||
# treat as a URL or file | ||||
src = url.open(repo.ui, spec) | ||||
|
r34461 | for l in src: | ||
|
r34457 | if " " in l: | ||
k, v = l.strip().split(" ", 1) | ||||
else: | ||||
k, v = l.strip(), "" | ||||
k = encoding.tolocal(k) | ||||
|
r34460 | try: | ||
|
r37378 | data[revsingle(repo, k).rev()] = encoding.tolocal(v) | ||
|
r34460 | except (error.LookupError, error.RepoLookupError): | ||
pass # we ignore data for nodes that don't exist locally | ||||
|
r34457 | finally: | ||
|
r34462 | if proc: | ||
|
r42776 | try: | ||
proc.communicate() | ||||
except ValueError: | ||||
# This happens if we started iterating src and then | ||||
# get a parse error on a line. It should be safe to ignore. | ||||
pass | ||||
|
r34462 | if src: | ||
src.close() | ||||
|
r35413 | if proc and proc.returncode != 0: | ||
raise error.Abort(_("extdata command '%s' failed: %s") | ||||
|
r37481 | % (cmd, procutil.explainexit(proc.returncode))) | ||
|
r34457 | |||
return data | ||||
|
r26490 | def _locksub(repo, lock, envvar, cmd, environ=None, *args, **kwargs): | ||
if lock is None: | ||||
raise error.LockInheritanceContractViolation( | ||||
'lock can only be inherited while held') | ||||
if environ is None: | ||||
environ = {} | ||||
with lock.inherit() as locker: | ||||
environ[envvar] = locker | ||||
return repo.ui.system(cmd, environ=environ, *args, **kwargs) | ||||
|
r26491 | |||
def wlocksub(repo, cmd, *args, **kwargs): | ||||
"""run cmd as a subprocess that allows inheriting repo's wlock | ||||
This can only be called while the wlock is held. This takes all the | ||||
arguments that ui.system does, and returns the exit code of the | ||||
subprocess.""" | ||||
return _locksub(repo, repo.currentwlock(), 'HG_WLOCK_LOCKER', cmd, *args, | ||||
**kwargs) | ||||
|
r26906 | |||
|
r38364 | class progress(object): | ||
|
r41246 | def __init__(self, ui, updatebar, topic, unit="", total=None): | ||
|
r38364 | self.ui = ui | ||
self.pos = 0 | ||||
self.topic = topic | ||||
self.unit = unit | ||||
self.total = total | ||||
|
r41179 | self.debug = ui.configbool('progress', 'debug') | ||
|
r41181 | self._updatebar = updatebar | ||
|
r38364 | |||
|
r38393 | def __enter__(self): | ||
|
r38522 | return self | ||
|
r38393 | |||
def __exit__(self, exc_type, exc_value, exc_tb): | ||||
self.complete() | ||||
|
r38364 | def update(self, pos, item="", total=None): | ||
|
r38438 | assert pos is not None | ||
|
r38364 | if total: | ||
self.total = total | ||||
self.pos = pos | ||||
|
r41245 | self._updatebar(self.topic, self.pos, item, self.unit, self.total) | ||
|
r41180 | if self.debug: | ||
self._printdebug(item) | ||||
|
r38364 | |||
def increment(self, step=1, item="", total=None): | ||||
self.update(self.pos + step, item, total) | ||||
|
r38392 | def complete(self): | ||
|
r41178 | self.pos = None | ||
self.unit = "" | ||||
self.total = None | ||||
|
r41245 | self._updatebar(self.topic, self.pos, "", self.unit, self.total) | ||
|
r38392 | |||
|
r41180 | def _printdebug(self, item): | ||
|
r41178 | if self.unit: | ||
unit = ' ' + self.unit | ||||
if item: | ||||
item = ' ' + item | ||||
if self.total: | ||||
pct = 100.0 * self.pos / self.total | ||||
self.ui.debug('%s:%s %d/%d%s (%4.2f%%)\n' | ||||
% (self.topic, item, self.pos, self.total, unit, pct)) | ||||
else: | ||||
self.ui.debug('%s:%s %d%s\n' % (self.topic, item, self.pos, unit)) | ||||
|
r38364 | |||
|
r26906 | def gdinitconfig(ui): | ||
"""helper function to know if a repo should be created as general delta | ||||
|
r26907 | """ | ||
# experimental config: format.generaldelta | ||||
r33235 | return (ui.configbool('format', 'generaldelta') | |||
|
r40920 | or ui.configbool('format', 'usegeneraldelta')) | ||
|
r26906 | |||
|
r26907 | def gddeltaconfig(ui): | ||
"""helper function to know if incoming delta should be optimised | ||||
""" | ||||
|
r26906 | # experimental config: format.generaldelta | ||
r33235 | return ui.configbool('format', 'generaldelta') | |||
|
r31553 | |||
class simplekeyvaluefile(object): | ||||
"""A simple file with key=value lines | ||||
Keys must be alphanumerics and start with a letter, values must not | ||||
contain '\n' characters""" | ||||
|
r32270 | firstlinekey = '__firstline' | ||
|
r31553 | |||
def __init__(self, vfs, path, keys=None): | ||||
self.vfs = vfs | ||||
self.path = path | ||||
|
r32270 | def read(self, firstlinenonkeyval=False): | ||
"""Read the contents of a simple key-value file | ||||
'firstlinenonkeyval' indicates whether the first line of file should | ||||
be treated as a key-value pair or reuturned fully under the | ||||
__firstline key.""" | ||||
|
r31553 | lines = self.vfs.readlines(self.path) | ||
|
r32270 | d = {} | ||
if firstlinenonkeyval: | ||||
if not lines: | ||||
e = _("empty simplekeyvalue file") | ||||
raise error.CorruptedState(e) | ||||
# we don't want to include '\n' in the __firstline | ||||
d[self.firstlinekey] = lines[0][:-1] | ||||
del lines[0] | ||||
|
r31553 | try: | ||
|
r32269 | # the 'if line.strip()' part prevents us from failing on empty | ||
# lines which only contain '\n' therefore are not skipped | ||||
# by 'if line' | ||||
|
r32270 | updatedict = dict(line[:-1].split('=', 1) for line in lines | ||
if line.strip()) | ||||
if self.firstlinekey in updatedict: | ||||
e = _("%r can't be used as a key") | ||||
raise error.CorruptedState(e % self.firstlinekey) | ||||
d.update(updatedict) | ||||
|
r31553 | except ValueError as e: | ||
raise error.CorruptedState(str(e)) | ||||
return d | ||||
|
r32270 | def write(self, data, firstline=None): | ||
|
r31553 | """Write key=>value mapping to a file | ||
data is a dict. Keys must be alphanumerical and start with a letter. | ||||
|
r32270 | Values must not contain newline characters. | ||
If 'firstline' is not None, it is written to file before | ||||
everything else, as it is, not in a key=value form""" | ||||
|
r31553 | lines = [] | ||
|
r32270 | if firstline is not None: | ||
lines.append('%s\n' % firstline) | ||||
|
r31553 | for k, v in data.items(): | ||
|
r32270 | if k == self.firstlinekey: | ||
e = "key name '%s' is reserved" % self.firstlinekey | ||||
raise error.ProgrammingError(e) | ||||
|
r35931 | if not k[0:1].isalpha(): | ||
|
r31553 | e = "keys must start with a letter in a key-value file" | ||
raise error.ProgrammingError(e) | ||||
if not k.isalnum(): | ||||
e = "invalid key name in a simple key-value file" | ||||
raise error.ProgrammingError(e) | ||||
if '\n' in v: | ||||
e = "invalid value in a simple key-value file" | ||||
raise error.ProgrammingError(e) | ||||
lines.append("%s=%s\n" % (k, v)) | ||||
with self.vfs(self.path, mode='wb', atomictemp=True) as fp: | ||||
fp.write(''.join(lines)) | ||||
r33249 | ||||
|
r33541 | _reportobsoletedsource = [ | ||
|
r33542 | 'debugobsolete', | ||
|
r33541 | 'pull', | ||
'push', | ||||
'serve', | ||||
'unbundle', | ||||
] | ||||
|
r34662 | _reportnewcssource = [ | ||
'pull', | ||||
'unbundle', | ||||
] | ||||
|
r37780 | def prefetchfiles(repo, revs, match): | ||
"""Invokes the registered file prefetch functions, allowing extensions to | ||||
ensure the corresponding files are available locally, before the command | ||||
uses them.""" | ||||
if match: | ||||
# The command itself will complain about files that don't exist, so | ||||
# don't duplicate the message. | ||||
match = matchmod.badmatch(match, lambda fn, msg: None) | ||||
else: | ||||
match = matchall(repo) | ||||
fileprefetchhooks(repo, revs, match) | ||||
# a list of (repo, revs, match) prefetch functions | ||||
|
r36154 | fileprefetchhooks = util.hooks() | ||
|
r35727 | # A marker that tells the evolve extension to suppress its own reporting | ||
_reportstroubledchangesets = True | ||||
|
r33541 | def registersummarycallback(repo, otr, txnname=''): | ||
r33249 | """register a callback to issue a summary after the transaction is closed | |||
""" | ||||
|
r34620 | def txmatch(sources): | ||
return any(txnname.startswith(source) for source in sources) | ||||
|
r34621 | categories = [] | ||
def reportsummary(func): | ||||
"""decorator for report callbacks.""" | ||||
|
r35140 | # The repoview life cycle is shorter than the one of the actual | ||
# underlying repository. So the filtered object can die before the | ||||
# weakref is used leading to troubles. We keep a reference to the | ||||
# unfiltered object and restore the filtering when retrieving the | ||||
# repository through the weakref. | ||||
filtername = repo.filtername | ||||
reporef = weakref.ref(repo.unfiltered()) | ||||
|
r34621 | def wrapped(tr): | ||
|
r34620 | repo = reporef() | ||
|
r35140 | if filtername: | ||
repo = repo.filtered(filtername) | ||||
|
r34621 | func(repo, tr) | ||
|
r35766 | newcat = '%02i-txnreport' % len(categories) | ||
|
r34621 | otr.addpostclose(newcat, wrapped) | ||
categories.append(newcat) | ||||
return wrapped | ||||
r43167 | ||||
@reportsummary | ||||
def reportchangegroup(repo, tr): | ||||
cgchangesets = tr.changes.get('changegroup-count-changesets', 0) | ||||
cgrevisions = tr.changes.get('changegroup-count-revisions', 0) | ||||
cgfiles = tr.changes.get('changegroup-count-files', 0) | ||||
cgheads = tr.changes.get('changegroup-count-heads', 0) | ||||
if cgchangesets or cgrevisions or cgfiles: | ||||
htext = "" | ||||
if cgheads: | ||||
htext = _(" (%+d heads)") % cgheads | ||||
msg = _("added %d changesets with %d changes to %d files%s\n") | ||||
repo.ui.status(msg % (cgchangesets, cgrevisions, cgfiles, htext)) | ||||
|
r34621 | if txmatch(_reportobsoletedsource): | ||
@reportsummary | ||||
def reportobsoleted(repo, tr): | ||||
|
r34620 | obsoleted = obsutil.getobsoleted(repo, tr) | ||
r43164 | newmarkers = len(tr.changes.get('obsmarkers', ())) | |||
if newmarkers: | ||||
repo.ui.status(_('%i new obsolescence markers\n') % newmarkers) | ||||
|
r34620 | if obsoleted: | ||
repo.ui.status(_('obsoleted %i changesets\n') | ||||
% len(obsoleted)) | ||||
|
r34662 | |||
|
r35728 | if (obsolete.isenabled(repo, obsolete.createmarkersopt) and | ||
repo.ui.configbool('experimental', 'evolution.report-instabilities')): | ||||
|
r35727 | instabilitytypes = [ | ||
('orphan', 'orphan'), | ||||
('phase-divergent', 'phasedivergent'), | ||||
('content-divergent', 'contentdivergent'), | ||||
] | ||||
def getinstabilitycounts(repo): | ||||
filtered = repo.changelog.filteredrevs | ||||
counts = {} | ||||
for instability, revset in instabilitytypes: | ||||
counts[instability] = len(set(obsolete.getrevs(repo, revset)) - | ||||
filtered) | ||||
return counts | ||||
oldinstabilitycounts = getinstabilitycounts(repo) | ||||
@reportsummary | ||||
def reportnewinstabilities(repo, tr): | ||||
newinstabilitycounts = getinstabilitycounts(repo) | ||||
for instability, revset in instabilitytypes: | ||||
delta = (newinstabilitycounts[instability] - | ||||
oldinstabilitycounts[instability]) | ||||
|
r38474 | msg = getinstabilitymessage(delta, instability) | ||
if msg: | ||||
repo.ui.warn(msg) | ||||
|
r35727 | |||
|
r34662 | if txmatch(_reportnewcssource): | ||
@reportsummary | ||||
def reportnewcs(repo, tr): | ||||
"""Report the range of new revisions pulled/unbundled.""" | ||||
|
r39337 | origrepolen = tr.changes.get('origrepolen', len(repo)) | ||
|
r39934 | unfi = repo.unfiltered() | ||
if origrepolen >= len(unfi): | ||||
|
r34662 | return | ||
|
r39933 | # Compute the bounds of new visible revisions' range. | ||
revs = smartset.spanset(repo, start=origrepolen) | ||||
|
r39934 | if revs: | ||
minrev, maxrev = repo[revs.min()], repo[revs.max()] | ||||
|
r34662 | |||
|
r39934 | if minrev == maxrev: | ||
revrange = minrev | ||||
else: | ||||
revrange = '%s:%s' % (minrev, maxrev) | ||||
draft = len(repo.revs('%ld and draft()', revs)) | ||||
secret = len(repo.revs('%ld and secret()', revs)) | ||||
if not (draft or secret): | ||||
msg = _('new changesets %s\n') % revrange | ||||
elif draft and secret: | ||||
msg = _('new changesets %s (%d drafts, %d secrets)\n') | ||||
msg %= (revrange, draft, secret) | ||||
elif draft: | ||||
msg = _('new changesets %s (%d drafts)\n') | ||||
msg %= (revrange, draft) | ||||
elif secret: | ||||
msg = _('new changesets %s (%d secrets)\n') | ||||
msg %= (revrange, secret) | ||||
else: | ||||
errormsg = 'entered unreachable condition' | ||||
raise error.ProgrammingError(errormsg) | ||||
repo.ui.status(msg) | ||||
|
r35169 | |||
|
r39935 | # search new changesets directly pulled as obsolete | ||
|
r39936 | duplicates = tr.changes.get('revduplicates', ()) | ||
obsadded = unfi.revs('(%d: + %ld) and obsolete()', | ||||
origrepolen, duplicates) | ||||
|
r39935 | cl = repo.changelog | ||
extinctadded = [r for r in obsadded if r not in cl] | ||||
if extinctadded: | ||||
# They are not just obsolete, but obsolete and invisible | ||||
# we call them "extinct" internally but the terms have not been | ||||
# exposed to users. | ||||
msg = '(%d other changesets obsolete on arrival)\n' | ||||
repo.ui.status(msg % len(extinctadded)) | ||||
|
r38189 | @reportsummary | ||
def reportphasechanges(repo, tr): | ||||
"""Report statistics of phase changes for changesets pre-existing | ||||
pull/unbundle. | ||||
""" | ||||
|
r39337 | origrepolen = tr.changes.get('origrepolen', len(repo)) | ||
|
r38189 | phasetracking = tr.changes.get('phases', {}) | ||
if not phasetracking: | ||||
return | ||||
published = [ | ||||
rev for rev, (old, new) in phasetracking.iteritems() | ||||
|
r39337 | if new == phases.public and rev < origrepolen | ||
|
r38189 | ] | ||
if not published: | ||||
return | ||||
|
r38268 | repo.ui.status(_('%d local changesets published\n') | ||
|
r38189 | % len(published)) | ||
|
r38474 | def getinstabilitymessage(delta, instability): | ||
"""function to return the message to show warning about new instabilities | ||||
exists as a separate function so that extension can wrap to show more | ||||
information like how to fix instabilities""" | ||||
if delta > 0: | ||||
return _('%i new %s changesets\n') % (delta, instability) | ||||
|
r35185 | def nodesummaries(repo, nodes, maxnumnodes=4): | ||
if len(nodes) <= maxnumnodes or repo.ui.verbose: | ||||
return ' '.join(short(h) for h in nodes) | ||||
first = ' '.join(short(h) for h in nodes[:maxnumnodes]) | ||||
|
r35207 | return _("%s and %d others") % (first, len(nodes) - maxnumnodes) | ||
|
r35185 | |||
|
r35186 | def enforcesinglehead(repo, tr, desc): | ||
"""check that no named branch has multiple heads""" | ||||
if desc in ('strip', 'repair'): | ||||
# skip the logic during strip | ||||
return | ||||
visible = repo.filtered('visible') | ||||
# possible improvement: we could restrict the check to affected branch | ||||
for name, heads in visible.branchmap().iteritems(): | ||||
if len(heads) > 1: | ||||
msg = _('rejecting multiple heads on branch "%s"') | ||||
msg %= name | ||||
hint = _('%d heads: %s') | ||||
hint %= (len(heads), nodesummaries(repo, heads)) | ||||
raise error.Abort(msg, hint=hint) | ||||
|
r35169 | def wrapconvertsink(sink): | ||
"""Allow extensions to wrap the sink returned by convcmd.convertsink() | ||||
before it is used, whether or not the convert extension was formally loaded. | ||||
""" | ||||
return sink | ||||
|
r35512 | |||
def unhidehashlikerevs(repo, specs, hiddentype): | ||||
"""parse the user specs and unhide changesets whose hash or revision number | ||||
is passed. | ||||
hiddentype can be: 1) 'warn': warn while unhiding changesets | ||||
2) 'nowarn': don't warn while unhiding changesets | ||||
returns a repo object with the required changesets unhidden | ||||
""" | ||||
if not repo.filtername or not repo.ui.configbool('experimental', | ||||
'directaccess'): | ||||
return repo | ||||
|
r35515 | if repo.filtername not in ('visible', 'visible-hidden'): | ||
|
r35512 | return repo | ||
symbols = set() | ||||
for spec in specs: | ||||
try: | ||||
tree = revsetlang.parse(spec) | ||||
except error.ParseError: # will be reported by scmutil.revrange() | ||||
continue | ||||
symbols.update(revsetlang.gethashlikesymbols(tree)) | ||||
if not symbols: | ||||
return repo | ||||
revs = _getrevsfromsymbols(repo, symbols) | ||||
if not revs: | ||||
return repo | ||||
if hiddentype == 'warn': | ||||
unfi = repo.unfiltered() | ||||
revstr = ", ".join([pycompat.bytestr(unfi[l]) for l in revs]) | ||||
repo.ui.warn(_("warning: accessing hidden changesets for write " | ||||
"operation: %s\n") % revstr) | ||||
|
r35515 | # we have to use new filtername to separate branch/tags cache until we can | ||
# disbale these cache when revisions are dynamically pinned. | ||||
|
r35512 | return repo.filtered('visible-hidden', revs) | ||
def _getrevsfromsymbols(repo, symbols): | ||||
"""parse the list of symbols and returns a set of revision numbers of hidden | ||||
changesets present in symbols""" | ||||
revs = set() | ||||
unfi = repo.unfiltered() | ||||
unficl = unfi.changelog | ||||
cl = repo.changelog | ||||
tiprev = len(unficl) | ||||
allowrevnums = repo.ui.configbool('experimental', 'directaccess.revnums') | ||||
for s in symbols: | ||||
try: | ||||
n = int(s) | ||||
if n <= tiprev: | ||||
if not allowrevnums: | ||||
continue | ||||
else: | ||||
if n not in cl: | ||||
revs.add(n) | ||||
continue | ||||
except ValueError: | ||||
pass | ||||
try: | ||||
|
r37885 | s = resolvehexnodeidprefix(unfi, s) | ||
|
r37112 | except (error.LookupError, error.WdirUnsupported): | ||
|
r35512 | s = None | ||
if s is not None: | ||||
rev = unficl.rev(s) | ||||
if rev not in cl: | ||||
revs.add(rev) | ||||
return revs | ||||
|
r38146 | |||
def bookmarkrevs(repo, mark): | ||||
""" | ||||
Select revisions reachable by a given bookmark | ||||
""" | ||||
return repo.revs("ancestors(bookmark(%s)) - " | ||||
"ancestors(head() and not bookmark(%s)) - " | ||||
"ancestors(bookmark() and not bookmark(%s))", | ||||
mark, mark, mark) | ||||
r42936 | ||||
def computechangesetfilesadded(ctx): | ||||
"""return the list of files added in a changeset | ||||
""" | ||||
added = [] | ||||
for f in ctx.files(): | ||||
if not any(f in p for p in ctx.parents()): | ||||
added.append(f) | ||||
return added | ||||
r42937 | ||||
def computechangesetfilesremoved(ctx): | ||||
"""return the list of files removed in a changeset | ||||
""" | ||||
removed = [] | ||||
for f in ctx.files(): | ||||
if f not in ctx: | ||||
removed.append(f) | ||||
return removed | ||||