This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10447

urlutil: make `paths` class old list of `path`
ClosedPublic

Authored by marmoute on Apr 15 2021, 8:03 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG7531cc34713c: urlutil: make `paths` class old list of `path`
Summary

We move from a {name → path} mapping to a {name → [path]} mapping. And
update all user code accordingly. For now, all the list contains exactly one
element, but we are now in a good place to make the config understand a list of
url.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.Apr 15 2021, 8:03 PM
baymax updated this revision to Diff 27016.Apr 17 2021, 7:44 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare requested changes to this revision.Apr 29 2021, 9:14 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
mercurial/utils/urlutil.py
478–479

Awaiting patiently for Py2 support to be dropped in order to use yield from

537

s/point/points/
s/support/supports/

Same for the others ones

This revision now requires changes to proceed.Apr 29 2021, 9:14 AM
baymax updated this revision to Diff 27207.Apr 29 2021, 1:47 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 27235.Apr 30 2021, 8:25 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 27419.May 3 2021, 9:52 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.May 6 2021, 12:24 PM
This revision is now accepted and ready to land.May 6 2021, 12:24 PM
pulkit accepted this revision.May 10 2021, 3:20 PM
marmoute added a commit: rHG7531cc34713c: urlutil: make `paths` class old list of `path`.May 15 2021, 7:21 PM
Closed by commit rHG7531cc34713c: urlutil: make `paths` class old list of `path` (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/templatekw.py (19 lines)
Mmercurial/utils/urlutil.py (141 lines)

Diff 26956

mercurial/templatekw.py

of your configuration file.""" of your configuration file."""
repo = context.resource(mapping, b'repo') repo = context.resource(mapping, b'repo')
# see commands.paths() for naming of dictionary keys # see commands.paths() for naming of dictionary keys
paths = repo.ui.paths paths = repo.ui.paths
all_paths = urlutil.list_paths(repo.ui) all_paths = urlutil.list_paths(repo.ui)
urls = util.sortdict((k, p.rawloc) for k, p in all_paths) urls = util.sortdict((k, p.rawloc) for k, p in all_paths)
def makemap(k): def makemap(k):
p = paths[k] ps = paths[k]
d = {b'name': k, b'url': p.rawloc} d = {b'name': k}
sub_opts = util.sortdict(sorted(pycompat.iteritems(p.suboptions))) if len(ps) == 1:
d[b'url'] = ps[0].rawloc
sub_opts = pycompat.iteritems(ps[0].suboptions)
sub_opts = util.sortdict(sorted(sub_opts))
d.update(sub_opts) d.update(sub_opts)
path_dict = util.sortdict() path_dict = util.sortdict()
for p in ps:
sub_opts = util.sortdict(sorted(pycompat.iteritems(p.suboptions)))
path_dict[b'url'] = p.rawloc path_dict[b'url'] = p.rawloc
path_dict.update(sub_opts) path_dict.update(sub_opts)
d[b'urls'] = [path_dict] d[b'urls'] = [path_dict]
return d return d
def format_one(k): def format_one(k):
return b'%s=%s' % (k, urls[k]) return b'%s=%s' % (k, urls[k])
return _hybrid(None, urls, makemap, format_one) return _hybrid(None, urls, makemap, format_one)

mercurial/utils/urlutil.py

'''remove all authentication information from a url string''' '''remove all authentication information from a url string'''
u = url(u) u = url(u)
u.user = u.passwd = None u.user = u.passwd = None
return bytes(u) return bytes(u)
def list_paths(ui, target_path=None): def list_paths(ui, target_path=None):
"""list all the (name, paths) in the passed ui""" """list all the (name, paths) in the passed ui"""
result = []
if target_path is None: if target_path is None:
return sorted(pycompat.iteritems(ui.paths)) for name, paths in sorted(pycompat.iteritems(ui.paths)):
else: for p in paths:
path = ui.paths.get(target_path) result.append((name, p))
if path is None:
return []
else: else:
return [(target_path, path)] for path in ui.paths.get(target_path, []):
result.append((target_path, path))
return result
def try_path(ui, url): def try_path(ui, url):
"""try to build a path from a url """try to build a path from a url
Return None if no Path could built. Return None if no Path could built.
""" """
try: try:
# we pass the ui instance are warning might need to be issued # we pass the ui instance are warning might need to be issued
return path(ui, None, rawloc=url) return path(ui, None, rawloc=url)
except ValueError: except ValueError:
return None return None
def get_push_paths(repo, ui, dests): def get_push_paths(repo, ui, dests):
"""yields all the `path` selected as push destination by `dests`""" """yields all the `path` selected as push destination by `dests`"""
if not dests: if not dests:
if b'default-push' in ui.paths: if b'default-push' in ui.paths:
yield ui.paths[b'default-push'] for p in ui.paths[b'default-push']:
yield p
AlphareUnsubmitted
Not Done

Awaiting patiently for Py2 support to be dropped in order to use yield from

Alphare: Awaiting patiently for Py2 support to be dropped in order to use `yield from`
elif b'default' in ui.paths: elif b'default' in ui.paths:
yield ui.paths[b'default'] for p in ui.paths[b'default']:
yield p
else: else:
raise error.ConfigError( raise error.ConfigError(
_(b'default repository not configured!'), _(b'default repository not configured!'),
hint=_(b"see 'hg help config.paths'"), hint=_(b"see 'hg help config.paths'"),
) )
else: else:
for dest in dests: for dest in dests:
if dest in ui.paths: if dest in ui.paths:
yield ui.paths[dest] for p in ui.paths[dest]:
yield p
else: else:
path = try_path(ui, dest) path = try_path(ui, dest)
if path is None: if path is None:
msg = _(b'repository %s does not exist') msg = _(b'repository %s does not exist')
msg %= dest msg %= dest
raise error.RepoError(msg) raise error.RepoError(msg)
yield path yield path
def get_pull_paths(repo, ui, sources, default_branches=()): def get_pull_paths(repo, ui, sources, default_branches=()):
"""yields all the `(path, branch)` selected as pull source by `sources`""" """yields all the `(path, branch)` selected as pull source by `sources`"""
if not sources: if not sources:
sources = [b'default'] sources = [b'default']
for source in sources: for source in sources:
if source in ui.paths: if source in ui.paths:
url = ui.paths[source].rawloc for p in ui.paths[source]:
yield parseurl(p.rawloc, default_branches)
else: else:
# Try to resolve as a local path or URI. # Try to resolve as a local path or URI.
path = try_path(ui, source) path = try_path(ui, source)
if path is not None: if path is not None:
url = path.rawloc url = path.rawloc
else: else:
url = source url = source
yield parseurl(url, default_branches) yield parseurl(url, default_branches)
def get_unique_push_path(action, repo, ui, dest=None): def get_unique_push_path(action, repo, ui, dest=None):
"""return a unique `path` or abort if multiple are found """return a unique `path` or abort if multiple are found
This is useful for command and action that does not support multiple This is useful for command and action that does not support multiple
destination (yet). destination (yet).
Note that for now, we cannot get multiple destination so this function is "trivial". Note that for now, we cannot get multiple destination so this function is "trivial".
The `action` parameter will be used for the error message. The `action` parameter will be used for the error message.
""" """
if dest is None: if dest is None:
dests = [] dests = []
else: else:
dests = [dest] dests = [dest]
dests = list(get_push_paths(repo, ui, dests)) dests = list(get_push_paths(repo, ui, dests))
assert len(dests) == 1 if len(dests) != 1:
if dest is None:
msg = _("default path point to %d urls while %s only support one")
AlphareUnsubmitted
Not Done

s/point/points/
s/support/supports/

Same for the others ones

Alphare: s/point/points/ s/support/supports/ Same for the others ones
msg %= (len(dests), action)
else:
msg = _("path point to %d urls while %s only support one: %s")
msg %= (len(dests), action, dest)
raise error.Abort(msg)
return dests[0] return dests[0]
def get_unique_pull_path(action, repo, ui, source=None, default_branches=()): def get_unique_pull_path(action, repo, ui, source=None, default_branches=()):
"""return a unique `(path, branch)` or abort if multiple are found """return a unique `(path, branch)` or abort if multiple are found
This is useful for command and action that does not support multiple This is useful for command and action that does not support multiple
destination (yet). destination (yet).
Note that for now, we cannot get multiple destination so this function is "trivial". Note that for now, we cannot get multiple destination so this function is "trivial".
The `action` parameter will be used for the error message. The `action` parameter will be used for the error message.
""" """
urls = []
if source is None: if source is None:
if b'default' in ui.paths: if b'default' in ui.paths:
url = ui.paths[b'default'].rawloc urls.extend(p.rawloc for p in ui.paths[b'default'])
else: else:
# XXX this is the historical default behavior, but that is not # XXX this is the historical default behavior, but that is not
# great, consider breaking BC on this. # great, consider breaking BC on this.
url = b'default' urls.append(b'default')
else: else:
if source in ui.paths: if source in ui.paths:
url = ui.paths[source].rawloc urls.extend(p.rawloc for p in ui.paths[source])
else: else:
# Try to resolve as a local path or URI. # Try to resolve as a local path or URI.
path = try_path(ui, source) path = try_path(ui, source)
if path is not None: if path is not None:
url = path.rawloc urls.append(path.rawloc)
else: else:
url = source urls.append(source)
return parseurl(url, default_branches) if len(urls) != 1:
if source is None:
msg = _("default path point to %d urls while %s only support one")
msg %= (len(urls), action)
else:
msg = _("path point to %d urls while %s only support one: %s")
msg %= (len(urls), action, source)
raise error.Abort(msg)
return parseurl(urls[0], default_branches)
def get_clone_path(ui, source, default_branches=()): def get_clone_path(ui, source, default_branches=()):
"""return the `(origsource, path, branch)` selected as clone source""" """return the `(origsource, path, branch)` selected as clone source"""
urls = []
if source is None: if source is None:
if b'default' in ui.paths: if b'default' in ui.paths:
url = ui.paths[b'default'].rawloc urls.extend(p.rawloc for p in ui.paths[b'default'])
else: else:
# XXX this is the historical default behavior, but that is not # XXX this is the historical default behavior, but that is not
# great, consider breaking BC on this. # great, consider breaking BC on this.
url = b'default' urls.append(b'default')
else: else:
if source in ui.paths: if source in ui.paths:
url = ui.paths[source].rawloc urls.extend(p.rawloc for p in ui.paths[source])
else: else:
# Try to resolve as a local path or URI. # Try to resolve as a local path or URI.
path = try_path(ui, source) path = try_path(ui, source)
if path is not None: if path is not None:
url = path.rawloc urls.append(path.rawloc)
else: else:
url = source urls.append(source)
if len(urls) != 1:
if source is None:
msg = _("default path point to %d urls while only one is supported")
msg %= len(urls)
else:
msg = _("path point to %d urls while only one is supported: %s")
msg %= (len(urls), source)
raise error.Abort(msg)
url = urls[0]
clone_path, branch = parseurl(url, default_branches) clone_path, branch = parseurl(url, default_branches)
return url, clone_path, branch return url, clone_path, branch
def parseurl(path, branches=None): def parseurl(path, branches=None):
'''parse url#branch, returning (url, (branch, branches))''' '''parse url#branch, returning (url, (branch, branches))'''
u = url(path) u = url(path)
branch = None branch = None
def __init__(self, ui): def __init__(self, ui):
dict.__init__(self) dict.__init__(self)
for name, loc in ui.configitems(b'paths', ignoresub=True): for name, loc in ui.configitems(b'paths', ignoresub=True):
# No location is the same as not existing. # No location is the same as not existing.
if not loc: if not loc:
continue continue
loc, sub_opts = ui.configsuboptions(b'paths', name) loc, sub_opts = ui.configsuboptions(b'paths', name)
self[name] = path(ui, name, rawloc=loc, suboptions=sub_opts) self[name] = [path(ui, name, rawloc=loc, suboptions=sub_opts)]
for name, p in sorted(self.items()): for name, old_paths in sorted(self.items()):
self[name] = _chain_path(p, ui, self) new_paths = []
for p in old_paths:
new_paths.extend(_chain_path(p, ui, self))
self[name] = new_paths
def getpath(self, ui, name, default=None): def getpath(self, ui, name, default=None):
"""Return a ``path`` from a string, falling back to default. """Return a ``path`` from a string, falling back to default.
``name`` can be a named path or locations. Locations are filesystem ``name`` can be a named path or locations. Locations are filesystem
paths or URIs. paths or URIs.
Returns None if ``name`` is not a registered path, a URI, or a local Returns None if ``name`` is not a registered path, a URI, or a local
path to a repo. path to a repo.
""" """
msg = b'getpath is deprecated, use `get_*` functions from urlutil' msg = b'getpath is deprecated, use `get_*` functions from urlutil'
self.deprecwarn(msg, '6.0') self.deprecwarn(msg, '6.0')
# Only fall back to default if no path was requested. # Only fall back to default if no path was requested.
if name is None: if name is None:
if not default: if not default:
default = () default = ()
elif not isinstance(default, (tuple, list)): elif not isinstance(default, (tuple, list)):
default = (default,) default = (default,)
for k in default: for k in default:
try: try:
return self[k] return self[k][0]
except KeyError: except KeyError:
continue continue
return None return None
# Most likely empty string. # Most likely empty string.
# This may need to raise in the future. # This may need to raise in the future.
if not name: if not name:
return None return None
if name in self: if name in self:
return self[name] return self[name][0]
else: else:
# Try to resolve as a local path or URI. # Try to resolve as a local path or URI.
path = try_path(ui, name) path = try_path(ui, name)
if path is None: if path is None:
raise error.RepoError(_(b'repository %s does not exist') % name) raise error.RepoError(_(b'repository %s does not exist') % name)
return path.rawloc return path.rawloc
return bytes(u) return bytes(u)
@pathsuboption(b'pushrev', b'pushrev') @pathsuboption(b'pushrev', b'pushrev')
def pushrevpathoption(ui, path, value): def pushrevpathoption(ui, path, value):
return value return value
def _chain_path(path, ui, paths): def _chain_path(base_path, ui, paths):
"""return the result of "path://" logic applied on a given path""" """return the result of "path://" logic applied on a given path"""
if path.url.scheme == b'path': new_paths = []
assert path.url.path is None if base_path.url.scheme != b'path':
subpath = paths.get(path.url.host) new_paths.append(base_path)
if subpath is None: else:
assert base_path.url.path is None
sub_paths = paths.get(base_path.url.host)
if sub_paths is None:
m = _(b'cannot use `%s`, "%s" is not a known path') m = _(b'cannot use `%s`, "%s" is not a known path')
m %= (path.rawloc, path.url.host) m %= (base_path.rawloc, base_path.url.host)
raise error.Abort(m) raise error.Abort(m)
for subpath in sub_paths:
path = base_path.copy()
if subpath.raw_url.scheme == b'path': if subpath.raw_url.scheme == b'path':
m = _(b'cannot use `%s`, "%s" is also defined as a `path://`') m = _(b'cannot use `%s`, "%s" is also defined as a `path://`')
m %= (path.rawloc, path.url.host) m %= (path.rawloc, path.url.host)
raise error.Abort(m) raise error.Abort(m)
path.url = subpath.url path.url = subpath.url
path.rawloc = subpath.rawloc path.rawloc = subpath.rawloc
path.loc = subpath.loc path.loc = subpath.loc
if path.branch is None: if path.branch is None:
path.branch = subpath.branch path.branch = subpath.branch
else: else:
base = path.rawloc.rsplit(b'#', 1)[0] base = path.rawloc.rsplit(b'#', 1)[0]
path.rawloc = b'%s#%s' % (base, path.branch) path.rawloc = b'%s#%s' % (base, path.branch)
suboptions = subpath._all_sub_opts.copy() suboptions = subpath._all_sub_opts.copy()
suboptions.update(path._own_sub_opts) suboptions.update(path._own_sub_opts)
path._apply_suboptions(ui, suboptions) path._apply_suboptions(ui, suboptions)
return path new_paths.append(path)
return new_paths
class path(object): class path(object):
"""Represents an individual path and its configuration.""" """Represents an individual path and its configuration."""
def __init__(self, ui=None, name=None, rawloc=None, suboptions=None): def __init__(self, ui=None, name=None, rawloc=None, suboptions=None):
"""Construct a path from its config options. """Construct a path from its config options.