/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/commands.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
26
26
import os
27
27
import sys
28
28
 
29
 
from bzrlib.lazy_import import lazy_import
 
29
from .lazy_import import lazy_import
30
30
lazy_import(globals(), """
31
31
import errno
32
32
import threading
33
33
 
34
 
import bzrlib
35
 
from bzrlib import (
 
34
import breezy
 
35
from breezy import (
36
36
    config,
37
37
    cleanup,
38
38
    cmdline,
46
46
    )
47
47
""")
48
48
 
49
 
from bzrlib.hooks import Hooks
50
 
from bzrlib.i18n import gettext
 
49
from .hooks import Hooks
 
50
from .i18n import gettext
51
51
# Compatibility - Option used to be in commands.
52
 
from bzrlib.option import Option
53
 
from bzrlib.plugin import disable_plugins, load_plugins
54
 
from bzrlib import registry
 
52
from .option import Option
 
53
from .plugin import disable_plugins, load_plugins
 
54
from . import registry
 
55
from .sixish import (
 
56
    string_types,
 
57
    )
55
58
 
56
59
 
57
60
class CommandInfo(object):
165
168
    if builtin_command_registry.keys():
166
169
        # only load once
167
170
        return
168
 
    import bzrlib.builtins
169
 
    for cmd_class in _scan_module_for_commands(bzrlib.builtins).values():
 
171
    import breezy.builtins
 
172
    for cmd_class in _scan_module_for_commands(breezy.builtins).values():
170
173
        builtin_command_registry.register(cmd_class)
171
 
    bzrlib.builtins._register_lazy_builtins()
 
174
    breezy.builtins._register_lazy_builtins()
172
175
 
173
176
 
174
177
def _scan_module_for_commands(module):
175
178
    r = {}
176
 
    for name, obj in module.__dict__.iteritems():
 
179
    for name, obj in module.__dict__.items():
177
180
        if name.startswith("cmd_"):
178
181
            real_name = _unsquish_command_name(name)
179
182
            r[real_name] = obj
309
312
    # Only do external command lookups when no command is found so far.
310
313
    if cmd_or_None is not None:
311
314
        return cmd_or_None
312
 
    from bzrlib.externalcommand import ExternalCommand
 
315
    from breezy.externalcommand import ExternalCommand
313
316
    cmd_obj = ExternalCommand.find_command(cmd_name)
314
317
    if cmd_obj:
315
318
        return cmd_obj
316
319
 
317
320
 
318
321
def _get_plugin_command(cmd_or_None, cmd_name):
319
 
    """Get a command from bzr's plugins."""
 
322
    """Get a command from brz's plugins."""
320
323
    try:
321
324
        return plugin_cmds.get(cmd_name)()
322
325
    except KeyError:
331
334
class Command(object):
332
335
    """Base class for commands.
333
336
 
334
 
    Commands are the heart of the command-line bzr interface.
 
337
    Commands are the heart of the command-line brz interface.
335
338
 
336
339
    The command object mostly handles the mapping of command-line
337
 
    parameters into one or more bzrlib operations, and of the results
 
340
    parameters into one or more breezy operations, and of the results
338
341
    into textual output.
339
342
 
340
343
    Commands normally don't have any state.  All their arguments are
385
388
 
386
389
    :cvar hooks: An instance of CommandHooks.
387
390
 
388
 
    :cvar __doc__: The help shown by 'bzr help command' for this command.
 
391
    :cvar __doc__: The help shown by 'brz help command' for this command.
389
392
        This is set by assigning explicitly to __doc__ so that -OO can
390
393
        be used::
391
394
 
434
437
 
435
438
        Only describes arguments, not options.
436
439
        """
437
 
        s = 'bzr ' + self.name() + ' '
 
440
        s = 'brz ' + self.name() + ' '
438
441
        for aname in self.takes_args:
439
442
            aname = aname.upper()
