← 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-03-09 16:48:55 UTC
  • mto: (6437.23.24 2.5)
  • mto: This revision was merged to the branch mainline in revision 6499.
  • Revision ID: v.ladeuil+lp@free.fr-20120309164855-htdn25hp7x65mmir
https://launchpad.net/bugs/940164
Rely on sphinx for texinfo doc generation

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
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
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
222
208
    Use of all_command_names() is encouraged rather than builtin_command_names
223
209
    and/or plugin_command_names.
224
210
    """
 
211
    _register_builtin_commands()
225
212
    return builtin_command_registry.keys()
226
213
 
227
214
 
239
226
    try:
240
227
        return _get_cmd_object(cmd_name, plugins_override)
241
228
    except KeyError:
242
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
229
        raise errors.BzrCommandError(gettext('unknown command "%s"') % cmd_name)
243
230
 
244
231
 
245
232
def _get_cmd_object(cmd_name, plugins_override=True, check_missing=True):
275
262
    # Allow plugins to extend commands
276
263
    for hook in Command.hooks['extend_command']:
277
264
        hook(cmd)
 
265
    if getattr(cmd, 'invoked_as', None) is None:
 
266
        cmd.invoked_as = cmd_name
278
267
    return cmd
279
268
 
280
269
 
357
346
    summary, then a complete description of the command.  A grammar
358
347
    description will be inserted.
359
348
 
360
 
    aliases
361
 
        Other accepted names for this command.
362
 
 
363
 
    takes_args
364
 
        List of argument forms, marked with whether they are optional,
365
 
        repeated, etc.
366
 
 
367
 
                Examples:
368
 
 
369
 
                ['to_location', 'from_branch?', 'file*']
370
 
 
371
 
                'to_location' is required
372
 
                'from_branch' is optional
373
 
                'file' can be specified 0 or more times
374
 
 
375
 
    takes_options
376
 
        List of options that may be given for this command.  These can
377
 
        be either strings, referring to globally-defined options,
378
 
        or option objects.  Retrieve through options().
379
 
 
380
 
    hidden
381
 
        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
382
365
        for commands intended for expert users.
383
366
 
384
 
    encoding_type
385
 
        Command objects will get a 'outf' attribute, which has been
386
 
        setup to properly handle encoding of unicode strings.
387
 
        encoding_type determines what will happen when characters cannot
388
 
        be encoded
389
 
            strict - abort if we cannot decode
390
 
            replace - put in a bogus character (typically '?')
391
 
            exact - do not encode sys.stdout
392
 
 
393
 
            NOTE: by default on Windows, sys.stdout is opened as a text
394
 
            stream, therefore LF line-endings are converted to CRLF.
395
 
            When a command uses encoding_type = 'exact', then
396
 
            sys.stdout is forced to be a binary stream, and line-endings
397
 
            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.)
398
385
 
399
386
    :cvar hooks: An instance of CommandHooks.
 
387
 
 
388
    :cvar __doc__: The help shown by 'bzr help command' for this command.
 
389
        This is set by assigning explicitly to __doc__ so that -OO can
 
390
        be used::
 
391
 
 
392
            class Foo(Command):
 
393
                __doc__ = "My help goes here"
400
394
    """
401
395
    aliases = []
402
396
    takes_args = []
403
397
    takes_options = []
404
398
    encoding_type = 'strict'
 
399
    invoked_as = None
 
400
    l10n = True
405
401
 
406
402
    hidden = False
407
403
 
408
404
    def __init__(self):
409
405
        """Construct an instance of this command."""
410
 
        if self.__doc__ == Command.__doc__:
411
 
            warn("No help message set for %r" % self)
412
406
        # List of standard options directly supported
413
407
        self.supported_std_options = []
414
408
        self._setup_run()
435
429
        """
436
430
        self._operation.cleanup_now()
437
431
 
438
 
    @deprecated_method(deprecated_in((2, 1, 0)))
439
 
    def _maybe_expand_globs(self, file_list):
440
 
        """Glob expand file_list if the platform does not do that itself.
441
 
 
442
 
        Not used anymore, now that the bzr command-line parser globs on
443
 
        Windows.
444
 
 
445
 
        :return: A possibly empty list of unicode paths.
446
 
 
447
 
        Introduced in bzrlib 0.18.
448
 
        """
449
 
        return file_list
450
 
 
451
432
    def _usage(self):
452
433
        """Return single-line grammar for this command.
453
434
 
481
462
            usage help (e.g. Purpose, Usage, Options) with a
482
463
            message explaining how to obtain full help.
