← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: John Arbash Meinel
  • Date: 2006-08-23 22:16:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1955.
  • Revision ID: john@arbash-meinel.com-20060823221627-fc64105bb12ae770
Ghozzy: Fix Bzr's support of Active FTP (aftp://)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006 by 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
28
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
29
# the profile output behind so it can be interactively examined?
30
30
 
31
 
import os
32
 
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
31
import codecs
37
32
import errno
 
33
import os
38
34
from warnings import warn
 
35
import sys
39
36
 
40
37
import bzrlib
41
 
from bzrlib import (
42
 
    debug,
43
 
    errors,
44
 
    option,
45
 
    osutils,
46
 
    registry,
47
 
    trace,
48
 
    win32utils,
49
 
    )
50
 
""")
51
 
 
52
 
from bzrlib.symbol_versioning import (
53
 
    deprecated_function,
54
 
    deprecated_method,
55
 
    )
56
 
# Compatibility
 
38
import bzrlib.errors as errors
 
39
from bzrlib.errors import (BzrError,
 
40
                           BzrCommandError,
 
41
                           BzrCheckError,
 
42
                           NotBranchError)
 
43
from bzrlib import option
57
44
from bzrlib.option import Option
58
 
 
 
45
import bzrlib.osutils
 
46
from bzrlib.revisionspec import RevisionSpec
 
47
from bzrlib.symbol_versioning import (deprecated_method, zero_eight)
 
48
import bzrlib.trace
 
49
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
59
50
 
60
51
plugin_cmds = {}
61
52
 
74
65
        k_unsquished = _unsquish_command_name(k)
75
66
    else:
76
67
        k_unsquished = k
77
 
    if k_unsquished not in plugin_cmds:
 
68
    if not plugin_cmds.has_key(k_unsquished):
78
69
        plugin_cmds[k_unsquished] = cmd
79
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
 
70
        mutter('registered plugin command %s', k_unsquished)
80
71
        if decorate and k_unsquished in builtin_command_names():
81
72
            return _builtin_commands()[k_unsquished]
82
73
    elif decorate:
84
75
        plugin_cmds[k_unsquished] = cmd
85
76
        return result
86
77
    else:
87
 
        trace.log_error('Two plugins defined the same command: %r' % k)
88
 
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
89
 
        trace.log_error('Previously this command was registered from %r' %
90
 
                        sys.modules[plugin_cmds[k_unsquished].__module__])
 
78
        log_error('Two plugins defined the same command: %r' % k)
 
79
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
91
80
 
92
81
 
93
82
def _squish_command_name(cmd):
95
84
 
96
85
 
97
86
def _unsquish_command_name(cmd):
 
87
    assert cmd.startswith("cmd_")
98
88
    return cmd[4:].replace('_','-')
99
89
 
100
90
 
138
128
    plugins_override
139
129
        If true, plugin commands can override builtins.
140
130
    """
141
 
    try:
142
 
        return _get_cmd_object(cmd_name, plugins_override)
143
 
    except KeyError:
144
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
145
 
 
146
 
 
147
 
def _get_cmd_object(cmd_name, plugins_override=True):
148
 
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
149
131
    from bzrlib.externalcommand import ExternalCommand
150
132
 
151
 
    # We want only 'ascii' command names, but the user may have typed
152
 
    # in a Unicode name. In that case, they should just get a
153
 
    # 'command not found' error later.
154
 
    # In the future, we may actually support Unicode command names.
 
133
    cmd_name = str(cmd_name)            # not unicode
155
134
 
156
135
    # first look up this command under the specified name
157
136
    cmds = _get_cmd_dict(plugins_override=plugins_override)
169
148
    if cmd_obj:
170
149
        return cmd_obj
171
150
 
172
 
    # look for plugins that provide this command but aren't installed
173
 
    for provider in command_providers_registry:
174
 
        try:
175
 
            plugin_metadata = provider.plugin_for_command(cmd_name)
176
 
        except errors.NoPluginAvailable:
177
 
            pass
178
 
        else:
179
 
            raise errors.CommandAvailableInPlugin(cmd_name, 
180
 
                                                  plugin_metadata, provider)
