/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
18
17
 
19
18
# TODO: Define arguments by objects, rather than just using names.
20
19
# Those objects can specify the expected type of the argument, which
26
25
import os
27
26
import sys
28
27
 
29
 
from .lazy_import import lazy_import
 
28
from bzrlib.lazy_import import lazy_import
30
29
lazy_import(globals(), """
 
30
import codecs
31
31
import errno
32
32
import threading
 
33
from warnings import warn
33
34
 
34
 
import breezy
35
 
from breezy import (
36
 
    config,
 
35
import bzrlib
 
36
from bzrlib import (
37
37
    cleanup,
38
38
    cmdline,
39
39
    debug,
40
 
    i18n,
 
40
    errors,
41
41
    option,
42
42
    osutils,
43
43
    trace,
44
44
    ui,
 
45
    win32utils,
45
46
    )
46
47
""")
47
48
 
48
 
from .hooks import Hooks
49
 
from .i18n import gettext
 
49
from bzrlib.hooks import HookPoint, Hooks
50
50
# Compatibility - Option used to be in commands.
51
 
from .option import Option
52
 
from .plugin import disable_plugins, load_plugins, plugin_name
53
 
from . import errors, registry
54
 
from .sixish import (
55
 
    string_types,
56
 
    text_type,
 
51
from bzrlib.option import Option
 
52
from bzrlib.plugin import disable_plugins, load_plugins
 
53
from bzrlib import registry
 
54
from bzrlib.symbol_versioning import (
 
55
    deprecated_function,
 
56
    deprecated_in,
 
57
    deprecated_method,
57
58
    )
58
59
 
59
60
 
60
 
class BzrOptionError(errors.BzrCommandError):
61
 
 
62
 
    _fmt = "Error in command line options"
63
 
 
64
 
 
65
 
class CommandAvailableInPlugin(Exception):
66
 
 
67
 
    internal_error = False
68
 
 
69
 
    def __init__(self, cmd_name, plugin_metadata, provider):
70
 
 
71
 
        self.plugin_metadata = plugin_metadata
72
 
        self.cmd_name = cmd_name
73
 
        self.provider = provider
74
 
 
75
 
    def __str__(self):
76
 
 
77
 
        _fmt = ('"%s" is not a standard brz command. \n'
78
 
                'However, the following official plugin provides this command: %s\n'
79
 
                'You can install it by going to: %s'
80
 
                % (self.cmd_name, self.plugin_metadata['name'],
81
 
                    self.plugin_metadata['url']))
82
 
 
83
 
        return _fmt
84
 
 
85
 
 
86
61
class CommandInfo(object):
87
62
    """Information about a command."""
88
63
 
187
162
 
188
163
 
189
164
def _unsquish_command_name(cmd):
190
 
    return cmd[4:].replace('_', '-')
 
165
    return cmd[4:].replace('_','-')
 
166
 
 
167
 
 
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())
191
176
 
192
177
 
193
178
def _register_builtin_commands():
194
179
    if builtin_command_registry.keys():
195
180
        # only load once
196
181
        return
197
 
    import breezy.builtins
198
 
    for cmd_class in _scan_module_for_commands(breezy.builtins):
 
182
    import bzrlib.builtins
 
183
    for cmd_class in _scan_module_for_commands(bzrlib.builtins).values():
199
184
        builtin_command_registry.register(cmd_class)
200
 
    breezy.builtins._register_lazy_builtins()
 
185
    bzrlib.builtins._register_lazy_builtins()
201
186
 
202
187
 
203
188
def _scan_module_for_commands(module):
204
 
    module_dict = module.__dict__
205
 
    for name in module_dict:
 
189
    r = {}
 
190
    for name, obj in module.__dict__.iteritems():
206
191
        if name.startswith("cmd_"):
207
 
            yield module_dict[name]
 
192
            real_name = _unsquish_command_name(name)
 
193
            r[real_name] = obj
 
194
    return r
208
195
 
209
196
 
210
197
def _list_bzr_commands(names):
235
222
    Use of all_command_names() is encouraged rather than builtin_command_names
236
223
    and/or plugin_command_names.
237
224
    """
238
 
    _register_builtin_commands()
239
225
    return builtin_command_registry.keys()
240
226
 
241
227
 
244
230
    return plugin_cmds.keys()
245
231
 
246
232
 
247
 
# Overrides for common mispellings that heuristics get wrong
248
 
_GUESS_OVERRIDES = {
249
 
    'ic': {'ci': 0}, # heuristic finds nick
250
 
    }
251
 
 
252
 
 
253
 
def guess_command(cmd_name):
254
 
    """Guess what command a user typoed.
255
 
 
256
 
    :param cmd_name: Command to search for
257
 
    :return: None if no command was found, name of a command otherwise
