← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

[merge] land Robert's branch-formats branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2004, 2005 by Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
# TODO: probably should say which arguments are candidates for glob
19
19
# expansion on windows and do that at the command level.
20
20
 
 
21
# TODO: Help messages for options.
 
22
 
21
23
# TODO: Define arguments by objects, rather than just using names.
22
24
# Those objects can specify the expected type of the argument, which
23
 
# would help with validation and shell completion.  They could also provide
24
 
# help/explanation for that argument in a structured way.
25
 
 
26
 
# TODO: Specific "examples" property on commands for consistent formatting.
 
25
# would help with validation and shell completion.
27
26
 
28
27
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
28
# the profile output behind so it can be interactively examined?
30
29
 
 
30
import sys
31
31
import os
32
 
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
 
import codecs
 
32
from warnings import warn
 
33
from inspect import getdoc
37
34
import errno
38
 
from warnings import warn
39
35
 
40
36
import bzrlib
41
 
from bzrlib import (
42
 
    debug,
43
 
    errors,
44
 
    option,
45
 
    osutils,
46
 
    trace,
47
 
    win32utils,
48
 
    )
49
 
""")
50
 
 
51
 
from bzrlib.symbol_versioning import (
52
 
    deprecated_function,
53
 
    deprecated_method,
54
 
    zero_eight,
55
 
    zero_eleven,
56
 
    )
57
 
# Compatibility
 
37
import bzrlib.trace
 
38
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
 
39
from bzrlib.errors import (BzrError, 
 
40
                           BzrCheckError,
 
41
                           BzrCommandError,
 
42
                           BzrOptionError,
 
43
                           NotBranchError)
 
44
from bzrlib.revisionspec import RevisionSpec
 
45
from bzrlib import BZRDIR
58
46
from bzrlib.option import Option
59
47
 
60
 
 
61
48
plugin_cmds = {}
62
49
 
63
50
 
64
51
def register_command(cmd, decorate=False):
65
 
    """Utility function to help register a command
66
 
 
67
 
    :param cmd: Command subclass to register
68
 
    :param decorate: If true, allow overriding an existing command
69
 
        of the same name; the old command is returned by this function.
70
 
        Otherwise it is an error to try to override an existing command.
71
 
    """
 
52
    "Utility function to help register a command"
72
53
    global plugin_cmds
73
54
    k = cmd.__name__
74
55
    if k.startswith("cmd_"):
75
56
        k_unsquished = _unsquish_command_name(k)
76
57
    else:
77
58
        k_unsquished = k
78
 
    if k_unsquished not in plugin_cmds:
 
59
    if not plugin_cmds.has_key(k_unsquished):
79
60
        plugin_cmds[k_unsquished] = cmd
80
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
 
61
        mutter('registered plugin command %s', k_unsquished)      
81
62
        if decorate and k_unsquished in builtin_command_names():
82
63
            return _builtin_commands()[k_unsquished]
83
64
    elif decorate:
85
66
        plugin_cmds[k_unsquished] = cmd
86
67
        return result
87
68
    else:
88
 
        trace.log_error('Two plugins defined the same command: %r' % k)
89
 
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
69
        log_error('Two plugins defined the same command: %r' % k)
 
70
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
90
71
 
91
72
 
92
73
def _squish_command_name(cmd):
104
85
    builtins = bzrlib.builtins.__dict__
105
86
    for name in builtins:
106
87
        if name.startswith("cmd_"):
107
 
            real_name = _unsquish_command_name(name)
 
88
            real_name = _unsquish_command_name(name)        
108
89
            r[real_name] = builtins[name]
109
90
    return r
 
91
 
110
92
            
111
93
 
112
94
def builtin_command_names():
138
120
    plugins_override
139
121
        If true, plugin commands can override builtins.
140
122
    """
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
123
    from bzrlib.externalcommand import ExternalCommand
150
124
 
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.
 
125
    cmd_name = str(cmd_name)            # not unicode
155
126
 
156
127
    # first look up this command under the specified name