181
 
 
182
 
    raise KeyError
 
151
    raise BzrCommandError('unknown command "%s"' % cmd_name)
183
152
 
184
153
 
185
154
class Command(object):
233
202
            replace - put in a bogus character (typically '?')
234
203
            exact - do not encode sys.stdout
235
204
 
236
 
            NOTE: by default on Windows, sys.stdout is opened as a text
237
 
            stream, therefore LF line-endings are converted to CRLF.
238
 
            When a command uses encoding_type = 'exact', then
239
 
            sys.stdout is forced to be a binary stream, and line-endings
240
 
            will not mangled.
241
 
 
242
205
    """
243
206
    aliases = []
244
207
    takes_args = []
251
214
        """Construct an instance of this command."""
252
215
        if self.__doc__ == Command.__doc__:
253
216
            warn("No help message set for %r" % self)
254
 
        # List of standard options directly supported
255
 
        self.supported_std_options = []
256
 
 
257
 
    def _maybe_expand_globs(self, file_list):
258
 
        """Glob expand file_list if the platform does not do that itself.
259
 
        
260
 
        :return: A possibly empty list of unicode paths.
261
 
 
262
 
        Introduced in bzrlib 0.18.
263
 
        """
264
 
        if not file_list:
265
 
            file_list = []
266
 
        if sys.platform == 'win32':
267
 
            file_list = win32utils.glob_expand(file_list)
268
 
        return list(file_list)
269
 
 
270
 
    def _usage(self):
271
 
        """Return single-line grammar for this command.
272
 
 
273
 
        Only describes arguments, not options.
274
 
        """
275
 
        s = 'bzr ' + self.name() + ' '
276
 
        for aname in self.takes_args:
277
 
            aname = aname.upper()
278
 
            if aname[-1] in ['$', '+']:
279
 
                aname = aname[:-1] + '...'
280
 
            elif aname[-1] == '?':
281
 
                aname = '[' + aname[:-1] + ']'
282
 
            elif aname[-1] == '*':
283
 
                aname = '[' + aname[:-1] + '...]'
284
 
            s += aname + ' '
285
 
        s = s[:-1]      # remove last space
286
 
        return s
287
 
 
288
 
    def get_help_text(self, additional_see_also=None, plain=True,
289
 
                      see_also_as_links=False):
290
 
        """Return a text string with help for this command.
291
 
        
292
 
        :param additional_see_also: Additional help topics to be
293
 
            cross-referenced.
294
 
        :param plain: if False, raw help (reStructuredText) is
295
 
            returned instead of plain text.
296
 
        :param see_also_as_links: if True, convert items in 'See also'
297
 
            list to internal links (used by bzr_man rstx generator)
