1
# Copyright (C) 2007-2010 Canonical Ltd
1
# Copyright (C) 2007-2011 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
72
72
('bzrlib.branch', 'Branch.hooks', 'BranchHooks'),
73
73
('bzrlib.bzrdir', 'BzrDir.hooks', 'BzrDirHooks'),
74
74
('bzrlib.commands', 'Command.hooks', 'CommandHooks'),
75
('bzrlib.config', 'ConfigHooks', '_ConfigHooks'),
75
76
('bzrlib.info', 'hooks', 'InfoHooks'),
76
77
('bzrlib.lock', 'Lock.hooks', 'LockHooks'),
77
78
('bzrlib.merge', 'Merger.hooks', 'MergeHooks'),
115
116
FOO hook is triggered.
119
def __init__(self, module=None, member_name=None):
120
"""Create a new hooks dictionary.
122
:param module: The module from which this hooks dictionary should be loaded
123
(used for lazy hooks)
124
:param member_name: Name under which this hooks dictionary should be loaded.
125
(used for lazy hooks)
119
127
dict.__init__(self)
120
128
self._callable_names = {}
129
self._module = module
130
self._member_name = member_name
132
def add_hook(self, name, doc, introduced, deprecated=None):
133
"""Add a hook point to this dictionary.
135
:param name: The name of the hook, for clients to use when registering.
136
:param doc: The docs for the hook.
137
:param introduced: When the hook was introduced (e.g. (0, 15)).
138
:param deprecated: When the hook was deprecated, None for
142
raise errors.DuplicateKey(name)
144
callbacks = _lazy_hooks.setdefault(
145
(self._module, self._member_name, name), [])
148
hookpoint = HookPoint(name=name, doc=doc, introduced=introduced,
149
deprecated=deprecated, callbacks=callbacks)
150
self[name] = hookpoint
152
@symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4)))
122
153
def create_hook(self, hook):
123
154
"""Create a hook which can have callbacks registered for it.
167
198
return self._callable_names.get(a_callable, "No hook name")
200
def install_named_hook_lazy(self, hook_name, callable_module,
201
callable_member, name):
202
"""Install a_callable in to the hook hook_name lazily, and label it.
204
:param hook_name: A hook name. See the __init__ method for the complete
206
:param callable_module: Name of the module in which the callable is
208
:param callable_member: Member name of the callable.
209
:param name: A name to associate the callable with, to show users what
213
hook = self[hook_name]
215
raise errors.UnknownHook(self.__class__.__name__, hook_name)
217
hook_lazy = getattr(hook, "hook_lazy")
218
except AttributeError:
219
raise errors.UnsupportedOperation(self.install_named_hook_lazy,
222
hook_lazy(callable_module, callable_member, name)
169
224
def install_named_hook(self, hook_name, a_callable, name):
170
225
"""Install a_callable in to the hook hook_name, and label it name.
172
:param hook_name: A hook name. See the __init__ method of BranchHooks
173
for the complete list of hooks.
227
:param hook_name: A hook name. See the __init__ method for the complete
174
229
:param a_callable: The callable to be invoked when the hook triggers.
175
230
The exact signature will depend on the hook - see the __init__
176
method of BranchHooks for details on each hook.
231
method for details on each hook.
177
232
:param name: A name to associate a_callable with, to show users what is
189
244
if name is not None:
190
245
self.name_hook(a_callable, name)
247
def uninstall_named_hook(self, hook_name, label):
248
"""Uninstall named hooks.
250
:param hook_name: Hook point name
251
:param label: Label of the callable to uninstall
254
hook = self[hook_name]
256
raise errors.UnknownHook(self.__class__.__name__, hook_name)
258
uninstall = getattr(hook, "uninstall")
259
except AttributeError:
260
raise errors.UnsupportedOperation(self.uninstall_named_hook, self)
192
264
def name_hook(self, a_callable, name):
193
265
"""Associate name with a_callable to show users what is running."""
194
266
self._callable_names[a_callable] = name
207
279
should describe the recommended replacement hook to register for.
210
def __init__(self, name, doc, introduced, deprecated):
282
def __init__(self, name, doc, introduced, deprecated=None, callbacks=None):
211
283
"""Create a HookPoint.
213
285
:param name: The name of the hook, for clients to use when registering.
220
292
self.__doc__ = doc
221
293
self.introduced = introduced
222
294
self.deprecated = deprecated
224
self._callback_names = {}
295
if callbacks is None:
298
self._callbacks = callbacks
227
301
"""Generate the documentation for this HookPoint.
247
321
return '\n'.join(strings)
249
323
def __eq__(self, other):
250
return (type(other) == type(self) and
251
other.__dict__ == self.__dict__)
324
return (type(other) == type(self) and other.__dict__ == self.__dict__)
326
def hook_lazy(self, callback_module, callback_member, callback_label):
327
"""Lazily register a callback to be called when this HookPoint fires.
329
:param callback_module: Module of the callable to use when this
331
:param callback_member: Member name of the callback.
332
:param callback_label: A label to show in the UI while this callback is
335
obj_getter = registry._LazyObjectGetter(callback_module,
337
self._callbacks.append((obj_getter, callback_label))
253
339
def hook(self, callback, callback_label):
254
340
"""Register a callback to be called when this HookPoint fires.
257
343
:param callback_label: A label to show in the UI while this callback is
260
self._callbacks.append(callback)
261
if callback_label is not None:
262
self._callback_names[callback] = callback_label
346
obj_getter = registry._ObjectGetter(callback)
347
self._callbacks.append((obj_getter, callback_label))
349
def uninstall(self, label):
350
"""Uninstall the callback with the specified label.
352
:param label: Label of the entry to uninstall
354
entries_to_remove = []
355
for entry in self._callbacks:
356
(entry_callback, entry_label) = entry
357
if entry_label == label:
358
entries_to_remove.append(entry)
359
if entries_to_remove == []:
360
raise KeyError("No entry with label %r" % label)
361
for entry in entries_to_remove:
362
self._callbacks.remove(entry)
264
364
def __iter__(self):
265
return iter(self._callbacks)
365
return (callback.get_obj() for callback, name in self._callbacks)
267
367
def __len__(self):
268
368
return len(self._callbacks)
272
372
strings.append("<%s(" % type(self).__name__)
273
373
strings.append(self.name)
274
374
strings.append("), callbacks=[")
275
for callback in self._callbacks:
276
strings.append(repr(callback))
375
callbacks = self._callbacks
376
for (callback, callback_name) in callbacks:
377
strings.append(repr(callback.get_obj()))
277
378
strings.append("(")
278
strings.append(self._callback_names[callback])
379
strings.append(callback_name)
279
380
strings.append("),")
280
if len(self._callbacks) == 1:
381
if len(callbacks) == 1:
281
382
strings[-1] = ")"
282
383
strings.append("]>")
283
384
return ''.join(strings)
322
423
hooks = known_hooks_key_to_object(hook_key)
323
424
segments.append(hooks.docs())
324
425
return '\n'.join(segments)
428
# Lazily registered hooks. Maps (module, name, hook_name) tuples
429
# to lists of tuples with objectgetters and names
433
def install_lazy_named_hook(hookpoints_module, hookpoints_name, hook_name,
435
"""Install a callable in to a hook lazily, and label it name.
437
:param hookpoints_module: Module name of the hook points.
438
:param hookpoints_name: Name of the hook points.
439
:param hook_name: A hook name.
440
:param callable: a callable to call for the hook.
441
:param name: A name to associate a_callable with, to show users what is
444
key = (hookpoints_module, hookpoints_name, hook_name)
445
obj_getter = registry._ObjectGetter(a_callable)
446
_lazy_hooks.setdefault(key, []).append((obj_getter, name))
added
removed
bzrlib/hooks.py
