scmutil.py
1801 lines
| 63.3 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 | ||
import re | ||||
|
r30520 | import socket | ||
|
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 ( | ||
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: | ||||
|
r32089 | reason = _('timed out waiting for lock held by %r') % 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) | ||
|
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")) | ||
|
r30520 | except IOError as inst: | ||
if util.safehasattr(inst, "code"): | ||||
|
r38791 | ui.error(_("abort: %s\n") % stringutil.forcebytestr(inst)) | ||
|
r30520 | elif util.safehasattr(inst, "reason"): | ||
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 | ||||
elif getattr(inst, "strerror", None): | ||||
if getattr(inst, "filename", None): | ||||
|
r38791 | 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)) | ||
|
r30520 | else: | ||
raise | ||||
except OSError as inst: | ||||
if getattr(inst, "filename", None) is not None: | ||||
|
r38791 | 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)) | ||
|
r30520 | 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 | ||||
except socket.error as inst: | ||||
|
r38791 | ui.error(_("abort: %s\n") % stringutil.forcebytestr(inst.args[-1])) | ||
|
r30520 | |||
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 | ||||
|
r17201 | allfiles = '\0'.join(dirstate._map) | ||
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 | ||||
# than the value of the tip rev | ||||
|
r39396 | if 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 | |||
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) | ||||
|
r20862 | if not l: | ||
first = second = None | ||||
elif l.isascending(): | ||||
first = l.min() | ||||
second = l.max() | ||||
elif l.isdescending(): | ||||
first = l.max() | ||||
second = l.min() | ||||
else: | ||||
|
r22816 | first = l.first() | ||
second = l.last() | ||||
|
r20862 | |||
if first is None: | ||||
|
r26587 | raise error.Abort(_('empty revision range')) | ||
|
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): | ||
|
r31024 | spec = revsetlang.formatspec('rev(%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 | ||||
|
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.''' | ||||
|
r14320 | if pats == ("",): | ||
pats = [] | ||||
|
r26326 | if opts is None: | ||
opts = {} | ||||
|
r14320 | if not globbed and default == 'relpath': | ||
pats = expandpats(pats or []) | ||||
|
r14670 | |||
|
r25467 | def bad(f, msg): | ||
|
r24338 | ctx.repo().ui.warn("%s: %s\n" % (m.rel(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.''' | ||
|
r14320 | return matchmod.always(repo.root, repo.getcwd()) | ||
|
r25467 | def matchfiles(repo, files, badfn=None): | ||
|
r21111 | '''Return a matcher that will efficiently match exactly these files.''' | ||
|
r25467 | return matchmod.exact(repo.root, repo.getcwd(), 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] | ||||
|
r27651 | def origpath(ui, repo, filepath): | ||
'''customize where .orig files are created | ||||
Fetch user defined path from config file: [ui] origbackuppath = <path> | ||||
|
r34145 | Fall back to default (filepath with .orig suffix) if not specified | ||
|
r27651 | ''' | ||
|
r33499 | origbackuppath = ui.config('ui', 'origbackuppath') | ||
|
r34544 | if not origbackuppath: | ||
|
r27651 | return filepath + ".orig" | ||
|
r34544 | # Convert filepath from an absolute path into a path inside the repo. | ||
filepathfromroot = util.normpath(os.path.relpath(filepath, | ||||
start=repo.root)) | ||||
origvfs = vfs.vfs(repo.wjoin(origbackuppath)) | ||||
origbackupdir = origvfs.dirname(filepathfromroot) | ||||
if not origvfs.isdir(origbackupdir) or origvfs.islink(origbackupdir): | ||||
ui.note(_('creating directory: %s\n') % origvfs.join(origbackupdir)) | ||||
|
r27651 | |||
|
r34544 | # Remove any files that conflict with the backup file's path | ||
for f in reversed(list(util.finddirs(filepathfromroot))): | ||||
if origvfs.isfileorlink(f): | ||||
ui.note(_('removing conflicting file: %s\n') | ||||
% origvfs.join(f)) | ||||
origvfs.unlink(f) | ||||
break | ||||
|
r27651 | |||
|
r34544 | origvfs.makedirs(origbackupdir) | ||
|
r35008 | if origvfs.isdir(filepathfromroot) and not origvfs.islink(filepathfromroot): | ||
|
r34544 | ui.note(_('removing conflicting directory: %s\n') | ||
% origvfs.join(filepathfromroot)) | ||||
origvfs.rmtree(filepathfromroot, forcibly=True) | ||||
return origvfs.join(filepathfromroot) | ||||
|
r27651 | |||
|
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 | |||
|
r34362 | # Calculate bookmark movements | ||
|
r34364 | if moves is None: | ||
moves = {} | ||||
|
r34363 | # Unfiltered repo is needed since nodes in replacements might be hidden. | ||
|
r34362 | unfi = repo.unfiltered() | ||
|
r39927 | 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 | ||||
|
r34362 | else: | ||
|
r39927 | 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) | ||||
|
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. | ||||
# NOTE: the filtering and 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) | ||||
|
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 | |||
|
r37286 | def addremove(repo, matcher, prefix, 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 | ||
join = lambda f: os.path.join(prefix, f) | ||||
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) | ||
try: | ||||
|
r37286 | if sub.addremove(submatch, prefix, opts): | ||
|
r23537 | ret = 1 | ||
except error.LookupError: | ||||
repo.ui.status(_("skipping missing subrepository: %s\n") | ||||
% join(subpath)) | ||||
|
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: | ||||
|
r23686 | status = _('adding %s\n') % m.uipath(abs) | ||
|
r39123 | label = 'addremove.added' | ||
|
r18863 | else: | ||
|
r23686 | status = _('removing %s\n') % m.uipath(abs) | ||
|
r39123 | label = 'addremove.removed' | ||
repo.ui.status(status, label=label) | ||||
|
r18863 | |||
|
r19152 | renames = _findrenames(repo, m, added + unknown, removed + deleted, | ||
similarity) | ||||
|
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) | ||||
renames = _findrenames(repo, m, added + unknown, removed + deleted, | ||||
similarity) | ||||
|
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 | ||||
|
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 | |||
|
r19152 | def _findrenames(repo, matcher, added, removed, similarity): | ||
'''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') % | ||||
(matcher.rel(old), matcher.rel(new), | ||||
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) | ||||
|
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 | |||
|
r24934 | def writerequires(opener, requirements): | ||
|
r27706 | with opener('requires', 'w') as fp: | ||
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 | |||
|
r38698 | On subsequent access, the cached result is returned. | ||
On external property set operations, stat() calls are performed and the new | ||||
value is cached. | ||||
On property delete operations, cached data is removed. | ||||
|
r14928 | |||
|
r38698 | When using the property API, cached data is always returned, if available: | ||
no stat() is performed to check if the file has changed and if the function | ||||
needs to be called to reflect file changes. | ||||
|
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 | ||||
|
r16115 | # do we need to check if the file changed? | ||
|
r37886 | if self.sname in obj.__dict__: | ||
|
r18316 | assert self.name in obj._filecache, self.name | ||
|
r37886 | return obj.__dict__[self.sname] | ||
|
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 | |||
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 | |||
def __delete__(self, obj): | ||||
try: | ||||
|
r37886 | del obj.__dict__[self.sname] | ||
|
r16115 | except KeyError: | ||
|
r37886 | raise AttributeError(self.sname) | ||
|
r26490 | |||
|
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: | ||
proc.communicate() | ||||
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): | ||
def __init__(self, ui, topic, unit="", total=None): | ||||
self.ui = ui | ||||
self.pos = 0 | ||||
self.topic = topic | ||||
self.unit = unit | ||||
self.total = total | ||||
|
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 | ||||
self._print(item) | ||||
def increment(self, step=1, item="", total=None): | ||||
self.update(self.pos + step, item, total) | ||||
|
r38392 | def complete(self): | ||
|
r38438 | self.ui.progress(self.topic, None) | ||
|
r38392 | |||
|
r38364 | def _print(self, item): | ||
self.ui.progress(self.topic, self.pos, item, self.unit, | ||||
self.total) | ||||
|
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') | |||
|
r38782 | or ui.configbool('format', 'usegeneraldelta') | ||
or ui.configbool('format', 'sparse-revlog')) | ||||
|
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 | ||||
if txmatch(_reportobsoletedsource): | ||||
@reportsummary | ||||
def reportobsoleted(repo, tr): | ||||
|
r34620 | obsoleted = obsutil.getobsoleted(repo, tr) | ||
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) | ||||