483
464
        """
 
465
        if self.l10n:
 
466
            i18n.install()  # Install i18n only for get_help_text for now.
484
467
        doc = self.help()
485
 
        if doc is None:
486
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
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.")
487
477
 
488
478
        # Extract the summary (purpose) and sections out from the text
489
479
        purpose,sections,order = self._get_help_parts(doc)
496
486
 
497
487
        # The header is the purpose and usage
498
488
        result = ""
499
 
        result += ':Purpose: %s\n' % purpose
 
489
        result += gettext(':Purpose: %s\n') % (purpose,)
500
490
        if usage.find('\n') >= 0:
501
 
            result += ':Usage:\n%s\n' % usage
 
491
            result += gettext(':Usage:\n%s\n') % (usage,)
502
492
        else:
503
 
            result += ':Usage:   %s\n' % usage
 
493
            result += gettext(':Usage:   %s\n') % (usage,)
504
494
        result += '\n'
505
495
 
506
496
        # Add the options
508
498
        # XXX: optparse implicitly rewraps the help, and not always perfectly,
509
499
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
510
500
        # 20090319
511
 
        options = option.get_optparser(self.options()).format_option_help()
512
 
        # XXX: According to the spec, ReST option lists actually don't support 
513
 
        # options like --1.9 so that causes syntax errors (in Sphinx at least).
514
 
        # As that pattern always appears in the commands that break, we trap
515
 
        # on that and then format that block of 'format' options as a literal
516
 
        # block.
517
 
        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:
518
510
            options = options.replace(' format:\n', ' format::\n\n', 1)
519
511
        if options.startswith('Options:'):
520
 
            result += ':' + options
521
 
        elif options.startswith('options:'):
522
 
            # Python 2.4 version of optparse
523
 
            result += ':Options:' + options[len('options:'):]
 
512
            result += gettext(':Options:%s') % (options[len('options:'):],)
524
513
        else:
525
514
            result += options
526
515
        result += '\n'
531
520
            if sections.has_key(None):
532
521
                text = sections.pop(None)
533
522
                text = '\n  '.join(text.splitlines())
534
 
                result += ':%s:\n  %s\n\n' % ('Description',text)
 
523
                result += gettext(':Description:\n  %s\n\n') % (text,)
535
524
 
536
525
            # Add the custom sections (e.g. Examples). Note that there's no need
537
526
            # to indent these as they must be indented already in the source.
538
527
            if sections:
539
528
                for label in order:
540
 
                    if sections.has_key(label):
541
 
                        result += ':%s:\n%s\n' % (label,sections[label])
 
529
                    if label in sections:
 
530
                        result += ':%s:\n%s\n' % (label, sections[label])
542
531
                result += '\n'
543
532
        else:
544
 
            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")
545
534
                % self.name())
546
535
 
547
536
        # Add the aliases, source (plug-in) and see also links, if any
548
537
        if self.aliases:
549
 
            result += ':Aliases:  '
 
538
            result += gettext(':Aliases:  ')
550
539
            result += ', '.join(self.aliases) + '\n'
551
540
        plugin_name = self.plugin_name()
552
541
        if plugin_name is not None:
553
 
            result += ':From:     plugin "%s"\n' % plugin_name
 
542
            result += gettext(':From:     plugin "%s"\n') % plugin_name
554
543
        see_also = self.get_see_also(additional_see_also)
555
544
        if see_also:
556
545
            if not plain and see_also_as_links:
562
551
                        see_also_links.append(item)
563
552
                    else:
564
553
                        # Use a Sphinx link for this entry
565
 
                        link_text = ":doc:`%s <%s-help>`" % (item, item)
 
554
                        link_text = gettext(":doc:`{0} <{1}-help>`").format(
 
555
                                                                    item, item)
566
556
                        see_also_links.append(link_text)
567
557
                see_also = see_also_links
568
 
            result += ':See also: '
569
 
            result += ', '.join(see_also) + '\n'
 
558
            result += gettext(':See also: %s') % ', '.join(see_also) + '\n'
570
559
 
571
560
        # If this will be rendered as plain text, convert it
572
561
        if plain:
653
642
    def run_argv_aliases(self, argv, alias_argv=None):
654
643
        """Parse the command line and run with extra aliases in alias_argv."""
655
644
        args, opts = parse_args(self, argv, alias_argv)
 
645
        self._setup_outf()
656
646
 
657
647
        # Process the standard options
658
648
        if 'help' in opts:  # e.g. bzr add --help
659
 
            sys.stdout.write(self.get_help_text())
 
649
            self.outf.write(self.get_help_text())
660
650
            return 0
661
651
        if 'usage' in opts:  # e.g. bzr add --usage
662
 
            sys.stdout.write(self.get_help_text(verbose=False))
 
652
            self.outf.write(self.get_help_text(verbose=False))
663
653
            return 0
664
654
        trace.set_verbosity_level(option._verbosity_level)
665
655
        if 'verbose' in self.supported_std_options:
670
660
            opts['quiet'] = trace.is_quiet()
671
661
        elif opts.has_key('quiet'):
672
662
            del opts['quiet']
673
 
 
674
663
        # mix arguments and options into one dictionary
675
664
        cmdargs = _match_argform(self.name(), self.takes_args, args)
676
665
        cmdopts = {}
680
669
        all_cmd_args = cmdargs.copy()
681
670
        all_cmd_args.update(cmdopts)
682
671
 
683
 
        self._setup_outf()
684
 
 
685
 
        return self.run(**all_cmd_args)
 
672
        try:
 
673
            return self.run(**all_cmd_args)
 
674
        finally:
 
675
            # reset it, so that other commands run in the same process won't
 
676
            # inherit state. Before we reset it, log any activity, so that it
 
677
            # gets properly tracked.
 
678
            ui.ui_factory.log_transport_activity(
 
679
                display=('bytes' in debug.debug_flags))
 
680
            trace.set_verbosity_level(0)
686
681
 
687
682
    def _setup_run(self):
688
683
        """Wrap the defined run method on self with a cleanup.