157
128
    cmds = _get_cmd_dict(plugins_override=plugins_override)
168
139
    cmd_obj = ExternalCommand.find_command(cmd_name)
169
140
    if cmd_obj:
170
141
        return cmd_obj
171
 
    raise KeyError
 
142
 
 
143
    raise BzrCommandError("unknown command %r" % cmd_name)
172
144
 
173
145
 
174
146
class Command(object):
212
184
    hidden
213
185
        If true, this command isn't advertised.  This is typically
214
186
        for commands intended for expert users.
215
 
 
216
 
    encoding_type
217
 
        Command objects will get a 'outf' attribute, which has been
218
 
        setup to properly handle encoding of unicode strings.
219
 
        encoding_type determines what will happen when characters cannot
220
 
        be encoded
221
 
            strict - abort if we cannot decode
222
 
            replace - put in a bogus character (typically '?')
223
 
            exact - do not encode sys.stdout
224
 
 
225
 
            NOTE: by default on Windows, sys.stdout is opened as a text
226
 
            stream, therefore LF line-endings are converted to CRLF.
227
 
            When a command uses encoding_type = 'exact', then
228
 
            sys.stdout is forced to be a binary stream, and line-endings
229
 
            will not mangled.
230
 
 
231
187
    """
232
188
    aliases = []
233
189
    takes_args = []
234
190
    takes_options = []
235
 
    encoding_type = 'strict'
236
191
 
237
192
    hidden = False
238
193
    
241
196
        if self.__doc__ == Command.__doc__:
242
197
            warn("No help message set for %r" % self)
243
198
 
244
 
    def _maybe_expand_globs(self, file_list):
245
 
        """Glob expand file_list if the platform does not do that itself.
246
 
        
247
 
        :return: A possibly empty list of unicode paths.
248
 
 
249
 
        Introduced in bzrlib 0.18.
250
 
        """
251
 
        if not file_list:
252
 
            file_list = []
253
 
        if sys.platform == 'win32':
254
 
            file_list = win32utils.glob_expand(file_list)
255
 
        return list(file_list)
256
 
 
257
 
    def _usage(self):
258
 
        """Return single-line grammar for this command.
259
 
 
260
 
        Only describes arguments, not options.
261
 
        """
262
 
        s = 'bzr ' + self.name() + ' '
263
 
        for aname in self.takes_args:
264
 
            aname = aname.upper()
265
 
            if aname[-1] in ['$', '+']:
266
 
                aname = aname[:-1] + '...'
267
 
            elif aname[-1] == '?':
268
 
                aname = '[' + aname[:-1] + ']'
269
 
            elif aname[-1] == '*':
270
 
                aname = '[' + aname[:-1] + '...]'
271
 
            s += aname + ' '
272
 
                
273
 
        assert s[-1] == ' '
274
 
        s = s[:-1]
275
 
        return s
276
 
 
277
 
    def get_help_text(self, additional_see_also=None):
278
 
        """Return a text string with help for this command.
279
 
        
280
 
        :param additional_see_also: Additional help topics to be
281
 
            cross-referenced.
282
 
        """
283
 
        doc = self.help()
284
 
        if doc is None:
285
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
286
 
 
287
 
        result = ""
288
 
        result += 'usage: %s\n' % self._usage()
289
 
 
290
 
        if self.aliases:
291
 
            result += 'aliases: '
292
 
            result += ', '.join(self.aliases) + '\n'
293
 
 
294
 
        result += '\n'
295
 
 
296
 
        plugin_name = self.plugin_name()
297
 
        if plugin_name is not None:
298
 
            result += '(From plugin "%s")' % plugin_name
299
 
            result += '\n\n'
300
 
 
301
 
        result += doc
302
 
        if result[-1] != '\n':
303
 
            result += '\n'
304
 
        result += '\n'
305
 
        result += option.get_optparser(self.options()).format_option_help()
306
 
        see_also = self.get_see_also(additional_see_also)
307
 
        if see_also:
308
 
            result += '\nSee also: '
309
 
            result += ', '.join(see_also)
310
 
            result += '\n'
311
 
        return result
312
 
 
313
 
    def get_help_topic(self):
314
 
        """Return the commands help topic - its name."""
315
 
        return self.name()
316
 
 
317
 
    def get_see_also(self, additional_terms=None):
318
 
        """Return a list of help topics that are related to this ommand.
