~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
32
33
 
33
34
import bzrlib
34
35
from bzrlib import (
 
36
    config,
35
37
    cleanup,
36
38
    cmdline,
37
39
    debug,
38
40
    errors,
 
41
    i18n,
39
42
    option,
40
43
    osutils,
41
44
    trace,
44
47
""")
45
48
 
46
49
from bzrlib.hooks import Hooks
 
50
from bzrlib.i18n import gettext
47
51
# Compatibility - Option used to be in commands.
48
52
from bzrlib.option import Option
49
53
from bzrlib.plugin import disable_plugins, load_plugins
50
54
from bzrlib import registry
51
 
from bzrlib.symbol_versioning import (
52
 
    deprecated_function,
53
 
    deprecated_in,
54
 
    deprecated_method,
55
 
    )
56
55
 
57
56
 
58
57
class CommandInfo(object):
162
161
    return cmd[4:].replace('_','-')
163
162
 
164
163
 
165
 
@deprecated_function(deprecated_in((2, 2, 0)))
166
 
def _builtin_commands():
167
 
    """Return a dict of {name: cmd_class} for builtin commands.
168
 
 
169
 
    :deprecated: Use the builtin_command_registry registry instead
170
 
    """
171
 
    # return dict(name: cmd_class)
172
 
    return dict(builtin_command_registry.items())
173
 
 
174
 
 
175
164
def _register_builtin_commands():
176
165
    if builtin_command_registry.keys():
177
166
        # only load once
237
226
    try:
238
227
        return _get_cmd_object(cmd_name, plugins_override)
239
228
    except KeyError:
240
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
229
        raise errors.BzrCommandError(gettext('unknown command "%s"') % cmd_name)
241
230
 
242
231
 
243
232
def _get_cmd_object(cmd_name, plugins_override=True, check_missing=True):
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.
398
 
 
399
 
    :ivar invoked_as:
 
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:
400
382
        A string indicating the real name under which this command was
401
 
        invoked, before expansion of aliases. 
 
383
        invoked, before expansion of aliases.
402
384
        (This may be None if the command was constructed and run in-process.)
403
385
 
404
386
    :cvar hooks: An instance of CommandHooks.
405
387
 
406
 
    :ivar __doc__: The help shown by 'bzr help command' for this command.
 
388
    :cvar __doc__: The help shown by 'bzr help command' for this command.
407
389
        This is set by assigning explicitly to __doc__ so that -OO can
408
390
        be used::
409
391
 
410
 
        class Foo(Command):
411
 
            __doc__ = "My help goes here"
 
392
            class Foo(Command):
 
393
                __doc__ = "My help goes here"
412
394
    """
413
395
    aliases = []
414
396
    takes_args = []
415
397
    takes_options = []
416
398
    encoding_type = 'strict'
417
399
    invoked_as = None
 
400
    l10n = True
418
401
 
419
402
    hidden = False
420
403
 
446
429
        """
447
430
        self._operation.cleanup_now()
448
431
 
449
 
    @deprecated_method(deprecated_in((2, 1, 0)))
450
 
    def _maybe_expand_globs(self, file_list):
451
 
        """Glob expand file_list if the platform does not do that itself.
452
 
 
453
 
        Not used anymore, now that the bzr command-line parser globs on
454
 
        Windows.
455
 
 
456
 
        :return: A possibly empty list of unicode paths.
457
 
 
458
 
        Introduced in bzrlib 0.18.
459
 
        """
460
 
        return file_list
461
 
 
462
432
    def _usage(self):
463
433
        """Return single-line grammar for this command.
464
434
 
492
462
            usage help (e.g. Purpose, Usage, Options) with a
493
463
            message explaining how to obtain full help.
494
464
        """
 
465
        if self.l10n:
 
466
            i18n.install()  # Install i18n only for get_help_text for now.
495
467
        doc = self.help()
496
 
        if not doc:
497
 
            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.")
498
477
 
499
478
        # Extract the summary (purpose) and sections out from the text
500
479
        purpose,sections,order = self._get_help_parts(doc)
507
486
 
508
487
        # The header is the purpose and usage
509
488
        result = ""
510
 
        result += ':Purpose: %s\n' % purpose
 
489
        result += gettext(':Purpose: %s\n') % (purpose,)
511
490
        if usage.find('\n') >= 0:
512
 
            result += ':Usage:\n%s\n' % usage
 
491
            result += gettext(':Usage:\n%s\n') % (usage,)
513
492
        else:
514
 
            result += ':Usage:   %s\n' % usage
 
493
            result += gettext(':Usage:   %s\n') % (usage,)
515
494
        result += '\n'
516
495
 
517
496
        # Add the options
519
498
        # XXX: optparse implicitly rewraps the help, and not always perfectly,
520
499
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
521
500
        # 20090319
522
 
        options = option.get_optparser(self.options()).format_option_help()
523
 
        # XXX: According to the spec, ReST option lists actually don't support 
524
 
        # options like --1.9 so that causes syntax errors (in Sphinx at least).
525
 
        # As that pattern always appears in the commands that break, we trap
526
 
        # on that and then format that block of 'format' options as a literal
527
 
        # block.
528
 
        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:
529
510
            options = options.replace(' format:\n', ' format::\n\n', 1)
530
511
        if options.startswith('Options:'):
531
 
            result += ':' + options
532
 
        elif options.startswith('options:'):
533
 
            # Python 2.4 version of optparse
534
 
            result += ':Options:' + options[len('options:'):]
 
512
            result += gettext(':Options:%s') % (options[len('options:'):],)
535
513
        else:
536
514
            result += options
537
515
        result += '\n'
542
520
            if sections.has_key(None):
543
521
                text = sections.pop(None)
544
522
                text = '\n  '.join(text.splitlines())
545
 
                result += ':%s:\n  %s\n\n' % ('Description',text)
 
523
                result += gettext(':Description:\n  %s\n\n') % (text,)
546
524
 
547
525
            # Add the custom sections (e.g. Examples). Note that there's no need
548
526
            # to indent these as they must be indented already in the source.
549
527
            if sections:
550
528
                for label in order:
551
 
                    if sections.has_key(label):
552
 
                        result += ':%s:\n%s\n' % (label,sections[label])
 
529
                    if label in sections:
 
530
                        result += ':%s:\n%s\n' % (label, sections[label])
553
531
                result += '\n'
554
532
        else:
555
 
            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")
556
534
                % self.name())
557
535
 
558
536
        # Add the aliases, source (plug-in) and see also links, if any
559
537
        if self.aliases:
560
 
            result += ':Aliases:  '
 
538
            result += gettext(':Aliases:  ')
561
539
            result += ', '.join(self.aliases) + '\n'
562
540
        plugin_name = self.plugin_name()
563
541
        if plugin_name is not None:
564
 
            result += ':From:     plugin "%s"\n' % plugin_name
 
542
            result += gettext(':From:     plugin "%s"\n') % plugin_name
565
543
        see_also = self.get_see_also(additional_see_also)
566
544
        if see_also:
567
545
            if not plain and see_also_as_links:
573
551
                        see_also_links.append(item)
574
552
                    else:
575
553
                        # Use a Sphinx link for this entry
576
 
                        link_text = ":doc:`%s <%s-help>`" % (item, item)
 
554
                        link_text = gettext(":doc:`{0} <{1}-help>`").format(
 
555
                                                                    item, item)
577
556
                        see_also_links.append(link_text)
578
557
                see_also = see_also_links
579
 
            result += ':See also: '
580
 
            result += ', '.join(see_also) + '\n'
 
558
            result += gettext(':See also: %s') % ', '.join(see_also) + '\n'
581
559
 
582
560
        # If this will be rendered as plain text, convert it
583
561
        if plain:
664
642
    def run_argv_aliases(self, argv, alias_argv=None):
665
643
        """Parse the command line and run with extra aliases in alias_argv."""
666
644
        args, opts = parse_args(self, argv, alias_argv)
 
645
        self._setup_outf()
667
646
 
668
647
        # Process the standard options
669
648
        if 'help' in opts:  # e.g. bzr add --help
670
 
            sys.stdout.write(self.get_help_text())
 
649
            self.outf.write(self.get_help_text())
671
650
            return 0
672
651
        if 'usage' in opts:  # e.g. bzr add --usage
673
 
            sys.stdout.write(self.get_help_text(verbose=False))
 
652
            self.outf.write(self.get_help_text(verbose=False))
674
653
            return 0
675
654
        trace.set_verbosity_level(option._verbosity_level)
676
655
        if 'verbose' in self.supported_std_options:
681
660
            opts['quiet'] = trace.is_quiet()
682
661
        elif opts.has_key('quiet'):
683
662
            del opts['quiet']
684
 
 
685
663
        # mix arguments and options into one dictionary
686
664
        cmdargs = _match_argform(self.name(), self.takes_args, args)
687
665
        cmdopts = {}
691
669
        all_cmd_args = cmdargs.copy()
692
670
        all_cmd_args.update(cmdopts)
693
671
 
694
 
        self._setup_outf()
695
 
 
696
672
        try:
697
673
            return self.run(**all_cmd_args)
698
674
        finally:
714
690
        """
715
691
        class_run = self.run
716
692
        def run(*args, **kwargs):
 
693
            for hook in Command.hooks['pre_command']:
 
694
                hook(self)
717
695
            self._operation = cleanup.OperationWithCleanups(class_run)
718
696
            try:
719
697
                return self._operation.run_simple(*args, **kwargs)
720
698
            finally:
721
699
                del self._operation
 
700
                for hook in Command.hooks['post_command']:
 
701
                    hook(self)
722
702
        self.run = run
723
703
 
724
 
    @deprecated_method(deprecated_in((2, 2, 0)))
725
 
    def run_direct(self, *args, **kwargs):
726
 
        """Deprecated thunk from bzrlib 2.1."""
727
 
        return self.run(*args, **kwargs)
728
 
 
729
704
    def run(self):
730
705
        """Actually run the command.
731
706
 
757
732
            return None
758
733
        return getdoc(self)
759
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
 
760
743
    def name(self):
761
744
        """Return the canonical name for this command.
762
745
 
809
792
            " is safe to mutate - e.g. to remove a command. "
810
793
            "list_commands should return the updated set of command names.",
811
794
            (1, 17))
 