258
 
    """
259
 
    names = set()
260
 
    for name in all_command_names():
261
 
        names.add(name)
262
 
        cmd = get_cmd_object(name)
263
 
        names.update(cmd.aliases)
264
 
    # candidate: modified levenshtein distance against cmd_name.
265
 
    costs = {}
266
 
    from . import patiencediff
267
 
    for name in sorted(names):
268
 
        matcher = patiencediff.PatienceSequenceMatcher(None, cmd_name, name)
269
 
        distance = 0.0
270
 
        opcodes = matcher.get_opcodes()
271
 
        for opcode, l1, l2, r1, r2 in opcodes:
272
 
            if opcode == 'delete':
273
 
                distance += l2-l1
274
 
            elif opcode == 'replace':
275
 
                distance += max(l2-l1, r2-l1)
276
 
            elif opcode == 'insert':
277
 
                distance += r2-r1
278
 
            elif opcode == 'equal':
279
 
                # Score equal ranges lower, making similar commands of equal
280
 
                # length closer than arbitrary same length commands.
281
 
                distance -= 0.1 * (l2-l1)
282
 
        costs[name] = distance
283
 
    costs.update(_GUESS_OVERRIDES.get(cmd_name, {}))
284
 
    costs = sorted((costs[key], key) for key in costs)
285
 
    if not costs:
286
 
        return
287
 
    if costs[0][0] > 4:
288
 
        return
289
 
    candidate = costs[0][1]
290
 
    return candidate
291
 
 
292
 
 
293
233
def get_cmd_object(cmd_name, plugins_override=True):
294
234
    """Return the command object for a command.
295
235
 
299
239
    try:
300
240
        return _get_cmd_object(cmd_name, plugins_override)
301
241
    except KeyError:
302
 
        # No command found, see if this was a typo
303
 
        candidate = guess_command(cmd_name)
304
 
        if candidate is not None:
305
 
            raise errors.BzrCommandError(
306
 
                    gettext('unknown command "%s". Perhaps you meant "%s"')
307
 
                    % (cmd_name, candidate))
308
 
        raise errors.BzrCommandError(gettext('unknown command "%s"')
309
 
                % cmd_name)
 
242
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
310
243
 
311
244
 
312
245
def _get_cmd_object(cmd_name, plugins_override=True, check_missing=True):
342
275
    # Allow plugins to extend commands
343
276
    for hook in Command.hooks['extend_command']:
344
277
        hook(cmd)
345
 
    if getattr(cmd, 'invoked_as', None) is None:
346
 
        cmd.invoked_as = cmd_name
347
278
    return cmd
348
279
 
349
280
 
350
 
class NoPluginAvailable(errors.BzrError):
351
 
    pass
352
 
 
353
 
 
354
281
def _try_plugin_provider(cmd_name):
355
282
    """Probe for a plugin provider having cmd_name."""
356
283
    try:
357
284
        plugin_metadata, provider = probe_for_provider(cmd_name)
358
 
        raise CommandAvailableInPlugin(cmd_name, plugin_metadata, provider)
359
 
    except NoPluginAvailable:
 
285
        raise errors.CommandAvailableInPlugin(cmd_name,
 
286
            plugin_metadata, provider)
 
287
    except errors.NoPluginAvailable:
360
288
        pass
361
289
 
362
290
 
371
299
    for provider in command_providers_registry:
372
300
        try:
373
301
            return provider.plugin_for_command(cmd_name), provider
374
 
        except NoPluginAvailable:
 
302
        except errors.NoPluginAvailable:
375
303
            pass
376
 
    raise NoPluginAvailable(cmd_name)
 
304
    raise errors.NoPluginAvailable(cmd_name)
377
305
 
378
306
 
379
307
def _get_bzr_command(cmd_or_None, cmd_name):
392
320
    # Only do external command lookups when no command is found so far.
393
321
    if cmd_or_None is not None:
394
322
        return cmd_or_None
395
 
    from breezy.externalcommand import ExternalCommand
 
323
    from bzrlib.externalcommand import ExternalCommand
396
324
    cmd_obj = ExternalCommand.find_command(cmd_name)
397
325
    if cmd_obj:
398
326
        return cmd_obj
399
327
 
400
328
 
401
329
def _get_plugin_command(cmd_or_None, cmd_name):
402
 
    """Get a command from brz's plugins."""
 
330
    """Get a command from bzr's plugins."""
403
331
    try:
404
332
        return plugin_cmds.get(cmd_name)()
405
333
    except KeyError:
414
342
class Command(object):
415
343
    """Base class for commands.
416
344
 
417
 
    Commands are the heart of the command-line brz interface.
 
345
    Commands are the heart of the command-line bzr interface.
418
346
 
419
347
    The command object mostly handles the mapping of command-line
420
 
    parameters into one or more breezy operations, and of the results
 
348
    parameters into one or more bzrlib operations, and of the results
421
349
    into textual output.
422
350
 
423
351
    Commands normally don't have any state.  All their arguments are
429
357
    summary, then a complete description of the command.  A grammar
430
358
    description will be inserted.
431
359
 
432
 
    :cvar aliases: Other accepted names for this command.
433
 
 
434
 
    :cvar takes_args: List of argument forms, marked with whether they are
435
 
        optional, repeated, etc.  Examples::
436
 
 
437
 
            ['to_location', 'from_branch?', 'file*']
438
 
 
439
 
        * 'to_location' is required
440
 
        * 'from_branch' is optional
441
 
        * 'file' can be specified 0 or more times
442
 
 
443
 
    :cvar takes_options: List of options that may be given for this command.
444
 
        These can be either strings, referring to globally-defined options, or
445
 
        option objects.  Retrieve through options().
446
 
 
447
 
    :cvar hidden: If true, this command isn't advertised.  This is typically
 
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
448
382
        for commands intended for expert users.
449
383
 
450
 
    :cvar encoding_type: Command objects will get a 'outf' attribute, which has
451
 
        been setup to properly handle encoding of unicode strings.
452
 
        encoding_type determines what will happen when characters cannot be
453
 
        encoded:
454
 
 
455
 
        * strict - abort if we cannot decode
456
 
        * replace - put in a bogus character (typically '?')
457
 
        * exact - do not encode sys.stdout
458
 
 
459
 
        NOTE: by default on Windows, sys.stdout is opened as a text stream,
460
 
        therefore LF line-endings are converted to CRLF.  When a command uses
461
 
        encoding_type = 'exact', then sys.stdout is forced to be a binary
462
 
        stream, and line-endings will not mangled.
463
 
 
464
 
    :cvar invoked_as:
465
 
        A string indicating the real name under which this command was
466
 
        invoked, before expansion of aliases.
467
 
        (This may be None if the command was constructed and run in-process.)
 
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.
468
398
 
469
399
    :cvar hooks: An instance of CommandHooks.
470
 
 
471
 
    :cvar __doc__: The help shown by 'brz help command' for this command.
472
 
        This is set by assigning explicitly to __doc__ so that -OO can
473
 
        be used::
474
 
 
475
 
            class Foo(Command):
476
 
                __doc__ = "My help goes here"
477
400
    """
