mercurial/pushkey.py

ui: refactor `readconfig()` into a form that can consume resources

The old form can't completely go away, because files outside of packages still
need to be read.  The name passed in here is a tuple of `package name, resource`
as needed by the resource API.

I like the idea of stating the config file is embedded in the executable by
listing is as `exe!package.resource`.  This would be consistent with how
`debuginstall` points to the executable for the python executable, lib, and
installed modules.  While in practice the filesystem path is available from the
backing ResourceReader when the resource is opened, it is a relative path on py2
and absolute on py3.  Further, while this would show in the `hg config` output
for each option if set as such here, it doesn't show in the `reading from...`
line when `--debug` is used.  The file isn't actually open where that prints, so
there's no way I see to get that info there.  So I opted for the simple prefix
to distinguish resources from files.

Differential Revision: https://phab.mercurial-scm.org/D7775

# pushkey.py - dispatching for pushing and pulling keys
#
# Copyright 2010 Matt Mackall <[e-mail]>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

from . import (
    bookmarks,
    encoding,
    obsolete,
    phases,
)


def _nslist(repo):
    n = {}
    for k in _namespaces:
        n[k] = b""
    if not obsolete.isenabled(repo, obsolete.exchangeopt):
        n.pop(b'obsolete')
    return n


_namespaces = {
    b"namespaces": (lambda *x: False, _nslist),
    b"bookmarks": (bookmarks.pushbookmark, bookmarks.listbookmarks),
    b"phases": (phases.pushphase, phases.listphases),
    b"obsolete": (obsolete.pushmarker, obsolete.listmarkers),
}


def register(namespace, pushkey, listkeys):
    _namespaces[namespace] = (pushkey, listkeys)


def _get(namespace):
    return _namespaces.get(namespace, (lambda *x: False, lambda *x: {}))


def push(repo, namespace, key, old, new):
    '''should succeed iff value was old'''
    pk = _get(namespace)[0]
    return pk(repo, key, old, new)


def list(repo, namespace):
    '''return a dict'''
    lk = _get(namespace)[1]
    return lk(repo)


encode = encoding.fromlocal

decode = encoding.tolocal


def encodekeys(keys):
    """encode the content of a pushkey namespace for exchange over the wire"""
    return b'\n'.join([b'%s\t%s' % (encode(k), encode(v)) for k, v in keys])


def decodekeys(data):
    """decode the content of a pushkey namespace from exchange over the wire"""
    result = {}
    for l in data.splitlines():
        k, v = l.split(b'\t')
        result[decode(k)] = decode(v)
    return result