795
        self.add_hook('pre_command',
 
796
            "Called prior to executing a command. Called with the command "
 
797
            "object.", (2, 6))
 
798
        self.add_hook('post_command',
 
799
            "Called after executing a command. Called with the command "
 
800
            "object.", (2, 6))
812
801
 
813
802
Command.hooks = CommandHooks()
814
803
 
833
822
    try:
834
823
        options, args = parser.parse_args(args)
835
824
    except UnicodeEncodeError,e:
836
 
        raise errors.BzrCommandError('Only ASCII permitted in option names')
 
825
        raise errors.BzrCommandError(
 
826
            gettext('Only ASCII permitted in option names'))
837
827
 
838
828
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
839
829
                 v is not option.OptionParser.DEFAULT_VALUE])
857
847
                argdict[argname + '_list'] = None
858
848
        elif ap[-1] == '+':
859
849
            if not args:
860
 
                raise errors.BzrCommandError("command %r needs one or more %s"
861
 
                                             % (cmd, argname.upper()))
 
850
                raise errors.BzrCommandError(gettext(
 
851
                      "command {0!r} needs one or more {1}").format(
 
852
                      cmd, argname.upper()))
862
853
            else:
863
854
                argdict[argname + '_list'] = args[:]
864
855
                args = []
865
856
        elif ap[-1] == '$': # all but one