298
 
        """
299
 
        doc = self.help()
300
 
        if doc is None:
301
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
302
 
 
303
 
        # Extract the summary (purpose) and sections out from the text
304
 
        purpose,sections = self._get_help_parts(doc)
305
 
 
306
 
        # If a custom usage section was provided, use it
307
 
        if sections.has_key('Usage'):
308
 
            usage = sections.pop('Usage')
309
 
        else:
310
 
            usage = self._usage()
311
 
 
312
 
        # The header is the purpose and usage
313
 
        result = ""
314
 
        result += ':Purpose: %s\n' % purpose
315
 
        if usage.find('\n') >= 0:
316
 
            result += ':Usage:\n%s\n' % usage
317
 
        else:
318
 
            result += ':Usage:   %s\n' % usage
319
 
        result += '\n'
320
 
 
321
 
        # Add the options
322
 
        options = option.get_optparser(self.options()).format_option_help()
323
 
        if options.startswith('Options:'):
324
 
            result += ':' + options
325
 
        elif options.startswith('options:'):
326
 
            # Python 2.4 version of optparse
327
 
            result += ':Options:' + options[len('options:'):]
328
 
        else:
329
 
            result += options
330
 
        result += '\n'
331
 
 
332
 
        # Add the description, indenting it 2 spaces
333
 
        # to match the indentation of the options
334
 
        if sections.has_key(None):
335
 
            text = sections.pop(None)
336
 
            text = '\n  '.join(text.splitlines())
337
 
            result += ':%s:\n  %s\n\n' % ('Description',text)
338
 
 
339
 
        # Add the custom sections (e.g. Examples). Note that there's no need
340
 
        # to indent these as they must be indented already in the source.
341
 
        if sections:
342
 
            labels = sorted(sections.keys())
343
 
            for label in labels:
344
 
                result += ':%s:\n%s\n\n' % (label,sections[label])
345
 
 
346
 
        # Add the aliases, source (plug-in) and see also links, if any
347
 
        if self.aliases:
348
 
            result += ':Aliases:  '
349
 
            result += ', '.join(self.aliases) + '\n'
350
 
        plugin_name = self.plugin_name()
351
 
        if plugin_name is not None:
352
 
            result += ':From:     plugin "%s"\n' % plugin_name
353
 
        see_also = self.get_see_also(additional_see_also)
354
 
        if see_also:
355
 
            if not plain and see_also_as_links:
356
 
                see_also_links = []
357
 
                for item in see_also:
358
 
                    if item == 'topics':
359
 
                        # topics doesn't have an independent section
360
 
                        # so don't create a real link
361
 
                        see_also_links.append(item)
362
 
                    else:
363
 
                        # Use a reST link for this entry
364
 
                        see_also_links.append("`%s`_" % (item,))
365
 
                see_also = see_also_links
366
 
            result += ':See also: '
367
 
            result += ', '.join(see_also) + '\n'
368
 
 
369
 
        # If this will be rendered as plan text, convert it
370
 
        if plain:
371
 
            import bzrlib.help_topics
372
 
            result = bzrlib.help_topics.help_as_plain_text(result)
373
 
        return result
374
 
 
375
 
    @staticmethod
376
 
    def _get_help_parts(text):
377
 
        """Split help text into a summary and named sections.
378
 
 
379
 
        :return: (summary,sections) where summary is the top line and
380
 
            sections is a dictionary of the rest indexed by section name.
381
 
            A section starts with a heading line of the form ":xxx:".
382
 
            Indented text on following lines is the section value.
383
 
            All text found outside a named section is assigned to the
384
 
            default section which is given the key of None.
385
 
        """
386
 
        def save_section(sections, label, section):
387
 
            if len(section) > 0:
388
 
                if sections.has_key(label):
389
 
                    sections[label] += '\n' + section
390
 
                else:
391
 
                    sections[label] = section
392
 
            
393
 
        lines = text.rstrip().splitlines()
394
 
        summary = lines.pop(0)
395
 
        sections = {}
396
 
        label,section = None,''
397
 
        for line in lines:
398
 
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
399
 
                save_section(sections, label, section)
400
 
                label,section = line[1:-1],''
401
 
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
402
 
                save_section(sections, label, section)
403
 
                label,section = None,line
404
 
            else:
405
 
                if len(section) > 0:
406
 
                    section += '\n' + line
407
 
                else:
408
 
                    section = line
409
 
        save_section(sections, label, section)
410
 
        return summary, sections
411
 
 
412
 
    def get_help_topic(self):
413
 
        """Return the commands help topic - its name."""
414
 
        return self.name()
415
 
 
416
 
    def get_see_also(self, additional_terms=None):
417
 
        """Return a list of help topics that are related to this command.
418
 
        
419
 
        The list is derived from the content of the _see_also attribute. Any
420
 
        duplicates are removed and the result is in lexical order.
421
 
        :param additional_terms: Additional help topics to cross-reference.
422
 
        :return: A list of help topics.
423
 
        """
424
 
        see_also = set(getattr(self, '_see_also', []))
425
 
        if additional_terms:
426
 
            see_also.update(additional_terms)
427
 
        return sorted(see_also)
428
217
 
429
218
    def options(self):
430
219
        """Return dict of valid options for this command.
431
220
 
