← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Vincent Ladeuil
  • Date: 2007-07-15 11:24:18 UTC
  • mfrom: (2617 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070715112418-9nn4n6esxv60ny4b
merge bzr.dev@1617

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 by 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
31
32
import sys
32
 
import os
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import codecs
 
37
import errno
33
38
from warnings import warn
34
 
import errno
35
39
 
36
40
import bzrlib
37
 
from bzrlib.errors import (BzrError, 
38
 
                           BzrCheckError,
39
 
                           BzrCommandError,
40
 
                           BzrOptionError,
41
 
                           NotBranchError)
 
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
42
58
from bzrlib.option import Option
43
 
from bzrlib.revisionspec import RevisionSpec
44
 
from bzrlib.symbol_versioning import *
45
 
import bzrlib.trace
46
 
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
 
59
 
47
60
 
48
61
plugin_cmds = {}
49
62
 
62
75
        k_unsquished = _unsquish_command_name(k)
63
76
    else:
64
77
        k_unsquished = k
65
 
    if not plugin_cmds.has_key(k_unsquished):
 
78
    if k_unsquished not in plugin_cmds:
66
79
        plugin_cmds[k_unsquished] = cmd
67
 
        mutter('registered plugin command %s', k_unsquished)
 
80
        ## trace.mutter('registered plugin command %s', k_unsquished)
68
81
        if decorate and k_unsquished in builtin_command_names():
69
82
            return _builtin_commands()[k_unsquished]
70
83
    elif decorate:
72
85
        plugin_cmds[k_unsquished] = cmd
73
86
        return result
74
87
    else:
75
 
        log_error('Two plugins defined the same command: %r' % k)
76
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
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__])
77
90
 
78
91
 
79
92
def _squish_command_name(cmd):
125
138
    plugins_override
126
139
        If true, plugin commands can override builtins.
127
140
    """
 
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."""
128
149
    from bzrlib.externalcommand import ExternalCommand
129
150
 
130
 
    cmd_name = str(cmd_name)            # not unicode
 
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.
131
155
 
132
156
    # first look up this command under the specified name
133
157
    cmds = _get_cmd_dict(plugins_override=plugins_override)
144
168
    cmd_obj = ExternalCommand.find_command(cmd_name)
145
169
    if cmd_obj:
146
170
        return cmd_obj
147
 
 
148
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
171
    raise KeyError
149
172
 
150
173
 
151
174
class Command(object):
189
212
    hidden
190
213
        If true, this command isn't advertised.  This is typically
191
214
        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
 
192
231
    """
193
232
    aliases = []
194
233
    takes_args = []
195
234
    takes_options = []
 
235
    encoding_type = 'strict'
196
236
 
197
237
    hidden = False
198
238
    
201
241
        if self.__doc__ == Command.__doc__:
202
242
            warn("No help message set for %r" % self)
203
243
 
 
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
 
204
330
    def options(self):
205
331
        """Return dict of valid options for this command.
206
332
 
207
333
        Maps from long option name to option object."""
208
334
        r = dict()
209
 
        r['help'] = Option.OPTIONS['help']
 
335
        r['help'] = option._help_option
210
336
        for o in self.takes_options:
211
 
            if not isinstance(o, Option):
212
 
                o = Option.OPTIONS[o]
 
337
            if isinstance(o, basestring):
 
338
                o = option.Option.OPTIONS[o]
213
339
            r[o.name] = o
214
340
        return r
215
341
 
216
 
    @deprecated_method(zero_eight)
217
 
    def run_argv(self, argv):
218
 
        """Parse command line and run.
219
 
        
220
 
        See run_argv_aliases for the 0.8 and beyond api.
