This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6403

util: make util.dirs() and util.finddirs() include root directory (API)
ClosedPublic

Authored by martinvonz on May 17 2019, 1:57 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd8e55c0c642c: util: make util.dirs() and util.finddirs() include root directory (API)
Summary

This changes the behavior of test-origbackup-conflict.t so it no
longer errors out when the backup path points to an existing
file. Instead, it replaces the file by a directory. That seems
reasonable to me.

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.May 17 2019, 1:57 PM
martinvonz updated this revision to Diff 15180.May 17 2019, 2:05 PM
Closed by commit rHGd8e55c0c642c: util: make util.dirs() and util.finddirs() include root directory (API) (authored by martinvonz). · Explain WhyMay 20 2019, 11:47 AM
This revision was automatically updated to reflect the committed changes.
pulkit added a subscriber: pulkit.May 24 2019, 8:11 AM

it no longer errors out when the backup path points to an existing
file. Instead, it replaces the file by a directory.

I think this should be a part of relnotes.

martinvonz added a comment.May 24 2019, 12:19 PM
In D6403#93612, @pulkit wrote:

it no longer errors out when the backup path points to an existing
file. Instead, it replaces the file by a directory.

I think this should be a part of relnotes.

Note that that's only if they have configured it incorrectly, but I think you're still right that it's worth mentioning. I'll send a patch.

Revision Contents
Changeset List

Diff 15195

mercurial/cext/dirs.c

