← 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-10-11 23:08:27 UTC
  • mto: This revision was merged to the branch mainline in revision 2080.
  • Revision ID: john@arbash-meinel.com-20061011230827-2bdfc45020695281
Change Copyright .. by Canonical to Copyright ... Canonical

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006, 2008 Canonical Ltd
 
1
# Copyright (C) 2006 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
 
    trace,
47
 
    win32utils,
48
 
    )
49
 
""")
50
 
 
51
 
from bzrlib import registry
52
 
# Compatibility
53
 
from bzrlib.hooks import Hooks
 
38
import bzrlib.errors as errors
 
39
from bzrlib.errors import (BzrError,
 
40
                           BzrCommandError,
 
41
                           BzrCheckError,
 
42
                           NotBranchError)
 
43
from bzrlib import option
54
44
from bzrlib.option import Option
55
 
 
56
 
 
57
 
class CommandInfo(object):
58
 
    """Information about a command."""
59
 
 
60
 
    def __init__(self, aliases):
61
 
        """The list of aliases for the command."""
62
 
        self.aliases = aliases
63
 
 
64
 
    @classmethod
65
 
    def from_command(klass, command):
66
 
        """Factory to construct a CommandInfo from a command."""
67
 
        return klass(command.aliases)
68
 
 
69
 
 
70
 
class CommandRegistry(registry.Registry):
71
 
 
72
 
    @staticmethod
73
 
    def _get_name(command_name):
74
 
        if command_name.startswith("cmd_"):
75
 
            return _unsquish_command_name(command_name)
76
 
        else:
77
 
            return command_name
78
 
 
79
 
    def register(self, cmd, decorate=False):
80
 
        """Utility function to help register a command
81
 
 
82
 
        :param cmd: Command subclass to register
83
 
        :param decorate: If true, allow overriding an existing command
84
 
            of the same name; the old command is returned by this function.
85
 
            Otherwise it is an error to try to override an existing command.
86
 
        """
87
 
        k = cmd.__name__
88
 
        k_unsquished = self._get_name(k)
89
 
        try:
90
 
            previous = self.get(k_unsquished)
91
 
        except KeyError:
92
 
            previous = _builtin_commands().get(k_unsquished)
93
 
        info = CommandInfo.from_command(cmd)
94
 
        try:
95
 
            registry.Registry.register(self, k_unsquished, cmd,
96
 
                                       override_existing=decorate, info=info)
97
 
        except KeyError:
98
 
            trace.log_error('Two plugins defined the same command: %r' % k)
99
 
            trace.log_error('Not loading the one in %r' %
100
 
                            sys.modules[cmd.__module__])
101
 
            trace.log_error('Previously this command was registered from %r' %
102
 
                            sys.modules[previous.__module__])
103
 
        return previous
104
 
 
105
 
    def register_lazy(self, command_name, aliases, module_name):
106
 
        """Register a command without loading its module.
107
 
 
108
 
        :param command_name: The primary name of the command.
109
 
        :param aliases: A list of aliases for the command.
110
 
        :module_name: The module that the command lives in.
111
 
        """
112
 
        key = self._get_name(command_name)
113
 
        registry.Registry.register_lazy(self, key, module_name, command_name,
114
 
                                        info=CommandInfo(aliases))
115
 
 
116
 
 
117
 
plugin_cmds = CommandRegistry()
 
45
import bzrlib.osutils
 
46
from bzrlib.symbol_versioning import (deprecated_method, zero_eight)
 
47
import bzrlib.trace
 
48
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
 
49
 
 
50
plugin_cmds = {}
118
51
 
119
52
 
120
53
def register_command(cmd, decorate=False):
 
54
    """Utility function to help register a command
 
55
 
 
56
    :param cmd: Command subclass to register
 
57
    :param decorate: If true, allow overriding an existing command
 
58
        of the same name; the old command is returned by this function.
 
59
        Otherwise it is an error to try to override an existing command.
 