432
221
        Maps from long option name to option object."""
433
 
        r = Option.STD_OPTIONS.copy()
434
 
        std_names = r.keys()
 
222
        r = dict()
 
223
        r['help'] = Option.OPTIONS['help']
435
224
        for o in self.takes_options:
436
225
            if isinstance(o, basestring):
437
 
                o = option.Option.OPTIONS[o]
 
226
                o = Option.OPTIONS[o]
438
227
            r[o.name] = o
439
 
            if o.name in std_names:
440
 
                self.supported_std_options.append(o.name)
441
228
        return r
442
229
 
443
230
    def _setup_outf(self):
444
231
        """Return a file linked to stdout, which has proper encoding."""
 
232
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
233
 
445
234
        # Originally I was using self.stdout, but that looks
446
235
        # *way* too much like sys.stdout
447
236
        if self.encoding_type == 'exact':
448
 
            # force sys.stdout to be binary stream on win32
449
 
            if sys.platform == 'win32':
450
 
                fileno = getattr(sys.stdout, 'fileno', None)
451
 
                if fileno:
452
 
                    import msvcrt
453
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
454
237
            self.outf = sys.stdout
455
238
            return
456
239
 
457
 
        output_encoding = osutils.get_terminal_encoding()
 
240
        output_encoding = bzrlib.osutils.get_terminal_encoding()
458
241
 
459
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout,
460
 
                        errors=self.encoding_type)
 
242
        # use 'replace' so that we don't abort if trying to write out
 
243
        # in e.g. the default C locale.
 
244
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
461
245
        # For whatever reason codecs.getwriter() does not advertise its encoding
462
246
        # it just returns the encoding of the wrapped file, which is completely
463
247
        # bogus. So set the attribute, so we can find the correct encoding later.
464
248
        self.outf.encoding = output_encoding
465
249
 
 
250
    @deprecated_method(zero_eight)
 
251
    def run_argv(self, argv):
 
252
        """Parse command line and run.
 
253
        
 
254
        See run_argv_aliases for the 0.8 and beyond api.
 
255
        """
 
256
        return self.run_argv_aliases(argv)
 
257
 
466
258
    def run_argv_aliases(self, argv, alias_argv=None):
467
259
        """Parse the command line and run with extra aliases in alias_argv."""
468
260
        if argv is None:
469
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
261
            warn("Passing None for [] is deprecated from bzrlib 0.10", 
470
262
                 DeprecationWarning, stacklevel=2)
471
263
            argv = []
472
264
        args, opts = parse_args(self, argv, alias_argv)
473
 
 
474
 
        # Process the standard options
475
265
        if 'help' in opts:  # e.g. bzr add --help
476
 
            sys.stdout.write(self.get_help_text())
 
266
            from bzrlib.help import help_on_command
 
267
            help_on_command(self.name())
477
268
            return 0
478
 
        trace.set_verbosity_level(option._verbosity_level)
479
 
        if 'verbose' in self.supported_std_options:
480
 
            opts['verbose'] = trace.is_verbose()
481
 
        elif opts.has_key('verbose'):
482
 
            del opts['verbose']
483
 
        if 'quiet' in self.supported_std_options:
484
 
            opts['quiet'] = trace.is_quiet()
485
 
        elif opts.has_key('quiet'):
486
 
            del opts['quiet']
487
 
 
488
269
        # mix arguments and options into one dictionary
489
270
        cmdargs = _match_argform(self.name(), self.takes_args, args)
490
271
        cmdopts = {}
508
289
        shell error code if not.  It's OK for this method to allow
509
290
        an exception to raise up.
510
291
        """
