comparison mercurial/namespaces.py @ 23717:d8663e6153c1

namespaces: use namespace object instead of dictionary

This isn't as bad as the diff seems, it only looks like scary. In this patch,
we use the 'namespace' object instead of accessing keys in a dictionary.

This required the 'templatename' and 'names' method to change their
implementation. Later, we will remove these functions entirely due to a better
api.

23716:f4828a8f6ae9

    _names_version = 0

    def __init__(self):
        self._names = util.sortdict()

        addns = self.addnamespace

        # we need current mercurial named objects (bookmarks, tags, and
        # branches) to be initialized somewhere, so that place is here
        addns("bookmarks", "bookmark",
              lambda repo, name: tolist(repo._bookmarks.get(name)),
              lambda repo, name: repo.nodebookmarks(name))

        addns("tags", "tag",
              lambda repo, name: tolist(repo._tagscache.tags.get(name)),
              lambda repo, name: repo.nodetags(name))

        addns("branches", "branch",
              lambda repo, name: tolist(repo.branchtip(name)),
              lambda repo, node: [repo[node].branch()])

    def addnamespace(self, namespace, templatename, namemap, nodemap,
                     order=None):
        """
        register a namespace

        namespace: the name to be registered (in plural form)
        templatename: the name to use for templating
        namemap: function that inputs a node, output name(s)
        nodemap: function that inputs a name, output node(s)
        order: optional argument to specify the order of namespaces
               (e.g. 'branches' should be listed before 'bookmarks')
        """
        val = {'templatename': templatename,
               'namemap': namemap,
               'nodemap': nodemap}
        if order is not None:
            self._names.insert(order, namespace, val)
        else:
            self._names[namespace] = val

        # we only generate a template keyword if one does not already exist
        if namespace not in templatekw.keywords:
            def generatekw(**args):
                return templatekw.shownames(namespace, **args)

            templatekw.keywords[namespace] = generatekw

    def singlenode(self, repo, name):
        """
        Return the 'best' node for the given name. Best means the first node
        in the first nonempty list returned by a name-to-nodes mapping function
        in the defined precedence order.

        Raises a KeyError if there is no such node.
        """
        for ns, v in self._names.iteritems():
            n = v['namemap'](repo, name)
            if n:
                # return max revision number
                if len(n) > 1:
                    cl = repo.changelog
                    maxrev = max(cl.rev(node) for node in n)

                return n[0]
        raise KeyError(_('no such name: %s') % name)

    def templatename(self, namespace):
        """method that returns the template name of a namespace"""
        return self._names[namespace]['templatename']

    def names(self, repo, namespace, node):
        """method that returns a (sorted) list of names in a namespace that
        match a given node"""
        return sorted(self._names[namespace]['nodemap'](repo, node))

class namespace(object):
    """provides an interface to a namespace

    Namespaces are basically generic many-to-many mapping between some

23717:d8663e6153c1

    _names_version = 0

    def __init__(self):
        self._names = util.sortdict()

        # shorten the class name for less indentation
        ns = namespace

        # we need current mercurial named objects (bookmarks, tags, and
        # branches) to be initialized somewhere, so that place is here
        n = ns("bookmarks", "bookmark",
              lambda repo, name: tolist(repo._bookmarks.get(name)),
              lambda repo, name: repo.nodebookmarks(name))
        self.addnamespace(n)

        n = ns("tags", "tag",
              lambda repo, name: tolist(repo._tagscache.tags.get(name)),
              lambda repo, name: repo.nodetags(name))
        self.addnamespace(n)

        n = ns("branches", "branch",
              lambda repo, name: tolist(repo.branchtip(name)),
              lambda repo, node: [repo[node].branch()])
        self.addnamespace(n)

    def addnamespace(self, namespace, order=None):
        """
        register a namespace

        namespace: the name to be registered (in plural form)
        templatename: the name to use for templating
        namemap: function that inputs a node, output name(s)
        nodemap: function that inputs a name, output node(s)
        order: optional argument to specify the order of namespaces
               (e.g. 'branches' should be listed before 'bookmarks')
        """
        if order is not None:
            self._names.insert(order, namespace.name, namespace)
        else:
            self._names[namespace.name] = namespace

        # we only generate a template keyword if one does not already exist
        if namespace.name not in templatekw.keywords:
            def generatekw(**args):
                return templatekw.shownames(namespace.name, **args)

            templatekw.keywords[namespace.name] = generatekw

    def singlenode(self, repo, name):
        """
        Return the 'best' node for the given name. Best means the first node
        in the first nonempty list returned by a name-to-nodes mapping function
        in the defined precedence order.

        Raises a KeyError if there is no such node.
        """
        for ns, v in self._names.iteritems():
            n = v.namemap(repo, name)
            if n:
                # return max revision number
                if len(n) > 1:
                    cl = repo.changelog
                    maxrev = max(cl.rev(node) for node in n)

                return n[0]
        raise KeyError(_('no such name: %s') % name)

    def templatename(self, namespace):
        """method that returns the template name of a namespace"""
        return self._names[namespace].templatename

    def names(self, repo, namespace, node):
        """method that returns a (sorted) list of names in a namespace that
        match a given node"""
        return sorted(self._names[namespace].nodemap(repo, node))

class namespace(object):
    """provides an interface to a namespace

    Namespaces are basically generic many-to-many mapping between some