60
    """
121
61
    global plugin_cmds
122
 
    return plugin_cmds.register(cmd, decorate)
 
62
    k = cmd.__name__
 
63
    if k.startswith("cmd_"):
 
64
        k_unsquished = _unsquish_command_name(k)
 
65
    else:
 
66
        k_unsquished = k
 
67
    if k_unsquished not in plugin_cmds:
 
68
        plugin_cmds[k_unsquished] = cmd
 
69
        mutter('registered plugin command %s', k_unsquished)
 
70
        if decorate and k_unsquished in builtin_command_names():
 
71
            return _builtin_commands()[k_unsquished]
 
72
    elif decorate:
 
73
        result = plugin_cmds[k_unsquished]
 
74
        plugin_cmds[k_unsquished] = cmd
 
75
        return result
 
76
    else:
 
77
        log_error('Two plugins defined the same command: %r' % k)
 
78
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
123
79
 
124
80
 
125
81
def _squish_command_name(cmd):
127
83
 
128
84
 
129
85
def _unsquish_command_name(cmd):
 
86
    assert cmd.startswith("cmd_")
130
87
    return cmd[4:].replace('_','-')
131
88
 
132
89
 
154
111
    """Return name->class mapping for all commands."""
155
112
    d = _builtin_commands()
156
113
    if plugins_override:
157
 
        d.update(plugin_cmds.iteritems())
 
114
        d.update(plugin_cmds)
158
115
    return d
159
116
 
160
117
    
170
127
    plugins_override
171
128
        If true, plugin commands can override builtins.
172
129
    """
173
 
    try:
174
 
        cmd = _get_cmd_object(cmd_name, plugins_override)
175
 
        # Allow plugins to extend commands
176
 
        for hook in Command.hooks['extend_command']:
177
 
            hook(cmd)
178
 
        return cmd
179
 
    except KeyError:
180
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
181
 
 
182
 
 
183
 
def _get_cmd_object(cmd_name, plugins_override=True):
184
 
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
185
130
    from bzrlib.externalcommand import ExternalCommand
186
131
 
187
132
    # We want only 'ascii' command names, but the user may have typed
190
135
    # In the future, we may actually support Unicode command names.
191
136
 
192
137
    # first look up this command under the specified name
193
 
    if plugins_override:
194
 
        try:
195
 
            return plugin_cmds.get(cmd_name)()
196
 
        except KeyError:
197
 
            pass
198
 
    cmds = _get_cmd_dict(plugins_override=False)
 
138
    cmds = _get_cmd_dict(plugins_override=plugins_override)
199
139
    try:
200
140
        return cmds[cmd_name]()
201
141
    except KeyError:
202
142
        pass
203
 
    if plugins_override:
204
 
        for key in plugin_cmds.keys():
205
 
            info = plugin_cmds.get_info(key)
206
 
            if cmd_name in info.aliases:
207
 
                return plugin_cmds.get(key)()
 
143
 
208
144
    # look for any command which claims this as an alias
209
145
    for real_cmd_name, cmd_class in cmds.iteritems():
210
146
        if cmd_name in cmd_class.aliases:
214
150
    if cmd_obj:
215
151
        return cmd_obj
216
152
 
217
 
    # look for plugins that provide this command but aren't installed
218
 
    for provider in command_providers_registry:
219
 
        try:
220
 
            plugin_metadata = provider.plugin_for_command(cmd_name)
221
 
        except errors.NoPluginAvailable:
222
 
            pass
223
 
        else:
224
 
            raise errors.CommandAvailableInPlugin(cmd_name,
225
 
                                                  plugin_metadata, provider)
226
 
    raise KeyError
 
153
    raise BzrCommandError('unknown command "%s"' % cmd_name)
227
154
 
228
155
 
229
156
class Command(object):
277
204
            replace - put in a bogus character (typically '?')
278
205
            exact - do not encode sys.stdout
279
206
 
280
 
            NOTE: by default on Windows, sys.stdout is opened as a text
281
 
            stream, therefore LF line-endings are converted to CRLF.
282
 
            When a command uses encoding_type = 'exact', then
283
 
            sys.stdout is forced to be a binary stream, and line-endings
284
 
            will not mangled.
285
 
 
286
 
    :cvar hooks: An instance of CommandHooks.
287
207
    """
288
208
    aliases = []
289
209
    takes_args = []
296
216
        """Construct an instance of this command."""
297
217
        if self.__doc__ == Command.__doc__:
298
218
            warn("No help message set for %r" % self)
299
 
        # List of standard options directly supported
300
 
        self.supported_std_options = []
301
 
 
302
 
    def _maybe_expand_globs(self, file_list):
303
 
        """Glob expand file_list if the platform does not do that itself.
304
 
        
305
 
        :return: A possibly empty list of unicode paths.
306
 
 
307
 
        Introduced in bzrlib 0.18.