511
 
        raise NotImplementedError('no implementation of command %r'
 
292
        raise NotImplementedError('no implementation of command %r' 
512
293
                                  % self.name())
513
294
 
514
295
    def help(self):
533
314
            return None
534
315
 
535
316
 
 
317
def parse_spec(spec):
 
318
    """
 
319
    >>> parse_spec(None)
 
320
    [None, None]
 
321
    >>> parse_spec("./")
 
322
    ['./', None]
 
323
    >>> parse_spec("../@")
 
324
    ['..', -1]
 
325
    >>> parse_spec("../f/@35")
 
326
    ['../f', 35]
 
327
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
 
328
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
 
329
    """
 
330
    if spec is None:
 
331
        return [None, None]
 
332
    if '/@' in spec:
 
333
        parsed = spec.split('/@')
 
334
        assert len(parsed) == 2
 
335
        if parsed[1] == "":
 
336
            parsed[1] = -1
 
337
        else:
 
338
            try:
 
339
                parsed[1] = int(parsed[1])
 
340
            except ValueError:
 
341
                pass # We can allow stuff like ./@revid:blahblahblah
 
342
            else:
 
343
                assert parsed[1] >=0
 
344
    else:
 
345
        parsed = [spec, None]
 
346
    return parsed
 
347
 
536
348
def parse_args(command, argv, alias_argv=None):
537
349
    """Parse command line.
538
350
    
549
361
        args = argv
550
362
 
551
363
    options, args = parser.parse_args(args)
552
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
364
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if 
553
365
                 v is not option.OptionParser.DEFAULT_VALUE])
554
366
    return args, opts
555
367
 
571
383
                argdict[argname + '_list'] = None
572
384
        elif ap[-1] == '+':
573
385
            if not args:
574
 
                raise errors.BzrCommandError("command %r needs one or more %s"
575
 
                                             % (cmd, argname.upper()))
 
386
                raise BzrCommandError("command %r needs one or more %s"
 
387
                        % (cmd, argname.upper()))
576
388
            else:
577
389
                argdict[argname + '_list'] = args[:]
578
390
                args = []
579
391
        elif ap[-1] == '$': # all but one
580
392
            if len(args) < 2:
581
 
                raise errors.BzrCommandError("command %r needs one or more %s"
582
 
                                             % (cmd, argname.upper()))
 
393
                raise BzrCommandError("command %r needs one or more %s"
 
394
                        % (cmd, argname.upper()))
583
395
            argdict[argname + '_list'] = args[:-1]
584
396
            args[:-1] = []
585
397
        else:
586
398
            # just a plain arg
587
399
            argname = ap
588
400
            if not args:
589
 
                raise errors.BzrCommandError("command %r requires argument %s"
590
 
                               % (cmd, argname.upper()))
 
401
                raise BzrCommandError("command %r requires argument %s"
 
402
                        % (cmd, argname.upper()))
591
403
            else:
592
404
                argdict[argname] = args.pop(0)
593
405
            
594
406
    if args:
595
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
596
 
                                     % (cmd, args[0]))
 
407
        raise BzrCommandError("extra argument to command %s: %s"
 
408
                              % (cmd, args[0]))
597
409
 
598
410
    return argdict
599
411
 
600
 
def apply_coveraged(dirname, the_callable, *args, **kwargs):
601
 
    # Cannot use "import trace", as that would import bzrlib.trace instead of
602
 
    # the standard library's trace.
603
 
    trace = __import__('trace')
604
 
 
605
 
    tracer = trace.Trace(count=1, trace=0)
606
 
    sys.settrace(tracer.globaltrace)
607
 
 
608
 
    ret = the_callable(*args, **kwargs)
609
 
 
610
 
    sys.settrace(None)
611
 
    results = tracer.results()
612
 
    results.write_results(show_missing=1, summary=False,
613
 
                          coverdir=dirname)
614
412
 
615
413
 
616
414
def apply_profiled(the_callable, *args, **kwargs):
638
436
 
639
437
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
640
438
    from bzrlib.lsprof import profile
 
439
    import cPickle
641
440
    ret, stats = profile(the_callable, *args, **kwargs)
642
441
    stats.sort()
643
442
    if filename is None:
644
443
        stats.pprint()
645
444
    else:
646
 
        stats.save(filename)
647
 
        trace.note('Profile data written to "%s".', filename)
 
445
        stats.freeze()
 
446
        cPickle.dump(stats, open(filename, 'w'), 2)
 
447
        print 'Profile data written to %r.' % filename
648
448
    return ret
649
449
 
650
450
 
651
 
def shlex_split_unicode(unsplit):
652
 
    import shlex
653
 
    return [u.decode('utf-8') for u in shlex.split(unsplit.encode('utf-8'))]
654
 
 
655
 
 
656
 
def get_alias(cmd, config=None):
657
 
    """Return an expanded alias, or None if no alias exists.
658
 
 
659
 
    cmd
660
 
        Command to be checked for an alias.
661
 
    config
662
 
        Used to specify an alternative config to use,
663
 
        which is especially useful for testing.
664
 
        If it is unspecified, the global config will be used.
665
 
    """
666
 
    if config is None:
667
 
        import bzrlib.config
668
 
        config = bzrlib.config.GlobalConfig()
669
 
    alias = config.get_alias(cmd)
 
451
def get_alias(cmd):
 
452
    """Return an expanded alias, or None if no alias exists"""
 
453
    import bzrlib.config
 
454
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
670
455
    if (alias):
671
 
        return shlex_split_unicode(alias)
 
456
        return alias.split(' ')
672
457
    return None
673
458
 
674
459
 
703
488
 
704
489
    --lsprof
705
490
        Run under the Python lsprof profiler.
706
 
 
707
 
    --coverage
708
 
        Generate line coverage report in the specified directory.
709
491
    """
710
492
    argv = list(argv)
711
 
    trace.mutter("bzr arguments: %r", argv)
712
493
 
713
494
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
714
495
                opt_no_aliases = False
715
 
    opt_lsprof_file = opt_coverage_dir = None
 
496
    opt_lsprof_file = None
716
497
 
717
498
    # --no-plugins is handled specially at a very early stage. We need
718
499
    # to load plugins before doing other command parsing so that they
736
517
            opt_no_aliases = True
737
518
        elif a == '--builtin':
738
519
            opt_builtin = True
739
 
        elif a == '--coverage':
740
 
            opt_coverage_dir = argv[i + 1]
741
 
            i += 1
742
 
        elif a.startswith('-D'):
743
 
            debug.debug_flags.add(a[2:])
 
520
        elif a in ('--quiet', '-q'):
 
521
            be_quiet()
744
522
        else:
745
523
            argv_copy.append(a)
746
524
        i += 1
752
530
        return 0
753
531
 
754
532
    if argv[0] == '--version':
755
 
        from bzrlib.builtins import cmd_version
756
 
        cmd_version().run_argv_aliases([])
 
533
        from bzrlib.version import show_version
 
534
        show_version()
757
535
        return 0
758
536
        
759
537
    if not opt_no_plugins:
771
549
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
772
550
            argv[0] = alias_argv.pop(0)
773
551
 
774
 
    cmd = argv.pop(0)
775
 
    # We want only 'ascii' command names, but the user may have typed
776
 
    # in a Unicode name. In that case, they should just get a
777
 
    # 'command not found' error later.
 
552
    cmd = str(argv.pop(0))
778
553
 
779
554
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
780
 
    run = cmd_obj.run_argv_aliases
781
 
    run_argv = [argv, alias_argv]
 
555
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
556
        run = cmd_obj.run_argv
 
557
        run_argv = [argv]
 
558
    else:
 
559
        run = cmd_obj.run_argv_aliases
 
560
        run_argv = [argv, alias_argv]
782
561
 
783
562
    try:
784
563
        if opt_lsprof:
785
 
            if opt_coverage_dir:
786
 
                trace.warning(
787
 
                    '--coverage ignored, because --lsprof is in use.')
788
564
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
789
565
        elif opt_profile:
790
 
            if opt_coverage_dir:
791
 
                trace.warning(
792
 
                    '--coverage ignored, because --profile is in use.')
793
566
            ret = apply_profiled(run, *run_argv)
794
 
        elif opt_coverage_dir:
795
 
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
796
567
        else:
797
568
            ret = run(*run_argv)
798
569
        return ret or 0
799
570
    finally:
800
571
        # reset, in case we may do other commands later within the same process
801
 
        option._verbosity_level = 0
 
572
        be_quiet(False)
802
573
 
803
574
def display_command(func):
804
575
    """Decorator that suppresses pipe/interrupt errors."""
808
579
            sys.stdout.flush()
809
580
            return result
810
581
        except IOError, e:
811
 
            if getattr(e, 'errno', None) is None:
 
582
            if not hasattr(e, 'errno'):
812
583
                raise
813
584
            if e.errno != errno.EPIPE:
814
585
                # Win32 raises IOError with errno=0 on a broken pipe
815
 
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
586
                if sys.platform != 'win32' or e.errno != 0:
816
587
                    raise
817
588
            pass
818
589
        except KeyboardInterrupt:
824
595
    import bzrlib.ui
825
596
    from bzrlib.ui.text import TextUIFactory
826
597
    bzrlib.ui.ui_factory = TextUIFactory()
827
 
     
828
 
    # Is this a final release version? If so, we should suppress warnings
829
 
    if bzrlib.version_info[3] == 'final':
830
 
        from bzrlib import symbol_versioning
831
 
        symbol_versioning.suppress_deprecation_warnings(override=False)
832
 
    try:
833
 
        argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
834
 
    except UnicodeDecodeError:
835
 
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
836
 
                                                            "encoding." % a))
 
