~bzr-pqm/bzr/bzr.dev

*** added file 'bzrlib/plugin.py'
--- /dev/null
+++ bzrlib/plugin.py
@@ -0,0 +1,92 @@
+# Copyright (C) 2004, 2005 by Canonical Ltd
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+# This module implements plug-in support.
+# Any python module in $BZR_PLUGIN_PATH will be imported upon initialization
+# of bzrlib (and then forgotten about).  In the plugin's main body, it should
+# update any bzrlib registries it wants to extend; for example, to add new
+# commands, import bzrlib.commands and add your new command to the
+# plugin_cmds variable.
+
+import sys, os, imp
+try:
+    set
+except NameError:
+    from sets import Set as set
+from bzrlib.trace import log_error
+
+
+def load_plugins():
+    """Find all python files which are plugins, and load them
+
+    The environment variable BZR_PLUGIN_PATH is considered a delimited set of
+    paths to look through. Each entry is searched for *.py files (and whatever
+    other extensions are used in the platform, such as *.pyd).
+    """
+    bzrpath = os.environ.get('BZR_PLUGIN_PATH', os.path.expanduser('~/.bzr/plugins'))
+
+    # The problem with imp.get_suffixes() is that it doesn't include
+    # .pyo which is technically valid
+    # It also means that "testmodule.so" will show up as both test and testmodule
+    # though it is only valid as 'test'
+    # but you should be careful, because "testmodule.py" loads as testmodule.
+    suffixes = imp.get_suffixes()
+    suffixes.append(('.pyo', 'rb', imp.PY_COMPILED))
+    package_entries = ['__init__.py', '__init__.pyc', '__init__.pyo']
+    for d in bzrpath.split(os.pathsep):
+        # going trough them one by one allows different plugins with the same
+        # filename in different directories in the path
+        if not d:
+            continue
+        plugin_names = set()
+        if not os.path.isdir(d):
+            continue
+        for f in os.listdir(d):
+            path = os.path.join(d, f)
+            if os.path.isdir(path):
+                for entry in package_entries:
+                    # This directory should be a package, and thus added to
+                    # the list
+                    if os.path.isfile(os.path.join(path, entry)):
+                        break
+                else: # This directory is not a package
+                    continue
+            else:
+                for suffix_info in suffixes:
+                    if f.endswith(suffix_info[0]):
+                        f = f[:-len(suffix_info[0])]
+                        if suffix_info[2] == imp.C_EXTENSION and f.endswith('module'):
+                            f = f[:-len('module')]
+                        break
+                else:
+                    continue
+            plugin_names.add(f)
+
+        plugin_names = list(plugin_names)
+        plugin_names.sort()
+        for name in plugin_names:
+            try:
+                plugin_info = imp.find_module(name, [d])
+                try:
+                    plugin = imp.load_module('bzrlib.plugin.' + name,
+                                             *plugin_info)
+                finally:
+                    if plugin_info[0] is not None:
+                        plugin_info[0].close()
+            except Exception, e:
+                log_error('Unable to load plugin: %r from %r\n%s' % (name, d, e))
+

*** modified file 'bzrlib/__init__.py'
--- bzrlib/__init__.py
+++ bzrlib/__init__.py
@@ -23,6 +23,7@@
 from diff import compare_trees
 from trace import mutter, warning, open_tracefile
 from log import show_log
+from plugin import load_plugins
 import add

 BZRDIR = ".bzr"
@@ -62,4 +63,4 @@
             return None
     except BzrError:
         return None
-
+

*** modified file 'bzrlib/commands.py'
--- bzrlib/commands.py
+++ bzrlib/commands.py
@@ -24,6 +24,24 @@
 from bzrlib.osutils import quotefn
 from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
      format_date
+
+
+plugin_cmds = {}
+
+
+def register_plugin_command(cmd):
+    "Utility function to help register a command"
+    global plugin_cmds
+    k = cmd.__name__
+    if k.startswith("cmd_"):
+        k_unsquished = _unsquish_command_name(k)
+    else:
+        k_unsquished = k
+    if not plugin_cmds.has_key(k_unsquished):
+        plugin_cmds[k_unsquished] = cmd
+    else:
+        log_error('Two plugins defined the same command: %r' % k)
+        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])


 def _squish_command_name(cmd):
@@ -68,100 +86,34 @@
         revs = int(revstr)
     return revs

