scmutil.py
1067 lines
| 34.1 KiB
| text/x-python
|
PythonLexer
/ mercurial / scmutil.py
|
r13962 | # scmutil.py - Mercurial core utility functions | ||
# | ||||
# Copyright Matt Mackall <mpm@selenic.com> | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
# GNU General Public License version 2 or any later version. | ||||
from i18n import _ | ||||
|
r18466 | from mercurial.node import nullrev | ||
|
r18900 | import util, error, osutil, revset, similar, encoding, phases, parsers | ||
|
r20033 | import pathutil | ||
|
r14320 | import match as matchmod | ||
|
r20980 | import os, errno, re, glob, tempfile | ||
|
r18690 | |||
if os.name == 'nt': | ||||
import scmwindows as scmplatform | ||||
else: | ||||
import scmposix as scmplatform | ||||
systemrcpath = scmplatform.systemrcpath | ||||
userrcpath = scmplatform.userrcpath | ||||
|
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)) | ||||
for subpath, ctx in sorted(subpaths.iteritems()): | ||||
yield subpath, ctx.sub(subpath) | ||||
|
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")) | ||||
|
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']: | ||
raise util.Abort(_("the name '%s' is reserved") % lbl) | ||||
|
r17821 | for c in (':', '\0', '\n', '\r'): | ||
if c in lbl: | ||||
|
r17850 | raise util.Abort(_("%r cannot be used in a name") % c) | ||
|
r18566 | try: | ||
int(lbl) | ||||
|
r19070 | raise util.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: | ||||
raise util.Abort(_("'\\n' and '\\r' disallowed in filenames: %r") % f) | ||||
|
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: | ||||
raise util.Abort(msg) | ||||
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) | ||||
abort = os.name == 'nt' or lval == 'abort' | ||||
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: | ||||
raise util.Abort(msg) | ||||
self._ui.warn(_("warning: %s\n") % msg) | ||||
|
r17201 | self._loweredfiles.add(fl) | ||
self._newfiles.add(f) | ||||
|
r13970 | |||
|
r17649 | class abstractvfs(object): | ||
|
r14089 | """Abstract base class; cannot be instantiated""" | ||
def __init__(self, *args, **kwargs): | ||||
'''Prevent instantiation; don't call this from subclasses.''' | ||||
raise NotImplementedError('attempted instantiating ' + str(type(self))) | ||||
|
r16455 | def tryread(self, path): | ||
|
r16479 | '''gracefully return an empty string for missing files''' | ||
|
r16455 | try: | ||
return self.read(path) | ||||
except IOError, inst: | ||||
if inst.errno != errno.ENOENT: | ||||
raise | ||||
return "" | ||||
|
r23368 | def tryreadlines(self, path, mode='rb'): | ||
'''gracefully return an empty array for missing files''' | ||||
try: | ||||
return self.readlines(path, mode=mode) | ||||
except IOError, inst: | ||||
if inst.errno != errno.ENOENT: | ||||
raise | ||||
return [] | ||||
|
r23370 | def open(self, path, mode="r", text=False, atomictemp=False, | ||
notindexed=False): | ||||
'''Open ``path`` file, which is relative to vfs root. | ||||
Newly created directories are marked as "not to be indexed by | ||||
the content indexing service", if ``notindexed`` is specified | ||||
for "write" mode access. | ||||
''' | ||||
|
r19897 | self.open = self.__call__ | ||
|
r23370 | return self.__call__(path, mode, text, atomictemp, notindexed) | ||
|
r19897 | |||
|
r14167 | def read(self, path): | ||
fp = self(path, 'rb') | ||||
|
r14097 | try: | ||
return fp.read() | ||||
finally: | ||||
fp.close() | ||||
|
r23368 | def readlines(self, path, mode='rb'): | ||
fp = self(path, mode=mode) | ||||
try: | ||||
return fp.readlines() | ||||
finally: | ||||
fp.close() | ||||
|
r14167 | def write(self, path, data): | ||
fp = self(path, 'wb') | ||||
try: | ||||
return fp.write(data) | ||||
finally: | ||||
fp.close() | ||||
|
r23371 | def writelines(self, path, data, mode='wb', notindexed=False): | ||
fp = self(path, mode=mode, notindexed=notindexed) | ||||
try: | ||||
return fp.writelines(data) | ||||
finally: | ||||
fp.close() | ||||
|
r14167 | def append(self, path, data): | ||
fp = self(path, 'ab') | ||||
|
r14097 | try: | ||
return fp.write(data) | ||||
finally: | ||||
fp.close() | ||||
|
r20086 | def chmod(self, path, mode): | ||
return os.chmod(self.join(path), mode) | ||||
|
r17161 | def exists(self, path=None): | ||
return os.path.exists(self.join(path)) | ||||
|
r19899 | def fstat(self, fp): | ||
return util.fstat(fp) | ||||
|
r17161 | def isdir(self, path=None): | ||
return os.path.isdir(self.join(path)) | ||||
|
r20085 | def isfile(self, path=None): | ||
return os.path.isfile(self.join(path)) | ||||
|
r18949 | def islink(self, path=None): | ||
return os.path.islink(self.join(path)) | ||||
|
r21563 | def lexists(self, path=None): | ||
return os.path.lexists(self.join(path)) | ||||
|
r19900 | def lstat(self, path=None): | ||
return os.lstat(self.join(path)) | ||||
|
r21799 | def listdir(self, path=None): | ||
return os.listdir(self.join(path)) | ||||
|
r17161 | def makedir(self, path=None, notindexed=True): | ||
return util.makedir(self.join(path), notindexed) | ||||
def makedirs(self, path=None, mode=None): | ||||
return util.makedirs(self.join(path), mode) | ||||
|
r20090 | def makelock(self, info, path): | ||
return util.makelock(info, self.join(path)) | ||||
|
r17723 | def mkdir(self, path=None): | ||
return os.mkdir(self.join(path)) | ||||
|
r20980 | def mkstemp(self, suffix='', prefix='tmp', dir=None, text=False): | ||
fd, name = tempfile.mkstemp(suffix=suffix, prefix=prefix, | ||||
dir=self.join(dir), text=text) | ||||
dname, fname = util.split(name) | ||||
if dir: | ||||
return fd, os.path.join(dir, fname) | ||||
else: | ||||
return fd, fname | ||||
|
r17747 | def readdir(self, path=None, stat=None, skip=None): | ||
return osutil.listdir(self.join(path), stat, skip) | ||||
|
r20090 | def readlock(self, path): | ||
return util.readlock(self.join(path)) | ||||
|
r18948 | def rename(self, src, dst): | ||
return util.rename(self.join(src), self.join(dst)) | ||||
|
r18950 | def readlink(self, path): | ||
return os.readlink(self.join(path)) | ||||
|
r18951 | def setflags(self, path, l, x): | ||
return util.setflags(self.join(path), l, x) | ||||
|
r17726 | def stat(self, path=None): | ||
return os.stat(self.join(path)) | ||||
|
r19895 | def unlink(self, path=None): | ||
return util.unlink(self.join(path)) | ||||
|
r21716 | def unlinkpath(self, path=None, ignoremissing=False): | ||
return util.unlinkpath(self.join(path), ignoremissing) | ||||
|
r19896 | def utime(self, path=None, t=None): | ||
return os.utime(self.join(path), t) | ||||
|
r17649 | class vfs(abstractvfs): | ||
'''Operate files relative to a base directory | ||||
|
r13970 | |||
This class is used to hide the details of COW semantics and | ||||
remote file access from higher level code. | ||||
''' | ||||
|
r18945 | def __init__(self, base, audit=True, expandpath=False, realpath=False): | ||
if expandpath: | ||||
base = util.expandpath(base) | ||||
if realpath: | ||||
base = os.path.realpath(base) | ||||
|
r13970 | self.base = base | ||
|
r17554 | self._setmustaudit(audit) | ||
self.createmode = None | ||||
self._trustnlink = None | ||||
def _getmustaudit(self): | ||||
return self._audit | ||||
def _setmustaudit(self, onoff): | ||||
self._audit = onoff | ||||
if onoff: | ||||
|
r20033 | self.audit = pathutil.pathauditor(self.base) | ||
|
r13970 | else: | ||
|
r18327 | self.audit = util.always | ||
|
r17554 | |||
mustaudit = property(_getmustaudit, _setmustaudit) | ||||
|
r13970 | |||
@util.propertycache | ||||
|
r14261 | def _cansymlink(self): | ||
|
r13970 | return util.checklink(self.base) | ||
|
r18192 | @util.propertycache | ||
def _chmod(self): | ||||
return util.checkexec(self.base) | ||||
|
r17763 | def _fixfilemode(self, name): | ||
|
r18192 | if self.createmode is None or not self._chmod: | ||
|
r13970 | return | ||
|
r17763 | os.chmod(name, self.createmode & 0666) | ||
|
r13970 | |||
|
r23370 | def __call__(self, path, mode="r", text=False, atomictemp=False, | ||
notindexed=False): | ||||
'''Open ``path`` file, which is relative to vfs root. | ||||
Newly created directories are marked as "not to be indexed by | ||||
the content indexing service", if ``notindexed`` is specified | ||||
for "write" mode access. | ||||
''' | ||||
|
r14720 | if self._audit: | ||
r = util.checkosfilename(path) | ||||
if r: | ||||
raise util.Abort("%s: %r" % (r, path)) | ||||
|
r18327 | self.audit(path) | ||
|
r16199 | f = self.join(path) | ||
|
r13970 | |||
if not text and "b" not in mode: | ||||
mode += "b" # for that other OS | ||||
nlink = -1 | ||||
|
r17937 | if mode not in ('r', 'rb'): | ||
dirname, basename = util.split(f) | ||||
# If basename is empty, then the path is malformed because it points | ||||
# to a directory. Let the posixfile() call below raise IOError. | ||||
if basename: | ||||
if atomictemp: | ||||
|
r23370 | util.ensuredirs(dirname, self.createmode, notindexed) | ||
|
r17937 | return util.atomictempfile(f, mode, self.createmode) | ||
try: | ||||
if 'w' in mode: | ||||
util.unlink(f) | ||||
nlink = 0 | ||||
else: | ||||
# nlinks() may behave differently for files on Windows | ||||
# shares if the file is open. | ||||
fd = util.posixfile(f) | ||||
nlink = util.nlinks(f) | ||||
if nlink < 1: | ||||
nlink = 2 # force mktempcopy (issue1922) | ||||
fd.close() | ||||
except (OSError, IOError), e: | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
|
r13970 | nlink = 0 | ||
|
r23370 | util.ensuredirs(dirname, self.createmode, notindexed) | ||
|
r17937 | if nlink > 0: | ||
if self._trustnlink is None: | ||||
self._trustnlink = nlink > 1 or util.checknlink(f) | ||||
if nlink > 1 or not self._trustnlink: | ||||
util.rename(util.mktempcopy(f), f) | ||||
|
r13970 | fp = util.posixfile(f, mode) | ||
if nlink == 0: | ||||
|
r17763 | self._fixfilemode(f) | ||
|
r13970 | return fp | ||
def symlink(self, src, dst): | ||||
|
r18327 | self.audit(dst) | ||
|
r16199 | linkname = self.join(dst) | ||
|
r13970 | try: | ||
os.unlink(linkname) | ||||
except OSError: | ||||
pass | ||||
|
r18678 | util.ensuredirs(os.path.dirname(linkname), self.createmode) | ||
|
r13970 | |||
|
r14261 | if self._cansymlink: | ||
|
r13970 | try: | ||
os.symlink(src, linkname) | ||||
except OSError, err: | ||||
raise OSError(err.errno, _('could not symlink to %r: %s') % | ||||
(src, err.strerror), linkname) | ||||
else: | ||||
|
r17768 | self.write(dst, src) | ||
|
r13971 | |||
|
r16199 | def join(self, path): | ||
|
r17161 | if path: | ||
|
r17681 | return os.path.join(self.base, path) | ||
else: | ||||
return self.base | ||||
|
r16199 | |||
|
r17649 | opener = vfs | ||
|
r17845 | class auditvfs(object): | ||
def __init__(self, vfs): | ||||
self.vfs = vfs | ||||
def _getmustaudit(self): | ||||
return self.vfs.mustaudit | ||||
def _setmustaudit(self, onoff): | ||||
self.vfs.mustaudit = onoff | ||||
mustaudit = property(_getmustaudit, _setmustaudit) | ||||
|
r17846 | class filtervfs(abstractvfs, auditvfs): | ||
|
r17649 | '''Wrapper vfs for filtering filenames with a function.''' | ||
|
r14090 | |||
|
r17846 | def __init__(self, vfs, filter): | ||
auditvfs.__init__(self, vfs) | ||||
|
r14090 | self._filter = filter | ||
def __call__(self, path, *args, **kwargs): | ||||
|
r17846 | return self.vfs(self._filter(path), *args, **kwargs) | ||
|
r14090 | |||
|
r17725 | def join(self, path): | ||
if path: | ||||
|
r17846 | return self.vfs.join(self._filter(path)) | ||
|
r17725 | else: | ||
|
r17846 | return self.vfs.join(path) | ||
|
r17725 | |||
|
r17649 | filteropener = filtervfs | ||
|
r18213 | class readonlyvfs(abstractvfs, auditvfs): | ||
'''Wrapper vfs preventing any writing.''' | ||||
def __init__(self, vfs): | ||||
auditvfs.__init__(self, vfs) | ||||
def __call__(self, path, mode='r', *args, **kw): | ||||
if mode not in ('r', 'rb'): | ||||
raise util.Abort('this vfs is read only') | ||||
return self.vfs(path, mode, *args, **kw) | ||||
|
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: | ||||
if 'HGRCPATH' in os.environ: | ||||
_rcpath = [] | ||||
for p in os.environ['HGRCPATH'].split(os.pathsep): | ||||
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 | |||
|
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: | ||
|
r14319 | raise util.Abort(_('empty revision set')) | ||
|
r22815 | return repo[l.last()] | ||
|
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: | ||||
|
r20819 | raise util.Abort(_('empty revision range')) | ||
|
r14319 | |||
|
r20862 | if first == second and len(revs) == 1 and _revrangesep not in revs[0]: | ||
return repo.lookup(first), None | ||||
|
r14319 | |||
|
r20862 | return repo.lookup(first), repo.lookup(second) | ||
|
r14319 | |||
_revrangesep = ':' | ||||
def revrange(repo, revs): | ||||
"""Yield revision as strings from a list of revision specifications.""" | ||||
def revfix(repo, val, defval): | ||||
if not val and val != 0 and defval is not None: | ||||
return defval | ||||
|
r16379 | return repo[val].rev() | ||
|
r14319 | |||
|
r20559 | seen, l = set(), revset.baseset([]) | ||
|
r14319 | for spec in revs: | ||
|
r16390 | if l and not seen: | ||
seen = set(l) | ||||
|
r14319 | # attempt to parse old-style ranges first to deal with | ||
# things like old-tag which contain query metacharacters | ||||
try: | ||||
if isinstance(spec, int): | ||||
seen.add(spec) | ||||
|
r20798 | l = l + revset.baseset([spec]) | ||
|
r14319 | continue | ||
if _revrangesep in spec: | ||||
start, end = spec.split(_revrangesep, 1) | ||||
start = revfix(repo, start, 0) | ||||
end = revfix(repo, end, len(repo) - 1) | ||||
|
r20699 | if end == nullrev and start < 0: | ||
|
r18466 | start = nullrev | ||
|
r17992 | rangeiter = repo.changelog.revs(start, end) | ||
|
r16390 | if not seen and not l: | ||
# by far the most common case: revs = ["-1:0"] | ||||
|
r20559 | l = revset.baseset(rangeiter) | ||
|
r16390 | # defer syncing seen until next iteration | ||
continue | ||||
|
r17992 | newrevs = set(rangeiter) | ||
|
r16390 | if seen: | ||
newrevs.difference_update(seen) | ||||
|
r16814 | seen.update(newrevs) | ||
|
r16390 | else: | ||
seen = newrevs | ||||
|
r20798 | l = l + revset.baseset(sorted(newrevs, reverse=start > end)) | ||
|
r14319 | continue | ||
elif spec and spec in repo: # single unquoted rev | ||||
rev = revfix(repo, spec, None) | ||||
if rev in seen: | ||||
continue | ||||
seen.add(rev) | ||||
|
r20798 | l = l + revset.baseset([rev]) | ||
|
r14319 | continue | ||
except error.RepoLookupError: | ||||
pass | ||||
# fall through to new-style queries if old-style fails | ||||
|
r20781 | m = revset.match(repo.ui, spec, repo) | ||
|
r20551 | if seen or l: | ||
dl = [r for r in m(repo, revset.spanset(repo)) if r not in seen] | ||||
|
r20798 | l = l + revset.baseset(dl) | ||
|
r20551 | seen.update(dl) | ||
else: | ||||
l = m(repo, revset.spanset(repo)) | ||||
|
r14319 | |||
return l | ||||
|
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 | ||
|
r16171 | def matchandpats(ctx, pats=[], opts={}, globbed=False, default='relpath'): | ||
|
r21111 | '''Return a matcher and the patterns that were used. | ||
The matcher will warn about bad matches.''' | ||||
|
r14320 | if pats == ("",): | ||
pats = [] | ||||
if not globbed and default == 'relpath': | ||||
pats = expandpats(pats or []) | ||||
|
r14670 | |||
m = ctx.match(pats, opts.get('include'), opts.get('exclude'), | ||||
|
r14669 | default) | ||
|
r14320 | def badfn(f, msg): | ||
|
r14671 | ctx._repo.ui.warn("%s: %s\n" % (m.rel(f), msg)) | ||
|
r14320 | m.bad = badfn | ||
|
r16171 | return m, pats | ||
def match(ctx, pats=[], opts={}, globbed=False, default='relpath'): | ||||
|
r21111 | '''Return a matcher that will warn about bad matches.''' | ||
|
r16171 | return matchandpats(ctx, pats, opts, globbed, default)[0] | ||
|
r14320 | |||
def matchall(repo): | ||||
|
r21111 | '''Return a matcher that will efficiently match everything.''' | ||
|
r14320 | return matchmod.always(repo.root, repo.getcwd()) | ||
def matchfiles(repo, files): | ||||
|
r21111 | '''Return a matcher that will efficiently match exactly these files.''' | ||
|
r14320 | return matchmod.exact(repo.root, repo.getcwd(), files) | ||
def addremove(repo, pats=[], opts={}, dry_run=None, similarity=None): | ||||
if dry_run is None: | ||||
dry_run = opts.get('dry_run') | ||||
if similarity is None: | ||||
similarity = float(opts.get('similarity') or 0) | ||||
# we'd use status here, except handling of symlinks and ignore is tricky | ||||
|
r14671 | m = match(repo[None], pats, opts) | ||
|
r16167 | rejected = [] | ||
m.bad = lambda x, y: rejected.append(x) | ||||
|
r23259 | added, unknown, deleted, removed, forgotten = _interestingfiles(repo, m) | ||
|
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): | ||||
rel = m.rel(abs) | ||||
if abs in unknownset: | ||||
|
r23427 | status = _('adding %s\n') % ((m.anypats() and rel) or abs) | ||
|
r18863 | else: | ||
|
r23427 | status = _('removing %s\n') % ((m.anypats() and rel) or 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 | ||||
return 0 | ||||
|
r19154 | def marktouched(repo, files, similarity=0.0): | ||
'''Assert that files have somehow been operated upon. files are relative to | ||||
the repo root.''' | ||||
m = matchfiles(repo, files) | ||||
rejected = [] | ||||
m.bad = lambda x, y: rejected.append(x) | ||||
|
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] | ||||
wlock = repo.wlock() | ||||
try: | ||||
wctx.forget(deleted) | ||||
wctx.add(unknown) | ||||
for new, old in renames.iteritems(): | ||||
wctx.copy(old, new) | ||||
finally: | ||||
wlock.release() | ||||
|
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), | ||||
|
r20715 | hint=_("see http://mercurial.selenic.com/wiki/MissingRequirement" | ||
|
r20820 | " for more information")) | ||
|
r14482 | return requirements | ||
|
r14928 | |||
|
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) | ||||
except OSError, e: | ||||
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 | ||||
recreating the object on every call (essentially the same behaviour 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): | ||||
|
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) | ||
|
r18897 | |||
|
r18898 | class dirs(object): | ||
'''a multiset of directory names from a dirstate or manifest''' | ||||
def __init__(self, map, skip=None): | ||||
self._dirs = {} | ||||
addpath = self.addpath | ||||
if util.safehasattr(map, 'iteritems') and skip is not None: | ||||
for f, s in map.iteritems(): | ||||
if s[0] != skip: | ||||
addpath(f) | ||||
else: | ||||
for f in map: | ||||
addpath(f) | ||||
def addpath(self, path): | ||||
dirs = self._dirs | ||||
for base in finddirs(path): | ||||
if base in dirs: | ||||
dirs[base] += 1 | ||||
return | ||||
dirs[base] = 1 | ||||
def delpath(self, path): | ||||
dirs = self._dirs | ||||
for base in finddirs(path): | ||||
if dirs[base] > 1: | ||||
dirs[base] -= 1 | ||||
return | ||||
del dirs[base] | ||||
def __iter__(self): | ||||
return self._dirs.iterkeys() | ||||
def __contains__(self, d): | ||||
return d in self._dirs | ||||
|
r18900 | if util.safehasattr(parsers, 'dirs'): | ||
dirs = parsers.dirs | ||||
|
r18897 | def finddirs(path): | ||
pos = path.rfind('/') | ||||
while pos != -1: | ||||
yield path[:pos] | ||||
pos = path.rfind('/', 0, pos) | ||||