This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7388

utils: move finddirs() to pathutil
ClosedPublic

Authored by martinvonz on Nov 14 2019, 11:17 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG0b7733719d21: utils: move finddirs() to pathutil
Summary

This is a follow-up to c21aca51b392 (utils: move the dirs definition
in pathutil (API), 2019-11-06). finddirs() is closely related to dirs
and used by it.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Nov 14 2019, 11:17 AM
indygreg accepted this revision.Nov 14 2019, 10:05 PM
This revision is now accepted and ready to land.Nov 14 2019, 10:05 PM
martinvonz added a commit: rHG0b7733719d21: utils: move finddirs() to pathutil.Nov 14 2019, 10:36 PM
Closed by commit rHG0b7733719d21: utils: move finddirs() to pathutil (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 18113

mercurial/context.py

wvfs.audit(f) wvfs.audit(f)
if self._repo.ui.configbool( if self._repo.ui.configbool(
b'experimental', b'merge.checkpathconflicts' b'experimental', b'merge.checkpathconflicts'
): ):
# remove files under the directory as they should already be # remove files under the directory as they should already be
# warned and backed up # warned and backed up
if wvfs.isdir(f) and not wvfs.islink(f): if wvfs.isdir(f) and not wvfs.islink(f):
wvfs.rmtree(f, forcibly=True) wvfs.rmtree(f, forcibly=True)
for p in reversed(list(util.finddirs(f))): for p in reversed(list(pathutil.finddirs(f))):
if wvfs.isfileorlink(p): if wvfs.isfileorlink(p):
wvfs.unlink(p) wvfs.unlink(p)
break break
else: else:
# don't remove files if path conflicts are not processed # don't remove files if path conflicts are not processed
if wvfs.isdir(f) and not wvfs.islink(f): if wvfs.isdir(f) and not wvfs.islink(f):
wvfs.removedirs(f) wvfs.removedirs(f)

mercurial/debugcommands.py

hg, hg,
httppeer, httppeer,
localrepo, localrepo,
lock as lockmod, lock as lockmod,
logcmdutil, logcmdutil,
merge as mergemod, merge as mergemod,
obsolete, obsolete,
obsutil, obsutil,
pathutil,
phases, phases,
policy, policy,
pvec, pvec,
pycompat, pycompat,
registrar, registrar,
repair, repair,
revlog, revlog,
revset, revset,
nf = util.normpath(f) nf = util.normpath(f)
ignored = None ignored = None
ignoredata = None ignoredata = None
if nf != b'.': if nf != b'.':
if ignore(nf): if ignore(nf):
ignored = nf ignored = nf
ignoredata = repo.dirstate._ignorefileandline(nf) ignoredata = repo.dirstate._ignorefileandline(nf)
else: else:
for p in util.finddirs(nf): for p in pathutil.finddirs(nf):
if ignore(p): if ignore(p):
ignored = p ignored = p
ignoredata = repo.dirstate._ignorefileandline(p) ignoredata = repo.dirstate._ignorefileandline(p)
break break
if ignored: if ignored:
if ignored == nf: if ignored == nf:
ui.write(_(b"%s is ignored\n") % uipathfn(f)) ui.write(_(b"%s is ignored\n") % uipathfn(f))
else: else:

mercurial/dirstate.py

oldstate = self[f] oldstate = self[f]
if state == b'a' or oldstate == b'r': if state == b'a' or oldstate == b'r':
scmutil.checkfilename(f) scmutil.checkfilename(f)
if self._map.hastrackeddir(f): if self._map.hastrackeddir(f):
raise error.Abort( raise error.Abort(
_(b'directory %r already in dirstate') % pycompat.bytestr(f) _(b'directory %r already in dirstate') % pycompat.bytestr(f)
) )
# shadows # shadows
for d in util.finddirs(f): for d in pathutil.finddirs(f):
if self._map.hastrackeddir(d): if self._map.hastrackeddir(d):
break break
entry = self._map.get(d) entry = self._map.get(d)
if entry is not None and entry[0] != b'r': if entry is not None and entry[0] != b'r':
raise error.Abort( raise error.Abort(
_(b'file %r in dirstate clashes with %r') _(b'file %r in dirstate clashes with %r')
% (pycompat.bytestr(d), pycompat.bytestr(f)) % (pycompat.bytestr(d), pycompat.bytestr(f))
) )
self._map.write(st, now) self._map.write(st, now)
self._lastnormaltime = 0 self._lastnormaltime = 0
self._dirty = False self._dirty = False
def _dirignore(self, f): def _dirignore(self, f):
if self._ignore(f): if self._ignore(f):
return True return True
for p in util.finddirs(f): for p in pathutil.finddirs(f):
if self._ignore(p): if self._ignore(p):
return True return True
return False return False
def _ignorefiles(self): def _ignorefiles(self):
files = [] files = []
if os.path.exists(self._join(b'.hgignore')): if os.path.exists(self._join(b'.hgignore')):
files.append(self._join(b'.hgignore')) files.append(self._join(b'.hgignore'))

mercurial/hgweb/hgwebdir_mod.py

) )
from .. import ( from .. import (
configitems, configitems,
encoding, encoding,
error, error,
extensions, extensions,
hg, hg,
pathutil,
profiling, profiling,
pycompat, pycompat,
registrar, registrar,
scmutil, scmutil,
templater, templater,
templateutil, templateutil,
ui as uimod, ui as uimod,
util, util,
if virtual.endswith(b'/index') and virtual not in repos: if virtual.endswith(b'/index') and virtual not in repos:
subdir = virtual[: -len(b'index')] subdir = virtual[: -len(b'index')]
if any(r.startswith(subdir) for r in repos): if any(r.startswith(subdir) for r in repos):
return self.makeindex(req, res, tmpl, subdir) return self.makeindex(req, res, tmpl, subdir)
def _virtualdirs(): def _virtualdirs():
# Check the full virtual path, and each parent # Check the full virtual path, and each parent
yield virtual yield virtual
for p in util.finddirs(virtual): for p in pathutil.finddirs(virtual):
yield p yield p
for virtualrepo in _virtualdirs(): for virtualrepo in _virtualdirs():
real = repos.get(virtualrepo) real = repos.get(virtualrepo)
if real: if real:
# Re-parse the WSGI environment to take into account our # Re-parse the WSGI environment to take into account our
# repository path component. # repository path component.
uenv = req.rawenv uenv = req.rawenv

mercurial/match.py

import re import re
from .i18n import _ from .i18n import _
from .pycompat import open from .pycompat import open
from . import ( from . import (
encoding, encoding,
error, error,
pathutil, pathutil,
pathutil,
policy, policy,
pycompat, pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
rustmod = policy.importrust('filepatterns') rustmod = policy.importrust('filepatterns')
def visitdir(self, dir): def visitdir(self, dir):
if self._prefix and dir in self._fileset: if self._prefix and dir in self._fileset:
return b'all' return b'all'
return ( return (
dir in self._fileset dir in self._fileset
or dir in self._dirs or dir in self._dirs
or any( or any(
parentdir in self._fileset for parentdir in util.finddirs(dir) parentdir in self._fileset
for parentdir in pathutil.finddirs(dir)
) )
) )
def visitchildrenset(self, dir): def visitchildrenset(self, dir):
ret = self.visitdir(dir) ret = self.visitdir(dir)
if ret is True: if ret is True:
return b'this' return b'this'
elif not ret: elif not ret:
for d, b in findsplitdirs(path): for d, b in findsplitdirs(path):
if d not in self._onlyinclude: if d not in self._onlyinclude:
continue continue
dirs.setdefault(d, set()).add(b) dirs.setdefault(d, set()).add(b)
@staticmethod @staticmethod
def _findsplitdirs(path): def _findsplitdirs(path):
# yields (dirname, basename) tuples, walking back to the root. This is # yields (dirname, basename) tuples, walking back to the root. This is
# very similar to util.finddirs, except: # very similar to pathutil.finddirs, except:
# - produces a (dirname, basename) tuple, not just 'dirname' # - produces a (dirname, basename) tuple, not just 'dirname'
# Unlike manifest._splittopdir, this does not suffix `dirname` with a # Unlike manifest._splittopdir, this does not suffix `dirname` with a
# slash. # slash.
oldpos = len(path) oldpos = len(path)
pos = path.rfind(b'/') pos = path.rfind(b'/')
while pos != -1: while pos != -1:
yield path[:pos], path[pos + 1 : oldpos] yield path[:pos], path[pos + 1 : oldpos]
oldpos = pos oldpos = pos
def visitdir(self, dir): def visitdir(self, dir):
if self._prefix and dir in self._roots: if self._prefix and dir in self._roots:
return b'all' return b'all'
return ( return (
dir in self._roots dir in self._roots
or dir in self._dirs or dir in self._dirs
or dir in self._parents or dir in self._parents
or any(parentdir in self._roots for parentdir in util.finddirs(dir)) or any(
parentdir in self._roots for parentdir in pathutil.finddirs(dir)
)
) )
@propertycache @propertycache
def _allparentschildren(self): def _allparentschildren(self):
# It may seem odd that we add dirs, roots, and parents, and then # It may seem odd that we add dirs, roots, and parents, and then
# restrict to only parents. This is to catch the case of: # restrict to only parents. This is to catch the case of:
# dirs = ['foo/bar'] # dirs = ['foo/bar']
# parents = ['foo'] # parents = ['foo']
# if we asked for the children of 'foo', but had only added # if we asked for the children of 'foo', but had only added
# self._parents, we wouldn't be able to respond ['bar']. # self._parents, we wouldn't be able to respond ['bar'].
return _dirchildren( return _dirchildren(
itertools.chain(self._dirs, self._roots, self._parents), itertools.chain(self._dirs, self._roots, self._parents),
onlyinclude=self._parents, onlyinclude=self._parents,
) )
def visitchildrenset(self, dir): def visitchildrenset(self, dir):
if self._prefix and dir in self._roots: if self._prefix and dir in self._roots:
return b'all' return b'all'
# Note: this does *not* include the 'dir in self._parents' case from # Note: this does *not* include the 'dir in self._parents' case from
# visitdir, that's handled below. # visitdir, that's handled below.
if ( if (
b'' in self._roots b'' in self._roots
or dir in self._roots or dir in self._roots
or dir in self._dirs or dir in self._dirs
or any(parentdir in self._roots for parentdir in util.finddirs(dir)) or any(
parentdir in self._roots for parentdir in pathutil.finddirs(dir)
)
): ):
return b'this' return b'this'
if dir in self._parents: if dir in self._parents:
return self._allparentschildren.get(dir) or set() return self._allparentschildren.get(dir) or set()
return set() return set()
@encoding.strmethod @encoding.strmethod
def matchfn(self, f): def matchfn(self, f):
if not f.startswith(self._pathprefix): if not f.startswith(self._pathprefix):
return False return False
return self._matcher.matchfn(f[len(self._pathprefix) :]) return self._matcher.matchfn(f[len(self._pathprefix) :])
@propertycache @propertycache
def _pathdirs(self): def _pathdirs(self):
return set(util.finddirs(self._path)) return set(pathutil.finddirs(self._path))
def visitdir(self, dir): def visitdir(self, dir):
if dir == self._path: if dir == self._path:
return self._matcher.visitdir(b'') return self._matcher.visitdir(b'')
if dir.startswith(self._pathprefix): if dir.startswith(self._pathprefix):
return self._matcher.visitdir(dir[len(self._pathprefix) :]) return self._matcher.visitdir(dir[len(self._pathprefix) :])
return dir in self._pathdirs return dir in self._pathdirs

mercurial/merge.py

from .thirdparty import attr from .thirdparty import attr
from . import ( from . import (
copies, copies,
encoding, encoding,
error, error,
filemerge, filemerge,
match as matchmod, match as matchmod,
obsutil, obsutil,
pathutil,
pycompat, pycompat,
scmutil, scmutil,
subrepoutil, subrepoutil,
util, util,
worker, worker,
) )
_pack = struct.pack _pack = struct.pack
self._missingdircache = set() self._missingdircache = set()
def __call__(self, repo, wctx, f): def __call__(self, repo, wctx, f):
if wctx.isinmemory(): if wctx.isinmemory():
# Nothing to do in IMM for the same reason as ``_checkunknownfile``. # Nothing to do in IMM for the same reason as ``_checkunknownfile``.
return False return False
# Check for path prefixes that exist as unknown files. # Check for path prefixes that exist as unknown files.
for p in reversed(list(util.finddirs(f))): for p in reversed(list(pathutil.finddirs(f))):
if p in self._missingdircache: if p in self._missingdircache:
return return
if p in self._unknowndircache: if p in self._unknowndircache:
continue continue
if repo.wvfs.audit.check(p): if repo.wvfs.audit.check(p):
if ( if (
repo.wvfs.isfileorlink(p) repo.wvfs.isfileorlink(p)
and repo.dirstate.normalize(p) not in repo.dirstate and repo.dirstate.normalize(p) not in repo.dirstate
else: else:
repo.ui.warn(_(b"%s: replacing untracked files in directory\n") % f) repo.ui.warn(_(b"%s: replacing untracked files in directory\n") % f)
for f, (m, args, msg) in pycompat.iteritems(actions): for f, (m, args, msg) in pycompat.iteritems(actions):
if m == ACTION_CREATED: if m == ACTION_CREATED:
backup = ( backup = (
f in fileconflicts f in fileconflicts
or f in pathconflicts or f in pathconflicts
or any(p in pathconflicts for p in util.finddirs(f)) or any(p in pathconflicts for p in pathutil.finddirs(f))
) )
(flags,) = args (flags,) = args
actions[f] = (ACTION_GET, (flags, backup), msg) actions[f] = (ACTION_GET, (flags, backup), msg)
def _forgetremoved(wctx, mctx, branchmerge): def _forgetremoved(wctx, mctx, branchmerge):
""" """
Forget removed files Forget removed files
def _filesindirs(repo, manifest, dirs): def _filesindirs(repo, manifest, dirs):
""" """
Generator that yields pairs of all the files in the manifest that are found Generator that yields pairs of all the files in the manifest that are found
inside the directories listed in dirs, and which directory they are found inside the directories listed in dirs, and which directory they are found
in. in.
""" """
for f in manifest: for f in manifest:
for p in util.finddirs(f): for p in pathutil.finddirs(f):
if p in dirs: if p in dirs:
yield f, p yield f, p
break break
def checkpathconflicts(repo, wctx, mctx, actions): def checkpathconflicts(repo, wctx, mctx, actions):
""" """
Check if any actions introduce path conflicts in the repository, updating Check if any actions introduce path conflicts in the repository, updating
for f, (m, args, msg) in actions.items(): for f, (m, args, msg) in actions.items():
if m in ( if m in (
ACTION_CREATED, ACTION_CREATED,
ACTION_DELETED_CHANGED, ACTION_DELETED_CHANGED,
ACTION_MERGE, ACTION_MERGE,
ACTION_CREATED_MERGE, ACTION_CREATED_MERGE,
): ):
# This action may create a new local file. # This action may create a new local file.
createdfiledirs.update(util.finddirs(f)) createdfiledirs.update(pathutil.finddirs(f))
if mf.hasdir(f): if mf.hasdir(f):
# The file aliases a local directory. This might be ok if all # The file aliases a local directory. This might be ok if all
# the files in the local directory are being deleted. This # the files in the local directory are being deleted. This
# will be checked once we know what all the deleted files are. # will be checked once we know what all the deleted files are.
remoteconflicts.add(f) remoteconflicts.add(f)
# Track the names of all deleted files. # Track the names of all deleted files.
if m == ACTION_REMOVE: if m == ACTION_REMOVE:
deletedfiles.add(f) deletedfiles.add(f)
repo.ui.note(_(b"getting %s\n") % f) repo.ui.note(_(b"getting %s\n") % f)
if backup: if backup:
# If a file or directory exists with the same name, back that # If a file or directory exists with the same name, back that
# up. Otherwise, look to see if there is a file that conflicts # up. Otherwise, look to see if there is a file that conflicts
# with a directory this file is in, and if so, back that up. # with a directory this file is in, and if so, back that up.
conflicting = f conflicting = f
if not repo.wvfs.lexists(f): if not repo.wvfs.lexists(f):
for p in util.finddirs(f): for p in pathutil.finddirs(f):
if repo.wvfs.isfileorlink(p): if repo.wvfs.isfileorlink(p):
conflicting = p conflicting = p
break break
if repo.wvfs.lexists(conflicting): if repo.wvfs.lexists(conflicting):
orig = scmutil.backuppath(ui, repo, conflicting) orig = scmutil.backuppath(ui, repo, conflicting)
util.rename(repo.wjoin(conflicting), orig) util.rename(repo.wjoin(conflicting), orig)
wfctx = wctx[f] wfctx = wctx[f]
wfctx.clearunknown() wfctx.clearunknown()

mercurial/pathutil.py

''' '''
d, p = os.path.splitdrive(path) d, p = os.path.splitdrive(path)
if len(p) != len(pycompat.ossep): if len(p) != len(pycompat.ossep):
return path + pycompat.ossep return path + pycompat.ossep
else: else:
return path return path
def finddirs(path):
pos = path.rfind(b'/')
while pos != -1:
yield path[:pos]
pos = path.rfind(b'/', 0, pos)
yield b''
class dirs(object): class dirs(object):
'''a multiset of directory names from a set of file paths''' '''a multiset of directory names from a set of file paths'''
def __init__(self, map, skip=None): def __init__(self, map, skip=None):
self._dirs = {} self._dirs = {}
addpath = self.addpath addpath = self.addpath
if isinstance(map, dict) and skip is not None: if isinstance(map, dict) and skip is not None:
for f, s in pycompat.iteritems(map): for f, s in pycompat.iteritems(map):
if s[0] != skip: if s[0] != skip:
addpath(f) addpath(f)
elif skip is not None: elif skip is not None:
raise error.ProgrammingError( raise error.ProgrammingError(
b"skip character is only supported with a dict source" b"skip character is only supported with a dict source"
) )
else: else:
for f in map: for f in map:
addpath(f) addpath(f)
def addpath(self, path): def addpath(self, path):
dirs = self._dirs dirs = self._dirs
for base in util.finddirs(path): for base in finddirs(path):
if base.endswith(b'/'): if base.endswith(b'/'):
raise ValueError( raise ValueError(
"found invalid consecutive slashes in path: %r" % base "found invalid consecutive slashes in path: %r" % base
) )
if base in dirs: if base in dirs:
dirs[base] += 1 dirs[base] += 1
return return
dirs[base] = 1 dirs[base] = 1
def delpath(self, path): def delpath(self, path):
dirs = self._dirs dirs = self._dirs
for base in util.finddirs(path): for base in finddirs(path):
if dirs[base] > 1: if dirs[base] > 1:
dirs[base] -= 1 dirs[base] -= 1
return return
del dirs[base] del dirs[base]
def __iter__(self): def __iter__(self):
return iter(self._dirs) return iter(self._dirs)

mercurial/scmutil.py

if origvfs is None: if origvfs is None:
return repo.wjoin(filepath + b".orig") return repo.wjoin(filepath + b".orig")
origbackupdir = origvfs.dirname(filepath) origbackupdir = origvfs.dirname(filepath)
if not origvfs.isdir(origbackupdir) or origvfs.islink(origbackupdir): if not origvfs.isdir(origbackupdir) or origvfs.islink(origbackupdir):
ui.note(_(b'creating directory: %s\n') % origvfs.join(origbackupdir)) ui.note(_(b'creating directory: %s\n') % origvfs.join(origbackupdir))
# Remove any files that conflict with the backup file's path # Remove any files that conflict with the backup file's path
for f in reversed(list(util.finddirs(filepath))): for f in reversed(list(pathutil.finddirs(filepath))):
if origvfs.isfileorlink(f): if origvfs.isfileorlink(f):
ui.note(_(b'removing conflicting file: %s\n') % origvfs.join(f)) ui.note(_(b'removing conflicting file: %s\n') % origvfs.join(f))
origvfs.unlink(f) origvfs.unlink(f)
break break
origvfs.makedirs(origbackupdir) origvfs.makedirs(origbackupdir)
if origvfs.isdir(filepath) and not origvfs.islink(filepath): if origvfs.isdir(filepath) and not origvfs.islink(filepath):

mercurial/util.py

if otherf: if otherf:
otherf.flush() otherf.flush()
f.write(b'%s at:\n' % msg.rstrip()) f.write(b'%s at:\n' % msg.rstrip())
for line in getstackframes(skip + 1, depth=depth): for line in getstackframes(skip + 1, depth=depth):
f.write(line) f.write(line)
f.flush() f.flush()
def finddirs(path):
pos = path.rfind(b'/')
while pos != -1:
yield path[:pos]
pos = path.rfind(b'/', 0, pos)
yield b''
# convenient shortcut # convenient shortcut
dst = debugstacktrace dst = debugstacktrace
def safename(f, tag, ctx, others=None): def safename(f, tag, ctx, others=None):
""" """
Generate a name that it is safe to rename f to in the given context. Generate a name that it is safe to rename f to in the given context.

rust/hg-core/src/utils/files.rs

assert_eq!(dirs.next(), Some(HgPath::new(b"foo"))); assert_eq!(dirs.next(), Some(HgPath::new(b"foo")));
assert_eq!(dirs.next(), Some(HgPath::new(b""))); assert_eq!(dirs.next(), Some(HgPath::new(b"")));
assert_eq!(dirs.next(), None); assert_eq!(dirs.next(), None);
assert_eq!(dirs.next(), None); assert_eq!(dirs.next(), None);
} }
#[test] #[test]
fn find_dirs_empty() { fn find_dirs_empty() {
// looks weird, but mercurial.util.finddirs(b"") yields b"" // looks weird, but mercurial.pathutil.finddirs(b"") yields b""
let mut dirs = super::find_dirs(HgPath::new(b"")); let mut dirs = super::find_dirs(HgPath::new(b""));
assert_eq!(dirs.next(), Some(HgPath::new(b""))); assert_eq!(dirs.next(), Some(HgPath::new(b"")));
assert_eq!(dirs.next(), None); assert_eq!(dirs.next(), None);
assert_eq!(dirs.next(), None); assert_eq!(dirs.next(), None);
} }
} }