702
697
                del self._operation
703
698
        self.run = run
704
699
 
705
 
    @deprecated_method(deprecated_in((2, 2, 0)))
706
 
    def run_direct(self, *args, **kwargs):
707
 
        """Deprecated thunk from bzrlib 2.1."""
708
 
        return self.run(*args, **kwargs)
709
 
 
710
700
    def run(self):
711
701
        """Actually run the command.
712
702
 
738
728
            return None
739
729
        return getdoc(self)
740
730
 
 
731
    def gettext(self, message):
 
732
        """Returns the gettext function used to translate this command's help.
 
733
 
 
734
        Commands provided by plugins should override this to use their
 
735
        own i18n system.
 
736
        """
 
737
        return i18n.gettext_per_paragraph(message)
 
738
 
741
739
    def name(self):
 
740
        """Return the canonical name for this command.
 
741
 
 
742
        The name under which it was actually invoked is available in invoked_as.
 
743
        """
742
744
        return _unsquish_command_name(self.__class__.__name__)
743
745
 
744
746
    def plugin_name(self):
762
764
        These are all empty initially, because by default nothing should get
763
765
        notified.
764
766
        """
765
 
        Hooks.__init__(self)
766
 
        self.create_hook(HookPoint('extend_command',
 
767
        Hooks.__init__(self, "bzrlib.commands", "Command.hooks")
 
768
        self.add_hook('extend_command',
767
769
            "Called after creating a command object to allow modifications "
768
770
            "such as adding or removing options, docs etc. Called with the "
769
 
            "new bzrlib.commands.Command object.", (1, 13), None))
770
 
        self.create_hook(HookPoint('get_command',
 
771
            "new bzrlib.commands.Command object.", (1, 13))
 
772
        self.add_hook('get_command',
771
773
            "Called when creating a single command. Called with "
772
774
            "(cmd_or_None, command_name). get_command should either return "
773
775
            "the cmd_or_None parameter, or a replacement Command object that "
774
776
            "should be used for the command. Note that the Command.hooks "
775
777
            "hooks are core infrastructure. Many users will prefer to use "
776
778
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
777
 
            (1, 17), None))
778
 
        self.create_hook(HookPoint('get_missing_command',
 
779
            (1, 17))
 
780
        self.add_hook('get_missing_command',
779
781
            "Called when creating a single command if no command could be "
780
782
            "found. Called with (command_name). get_missing_command should "
781
783
            "either return None, or a Command object to be used for the "
782
 
            "command.", (1, 17), None))
783
 
        self.create_hook(HookPoint('list_commands',
 
784
            "command.", (1, 17))
 
785
        self.add_hook('list_commands',
784
786
            "Called when enumerating commands. Called with a set of "
785
787
            "cmd_name strings for all the commands found so far. This set "
786
788
            " is safe to mutate - e.g. to remove a command. "
787
789
            "list_commands should return the updated set of command names.",
788
 
            (1, 17), None))
 
790
            (1, 17))
789
791
 
790
792
Command.hooks = CommandHooks()
791
793
 
805
807
    else:
806
808
        args = argv
807
809
 