-def _find_plugins():
-    """Find all python files which are plugins, and load their commands
-    to add to the list of "all commands"
-
-    The environment variable BZRPATH is considered a delimited set of
-    paths to look through. Each entry is searched for *.py files.
-    If a directory is found, it is also searched, but they are
-    not searched recursively. This allows you to revctl the plugins.
-
-    Inside the plugin should be a series of cmd_* function, which inherit from
-    the bzrlib.commands.Command class.
-    """
-    bzrpath = os.environ.get('BZRPLUGINPATH', '')
-
-    plugin_cmds = {}
-    if not bzrpath:
-        return plugin_cmds
-    _platform_extensions = {
-        'win32':'.pyd',
-        'cygwin':'.dll',
-        'darwin':'.dylib',
-        'linux2':'.so'
-        }
-    if _platform_extensions.has_key(sys.platform):
-        platform_extension = _platform_extensions[sys.platform]
-    else:
-        platform_extension = None
-    for d in bzrpath.split(os.pathsep):
-        plugin_names = {} # This should really be a set rather than a dict
-        for f in os.listdir(d):
-            if f.endswith('.py'):
-                f = f[:-3]
-            elif f.endswith('.pyc') or f.endswith('.pyo'):
-                f = f[:-4]
-            elif platform_extension and f.endswith(platform_extension):
-                f = f[:-len(platform_extension)]
-                if f.endswidth('module'):
-                    f = f[:-len('module')]
-            else:
-                continue
-            if not plugin_names.has_key(f):
-                plugin_names[f] = True
-
-        plugin_names = plugin_names.keys()
-        plugin_names.sort()
-        try:
-            sys.path.insert(0, d)
-            for name in plugin_names:
-                try:
-                    old_module = None
-                    try:
-                        if sys.modules.has_key(name):
-                            old_module = sys.modules[name]
-                            del sys.modules[name]
-                        plugin = __import__(name, locals())
-                        for k in dir(plugin):
-                            if k.startswith('cmd_'):
-                                k_unsquished = _unsquish_command_name(k)
-                                if not plugin_cmds.has_key(k_unsquished):
-                                    plugin_cmds[k_unsquished] = getattr(plugin, k)
-                                else:
-                                    log_error('Two plugins defined the same command: %r' % k)
-                                    log_error('Not loading the one in %r in dir %r' % (name, d))
-                    finally:
-                        if old_module:
-                            sys.modules[name] = old_module
-                except ImportError, e:
-                    log_error('Unable to load plugin: %r from %r\n%s' % (name, d, e))
-        finally:
-            sys.path.pop(0)
-    return plugin_cmds
-
-def _get_cmd_dict(include_plugins=True):
+def _get_cmd_dict(plugins_override=True):
     d = {}
     for k, v in globals().iteritems():
         if k.startswith("cmd_"):
             d[_unsquish_command_name(k)] = v
-    if include_plugins:
-        d.update(_find_plugins())
+    # If we didn't load plugins, the plugin_cmds dict will be empty
+    if plugins_override:
+        d.update(plugin_cmds)
+    else:
+        d2 = {}
+        d2.update(plugin_cmds)
+        d2.update(d)
+        d = d2
     return d

-def get_all_cmds(include_plugins=True):
+def get_all_cmds(plugins_override=True):
     """Return canonical name and class for all registered commands."""
-    for k, v in _get_cmd_dict(include_plugins=include_plugins).iteritems():
+    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
         yield k,v


-def get_cmd_class(cmd,include_plugins=True):
+def get_cmd_class(cmd, plugins_override=True):
     """Return the canonical name and command class for a command.
     """
     cmd = str(cmd)                      # not unicode

     # first look up this command under the specified name
-    cmds = _get_cmd_dict(include_plugins=include_plugins)
+    cmds = _get_cmd_dict(plugins_override=plugins_override)
     try:
         return cmd, cmds[cmd]
     except KeyError:
@@ -1461,6 +1413,75 @@
     return argdict


