|
|
# utils.urlutil - code related to [paths] management
|
|
|
#
|
|
|
# Copyright 2005-2021 Olivia Mackall <olivia@selenic.com> and others
|
|
|
#
|
|
|
# This software may be used and distributed according to the terms of the
|
|
|
# GNU General Public License version 2 or any later version.
|
|
|
import os
|
|
|
|
|
|
from ..i18n import _
|
|
|
from ..pycompat import (
|
|
|
getattr,
|
|
|
setattr,
|
|
|
)
|
|
|
from .. import (
|
|
|
error,
|
|
|
pycompat,
|
|
|
util,
|
|
|
)
|
|
|
|
|
|
|
|
|
class paths(dict):
|
|
|
"""Represents a collection of paths and their configs.
|
|
|
|
|
|
Data is initially derived from ui instances and the config files they have
|
|
|
loaded.
|
|
|
"""
|
|
|
|
|
|
def __init__(self, ui):
|
|
|
dict.__init__(self)
|
|
|
|
|
|
for name, loc in ui.configitems(b'paths', ignoresub=True):
|
|
|
# No location is the same as not existing.
|
|
|
if not loc:
|
|
|
continue
|
|
|
loc, sub_opts = ui.configsuboptions(b'paths', name)
|
|
|
self[name] = path(ui, name, rawloc=loc, suboptions=sub_opts)
|
|
|
|
|
|
for name, p in sorted(self.items()):
|
|
|
p.chain_path(ui, self)
|
|
|
|
|
|
def getpath(self, ui, name, default=None):
|
|
|
"""Return a ``path`` from a string, falling back to default.
|
|
|
|
|
|
``name`` can be a named path or locations. Locations are filesystem
|
|
|
paths or URIs.
|
|
|
|
|
|
Returns None if ``name`` is not a registered path, a URI, or a local
|
|
|
path to a repo.
|
|
|
"""
|
|
|
# Only fall back to default if no path was requested.
|
|
|
if name is None:
|
|
|
if not default:
|
|
|
default = ()
|
|
|
elif not isinstance(default, (tuple, list)):
|
|
|
default = (default,)
|
|
|
for k in default:
|
|
|
try:
|
|
|
return self[k]
|
|
|
except KeyError:
|
|
|
continue
|
|
|
return None
|
|
|
|
|
|
# Most likely empty string.
|
|
|
# This may need to raise in the future.
|
|
|
if not name:
|
|
|
return None
|
|
|
|
|
|
try:
|
|
|
return self[name]
|
|
|
except KeyError:
|
|
|
# Try to resolve as a local path or URI.
|
|
|
try:
|
|
|
# we pass the ui instance are warning might need to be issued
|
|
|
return path(ui, None, rawloc=name)
|
|
|
except ValueError:
|
|
|
raise error.RepoError(_(b'repository %s does not exist') % name)
|
|
|
|
|
|
|
|
|
_pathsuboptions = {}
|
|
|
|
|
|
|
|
|
def pathsuboption(option, attr):
|
|
|
"""Decorator used to declare a path sub-option.
|
|
|
|
|
|
Arguments are the sub-option name and the attribute it should set on
|
|
|
``path`` instances.
|
|
|
|
|
|
The decorated function will receive as arguments a ``ui`` instance,
|
|
|
``path`` instance, and the string value of this option from the config.
|
|
|
The function should return the value that will be set on the ``path``
|
|
|
instance.
|
|
|
|
|
|
This decorator can be used to perform additional verification of
|
|
|
sub-options and to change the type of sub-options.
|
|
|
"""
|
|
|
|
|
|
def register(func):
|
|
|
_pathsuboptions[option] = (attr, func)
|
|
|
return func
|
|
|
|
|
|
return register
|
|
|
|
|
|
|
|
|
@pathsuboption(b'pushurl', b'pushloc')
|
|
|
def pushurlpathoption(ui, path, value):
|
|
|
u = util.url(value)
|
|
|
# Actually require a URL.
|
|
|
if not u.scheme:
|
|
|
ui.warn(_(b'(paths.%s:pushurl not a URL; ignoring)\n') % path.name)
|
|
|
return None
|
|
|
|
|
|
# Don't support the #foo syntax in the push URL to declare branch to
|
|
|
# push.
|
|
|
if u.fragment:
|
|
|
ui.warn(
|
|
|
_(
|
|
|
b'("#fragment" in paths.%s:pushurl not supported; '
|
|
|
b'ignoring)\n'
|
|
|
)
|
|
|
% path.name
|
|
|
)
|
|
|
u.fragment = None
|
|
|
|
|
|
return bytes(u)
|
|
|
|
|
|
|
|
|
@pathsuboption(b'pushrev', b'pushrev')
|
|
|
def pushrevpathoption(ui, path, value):
|
|
|
return value
|
|
|
|
|
|
|
|
|
class path(object):
|
|
|
"""Represents an individual path and its configuration."""
|
|
|
|
|
|
def __init__(self, ui, name, rawloc=None, suboptions=None):
|
|
|
"""Construct a path from its config options.
|
|
|
|
|
|
``ui`` is the ``ui`` instance the path is coming from.
|
|
|
``name`` is the symbolic name of the path.
|
|
|
``rawloc`` is the raw location, as defined in the config.
|
|
|
``pushloc`` is the raw locations pushes should be made to.
|
|
|
|
|
|
If ``name`` is not defined, we require that the location be a) a local
|
|
|
filesystem path with a .hg directory or b) a URL. If not,
|
|
|
``ValueError`` is raised.
|
|
|
"""
|
|
|
if not rawloc:
|
|
|
raise ValueError(b'rawloc must be defined')
|
|
|
|
|
|
# Locations may define branches via syntax <base>#<branch>.
|
|
|
u = util.url(rawloc)
|
|
|
branch = None
|
|
|
if u.fragment:
|
|
|
branch = u.fragment
|
|
|
u.fragment = None
|
|
|
|
|
|
self.url = u
|
|
|
# the url from the config/command line before dealing with `path://`
|
|
|
self.raw_url = u.copy()
|
|
|
self.branch = branch
|
|
|
|
|
|
self.name = name
|
|
|
self.rawloc = rawloc
|
|
|
self.loc = b'%s' % u
|
|
|
|
|
|
self._validate_path()
|
|
|
|
|
|
_path, sub_opts = ui.configsuboptions(b'paths', b'*')
|
|
|
self._own_sub_opts = {}
|
|
|
if suboptions is not None:
|
|
|
self._own_sub_opts = suboptions.copy()
|
|
|
sub_opts.update(suboptions)
|
|
|
self._all_sub_opts = sub_opts.copy()
|
|
|
|
|
|
self._apply_suboptions(ui, sub_opts)
|
|
|
|
|
|
def chain_path(self, ui, paths):
|
|
|
if self.url.scheme == b'path':
|
|
|
assert self.url.path is None
|
|
|
try:
|
|
|
subpath = paths[self.url.host]
|
|
|
except KeyError:
|
|
|
m = _('cannot use `%s`, "%s" is not a known path')
|
|
|
m %= (self.rawloc, self.url.host)
|
|
|
raise error.Abort(m)
|
|
|
if subpath.raw_url.scheme == b'path':
|
|
|
m = _('cannot use `%s`, "%s" is also define as a `path://`')
|
|
|
m %= (self.rawloc, self.url.host)
|
|
|
raise error.Abort(m)
|
|
|
self.url = subpath.url
|
|
|
self.rawloc = subpath.rawloc
|
|
|
self.loc = subpath.loc
|
|
|
if self.branch is None:
|
|
|
self.branch = subpath.branch
|
|
|
else:
|
|
|
base = self.rawloc.rsplit(b'#', 1)[0]
|
|
|
self.rawloc = b'%s#%s' % (base, self.branch)
|
|
|
suboptions = subpath._all_sub_opts.copy()
|
|
|
suboptions.update(self._own_sub_opts)
|
|
|
self._apply_suboptions(ui, suboptions)
|
|
|
|
|
|
def _validate_path(self):
|
|
|
# When given a raw location but not a symbolic name, validate the
|
|
|
# location is valid.
|
|
|
if (
|
|
|
not self.name
|
|
|
and not self.url.scheme
|
|
|
and not self._isvalidlocalpath(self.loc)
|
|
|
):
|
|
|
raise ValueError(
|
|
|
b'location is not a URL or path to a local '
|
|
|
b'repo: %s' % self.rawloc
|
|
|
)
|
|
|
|
|
|
def _apply_suboptions(self, ui, sub_options):
|
|
|
# Now process the sub-options. If a sub-option is registered, its
|
|
|
# attribute will always be present. The value will be None if there
|
|
|
# was no valid sub-option.
|
|
|
for suboption, (attr, func) in pycompat.iteritems(_pathsuboptions):
|
|
|
if suboption not in sub_options:
|
|
|
setattr(self, attr, None)
|
|
|
continue
|
|
|
|
|
|
value = func(ui, self, sub_options[suboption])
|
|
|
setattr(self, attr, value)
|
|
|
|
|
|
def _isvalidlocalpath(self, path):
|
|
|
"""Returns True if the given path is a potentially valid repository.
|
|
|
This is its own function so that extensions can change the definition of
|
|
|
'valid' in this case (like when pulling from a git repo into a hg
|
|
|
one)."""
|
|
|
try:
|
|
|
return os.path.isdir(os.path.join(path, b'.hg'))
|
|
|
# Python 2 may return TypeError. Python 3, ValueError.
|
|
|
except (TypeError, ValueError):
|
|
|
return False
|
|
|
|
|
|
@property
|
|
|
def suboptions(self):
|
|
|
"""Return sub-options and their values for this path.
|
|
|
|
|
|
This is intended to be used for presentation purposes.
|
|
|
"""
|
|
|
d = {}
|
|
|
for subopt, (attr, _func) in pycompat.iteritems(_pathsuboptions):
|
|
|
value = getattr(self, attr)
|
|
|
if value is not None:
|
|
|
d[subopt] = value
|
|
|
return d
|
|
|
|