478
401
    aliases = []
479
402
    takes_args = []
480
403
    takes_options = []
481
404
    encoding_type = 'strict'
482
 
    invoked_as = None
483
 
    l10n = True
484
405
 
485
406
    hidden = False
486
407
 
487
408
    def __init__(self):
488
409
        """Construct an instance of this command."""
 
410
        if self.__doc__ == Command.__doc__:
 
411
            warn("No help message set for %r" % self)
489
412
        # List of standard options directly supported
490
413
        self.supported_std_options = []
491
414
        self._setup_run()
512
435
        """
513
436
        self._operation.cleanup_now()
514
437
 
 
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
 
515
451
    def _usage(self):
516
452
        """Return single-line grammar for this command.
517
453
 
518
454
        Only describes arguments, not options.
519
455
        """
520
 
        s = 'brz ' + self.name() + ' '
 
456
        s = 'bzr ' + self.name() + ' '
521
457
        for aname in self.takes_args:
522
458
            aname = aname.upper()
523
459
            if aname[-1] in ['$', '+']:
545
481
            usage help (e.g. Purpose, Usage, Options) with a
546
482
            message explaining how to obtain full help.
547
483
        """
548
 
        if self.l10n:
549
 
            i18n.install()  # Install i18n only for get_help_text for now.
550
484
        doc = self.help()
551
 
        if doc:
552
 
            # Note: If self.gettext() translates ':Usage:\n', the section will
553
 
            # be shown after "Description" section and we don't want to
554
 
            # translate the usage string.
555
 
            # Though, brz export-pot don't exports :Usage: section and it must
556
 
            # not be translated.
557
 
            doc = self.gettext(doc)
558
 
        else:
559
 
            doc = gettext("No help for this command.")
 
485
        if doc is None:
 
486
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
560
487
 
561
488
        # Extract the summary (purpose) and sections out from the text
562
 
        purpose, sections, order = self._get_help_parts(doc)
 
489
        purpose,sections,order = self._get_help_parts(doc)
563
490
 
564
491
        # If a custom usage section was provided, use it
565
 
        if 'Usage' in sections:
 
492
        if sections.has_key('Usage'):
566
493
            usage = sections.pop('Usage')
567
494
        else:
568
495
            usage = self._usage()
569
496
 
570
497
        # The header is the purpose and usage
571
498
        result = ""
572
 
        result += gettext(':Purpose: %s\n') % (purpose,)
 
499
        result += ':Purpose: %s\n' % purpose
573
500
        if usage.find('\n') >= 0:
574
 
            result += gettext(':Usage:\n%s\n') % (usage,)
 
501
            result += ':Usage:\n%s\n' % usage
575
502
        else:
576
 
            result += gettext(':Usage:   %s\n') % (usage,)
 
503
            result += ':Usage:   %s\n' % usage
577
504
        result += '\n'
578
505
 
579
506
        # Add the options
581
508
        # XXX: optparse implicitly rewraps the help, and not always perfectly,
582
509
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
583
510
        # 20090319
584
 
        parser = option.get_optparser(self.options())
585
 
        options = parser.format_option_help()
586
 
        # FIXME: According to the spec, ReST option lists actually don't
587
 
        # support options like --1.14 so that causes syntax errors (in Sphinx
588
 
        # at least).  As that pattern always appears in the commands that
589
 
        # break, we trap on that and then format that block of 'format' options
590
 
        # as a literal block. We use the most recent format still listed so we
591
 
        # don't have to do that too often -- vila 20110514
592
 
        if not plain and options.find('  --1.14  ') != -1:
 
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:
593
518
            options = options.replace(' format:\n', ' format::\n\n', 1)
594
519
        if options.startswith('Options:'):
595
 
            result += gettext(':Options:%s') % (options[len('options:'):],)
 
520
            result += ':' + options
 
521
        elif options.startswith('options:'):
 
522
            # Python 2.4 version of optparse
 
523
            result += ':Options:' + options[len('options:'):]
596
524
        else:
597
525
            result += options
598
526
        result += '\n'
600
528
        if verbose:
601
529
            # Add the description, indenting it 2 spaces
602
530
            # to match the indentation of the options
603
 
            if None in sections:
 
531
            if sections.has_key(None):
604
532
                text = sections.pop(None)