308
 
        """
309
 
        if not file_list:
310
 
            file_list = []
311
 
        if sys.platform == 'win32':
312
 
            file_list = win32utils.glob_expand(file_list)
313
 
        return list(file_list)
314
 
 
315
 
    def _usage(self):
316
 
        """Return single-line grammar for this command.
317
 
 
318
 
        Only describes arguments, not options.
319
 
        """
320
 
        s = 'bzr ' + self.name() + ' '
321
 
        for aname in self.takes_args:
322
 
            aname = aname.upper()
323
 
            if aname[-1] in ['$', '+']:
324
 
                aname = aname[:-1] + '...'
325
 
            elif aname[-1] == '?':
326
 
                aname = '[' + aname[:-1] + ']'
327
 
            elif aname[-1] == '*':
328
 
                aname = '[' + aname[:-1] + '...]'
329
 
            s += aname + ' '
330
 
        s = s[:-1]      # remove last space
331
 
        return s
332
 
 
333
 
    def get_help_text(self, additional_see_also=None, plain=True,
334
 
                      see_also_as_links=False):
335
 
        """Return a text string with help for this command.
336
 
        
337
 
        :param additional_see_also: Additional help topics to be
338
 
            cross-referenced.
339
 
        :param plain: if False, raw help (reStructuredText) is
340
 
            returned instead of plain text.
341
 
        :param see_also_as_links: if True, convert items in 'See also'
342
 
            list to internal links (used by bzr_man rstx generator)
343
 
        """
344
 
        doc = self.help()
345
 
        if doc is None:
346
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
347
 
 
348
 
        # Extract the summary (purpose) and sections out from the text
349
 
        purpose,sections,order = self._get_help_parts(doc)
350
 
 
351
 
        # If a custom usage section was provided, use it
352
 
        if sections.has_key('Usage'):
353
 
            usage = sections.pop('Usage')
354
 
        else:
355
 
            usage = self._usage()
356
 
 
357
 
        # The header is the purpose and usage
358
 
        result = ""
359
 
        result += ':Purpose: %s\n' % purpose
360
 
        if usage.find('\n') >= 0:
361
 
            result += ':Usage:\n%s\n' % usage
362
 
        else:
363
 
            result += ':Usage:   %s\n' % usage
364
 
        result += '\n'
365
 
 
366
 
        # Add the options
367
 
        options = option.get_optparser(self.options()).format_option_help()
368
 
        if options.startswith('Options:'):
369
 
            result += ':' + options
370
 
        elif options.startswith('options:'):
371
 
            # Python 2.4 version of optparse
372
 
            result += ':Options:' + options[len('options:'):]
373
 
        else:
374
 
            result += options
375
 
        result += '\n'
376
 
 
377
 
        # Add the description, indenting it 2 spaces
378
 
        # to match the indentation of the options
379
 
        if sections.has_key(None):
380
 
            text = sections.pop(None)
381
 
            text = '\n  '.join(text.splitlines())
382
 
            result += ':%s:\n  %s\n\n' % ('Description',text)
383
 
 
384
 
        # Add the custom sections (e.g. Examples). Note that there's no need
385
 
        # to indent these as they must be indented already in the source.
386
 
        if sections:
387
 
            for label in order:
388
 
                if sections.has_key(label):
389
 
                    result += ':%s:\n%s\n\n' % (label,sections[label])
390
 
 
391
 
        # Add the aliases, source (plug-in) and see also links, if any
392
 
        if self.aliases:
393
 
            result += ':Aliases:  '
394
 
            result += ', '.join(self.aliases) + '\n'
395
 
        plugin_name = self.plugin_name()
396
 
        if plugin_name is not None:
397
 
            result += ':From:     plugin "%s"\n' % plugin_name
398
 
        see_also = self.get_see_also(additional_see_also)
399
 
        if see_also:
400
 
            if not plain and see_also_as_links:
401
 
                see_also_links = []
402
 
                for item in see_also:
403
 
                    if item == 'topics':
404
 
                        # topics doesn't have an independent section
405
 
                        # so don't create a real link
406
 
                        see_also_links.append(item)
407
 
                    else:
408
 
                        # Use a reST link for this entry
409
 
                        see_also_links.append("`%s`_" % (item,))
410
 
                see_also = see_also_links
411
 
            result += ':See also: '
412
 
            result += ', '.join(see_also) + '\n'
413
 
 
414
 
        # If this will be rendered as plain text, convert it
415
 
        if plain:
416
 
            import bzrlib.help_topics
417
 
            result = bzrlib.help_topics.help_as_plain_text(result)
418
 
        return result
419
 
 
420
 
    @staticmethod
421
 
    def _get_help_parts(text):
422
 
        """Split help text into a summary and named sections.
