/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/registry.py

  • Committer: Jelmer Vernooij
  • Date: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/registry.py
16
16
 
17
17
"""Classes to provide name-to-object registry-like support."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
from .pyutils import get_named_object
20
22
 
21
23
 
100
102
        self._default_key = None
101
103
        # Map from key => (is_lazy, info)
102
104
        self._dict = {}
103
 
        self._aliases = {}
104
105
        self._help_dict = {}
105
106
        self._info_dict = {}
106
107
 
107
 
    def aliases(self):
108
 
        """Return a set of the format names which are aliases."""
109
 
        return dict(self._aliases.items())
110
 
 
111
 
    def alias_map(self):
112
 
        ret = {}
113
 
        for alias, target in self._aliases.items():
114
 
            ret.setdefault(target, []).append(alias)
115
 
        return ret
116
 
 
117
108
    def register(self, key, obj, help=None, info=None,
118
109
                 override_existing=False):
119
110
        """Register a new object to a name.
161
152
        self._dict[key] = _LazyObjectGetter(module_name, member_name)
162
153
        self._add_help_and_info(key, help=help, info=info)
163
154
 
164
 
    def register_alias(self, key, target, info=None):
165
 
        """Register an alias.
166
 
 
167
 
        :param key: Alias name
168
 
        :param target: Target key name
169
 
        """
170
 
        if key in self._dict and key not in self._aliases:
171
 
            raise KeyError('Key %r already registered and not an alias' % key)
172
 
        self._dict[key] = self._dict[target]
173
 
        self._aliases[key] = target
174
 
        if info is None:
175
 
            info = self._info_dict[target]
176
 
        self._add_help_and_info(key, help=self._help_dict[target], info=info)
177
 
 
178
155
    def _add_help_and_info(self, key, help=None, info=None):
179
156
        """Add the help and information about this key"""
180
157
        self._help_dict[key] = help
271
248
        return self._default_key
272
249
 
273
250
    default_key = property(_get_default_key, _set_default_key,
274
 
                           doc="Current value of the default key."
275
 
                           " Can be set to any existing key.")
 
251
                            doc="Current value of the default key."
 
252
                                " Can be set to any existing key.")
276
253
 
277
254
 
278
255
class FormatRegistry(Registry):
285
262
    def register(self, key, obj, help=None, info=None,
286
263
                 override_existing=False):
287
264
        Registry.register(self, key, obj, help=help, info=info,
288
 
                          override_existing=override_existing)
 
265
            override_existing=override_existing)
289
266
        if self._other_registry is not None:
290
267
            self._other_registry.register(key, obj, help=help,
291
 
                                          info=info, override_existing=override_existing)
 
268
                info=info, override_existing=override_existing)
292
269
 
293
270
    def register_lazy(self, key, module_name, member_name,
294
271
                      help=None, info=None,
296
273
        # Overridden to allow capturing registrations to two seperate
297
274
        # registries in a single call.
298
275
        Registry.register_lazy(self, key, module_name, member_name,
299
 
                               help=help, info=info, override_existing=override_existing)
 
276
                help=help, info=info, override_existing=override_existing)
300
277
        if self._other_registry is not None:
301
278
            self._other_registry.register_lazy(key, module_name, member_name,
302
 
                                               help=help, info=info, override_existing=override_existing)
 
279
                help=help, info=info, override_existing=override_existing)
303
280
 
304
281
    def remove(self, key):
305
282
        Registry.remove(self, key)