319
 
        
320
 
        The list is derived from the content of the _see_also attribute. Any
321
 
        duplicates are removed and the result is in lexical order.
322
 
        :param additional_terms: Additional help topics to cross-reference.
323
 
        :return: A list of help topics.
324
 
        """
325
 
        see_also = set(getattr(self, '_see_also', []))
326
 
        if additional_terms:
327
 
            see_also.update(additional_terms)
328
 
        return sorted(see_also)
329
 
 
330
199
    def options(self):
331
200
        """Return dict of valid options for this command.
332
201
 
333
202
        Maps from long option name to option object."""
334
203
        r = dict()
335
 
        r['help'] = option._help_option
 
204
        r['help'] = Option.OPTIONS['help']
336
205
        for o in self.takes_options:
337
 
            if isinstance(o, basestring):
338
 
                o = option.Option.OPTIONS[o]
 
206
            if not isinstance(o, Option):
 
207
                o = Option.OPTIONS[o]
339
208
            r[o.name] = o
340
209
        return r
341
210
 
342
 
    def _setup_outf(self):
343
 
        """Return a file linked to stdout, which has proper encoding."""
344
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
345
 
 
346
 
        # Originally I was using self.stdout, but that looks
347
 
        # *way* too much like sys.stdout
348
 
        if self.encoding_type == 'exact':
349
 
            # force sys.stdout to be binary stream on win32
350
 
            if sys.platform == 'win32':
351
 
                fileno = getattr(sys.stdout, 'fileno', None)
352
 
                if fileno:
353
 
                    import msvcrt
354
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
355
 
            self.outf = sys.stdout
356
 
            return
357
 
 
358
 
        output_encoding = osutils.get_terminal_encoding()
359
 
 
360
 
        # use 'replace' so that we don't abort if trying to write out
361
 
        # in e.g. the default C locale.
362
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
363
 
        # For whatever reason codecs.getwriter() does not advertise its encoding
364
 
        # it just returns the encoding of the wrapped file, which is completely
365
 
        # bogus. So set the attribute, so we can find the correct encoding later.
366
 
        self.outf.encoding = output_encoding
367
 
 
368
 
    def run_argv_aliases(self, argv, alias_argv=None):
369
 
        """Parse the command line and run with extra aliases in alias_argv."""
370
 
        if argv is None:
371
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
372
 
                 DeprecationWarning, stacklevel=2)
373
 
            argv = []
374
 
        args, opts = parse_args(self, argv, alias_argv)
 
211
    def run_argv(self, argv):
 
212
        """Parse command line and run."""
 
213
        args, opts = parse_args(self, argv)
375
214
        if 'help' in opts:  # e.g. bzr add --help
376
 
            sys.stdout.write(self.get_help_text())
 
215
            from bzrlib.help import help_on_command
 
216
            help_on_command(self.name())
377
217
            return 0
 
218
        # XXX: This should be handled by the parser
 
219
        allowed_names = self.options().keys()
 
220
        for oname in opts:
 
221
            if oname not in allowed_names:
 
222
                raise BzrCommandError("option '--%s' is not allowed for command %r"
 
223
                                      % (oname, self.name()))
378
224
        # mix arguments and options into one dictionary
379
225
        cmdargs = _match_argform(self.name(), self.takes_args, args)
380
226
        cmdopts = {}
384
230
        all_cmd_args = cmdargs.copy()
385
231
        all_cmd_args.update(cmdopts)
386
232
 
387
 
        self._setup_outf()
388
 
 
389
233
        return self.run(**all_cmd_args)
390
234
    
391
235
    def run(self):
398
242
        shell error code if not.  It's OK for this method to allow
399
243
        an exception to raise up.
400
244
        """