423
 
 
424
 
        :return: (summary,sections,order) where summary is the top line and
425
 
            sections is a dictionary of the rest indexed by section name.
426
 
            order is the order the section appear in the text.
427
 
            A section starts with a heading line of the form ":xxx:".
428
 
            Indented text on following lines is the section value.
429
 
            All text found outside a named section is assigned to the
430
 
            default section which is given the key of None.
431
 
        """
432
 
        def save_section(sections, order, label, section):
433
 
            if len(section) > 0:
434
 
                if sections.has_key(label):
435
 
                    sections[label] += '\n' + section
436
 
                else:
437
 
                    order.append(label)
438
 
                    sections[label] = section
439
 
 
440
 
        lines = text.rstrip().splitlines()
441
 
        summary = lines.pop(0)
442
 
        sections = {}
443
 
        order = []
444
 
        label,section = None,''
445
 
        for line in lines:
446
 
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
447
 
                save_section(sections, order, label, section)
448
 
                label,section = line[1:-1],''
449
 
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
450
 
                save_section(sections, order, label, section)
451
 
                label,section = None,line
452
 
            else:
453
 
                if len(section) > 0:
454
 
                    section += '\n' + line
455
 
                else:
456
 
                    section = line
457
 
        save_section(sections, order, label, section)
458
 
        return summary, sections, order
459
 
 
460
 
    def get_help_topic(self):
461
 
        """Return the commands help topic - its name."""
462
 
        return self.name()
463
 
 
464
 
    def get_see_also(self, additional_terms=None):
465
 
        """Return a list of help topics that are related to this command.
466
 
        
467
 
        The list is derived from the content of the _see_also attribute. Any
468
 
        duplicates are removed and the result is in lexical order.
469
 
        :param additional_terms: Additional help topics to cross-reference.
470
 
        :return: A list of help topics.
471
 
        """
472
 
        see_also = set(getattr(self, '_see_also', []))
473
 
        if additional_terms:
474
 
            see_also.update(additional_terms)
475
 
        return sorted(see_also)
476
219
 
477
220
    def options(self):
478
221
        """Return dict of valid options for this command.
479
222
 
480
223
        Maps from long option name to option object."""
481
 
        r = Option.STD_OPTIONS.copy()
482
 
        std_names = r.keys()
 
224
        r = dict()
 
225
        r['help'] = Option.OPTIONS['help']
483
226
        for o in self.takes_options:
484
227
            if isinstance(o, basestring):
485
 
                o = option.Option.OPTIONS[o]
 
228
                o = Option.OPTIONS[o]
486
229
            r[o.name] = o
487
 
            if o.name in std_names:
488
 
                self.supported_std_options.append(o.name)
489
230
        return r
490
231
 
491
232
    def _setup_outf(self):
492
233
        """Return a file linked to stdout, which has proper encoding."""
 
234
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
235
 
493
236
        # Originally I was using self.stdout, but that looks
494
237
        # *way* too much like sys.stdout
495
238
        if self.encoding_type == 'exact':
496
 
            # force sys.stdout to be binary stream on win32
497
 
            if sys.platform == 'win32':
498
 
                fileno = getattr(sys.stdout, 'fileno', None)
499
 
                if fileno:
500
 
                    import msvcrt
501
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
502
239
            self.outf = sys.stdout
503
240
            return
504
241
 
505
 
        output_encoding = osutils.get_terminal_encoding()
 
242
        output_encoding = bzrlib.osutils.get_terminal_encoding()
506
243
 
507
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout,
508
 
                        errors=self.encoding_type)
 
244
        # use 'replace' so that we don't abort if trying to write out
 
245
        # in e.g. the default C locale.
 
246
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
509
247
        # For whatever reason codecs.getwriter() does not advertise its encoding
510
248
        # it just returns the encoding of the wrapped file, which is completely
511
249
        # bogus. So set the attribute, so we can find the correct encoding later.
512
250
        self.outf.encoding = output_encoding
513
251
 
 
252
    @deprecated_method(zero_eight)
 
253
    def run_argv(self, argv):
 
254
        """Parse command line and run.
 
255
        
 
256
        See run_argv_aliases for the 0.8 and beyond api.
 
