/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 bzrlib/plugin.py

Fix some bit of fetching.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugin.py
1
 
# Copyright (C) 2004, 2005, 2007 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
"""bzr python plugin support.
19
 
 
20
 
When load_plugins() is invoked, any python module in any directory in
21
 
$BZR_PLUGIN_PATH will be imported.  The module will be imported as
22
 
'bzrlib.plugins.$BASENAME(PLUGIN)'.  In the plugin's main body, it should
23
 
update any bzrlib registries it wants to extend; for example, to add new
24
 
commands, import bzrlib.commands and add your new command to the plugin_cmds
25
 
variable.
26
 
 
27
 
BZR_PLUGIN_PATH is also honoured for any plugins imported via
28
 
'import bzrlib.plugins.PLUGINNAME', as long as set_plugins_path has been 
29
 
called.
30
 
"""
31
 
 
32
 
import os
33
 
import sys
34
 
 
35
 
from bzrlib.lazy_import import lazy_import
36
 
lazy_import(globals(), """
37
 
import imp
38
 
import re
39
 
import types
40
 
import zipfile
41
 
 
42
 
from bzrlib import (
43
 
    config,
44
 
    osutils,
45
 
    )
46
 
from bzrlib import plugins as _mod_plugins
47
 
""")
48
 
 
49
 
from bzrlib.symbol_versioning import deprecated_function, zero_ninetyone
50
 
from bzrlib.trace import mutter, warning, log_exception_quietly
51
 
 
52
 
 
53
 
DEFAULT_PLUGIN_PATH = None
54
 
_loaded = False
55
 
 
56
 
def get_default_plugin_path():
57
 
    """Get the DEFAULT_PLUGIN_PATH"""
58
 
    global DEFAULT_PLUGIN_PATH
59
 
    if DEFAULT_PLUGIN_PATH is None:
60
 
        DEFAULT_PLUGIN_PATH = osutils.pathjoin(config.config_dir(), 'plugins')
61
 
    return DEFAULT_PLUGIN_PATH
62
 
 
63
 
 
64
 
@deprecated_function(zero_ninetyone)
65
 
def all_plugins():
66
 
    """Return a dictionary of the plugins."""
67
 
    return dict((name, plugin.module) for name, plugin in plugins().items())
68
 
 
69
 
 
70
 
def disable_plugins():
71
 
    """Disable loading plugins.
72
 
 
73
 
    Future calls to load_plugins() will be ignored.
74
 
    """
75
 
    # TODO: jam 20060131 This should probably also disable
76
 
    #       load_from_dirs()
77
 
    global _loaded
78
 
    _loaded = True
79
 
 
80
 
def _strip_trailing_sep(path):
81
 
    return path.rstrip("\\/")
82
 
 
83
 
def set_plugins_path():
84
 
    """Set the path for plugins to be loaded from."""
85
 
    path = os.environ.get('BZR_PLUGIN_PATH',
86
 
                          get_default_plugin_path()).split(os.pathsep)
87
 
    # Get rid of trailing slashes, since Python can't handle them when
88
 
    # it tries to import modules.
89
 
    path = map(_strip_trailing_sep, path)
90
 
    # search the plugin path before the bzrlib installed dir
91
 
    path.append(os.path.dirname(_mod_plugins.__file__))
92
 
    _mod_plugins.__path__ = path
93
 
    return path
94
 
 
95
 
 
96
 
def load_plugins():
97
 
    """Load bzrlib plugins.
98
 
 
99
 
    The environment variable BZR_PLUGIN_PATH is considered a delimited
100
 
    set of paths to look through. Each entry is searched for *.py
101
 
    files (and whatever other extensions are used in the platform,
102
 
    such as *.pyd).
103
 
 
104
 
    load_from_dirs() provides the underlying mechanism and is called with
105
 
    the default directory list to provide the normal behaviour.
106
 
    """
107
 
    global _loaded
108
 
    if _loaded:
109
 
        # People can make sure plugins are loaded, they just won't be twice
110
 
        return