808
 
    options, args = parser.parse_args(args)
 
810
    # for python 2.5 and later, optparse raises this exception if a non-ascii
 
811
    # option name is given.  See http://bugs.python.org/issue2931
 
812
    try:
 
813
        options, args = parser.parse_args(args)
 
814
    except UnicodeEncodeError,e:
 
815
        raise errors.BzrCommandError(
 
816
            gettext('Only ASCII permitted in option names'))
 
817
 
809
818
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
810
819
                 v is not option.OptionParser.DEFAULT_VALUE])
811
820
    return args, opts
828
837
                argdict[argname + '_list'] = None
829
838
        elif ap[-1] == '+':
830
839
            if not args:
831
 
                raise errors.BzrCommandError("command %r needs one or more %s"
832
 
                                             % (cmd, argname.upper()))
 
840
                raise errors.BzrCommandError(gettext(
 
841
                      "command {0!r} needs one or more {1}").format(
 
842
                      cmd, argname.upper()))
833
843
            else:
834
844
                argdict[argname + '_list'] = args[:]
835
845
                args = []
836
846
        elif ap[-1] == '$': # all but one
837
847
            if len(args) < 2:
838
 
                raise errors.BzrCommandError("command %r needs one or more %s"
839
 
                                             % (cmd, argname.upper()))
 
848
                raise errors.BzrCommandError(
 
849
                      gettext("command {0!r} needs one or more {1}").format(
 
850
                                             cmd, argname.upper()))
840
851
            argdict[argname + '_list'] = args[:-1]
841
852
            args[:-1] = []
842
853
        else:
843
854
            # just a plain arg
844
855
            argname = ap
845
856
            if not args:
846
 
                raise errors.BzrCommandError("command %r requires argument %s"
847
 
                               % (cmd, argname.upper()))
 
857
                raise errors.BzrCommandError(
 
858
                     gettext("command {0!r} requires argument {1}").format(
 
859
                               cmd, argname.upper()))
848
860
            else:
849
861
                argdict[argname] = args.pop(0)
850
862
 
851
863
    if args:
852
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
853
 
                                     % (cmd, args[0]))
 
864
        raise errors.BzrCommandError( gettext(
 
865
                              "extra argument to command {0}: {1}").format(
 
866
                                       cmd, args[0]) )
854
867
 
855
868
    return argdict
856
869
 
939
952
 
940
953
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
941
954
    from bzrlib.lsprof import profile
942
 
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
 
955
    ret, stats = profile(exception_to_return_code, the_callable,
 
956
                         *args, **kwargs)
943
957
    stats.sort()
944
958
    if filename is None:
945
959
        stats.pprint()
946
960
    else:
947
961
        stats.save(filename)
948
 
        trace.note('Profile data written to "%s".', filename)
 
962
        trace.note(gettext('Profile data written to "%s".'), filename)
949
963
    return ret
950
964
 
951
965
 
952
 
@deprecated_function(deprecated_in((2, 2, 0)))
953
 
def shlex_split_unicode(unsplit):
954
 
    return cmdline.split(unsplit)
955
 
 
956
 
 
957
966
def get_alias(cmd, config=None):
958
967
    """Return an expanded alias, or None if no alias exists.
959
968
 
1015
1024
        Specify the number of processes that can be run concurrently (selftest).
1016
1025
    """
1017
1026
    trace.mutter("bazaar version: " + bzrlib.__version__)
1018
 
    argv = list(argv)
 
1027
    argv = _specified_or_unicode_argv(argv)
1019
1028
    trace.mutter("bzr arguments: %r", argv)
1020
1029
 
1021
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
1022
 
                opt_no_aliases = False
 
1030
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
 
1031
            opt_no_l10n = opt_no_aliases = False
1023
1032
    opt_lsprof_file = opt_coverage_dir = None
1024
1033
 
1025
1034
    # --no-plugins is handled specially at a very early stage. We need
1028
1037
 
1029
1038
    argv_copy = []
1030
1039
    i = 0
 
1040
    override_config = []
1031
1041
    while i < len(argv):
1032
1042
        a = argv[i]
1033
1043
        if a == '--profile':
1042
1052
            opt_no_plugins = True
1043
1053
        elif a == '--no-aliases':
1044
1054
            opt_no_aliases = True
 
1055
        elif a == '--no-l10n':
 
1056
            opt_no_l10n = True
1045
1057
        elif a == '--builtin':
1046
1058
            opt_builtin = True
1047
1059
        elif a == '--concurrency':
1050
1062
        elif a == '--coverage':
