scmutil.py
967 lines
| 32.4 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 | ||
|
r27482 | |||
from .i18n import _ | ||||
from .node import wdirrev | ||||
from . import ( | ||||
encoding, | ||||
error, | ||||
match as matchmod, | ||||
osutil, | ||||
pathutil, | ||||
phases, | ||||
|
r30305 | pycompat, | ||
|
r31024 | revsetlang, | ||
|
r27482 | similar, | ||
util, | ||||
|
r31217 | vfs as vfsmod, | ||
|
r27482 | ) | ||
|
r18690 | |||
|
r30639 | if pycompat.osname == 'nt': | ||
|
r27482 | from . import scmwindows as scmplatform | ||
|
r18690 | else: | ||
|
r27482 | from . import scmposix as scmplatform | ||
|
r18690 | |||
systemrcpath = scmplatform.systemrcpath | ||||
userrcpath = scmplatform.userrcpath | ||||
|
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): | ||||
return (('<status modified=%r, added=%r, removed=%r, deleted=%r, ' | ||||
'unknown=%r, ignored=%r, clean=%r>') % self) | ||||
|
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: | ||||
|
r18617 | if n not in repo: | ||
# discovery should not have included the filtered revision, | ||||
# we have to explicitly exclude it until discovery is cleanup. | ||||
continue | ||||
|
r17248 | 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: | ||||
return func() | ||||
# Global exception handling, alphabetically | ||||
# Mercurial-specific first, followed by built-in and library exceptions | ||||
except error.LockHeld as inst: | ||||
if inst.errno == errno.ETIMEDOUT: | ||||
reason = _('timed out waiting for lock held by %s') % inst.locker | ||||
else: | ||||
reason = _('lock held by %s') % inst.locker | ||||
ui.warn(_("abort: %s: %s\n") % (inst.desc or inst.filename, reason)) | ||||
except error.LockUnavailable as inst: | ||||
ui.warn(_("abort: could not lock %s: %s\n") % | ||||
(inst.desc or inst.filename, inst.strerror)) | ||||
except error.OutOfBandError as inst: | ||||
if inst.args: | ||||
msg = _("abort: remote error:\n") | ||||
else: | ||||
msg = _("abort: remote error\n") | ||||
ui.warn(msg) | ||||
if inst.args: | ||||
ui.warn(''.join(inst.args)) | ||||
if inst.hint: | ||||
ui.warn('(%s)\n' % inst.hint) | ||||
except error.RepoError as inst: | ||||
ui.warn(_("abort: %s!\n") % inst) | ||||
if inst.hint: | ||||
ui.warn(_("(%s)\n") % inst.hint) | ||||
except error.ResponseError as inst: | ||||
ui.warn(_("abort: %s") % inst.args[0]) | ||||
if not isinstance(inst.args[1], basestring): | ||||
ui.warn(" %r\n" % (inst.args[1],)) | ||||
elif not inst.args[1]: | ||||
ui.warn(_(" empty string\n")) | ||||
else: | ||||
ui.warn("\n%r\n" % util.ellipsis(inst.args[1])) | ||||
except error.CensoredNodeError as inst: | ||||
ui.warn(_("abort: file censored %s!\n") % inst) | ||||
except error.RevlogError as inst: | ||||
ui.warn(_("abort: %s!\n") % inst) | ||||
except error.SignalInterrupt: | ||||
ui.warn(_("killed!\n")) | ||||
except error.InterventionRequired as inst: | ||||
ui.warn("%s\n" % inst) | ||||
if inst.hint: | ||||
ui.warn(_("(%s)\n") % inst.hint) | ||||
return 1 | ||||
except error.Abort as inst: | ||||
ui.warn(_("abort: %s\n") % inst) | ||||
if inst.hint: | ||||
ui.warn(_("(%s)\n") % inst.hint) | ||||
except ImportError as inst: | ||||
ui.warn(_("abort: %s!\n") % inst) | ||||
m = str(inst).split()[-1] | ||||
if m in "mpatch bdiff".split(): | ||||
ui.warn(_("(did you forget to compile extensions?)\n")) | ||||
elif m in "zlib".split(): | ||||
ui.warn(_("(is your Python install correct?)\n")) | ||||
except IOError as inst: | ||||
if util.safehasattr(inst, "code"): | ||||
ui.warn(_("abort: %s\n") % inst) | ||||
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 | ||||
if isinstance(reason, unicode): | ||||
# SSLError of Python 2.7.9 contains a unicode | ||||
reason = reason.encode(encoding.encoding, 'replace') | ||||
ui.warn(_("abort: error: %s\n") % reason) | ||||
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): | ||||
ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename)) | ||||
else: | ||||
ui.warn(_("abort: %s\n") % inst.strerror) | ||||
else: | ||||
raise | ||||
except OSError as inst: | ||||
if getattr(inst, "filename", None) is not None: | ||||
ui.warn(_("abort: %s: '%s'\n") % (inst.strerror, inst.filename)) | ||||
else: | ||||
ui.warn(_("abort: %s\n") % inst.strerror) | ||||
except MemoryError: | ||||
ui.warn(_("abort: out of memory\n")) | ||||
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: | ||||
ui.warn(_("abort: %s\n") % inst.args[-1]) | ||||
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: | ||||
|
r26587 | raise error.Abort(_("%r cannot be used in a name") % c) | ||
|
r18566 | try: | ||
int(lbl) | ||||
|
r26587 | raise error.Abort(_("cannot use an integer as a name")) | ||
|
r18566 | except ValueError: | ||
pass | ||||
|
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: | ||||
|
r26587 | raise error.Abort(_("'\\n' and '\\r' disallowed in filenames: %r") % 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: | ||||
|
r14138 | msg = "%s: %r" % (msg, f) | ||
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''' | ||||
val = ui.config('ui', 'portablefilenames', 'warn') | ||||
lval = val.lower() | ||||
bval = util.parsebool(val) | ||||
|
r30639 | abort = pycompat.osname == 'nt' 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: | ||
s.update('%s;' % rev) | ||||
key = s.digest() | ||||
return key | ||||
|
r31217 | # compatibility layer since all 'vfs' code moved to 'mercurial.vfs' | ||
# | ||||
# This is hard to instal deprecation warning to this since we do not have | ||||
# access to a 'ui' object. | ||||
opener = vfs = vfsmod.vfs | ||||
filteropener = filtervfs = vfsmod.filtervfs | ||||
abstractvfs = vfsmod.abstractvfs | ||||
readonlyvfs = vfsmod.readonlyvfs | ||||
auditvfs = vfsmod.auditvfs | ||||
checkambigatclosing = vfsmod.checkambigatclosing | ||||
|
r18213 | |||
|
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 | match = False | ||
dirstat = os.stat(dirname) | ||||
for lstdirstat in dirlst: | ||||
if samestat(dirstat, lstdirstat): | ||||
match = True | ||||
break | ||||
if not match: | ||||
dirlst.append(dirstat) | ||||
return not match | ||||
else: | ||||
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 | |||
|
r14224 | def osrcpath(): | ||
|
r13985 | '''return default os-specific hgrc search path''' | ||
|
r23142 | path = [] | ||
defaultpath = os.path.join(util.datapath, 'default.d') | ||||
if os.path.isdir(defaultpath): | ||||
for f, kind in osutil.listdir(defaultpath): | ||||
if f.endswith('.rc'): | ||||
path.append(os.path.join(defaultpath, f)) | ||||
path.extend(systemrcpath()) | ||||
|
r14226 | path.extend(userrcpath()) | ||
|
r13985 | path = [os.path.normpath(f) for f in path] | ||
return path | ||||
|
r13984 | _rcpath = None | ||
def rcpath(): | ||||
'''return hgrc search path. if env var HGRCPATH is set, use it. | ||||
for each item in path, if directory, use files ending in .rc, | ||||
else use item. | ||||
make HGRCPATH empty to only look in .hg/hgrc of current repo. | ||||
if no HGRCPATH, use default os-specific path.''' | ||||
global _rcpath | ||||
if _rcpath is None: | ||||
|
r30109 | if 'HGRCPATH' in encoding.environ: | ||
|
r13984 | _rcpath = [] | ||
|
r30305 | for p in encoding.environ['HGRCPATH'].split(pycompat.ospathsep): | ||
|
r13984 | if not p: | ||
continue | ||||
p = util.expandpath(p) | ||||
if os.path.isdir(p): | ||||
for f, kind in osutil.listdir(p): | ||||
if f.endswith('.rc'): | ||||
_rcpath.append(os.path.join(p, f)) | ||||
else: | ||||
_rcpath.append(p) | ||||
else: | ||||
|
r14224 | _rcpath = osrcpath() | ||
|
r13984 | return _rcpath | ||
|
r13986 | |||
|
r25739 | def intrev(rev): | ||
|
r24582 | """Return integer for a given revision that can be used in comparison or | ||
arithmetic operation""" | ||||
if rev is None: | ||||
|
r25739 | return wdirrev | ||
|
r24582 | return rev | ||
|
r14319 | def revsingle(repo, revspec, default='.'): | ||
|
r19509 | if not revspec and revspec != 0: | ||
|
r14319 | return repo[default] | ||
l = revrange(repo, [revspec]) | ||||
|
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: | ||||
return repo.dirstate.p1(), None | ||||
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]): | ||||
|
r20862 | return repo.lookup(first), None | ||
|
r14319 | |||
|
r20862 | return repo.lookup(first), repo.lookup(second) | ||
|
r14319 | |||
|
r29417 | def revrange(repo, specs): | ||
"""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) | ||
|
r31025 | return repo.anyrevs(allspecs, user=True) | ||
|
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: | ||||
return [parents[0], repo['null']] | ||||
if parents[0].rev() >= intrev(ctx.rev()) - 1: | ||||
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 | |||
|
r27651 | def origpath(ui, repo, filepath): | ||
'''customize where .orig files are created | ||||
Fetch user defined path from config file: [ui] origbackuppath = <path> | ||||
Fall back to default (filepath) if not specified | ||||
''' | ||||
origbackuppath = ui.config('ui', 'origbackuppath', None) | ||||
if origbackuppath is None: | ||||
return filepath + ".orig" | ||||
filepathfromroot = os.path.relpath(filepath, start=repo.root) | ||||
fullorigpath = repo.wjoin(origbackuppath, filepathfromroot) | ||||
origbackupdir = repo.vfs.dirname(fullorigpath) | ||||
if not repo.vfs.exists(origbackupdir): | ||||
ui.note(_('creating directory: %s\n') % origbackupdir) | ||||
util.makedirs(origbackupdir) | ||||
return fullorigpath + ".orig" | ||||
|
r26329 | def addremove(repo, matcher, prefix, opts=None, dry_run=None, similarity=None): | ||
if opts is None: | ||||
opts = {} | ||||
|
r23533 | m = matcher | ||
|
r14320 | if dry_run is None: | ||
dry_run = opts.get('dry_run') | ||||
if similarity is None: | ||||
similarity = float(opts.get('similarity') or 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: | ||||
if sub.addremove(submatch, prefix, opts, dry_run, similarity): | ||||
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) | ||
|
r18863 | else: | ||
|
r23686 | status = _('removing %s\n') % m.uipath(abs) | ||
|
r18863 | repo.ui.status(status) | ||
|
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 = [], [], [], [], [] | ||
|
r20033 | audit_path = pathutil.pathauditor(repo.root) | ||
|
r19150 | |||
ctx = repo[None] | ||||
dirstate = repo.dirstate | ||||
|
r19655 | walkresults = dirstate.walk(matcher, sorted(ctx.substate), True, 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 | |||
def readrequires(opener, supported): | ||||
'''Reads and parses .hg/requires and checks if all entries found | ||||
are in the list of supported features.''' | ||||
requirements = set(opener.read("requires").splitlines()) | ||||
|
r14746 | missings = [] | ||
|
r14482 | for r in requirements: | ||
if r not in supported: | ||||
|
r14484 | if not r or not r[0].isalnum(): | ||
raise error.RequirementError(_(".hg/requires file is corrupt")) | ||||
|
r14746 | missings.append(r) | ||
missings.sort() | ||||
if missings: | ||||
|
r16683 | raise error.RequirementError( | ||
|
r20820 | _("repository requires features unknown to this Mercurial: %s") | ||
% " ".join(missings), | ||||
|
r26421 | hint=_("see https://mercurial-scm.org/wiki/MissingRequirement" | ||
|
r20820 | " for more information")) | ||
|
r14482 | return requirements | ||
|
r14928 | |||
|
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): | ||
|
r20045 | '''A property like decorator that tracks files under .hg/ for updates. | ||
|
r14928 | |||
Records stat info when called in _filecache. | ||||
|
r20045 | On subsequent calls, compares old stat info with new info, and recreates the | ||
object when any of the files changes, updating the new stat info in | ||||
_filecache. | ||||
|
r14928 | |||
Mercurial either atomic renames or appends for files under .hg, | ||||
so to ensure the cache is reliable we need the filesystem to be able | ||||
to tell us if a file has been replaced. If it can't, we fallback to | ||||
|
r26098 | recreating the object on every call (essentially the same behavior as | ||
|
r20045 | propertycache). | ||
''' | ||||
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). | ||||
""" | ||||
return obj.join(fname) | ||||
|
r14928 | |||
def __call__(self, func): | ||||
self.func = func | ||||
self.name = func.__name__ | ||||
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? | ||
if self.name in obj.__dict__: | ||||
|
r18316 | assert self.name in obj._filecache, self.name | ||
|
r16115 | return obj.__dict__[self.name] | ||
|
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 | ||||
|
r16115 | obj.__dict__[self.name] = 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 | ||||
|
r16115 | obj.__dict__[self.name] = value # update copy returned by obj.x | ||
def __delete__(self, obj): | ||||
try: | ||||
del obj.__dict__[self.name] | ||||
except KeyError: | ||||
|
r18177 | raise AttributeError(self.name) | ||
|
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 | |||
def gdinitconfig(ui): | ||||
"""helper function to know if a repo should be created as general delta | ||||
|
r26907 | """ | ||
# experimental config: format.generaldelta | ||||
return (ui.configbool('format', 'generaldelta', False) | ||||
|
r27093 | or ui.configbool('format', 'usegeneraldelta', True)) | ||
|
r26906 | |||
|
r26907 | def gddeltaconfig(ui): | ||
"""helper function to know if incoming delta should be optimised | ||||
""" | ||||
|
r26906 | # experimental config: format.generaldelta | ||
return ui.configbool('format', 'generaldelta', False) | ||||