401
 
        raise NotImplementedError('no implementation of command %r'
402
 
                                  % self.name())
 
245
        raise NotImplementedError()
 
246
 
403
247
 
404
248
    def help(self):
405
249
        """Return help message for this class."""
406
 
        from inspect import getdoc
407
250
        if self.__doc__ is Command.__doc__:
408
251
            return None
409
252
        return getdoc(self)
411
254
    def name(self):
412
255
        return _unsquish_command_name(self.__class__.__name__)
413
256
 
414
 
    def plugin_name(self):
415
 
        """Get the name of the plugin that provides this command.
416
 
 
417
 
        :return: The name of the plugin or None if the command is builtin.
418
 
        """
419
 
        mod_parts = self.__module__.split('.')
420
 
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
421
 
            return mod_parts[2]
422
 
        else:
423
 
            return None
424
 
 
425
 
 
426
 
# Technically, this function hasn't been use in a *really* long time
427
 
# but we are only deprecating it now.
428
 
@deprecated_function(zero_eleven)
 
257
 
429
258
def parse_spec(spec):
430
259
    """
431
260
    >>> parse_spec(None)
457
286
        parsed = [spec, None]
458
287
    return parsed
459
288
 
460
 
def parse_args(command, argv, alias_argv=None):
 
289
def parse_args(command, argv):
461
290
    """Parse command line.
462
291
    
463
292
    Arguments and options are parsed at this level before being passed
465
294
    lookup table, something about the available options, what optargs
466
295
    they take, and which commands will accept them.