866
857
            if len(args) < 2:
867
 
                raise errors.BzrCommandError("command %r needs one or more %s"
868
 
                                             % (cmd, argname.upper()))
 
858
                raise errors.BzrCommandError(
 
859
                      gettext("command {0!r} needs one or more {1}").format(
 
860
                                             cmd, argname.upper()))
869
861
            argdict[argname + '_list'] = args[:-1]
870
862
            args[:-1] = []
871
863
        else:
872
864
            # just a plain arg
873
865
            argname = ap
874
866
            if not args:
875
 
                raise errors.BzrCommandError("command %r requires argument %s"
876
 
                               % (cmd, argname.upper()))
 
867
                raise errors.BzrCommandError(
 
868
                     gettext("command {0!r} requires argument {1}").format(
 
869
                               cmd, argname.upper()))
877
870
            else:
878
871
                argdict[argname] = args.pop(0)
879
872
 
880
873
    if args:
881
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
882
 
                                     % (cmd, args[0]))
 
874
        raise errors.BzrCommandError( gettext(
 
875
                              "extra argument to command {0}: {1}").format(
 
876
                                       cmd, args[0]) )
883
877
 
884
878
    return argdict
885
879
 
941
935
        exitcode = trace.report_exception(exc_info, sys.stderr)
942
936
        if os.environ.get('BZR_PDB'):
