mercurial/utils/urlutil.py

47197:26b3953ba1b0

    return bytes(u)


def list_paths(ui, target_path=None):
    """list all the (name, paths) in the passed ui"""
    if target_path is None:
        return sorted(pycompat.iteritems(ui.paths))
    else:
        path = ui.paths.get(target_path)
        if path is None:
            return []
        else:
            return [(target_path, path)]


def try_path(ui, url):
    """try to build a path from a url

def get_push_paths(repo, ui, dests):
    """yields all the `path` selected as push destination by `dests`"""
    if not dests:
        if b'default-push' in ui.paths:
            yield ui.paths[b'default-push']
        elif b'default' in ui.paths:
            yield ui.paths[b'default']
        else:
            raise error.ConfigError(
                _(b'default repository not configured!'),
                hint=_(b"see 'hg help config.paths'"),
            )
    else:
        for dest in dests:
            if dest in ui.paths:
                yield ui.paths[dest]
            else:
                path = try_path(ui, dest)
                if path is None:
                    msg = _(b'repository %s does not exist')
                    msg %= dest

    """yields all the `(path, branch)` selected as pull source by `sources`"""
    if not sources:
        sources = [b'default']
    for source in sources:
        if source in ui.paths:
            url = ui.paths[source].rawloc
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, source)
            if path is not None:
                url = path.rawloc
            else:
                url = source
        yield parseurl(url, default_branches)


def get_unique_push_path(action, repo, ui, dest=None):
    """return a unique `path` or abort if multiple are found

    if dest is None:
        dests = []
    else:
        dests = [dest]
    dests = list(get_push_paths(repo, ui, dests))
    assert len(dests) == 1
    return dests[0]


def get_unique_pull_path(action, repo, ui, source=None, default_branches=()):
    """return a unique `(path, branch)` or abort if multiple are found

    Note that for now, we cannot get multiple destination so this function is "trivial".

    The `action` parameter will be used for the error message.
    """
    if source is None:
        if b'default' in ui.paths:
            url = ui.paths[b'default'].rawloc
        else:
            # XXX this is the historical default behavior, but that is not
            # great, consider breaking BC on this.
            url = b'default'
    else:
        if source in ui.paths:
            url = ui.paths[source].rawloc
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, source)
            if path is not None:
                url = path.rawloc
            else:
                url = source
    return parseurl(url, default_branches)


def get_clone_path(ui, source, default_branches=()):
    """return the `(origsource, path, branch)` selected as clone source"""
    if source is None:
        if b'default' in ui.paths:
            url = ui.paths[b'default'].rawloc
        else:
            # XXX this is the historical default behavior, but that is not
            # great, consider breaking BC on this.
            url = b'default'
    else:
        if source in ui.paths:
            url = ui.paths[source].rawloc
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, source)
            if path is not None:
                url = path.rawloc
            else:
                url = source
    clone_path, branch = parseurl(url, default_branches)
    return url, clone_path, branch


def parseurl(path, branches=None):

        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()):
            self[name] = _chain_path(p, 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

                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
        if name in self:
            return self[name]
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, name)
            if path is None:
                raise error.RepoError(_(b'repository %s does not exist') % name)

@pathsuboption(b'pushrev', b'pushrev')
def pushrevpathoption(ui, path, value):
    return value


def _chain_path(path, ui, paths):
    """return the result of "path://" logic applied on a given path"""
    if path.url.scheme == b'path':
        assert path.url.path is None
        subpath = paths.get(path.url.host)
        if subpath is None:
            m = _(b'cannot use `%s`, "%s" is not a known path')
            m %= (path.rawloc, path.url.host)
            raise error.Abort(m)
        if subpath.raw_url.scheme == b'path':
            m = _(b'cannot use `%s`, "%s" is also defined as a `path://`')
            m %= (path.rawloc, path.url.host)
            raise error.Abort(m)
        path.url = subpath.url
        path.rawloc = subpath.rawloc
        path.loc = subpath.loc
        if path.branch is None:
            path.branch = subpath.branch
        else:
            base = path.rawloc.rsplit(b'#', 1)[0]
            path.rawloc = b'%s#%s' % (base, path.branch)
        suboptions = subpath._all_sub_opts.copy()
        suboptions.update(path._own_sub_opts)
        path._apply_suboptions(ui, suboptions)
    return path


class path(object):
    """Represents an individual path and its configuration."""

47198:7531cc34713c

    return bytes(u)


def list_paths(ui, target_path=None):
    """list all the (name, paths) in the passed ui"""
    result = []
    if target_path is None:
        for name, paths in sorted(pycompat.iteritems(ui.paths)):
            for p in paths:
                result.append((name, p))

    else:
        for path in ui.paths.get(target_path, []):
            result.append((target_path, path))
    return result