111
 
    _loaded = True
112
 
 
113
 
    # scan for all plugins in the path.
114
 
    load_from_path(set_plugins_path())
115
 
 
116
 
 
117
 
def load_from_path(dirs):
118
 
    """Load bzrlib plugins found in each dir in dirs.
119
 
 
120
 
    Loading a plugin means importing it into the python interpreter.
121
 
    The plugin is expected to make calls to register commands when
122
 
    it's loaded (or perhaps access other hooks in future.)
123
 
 
124
 
    Plugins are loaded into bzrlib.plugins.NAME, and can be found there
125
 
    for future reference.
126
 
 
127
 
    The python module path for bzrlib.plugins will be modified to be 'dirs'.
128
 
    """
129
 
    # We need to strip the trailing separators here as well as in the
130
 
    # set_plugins_path function because calling code can pass anything in to
131
 
    # this function, and since it sets plugins.__path__, it should set it to
132
 
    # something that will be valid for Python to use (in case people try to
133
 
    # run "import bzrlib.plugins.PLUGINNAME" after calling this function).
134
 
    _mod_plugins.__path__ = map(_strip_trailing_sep, dirs)
135
 
    for d in dirs:
136
 
        if not d:
137
 
            continue
138
 
        mutter('looking for plugins in %s', d)
139
 
        if os.path.isdir(d):
140
 
            load_from_dir(d)
141
 
        else:
142
 
            # it might be a zip: try loading from the zip.
143
 
            load_from_zip(d)
144
 
            continue
145
 
 
146
 
 
147
 
# backwards compatability: load_from_dirs was the old name
148
 
# This was changed in 0.15
149
 
load_from_dirs = load_from_path
150
 
 
151
 
 
152
 
def load_from_dir(d):
153
 
    """Load the plugins in directory d."""
154
 
    # Get the list of valid python suffixes for __init__.py?
155
 
    # this includes .py, .pyc, and .pyo (depending on if we are running -O)
156
 
    # but it doesn't include compiled modules (.so, .dll, etc)
157
 
    valid_suffixes = [suffix for suffix, mod_type, flags in imp.get_suffixes()
158
 
                              if flags in (imp.PY_SOURCE, imp.PY_COMPILED)]
159
 
    package_entries = ['__init__'+suffix for suffix in valid_suffixes]
160
 
    plugin_names = set()
161
 
    for f in os.listdir(d):
162
 
        path = osutils.pathjoin(d, f)
163
 
        if os.path.isdir(path):
164
 
            for entry in package_entries:
165
 
                # This directory should be a package, and thus added to
166
 
                # the list
167
 
                if os.path.isfile(osutils.pathjoin(path, entry)):
168
 
                    break
169
 
            else: # This directory is not a package
170
 
                continue
171
 
        else:
172
 
            for suffix_info in imp.get_suffixes():
173
 
                if f.endswith(suffix_info[0]):
174
 
                    f = f[:-len(suffix_info[0])]
175
 
                    if suffix_info[2] == imp.C_EXTENSION and f.endswith('module'):
176
 
                        f = f[:-len('module')]
177
 
                    break
178
 
            else:
179
 
                continue
180
 
        if getattr(_mod_plugins, f, None):
181
 
            mutter('Plugin name %s already loaded', f)
182
 
        else:
183
 
            # mutter('add plugin name %s', f)
184
 
            plugin_names.add(f)
185
 
    
186
 
    for name in plugin_names:
187
 
        try:
188
 
            exec "import bzrlib.plugins.%s" % name in {}
189
 
        except KeyboardInterrupt:
190
 
            raise
191
 
        except Exception, e:
192
 
            ## import pdb; pdb.set_trace()
193
 
            if re.search('\.|-| ', name):
194
 
                sanitised_name = re.sub('[-. ]', '_', name)
195
 
                warning("Unable to load %r in %r as a plugin because file path"
196
 
                        " isn't a valid module name; try renaming it to %r."
197
 
                        % (name, d, sanitised_name))
198
 
            else:
199
 
                warning('Unable to load plugin %r from %r' % (name, d))
200
 
            log_exception_quietly()
201
 
 
202
 
 
203
 
def load_from_zip(zip_name):
204
 
    """Load all the plugins in a zip."""
205
 
    valid_suffixes = ('.py', '.pyc', '.pyo')    # only python modules/packages
206
 
                                                # is allowed
207
 
 
208
 
    try:
209
 
        index = zip_name.rindex('.zip')
210
 
    except ValueError:
211
 
        return
212
 
    archive = zip_name[:index+4]
213
 
    prefix = zip_name[index+5:]
214
 
 
215
 
    mutter('Looking for plugins in %r', zip_name)
216
 
 
217
 
    # use zipfile to get list of files/dirs inside zip
218
 
    try:
219
 
        z = zipfile.ZipFile(archive)
220
 
        namelist = z.namelist()
221
 
        z.close()
222
 
    except zipfile.error:
223
 
        # not a valid zip
224
 
        return
225
 
 
226
 
    if prefix:
227
 
        prefix = prefix.replace('\\','/')
228
 
        if prefix[-1] != '/':
229
 
            prefix += '/'
230
 
        ix = len(prefix)
231
 
        namelist = [name[ix:]
232
 
                    for name in namelist
233
 
                    if name.startswith(prefix)]
234
 
 
235
 
    mutter('Names in archive: %r', namelist)
236
 
    
237
 
    for name in namelist:
238
 
        if not name or name.endswith('/'):
239
 
            continue
240
 
    
241
 
        # '/' is used to separate pathname components inside zip archives
242
 
        ix = name.rfind('/')
243
 
        if ix == -1:
244
 
            head, tail = '', name
245
 
        else:
246
 
            head, tail = name.rsplit('/',1)
247
 
        if '/' in head:
248
 
            # we don't need looking in subdirectories
249
 
            continue
250
 
    
251
 
        base, suffix = osutils.splitext(tail)
252
 
        if suffix not in valid_suffixes:
253
 
            continue
254
 
    
255
 
        if base == '__init__':
256
 
            # package
257
 
            plugin_name = head
258
 
        elif head == '':
259
 
            # module
260
 
            plugin_name = base
261
 
        else:
262
 
            continue
263
 
    
264
 
        if not plugin_name:
265
 
            continue
266
 
        if getattr(_mod_plugins, plugin_name, None):
267
 
            mutter('Plugin name %s already loaded', plugin_name)
268
 
            continue
269
 
    
270
 
        try:
271
 
            exec "import bzrlib.plugins.%s" % plugin_name in {}
272
 
            mutter('Load plugin %s from zip %r', plugin_name, zip_name)
273
 
        except KeyboardInterrupt:
274
 
            raise
275
 
        except Exception, e:
276
 
            ## import pdb; pdb.set_trace()
277
 
            warning('Unable to load plugin %r from %r'
278
 
                    % (name, zip_name))
279
 
            log_exception_quietly()
280
 
 
281
 
 
282
 
def plugins():
283
 
    """Return a dictionary of the plugins.
284
 
    
285
 
    Each item in the dictionary is a PlugIn object.
286
 
    """
287
 
    result = {}
288
 
    for name, plugin in _mod_plugins.__dict__.items():
289
 
        if isinstance(plugin, types.ModuleType):
290
 
            result[name] = PlugIn(name, plugin)
291
 
    return result
292
 
 
293
 
 
294
 
class PluginsHelpIndex(object):
295
 
    """A help index that returns help topics for plugins."""
296
 
 
297
 
    def __init__(self):
298
 
        self.prefix = 'plugins/'
299
 
 
300
 
    def get_topics(self, topic):
301
 
        """Search for topic in the loaded plugins.
302
 
 
303
 
        This will not trigger loading of new plugins.
304
 
 
305
 
        :param topic: A topic to search for.
306
 
        :return: A list which is either empty or contains a single
307
 
            RegisteredTopic entry.
308
 
        """
309
 
        if not topic:
310
 
            return []