257
        """
 
258
        return self.run_argv_aliases(argv)
 
259
 
514
260
    def run_argv_aliases(self, argv, alias_argv=None):
515
261
        """Parse the command line and run with extra aliases in alias_argv."""
516
262
        if argv is None:
517
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
263
            warn("Passing None for [] is deprecated from bzrlib 0.10", 
518
264
                 DeprecationWarning, stacklevel=2)
519
265
            argv = []
520
266
        args, opts = parse_args(self, argv, alias_argv)
521
 
 
522
 
        # Process the standard options
523
267
        if 'help' in opts:  # e.g. bzr add --help
524
 
            sys.stdout.write(self.get_help_text())
 
268
            from bzrlib.help import help_on_command
 
269
            help_on_command(self.name())
525
270
            return 0
526
 
        trace.set_verbosity_level(option._verbosity_level)
527
 
        if 'verbose' in self.supported_std_options:
528
 
            opts['verbose'] = trace.is_verbose()
529
 
        elif opts.has_key('verbose'):
530
 
            del opts['verbose']
531
 
        if 'quiet' in self.supported_std_options:
532
 
            opts['quiet'] = trace.is_quiet()
533
 
        elif opts.has_key('quiet'):
534
 
            del opts['quiet']
535
 
 
536
271
        # mix arguments and options into one dictionary
537
272
        cmdargs = _match_argform(self.name(), self.takes_args, args)
538
273
        cmdopts = {}
545
280
        self._setup_outf()
546
281
 
547
282
        return self.run(**all_cmd_args)
548
 
 
 
283
    
549
284
    def run(self):
550
285
        """Actually run the command.
551
286
 
556
291
        shell error code if not.  It's OK for this method to allow
557
292
        an exception to raise up.
558
293
        """
559
 
        raise NotImplementedError('no implementation of command %r'
 
294
        raise NotImplementedError('no implementation of command %r' 
560
295
                                  % self.name())
561
296
 
562
297
    def help(self):
581
316
            return None
582
317
 
583
318
 
584
 
class CommandHooks(Hooks):
585
 
    """Hooks related to Command object creation/enumeration."""
586
 
 
587
 
    def __init__(self):
588
 
        """Create the default hooks.
589
 
 
590
 
        These are all empty initially, because by default nothing should get
591
 
        notified.
592
 
        """
593
 
        Hooks.__init__(self)
594
 
        # Introduced in 1.13:
595
 
        # invoked after creating a command object to allow modifications such
596
 
        # as adding or removing options, docs etc. Invoked with the command
597
 
        # object.
598
 
        self['extend_command'] = []
599
 
 
600
 
Command.hooks = CommandHooks()
601
 
 
 
319
def parse_spec(spec):
 
320
    """
 
321
    >>> parse_spec(None)
 
322
    [None, None]
 
323
    >>> parse_spec("./")
 
324
    ['./', None]
 
325
    >>> parse_spec("../@")
 
326
    ['..', -1]
 
327
    >>> parse_spec("../f/@35")
 
328
    ['../f', 35]
 
329
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
 
330
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
 
331
    """
 
332
    if spec is None:
 
333
        return [None, None]
 
334
    if '/@' in spec:
 
335
        parsed = spec.split('/@')
 
336
        assert len(parsed) == 2
 
337
        if parsed[1] == "":
 
338
            parsed[1] = -1
 
339
        else:
 
340
            try:
 
341
                parsed[1] = int(parsed[1])
 
342
            except ValueError:
 
343
                pass # We can allow stuff like ./@revid:blahblahblah
 
344
            else:
 
345
                assert parsed[1] >=0
 
346
    else:
 
347
        parsed = [spec, None]
 
348
    return parsed
602
349
 
603
350
def parse_args(command, argv, alias_argv=None):
604
351
    """Parse command line.
616
363
        args = argv
617
364
 
618
365
    options, args = parser.parse_args(args)
619
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
366
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if 
620
367
                 v is not option.OptionParser.DEFAULT_VALUE])
621
368
    return args, opts
622
369
 
638
385
                argdict[argname + '_list'] = None
639
386
        elif ap[-1] == '+':
640
387
            if not args:
641
 
                raise errors.BzrCommandError("command %r needs one or more %s"
642
 
                                             % (cmd, argname.upper()))
 
388
                raise BzrCommandError("command %r needs one or more %s"
 
389
                        % (cmd, argname.upper()))
643
390
            else:
644
391
                argdict[argname + '_list'] = args[:]
645
392
                args = []
646
393
        elif ap[-1] == '$': # all but one
