/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/hooks.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/hooks.py
16
16
 
17
17
"""Support for plugin hooking logic."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
from . import (
20
 
    errors,
21
22
    registry,
22
23
    )
23
24
from .lazy_import import lazy_import
26
27
 
27
28
from breezy import (
28
29
    _format_version_tuple,
 
30
    errors,
29
31
    pyutils,
30
32
    )
31
33
from breezy.i18n import gettext
32
34
""")
33
35
 
34
36
 
35
 
class UnknownHook(errors.BzrError):
36
 
 
37
 
    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of breezy."
38
 
 
39
 
    def __init__(self, hook_type, hook_name):
40
 
        errors.BzrError.__init__(self)
41
 
        self.type = hook_type
42
 
        self.hook = hook_name
43
 
 
44
 
 
45
37
class KnownHooksRegistry(registry.Registry):
46
38
    # known_hooks registry contains
47
39
    # tuple of (module, member name) which is the hook point
49
41
    # callable to get the empty specific Hooks for that attribute
50
42
 
51
43
    def register_lazy_hook(self, hook_module_name, hook_member_name,
52
 
                           hook_factory_member_name):
 
44
            hook_factory_member_name):
53
45
        self.register_lazy((hook_module_name, hook_member_name),
54
 
                           hook_module_name, hook_factory_member_name)
 
46
            hook_module_name, hook_factory_member_name)
55
47
 
56
48
    def iter_parent_objects(self):
57
49
        """Yield (hook_key, (parent_object, attr)) tuples for every registered
86
78
    ('breezy.merge', 'Merger.hooks', 'MergeHooks'),
87
79
    ('breezy.msgeditor', 'hooks', 'MessageEditorHooks'),
88
80
    ('breezy.mutabletree', 'MutableTree.hooks', 'MutableTreeHooks'),
89
 
    ('breezy.bzr.smart.client', '_SmartClient.hooks', 'SmartClientHooks'),
90
 
    ('breezy.bzr.smart.server', 'SmartTCPServer.hooks', 'SmartServerHooks'),
 
81
    ('breezy.smart.client', '_SmartClient.hooks', 'SmartClientHooks'),
 
82
    ('breezy.smart.server', 'SmartTCPServer.hooks', 'SmartServerHooks'),
91
83
    ('breezy.status', 'hooks', 'StatusHooks'),
92
84
    ('breezy.transport', 'Transport.hooks', 'TransportHooks'),
93
85
    ('breezy.version_info_formats.format_rio', 'RioVersionInfoBuilder.hooks',
162
154
        hook_docs = []
163
155
        name = self.__class__.__name__
164
156
        hook_docs.append(name)
165
 
        hook_docs.append("-" * len(name))
 
157
        hook_docs.append("-"*len(name))
166
158
        hook_docs.append("")
167
159
        for hook_name in hook_names:
168
160
            hook = self[hook_name]
175
167
                strings.append("~" * len(hook_name))
176
168
                strings.append("")
177
169
                strings.append("An old-style hook. For documentation see the __init__ "
178
 
                               "method of '%s'\n" % (name,))
 
170
                    "method of '%s'\n" % (name,))
179
171
                hook_docs.extend(strings)
180
172
        return "\n".join(hook_docs)
181
173
 
196
188
            return 'No hook name'
197
189
        return name
198
190
 
 
191
 
199
192
    def install_named_hook_lazy(self, hook_name, callable_module,
200
 
                                callable_member, name):
 
193
        callable_member, name):
201
194
        """Install a_callable in to the hook hook_name lazily, and label it.
202
195
 
203
196
        :param hook_name: A hook name. See the __init__ method for the complete
211
204
        try:
212
205
            hook = self[hook_name]
213
206
        except KeyError:
214
 
            raise UnknownHook(self.__class__.__name__, hook_name)
 
207
            raise errors.UnknownHook(self.__class__.__name__, hook_name)
215
208
        try:
216
209
            hook_lazy = getattr(hook, "hook_lazy")
217
210
        except AttributeError:
218
211
            raise errors.UnsupportedOperation(self.install_named_hook_lazy,
219
 
                                              self)
 
212
                self)
220
213
        else:
221
214
            hook_lazy(callable_module, callable_member, name)
222
215
        if name is not None:
236
229
        try:
237
230
            hook = self[hook_name]
238
231
        except KeyError:
239
 
            raise UnknownHook(self.__class__.__name__, hook_name)
 
232
            raise errors.UnknownHook(self.__class__.__name__, hook_name)
240
233
        try:
241
234
            # list hooks, old-style, not yet deprecated but less useful.
242
235
            hook.append(a_callable)
254
247
        try:
255
248
            hook = self[hook_name]
256
249
        except KeyError:
257
 
            raise UnknownHook(self.__class__.__name__, hook_name)
 
250
            raise errors.UnknownHook(self.__class__.__name__, hook_name)
258
251
        try:
259
252
            uninstall = getattr(hook, "uninstall")
260
253
        except AttributeError:
267
260
        self._callable_names[a_callable] = name
268
261
 
269
262
    def name_hook_lazy(self, callable_module, callable_member, callable_name):
270
 
        self._lazy_callable_names[(callable_module, callable_member)] = \
 
263
        self._lazy_callable_names[(callable_module, callable_member)]= \
271
264
            callable_name
272
265
 
273
266
 
309
302
        """
310
303
        strings = []
311
304
        strings.append(self.name)
312
 
        strings.append('~' * len(self.name))
 
305
        strings.append('~'*len(self.name))
313
306
        strings.append('')
314
307
        if self.introduced:
315
308
            introduced_string = _format_version_tuple(self.introduced)
321
314
            strings.append(gettext('Deprecated in: %s') % deprecated_string)
322
315
        strings.append('')
323
316
        strings.extend(textwrap.wrap(self.__doc__,
324
 
                                     break_long_words=False))
 
317
            break_long_words=False))
325
318
        strings.append('')
326
319
        return '\n'.join(strings)
327
320
 
338
331
            processing.
339
332
        """
340
333
        obj_getter = registry._LazyObjectGetter(callback_module,
341
 
                                                callback_member)
 
334
            callback_member)
342
335
        self._callbacks.append((obj_getter, callback_label))
343
336
 
344
337
    def hook(self, callback, callback_label):
390
383
 
391
384
 
392
385
_help_prefix = \
393
 
    """
 
386
"""
394
387
Hooks
395
388
=====
396
389
 
422
415
 
423
416
"""
424
417
 
425
 
 
426
418
def hooks_help_text(topic):
427
419
    segments = [_help_prefix]
428
420
    for hook_key in sorted(known_hooks.keys()):
437
429
 
438
430
 
439
431
def install_lazy_named_hook(hookpoints_module, hookpoints_name, hook_name,
440
 
                            a_callable, name):
 
432
    a_callable, name):
441
433
    """Install a callable in to a hook lazily, and label it name.
442
434
 
443
435
    :param hookpoints_module: Module name of the hook points.