311
 
        if topic.startswith(self.prefix):
312
 
            topic = topic[len(self.prefix):]
313
 
        plugin_module_name = 'bzrlib.plugins.%s' % topic
314
 
        try:
315
 
            module = sys.modules[plugin_module_name]
316
 
        except KeyError:
317
 
            return []
318
 
        else:
319
 
            return [ModuleHelpTopic(module)]
320
 
 
321
 
 
322
 
class ModuleHelpTopic(object):
323
 
    """A help topic which returns the docstring for a module."""
324
 
 
325
 
    def __init__(self, module):
326
 
        """Constructor.
327
 
 
328
 
        :param module: The module for which help should be generated.
329
 
        """
330
 
        self.module = module
331
 
 
332
 
    def get_help_text(self, additional_see_also=None):
333
 
        """Return a string with the help for this topic.
334
 
 
335
 
        :param additional_see_also: Additional help topics to be
336
 
            cross-referenced.
337
 
        """
338
 
        if not self.module.__doc__:
339
 
            result = "Plugin '%s' has no docstring.\n" % self.module.__name__
340
 
        else:
341
 
            result = self.module.__doc__
342
 
        if result[-1] != '\n':
343
 
            result += '\n'
344
 
        # there is code duplicated here and in bzrlib/help_topic.py's 
345
 
        # matching Topic code. This should probably be factored in
346
 
        # to a helper function and a common base class.
347
 
        if additional_see_also is not None:
348
 
            see_also = sorted(set(additional_see_also))
349
 
        else:
350
 
            see_also = None
351
 
        if see_also:
352
 
            result += 'See also: '
353
 
            result += ', '.join(see_also)
354
 
            result += '\n'
355
 
        return result
356
 
 
357
 
    def get_help_topic(self):
358
 
        """Return the modules help topic - its __name__ after bzrlib.plugins.."""
359
 
        return self.module.__name__[len('bzrlib.plugins.'):]
360
 
 
361
 
 
362
 
class PlugIn(object):
363
 
    """The bzrlib representation of a plugin.
364
 
 
365
 
    The PlugIn object provides a way to manipulate a given plugin module.
366
 
    """
367
 
 
368
 
    def __init__(self, name, module):
369
 
        """Construct a plugin for module."""
370
 
        self.name = name
371
 
        self.module = module
372
 
 
373
 
    def path(self):
374
 
        """Get the path that this plugin was loaded from."""
375
 
        if getattr(self.module, '__path__', None) is not None:
376
 
            return os.path.abspath(self.module.__path__[0])
377
 
        elif getattr(self.module, '__file__', None) is not None:
378
 
            return os.path.abspath(self.module.__file__)
379
 
        else:
380
 
            return repr(self.module)
381
 
 
382
 
    def __str__(self):
383
 
        return "<%s.%s object at %s, name=%s, module=%s>" % (
384
 
            self.__class__.__module__, self.__class__.__name__, id(self),
385
 
            self.name, self.module)
386
 
 
387
 
    __repr__ = __str__
388
 
 
389
 
    def test_suite(self):
390
 
        """Return the plugin's test suite."""
391
 
        if getattr(self.module, 'test_suite', None) is not None:
392
 
            return self.module.test_suite()
393
 
        else:
394
 
            return None
395
 
 
396
 
    def version_info(self):
397
 
        """Return the plugin's version_tuple or None if unknown."""
398
 
        version_info = getattr(self.module, 'version_info', None)
399
 
        if version_info is not None and len(version_info) == 3:
400
 
            version_info = tuple(version_info) + ('final', 0)
401
 
        return version_info
402
 
    
403
 
    def _get__version__(self):
404
 
        version_info = self.version_info()
405
 
        if version_info is None:
406
 
            return "unknown"
407
 
        if version_info[3] == 'final':
408
 
            version_string = '%d.%d.%d' % version_info[:3]
409
 
        else:
410
 
            version_string = '%d.%d.%d%s%d' % version_info
411
 
        return version_string
412
 
 
413
 
    __version__ = property(_get__version__)