467
296
    """
468
 
    # TODO: make it a method of the Command?
469
 
    parser = option.get_optparser(command.options())
470
 
    if alias_argv is not None:
471
 
        args = alias_argv + argv
472
 
    else:
473
 
        args = argv
474
 
 
475
 
    options, args = parser.parse_args(args)
476
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
477
 
                 v is not option.OptionParser.DEFAULT_VALUE])
 
297
    # TODO: chop up this beast; make it a method of the Command
 
298
    args = []
 
299
    opts = {}
 
300
 
 
301
    cmd_options = command.options()
 
302
    argsover = False
 
303
    while argv:
 
304
        a = argv.pop(0)
 
305
        if argsover:
 
306
            args.append(a)
 
307
            continue
 
308
        elif a == '--':
 
309
            # We've received a standalone -- No more flags
 
310
            argsover = True
 
311
            continue
 
312
        if a[0] == '-':
 
313
            # option names must not be unicode
 
314
            a = str(a)
 
315
            optarg = None
 
316
            if a[1] == '-':
 
317
                mutter("  got option %r", a)
 
318
                if '=' in a:
 
319
                    optname, optarg = a[2:].split('=', 1)
 
320
                else:
 
321
                    optname = a[2:]
 
322
                if optname not in cmd_options:
 
323
                    raise BzrOptionError('unknown long option %r for command %s'
 
324
                        % (a, command.name()))
 
325
            else:
 
326
                shortopt = a[1:]
 
327
                if shortopt in Option.SHORT_OPTIONS:
 
328
                    # Multi-character options must have a space to delimit
 
329
                    # their value
 
330
                    # ^^^ what does this mean? mbp 20051014
 
331
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
332
                else:
 
333
                    # Single character short options, can be chained,
 
334
                    # and have their value appended to their name
 
335
                    shortopt = a[1:2]
 
336
                    if shortopt not in Option.SHORT_OPTIONS:
 
337
                        # We didn't find the multi-character name, and we
 
338
                        # didn't find the single char name
 
339
                        raise BzrError('unknown short option %r' % a)
 
340
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
341
 
 
342
                    if a[2:]:
 
343
                        # There are extra things on this option
 
344
                        # see if it is the value, or if it is another
 
345
                        # short option
 
346
                        optargfn = Option.OPTIONS[optname].type
 
347
                        if optargfn is None:
 
348
                            # This option does not take an argument, so the
 
349
                            # next entry is another short option, pack it back
 
350
                            # into the list
 
351
                            argv.insert(0, '-' + a[2:])
 
352
                        else:
 
353
                            # This option takes an argument, so pack it
 
354
                            # into the array
 
355
                            optarg = a[2:]
 
356
            
 
357
                if optname not in cmd_options:
 
358
                    raise BzrOptionError('unknown short option %r for command'
 
359
                        ' %s' % (shortopt, command.name()))
 
360
            if optname in opts:
 
361
                # XXX: Do we ever want to support this, e.g. for -r?
 
362
                raise BzrError('repeated option %r' % a)
 
363
                
 
364
            option_obj = cmd_options[optname]
 
365
            optargfn = option_obj.type
 
366
            if optargfn:
 
367
                if optarg == None:
 
368
                    if not argv:
 
369
                        raise BzrError('option %r needs an argument' % a)
 
370
                    else:
 
371
                        optarg = argv.pop(0)
 
372
                opts[optname] = optargfn(optarg)
 
373
            else:
 
374
                if optarg != None:
 
375
                    raise BzrError('option %r takes no argument' % optname)
 
376
                opts[optname] = True
 
377
        else:
 
378
            args.append(a)
478
379
    return args, opts
479
380
 
480
381
 
495
396
                argdict[argname + '_list'] = None
496
397
        elif ap[-1] == '+':
497
398
            if not args:
498
 
                raise errors.BzrCommandError("command %r needs one or more %s"
499
 
                                             % (cmd, argname.upper()))
 
399
                raise BzrCommandError("command %r needs one or more %s"
 
400
                        % (cmd, argname.upper()))
500
401
            else:
501
402
                argdict[argname + '_list'] = args[:]
502
403
                args = []
503
404
        elif ap[-1] == '$': # all but one
504
405
            if len(args) < 2:
505
 
                raise errors.BzrCommandError("command %r needs one or more %s"
506
 
                                             % (cmd, argname.upper()))
 
406
                raise BzrCommandError("command %r needs one or more %s"
 
407
                        % (cmd, argname.upper()))
507
408
            argdict[argname + '_list'] = args[:-1]
508
 
            args[:-1] = []
 
409
            args[:-1] = []                
509
410
        else:
510
411
            # just a plain arg
511
412
            argname = ap
512
413
            if not args:
513
 
                raise errors.BzrCommandError("command %r requires argument %s"
514
 
                               % (cmd, argname.upper()))
 
414
                raise BzrCommandError("command %r requires argument %s"
 
415
                        % (cmd, argname.upper()))
515
416
            else:
516
417
                argdict[argname] = args.pop(0)
517
418
            
518
419
    if args:
519
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
520
 
                                     % (cmd, args[0]))
 
420
        raise BzrCommandError("extra argument to command %s: %s"
 
421
                              % (cmd, args[0]))
521
422
 
522
423
    return argdict
523
424
 
546
447
        os.remove(pfname)
547
448
 
548
449
 
549
 
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
450
def apply_lsprofiled(the_callable, *args, **kwargs):
550
451
    from bzrlib.lsprof import profile
551
 
    ret, stats = profile(the_callable, *args, **kwargs)
 
452
    ret,stats = profile(the_callable,*args,**kwargs)
552
453
    stats.sort()
553
 
    if filename is None:
554
 
        stats.pprint()
555
 
    else:
556
 
        stats.save(filename)
557
 
        trace.note('Profile data written to "%s".', filename)
 
454
    stats.pprint()
558
455
    return ret
559
456
 
560
 
 
561
 
def get_alias(cmd, config=None):
562
 
    """Return an expanded alias, or None if no alias exists.
563
 
 
564
 
    cmd
565
 
        Command to be checked for an alias.
566
 
    config
567
 
        Used to specify an alternative config to use,
568
 
        which is especially useful for testing.
569
 
        If it is unspecified, the global config will be used.
570
 
    """
571
 
    if config is None:
572
 
        import bzrlib.config
573
 
        config = bzrlib.config.GlobalConfig()
574
 
    alias = config.get_alias(cmd)
575
 
    if (alias):
576
 
        import shlex
577
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
578
 
    return None
579
 
 
580
 
 
581
457
def run_bzr(argv):
582
458
    """Execute a command.