+def _parse_master_args(argv):
+    """Parse the arguments that always go with the original command.
+    These are things like bzr --no-plugins, etc.
+
+    There are now 2 types of option flags. Ones that come *before* the command,
+    and ones that come *after* the command.
+    Ones coming *before* the command are applied against all possible commands.
+    And are generally applied before plugins are loaded.
+
+    The current list are:
+        --builtin   Allow plugins to load, but don't let them override builtin commands,
+                    they will still be allowed if they do not override a builtin.
+        --no-plugins    Don't load any plugins. This lets you get back to official source
+                        behavior.
+        --profile   Enable the hotspot profile before running the command.
+                    For backwards compatibility, this is also a non-master option.
+        --version   Spit out the version of bzr that is running and exit.
+                    This is also a non-master option.
+        --help      Run help and exit, also a non-master option (I think that should stay, though)
+
+    >>> argv, opts = _parse_master_args(['bzr', '--test'])
+    Traceback (most recent call last):
+    ...
+    BzrCommandError: Invalid master option: 'test'
+    >>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
+    >>> print argv
+    ['command']
+    >>> print opts['version']
+    True
+    >>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
+    >>> print argv
+    ['command', '--more-options']
+    >>> print opts['profile']
+    True
+    >>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
+    >>> print argv
+    ['command']
+    >>> print opts['no-plugins']
+    True
+    >>> print opts['profile']
+    False
+    >>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
+    >>> print argv
+    ['command', '--profile']
+    >>> print opts['profile']
+    False
+    """
+    master_opts = {'builtin':False,
+        'no-plugins':False,
+        'version':False,
+        'profile':False,
+        'help':False
+    }
+
+    # This is the point where we could hook into argv[0] to determine
+    # what front-end is supposed to be run
+    # For now, we are just ignoring it.
+    cmd_name = argv.pop(0)
+    for arg in argv[:]:
+        if arg[:2] != '--': # at the first non-option, we return the rest
+            break
+        arg = arg[2:] # Remove '--'
+        if arg not in master_opts:
+            # We could say that this is not an error, that we should
+            # just let it be handled by the main section instead
+            raise BzrCommandError('Invalid master option: %r' % arg)
+        argv.pop(0) # We are consuming this entry
+        master_opts[arg] = True
+    return argv, master_opts

 def run_bzr(argv):
     """Execute a command.
@@ -1470,22 +1491,21 @@
     """
     argv = [a.decode(bzrlib.user_encoding) for a in argv]

-    include_plugins=True
     try:
-        args, opts = parse_args(argv[1:])
-        if 'help' in opts:
+        argv, master_opts = _parse_master_args(argv)
+        if not master_opts['no-plugins']:
+            bzrlib.load_plugins()
+        args, opts = parse_args(argv)
+        if 'help' in opts or master_opts['help']:
             import help
             if args:
                 help.help(args[0])
             else:
                 help.help()
             return 0
-        elif 'version' in opts:
+        elif 'version' in opts or master_opts['version']:
             show_version()
             return 0
-        elif args and args[0] == 'builtin':
-            include_plugins=False
-            args = args[1:]
         cmd = str(args.pop(0))
     except IndexError:
         import help
@@ -1493,14 +1513,15 @@
         return 1


-    canonical_cmd, cmd_class = get_cmd_class(cmd,include_plugins=include_plugins)
-
-    # global option
+    plugins_override = not (master_opts['builtin'])
+    canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
+
+    profile = master_opts['profile']
+    # For backwards compatibility, I would rather stick with --profile being a
+    # master/global option
     if 'profile' in opts:
         profile = True
         del opts['profile']
-    else:
-        profile = False

     # check options are reasonable
     allowed = cmd_class.takes_options

*** modified file 'testbzr'
--- testbzr
+++ testbzr
@@ -149,6 +149,7 @@
     """Run a test involving creating a plugin to load,
     and making sure it is seen properly.
     """
+    orig_help = backtick('bzr help commands') # No plugins yet
     mkdir('plugin_test')
     f = open(os.path.join('plugin_test', 'myplug.py'), 'wb')
     f.write("""import bzrlib, bzrlib.commands
@@ -157,24 +158,36 @@
     aliases = ['mplg']
     def run(self):
         print 'Hello from my plugin'
+class cmd_myplug_with_opt(bzrlib.commands.Command):
+    '''A simple plugin that requires a special option'''
+    takes_options = ['aspecialoptionthatdoesntexist']
+    def run(self, aspecialoptionthatdoesntexist=None):
+        print 'Found: %s' % aspecialoptionthatdoesntexist
+
+bzrlib.commands.register_plugin_command(cmd_myplug)
+bzrlib.commands.register_plugin_command(cmd_myplug_with_opt)
+bzrlib.commands.OPTIONS['aspecialoptionthatdoesntexist'] = str
 """)
     f.close()