598
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
837
599
    ret = run_bzr_catch_errors(argv)
838
 
    trace.mutter("return code %d", ret)
 
600
    mutter("return code %d", ret)
839
601
    return ret
840
602
 
841
603
 
842
604
def run_bzr_catch_errors(argv):
843
 
    # Note: The except clause logic below should be kept in sync with the
844
 
    # profile() routine in lsprof.py.
845
605
    try:
846
606
        return run_bzr(argv)
847
 
    except (KeyboardInterrupt, Exception), e:
 
607
        # do this here inside the exception wrappers to catch EPIPE
 
608
        sys.stdout.flush()
 
609
    except Exception, e:
848
610
        # used to handle AssertionError and KeyboardInterrupt
849
611
        # specially here, but hopefully they're handled ok by the logger now
850
 
        exitcode = trace.report_exception(sys.exc_info(), sys.stderr)
 
612
        bzrlib.trace.report_exception(sys.exc_info(), sys.stderr)
851
613
        if os.environ.get('BZR_PDB'):
852
614
            print '**** entering debugger'
853
615
            import pdb
854
616
            pdb.post_mortem(sys.exc_traceback)
855
 
        return exitcode
856
 
 
857
 
 
858
 
def run_bzr_catch_user_errors(argv):
859
 
    """Run bzr and report user errors, but let internal errors propagate.
860
 
 
861
 
    This is used for the test suite, and might be useful for other programs
862
 
    that want to wrap the commandline interface.
863
 
    """
