← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

Compare URLs in RemoteRepository.__eq__, rather than '_client' attributes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 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
 
 
23
21
# TODO: Define arguments by objects, rather than just using names.
24
22
# Those objects can specify the expected type of the argument, which
25
 
# would help with validation and shell completion.
 
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.
26
27
 
27
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
28
29
# the profile output behind so it can be interactively examined?
29
30
 
 
31
import os
30
32
import sys
31
 
import os
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import codecs
 
37
import errno
32
38
from warnings import warn
33
 
from inspect import getdoc
34
 
import errno
35
39
 
36
40
import bzrlib
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
 
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
46
58
from bzrlib.option import Option
47
59
 
 
60
 
48
61
plugin_cmds = {}
49
62
 
50
63
 
51
64
def register_command(cmd, decorate=False):
52
 
    "Utility function to help register a command"
 
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
    """
53
72
    global plugin_cmds
54
73
    k = cmd.__name__
55
74
    if k.startswith("cmd_"):
56
75
        k_unsquished = _unsquish_command_name(k)
57
76
    else:
58
77
        k_unsquished = k
59
 
    if not plugin_cmds.has_key(k_unsquished):
 
78
    if k_unsquished not in plugin_cmds:
60
79
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
80
        ## trace.mutter('registered plugin command %s', k_unsquished)
62
81
        if decorate and k_unsquished in builtin_command_names():
63
82
            return _builtin_commands()[k_unsquished]
64
83
    elif decorate:
66
85
        plugin_cmds[k_unsquished] = cmd
67
86
        return result
68
87
    else:
69
 
        log_error('Two plugins defined the same command: %r' % k)
70
 
        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__])
71
90
 
72
91
 
73
92
def _squish_command_name(cmd):
85
104
    builtins = bzrlib.builtins.__dict__
86
105
    for name in builtins:
87
106
        if name.startswith("cmd_"):
88
 
            real_name = _unsquish_command_name(name)        
 
107
            real_name = _unsquish_command_name(name)
89
108
            r[real_name] = builtins[name]
90
109
    return r
91
 
 
92
110
            
93
111
 
94
112
def builtin_command_names():
120
138
    plugins_override
121
139
        If true, plugin commands can override builtins.
122
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."""
123
149
    from bzrlib.externalcommand import ExternalCommand
124
150
 
125
 
    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.
126
155
 
127
156
    # first look up this command under the specified name
128
157
    cmds = _get_cmd_dict(plugins_override=plugins_override)
139
168
    cmd_obj = ExternalCommand.find_command(cmd_name)
140
169
    if cmd_obj:
141
170
        return cmd_obj
142
 
 
143
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
171
    raise KeyError
144
172
 
145
173
 
146
174
class Command(object):
168
196
        List of argument forms, marked with whether they are optional,
169
197
        repeated, etc.
170
198
 
171
 
                Examples:
172
 
 
173
 
                ['to_location', 'from_branch?', 'file*']
174
 
 
175
 
                'to_location' is required
176
 
                'from_branch' is optional
177
 
                'file' can be specified 0 or more times
 
199
                Examples:
 
200
 
 
201
                ['to_location', 'from_branch?', 'file*']
 
202
 
 
203
                'to_location' is required
 
204
                'from_branch' is optional
 
205
                'file' can be specified 0 or more times
178
206
 
179
207
    takes_options
180
208
        List of options that may be given for this command.  These can
184
212
    hidden
185
213
        If true, this command isn't advertised.  This is typically
186
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
 
187
231
    """
188
232
    aliases = []
189
233
    takes_args = []
190
234
    takes_options = []
 
235
    encoding_type = 'strict'
191
236
 
192
237
    hidden = False
193
238
    
196
241
        if self.__doc__ == Command.__doc__:
197
242
            warn("No help message set for %r" % self)
198
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
 
199
330
    def options(self):
200
331
        """Return dict of valid options for this command.
201
332
 