221
 
        """
222
 
        return self.run_argv_aliases(argv)
 
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
223
367
 
224
368
    def run_argv_aliases(self, argv, alias_argv=None):
225
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 = []
226
374
        args, opts = parse_args(self, argv, alias_argv)
227
375
        if 'help' in opts:  # e.g. bzr add --help
228
 
            from bzrlib.help import help_on_command
229
 
            help_on_command(self.name())
 
376
            sys.stdout.write(self.get_help_text())
230
377
            return 0
231
 
        # XXX: This should be handled by the parser
232
 
        allowed_names = self.options().keys()
233
 
        for oname in opts:
234
 
            if oname not in allowed_names:
235
 
                raise BzrCommandError("option '--%s' is not allowed for"
236
 
                                      " command %r" % (oname, self.name()))
237
378
        # mix arguments and options into one dictionary
238
379
        cmdargs = _match_argform(self.name(), self.takes_args, args)
239
380
        cmdopts = {}
243
384
        all_cmd_args = cmdargs.copy()
244
385
        all_cmd_args.update(cmdopts)
245
386
 
 
387
        self._setup_outf()
 
388
 
246
389
        return self.run(**all_cmd_args)
247
390
    
248
391
    def run(self):
255
398
        shell error code if not.  It's OK for this method to allow
256
399
        an exception to raise up.
257
400
        """
258
 
        raise NotImplementedError('no implementation of command %r' 
 
401
        raise NotImplementedError('no implementation of command %r'
259
402
                                  % self.name())
260
403
 
261
404
    def help(self):
268
411
    def name(self):
269
412
        return _unsquish_command_name(self.__class__.__name__)
270
413
 
271
 
 
 
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)
272
429
def parse_spec(spec):
273
430
    """
274
431
    >>> parse_spec(None)
308
465
    lookup table, something about the available options, what optargs
309
466
    they take, and which commands will accept them.
310
467
    """
311
 
    # TODO: chop up this beast; make it a method of the Command
312
 
    args = []
313
 
    opts = {}
314
 
    alias_opts = {}
315
 
 
316
 
    cmd_options = command.options()
317
 
    argsover = False
318
 
    proc_aliasarg = True # Are we processing alias_argv now?
319
 
    for proc_argv in alias_argv, argv:
320
 
        while proc_argv:
321
 
            a = proc_argv.pop(0)
322
 
            if argsover:
323
 
                args.append(a)
324
 
                continue
325
 
            elif a == '--':
326
 
                # We've received a standalone -- No more flags
327
 
                argsover = True
328
 
                continue
329
 
            if a[0] == '-':
330
 
                # option names must not be unicode
331
 
                a = str(a)
332
 
                optarg = None
333
 
                if a[1] == '-':
334
 
                    mutter("  got option %r", a)
335
 
                    if '=' in a:
336
 
                        optname, optarg = a[2:].split('=', 1)
337
 
                    else:
338
 
                        optname = a[2:]
339
 
                    if optname not in cmd_options:
340
 
                        raise BzrOptionError('unknown long option %r for'
341
 
                                             ' command %s' % 
342
 
                                             (a, command.name()))
343
 
                else:
344
 
                    shortopt = a[1:]
345
 
                    if shortopt in Option.SHORT_OPTIONS:
346
 
                        # Multi-character options must have a space to delimit
347
 
                        # their value
348
 
                        # ^^^ what does this mean? mbp 20051014
349
 
                        optname = Option.SHORT_OPTIONS[shortopt].name
350
 
                    else:
351
 
                        # Single character short options, can be chained,
352
 
                        # and have their value appended to their name
353
 
                        shortopt = a[1:2]
354
 
                        if shortopt not in Option.SHORT_OPTIONS:
355
 
                            # We didn't find the multi-character name, and we
356
 
                            # didn't find the single char name
357
 
                            raise BzrError('unknown short option %r' % a)
358
 
                        optname = Option.SHORT_OPTIONS[shortopt].name
359
 
 
360
 
                        if a[2:]:
361
 
                            # There are extra things on this option
362
 
                            # see if it is the value, or if it is another
363
 
                            # short option
364
 
                            optargfn = Option.OPTIONS[optname].type
365
 
                            if optargfn is None:
366
 
                                # This option does not take an argument, so the
367
 
                                # next entry is another short option, pack it
368
 
                                # back into the list
369
 
                                proc_argv.insert(0, '-' + a[2:])
370
 
                            else:
371
 
                                # This option takes an argument, so pack it
372
 
                                # into the array
373
 
                                optarg = a[2:]
374
 
                
375
 
                    if optname not in cmd_options:
376
 
                        raise BzrOptionError('unknown short option %r for'
377
 
                                             ' command %s' % 
378
 
                                             (shortopt, command.name()))
379
 
                if optname in opts:
380
 
                    # XXX: Do we ever want to support this, e.g. for -r?
381
 
                    if proc_aliasarg:
382
 
                        raise BzrError('repeated option %r' % a)