440
443
            if aname[-1] in ['$', '+']:
469
472
            # Note: If self.gettext() translates ':Usage:\n', the section will
470
473
            # be shown after "Description" section and we don't want to
471
474
            # translate the usage string.
472
 
            # Though, bzr export-pot don't exports :Usage: section and it must
 
475
            # Though, brz export-pot don't exports :Usage: section and it must
473
476
            # not be translated.
474
477
            doc = self.gettext(doc)
475
478
        else:
479
482
        purpose,sections,order = self._get_help_parts(doc)
480
483
 
481
484
        # If a custom usage section was provided, use it
482
 
        if sections.has_key('Usage'):
 
485
        if 'Usage' in sections:
483
486
            usage = sections.pop('Usage')
484
487
        else:
485
488
            usage = self._usage()
517
520
        if verbose:
518
521
            # Add the description, indenting it 2 spaces
519
522
            # to match the indentation of the options
520
 
            if sections.has_key(None):
 
523
            if None in sections:
521
524
                text = sections.pop(None)
522
525
                text = '\n  '.join(text.splitlines())
523
526
                result += gettext(':Description:\n  %s\n\n') % (text,)
530
533
                        result += ':%s:\n%s\n' % (label, sections[label])
531
534
                result += '\n'
532
535
        else:
533
 
            result += (gettext("See bzr help %s for more details and examples.\n\n")
 
536
            result += (gettext("See brz help %s for more details and examples.\n\n")
534
537
                % self.name())
535
538
 
536
539
        # Add the aliases, source (plug-in) and see also links, if any
559
562
 
560
563
        # If this will be rendered as plain text, convert it
561
564
        if plain:
562
 
            import bzrlib.help_topics
563
 
            result = bzrlib.help_topics.help_as_plain_text(result)
 
565
            import breezy.help_topics
 
566
            result = breezy.help_topics.help_as_plain_text(result)
564
567
        return result
565
568
 
566
569
    @staticmethod
577
580
        """
578
581
        def save_section(sections, order, label, section):
579
582
            if len(section) > 0:
580
 
                if sections.has_key(label):
 
583
                if label in sections:
581
584
                    sections[label] += '\n' + section
582
585
                else:
583
586
                    order.append(label)
627
630
        r = Option.STD_OPTIONS.copy()
628
631
        std_names = r.keys()
629
632
        for o in self.takes_options:
630
 
            if isinstance(o, basestring):
 
633
            if isinstance(o, string_types):
631
634
                o = option.Option.OPTIONS[o]
632
635
            r[o.name] = o
633
636
            if o.name in std_names:
645
648
        self._setup_outf()
646
649
 
647
650
        # Process the standard options
648
 
        if 'help' in opts:  # e.g. bzr add --help
 
651
        if 'help' in opts:  # e.g. brz add --help
649
652
            self.outf.write(self.get_help_text())
650
653
            return 0
651
 
        if 'usage' in opts:  # e.g. bzr add --usage
 
654
        if 'usage' in opts:  # e.g. brz add --usage
652
655
            self.outf.write(self.get_help_text(verbose=False))
653
656
            return 0
654
657
        trace.set_verbosity_level(option._verbosity_level)
655
658
        if 'verbose' in self.supported_std_options:
656
659
            opts['verbose'] = trace.is_verbose()
657
 
        elif opts.has_key('verbose'):
 
660
        elif 'verbose' in opts:
658
661
            del opts['verbose']
659
662
        if 'quiet' in self.supported_std_options:
660
663
            opts['quiet'] = trace.is_quiet()
661
 
        elif opts.has_key('quiet'):
 
664
        elif 'quiet' in opts:
662
665
            del opts['quiet']
663
666
        # mix arguments and options into one dictionary
664
667
        cmdargs = _match_argform(self.name(), self.takes_args, args)
768
771
        These are all empty initially, because by default nothing should get
769
772
        notified.
770
773
        """
771
 
        Hooks.__init__(self, "bzrlib.commands", "Command.hooks")
 
774
        Hooks.__init__(self, "breezy.commands", "Command.hooks")
772
775
        self.add_hook('extend_command',
773
776
            "Called after creating a command object to allow modifications "
774
777
            "such as adding or removing options, docs etc. Called with the "
775
 
            "new bzrlib.commands.Command object.", (1, 13))
 
778
            "new breezy.commands.Command object.", (1, 13))