202
333
        Maps from long option name to option object."""
203
334
        r = dict()
204
 
        r['help'] = Option.OPTIONS['help']
 
335
        r['help'] = option._help_option
205
336
        for o in self.takes_options:
206
 
            if not isinstance(o, Option):
207
 
                o = Option.OPTIONS[o]
 
337
            if isinstance(o, basestring):
 
338
                o = option.Option.OPTIONS[o]
208
339
            r[o.name] = o
209
340
        return r
210
341
 
211
 
    def run_argv(self, argv):
212
 
        """Parse command line and run."""
213
 
        args, opts = parse_args(self, 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
 
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)
214
375
        if 'help' in opts:  # e.g. bzr add --help
215
 
            from bzrlib.help import help_on_command
216
 
            help_on_command(self.name())
 
376
            sys.stdout.write(self.get_help_text())
217
377
            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()))
224
378
        # mix arguments and options into one dictionary
225
379
        cmdargs = _match_argform(self.name(), self.takes_args, args)
226
380
        cmdopts = {}
230
384
        all_cmd_args = cmdargs.copy()
231
385
        all_cmd_args.update(cmdopts)
232
386
 
 
387
        self._setup_outf()
 
388
 
233
389
        return self.run(**all_cmd_args)
234
390
    
235
391
    def run(self):
242
398
        shell error code if not.  It's OK for this method to allow
243
399
        an exception to raise up.
244
400
        """
245
 
        raise NotImplementedError()
246
 
 
 
401
        raise NotImplementedError('no implementation of command %r'
 
402
                                  % self.name())
247
403
 
248
404
    def help(self):
249
405
        """Return help message for this class."""
 
406
        from inspect import getdoc
250
407
        if self.__doc__ is Command.__doc__:
251
408
            return None
252
409
        return getdoc(self)
254
411
    def name(self):
255
412
        return _unsquish_command_name(self.__class__.__name__)
256
413
 
257
 
 
 
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)
258
429
def parse_spec(spec):
259
430
    """
260
431
    >>> parse_spec(None)
286
457
        parsed = [spec, None]
287
458
    return parsed
288
459
 
289
 
def parse_args(command, argv):
 
460
def parse_args(command, argv, alias_argv=None):
290
461
    """Parse command line.
291
462
    
292
463
    Arguments and options are parsed at this level before being passed
294
465
    lookup table, something about the available options, what optargs
295
466
    they take, and which commands will accept them.
296
467
    """
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)
 
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])
379
478
    return args, opts
380
479
 
381
480
 
396
495
                argdict[argname + '_list'] = None
397
496
        elif ap[-1] == '+':
398
497
            if not args:
399
 
                raise BzrCommandError("command %r needs one or more %s"
400
 
                        % (cmd, argname.upper()))
 
498
                raise errors.BzrCommandError("command %r needs one or more %s"
 
499
                                             % (cmd, argname.upper()))
401
500
            else:
402
501
                argdict[argname + '_list'] = args[:]
403
502
                args = []
404
503
        elif ap[-1] == '$': # all but one
405
504
            if len(args) < 2:
406
 
                raise BzrCommandError("command %r needs one or more %s"
407
 
                        % (cmd, argname.upper()))
 
505
                raise errors.BzrCommandError("command %r needs one or more %s"
 
506
                                             % (cmd, argname.upper()))
408
507
            argdict[argname + '_list'] = args[:-1]
409
 
            args[:-1] = []                
 
508
            args[:-1] = []
410
509
        else:
411
510
            # just a plain arg
412
511
            argname = ap
413
512
            if not args:
414
 
                raise BzrCommandError("command %r requires argument %s"
415
 
                        % (cmd, argname.upper()))
 
513
                raise errors.BzrCommandError("command %r requires argument %s"
 
514
                               % (cmd, argname.upper()))
416
515
            else:
417
516
                argdict[argname] = args.pop(0)
418
517
            
419
518
    if args:
420
 
        raise BzrCommandError("extra argument to command %s: %s"
421
 
                              % (cmd, args[0]))
 
519
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
520
                                     % (cmd, args[0]))
422
521
 
423
522
    return argdict
424
523
 
447
546
        os.remove(pfname)
448
547
 
449
548
 
450
 
def apply_lsprofiled(the_callable, *args, **kwargs):
 
549
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
451
550
    from bzrlib.lsprof import profile
452
 
    ret,stats = profile(the_callable,*args,**kwargs)
 
551
    ret, stats = profile(the_callable, *args, **kwargs)
453
552
    stats.sort()
454
 
    stats.pprint()
 
553
    if filename is None:
 
554
        stats.pprint()
 
555
    else:
 
556
        stats.save(filename)
 
557
        trace.note('Profile data written to "%s".', filename)
455
558
    return ret
456
559
 
 
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
 
457
581
def run_bzr(argv):
458
582
    """Execute a command.
459
583
 
462
586
    
463
587
    argv
464
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).
465
591
    
466
592
    Returns a command status or raises an exception.
467
593
 
471
597
    --no-plugins
472
598
        Do not load plugin modules at all
473
599
 
 
600
    --no-aliases
 
601
        Do not allow aliases
 
602
 
474
603
    --builtin