383
 
                    elif optname in alias_opts:
384
 
                        # Replace what's in the alias with what's in the real
385
 
                        # argument
386
 
                        del alias_opts[optname]
387
 
                        del opts[optname]
388
 
                        proc_argv.insert(0, a)
389
 
                        continue
390
 
                    else:
391
 
                        raise BzrError('repeated option %r' % a)
392
 
                    
393
 
                option_obj = cmd_options[optname]
394
 
                optargfn = option_obj.type
395
 
                if optargfn:
396
 
                    if optarg == None:
397
 
                        if not proc_argv:
398
 
                            raise BzrError('option %r needs an argument' % a)
399
 
                        else:
400
 
                            optarg = proc_argv.pop(0)
401
 
                    opts[optname] = optargfn(optarg)
402
 
                    if proc_aliasarg:
403
 
                        alias_opts[optname] = optargfn(optarg)
404
 
                else:
405
 
                    if optarg != None:
406
 
                        raise BzrError('option %r takes no argument' % optname)
407
 
                    opts[optname] = True
408
 
                    if proc_aliasarg:
409
 
                        alias_opts[optname] = True
410
 
            else:
411
 
                args.append(a)
412
 
        proc_aliasarg = False # Done with alias argv
 
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])
413
478
    return args, opts
414
479
 
415
480
 
430
495
                argdict[argname + '_list'] = None
431
496
        elif ap[-1] == '+':
432
497
            if not args:
433
 
                raise BzrCommandError("command %r needs one or more %s"
434
 
                        % (cmd, argname.upper()))
 
498
                raise errors.BzrCommandError("command %r needs one or more %s"
 
499
                                             % (cmd, argname.upper()))
435
500
            else:
436
501
                argdict[argname + '_list'] = args[:]
437
502
                args = []
438
503
        elif ap[-1] == '$': # all but one
439
504
            if len(args) < 2:
440
 
                raise BzrCommandError("command %r needs one or more %s"
441
 
                        % (cmd, argname.upper()))
 
505
                raise errors.BzrCommandError("command %r needs one or more %s"
 
506
                                             % (cmd, argname.upper()))
442
507
            argdict[argname + '_list'] = args[:-1]
443
 
            args[:-1] = []                
 
508
            args[:-1] = []
444
509
        else:
445
510
            # just a plain arg
446
511
            argname = ap
447
512
            if not args:
448
 
                raise BzrCommandError("command %r requires argument %s"
449
 
                        % (cmd, argname.upper()))
 
513
                raise errors.BzrCommandError("command %r requires argument %s"
 
514
                               % (cmd, argname.upper()))
450
515
            else:
451
516
                argdict[argname] = args.pop(0)
452
517
            
453
518
    if args:
454
 
        raise BzrCommandError("extra argument to command %s: %s"
455
 
                              % (cmd, args[0]))
 
519
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
520
                                     % (cmd, args[0]))
456
521
 
457
522
    return argdict
458
523
 
483
548
 
484
549
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
485
550
    from bzrlib.lsprof import profile
486
 
    import cPickle
487
551
    ret, stats = profile(the_callable, *args, **kwargs)
488
552
    stats.sort()
489
553
    if filename is None:
490
554
        stats.pprint()
491
555
    else:
492
 
        stats.freeze()
493
 
        cPickle.dump(stats, open(filename, 'w'), 2)
494
 
        print 'Profile data written to %r.' % filename
 
556
        stats.save(filename)
 
557
        trace.note('Profile data written to "%s".', filename)
495
558
    return ret
496
559
 
497
560
 
498
 
def get_alias(cmd):
499
 
    """Return an expanded alias, or None if no alias exists"""
500
 
    import bzrlib.config
501
 
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
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)
502
575
    if (alias):
503
 
        return alias.split(' ')
 
576
        import shlex
 
577
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
504
578
    return None
505
579
 
506
580
 
512
586
    
513
587
    argv
514
588
       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).
515
591
    
516
592
    Returns a command status or raises an exception.
517
593
 
534
610
    --lsprof
535
611
        Run under the Python lsprof profiler.