1051
1063
            opt_coverage_dir = argv[i + 1]
1052
1064
            i += 1
 
1065
        elif a == '--profile-imports':
 
1066
            pass # already handled in startup script Bug #588277
1053
1067
        elif a.startswith('-D'):
1054
1068
            debug.debug_flags.add(a[2:])
 
1069
        elif a.startswith('-O'):
 
1070
            override_config.append(a[2:])
1055
1071
        else:
1056
1072
            argv_copy.append(a)
1057
1073
        i += 1
1058
1074
 
 
1075
    if bzrlib.global_state is None:
 
1076
        # FIXME: Workaround for users that imported bzrlib but didn't call
 
1077
        # bzrlib.initialize -- vila 2012-01-19
 
1078
        cmdline_overrides = config.CommandLineStore()
 
1079
    else:
 
1080
        cmdline_overrides = bzrlib.global_state.cmdline_overrides
 
1081
    cmdline_overrides._from_cmdline(override_config)
 
1082
 
1059
1083
    debug.set_debug_flags_from_config()
1060
1084
 
1061
1085
    if not opt_no_plugins:
1077
1101
    if not opt_no_aliases:
1078
1102
        alias_argv = get_alias(argv[0])
1079
1103
        if alias_argv:
1080
 
            user_encoding = osutils.get_user_encoding()
1081
 
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1082
1104
            argv[0] = alias_argv.pop(0)
1083
1105
 
1084
1106
    cmd = argv.pop(0)
1085
 
    # We want only 'ascii' command names, but the user may have typed
1086
 
    # in a Unicode name. In that case, they should just get a
1087
 
    # 'command not found' error later.
1088
 
 
1089
1107
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
1108
    if opt_no_l10n:
 
1109
        cmd.l10n = False
1090
1110
    run = cmd_obj.run_argv_aliases
1091
1111
    run_argv = [argv, alias_argv]
1092
1112
 
1117
1137
        if 'memory' in debug.debug_flags:
1118
1138
            trace.debug_memory('Process status after command:', short=False)
1119
1139
        option._verbosity_level = saved_verbosity_level
 
1140
        # Reset the overrides 
 
1141
        cmdline_overrides._reset()
1120
1142
 
1121
1143
 
1122
1144
def display_command(func):
1151
1173
        "bzr plugin commands")
1152
1174
    Command.hooks.install_named_hook("get_command", _get_external_command,
1153
1175
        "bzr external command lookup")
1154
 
    Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
1155
 
        "bzr plugin-provider-db check")
 
1176
    Command.hooks.install_named_hook("get_missing_command",
 
1177
                                     _try_plugin_provider,
 
1178
                                     "bzr plugin-provider-db check")
1156
1179
 
1157
1180
 
1158
1181
 
1165
1188
        new_argv = []
1166
1189
        try:
1167
1190
            # ensure all arguments are unicode strings
1168
 
            for a in argv[1:]:
 
1191
            for a in argv:
1169
1192
                if isinstance(a, unicode):
1170
1193
                    new_argv.append(a)
1171
1194
                else:
1187
1210
 
1188
1211
    :return: exit code of bzr command.
1189
1212
    """
1190
 
    argv = _specified_or_unicode_argv(argv)
 
1213
    if argv is not None:
 
1214
        argv = argv[1:]
1191
1215
    _register_builtin_commands()
1192
1216
    ret = run_bzr_catch_errors(argv)
1193
 
    bzrlib.ui.ui_factory.log_transport_activity(
1194
 
        display=('bytes' in debug.debug_flags))
1195
1217
    trace.mutter("return code %d", ret)
1196
1218
    return ret
1197
1219
 
1250
1272
 
1251
1273
 
1252
1274
class Provider(object):
1253
 
    '''Generic class to be overriden by plugins'''
 
1275
    """Generic class to be overriden by plugins"""
1254
1276
 
1255
1277
    def plugin_for_command(self, cmd_name):
1256
 
        '''Takes a command and returns the information for that plugin
 
1278
        """Takes a command and returns the information for that plugin
1257
1279
 
1258
1280
        :return: A dictionary with all the available information
1259
 
        for the requested plugin
1260
 
        '''
 
1281
            for the requested plugin
 
1282
        """
1261
1283
        raise NotImplementedError
1262
1284
 
1263
1285
 
1264
1286
class ProvidersRegistry(registry.Registry):
1265
 
    '''This registry exists to allow other providers to exist'''
 
1287
    """This registry exists to allow other providers to exist"""
1266
1288
 
1267
1289
    def __iter__(self):
1268
1290
        for key, provider in self.iteritems():