← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Vincent Ladeuil
  • Date: 2012-02-14 17:22:37 UTC
  • mfrom: (6466 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120214172237-7dv7er3n4uy8d5m4
Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.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
from __future__ import absolute_import
17
18
 
18
19
# TODO: Define arguments by objects, rather than just using names.
19
20
# Those objects can specify the expected type of the argument, which
27
28
 
28
29
from bzrlib.lazy_import import lazy_import
29
30
lazy_import(globals(), """
30
 
import codecs
31
31
import errno
32
32
import threading
33
 
from warnings import warn
34
33
 
35
34
import bzrlib
36
35
from bzrlib import (
 
36
    config,
37
37
    cleanup,
38
38
    cmdline,
39
39
    debug,
40
40
    errors,
 
41
    i18n,
41
42
    option,
42
43
    osutils,
43
44
    trace,
44
45
    ui,
45
 
    win32utils,
46
46
    )
47
47
""")
48
48
 
49
 
from bzrlib.hooks import HookPoint, Hooks
 
49
from bzrlib.hooks import Hooks
 
50
from bzrlib.i18n import gettext
50
51
# Compatibility - Option used to be in commands.
51
52
from bzrlib.option import Option
52
53
from bzrlib.plugin import disable_plugins, load_plugins
53
54
from bzrlib import registry
54
 
from bzrlib.symbol_versioning import (
55
 
    deprecated_function,
56
 
    deprecated_in,
57
 
    deprecated_method,
58
 
    )
59
55
 
60
56
 
61
57
class CommandInfo(object):
165
161
    return cmd[4:].replace('_','-')
166
162
 
167
163
 
168
 
@deprecated_function(deprecated_in((2, 2, 0)))
169
 
def _builtin_commands():
170
 
    """Return a dict of {name: cmd_class} for builtin commands.
171
 
 
172
 
    :deprecated: Use the builtin_command_registry registry instead
173
 
    """
174
 
    # return dict(name: cmd_class)
175
 
    return dict(builtin_command_registry.items())
176
 
 
177
 
 
178
164
def _register_builtin_commands():
179
165
    if builtin_command_registry.keys():
180
166
        # only load once
240
226
    try:
241
227
        return _get_cmd_object(cmd_name, plugins_override)
242
228
    except KeyError:
243
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
229
        raise errors.BzrCommandError(gettext('unknown command "%s"') % cmd_name)
244
230
 
245
231
 
246
232
def _get_cmd_object(cmd_name, plugins_override=True, check_missing=True):
276
262
    # Allow plugins to extend commands
277
263
    for hook in Command.hooks['extend_command']:
278
264
        hook(cmd)
 
265
    if getattr(cmd, 'invoked_as', None) is None:
 
266
        cmd.invoked_as = cmd_name
279
267
    return cmd
280
268
 
281
269
 
358
346
    summary, then a complete description of the command.  A grammar
359
347
    description will be inserted.
360
348
 
361
 
    aliases
362
 
        Other accepted names for this command.
363
 
 
364
 
    takes_args
365
 
        List of argument forms, marked with whether they are optional,
366
 
        repeated, etc.
367
 
 
368
 
                Examples:
369
 
 
370
 
                ['to_location', 'from_branch?', 'file*']
371
 
 
372
 
                'to_location' is required
373
 
                'from_branch' is optional
374
 
                'file' can be specified 0 or more times
375
 
 
376
 
    takes_options
377
 
        List of options that may be given for this command.  These can
378
 
        be either strings, referring to globally-defined options,
379
 
        or option objects.  Retrieve through options().
380
 
 
381
 
    hidden
382
 
        If true, this command isn't advertised.  This is typically
 
349
    :cvar aliases: Other accepted names for this command.
 
350
 
 
351
    :cvar takes_args: List of argument forms, marked with whether they are
 
352
        optional, repeated, etc.  Examples::
 
353
 
 
354
            ['to_location', 'from_branch?', 'file*']
 
355
 
 
356
        * 'to_location' is required
 
357
        * 'from_branch' is optional
 
358
        * 'file' can be specified 0 or more times
 
359
 
 
360
    :cvar takes_options: List of options that may be given for this command.
 
361
        These can be either strings, referring to globally-defined options, or
 
362
        option objects.  Retrieve through options().
 
363
 
 
364
    :cvar hidden: If true, this command isn't advertised.  This is typically
383
365
        for commands intended for expert users.
384
366
 
385
 
    encoding_type
386
 
        Command objects will get a 'outf' attribute, which has been
387
 
        setup to properly handle encoding of unicode strings.
388
 
        encoding_type determines what will happen when characters cannot
389
 
        be encoded
390
 
            strict - abort if we cannot decode
391
 
            replace - put in a bogus character (typically '?')
392
 
            exact - do not encode sys.stdout
393
 
 
394
 
            NOTE: by default on Windows, sys.stdout is opened as a text
395
 
            stream, therefore LF line-endings are converted to CRLF.
396
 
            When a command uses encoding_type = 'exact', then
397
 
            sys.stdout is forced to be a binary stream, and line-endings
398
 
            will not mangled.
 
367
    :cvar encoding_type: Command objects will get a 'outf' attribute, which has
 
368
        been setup to properly handle encoding of unicode strings.
 
369
        encoding_type determines what will happen when characters cannot be
 
370
        encoded:
 
371
 
 
372
        * strict - abort if we cannot decode
 
373
        * replace - put in a bogus character (typically '?')
 
374
        * exact - do not encode sys.stdout
 
375
 
 
376
        NOTE: by default on Windows, sys.stdout is opened as a text stream,
 
377
        therefore LF line-endings are converted to CRLF.  When a command uses
 
378
        encoding_type = 'exact', then sys.stdout is forced to be a binary
 
379
        stream, and line-endings will not mangled.
 
380
 
 
381
    :cvar invoked_as:
 
382
        A string indicating the real name under which this command was
 
383
        invoked, before expansion of aliases.
 
384
        (This may be None if the command was constructed and run in-process.)
399
385
 
400
386
    :cvar hooks: An instance of CommandHooks.
401
 
    :ivar __doc__: The help shown by 'bzr help command' for this command.
 
387
 
 
388
    :cvar __doc__: The help shown by 'bzr help command' for this command.
402
389
        This is set by assigning explicitly to __doc__ so that -OO can
403
390
        be used::
404
391
 
405
 
        class Foo(Command):
406
 
            __doc__ = "My help goes here"
 
392
            class Foo(Command):
 
393
                __doc__ = "My help goes here"
407
394
    """
408
395
    aliases = []
409
396
    takes_args = []
410
397
    takes_options = []
411
398
    encoding_type = 'strict'
 
399
    invoked_as = None
 
400
    l10n = True
412
401
 
413
402
    hidden = False
414
403
 
440
429
        """
441
430
        self._operation.cleanup_now()
442
431
 
443
 
    @deprecated_method(deprecated_in((2, 1, 0)))
444
 
    def _maybe_expand_globs(self, file_list):
445
 
        """Glob expand file_list if the platform does not do that itself.
446
 
 
447
 
        Not used anymore, now that the bzr command-line parser globs on
448
 
        Windows.
449
 
 
450
 
        :return: A possibly empty list of unicode paths.
451
 
 
452
 
        Introduced in bzrlib 0.18.
453
 
        """
454
 
        return file_list
455
 
 
456
432
    def _usage(self):
457
433
        """Return single-line grammar for this command.
458
434
 
486
462
            usage help (e.g. Purpose, Usage, Options) with a
487
463
            message explaining how to obtain full help.
488
464
        """
 
465
        if self.l10n:
 
466
            i18n.install()  # Install i18n only for get_help_text for now.
489
467
        doc = self.help()
490
 
        if not doc:
491
 
            doc = "No help for this command."
 
468
        if doc:
 
469
            # Note: If self.gettext() translates ':Usage:\n', the section will
 
470
            # be shown after "Description" section and we don't want to
 
471
            # translate the usage string.
 
472
            # Though, bzr export-pot don't exports :Usage: section and it must
 
473
            # not be translated.
 
474
            doc = self.gettext(doc)
 
475
        else:
 
476
            doc = gettext("No help for this command.")
492
477
 
493
478
        # Extract the summary (purpose) and sections out from the text
494
479
        purpose,sections,order = self._get_help_parts(doc)
501
486
 
502
487
        # The header is the purpose and usage
503
488
        result = ""
504
 
        result += ':Purpose: %s\n' % purpose
 
489
        result += gettext(':Purpose: %s\n') % (purpose,)
505
490
        if usage.find('\n') >= 0:
506
 
            result += ':Usage:\n%s\n' % usage
 
491
            result += gettext(':Usage:\n%s\n') % (usage,)
507
492
        else:
508
 
            result += ':Usage:   %s\n' % usage
 
493
            result += gettext(':Usage:   %s\n') % (usage,)
509
494
        result += '\n'
510
495
 
511
496
        # Add the options
513
498
        # XXX: optparse implicitly rewraps the help, and not always perfectly,
514
499
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
515
500
        # 20090319
516
 
        options = option.get_optparser(self.options()).format_option_help()
517
 
        # XXX: According to the spec, ReST option lists actually don't support 
518
 
        # options like --1.9 so that causes syntax errors (in Sphinx at least).
519
 
        # As that pattern always appears in the commands that break, we trap
520
 
        # on that and then format that block of 'format' options as a literal
521
 
        # block.
522
 
        if not plain and options.find('  --1.9  ') != -1:
 
501
        parser = option.get_optparser(self.options())
 
502
        options = parser.format_option_help()
 
503
        # FIXME: According to the spec, ReST option lists actually don't
 
504
        # support options like --1.14 so that causes syntax errors (in Sphinx
 
505
        # at least).  As that pattern always appears in the commands that
 
506
        # break, we trap on that and then format that block of 'format' options
 
507
        # as a literal block. We use the most recent format still listed so we
 
508
        # don't have to do that too often -- vila 20110514
 
509
        if not plain and options.find('  --1.14  ') != -1:
523
510
            options = options.replace(' format:\n', ' format::\n\n', 1)
524
511
        if options.startswith('Options:'):
525
 
            result += ':' + options
526
 
        elif options.startswith('options:'):
527
 
            # Python 2.4 version of optparse
528
 
            result += ':Options:' + options[len('options:'):]
 
512
            result += gettext(':Options:%s') % (options[len('options:'):],)
529
513
        else:
530
514
            result += options
531
515
        result += '\n'
536
520
            if sections.has_key(None):
537
521
                text = sections.pop(None)
538
522
                text = '\n  '.join(text.splitlines())
539
 
                result += ':%s:\n  %s\n\n' % ('Description',text)
 
523
                result += gettext(':Description:\n  %s\n\n') % (text,)
540
524
 
541
525
            # Add the custom sections (e.g. Examples). Note that there's no need
542
526
            # to indent these as they must be indented already in the source.
543
527
            if sections:
544
528
                for label in order:
545
 
                    if sections.has_key(label):
546
 
                        result += ':%s:\n%s\n' % (label,sections[label])
 
529
                    if label in sections:
 
530
                        result += ':%s:\n%s\n' % (label, sections[label])
547
531
                result += '\n'
548
532
        else:
549
 
            result += ("See bzr help %s for more details and examples.\n\n"
 
533
            result += (gettext("See bzr help %s for more details and examples.\n\n")
550
534
                % self.name())
551
535
 
552
536
        # Add the aliases, source (plug-in) and see also links, if any
553
537
        if self.aliases:
554
 
            result += ':Aliases:  '
 
538
            result += gettext(':Aliases:  ')
555
539
            result += ', '.join(self.aliases) + '\n'
556
540
        plugin_name = self.plugin_name()
557
541
        if plugin_name is not None:
558
 
            result += ':From:     plugin "%s"\n' % plugin_name
 
542
            result += gettext(':From:     plugin "%s"\n') % plugin_name
559
543
        see_also = self.get_see_also(additional_see_also)
560
544
        if see_also:
561
545
            if not plain and see_also_as_links:
567
551
                        see_also_links.append(item)
568
552
                    else:
569
553
                        # Use a Sphinx link for this entry
570
 
                        link_text = ":doc:`%s <%s-help>`" % (item, item)
 
554
                        link_text = gettext(":doc:`{0} <{1}-help>`").format(
 
555
                                                                    item, item)
571
556
                        see_also_links.append(link_text)
572
557
                see_also = see_also_links
573
 
            result += ':See also: '
574
 
            result += ', '.join(see_also) + '\n'
 
558
            result += gettext(':See also: %s') % ', '.join(see_also) + '\n'
575
559
 
576
560
        # If this will be rendered as plain text, convert it
577
561
        if plain:
658
642
    def run_argv_aliases(self, argv, alias_argv=None):
659
643
        """Parse the command line and run with extra aliases in alias_argv."""
660
644
        args, opts = parse_args(self, argv, alias_argv)
 
645
        self._setup_outf()
661
646
 
662
647
        # Process the standard options
663
648
        if 'help' in opts:  # e.g. bzr add --help
664
 
            sys.stdout.write(self.get_help_text())
 
649
            self.outf.write(self.get_help_text())
665
650
            return 0
666
651
        if 'usage' in opts:  # e.g. bzr add --usage
667
 
            sys.stdout.write(self.get_help_text(verbose=False))
 
652
            self.outf.write(self.get_help_text(verbose=False))
668
653
            return 0
669
654
        trace.set_verbosity_level(option._verbosity_level)
670
655
        if 'verbose' in self.supported_std_options:
675
660
            opts['quiet'] = trace.is_quiet()
676
661
        elif opts.has_key('quiet'):
677
662
            del opts['quiet']
678
 
 
679
663
        # mix arguments and options into one dictionary
680
664
        cmdargs = _match_argform(self.name(), self.takes_args, args)
681
665
        cmdopts = {}
685
669
        all_cmd_args = cmdargs.copy()
686
670
        all_cmd_args.update(cmdopts)
687
671
 
688
 
        self._setup_outf()
689
 
 
690
672
        try:
691
673
            return self.run(**all_cmd_args)
692
674
        finally:
708
690
        """
709
691
        class_run = self.run
710
692
        def run(*args, **kwargs):
 
693
            for hook in Command.hooks['pre_command']:
 
694
                hook(self)
711
695
            self._operation = cleanup.OperationWithCleanups(class_run)
712
696
            try:
713
697
                return self._operation.run_simple(*args, **kwargs)
714
698
            finally:
715
699
                del self._operation
 
700
                for hook in Command.hooks['post_command']:
 
701
                    hook(self)
716
702
        self.run = run
717
703
 
718
 
    @deprecated_method(deprecated_in((2, 2, 0)))
719
 
    def run_direct(self, *args, **kwargs):
720
 
        """Deprecated thunk from bzrlib 2.1."""
721
 
        return self.run(*args, **kwargs)
722
 
 
723
704
    def run(self):
724
705
        """Actually run the command.
725
706
 
751
732
            return None
752
733
        return getdoc(self)
753
734
 
 
735
    def gettext(self, message):
 
736
        """Returns the gettext function used to translate this command's help.
 
737
 
 
738
        Commands provided by plugins should override this to use their
 
739
        own i18n system.
 
740
        """
 
741
        return i18n.gettext_per_paragraph(message)
 
742
 
754
743
    def name(self):
 
744
        """Return the canonical name for this command.
 
745
 
 
746
        The name under which it was actually invoked is available in invoked_as.
 
747
        """
755
748
        return _unsquish_command_name(self.__class__.__name__)
756
749
 
757
750
    def plugin_name(self):
775
768
        These are all empty initially, because by default nothing should get
776
769
        notified.
777
770
        """
778
 
        Hooks.__init__(self)
779
 
        self.create_hook(HookPoint('extend_command',
 
771
        Hooks.__init__(self, "bzrlib.commands", "Command.hooks")
 
772
        self.add_hook('extend_command',
780
773
            "Called after creating a command object to allow modifications "
781
774
            "such as adding or removing options, docs etc. Called with the "
782
 
            "new bzrlib.commands.Command object.", (1, 13), None))
783
 
        self.create_hook(HookPoint('get_command',
 
775
            "new bzrlib.commands.Command object.", (1, 13))
 
776
        self.add_hook('get_command',
784
777
            "Called when creating a single command. Called with "
785
778
            "(cmd_or_None, command_name). get_command should either return "
786
779
            "the cmd_or_None parameter, or a replacement Command object that "
787
780
            "should be used for the command. Note that the Command.hooks "
788
781
            "hooks are core infrastructure. Many users will prefer to use "
789
782
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
790
 
            (1, 17), None))
791
 
        self.create_hook(HookPoint('get_missing_command',
 
783
            (1, 17))
 
784
        self.add_hook('get_missing_command',
792
785
            "Called when creating a single command if no command could be "
793
786
            "found. Called with (command_name). get_missing_command should "
794
787
            "either return None, or a Command object to be used for the "
795
 
            "command.", (1, 17), None))
796
 
        self.create_hook(HookPoint('list_commands',
 
788
            "command.", (1, 17))
 
789
        self.add_hook('list_commands',
797
790
            "Called when enumerating commands. Called with a set of "
798
791
            "cmd_name strings for all the commands found so far. This set "
799
792
            " is safe to mutate - e.g. to remove a command. "
800
793
            "list_commands should return the updated set of command names.",
801
 
            (1, 17), None))
 
794
            (1, 17))
 
795
        self.add_hook('pre_command',
 
796
            "Called prior to executing a command. Called with the command "
 
797
            "object.", (2, 5))
 
798
        self.add_hook('post_command',
 
799
            "Called after executing a command. Called with the command "
 
800
            "object.", (2, 5))
802
801
 
803
802
Command.hooks = CommandHooks()
804
803
 
823
822
    try:
824
823
        options, args = parser.parse_args(args)
825
824
    except UnicodeEncodeError,e:
826
 
        raise errors.BzrCommandError('Only ASCII permitted in option names')
 
825
        raise errors.BzrCommandError(
 
826
            gettext('Only ASCII permitted in option names'))
827
827
 
828
828
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
829
829
                 v is not option.OptionParser.DEFAULT_VALUE])
847
847
                argdict[argname + '_list'] = None
848
848
        elif ap[-1] == '+':
849
849
            if not args:
850
 
                raise errors.BzrCommandError("command %r needs one or more %s"
851
 
                                             % (cmd, argname.upper()))
 
850
                raise errors.BzrCommandError(gettext(
 
851
                      "command {0!r} needs one or more {1}").format(
 
852
                      cmd, argname.upper()))
852
853
            else:
853
854
                argdict[argname + '_list'] = args[:]
854
855
                args = []
855
856
        elif ap[-1] == '$': # all but one
856
857
            if len(args) < 2:
857
 
                raise errors.BzrCommandError("command %r needs one or more %s"
858
 
                                             % (cmd, argname.upper()))
 
858
                raise errors.BzrCommandError(
 
859
                      gettext("command {0!r} needs one or more {1}").format(
 
860
                                             cmd, argname.upper()))
859
861
            argdict[argname + '_list'] = args[:-1]
860
862
            args[:-1] = []
861
863
        else:
862
864
            # just a plain arg
863
865
            argname = ap
864
866
            if not args:
865
 
                raise errors.BzrCommandError("command %r requires argument %s"
866
 
                               % (cmd, argname.upper()))
 
867
                raise errors.BzrCommandError(
 
868
                     gettext("command {0!r} requires argument {1}").format(
 
869
                               cmd, argname.upper()))
867
870
            else:
868
871
                argdict[argname] = args.pop(0)
869
872
 
870
873
    if args:
871
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
872
 
                                     % (cmd, args[0]))
 
874
        raise errors.BzrCommandError( gettext(
 
875
                              "extra argument to command {0}: {1}").format(
 
876
                                       cmd, args[0]) )
873
877
 
874
878
    return argdict
875
879
 
958
962
 
959
963
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
960
964
    from bzrlib.lsprof import profile
961
 
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
 
965
    ret, stats = profile(exception_to_return_code, the_callable,
 
966
                         *args, **kwargs)
962
967
    stats.sort()
963
968
    if filename is None:
964
969
        stats.pprint()
965
970
    else:
966
971
        stats.save(filename)
967
 
        trace.note('Profile data written to "%s".', filename)
 
972
        trace.note(gettext('Profile data written to "%s".'), filename)
968
973
    return ret
969
974
 
970
975
 
971
 
@deprecated_function(deprecated_in((2, 2, 0)))
972
 
def shlex_split_unicode(unsplit):
973
 
    return cmdline.split(unsplit)
974
 
 
975
 
 
976
976
def get_alias(cmd, config=None):
977
977
    """Return an expanded alias, or None if no alias exists.
978
978
 
1034
1034
        Specify the number of processes that can be run concurrently (selftest).
1035
1035
    """
1036
1036
    trace.mutter("bazaar version: " + bzrlib.__version__)
1037
 
    argv = list(argv)
 
1037
    argv = _specified_or_unicode_argv(argv)
1038
1038
    trace.mutter("bzr arguments: %r", argv)
1039
1039
 
1040
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
1041
 
                opt_no_aliases = False
 
1040
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
 
1041
            opt_no_l10n = opt_no_aliases = False
1042
1042
    opt_lsprof_file = opt_coverage_dir = None
1043
1043
 
1044
1044
    # --no-plugins is handled specially at a very early stage. We need
1047
1047
 
1048
1048
    argv_copy = []
1049
1049
    i = 0
 
1050
    override_config = []
1050
1051
    while i < len(argv):
1051
1052
        a = argv[i]
1052
1053
        if a == '--profile':
1061
1062
            opt_no_plugins = True
1062
1063
        elif a == '--no-aliases':
1063
1064
            opt_no_aliases = True
 
1065
        elif a == '--no-l10n':
 
1066
            opt_no_l10n = True
1064
1067
        elif a == '--builtin':
1065
1068
            opt_builtin = True
1066
1069
        elif a == '--concurrency':
1073
1076
            pass # already handled in startup script Bug #588277
1074
1077
        elif a.startswith('-D'):
1075
1078
            debug.debug_flags.add(a[2:])
 
1079
        elif a.startswith('-O'):
 
1080
            override_config.append(a[2:])
1076
1081
        else:
1077
1082
            argv_copy.append(a)
1078
1083
        i += 1
1079
1084
 
 
1085
    if bzrlib.global_state is None:
 
1086
        # FIXME: Workaround for users that imported bzrlib but didn't call
 
1087
        # bzrlib.initialize -- vila 2012-01-19
 
1088
        cmdline_overrides = config.CommandLineStore()
 
1089
    else:
 
1090
        cmdline_overrides = bzrlib.global_state.cmdline_overrides
 
1091
    cmdline_overrides._from_cmdline(override_config)
 
1092
 
1080
1093
    debug.set_debug_flags_from_config()
1081
1094
 
1082
1095
    if not opt_no_plugins:
1102
1115
 
1103
1116
    cmd = argv.pop(0)
1104
1117
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
1118
    if opt_no_l10n:
 
1119
        cmd.l10n = False
1105
1120
    run = cmd_obj.run_argv_aliases
1106
1121
    run_argv = [argv, alias_argv]
1107
1122
 
1132
1147
        if 'memory' in debug.debug_flags:
1133
1148
            trace.debug_memory('Process status after command:', short=False)
1134
1149
        option._verbosity_level = saved_verbosity_level
 
1150
        # Reset the overrides 
 
1151
        cmdline_overrides._reset()
1135
1152
 
1136
1153
 
1137
1154
def display_command(func):
1166
1183
        "bzr plugin commands")
1167
1184
    Command.hooks.install_named_hook("get_command", _get_external_command,
1168
1185
        "bzr external command lookup")
1169
 
    Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
1170
 
        "bzr plugin-provider-db check")
 
1186
    Command.hooks.install_named_hook("get_missing_command",
 
1187
                                     _try_plugin_provider,
 
1188
                                     "bzr plugin-provider-db check")
1171
1189
 
1172
1190
 
1173
1191
 
1180
1198
        new_argv = []
1181
1199
        try:
1182
1200
            # ensure all arguments are unicode strings
1183
 
            for a in argv[1:]:
 
1201
            for a in argv:
1184
1202
                if isinstance(a, unicode):
1185
1203
                    new_argv.append(a)
1186
1204
                else:
1202
1220
 
1203
1221
    :return: exit code of bzr command.
1204
1222
    """
1205
 
    argv = _specified_or_unicode_argv(argv)
 
1223
    if argv is not None:
 
1224
        argv = argv[1:]
1206
1225
    _register_builtin_commands()
1207
1226
    ret = run_bzr_catch_errors(argv)
1208
1227
    trace.mutter("return code %d", ret)
1263
1282
 
1264
1283
 
1265
1284
class Provider(object):
1266
 
    '''Generic class to be overriden by plugins'''
 
1285
    """Generic class to be overriden by plugins"""
1267
1286
 
1268
1287
    def plugin_for_command(self, cmd_name):
1269
 
        '''Takes a command and returns the information for that plugin
 
1288
        """Takes a command and returns the information for that plugin
1270
1289
 
1271
1290
        :return: A dictionary with all the available information
1272
 
        for the requested plugin
1273
 
        '''
 
1291
            for the requested plugin
 
1292
        """
1274
1293
        raise NotImplementedError
1275
1294
 
1276
1295
 
1277
1296
class ProvidersRegistry(registry.Registry):
1278
 
    '''This registry exists to allow other providers to exist'''
 
1297
    """This registry exists to allow other providers to exist"""
1279
1298
 
1280
1299
    def __iter__(self):
1281
1300
        for key, provider in self.iteritems():