647
394
            if len(args) < 2:
648
 
                raise errors.BzrCommandError("command %r needs one or more %s"
649
 
                                             % (cmd, argname.upper()))
 
395
                raise BzrCommandError("command %r needs one or more %s"
 
396
                        % (cmd, argname.upper()))
650
397
            argdict[argname + '_list'] = args[:-1]
651
398
            args[:-1] = []
652
399
        else:
653
400
            # just a plain arg
654
401
            argname = ap
655
402
            if not args:
656
 
                raise errors.BzrCommandError("command %r requires argument %s"
657
 
                               % (cmd, argname.upper()))
 
403
                raise BzrCommandError("command %r requires argument %s"
 
404
                        % (cmd, argname.upper()))
658
405
            else:
659
406
                argdict[argname] = args.pop(0)
660
407
            
661
408
    if args:
662
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
663
 
                                     % (cmd, args[0]))
 
409
        raise BzrCommandError("extra argument to command %s: %s"
 
410
                              % (cmd, args[0]))
664
411
 
665
412
    return argdict
666
413
 
667
 
def apply_coveraged(dirname, the_callable, *args, **kwargs):
668
 
    # Cannot use "import trace", as that would import bzrlib.trace instead of
669
 
    # the standard library's trace.
670
 
    trace = __import__('trace')
671
 
 
672
 
    tracer = trace.Trace(count=1, trace=0)
673
 
    sys.settrace(tracer.globaltrace)
674
 
 
675
 
    ret = the_callable(*args, **kwargs)
676
 
 
677
 
    sys.settrace(None)
678
 
    results = tracer.results()
679
 
    results.write_results(show_missing=1, summary=False,
680
 
                          coverdir=dirname)
681
414
 
682
415
 
683
416
def apply_profiled(the_callable, *args, **kwargs):
705
438
 
706
439
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
707
440
    from bzrlib.lsprof import profile
 
441
    import cPickle
708
442
    ret, stats = profile(the_callable, *args, **kwargs)
709
443
    stats.sort()
710
444
    if filename is None:
711
445
        stats.pprint()
712
446
    else:
713
 
        stats.save(filename)
714
 
        trace.note('Profile data written to "%s".', filename)
 
447
        stats.freeze()
 
448
        cPickle.dump(stats, open(filename, 'w'), 2)
 
449
        print 'Profile data written to %r.' % filename
715
450
    return ret
716
451
 
717
452
 
718
 
def shlex_split_unicode(unsplit):
719
 
    import shlex
720
 
    return [u.decode('utf-8') for u in shlex.split(unsplit.encode('utf-8'))]
721
 
 
722
 
 
723
 
def get_alias(cmd, config=None):
724
 
    """Return an expanded alias, or None if no alias exists.
725
 
 
726
 
    cmd
727
 
        Command to be checked for an alias.
728
 
    config
729
 
        Used to specify an alternative config to use,
730
 
        which is especially useful for testing.
731
 
        If it is unspecified, the global config will be used.
732
 
    """
733
 
    if config is None:
734
 
        import bzrlib.config
735
 
        config = bzrlib.config.GlobalConfig()
736
 
    alias = config.get_alias(cmd)
 
453
def get_alias(cmd):
 
454
    """Return an expanded alias, or None if no alias exists"""
 
455
    import bzrlib.config
 
456
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
737
457
    if (alias):
738
 
        return shlex_split_unicode(alias)
 
458
        return alias.split(' ')
739
459
    return None
740
460
 
741
461
 
742
462
def run_bzr(argv):
743
463
    """Execute a command.
744
464
 
 
465
    This is similar to main(), but without all the trappings for
 
466
    logging and error handling.  
 
467
    
745
468
    argv
746
469
       The command-line arguments, without the program name from argv[0]
747
470
       These should already be decoded. All library/test code calling
767
490
 
768
491
    --lsprof
769
492
        Run under the Python lsprof profiler.
770
 
 
771
 
    --coverage
772
 
        Generate line coverage report in the specified directory.
773
493
    """
774
494
    argv = list(argv)
775
 
    trace.mutter("bzr arguments: %r", argv)
776
495
 
777
496
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
778
497
                opt_no_aliases = False
779
 
    opt_lsprof_file = opt_coverage_dir = None
 
498
    opt_lsprof_file = None
780
499
 
781
500
    # --no-plugins is handled specially at a very early stage. We need
782
501
    # to load plugins before doing other command parsing so that they