583
459
 
586
462
    
587
463
    argv
588
464
       The command-line arguments, without the program name from argv[0]
589
 
       These should already be decoded. All library/test code calling
590
 
       run_bzr should be passing valid strings (don't need decoding).
591
465
    
592
466
    Returns a command status or raises an exception.
593
467
 
597
471
    --no-plugins
598
472
        Do not load plugin modules at all
599
473
 
600
 
    --no-aliases
601
 
        Do not allow aliases
602
 
 
603
474
    --builtin
604
475
        Only use builtin commands.  (Plugins are still allowed to change
605
476
        other behaviour.)
610
481
    --lsprof
611
482
        Run under the Python lsprof profiler.
612
483
    """
613
 
    argv = list(argv)
614
 
    trace.mutter("bzr arguments: %r", argv)
 
484
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
615
485
 
616
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
617
 
                opt_no_aliases = False
618
 
    opt_lsprof_file = None
 
486
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = False
619
487
 
620
488
    # --no-plugins is handled specially at a very early stage. We need
621
489
    # to load plugins before doing other command parsing so that they
622
490
    # can override commands, but this needs to happen first.
623
491
 
624
 
    argv_copy = []
625
 
    i = 0
626
 
    while i < len(argv):
627
 
        a = argv[i]
 
492
    for a in argv:
628
493
        if a == '--profile':
629
494
            opt_profile = True
630
495
        elif a == '--lsprof':
631
496
            opt_lsprof = True
632
 
        elif a == '--lsprof-file':
633
 
            opt_lsprof = True
634
 
            opt_lsprof_file = argv[i + 1]
635
 
            i += 1
636
497
        elif a == '--no-plugins':
637
498
            opt_no_plugins = True
638
 
        elif a == '--no-aliases':
639
 
            opt_no_aliases = True
640
499
        elif a == '--builtin':
641
500
            opt_builtin = True
642
501
        elif a in ('--quiet', '-q'):
643
 
            trace.be_quiet()
644
 
        elif a.startswith('-D'):
645
 
            debug.debug_flags.add(a[2:])
 
502
            be_quiet()
646
503
        else:
647
 
            argv_copy.append(a)
648
 
        i += 1
 
504
            continue
 
505
        argv.remove(a)
649
506
 
650
 
    argv = argv_copy
651
 
    if (not argv):
652
 
        from bzrlib.builtins import cmd_help
653
 
        cmd_help().run_argv_aliases([])
 
507
    if (not argv) or (argv[0] == '--help'):
 
508
        from bzrlib.help import help
 
509
        if len(argv) > 1:
 
510
            help(argv[1])
 
511
        else:
 
512
            help()
654
513
        return 0
655
514
 
656
515
    if argv[0] == '--version':
657
 
        from bzrlib.version import show_version
 
516
        from bzrlib.builtins import show_version
658
517
        show_version()
659
518
        return 0
660
519
        
661
520
    if not opt_no_plugins:
662
521
        from bzrlib.plugin import load_plugins
663
522
        load_plugins()
664
 
    else:
665
 
        from bzrlib.plugin import disable_plugins
666
 
        disable_plugins()
667
 
 
668
 
    alias_argv = None
669
 
 
670
 
    if not opt_no_aliases:
671
 
        alias_argv = get_alias(argv[0])
672
 
        if alias_argv:
673
 
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
674
 
            argv[0] = alias_argv.pop(0)
675
 
 
676
 
    cmd = argv.pop(0)
677
 
    # We want only 'ascii' command names, but the user may have typed
678
 
    # in a Unicode name. In that case, they should just get a
679
 
    # 'command not found' error later.
 
523
 
 
524
    cmd = str(argv.pop(0))
680
525
 
681
526
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
682
 
    run = cmd_obj.run_argv_aliases
683
 
    run_argv = [argv, alias_argv]
684
527
 
685
528
    try:
686
529
        if opt_lsprof:
687
 
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
530
            ret = apply_lsprofiled(cmd_obj.run_argv, argv)
688
531
        elif opt_profile:
689
 
            ret = apply_profiled(run, *run_argv)
 
532
            ret = apply_profiled(cmd_obj.run_argv, argv)
690
533
        else:
691
 
            ret = run(*run_argv)
 
534
            ret = cmd_obj.run_argv(argv)
692
535
        return ret or 0
693
536
    finally:
694
537
        # reset, in case we may do other commands later within the same process
695
 
        trace.be_quiet(False)
 
538
        be_quiet(False)
696
539
 
697
540
def display_command(func):
698
541
    """Decorator that suppresses pipe/interrupt errors."""
702
545
            sys.stdout.flush()
703
546
            return result
704
547
        except IOError, e:
705
 
            if getattr(e, 'errno', None) is None:
 
548
            if not hasattr(e, 'errno'):
706
549
                raise
707
550
            if e.errno != errno.EPIPE:
708
 
                # Win32 raises IOError with errno=0 on a broken pipe
709
 
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
710
 
                    raise
 
551
                raise
711
552
            pass
712
553
        except KeyboardInterrupt:
713
554
            pass
717
558
def main(argv):
718
559
    import bzrlib.ui
719
560
    from bzrlib.ui.text import TextUIFactory
 
561
    ## bzrlib.trace.enable_default_logging()
 
562
    bzrlib.trace.log_startup(argv)
720
563
    bzrlib.ui.ui_factory = TextUIFactory()
721
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
722
 
    ret = run_bzr_catch_errors(argv)
723
 
    trace.mutter("return code %d", ret)
 
564
    ret = run_bzr_catch_errors(argv[1:])
 
565
    mutter("return code %d", ret)
724
566
    return ret
725
567
 
726
568
 
727
569
def run_bzr_catch_errors(argv):
728
570
    try:
729
 
        return run_bzr(argv)
730
 
    except (KeyboardInterrupt, Exception), e:
 
571
        try:
 
572
            return run_bzr(argv)
 
573
        finally:
 
574
            # do this here inside the exception wrappers to catch EPIPE
 
575
            sys.stdout.flush()
 
576
    except Exception, e:
731
577
        # used to handle AssertionError and KeyboardInterrupt
732
578
        # specially here, but hopefully they're handled ok by the logger now
733
 
        trace.report_exception(sys.exc_info(), sys.stderr)
734
 
        if os.environ.get('BZR_PDB'):
735
 
            print '**** entering debugger'
736
 
            import pdb
737
 
            pdb.post_mortem(sys.exc_traceback)
738
 
        return 3
739
 
 
740
 
 
741
 
class HelpCommandIndex(object):
742
 
    """A index for bzr help that returns commands."""
743
 
 
744
 
    def __init__(self):
745
 
        self.prefix = 'commands/'
746
 
 
747
 
    def get_topics(self, topic):
748
 
        """Search for topic amongst commands.
749
 
 
750
 
        :param topic: A topic to search for.
751
 
        :return: A list which is either empty or contains a single
752
 
            Command entry.
753
 
        """
754
 
        if topic and topic.startswith(self.prefix):
755
 
            topic = topic[len(self.prefix):]
756
 
        try:
757
 
            cmd = _get_cmd_object(topic)
758
 
        except KeyError:
759
 
            return []
 
579
        import errno
 
580
        if (isinstance(e, IOError) 
 
581
            and hasattr(e, 'errno')
 
582
            and e.errno == errno.EPIPE):
 
583
            bzrlib.trace.note('broken pipe')
 
584
            return 3
760
585
        else:
761
 
            return [cmd]
762
 
 
 
586
            bzrlib.trace.log_exception()
 
587
            if os.environ.get('BZR_PDB'):
 
588
                print '**** entering debugger'
 
589
                import pdb
 
590
                pdb.post_mortem(sys.exc_traceback)
 
591
            return 3
763
592
 
764
593
if __name__ == '__main__':
765
594
    sys.exit(main(sys.argv))