776
779
        self.add_hook('get_command',
777
780
            "Called when creating a single command. Called with "
778
781
            "(cmd_or_None, command_name). get_command should either return "
779
782
            "the cmd_or_None parameter, or a replacement Command object that "
780
783
            "should be used for the command. Note that the Command.hooks "
781
784
            "hooks are core infrastructure. Many users will prefer to use "
782
 
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
 
785
            "breezy.commands.register_command or plugin_cmds.register_lazy.",
783
786
            (1, 17))
784
787
        self.add_hook('get_missing_command',
785
788
            "Called when creating a single command if no command could be "
821
824
    # option name is given.  See http://bugs.python.org/issue2931
822
825
    try:
823
826
        options, args = parser.parse_args(args)
824
 
    except UnicodeEncodeError,e:
 
827
    except UnicodeEncodeError as e:
825
828
        raise errors.BzrCommandError(
826
829
            gettext('Only ASCII permitted in option names'))
827
830
 
828
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
831
    opts = dict([(k, v) for k, v in options.__dict__.items() if
829
832
                 v is not option.OptionParser.DEFAULT_VALUE])
830
833
    return args, opts
831
834
 
878
881
    return argdict
879
882
 
880
883
def apply_coveraged(dirname, the_callable, *args, **kwargs):
881
 
    # Cannot use "import trace", as that would import bzrlib.trace instead of
 
884
    # Cannot use "import trace", as that would import breezy.trace instead of
882
885
    # the standard library's trace.
883
886
    trace = __import__('trace')
884
887
 
928
931
    """
929
932
    try:
930
933
        return the_callable(*args, **kwargs)
931
 
    except (KeyboardInterrupt, Exception), e:
 
934
    except (KeyboardInterrupt, Exception) as e:
932
935
        # used to handle AssertionError and KeyboardInterrupt
933
936
        # specially here, but hopefully they're handled ok by the logger now
934
937
        exc_info = sys.exc_info()
935
938
        exitcode = trace.report_exception(exc_info, sys.stderr)
936
 
        if os.environ.get('BZR_PDB'):
937
 
            print '**** entering debugger'
 
939
        if os.environ.get('BRZ_PDB'):
 
940
            print('**** entering debugger')
938
941
            import pdb
939
942
            pdb.post_mortem(exc_info[2])
940
943
        return exitcode
941
944
 
942
945
 
943
946
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
944
 
    from bzrlib.lsprof import profile
 
947
    from breezy.lsprof import profile
945
948
    ret, stats = profile(exception_to_return_code, the_callable,
946
949
                         *args, **kwargs)
947
950
    stats.sort()
964
967
        If it is unspecified, the global config will be used.
965
968
    """
966
969
    if config is None:
967
 
        import bzrlib.config
968
 
        config = bzrlib.config.GlobalConfig()
 
970
        import breezy.config
 
971
        config = breezy.config.GlobalConfig()
969
972
    alias = config.get_alias(cmd)
970
973
    if (alias):
971
974
        return cmdline.split(alias)
1013
1016
    --concurrency
1014
1017
        Specify the number of processes that can be run concurrently (selftest).
1015
1018
    """
1016
 
    trace.mutter("bazaar version: " + bzrlib.__version__)
 
1019
    trace.mutter("breezy version: " + breezy.__version__)
1017
1020
    argv = _specified_or_unicode_argv(argv)
1018
 
    trace.mutter("bzr arguments: %r", argv)
 
1021
    trace.mutter("brz arguments: %r", argv)
1019
1022
 
1020
1023
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
1021
1024
            opt_no_l10n = opt_no_aliases = False
1047
1050
        elif a == '--builtin':
1048
1051
            opt_builtin = True
1049
1052
        elif a == '--concurrency':
1050
 
            os.environ['BZR_CONCURRENCY'] = argv[i + 1]
 
1053
            os.environ['BRZ_CONCURRENCY'] = argv[i + 1]
1051
1054
            i += 1
1052
1055
        elif a == '--coverage':
1053
1056
            opt_coverage_dir = argv[i + 1]
1062
1065
            argv_copy.append(a)
1063
1066
        i += 1
1064
1067
 
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
    if breezy.global_state is None:
 
1069
        # FIXME: Workaround for users that imported breezy but didn't call
 
1070
        # breezy.initialize -- vila 2012-01-19
1068
1071
        cmdline_overrides = config.CommandLineStore()
1069
1072
    else:
1070
 
        cmdline_overrides = bzrlib.global_state.cmdline_overrides
 
1073
        cmdline_overrides = breezy.global_state.cmdline_overrides
1071
1074
    cmdline_overrides._from_cmdline(override_config)
1072
1075
 
1073
1076
    debug.set_debug_flags_from_config()
1096
1099
    cmd = argv.pop(0)
1097
1100
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1098
1101
    if opt_no_l10n:
1099
 
        cmd.l10n = False
 
1102
        cmd_obj.l10n = False
1100
1103
    run = cmd_obj.run_argv_aliases
1101
1104
    run_argv = [argv, alias_argv]
1102
1105
 
1138
1141
            result = func(*args, **kwargs)
1139
1142
            sys.stdout.flush()
1140
1143
            return result
1141
 
        except IOError, e:
 
1144
        except IOError as e:
1142
1145
            if getattr(e, 'errno', None) is None:
1143
1146
                raise
1144
1147
            if e.errno != errno.EPIPE:
1191
1194
def main(argv=None):
1192
1195
    """Main entry point of command-line interface.
1193
1196
 
1194
 
    Typically `bzrlib.initialize` should be called first.
 
1197
    Typically `breezy.initialize` should be called first.
1195
1198
 
1196
1199
    :param argv: list of unicode command-line arguments similar to sys.argv.
1197
1200
        argv[0] is script name usually, it will be ignored.
1198
1201
        Don't pass here sys.argv because this list contains plain strings
1199
1202
        and not unicode; pass None instead.
1200
1203
 
1201
 
    :return: exit code of bzr command.
 
1204
    :return: exit code of brz command.
1202
1205
    """
1203
1206
    if argv is not None:
1204
1207
        argv = argv[1:]
1220
1223
 
1221
1224
 
1222
1225
def run_bzr_catch_user_errors(argv):
1223
 
    """Run bzr and report user errors, but let internal errors propagate.
 
1226
    """Run brz and report user errors, but let internal errors propagate.
1224
1227
 
1225
1228
    This is used for the test suite, and might be useful for other programs
1226
1229
    that want to wrap the commandline interface.
1229
1232
    install_bzr_command_hooks()
1230
1233
    try:
1231
1234
        return run_bzr(argv)
1232
 
    except Exception, e:
 
1235
    except Exception as e:
1233
1236
        if (isinstance(e, (OSError, IOError))
1234
1237
            or not getattr(e, 'internal_error', True)):
1235
1238
            trace.report_exception(sys.exc_info(), sys.stderr)
1277
1280
    """This registry exists to allow other providers to exist"""
1278
1281
 
1279
1282
    def __iter__(self):
1280
 
        for key, provider in self.iteritems():
 
1283
        for key, provider in self.items():
1281
1284
            yield provider
1282
1285
 
1283
1286
command_providers_registry = ProvidersRegistry()