800
519
            opt_no_aliases = True
801
520
        elif a == '--builtin':
802
521
            opt_builtin = True
803
 
        elif a == '--coverage':
804
 
            opt_coverage_dir = argv[i + 1]
805
 
            i += 1
806
 
        elif a.startswith('-D'):
807
 
            debug.debug_flags.add(a[2:])
 
522
        elif a in ('--quiet', '-q'):
 
523
            be_quiet()
808
524
        else:
809
525
            argv_copy.append(a)
810
526
        i += 1
816
532
        return 0
817
533
 
818
534
    if argv[0] == '--version':
819
 
        from bzrlib.builtins import cmd_version
820
 
        cmd_version().run_argv_aliases([])
 
535
        from bzrlib.version import show_version
 
536
        show_version()
821
537
        return 0
822
 
 
 
538
        
823
539
    if not opt_no_plugins:
824
540
        from bzrlib.plugin import load_plugins
825
541
        load_plugins()
832
548
    if not opt_no_aliases:
833
549
        alias_argv = get_alias(argv[0])
834
550
        if alias_argv:
835
 
            user_encoding = osutils.get_user_encoding()
836
 
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
 
551
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
837
552
            argv[0] = alias_argv.pop(0)
838
553
 
839
554
    cmd = argv.pop(0)
842
557
    # 'command not found' error later.
843
558
 
844
559
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
845
 
    run = cmd_obj.run_argv_aliases
846
 
    run_argv = [argv, alias_argv]
 
560
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
561
        run = cmd_obj.run_argv
 
562
        run_argv = [argv]
 
563
    else:
 
564
        run = cmd_obj.run_argv_aliases
 
565
        run_argv = [argv, alias_argv]
847
566
 
848
567
    try:
849
 
        # We can be called recursively (tests for example), but we don't want
850
 
        # the verbosity level to propagate.
851
 
        saved_verbosity_level = option._verbosity_level
852
 
        option._verbosity_level = 0
853
568
        if opt_lsprof:
854
 
            if opt_coverage_dir:
855
 
                trace.warning(
856
 
                    '--coverage ignored, because --lsprof is in use.')
857
569
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
858
570
        elif opt_profile:
859
 
            if opt_coverage_dir:
860
 
                trace.warning(
861
 
                    '--coverage ignored, because --profile is in use.')
862
571
            ret = apply_profiled(run, *run_argv)
863
 
        elif opt_coverage_dir:
864
 
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
865
572
        else:
866
573
            ret = run(*run_argv)
867
 
        if 'memory' in debug.debug_flags:
868
 
            trace.debug_memory('Process status after command:', short=False)
869
574
        return ret or 0
870
575
    finally:
871
 
        # reset, in case we may do other commands later within the same
872
 
        # process. Commands that want to execute sub-commands must propagate
873
 
        # --verbose in their own way.
874
 
        option._verbosity_level = saved_verbosity_level
875
 
 
 
576
        # reset, in case we may do other commands later within the same process
 
577
        be_quiet(False)
876
578
 
877
579
def display_command(func):
878
580
    """Decorator that suppresses pipe/interrupt errors."""
886
588
                raise
887
589
            if e.errno != errno.EPIPE:
888
590
                # Win32 raises IOError with errno=0 on a broken pipe
889
 
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
591
                if sys.platform != 'win32' or e.errno != 0:
890
592
                    raise
891
593
            pass
892
594
        except KeyboardInterrupt:
896
598
 
897
599
def main(argv):
898
600
    import bzrlib.ui
899
 
    bzrlib.ui.ui_factory = bzrlib.ui.make_ui_for_terminal(
900
 
        sys.stdin, sys.stdout, sys.stderr)
901
 
 
902
 
    # Is this a final release version? If so, we should suppress warnings
903
 
    if bzrlib.version_info[3] == 'final':
904
 
        from bzrlib import symbol_versioning
905
 
        symbol_versioning.suppress_deprecation_warnings(override=False)
906
 
    try:
907
 
        user_encoding = osutils.get_user_encoding()
908
 
        argv = [a.decode(user_encoding) for a in argv[1:]]
909
 
    except UnicodeDecodeError:
910
 
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
911
 
                                                            "encoding." % a))
 
601
    from bzrlib.ui.text import TextUIFactory
 
602
    bzrlib.ui.ui_factory = TextUIFactory()
 
603
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
912
604
    ret = run_bzr_catch_errors(argv)
913
 
    trace.mutter("return code %d", ret)
 