def try_path(ui, url):
    """try to build a path from a url

def get_push_paths(repo, ui, dests):
    """yields all the `path` selected as push destination by `dests`"""
    if not dests:
        if b'default-push' in ui.paths:
            for p in ui.paths[b'default-push']:
                yield p
        elif b'default' in ui.paths:
            for p in ui.paths[b'default']:
                yield p
        else:
            raise error.ConfigError(
                _(b'default repository not configured!'),
                hint=_(b"see 'hg help config.paths'"),
            )
    else:
        for dest in dests:
            if dest in ui.paths:
                for p in ui.paths[dest]:
                    yield p
            else:
                path = try_path(ui, dest)
                if path is None:
                    msg = _(b'repository %s does not exist')
                    msg %= dest

    """yields all the `(path, branch)` selected as pull source by `sources`"""
    if not sources:
        sources = [b'default']
    for source in sources:
        if source in ui.paths:
            for p in ui.paths[source]:
                yield parseurl(p.rawloc, default_branches)
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, source)
            if path is not None:
                url = path.rawloc
            else:
                url = source
            yield parseurl(url, default_branches)


def get_unique_push_path(action, repo, ui, dest=None):
    """return a unique `path` or abort if multiple are found

    if dest is None:
        dests = []
    else:
        dests = [dest]
    dests = list(get_push_paths(repo, ui, dests))
    if len(dests) != 1:
        if dest is None:
            msg = _("default path points to %d urls while %s only supports one")
            msg %= (len(dests), action)
        else:
            msg = _("path points to %d urls while %s only supports one: %s")
            msg %= (len(dests), action, dest)
        raise error.Abort(msg)
    return dests[0]


def get_unique_pull_path(action, repo, ui, source=None, default_branches=()):
    """return a unique `(path, branch)` or abort if multiple are found

    Note that for now, we cannot get multiple destination so this function is "trivial".

    The `action` parameter will be used for the error message.
    """
    urls = []
    if source is None:
        if b'default' in ui.paths:
            urls.extend(p.rawloc for p in ui.paths[b'default'])
        else:
            # XXX this is the historical default behavior, but that is not
            # great, consider breaking BC on this.
            urls.append(b'default')
    else:
        if source in ui.paths:
            urls.extend(p.rawloc for p in ui.paths[source])
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, source)
            if path is not None:
                urls.append(path.rawloc)
            else:
                urls.append(source)
    if len(urls) != 1:
        if source is None:
            msg = _("default path points to %d urls while %s only supports one")
            msg %= (len(urls), action)
        else:
            msg = _("path points to %d urls while %s only supports 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=()):
    """return the `(origsource, path, branch)` selected as clone source"""
    urls = []
    if source is None:
        if b'default' in ui.paths:
            urls.extend(p.rawloc for p in ui.paths[b'default'])
        else:
            # XXX this is the historical default behavior, but that is not
            # great, consider breaking BC on this.
            urls.append(b'default')
    else:
        if source in ui.paths:
            urls.extend(p.rawloc for p in ui.paths[source])
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, source)
            if path is not None:
                urls.append(path.rawloc)
            else:
                urls.append(source)
    if len(urls) != 1:
        if source is None:
            msg = _(
                "default path points to %d urls while only one is supported"
            )
            msg %= len(urls)
        else:
            msg = _("path points 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)
    return url, clone_path, branch


def parseurl(path, branches=None):

        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, old_paths in sorted(self.items()):
            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):
        """Return a ``path`` from a string, falling back to default.

        ``name`` can be a named path or locations. Locations are filesystem

                default = ()
            elif not isinstance(default, (tuple, list)):
                default = (default,)
            for k in default:
                try:
                    return self[k][0]
                except KeyError:
                    continue
            return None

        # Most likely empty string.
        # This may need to raise in the future.
        if not name:
            return None
        if name in self:
            return self[name][0]
        else:
            # Try to resolve as a local path or URI.
            path = try_path(ui, name)
            if path is None:
                raise error.RepoError(_(b'repository %s does not exist') % name)

@pathsuboption(b'pushrev', b'pushrev')
def pushrevpathoption(ui, path, value):
    return value


def _chain_path(base_path, ui, paths):
    """return the result of "path://" logic applied on a given path"""
    new_paths = []
    if base_path.url.scheme != b'path':
        new_paths.append(base_path)
    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 %= (base_path.rawloc, base_path.url.host)
            raise error.Abort(m)
        for subpath in sub_paths:
            path = base_path.copy()
            if subpath.raw_url.scheme == b'path':
                m = _(b'cannot use `%s`, "%s" is also defined as a `path://`')
                m %= (path.rawloc, path.url.host)
                raise error.Abort(m)
            path.url = subpath.url
            path.rawloc = subpath.rawloc
            path.loc = subpath.loc
            if path.branch is None:
                path.branch = subpath.branch
            else:
                base = path.rawloc.rsplit(b'#', 1)[0]
                path.rawloc = b'%s#%s' % (base, path.branch)
            suboptions = subpath._all_sub_opts.copy()
            suboptions.update(path._own_sub_opts)
            path._apply_suboptions(ui, suboptions)
            new_paths.append(path)
    return new_paths


class path(object):
    """Represents an individual path and its configuration."""