943
937
            print '**** entering debugger'
944
 
            tb = exc_info[2]
945
938
            import pdb
946
 
            if sys.version_info[:2] < (2, 6):
947
 
                # XXX: we want to do
948
 
                #    pdb.post_mortem(tb)
949
 
                # but because pdb.post_mortem gives bad results for tracebacks
950
 
                # from inside generators, we do it manually.
951
 
                # (http://bugs.python.org/issue4150, fixed in Python 2.6)
952
 
 
953
 
                # Setup pdb on the traceback
954
 
                p = pdb.Pdb()
955
 
                p.reset()
956
 
                p.setup(tb.tb_frame, tb)
957
 
                # Point the debugger at the deepest frame of the stack
958
 
                p.curindex = len(p.stack) - 1
959
 
                p.curframe = p.stack[p.curindex][0]
960
 
                # Start the pdb prompt.
961
 
                p.print_stack_entry(p.stack[p.curindex])
962
 
                p.execRcLines()
963
 
                p.cmdloop()
964
 
            else:
965
 
                pdb.post_mortem(tb)
 
939
            pdb.post_mortem(exc_info[2])
966
940
        return exitcode
967
941
 
968
942
 
969
943
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
970
944
    from bzrlib.lsprof import profile
971
 
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
 
945
    ret, stats = profile(exception_to_return_code, the_callable,
 
946
                         *args, **kwargs)
972
947
    stats.sort()
973
948
    if filename is None:
974
949
        stats.pprint()
975
950
    else:
976
951
        stats.save(filename)
977
 
        trace.note('Profile data written to "%s".', filename)
 
952
        trace.note(gettext('Profile data written to "%s".'), filename)
978
953
    return ret
979
954
 
980
955
 
981
 
@deprecated_function(deprecated_in((2, 2, 0)))
982
 
def shlex_split_unicode(unsplit):
983
 
    return cmdline.split(unsplit)