864
 
    try:
865
 
        return run_bzr(argv)
866
 
    except Exception, e:
867
 
        if (isinstance(e, (OSError, IOError))
868
 
            or not getattr(e, 'internal_error', True)):
869
 
            trace.report_exception(sys.exc_info(), sys.stderr)
870
 
            return 3
871
 
        else:
872
 
            raise
873
 
 
874
 
 
875
 
class HelpCommandIndex(object):
876
 
    """A index for bzr help that returns commands."""
877
 
 
878
 
    def __init__(self):
879
 
        self.prefix = 'commands/'
880
 
 
881
 
    def get_topics(self, topic):
882
 
        """Search for topic amongst commands.
883
 
 
884
 
        :param topic: A topic to search for.
885
 
        :return: A list which is either empty or contains a single
886
 
            Command entry.
887
 
        """
888
 
        if topic and topic.startswith(self.prefix):
889
 
            topic = topic[len(self.prefix):]
890
 
        try:
891
 
            cmd = _get_cmd_object(topic)
892
 
        except KeyError:
893
 
            return []
894
 
        else:
895
 
            return [cmd]
896
 
 
897
 
 
898
 
class Provider(object):
899
 
    '''Generic class to be overriden by plugins'''
900
 
 
901
 
    def plugin_for_command(self, cmd_name):
902
 
        '''Takes a command and returns the information for that plugin
903
 
        
904
 
        :return: A dictionary with all the available information 
905
 
        for the requested plugin
906
 
        '''
907
 
        raise NotImplementedError
908
 
 
909
 
 
910
 
class ProvidersRegistry(registry.Registry):
911
 
    '''This registry exists to allow other providers to exist'''
912
 
 
913
 
    def __iter__(self):
914
 
        for key, provider in self.iteritems():
915
 
            yield provider
916
 
 
917
 
command_providers_registry = ProvidersRegistry()
918
 
 
 
617
        return 3
919
618
 
920
619
if __name__ == '__main__':
921
620
    sys.exit(main(sys.argv))