← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/hooks.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/hooks.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
17
"""Support for plugin hooking logic."""
19
18
 
 
19
from __future__ import absolute_import
 
20
 
20
21
from bzrlib import (
21
22
    registry,
22
23
    symbol_versioning,
30
31
    errors,
31
32
    pyutils,
32
33
    )
 
34
from bzrlib.i18n import gettext
33
35
""")
34
36
 
35
37
 
70
72
 
71
73
_builtin_known_hooks = (
72
74
    ('bzrlib.branch', 'Branch.hooks', 'BranchHooks'),
73
 
    ('bzrlib.bzrdir', 'BzrDir.hooks', 'BzrDirHooks'),
 
75
    ('bzrlib.controldir', 'ControlDir.hooks', 'ControlDirHooks'),
74
76
    ('bzrlib.commands', 'Command.hooks', 'CommandHooks'),
75
77
    ('bzrlib.config', 'ConfigHooks', '_ConfigHooks'),
76
78
    ('bzrlib.info', 'hooks', 'InfoHooks'),
81
83
    ('bzrlib.smart.client', '_SmartClient.hooks', 'SmartClientHooks'),
82
84
    ('bzrlib.smart.server', 'SmartTCPServer.hooks', 'SmartServerHooks'),
83
85
    ('bzrlib.status', 'hooks', 'StatusHooks'),
 
86
    ('bzrlib.transport', 'Transport.hooks', 'TransportHooks'),
84
87
    ('bzrlib.version_info_formats.format_rio', 'RioVersionInfoBuilder.hooks',
85
88
        'RioVersionInfoBuilderHooks'),
86
89
    ('bzrlib.merge_directive', 'BaseMergeDirective.hooks',
103
106
    return pyutils.get_named_object(module_name, member_name)
104
107
 
105
108
 
106
 
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3)))
107
 
def known_hooks_key_to_parent_and_attribute(key):
108
 
    """See KnownHooksRegistry.key_to_parent_and_attribute."""
109
 
    return known_hooks.key_to_parent_and_attribute(key)
110
 
 
111
 
 
112
109
class Hooks(dict):
113
110
    """A dictionary mapping hook name to a list of callables.
114
111
 
126
123
        """
127
124
        dict.__init__(self)
128
125
        self._callable_names = {}
 
126
        self._lazy_callable_names = {}
129
127
        self._module = module
130
128
        self._member_name = member_name
131
129
 
149
147
                              deprecated=deprecated, callbacks=callbacks)
150
148
        self[name] = hookpoint
151
149
 
152
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4)))
153
 
    def create_hook(self, hook):
154
 
        """Create a hook which can have callbacks registered for it.
155
 
 
156
 
        :param hook: The hook to create. An object meeting the protocol of
157
 
            bzrlib.hooks.HookPoint. It's name is used as the key for future
158
 
            lookups.
159
 
        """
160
 
        if hook.name in self:
161
 
            raise errors.DuplicateKey(hook.name)
162
 
        self[hook.name] = hook
163
 
 
164
150
    def docs(self):
165
151
        """Generate the documentation for this Hooks instance.
166
152
 
195
181
        the code names are rarely meaningful for end users and this is not
196
182
        intended for debugging.
197
183
        """
198
 
        return self._callable_names.get(a_callable, "No hook name")
 
184
        name = self._callable_names.get(a_callable, None)
 
185
        if name is None and a_callable is not None:
 
186
            name = self._lazy_callable_names.get((a_callable.__module__,
 
187
                                                  a_callable.__name__),
 
188
                                                 None)
 
189
        if name is None:
 
190
            return 'No hook name'
 
191
        return name
 
192
 
199
193
 
200
194
    def install_named_hook_lazy(self, hook_name, callable_module,
201
195
        callable_member, name):
220
214
                self)
221
215
        else:
222
216
            hook_lazy(callable_module, callable_member, name)
 
217
        if name is not None:
 
218
            self.name_hook_lazy(callable_module, callable_member, name)
223
219
 
224
220
    def install_named_hook(self, hook_name, a_callable, name):
225
221
        """Install a_callable in to the hook hook_name, and label it name.
265
261
        """Associate name with a_callable to show users what is running."""
266
262
        self._callable_names[a_callable] = name
267
263
 
 
264
    def name_hook_lazy(self, callable_module, callable_member, callable_name):
 
265
        self._lazy_callable_names[(callable_module, callable_member)]= \
 
266
            callable_name
 
267
 
268
268
 
269
269
class HookPoint(object):
270
270
    """A single hook that clients can register to be called back when it fires.
310
310
            introduced_string = _format_version_tuple(self.introduced)
311
311
        else:
312
312
            introduced_string = 'unknown'
313
 
        strings.append('Introduced in: %s' % introduced_string)
 
313
        strings.append(gettext('Introduced in: %s') % introduced_string)
314
314
        if self.deprecated:
315
315
            deprecated_string = _format_version_tuple(self.deprecated)
316
 
            strings.append('Deprecated in: %s' % deprecated_string)
 
316
            strings.append(gettext('Deprecated in: %s') % deprecated_string)
317
317
        strings.append('')
318
318
        strings.extend(textwrap.wrap(self.__doc__,
319
319
            break_long_words=False))