605
533
                text = '\n  '.join(text.splitlines())
606
 
                result += gettext(':Description:\n  %s\n\n') % (text,)
 
534
                result += ':%s:\n  %s\n\n' % ('Description',text)
607
535
 
608
536
            # Add the custom sections (e.g. Examples). Note that there's no need
609
537
            # to indent these as they must be indented already in the source.
610
538
            if sections:
611
539
                for label in order:
612
 
                    if label in sections:
613
 
                        result += ':%s:\n%s\n' % (label, sections[label])
 
540
                    if sections.has_key(label):
 
541
                        result += ':%s:\n%s\n' % (label,sections[label])
614
542
                result += '\n'
615
543
        else:
616
 
            result += (gettext("See brz help %s for more details and examples.\n\n")
 
544
            result += ("See bzr help %s for more details and examples.\n\n"
617
545
                % self.name())
618
546
 
619
547
        # Add the aliases, source (plug-in) and see also links, if any
620
548
        if self.aliases:
621
 
            result += gettext(':Aliases:  ')
 
549
            result += ':Aliases:  '
622
550
            result += ', '.join(self.aliases) + '\n'
623
551
        plugin_name = self.plugin_name()
624
552
        if plugin_name is not None:
625
 
            result += gettext(':From:     plugin "%s"\n') % plugin_name
 
553
            result += ':From:     plugin "%s"\n' % plugin_name
626
554
        see_also = self.get_see_also(additional_see_also)
627
555
        if see_also:
628
556
            if not plain and see_also_as_links:
634
562
                        see_also_links.append(item)
635
563
                    else:
636
564
                        # Use a Sphinx link for this entry
637
 
                        link_text = gettext(":doc:`{0} <{1}-help>`").format(
638
 
                                                                    item, item)
 
565
                        link_text = ":doc:`%s <%s-help>`" % (item, item)
639
566
                        see_also_links.append(link_text)
640
567
                see_also = see_also_links
641
 
            result += gettext(':See also: %s') % ', '.join(see_also) + '\n'
 
568
            result += ':See also: '
 
569
            result += ', '.join(see_also) + '\n'
642
570
 
643
571
        # If this will be rendered as plain text, convert it
644
572
        if plain:
645
 
            import breezy.help_topics
646
 
            result = breezy.help_topics.help_as_plain_text(result)
 
573
            import bzrlib.help_topics
 
574
            result = bzrlib.help_topics.help_as_plain_text(result)
647
575
        return result
648
576
 
649
577
    @staticmethod
660
588
        """
661
589
        def save_section(sections, order, label, section):
662
590
            if len(section) > 0:
663
 
                if label in sections:
 
591
                if sections.has_key(label):
664
592
                    sections[label] += '\n' + section
665
593
                else:
666
594
                    order.append(label)
670
598
        summary = lines.pop(0)
671
599
        sections = {}
672
600
        order = []
673
 
        label, section = None, ''
 
601
        label,section = None,''
674
602
        for line in lines:
675
603
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
676
604
                save_section(sections, order, label, section)
677
 
                label, section = line[1:-1], ''
 
605
                label,section = line[1:-1],''
678
606
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
679
607
                save_section(sections, order, label, section)
680
 
                label, section = None, line
 
608
                label,section = None,line
681
609
            else:
682
610
                if len(section) > 0:
683
611
                    section += '\n' + line
708
636
 
709
637
        Maps from long option name to option object."""
710
638
        r = Option.STD_OPTIONS.copy()
711
 
        std_names = set(r)
 
639
        std_names = r.keys()
712
640
        for o in self.takes_options:
713
 
            if isinstance(o, string_types):
 
641
            if isinstance(o, basestring):
714
642
                o = option.Option.OPTIONS[o]
715
643
            r[o.name] = o
716
644
            if o.name in std_names:
725
653
    def run_argv_aliases(self, argv, alias_argv=None):
726
654
        """Parse the command line and run with extra aliases in alias_argv."""
727
655
        args, opts = parse_args(self, argv, alias_argv)
728
 
        self._setup_outf()
729
656
 
730
657
        # Process the standard options
731
 
        if 'help' in opts:  # e.g. brz add --help
732
 
            self.outf.write(self.get_help_text())
 
658
        if 'help' in opts:  # e.g. bzr add --help
 
659
            sys.stdout.write(self.get_help_text())
733
660
            return 0
734
 
        if 'usage' in opts:  # e.g. brz add --usage
735
 
            self.outf.write(self.get_help_text(verbose=False))
 
661
        if 'usage' in opts:  # e.g. bzr add --usage
 
662
            sys.stdout.write(self.get_help_text(verbose=False))
736
663
            return 0
737
664
        trace.set_verbosity_level(option._verbosity_level)
738
665
        if 'verbose' in self.supported_std_options:
739
666
            opts['verbose'] = trace.is_verbose()
740
 
        elif 'verbose' in opts:
 
667
        elif opts.has_key('verbose'):
741
668
            del opts['verbose']
742
669
        if 'quiet' in self.supported_std_options:
743
670
            opts['quiet'] = trace.is_quiet()
744
 
        elif 'quiet' in opts:
 
671
        elif opts.has_key('quiet'):
745
672
            del opts['quiet']
 
673
 
746
674
        # mix arguments and options into one dictionary
747
675
        cmdargs = _match_argform(self.name(), self.takes_args, args)
748
676
        cmdopts = {}
752
680
        all_cmd_args = cmdargs.copy()
753
681
        all_cmd_args.update(cmdopts)
754
682
 
755
 
        try:
756
 
            return self.run(**all_cmd_args)
757
 
        finally:
758
 
            # reset it, so that other commands run in the same process won't
759
 
            # inherit state. Before we reset it, log any activity, so that it
760
 
            # gets properly tracked.
761
 
            ui.ui_factory.log_transport_activity(
762
 
                display=('bytes' in debug.debug_flags))
763
 
            trace.set_verbosity_level(0)
 
683
        self._setup_outf()
 
684
 
 
685
        return self.run(**all_cmd_args)
764
686
 
765
687
    def _setup_run(self):
766
688
        """Wrap the defined run method on self with a cleanup.
773
695
        """
774
696
        class_run = self.run
775
697
        def run(*args, **kwargs):
776
 
            for hook in Command.hooks['pre_command']:
777
 
                hook(self)
778
698
            self._operation = cleanup.OperationWithCleanups(class_run)
779
699
            try:
780
700
                return self._operation.run_simple(*args, **kwargs)
781
701
            finally:
782
702
                del self._operation
783
 
                for hook in Command.hooks['post_command']:
784
 
                    hook(self)
785
703
        self.run = run
786
704
 
 
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
 
787
710
    def run(self):
788
711
        """Actually run the command.
789
712
 
815
738
            return None
816
739
        return getdoc(self)
817
740
 
818
 
    def gettext(self, message):
819
 
        """Returns the gettext function used to translate this command's help.
820
 
 
821
 
        Commands provided by plugins should override this to use their
822
 
        own i18n system.
823
 
        """
824
 
        return i18n.gettext_per_paragraph(message)
825
 
 
826
741
    def name(self):
827
 
        """Return the canonical name for this command.
828
 
 
829
 
        The name under which it was actually invoked is available in invoked_as.
830
 
        """
831
742
        return _unsquish_command_name(self.__class__.__name__)
832
743
 
833
744
    def plugin_name(self):
835
746
 
836
747
        :return: The name of the plugin or None if the command is builtin.
837
748
        """
838
 
        return plugin_name(self.__module__)
 
749
        mod_parts = self.__module__.split('.')
 
750
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
751
            return mod_parts[2]
 
752
        else:
 
753
            return None
839
754
 
840
755
 
841
756
class CommandHooks(Hooks):
847
762
        These are all empty initially, because by default nothing should get
848
763
        notified.
849
764
        """
850
 
        Hooks.__init__(self, "breezy.commands", "Command.hooks")
851
 
        self.add_hook('extend_command',
 
765
        Hooks.__init__(self)
 
766
        self.create_hook(HookPoint('extend_command',
852
767
            "Called after creating a command object to allow modifications "
853
768
            "such as adding or removing options, docs etc. Called with the "
854
 
            "new breezy.commands.Command object.", (1, 13))
855
 
        self.add_hook('get_command',
 
769
            "new bzrlib.commands.Command object.", (1, 13), None))
 
770
        self.create_hook(HookPoint('get_command',
856
771
            "Called when creating a single command. Called with "
857
772
            "(cmd_or_None, command_name). get_command should either return "
858
773
            "the cmd_or_None parameter, or a replacement Command object that "
859
774
            "should be used for the command. Note that the Command.hooks "
860
775
            "hooks are core infrastructure. Many users will prefer to use "
861
 
            "breezy.commands.register_command or plugin_cmds.register_lazy.",
862
 
            (1, 17))
863
 
        self.add_hook('get_missing_command',
 
776
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
 
777
            (1, 17), None))
 
778
        self.create_hook(HookPoint('get_missing_command',
864
779
            "Called when creating a single command if no command could be "
865
780
            "found. Called with (command_name). get_missing_command should "
866
781
            "either return None, or a Command object to be used for the "
867
 
            "command.", (1, 17))
868
 
        self.add_hook('list_commands',
 
782
            "command.", (1, 17), None))
 
783
        self.create_hook(HookPoint('list_commands',
869
784
            "Called when enumerating commands. Called with a set of "
870
785
            "cmd_name strings for all the commands found so far. This set "
871
786
            " is safe to mutate - e.g. to remove a command. "
872
787
            "list_commands should return the updated set of command names.",
873
 
            (1, 17))
874
 
        self.add_hook('pre_command',
875
 
            "Called prior to executing a command. Called with the command "
876
 
            "object.", (2, 6))
877
 
        self.add_hook('post_command',
878
 
            "Called after executing a command. Called with the command "
879
 
            "object.", (2, 6))
 
788
            (1, 17), None))
880
789
 
881
790
Command.hooks = CommandHooks()
882
791
 
896
805
    else:
897
806
        args = argv
898
807
 
899
 
    # for python 2.5 and later, optparse raises this exception if a non-ascii
900
 
    # option name is given.  See http://bugs.python.org/issue2931
901
 
    try:
902
 
        options, args = parser.parse_args(args)
903
 
    except UnicodeEncodeError as e:
904
 
        raise errors.BzrCommandError(
905
 
            gettext('Only ASCII permitted in option names'))
906
 
 
907
 
    opts = dict((k, v) for k, v in options.__dict__.items() if
908
 
                v is not option.OptionParser.DEFAULT_VALUE)
 
808
    options, args = parser.parse_args(args)
 
809
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
810
                 v is not option.OptionParser.DEFAULT_VALUE])
909
811
    return args, opts
910
812
 
911
813
 
926
828
                argdict[argname + '_list'] = None
927
829
        elif ap[-1] == '+':
928
830
            if not args:
929
 
                raise errors.BzrCommandError(gettext(
930
 
                      "command {0!r} needs one or more {1}").format(
931
 
                      cmd, argname.upper()))
 
831
                raise errors.BzrCommandError("command %r needs one or more %s"
 
832
                                             % (cmd, argname.upper()))
932
833
            else:
933
834
                argdict[argname + '_list'] = args[:]
934
835
                args = []
935
836
        elif ap[-1] == '$': # all but one
936
837
            if len(args) < 2:
937
 
                raise errors.BzrCommandError(
938
 
                      gettext("command {0!r} needs one or more {1}").format(
939
 
                                             cmd, argname.upper()))
 
838
                raise errors.BzrCommandError("command %r needs one or more %s"
 
839
                                             % (cmd, argname.upper()))
940
840
            argdict[argname + '_list'] = args[:-1]
941
841
            args[:-1] = []
942
842
        else:
943
843
            # just a plain arg
944
844
            argname = ap
945
845
            if not args:
946
 
                raise errors.BzrCommandError(
947
 
                     gettext("command {0!r} requires argument {1}").format(
948
 
                               cmd, argname.upper()))
 
846
                raise errors.BzrCommandError("command %r requires argument %s"
 
847
                               % (cmd, argname.upper()))
949
848
            else:
950
849
                argdict[argname] = args.pop(0)
951
850
 
952
851
    if args:
953
 
        raise errors.BzrCommandError( gettext(
954
 
                              "extra argument to command {0}: {1}").format(
955
 
                                       cmd, args[0]) )
 
852
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
853
                                     % (cmd, args[0]))
956
854
 
957
855
    return argdict
958
856
 
959
 
 
960
 
def apply_coveraged(the_callable, *args, **kwargs):
961
 
    import coverage
962
 
    cov = coverage.Coverage()
963
 
    os.environ['COVERAGE_PROCESS_START'] = cov.config_file
964
 
    cov.start()
 
857
def apply_coveraged(dirname, the_callable, *args, **kwargs):
 
858
    # Cannot use "import trace", as that would import bzrlib.trace instead of
 
859
    # the standard library's trace.
 
860
    trace = __import__('trace')
 
861
 
 
862
    tracer = trace.Trace(count=1, trace=0)
 
863
    sys.settrace(tracer.globaltrace)
 
864
    threading.settrace(tracer.globaltrace)
 
865
 
965
866
    try:
966
867
        return exception_to_return_code(the_callable, *args, **kwargs)
967
868
    finally:
968
 
        cov.stop()
969
 
        cov.save()
 
869
        sys.settrace(None)
 
870
        results = tracer.results()
 
871
        results.write_results(show_missing=1, summary=False,
 
872
                              coverdir=dirname)
970
873
 
971
874
 
972
875
def apply_profiled(the_callable, *args, **kwargs):
1002
905
    """
1003
906
    try:
1004
907
        return the_callable(*args, **kwargs)
1005
 
    except (KeyboardInterrupt, Exception) as e:
 
908
    except (KeyboardInterrupt, Exception), e:
1006
909
        # used to handle AssertionError and KeyboardInterrupt
1007
910
        # specially here, but hopefully they're handled ok by the logger now
1008
911
        exc_info = sys.exc_info()
1009
912
        exitcode = trace.report_exception(exc_info, sys.stderr)
1010
 
        if os.environ.get('BRZ_PDB'):
1011
 
            print('**** entering debugger')
 
913
        if os.environ.get('BZR_PDB'):
 
914
            print '**** entering debugger'
 
915
            tb = exc_info[2]
1012
916
            import pdb
1013
 
            pdb.post_mortem(exc_info[2])
 
917
            if sys.version_info[:2] < (2, 6):
 
918
                # XXX: we want to do
 
919
                #    pdb.post_mortem(tb)
 
920
                # but because pdb.post_mortem gives bad results for tracebacks
 
921
                # from inside generators, we do it manually.
 
922
                # (http://bugs.python.org/issue4150, fixed in Python 2.6)
 
923
 
 
924
                # Setup pdb on the traceback
 
925
                p = pdb.Pdb()
 
926
                p.reset()
 
927
                p.setup(tb.tb_frame, tb)
 
928
                # Point the debugger at the deepest frame of the stack
 
929
                p.curindex = len(p.stack) - 1
 
930
                p.curframe = p.stack[p.curindex][0]
 
931
                # Start the pdb prompt.
 
932
                p.print_stack_entry(p.stack[p.curindex])
 
933
                p.execRcLines()
 
934
                p.cmdloop()
 
935
            else:
 
936
                pdb.post_mortem(tb)
1014
937
        return exitcode
1015
938
 
1016
939
 
1017
940
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
1018
 
    from breezy.lsprof import profile
1019
 
    ret, stats = profile(exception_to_return_code, the_callable,
1020
 
                         *args, **kwargs)
 
941
    from bzrlib.lsprof import profile
 
942
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
1021
943
    stats.sort()
1022
944
    if filename is None:
1023
945
        stats.pprint()
1024
946
    else:
1025
947
        stats.save(filename)
1026
 
        trace.note(gettext('Profile data written to "%s".'), filename)
 
948
        trace.note('Profile data written to "%s".', filename)
1027
949
    return ret
1028
950
 
1029
951
 
 
952
@deprecated_function(deprecated_in((2, 2, 0)))
 
953
def shlex_split_unicode(unsplit):
 
954
    return cmdline.split(unsplit)
 
955
 
 
956
 
1030
957
def get_alias(cmd, config=None):
1031
958
    """Return an expanded alias, or None if no alias exists.
1032
959
 
1038
965
        If it is unspecified, the global config will be used.
1039
966
    """
1040
967
    if config is None:
1041
 
        import breezy.config
1042
 
        config = breezy.config.GlobalConfig()
 
968
        import bzrlib.config
 
969
        config = bzrlib.config.GlobalConfig()
1043
970
    alias = config.get_alias(cmd)
1044
971
    if (alias):
1045
972
        return cmdline.split(alias)
1082
1009
        Run under the Python lsprof profiler.
1083
1010
 
1084
1011
    --coverage
1085
 
        Generate code coverage report
 
1012
        Generate line coverage report in the specified directory.
1086
1013
 
1087
1014
    --concurrency
1088
1015
        Specify the number of processes that can be run concurrently (selftest).
1089
1016
    """
1090
 
    trace.mutter("breezy version: " + breezy.__version__)
1091
 
    argv = _specified_or_unicode_argv(argv)
1092
 
    trace.mutter("brz arguments: %r", argv)
 
1017
    trace.mutter("bazaar version: " + bzrlib.__version__)
 
1018
    argv = list(argv)
 
1019
    trace.mutter("bzr arguments: %r", argv)
1093
1020
 
1094
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
1095
 
            opt_coverage = opt_no_l10n = opt_no_aliases = False
1096
 
    opt_lsprof_file = None
 
1021
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
1022
                opt_no_aliases = False
 
1023
    opt_lsprof_file = opt_coverage_dir = None
1097
1024
 
1098
1025
    # --no-plugins is handled specially at a very early stage. We need
1099
1026
    # to load plugins before doing other command parsing so that they
1101
1028
 
1102
1029
    argv_copy = []
1103
1030
    i = 0
1104
 
    override_config = []
1105
1031
    while i < len(argv):
1106
1032
        a = argv[i]
1107
1033
        if a == '--profile':
1116
1042
            opt_no_plugins = True
1117
1043
        elif a == '--no-aliases':
1118
1044
            opt_no_aliases = True
1119
 
        elif a == '--no-l10n':
1120
 
            opt_no_l10n = True
1121
1045
        elif a == '--builtin':
1122
1046
            opt_builtin = True
1123
1047
        elif a == '--concurrency':
1124
 
            os.environ['BRZ_CONCURRENCY'] = argv[i + 1]
 
1048
            os.environ['BZR_CONCURRENCY'] = argv[i + 1]
1125
1049
            i += 1
1126
1050
        elif a == '--coverage':
1127
 
            opt_coverage = True
1128
 
        elif a == '--profile-imports':
1129
 
            pass # already handled in startup script Bug #588277
 
1051
            opt_coverage_dir = argv[i + 1]
 
1052
            i += 1
1130
1053
        elif a.startswith('-D'):
1131
1054
            debug.debug_flags.add(a[2:])
1132
 
        elif a.startswith('-O'):
1133
 
            override_config.append(a[2:])
1134
1055
        else:
1135
1056
            argv_copy.append(a)
1136
1057
        i += 1
1137
1058
 
1138
 
    cmdline_overrides = breezy.get_global_state().cmdline_overrides
1139
 
    cmdline_overrides._from_cmdline(override_config)
1140
 
 
1141
1059
    debug.set_debug_flags_from_config()
1142
1060
 
1143
1061
    if not opt_no_plugins:
1159
1077
    if not opt_no_aliases:
1160
1078
        alias_argv = get_alias(argv[0])
1161
1079
        if alias_argv:
 
1080
            user_encoding = osutils.get_user_encoding()
 
1081
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1162
1082
            argv[0] = alias_argv.pop(0)
1163
1083
 
1164
1084
    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
 
1165
1089
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1166
 
    if opt_no_l10n:
1167
 
        cmd_obj.l10n = False
1168
1090
    run = cmd_obj.run_argv_aliases
1169
1091
    run_argv = [argv, alias_argv]
1170
1092
 
1174
1096
        saved_verbosity_level = option._verbosity_level
1175
1097
        option._verbosity_level = 0
1176
1098
        if opt_lsprof:
1177
 
            if opt_coverage:
 
1099
            if opt_coverage_dir:
1178
1100
                trace.warning(
1179
1101
                    '--coverage ignored, because --lsprof is in use.')
1180
1102
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
1181
1103
        elif opt_profile:
1182
 
            if opt_coverage:
 
1104
            if opt_coverage_dir:
1183
1105
                trace.warning(
1184
1106
                    '--coverage ignored, because --profile is in use.')
1185
1107
            ret = apply_profiled(run, *run_argv)
1186
 
        elif opt_coverage:
1187
 
            ret = apply_coveraged(run, *run_argv)
 
1108
        elif opt_coverage_dir:
 
1109
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
1188
1110
        else:
1189
1111
            ret = run(*run_argv)
1190
1112
        return ret or 0
1195
1117
        if 'memory' in debug.debug_flags:
1196
1118
            trace.debug_memory('Process status after command:', short=False)
1197
1119
        option._verbosity_level = saved_verbosity_level
1198
 
        # Reset the overrides 
1199
 
        cmdline_overrides._reset()
1200
1120
 
1201
1121
 
1202
1122
def display_command(func):
1206
1126
            result = func(*args, **kwargs)
1207
1127
            sys.stdout.flush()
1208
1128
            return result
1209
 
        except IOError as e:
 
1129
        except IOError, e:
1210
1130
            if getattr(e, 'errno', None) is None:
1211
1131
                raise
1212
1132
            if e.errno != errno.EPIPE:
1231
1151
        "bzr plugin commands")
1232
1152
    Command.hooks.install_named_hook("get_command", _get_external_command,
1233
1153
        "bzr external command lookup")
1234
 
    Command.hooks.install_named_hook("get_missing_command",
1235
 
                                     _try_plugin_provider,
1236
 
                                     "bzr plugin-provider-db check")
 
1154
    Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
 
1155
        "bzr plugin-provider-db check")
1237
1156
 
1238
1157
 
1239
1158
 
1242
1161
    # the process arguments in a unicode-safe way.
1243
1162
    if argv is None:
1244
1163
        return osutils.get_unicode_argv()
1245
 
    new_argv = []
1246
 
    try:
1247
 
        # ensure all arguments are unicode strings
1248
 
        for a in argv:
1249
 
            if not isinstance(a, string_types):
1250
 
                raise ValueError('not native str or unicode: %r' % (a,))
1251
 
            if isinstance(a, bytes):
1252
 
                # For Python 2 only allow ascii native strings
1253
 
                a = a.decode('ascii')
1254
 
            new_argv.append(a)
1255
 
    except (ValueError, UnicodeDecodeError):
1256
 
        raise errors.BzrError("argv should be list of unicode strings.")
1257
 
    return new_argv
 
1164
    else:
 
1165
        new_argv = []
 
1166
        try:
 
1167
            # ensure all arguments are unicode strings
 
1168
            for a in argv[1:]:
 
1169
                if isinstance(a, unicode):
 
1170
                    new_argv.append(a)
 
1171
                else:
 
1172
                    new_argv.append(a.decode('ascii'))
 
1173
        except UnicodeDecodeError:
 
1174
            raise errors.BzrError("argv should be list of unicode strings.")
 
1175
        return new_argv
1258
1176
 
1259
1177
 
1260
1178
def main(argv=None):
1261
1179
    """Main entry point of command-line interface.
1262
1180
 
1263
 
    Typically `breezy.initialize` should be called first.
 
1181
    Typically `bzrlib.initialize` should be called first.
1264
1182
 
1265
1183
    :param argv: list of unicode command-line arguments similar to sys.argv.
1266
1184
        argv[0] is script name usually, it will be ignored.
1267
1185
        Don't pass here sys.argv because this list contains plain strings
1268
1186
        and not unicode; pass None instead.
1269
1187
 
1270
 
    :return: exit code of brz command.
 
1188
    :return: exit code of bzr command.
1271
1189
    """
1272
 
    if argv is not None:
1273
 
        argv = argv[1:]
 
1190
    argv = _specified_or_unicode_argv(argv)
1274
1191
    _register_builtin_commands()
1275
1192
    ret = run_bzr_catch_errors(argv)
 
1193
    bzrlib.ui.ui_factory.log_transport_activity(
 
1194
        display=('bytes' in debug.debug_flags))
1276
1195
    trace.mutter("return code %d", ret)
1277
1196
    return ret
1278
1197
 
1289
1208
 
1290
1209
 
1291
1210
def run_bzr_catch_user_errors(argv):
1292
 
    """Run brz and report user errors, but let internal errors propagate.
 
1211
    """Run bzr and report user errors, but let internal errors propagate.
1293
1212
 
1294
1213
    This is used for the test suite, and might be useful for other programs
1295
1214
    that want to wrap the commandline interface.
1298
1217
    install_bzr_command_hooks()
1299
1218
    try:
1300
1219
        return run_bzr(argv)
1301
 
    except Exception as e:
 
1220
    except Exception, e:
1302
1221
        if (isinstance(e, (OSError, IOError))
1303
1222
            or not getattr(e, 'internal_error', True)):
1304
1223
            trace.report_exception(sys.exc_info(), sys.stderr)
1331
1250
 
1332
1251
 
1333
1252
class Provider(object):
1334
 
    """Generic class to be overriden by plugins"""
 
1253
    '''Generic class to be overriden by plugins'''
1335
1254
 
1336
1255
    def plugin_for_command(self, cmd_name):
1337
 
        """Takes a command and returns the information for that plugin
 
1256
        '''Takes a command and returns the information for that plugin
1338
1257
 
1339
1258
        :return: A dictionary with all the available information
1340
 
            for the requested plugin
1341
 
        """
 
1259
        for the requested plugin
 
1260
        '''
1342
1261
        raise NotImplementedError
1343
1262
 
1344
1263
 
1345
1264
class ProvidersRegistry(registry.Registry):
1346
 
    """This registry exists to allow other providers to exist"""
 
1265
    '''This registry exists to allow other providers to exist'''
1347
1266
 
1348
1267
    def __iter__(self):
1349
 
        for key, provider in self.items():
 
1268
        for key, provider in self.iteritems():
1350
1269
            yield provider
1351
1270
 
1352
1271
command_providers_registry = ProvidersRegistry()