475
604
        Only use builtin commands.  (Plugins are still allowed to change
476
605
        other behaviour.)
481
610
    --lsprof
482
611
        Run under the Python lsprof profiler.
483
612
    """
484
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
613
    argv = list(argv)
 
614
    trace.mutter("bzr arguments: %r", argv)
485
615
 
486
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = False
 
616
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
617
                opt_no_aliases = False
 
618
    opt_lsprof_file = None
487
619
 
488
620
    # --no-plugins is handled specially at a very early stage. We need
489
621
    # to load plugins before doing other command parsing so that they
490
622
    # can override commands, but this needs to happen first.
491
623
 
492
 
    for a in argv:
 
624
    argv_copy = []
 
625
    i = 0
 
626
    while i < len(argv):
 
627
        a = argv[i]
493
628
        if a == '--profile':
494
629
            opt_profile = True
495
630
        elif a == '--lsprof':
496
631
            opt_lsprof = True
 
632
        elif a == '--lsprof-file':
 
633
            opt_lsprof = True
 
634
            opt_lsprof_file = argv[i + 1]
 
635
            i += 1
497
636
        elif a == '--no-plugins':
498
637
            opt_no_plugins = True
 
638
        elif a == '--no-aliases':
 
639
            opt_no_aliases = True
499
640
        elif a == '--builtin':
500
641
            opt_builtin = True
501
642
        elif a in ('--quiet', '-q'):
502
 
            be_quiet()
 
643
            trace.be_quiet()
 
644
        elif a.startswith('-D'):
 
645
            debug.debug_flags.add(a[2:])
503
646
        else:
504
 
            continue
505
 
        argv.remove(a)
 
647
            argv_copy.append(a)
 
648
        i += 1
506
649
 
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()
 
650
    argv = argv_copy
 
651
    if (not argv):
 
652
        from bzrlib.builtins import cmd_help
 
653
        cmd_help().run_argv_aliases([])
513
654
        return 0
514
655
 
515
656
    if argv[0] == '--version':
516
 
        from bzrlib.builtins import show_version
 
657
        from bzrlib.version import show_version
517
658
        show_version()
518
659
        return 0
519
660
        
520
661
    if not opt_no_plugins:
521
662
        from bzrlib.plugin import load_plugins
522
663
        load_plugins()
523
 
 
524
 
    cmd = str(argv.pop(0))
 
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.
525
680
 
526
681
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
682
    run = cmd_obj.run_argv_aliases
 
683
    run_argv = [argv, alias_argv]
527
684
 
528
685
    try:
529
686
        if opt_lsprof:
530
 
            ret = apply_lsprofiled(cmd_obj.run_argv, argv)
 
687
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
531
688
        elif opt_profile:
532
 
            ret = apply_profiled(cmd_obj.run_argv, argv)
 
689
            ret = apply_profiled(run, *run_argv)
533
690
        else:
534
 
            ret = cmd_obj.run_argv(argv)
 
691
            ret = run(*run_argv)
535
692
        return ret or 0
536
693
    finally:
537
694
        # reset, in case we may do other commands later within the same process
538
 
        be_quiet(False)
 
695
        trace.be_quiet(False)
539
696
 
540
697
def display_command(func):
541
698
    """Decorator that suppresses pipe/interrupt errors."""
545
702
            sys.stdout.flush()
546
703
            return result
547
704
        except IOError, e:
548
 
            if not hasattr(e, 'errno'):
 
705
            if getattr(e, 'errno', None) is None:
549
706
                raise
550
707
            if e.errno != errno.EPIPE:
551
 
                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
552
711
            pass
553
712
        except KeyboardInterrupt:
554
713
            pass
558
717
def main(argv):
559
718
    import bzrlib.ui
560
719
    from bzrlib.ui.text import TextUIFactory
561
 
    ## bzrlib.trace.enable_default_logging()
562
 
    bzrlib.trace.log_startup(argv)
563
720
    bzrlib.ui.ui_factory = TextUIFactory()
564
 
    ret = run_bzr_catch_errors(argv[1:])
565
 
    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)
566
724
    return ret
567
725
 
568
726
 
569
727
def run_bzr_catch_errors(argv):
570
728
    try:
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:
 
729
        return run_bzr(argv)
 
730
    except (KeyboardInterrupt, Exception), e:
577
731
        # used to handle AssertionError and KeyboardInterrupt
578
732
        # specially here, but hopefully they're handled ok by the logger now
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
 
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 []
585
760
        else:
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
 
761
            return [cmd]
 
762
 
592
763
 
593
764
if __name__ == '__main__':
594
765
    sys.exit(main(sys.argv))