/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: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

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
 
 
21
 
from bzrlib.pyutils import get_named_object
 
19
from .pyutils import get_named_object
22
20
 
23
21
 
24
22
class _ObjectGetter(object):
102
100
        self._default_key = None
103
101
        # Map from key => (is_lazy, info)
104
102
        self._dict = {}
 
103
        self._aliases = {}
105
104
        self._help_dict = {}
106
105
        self._info_dict = {}
107
106
 
 
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
 
108
117
    def register(self, key, obj, help=None, info=None,
109
118
                 override_existing=False):
110
119
        """Register a new object to a name.
152
161
        self._dict[key] = _LazyObjectGetter(module_name, member_name)
153
162
        self._add_help_and_info(key, help=help, info=info)
154
163
 
 
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
 
155
178
    def _add_help_and_info(self, key, help=None, info=None):
156
179
        """Add the help and information about this key"""
157
180
        self._help_dict[key] = help
227
250
 
228
251
    def keys(self):
229
252
        """Get a list of registered entries"""
230
 
        return sorted(self._dict.keys())
 
253
        return sorted(self._dict)
231
254
 
232
255
    def iteritems(self):
233
 
        for key, getter in self._dict.iteritems():
234
 
            yield key, getter.get_obj()
 
256
        for key in self._dict:
 
257
            yield key, self._dict[key].get_obj()
235
258
 
236
259
    def items(self):
237
260
        # We should not use the iteritems() implementation below (see bug
238
261
        # #430510)
239
 
        return sorted([(key, getter.get_obj())
240
 
                       for key, getter in self._dict.items()])
 
262
        return [(key, self._dict[key].get_obj()) for key in self.keys()]
241
263
 
242
264
    def _set_default_key(self, key):
243
 
        if not self._dict.has_key(key):
 
265
        if key not in self._dict:
244
266
            raise KeyError('No object registered under key %s.' % key)
245
267
        else:
246
268
            self._default_key = key
249
271
        return self._default_key
250
272
 
251
273
    default_key = property(_get_default_key, _set_default_key,
252
 
                            doc="Current value of the default key."
253
 
                                " Can be set to any existing key.")
 
274
                           doc="Current value of the default key."
 
275
                           " Can be set to any existing key.")
254
276
 
255
277
 
256
278
class FormatRegistry(Registry):
263
285
    def register(self, key, obj, help=None, info=None,
264
286
                 override_existing=False):
265
287
        Registry.register(self, key, obj, help=help, info=info,
266
 
            override_existing=override_existing)
 
288
                          override_existing=override_existing)
267
289
        if self._other_registry is not None:
268
290
            self._other_registry.register(key, obj, help=help,
269
 
                info=info, override_existing=override_existing)
 
291
                                          info=info, override_existing=override_existing)
270
292
 
271
293
    def register_lazy(self, key, module_name, member_name,
272
294
                      help=None, info=None,
274
296
        # Overridden to allow capturing registrations to two seperate
275
297
        # registries in a single call.
276
298
        Registry.register_lazy(self, key, module_name, member_name,
277
 
                help=help, info=info, override_existing=override_existing)
 
299
                               help=help, info=info, override_existing=override_existing)
278
300
        if self._other_registry is not None:
279
301
            self._other_registry.register_lazy(key, module_name, member_name,
280
 
                help=help, info=info, override_existing=override_existing)
 
302
                                               help=help, info=info, override_existing=override_existing)
281
303
 
282
304
    def remove(self, key):
283
305
        Registry.remove(self, key)