605
    mutter("return code %d", ret)
914
606
    return ret
915
607
 
916
608
 
917
609
def run_bzr_catch_errors(argv):
918
 
    # Note: The except clause logic below should be kept in sync with the
919
 
    # profile() routine in lsprof.py.
920
610
    try:
921
611
        return run_bzr(argv)
 
612
        # do this here inside the exception wrappers to catch EPIPE
 
613
        sys.stdout.flush()
922
614
    except (KeyboardInterrupt, Exception), e:
923
615
        # used to handle AssertionError and KeyboardInterrupt
924
616
        # specially here, but hopefully they're handled ok by the logger now
925
 
        exc_info = sys.exc_info()
926
 
        exitcode = trace.report_exception(exc_info, sys.stderr)
 
617
        bzrlib.trace.report_exception(sys.exc_info(), sys.stderr)
927
618
        if os.environ.get('BZR_PDB'):
928
619
            print '**** entering debugger'
929
 
            tb = exc_info[2]
930
620
            import pdb
931
 
            if sys.version_info[:2] < (2, 6):
932
 
                # XXX: we want to do
933
 
                #    pdb.post_mortem(tb)
934
 
                # but because pdb.post_mortem gives bad results for tracebacks
935
 
                # from inside generators, we do it manually.
936
 
                # (http://bugs.python.org/issue4150, fixed in Python 2.6)
937
 
                
938
 
                # Setup pdb on the traceback
939
 
                p = pdb.Pdb()
940
 
                p.reset()
941
 
                p.setup(tb.tb_frame, tb)
942
 
                # Point the debugger at the deepest frame of the stack
943
 
                p.curindex = len(p.stack) - 1
944
 
                p.curframe = p.stack[p.curindex]
945
 
                # Start the pdb prompt.
946
 
                p.print_stack_entry(p.stack[p.curindex])
947
 
                p.execRcLines()
948
 
                p.cmdloop()
949
 
            else:
950
 
                pdb.post_mortem(tb)
951
 
        return exitcode
952
 
 
953
 
 
954
 
def run_bzr_catch_user_errors(argv):
955
 
    """Run bzr and report user errors, but let internal errors propagate.
956
 
 
957
 
    This is used for the test suite, and might be useful for other programs
958
 
    that want to wrap the commandline interface.
959
 
    """
960
 
    try:
961
 
        return run_bzr(argv)
962
 
    except Exception, e:
963
 
        if (isinstance(e, (OSError, IOError))
964
 
            or not getattr(e, 'internal_error', True)):
965
 
            trace.report_exception(sys.exc_info(), sys.stderr)
966
 
            return 3
967
 
        else:
968
 
            raise
969
 
 
970
 
 
971
 
class HelpCommandIndex(object):
972
 
    """A index for bzr help that returns commands."""
973
 
 
974
 
    def __init__(self):
975
 
        self.prefix = 'commands/'
976
 
 
977
 
    def get_topics(self, topic):
978
 
        """Search for topic amongst commands.
979
 
 
980
 
        :param topic: A topic to search for.
981
 
        :return: A list which is either empty or contains a single
982
 
            Command entry.
983
 
        """
984
 
        if topic and topic.startswith(self.prefix):
985
 
            topic = topic[len(self.prefix):]
986
 
        try:
987
 
            cmd = _get_cmd_object(topic)
988
 
        except KeyError:
989
 
            return []
990
 
        else:
991
 
            return [cmd]
992
 
 
993
 
 
994
 
class Provider(object):
995
 
    '''Generic class to be overriden by plugins'''
996
 
 
997
 
    def plugin_for_command(self, cmd_name):
998
 
        '''Takes a command and returns the information for that plugin
999
 
        
1000
 
        :return: A dictionary with all the available information 
1001
 
        for the requested plugin
1002
 
        '''
1003
 
        raise NotImplementedError
1004
 
 
1005
 
 
1006
 
class ProvidersRegistry(registry.Registry):
1007
 
    '''This registry exists to allow other providers to exist'''
1008
 
 
1009
 
    def __iter__(self):
1010
 
        for key, provider in self.iteritems():
1011
 
            yield provider
1012
 
 
1013
 
command_providers_registry = ProvidersRegistry()
1014
 
 
 
621
            pdb.post_mortem(sys.exc_traceback)
 
622
        return 3
1015
623
 
1016
624
if __name__ == '__main__':
1017
625
    sys.exit(main(sys.argv))