536
612
    """
537
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
613
    argv = list(argv)
 
614
    trace.mutter("bzr arguments: %r", argv)
538
615
 
539
616
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
540
617
                opt_no_aliases = False
553
630
        elif a == '--lsprof':
554
631
            opt_lsprof = True
555
632
        elif a == '--lsprof-file':
 
633
            opt_lsprof = True
556
634
            opt_lsprof_file = argv[i + 1]
557
635
            i += 1
558
636
        elif a == '--no-plugins':
562
640
        elif a == '--builtin':
563
641
            opt_builtin = True
564
642
        elif a in ('--quiet', '-q'):
565
 
            be_quiet()
 
643
            trace.be_quiet()
 
644
        elif a.startswith('-D'):
 
645
            debug.debug_flags.add(a[2:])
566
646
        else:
567
647
            argv_copy.append(a)
568
648
        i += 1
569
649
 
570
650
    argv = argv_copy
571
 
    if (not argv) or (argv[0] == '--help'):
572
 
        from bzrlib.help import help
573
 
        if len(argv) > 1:
574
 
            help(argv[1])
575
 
        else:
576
 
            help()
 
651
    if (not argv):
 
652
        from bzrlib.builtins import cmd_help
 
653
        cmd_help().run_argv_aliases([])
577
654
        return 0
578
655
 
579
656
    if argv[0] == '--version':
580
 
        from bzrlib.builtins import show_version
 
657
        from bzrlib.version import show_version
581
658
        show_version()
582
659
        return 0
583
660
        
596
673
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
597
674
            argv[0] = alias_argv.pop(0)
598
675
 
599
 
    cmd = str(argv.pop(0))
 
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.
600
680
 
601
681
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
602
 
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
603
 
        run = cmd_obj.run_argv
604
 
        run_argv = [argv]
605
 
    else:
606
 
        run = cmd_obj.run_argv_aliases
607
 
        run_argv = [argv, alias_argv]
 
682
    run = cmd_obj.run_argv_aliases
 
683
    run_argv = [argv, alias_argv]
608
684
 
609
685
    try:
610
686
        if opt_lsprof:
616
692
        return ret or 0
617
693
    finally:
618
694
        # reset, in case we may do other commands later within the same process
619
 
        be_quiet(False)
 
695
        trace.be_quiet(False)
620
696
 
621
697
def display_command(func):
622
698
    """Decorator that suppresses pipe/interrupt errors."""
626
702
            sys.stdout.flush()
627
703
            return result
628
704
        except IOError, e:
629
 
            if not hasattr(e, 'errno'):
 
705
            if getattr(e, 'errno', None) is None:
630
706
                raise
631
707
            if e.errno != errno.EPIPE:
632
 
                raise
 
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
633
711
            pass
634
712
        except KeyboardInterrupt:
635
713
            pass
639
717
def main(argv):
640
718
    import bzrlib.ui
641
719
    from bzrlib.ui.text import TextUIFactory
642
 
    ## bzrlib.trace.enable_default_logging()
643
 
    bzrlib.trace.log_startup(argv)
644
720
    bzrlib.ui.ui_factory = TextUIFactory()
645
 
    ret = run_bzr_catch_errors(argv[1:])
646
 
    mutter("return code %d", ret)
 
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)
647
724
    return ret
648
725
 
649
726
 
650
727
def run_bzr_catch_errors(argv):
651
728
    try:
652
 
        try:
653
 
            return run_bzr(argv)
654
 
        finally:
655
 
            # do this here inside the exception wrappers to catch EPIPE
656
 
            sys.stdout.flush()
657
 
    except Exception, e:
 
729
        return run_bzr(argv)
 
730
    except (KeyboardInterrupt, Exception), e:
658
731
        # used to handle AssertionError and KeyboardInterrupt
659
732
        # specially here, but hopefully they're handled ok by the logger now
660
 
        import errno
661
 
        if (isinstance(e, IOError) 
662
 
            and hasattr(e, 'errno')
663
 
            and e.errno == errno.EPIPE):
664
 
            bzrlib.trace.note('broken pipe')
665
 
            return 3
 
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 []
666
760
        else:
667
 
            bzrlib.trace.log_exception()
668
 
            if os.environ.get('BZR_PDB'):
669
 
                print '**** entering debugger'
670
 
                import pdb
671
 
                pdb.post_mortem(sys.exc_traceback)
672
 
            return 3
 
761
            return [cmd]
 
762
 
673
763
 
674
764
if __name__ == '__main__':
675
765
    sys.exit(main(sys.argv))