-    os.environ['BZRPLUGINPATH'] = os.path.abspath('plugin_test')
-    help = backtick('bzr help commands')
+    os.environ['BZR_PLUGIN_PATH'] = os.path.abspath('plugin_test')
+    help = backtick('bzr help commands') #Help with user-visible plugins
     assert help.find('myplug') != -1
     assert help.find('Just a simple test plugin.') != -1


     assert backtick('bzr myplug') == 'Hello from my plugin\n'
     assert backtick('bzr mplg') == 'Hello from my plugin\n'
+    assert backtick('bzr myplug-with-opt') == 'Found: None\n'
+    assert backtick('bzr myplug-with-opt --aspecialoptionthatdoesntexist=2') == 'Found: 2\n'

     f = open(os.path.join('plugin_test', 'override.py'), 'wb')
     f.write("""import bzrlib, bzrlib.commands
-class cmd_commit(bzrlib.commands.cmd_commit):
-    '''Commit changes into a new revision.'''
+class cmd_revno(bzrlib.commands.cmd_revno):
+    '''Show current revision number.'''
     def run(self, *args, **kwargs):
         print "I'm sorry dave, you can't do that"
+        return 1

 class cmd_help(bzrlib.commands.cmd_help):
     '''Show help on a command or other topic.'''
@@ -182,16 +195,67 @@
         print "You have been overridden"
         bzrlib.commands.cmd_help.run(self, *args, **kwargs)

+bzrlib.commands.register_plugin_command(cmd_revno)
+bzrlib.commands.register_plugin_command(cmd_help)
 """)
     f.close()

-    newhelp = backtick('bzr help commands')
+    newhelp = backtick('bzr help commands') # Help with no new commands,
     assert newhelp.startswith('You have been overridden\n')
     # We added a line, but the rest should work
     assert newhelp[25:] == help
-
-    assert backtick('bzr commit -m test') == "I'm sorry dave, you can't do that\n"
-
+    # Make sure we can get back to the original command
+    # Not overridden, and no extra commands present
+    assert backtick('bzr --builtin help commands') == help
+    assert backtick('bzr --no-plugins help commands') == orig_help
+
+    assert backtick('bzr revno', retcode=1) == "I'm sorry dave, you can't do that\n"
+
+    print_txt = '** Loading noop plugin'
+    f = open(os.path.join('plugin_test', 'loading.py'), 'wb')
+    f.write("""import bzrlib, bzrlib.commands
+class cmd_noop(bzrlib.commands.Command):
+    def run(self, *args, **kwargs):
+        pass
+
+print %r
+bzrlib.commands.register_plugin_command(cmd_noop)
+""" % print_txt)
+    f.close()
+    print_txt += '\n'
+
+    # Check that --builtin still loads the plugin, and enables it as
+    # an extra command, but not as an override
+    # and that --no-plugins doesn't load the command at all
+    assert backtick('bzr noop') == print_txt
+    assert backtick('bzr --builtin help')[:len(print_txt)] == print_txt
+    assert backtick('bzr --no-plugins help')[:len(print_txt)] != print_txt
+    runcmd('bzr revno', retcode=1)
+    runcmd('bzr --builtin revno', retcode=0)
+    runcmd('bzr --no-plugins revno', retcode=0)
+    runcmd('bzr --builtin noop', retcode=0)
+    runcmd('bzr --no-plugins noop', retcode=1)
+
+    # Check that packages can also be loaded
+    test_str = 'packages work'
+    os.mkdir(os.path.join('plugin_test', 'testpkg'))
+    f = open(os.path.join('plugin_test', 'testpkg', '__init__.py'), 'wb')
+    f.write("""import bzrlib, bzrlib.commands
+class testpkgcmd(bzrlib.commands.Command):
+    def run(self, *args, **kwargs):
+        print %r
+
+bzrlib.commands.register_plugin_command(testpkgcmd)
+""" % test_str)
+    f.close()
+    test_str += '\n'
+    assert backtick('bzr testpkgcmd') == print_txt + test_str
+    runcmd('bzr --no-plugins testpkgcmd', retcode=1)
+
+    # Make sure that setting BZR_PLUGIN_PATH to empty is the same as using --no-plugins
+    os.environ['BZR_PLUGIN_PATH'] = ''
+    assert backtick('bzr help commands') == orig_help
+
     shutil.rmtree('plugin_test')

 try:
@@ -221,6 +285,9 @@

     runcmd(['mkdir', TESTDIR])
     cd(TESTDIR)
+    # This means that any command that is naively run in this directory
+    # Won't affect the parent directory.
+    runcmd('bzr init')
     test_root = os.getcwd()

     progress("introductory commands")