984
 
 
985
 
 
986
956
def get_alias(cmd, config=None):
987
957
    """Return an expanded alias, or None if no alias exists.
988
958
 
1047
1017
    argv = _specified_or_unicode_argv(argv)
1048
1018
    trace.mutter("bzr arguments: %r", argv)
1049
1019
 
1050
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
1051
 
                opt_no_aliases = False
 
1020
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
 
1021
            opt_no_l10n = opt_no_aliases = False
1052
1022
    opt_lsprof_file = opt_coverage_dir = None
1053
1023
 
1054
1024
    # --no-plugins is handled specially at a very early stage. We need
1057
1027
 
1058
1028
    argv_copy = []
1059
1029
    i = 0
 
1030
    override_config = []
1060
1031
    while i < len(argv):
1061
1032
        a = argv[i]
1062
1033
        if a == '--profile':
1071
1042
            opt_no_plugins = True
1072
1043
        elif a == '--no-aliases':
1073
1044
            opt_no_aliases = True
 
1045
        elif a == '--no-l10n':
 
1046
            opt_no_l10n = True
1074
1047
        elif a == '--builtin':
1075
1048
            opt_builtin = True
1076
1049
        elif a == '--concurrency':
1083
1056
            pass # already handled in startup script Bug #588277
1084
1057
        elif a.startswith('-D'):
1085
1058
            debug.debug_flags.add(a[2:])
 
1059
        elif a.startswith('-O'):
 
1060
            override_config.append(a[2:])
1086
1061
        else:
1087
1062
            argv_copy.append(a)
1088
1063
        i += 1
1089
1064
 
 
1065
    if bzrlib.global_state is None:
 
1066
        # FIXME: Workaround for users that imported bzrlib but didn't call
 
1067
        # bzrlib.initialize -- vila 2012-01-19
 
1068
        cmdline_overrides = config.CommandLineStore()
 
1069
    else:
 
1070
        cmdline_overrides = bzrlib.global_state.cmdline_overrides
 
1071
    cmdline_overrides._from_cmdline(override_config)
 
1072
 
1090
1073
    debug.set_debug_flags_from_config()
1091
1074
 
1092
1075
    if not opt_no_plugins:
1112
1095
 
1113
1096
    cmd = argv.pop(0)
1114
1097
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
1098
    if opt_no_l10n:
 
1099
        cmd.l10n = False
1115
1100
    run = cmd_obj.run_argv_aliases
1116
1101
    run_argv = [argv, alias_argv]
1117
1102
 
1142
1127
        if 'memory' in debug.debug_flags:
1143
1128
            trace.debug_memory('Process status after command:', short=False)
1144
1129
        option._verbosity_level = saved_verbosity_level
 
1130
        # Reset the overrides 
 
1131
        cmdline_overrides._reset()
1145
1132
 
1146
1133
 
1147
1134
def display_command(func):
1176
1163
        "bzr plugin commands")
1177
1164
    Command.hooks.install_named_hook("get_command", _get_external_command,
1178
1165
        "bzr external command lookup")
1179
 
    Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
1180
 
        "bzr plugin-provider-db check")
 
1166
    Command.hooks.install_named_hook("get_missing_command",
 
1167
                                     _try_plugin_provider,
 
1168
                                     "bzr plugin-provider-db check")
1181
1169
 
1182
1170
 
1183
1171
 
1274
1262
 
1275
1263
 
1276
1264
class Provider(object):
1277
 
    '''Generic class to be overriden by plugins'''
 
1265
    """Generic class to be overriden by plugins"""
1278
1266
 
1279
1267
    def plugin_for_command(self, cmd_name):
1280
 
        '''Takes a command and returns the information for that plugin
 
1268
        """Takes a command and returns the information for that plugin
1281
1269
 
1282
1270
        :return: A dictionary with all the available information
1283
 
        for the requested plugin
1284
 
        '''
 
1271
            for the requested plugin
 
1272
        """
1285
1273
        raise NotImplementedError
1286
1274
 
1287
1275
 
1288
1276
class ProvidersRegistry(registry.Registry):
1289
 
    '''This registry exists to allow other providers to exist'''
 
1277
    """This registry exists to allow other providers to exist"""
1290
1278
 
1291
1279
    def __iter__(self):
1292
1280
        for key, provider in self.iteritems():