static inline Py_ssize_t _finddir(const char *path, Py_ssize_t pos) static inline Py_ssize_t _finddir(const char *path, Py_ssize_t pos)
{ {
while (pos != -1) { while (pos != -1) {
if (path[pos] == '/') if (path[pos] == '/')
break; break;
pos -= 1; pos -= 1;
} }
if (pos == -1) {
return 0;
}
return pos; return pos;
} }
static int _addpath(PyObject *dirs, PyObject *path) static int _addpath(PyObject *dirs, PyObject *path)
{ {
const char *cpath = PyBytes_AS_STRING(path); const char *cpath = PyBytes_AS_STRING(path);
Py_ssize_t pos = PyBytes_GET_SIZE(path); Py_ssize_t pos = PyBytes_GET_SIZE(path);

mercurial/cext/parsers.c

{"fm1readmarkers", fm1readmarkers, METH_VARARGS, {"fm1readmarkers", fm1readmarkers, METH_VARARGS,
"parse v1 obsolete markers\n"}, "parse v1 obsolete markers\n"},
{NULL, NULL}}; {NULL, NULL}};
void dirs_module_init(PyObject *mod); void dirs_module_init(PyObject *mod);
void manifest_module_init(PyObject *mod); void manifest_module_init(PyObject *mod);
void revlog_module_init(PyObject *mod); void revlog_module_init(PyObject *mod);
static const int version = 12; static const int version = 13;
static void module_init(PyObject *mod) static void module_init(PyObject *mod)
{ {
PyObject *capsule = NULL; PyObject *capsule = NULL;
PyModule_AddIntConstant(mod, "version", version); PyModule_AddIntConstant(mod, "version", version);
/* This module constant has two purposes. First, it lets us unit test /* This module constant has two purposes. First, it lets us unit test
* the ImportError raised without hard-coding any error text. This * the ImportError raised without hard-coding any error text. This

mercurial/hgweb/hgwebdir_mod.py

# nested indexes and hgwebs # nested indexes and hgwebs
if virtual.endswith('/index') and virtual not in repos: if virtual.endswith('/index') and virtual not in repos:
subdir = virtual[:-len('index')] subdir = virtual[:-len('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, each parent, and the root ('') # Check the full virtual path, and each parent
if virtual != '':
yield virtual yield virtual
for p in util.finddirs(virtual): for p in util.finddirs(virtual):
yield p yield p
yield ''
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
if pycompat.ispy3: if pycompat.ispy3:
uenv = {k.decode('latin1'): v for k, v in uenv = {k.decode('latin1'): v for k, v in

mercurial/match.py

@propertycache @propertycache
def _dirs(self): def _dirs(self):
return set(util.dirs(self._fileset)) | {''} return set(util.dirs(self._fileset)) | {''}
def visitdir(self, dir): def visitdir(self, dir):
dir = normalizerootdir(dir, 'visitdir') dir = normalizerootdir(dir, 'visitdir')
if self._prefix and dir in self._fileset: if self._prefix and dir in self._fileset:
return 'all' return 'all'
return ('' in self._fileset or return (dir in self._fileset or
dir in self._fileset or
dir in self._dirs or dir in self._dirs or
any(parentdir in self._fileset any(parentdir in self._fileset
for parentdir in util.finddirs(dir))) for parentdir in util.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 'this' return 'this'
# parents are directories which are non-recursively included because # parents are directories which are non-recursively included because
# they are needed to get to items in _dirs or _roots. # they are needed to get to items in _dirs or _roots.
self._parents = set(parents) self._parents = set(parents)
def visitdir(self, dir): def visitdir(self, dir):
dir = normalizerootdir(dir, 'visitdir') dir = normalizerootdir(dir, 'visitdir')
if self._prefix and dir in self._roots: if self._prefix and dir in self._roots:
return 'all' return 'all'
return ('' in self._roots or return (dir in self._roots or
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 any(parentdir in self._roots
for parentdir in util.finddirs(dir))) for parentdir in util.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
be matched non-recursively, and `parents` are the implicitly required be matched non-recursively, and `parents` are the implicitly required
directories to walk to items in either roots or dirs. directories to walk to items in either roots or dirs.
Returns a tuple of (roots, dirs, parents). Returns a tuple of (roots, dirs, parents).
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''), ... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''),
... (b'glob', b'g*', b'')]) ... (b'glob', b'g*', b'')])
(['g/h', 'g/h', ''], [], ['g', '']) (['g/h', 'g/h', ''], [], ['', 'g'])
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')]) ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')])
([], ['g/h', ''], ['g', '']) ([], ['g/h', ''], ['', 'g'])
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'relpath', b'r', b''), (b'path', b'p/p', b''), ... [(b'relpath', b'r', b''), (b'path', b'p/p', b''),
... (b'path', b'', b'')]) ... (b'path', b'', b'')])
(['r', 'p/p', ''], [], ['p', '']) (['r', 'p/p', ''], [], ['', 'p'])
>>> _rootsdirsandparents( >>> _rootsdirsandparents(
... [(b'relglob', b'rg*', b''), (b're', b're/', b''), ... [(b'relglob', b'rg*', b''), (b're', b're/', b''),
... (b'relre', b'rr', b'')]) ... (b'relre', b'rr', b'')])
(['', '', ''], [], ['']) (['', '', ''], [], [''])
''' '''
r, d = _patternrootsanddirs(kindpats) r, d = _patternrootsanddirs(kindpats)
p = [] p = []
# Append the parents as non-recursive/exact directories, since they must be # Append the parents as non-recursive/exact directories, since they must be
# scanned to get to either the roots or the other exact directories. # scanned to get to either the roots or the other exact directories.
p.extend(util.dirs(d)) p.extend(util.dirs(d))
p.extend(util.dirs(r)) p.extend(util.dirs(r))
# util.dirs() does not include the root directory, so add it manually
p.append('')
# FIXME: all uses of this function convert these to sets, do so before # FIXME: all uses of this function convert these to sets, do so before
# returning. # returning.
# FIXME: all uses of this function do not need anything in 'roots' and # FIXME: all uses of this function do not need anything in 'roots' and
# 'dirs' to also be in 'parents', consider removing them before returning. # 'dirs' to also be in 'parents', consider removing them before returning.
return r, d, p return r, d, p
def _explicitfiles(kindpats): def _explicitfiles(kindpats):

mercurial/policy.py

return fakelocals[modname] return fakelocals[modname]
# keep in sync with "version" in C modules # keep in sync with "version" in C modules
_cextversions = { _cextversions = {
(r'cext', r'base85'): 1, (r'cext', r'base85'): 1,
(r'cext', r'bdiff'): 3, (r'cext', r'bdiff'): 3,
(r'cext', r'mpatch'): 1, (r'cext', r'mpatch'): 1,
(r'cext', r'osutil'): 4, (r'cext', r'osutil'): 4,
(r'cext', r'parsers'): 12, (r'cext', r'parsers'): 13,
} }
# map import request to other package or module # map import request to other package or module
_modredirects = { _modredirects = {
(r'cext', r'charencode'): (r'cext', r'parsers'), (r'cext', r'charencode'): (r'cext', r'parsers'),
(r'cffi', r'base85'): (r'pure', r'base85'), (r'cffi', r'base85'): (r'pure', r'base85'),
(r'cffi', r'charencode'): (r'pure', r'charencode'), (r'cffi', r'charencode'): (r'pure', r'charencode'),
(r'cffi', r'parsers'): (r'pure', r'parsers'), (r'cffi', r'parsers'): (r'pure', r'parsers'),

mercurial/util.py

if safehasattr(parsers, 'dirs'): if safehasattr(parsers, 'dirs'):
dirs = parsers.dirs dirs = parsers.dirs
def finddirs(path): def finddirs(path):
pos = path.rfind('/') pos = path.rfind('/')
while pos != -1: while pos != -1:
yield path[:pos] yield path[:pos]
pos = path.rfind('/', 0, pos) pos = path.rfind('/', 0, pos)
yield ''
# 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.

relnotes/next

== Internal API Changes == == Internal API Changes ==
* Matchers are no longer iterable. Use `match.files()` instead. * Matchers are no longer iterable. Use `match.files()` instead.
* `match.visitdir()` and `match.visitchildrenset()` now expect the * `match.visitdir()` and `match.visitchildrenset()` now expect the
empty string instead of '.' to indicate the root directory. empty string instead of '.' to indicate the root directory.
* `util.dirs()` and `util.finddirs()` now include an entry for the
root directory (empty string).

tests/test-origbackup-conflict.t

$ hg up -q 0 $ hg up -q 0
$ mkdir b $ mkdir b
$ echo c5 > b/c $ echo c5 > b/c
$ hg up --verbose c1 --config ui.origbackuppath=.hg/badorigbackups $ hg up --verbose c1 --config ui.origbackuppath=.hg/badorigbackups
resolving manifests resolving manifests
b/c: replacing untracked file b/c: replacing untracked file
getting b/c getting b/c
creating directory: $TESTTMP/repo/.hg/badorigbackups/b creating directory: $TESTTMP/repo/.hg/badorigbackups/b
abort: $ENOTDIR$: *$TESTTMP/repo/.hg/badorigbackups/b* (glob) removing conflicting file: $TESTTMP/repo/.hg/badorigbackups
[255] getting d
$ cat .hg/badorigbackups 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
data (activating bookmark c1)
$ ls .hg/badorigbackups/b
c