~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

(jameinel) (bug #780544) when updating the WT,
 allow it to be done with a fast delta,
 rather than setting the state from scratch. (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
27
27
 
28
28
from bzrlib.lazy_import import lazy_import
29
29
lazy_import(globals(), """
30
 
import codecs
31
30
import errno
32
31
import threading
33
 
from warnings import warn
34
32
 
35
33
import bzrlib
36
34
from bzrlib import (
42
40
    osutils,
43
41
    trace,
44
42
    ui,
45
 
    win32utils,
46
43
    )
47
44
""")
48
45
 
49
 
from bzrlib.hooks import HookPoint, Hooks
 
46
from bzrlib.hooks import Hooks
50
47
# Compatibility - Option used to be in commands.
51
48
from bzrlib.option import Option
52
49
from bzrlib.plugin import disable_plugins, load_plugins
222
219
    Use of all_command_names() is encouraged rather than builtin_command_names
223
220
    and/or plugin_command_names.
224
221
    """
 
222
    _register_builtin_commands()
225
223
    return builtin_command_registry.keys()
226
224
 
227
225
 
275
273
    # Allow plugins to extend commands
276
274
    for hook in Command.hooks['extend_command']:
277
275
        hook(cmd)
 
276
    if getattr(cmd, 'invoked_as', None) is None:
 
277
        cmd.invoked_as = cmd_name
278
278
    return cmd
279
279
 
280
280
 
357
357
    summary, then a complete description of the command.  A grammar
358
358
    description will be inserted.
359
359
 
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
 
360
    :cvar aliases: Other accepted names for this command.
 
361
 
 
362
    :cvar takes_args: List of argument forms, marked with whether they are
 
363
        optional, repeated, etc.  Examples::
 
364
 
 
365
            ['to_location', 'from_branch?', 'file*']
 
366
 
 
367
        * 'to_location' is required
 
368
        * 'from_branch' is optional
 
369
        * 'file' can be specified 0 or more times
 
370
 
 
371
    :cvar takes_options: List of options that may be given for this command.
 
372
        These can be either strings, referring to globally-defined options, or
 
373
        option objects.  Retrieve through options().
 
374
 
 
375
    :cvar hidden: If true, this command isn't advertised.  This is typically
382
376
        for commands intended for expert users.
383
377
 
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.
 
378
    :cvar encoding_type: Command objects will get a 'outf' attribute, which has
 
379
        been setup to properly handle encoding of unicode strings.
 
380
        encoding_type determines what will happen when characters cannot be
 
381
        encoded:
 
382
 
 
383
        * strict - abort if we cannot decode
 
384
        * replace - put in a bogus character (typically '?')
 
385
        * exact - do not encode sys.stdout
 
386
 
 
387
        NOTE: by default on Windows, sys.stdout is opened as a text stream,
 
388
        therefore LF line-endings are converted to CRLF.  When a command uses
 
389
        encoding_type = 'exact', then sys.stdout is forced to be a binary
 
390
        stream, and line-endings will not mangled.
 
391
 
 
392
    :cvar invoked_as:
 
393
        A string indicating the real name under which this command was
 
394
        invoked, before expansion of aliases.
 
395
        (This may be None if the command was constructed and run in-process.)
398
396
 
399
397
    :cvar hooks: An instance of CommandHooks.
 
398
 
 
399
    :cvar __doc__: The help shown by 'bzr help command' for this command.
 
400
        This is set by assigning explicitly to __doc__ so that -OO can
 
401
        be used::
 
402
 
 
403
            class Foo(Command):
 
404
                __doc__ = "My help goes here"
400
405
    """
401
406
    aliases = []
402
407
    takes_args = []
403
408
    takes_options = []
404
409
    encoding_type = 'strict'
 
410
    invoked_as = None
405
411
 
406
412
    hidden = False
407
413
 
408
414
    def __init__(self):
409
415
        """Construct an instance of this command."""
410
 
        if self.__doc__ == Command.__doc__:
411
 
            warn("No help message set for %r" % self)
412
416
        # List of standard options directly supported
413
417
        self.supported_std_options = []
414
418
        self._setup_run()
482
486
            message explaining how to obtain full help.
483
487
        """
484
488
        doc = self.help()
485
 
        if doc is None:
486
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
489
        if not doc:
 
490
            doc = "No help for this command."
487
491
 
488
492
        # Extract the summary (purpose) and sections out from the text
489
493
        purpose,sections,order = self._get_help_parts(doc)
509
513
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
510
514
        # 20090319
511
515
        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:
 
516
        # FIXME: According to the spec, ReST option lists actually don't
 
517
        # support options like --1.14 so that causes syntax errors (in Sphinx
 
518
        # at least).  As that pattern always appears in the commands that
 
519
        # break, we trap on that and then format that block of 'format' options
 
520
        # as a literal block. We use the most recent format still listed so we
 
521
        # don't have to do that too often -- vila 20110514
 
522
        if not plain and options.find('  --1.14  ') != -1:
518
523
            options = options.replace(' format:\n', ' format::\n\n', 1)
519
524
        if options.startswith('Options:'):
520
525
            result += ':' + options
682
687
 
683
688
        self._setup_outf()
684
689
 
685
 
        return self.run(**all_cmd_args)
 
690
        try:
 
691
            return self.run(**all_cmd_args)
 
692
        finally:
 
693
            # reset it, so that other commands run in the same process won't
 
694
            # inherit state. Before we reset it, log any activity, so that it
 
695
            # gets properly tracked.
 
696
            ui.ui_factory.log_transport_activity(
 
697
                display=('bytes' in debug.debug_flags))
 
698
            trace.set_verbosity_level(0)
686
699
 
687
700
    def _setup_run(self):
688
701
        """Wrap the defined run method on self with a cleanup.
739
752
        return getdoc(self)
740
753
 
741
754
    def name(self):
 
755
        """Return the canonical name for this command.
 
756
 
 
757
        The name under which it was actually invoked is available in invoked_as.
 
758
        """
742
759
        return _unsquish_command_name(self.__class__.__name__)
743
760
 
744
761
    def plugin_name(self):
762
779
        These are all empty initially, because by default nothing should get
763
780
        notified.
764
781
        """
765
 
        Hooks.__init__(self)
766
 
        self.create_hook(HookPoint('extend_command',
 
782
        Hooks.__init__(self, "bzrlib.commands", "Command.hooks")
 
783
        self.add_hook('extend_command',
767
784
            "Called after creating a command object to allow modifications "
768
785
            "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',
 
786
            "new bzrlib.commands.Command object.", (1, 13))
 
787
        self.add_hook('get_command',
771
788
            "Called when creating a single command. Called with "
772
789
            "(cmd_or_None, command_name). get_command should either return "
773
790
            "the cmd_or_None parameter, or a replacement Command object that "
774
791
            "should be used for the command. Note that the Command.hooks "
775
792
            "hooks are core infrastructure. Many users will prefer to use "
776
793
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
777
 
            (1, 17), None))
778
 
        self.create_hook(HookPoint('get_missing_command',
 
794
            (1, 17))
 
795
        self.add_hook('get_missing_command',
779
796
            "Called when creating a single command if no command could be "
780
797
            "found. Called with (command_name). get_missing_command should "
781
798
            "either return None, or a Command object to be used for the "
782
 
            "command.", (1, 17), None))
783
 
        self.create_hook(HookPoint('list_commands',
 
799
            "command.", (1, 17))
 
800
        self.add_hook('list_commands',
784
801
            "Called when enumerating commands. Called with a set of "
785
802
            "cmd_name strings for all the commands found so far. This set "
786
803
            " is safe to mutate - e.g. to remove a command. "
787
804
            "list_commands should return the updated set of command names.",
788
 
            (1, 17), None))
 
805
            (1, 17))
789
806
 
790
807
Command.hooks = CommandHooks()
791
808
 
805
822
    else:
806
823
        args = argv
807
824
 
808
 
    options, args = parser.parse_args(args)
 
825
    # for python 2.5 and later, optparse raises this exception if a non-ascii
 
826
    # option name is given.  See http://bugs.python.org/issue2931
 
827
    try:
 
828
        options, args = parser.parse_args(args)
 
829
    except UnicodeEncodeError,e:
 
830
        raise errors.BzrCommandError('Only ASCII permitted in option names')
 
831
 
809
832
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
810
833
                 v is not option.OptionParser.DEFAULT_VALUE])
811
834
    return args, opts
1015
1038
        Specify the number of processes that can be run concurrently (selftest).
1016
1039
    """
1017
1040
    trace.mutter("bazaar version: " + bzrlib.__version__)
1018
 
    argv = list(argv)
 
1041
    argv = _specified_or_unicode_argv(argv)
1019
1042
    trace.mutter("bzr arguments: %r", argv)
1020
1043
 
1021
1044
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
1050
1073
        elif a == '--coverage':
1051
1074
            opt_coverage_dir = argv[i + 1]
1052
1075
            i += 1
 
1076
        elif a == '--profile-imports':
 
1077
            pass # already handled in startup script Bug #588277
1053
1078
        elif a.startswith('-D'):
1054
1079
            debug.debug_flags.add(a[2:])
1055
1080
        else:
1077
1102
    if not opt_no_aliases:
1078
1103
        alias_argv = get_alias(argv[0])
1079
1104
        if alias_argv:
1080
 
            user_encoding = osutils.get_user_encoding()
1081
 
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1082
1105
            argv[0] = alias_argv.pop(0)
1083
1106
 
1084
1107
    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
1108
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1090
1109
    run = cmd_obj.run_argv_aliases
1091
1110
    run_argv = [argv, alias_argv]
1165
1184
        new_argv = []
1166
1185
        try:
1167
1186
            # ensure all arguments are unicode strings
1168
 
            for a in argv[1:]:
 
1187
            for a in argv:
1169
1188
                if isinstance(a, unicode):
1170
1189
                    new_argv.append(a)
1171
1190
                else:
1187
1206
 
1188
1207
    :return: exit code of bzr command.
1189
1208
    """
1190
 
    argv = _specified_or_unicode_argv(argv)
 
1209
    if argv is not None:
 
1210
        argv = argv[1:]
1191
1211
    _register_builtin_commands()
1192
1212
    ret = run_bzr_catch_errors(argv)
1193
 
    bzrlib.ui.ui_factory.log_transport_activity(
1194
 
        display=('bytes' in debug.debug_flags))
1195
1213
    trace.mutter("return code %d", ret)
1196
1214
    return ret
1197
1215
 
1250
1268
 
1251
1269
 
1252
1270
class Provider(object):
1253
 
    '''Generic class to be overriden by plugins'''
 
1271
    """Generic class to be overriden by plugins"""
1254
1272
 
1255
1273
    def plugin_for_command(self, cmd_name):
1256
 
        '''Takes a command and returns the information for that plugin
 
1274
        """Takes a command and returns the information for that plugin
1257
1275
 
1258
1276
        :return: A dictionary with all the available information
1259
 
        for the requested plugin
1260
 
        '''
 
1277
            for the requested plugin
 
1278
        """
1261
1279
        raise NotImplementedError
1262
1280
 
1263
1281
 
1264
1282
class ProvidersRegistry(registry.Registry):
1265
 
    '''This registry exists to allow other providers to exist'''
 
1283
    """This registry exists to allow other providers to exist"""
1266
1284
 
1267
1285
    def __iter__(self):
1268
1286
        for key, provider in self.iteritems():