~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Pool
  • Date: 2006-05-23 10:57:02 UTC
  • mfrom: (1725 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1726.
  • Revision ID: mbp@sourcefrog.net-20060523105702-e5de4664cfdb4e8d
[merge] bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 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
 
 
23
 
# TODO: Define arguments by objects, rather than just using names.
24
 
# Those objects can specify the expected type of the argument, which
25
 
# would help with validation and shell completion.
26
 
 
27
 
 
28
 
# TODO: Help messages for options.
29
 
 
30
 
# TODO: Define arguments by objects, rather than just using names.
31
 
# Those objects can specify the expected type of the argument, which
32
 
# would help with validation and shell completion.
33
 
 
34
 
 
 
21
# TODO: Define arguments by objects, rather than just using names.
 
22
# 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.
 
27
 
 
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
 
29
# the profile output behind so it can be interactively examined?
35
30
 
36
31
import sys
37
32
import os
38
33
from warnings import warn
39
 
from inspect import getdoc
 
34
import errno
40
35
 
41
36
import bzrlib
 
37
from bzrlib.errors import (BzrError,
 
38
                           BzrCheckError,
 
39
                           BzrCommandError,
 
40
                           BzrOptionError,
 
41
                           NotBranchError)
 
42
from bzrlib.option import Option
 
43
from bzrlib.revisionspec import RevisionSpec
 
44
from bzrlib.symbol_versioning import *
42
45
import bzrlib.trace
43
 
from bzrlib.trace import mutter, note, log_error, warning
44
 
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
45
 
from bzrlib.branch import find_branch
46
 
from bzrlib import BZRDIR
 
46
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
47
47
 
48
48
plugin_cmds = {}
49
49
 
50
50
 
51
 
def register_command(cmd):
52
 
    "Utility function to help register a command"
 
51
def register_command(cmd, decorate=False):
 
52
    """Utility function to help register a command
 
53
 
 
54
    :param cmd: Command subclass to register
 
55
    :param decorate: If true, allow overriding an existing command
 
56
        of the same name; the old command is returned by this function.
 
57
        Otherwise it is an error to try to override an existing command.
 
58
    """
53
59
    global plugin_cmds
54
60
    k = cmd.__name__
55
61
    if k.startswith("cmd_"):
58
64
        k_unsquished = k
59
65
    if not plugin_cmds.has_key(k_unsquished):
60
66
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
67
        mutter('registered plugin command %s', k_unsquished)
 
68
        if decorate and k_unsquished in builtin_command_names():
 
69
            return _builtin_commands()[k_unsquished]
 
70
    elif decorate:
 
71
        result = plugin_cmds[k_unsquished]
 
72
        plugin_cmds[k_unsquished] = cmd
 
73
        return result
62
74
    else:
63
75
        log_error('Two plugins defined the same command: %r' % k)
64
76
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
73
85
    return cmd[4:].replace('_','-')
74
86
 
75
87
 
76
 
def _parse_revision_str(revstr):
77
 
    """This handles a revision string -> revno.
78
 
 
79
 
    This always returns a list.  The list will have one element for 
80
 
 
81
 
    It supports integers directly, but everything else it
82
 
    defers for passing to Branch.get_revision_info()
83
 
 
84
 
    >>> _parse_revision_str('234')
85
 
    [234]
86
 
    >>> _parse_revision_str('234..567')
87
 
    [234, 567]
88
 
    >>> _parse_revision_str('..')
89
 
    [None, None]
90
 
    >>> _parse_revision_str('..234')
91
 
    [None, 234]
92
 
    >>> _parse_revision_str('234..')
93
 
    [234, None]
94
 
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
95
 
    [234, 456, 789]
96
 
    >>> _parse_revision_str('234....789') # Error?
97
 
    [234, None, 789]
98
 
    >>> _parse_revision_str('revid:test@other.com-234234')
99
 
    ['revid:test@other.com-234234']
100
 
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
101
 
    ['revid:test@other.com-234234', 'revid:test@other.com-234235']
102
 
    >>> _parse_revision_str('revid:test@other.com-234234..23')
103
 
    ['revid:test@other.com-234234', 23]
104
 
    >>> _parse_revision_str('date:2005-04-12')
105
 
    ['date:2005-04-12']
106
 
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
107
 
    ['date:2005-04-12 12:24:33']
108
 
    >>> _parse_revision_str('date:2005-04-12T12:24:33')
109
 
    ['date:2005-04-12T12:24:33']
110
 
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
111
 
    ['date:2005-04-12,12:24:33']
112
 
    >>> _parse_revision_str('-5..23')
113
 
    [-5, 23]
114
 
    >>> _parse_revision_str('-5')
115
 
    [-5]
116
 
    >>> _parse_revision_str('123a')
117
 
    ['123a']
118
 
    >>> _parse_revision_str('abc')
119
 
    ['abc']
120
 
    """
121
 
    import re
122
 
    old_format_re = re.compile('\d*:\d*')
123
 
    m = old_format_re.match(revstr)
124
 
    if m:
125
 
        warning('Colon separator for revision numbers is deprecated.'
126
 
                ' Use .. instead')
127
 
        revs = []
128
 
        for rev in revstr.split(':'):
129
 
            if rev:
130
 
                revs.append(int(rev))
131
 
            else:
132
 
                revs.append(None)
133
 
        return revs
134
 
    revs = []
135
 
    for x in revstr.split('..'):
136
 
        if not x:
137
 
            revs.append(None)
138
 
        else:
139
 
            try:
140
 
                revs.append(int(x))
141
 
            except ValueError:
142
 
                revs.append(x)
143
 
    return revs
144
 
 
145
 
 
146
 
def get_merge_type(typestring):
147
 
    """Attempt to find the merge class/factory associated with a string."""
148
 
    from merge import merge_types
149
 
    try:
150
 
        return merge_types[typestring][0]
151
 
    except KeyError:
152
 
        templ = '%s%%7s: %%s' % (' '*12)
153
 
        lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
154
 
        type_list = '\n'.join(lines)
155
 
        msg = "No known merge type %s. Supported types are:\n%s" %\
156
 
            (typestring, type_list)
157
 
        raise BzrCommandError(msg)
158
 
 
159
 
 
160
88
def _builtin_commands():
161
89
    import bzrlib.builtins
162
90
    r = {}
163
91
    builtins = bzrlib.builtins.__dict__
164
92
    for name in builtins:
165
93
        if name.startswith("cmd_"):
166
 
            real_name = _unsquish_command_name(name)        
 
94
            real_name = _unsquish_command_name(name)
167
95
            r[real_name] = builtins[name]
168
96
    return r
169
 
 
170
97
            
171
98
 
172
99
def builtin_command_names():
246
173
        List of argument forms, marked with whether they are optional,
247
174
        repeated, etc.
248
175
 
 
176
                Examples:
 
177
 
 
178
                ['to_location', 'from_branch?', 'file*']
 
179
 
 
180
                'to_location' is required
 
181
                'from_branch' is optional
 
182
                'file' can be specified 0 or more times
 
183
 
249
184
    takes_options
250
 
        List of options that may be given for this command.
 
185
        List of options that may be given for this command.  These can
 
186
        be either strings, referring to globally-defined options,
 
187
        or option objects.  Retrieve through options().
251
188
 
252
189
    hidden
253
190
        If true, this command isn't advertised.  This is typically
254
191
        for commands intended for expert users.
255
192
    """
256
193
    aliases = []
257
 
    
258
194
    takes_args = []
259
195
    takes_options = []
260
196
 
265
201
        if self.__doc__ == Command.__doc__:
266
202
            warn("No help message set for %r" % self)
267
203
 
268
 
 
 
204
    def options(self):
 
205
        """Return dict of valid options for this command.
 
206
 
 
207
        Maps from long option name to option object."""
 
208
        r = dict()
 
209
        r['help'] = Option.OPTIONS['help']
 
210
        for o in self.takes_options:
 
211
            if not isinstance(o, Option):
 
212
                o = Option.OPTIONS[o]
 
213
            r[o.name] = o
 
214
        return r
 
215
 
 
216
    @deprecated_method(zero_eight)
269
217
    def run_argv(self, argv):
270
 
        """Parse command line and run."""
271
 
        args, opts = parse_args(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)
272
223
 
 
224
    def run_argv_aliases(self, argv, alias_argv=None):
 
225
        """Parse the command line and run with extra aliases in alias_argv."""
 
226
        args, opts = parse_args(self, argv, alias_argv)
273
227
        if 'help' in opts:  # e.g. bzr add --help
274
228
            from bzrlib.help import help_on_command
275
229
            help_on_command(self.name())
276
230
            return 0
277
 
 
278
 
        # check options are reasonable
279
 
        allowed = self.takes_options
 
231
        # XXX: This should be handled by the parser
 
232
        allowed_names = self.options().keys()
280
233
        for oname in opts:
281
 
            if oname not in allowed:
282
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
283
 
                                      % (oname, self.name()))
284
 
 
 
234
            if oname not in allowed_names:
 
235
                raise BzrCommandError("option '--%s' is not allowed for"
 
236
                                      " command %r" % (oname, self.name()))
285
237
        # mix arguments and options into one dictionary
286
238
        cmdargs = _match_argform(self.name(), self.takes_args, args)
287
239
        cmdopts = {}
292
244
        all_cmd_args.update(cmdopts)
293
245
 
294
246
        return self.run(**all_cmd_args)
295
 
 
296
247
    
297
248
    def run(self):
298
249
        """Actually run the command.
304
255
        shell error code if not.  It's OK for this method to allow
305
256
        an exception to raise up.
306
257
        """
307
 
        raise NotImplementedError()
308
 
 
 
258
        raise NotImplementedError('no implementation of command %r' 
 
259
                                  % self.name())
309
260
 
310
261
    def help(self):
311
262
        """Return help message for this class."""
 
263
        from inspect import getdoc
312
264
        if self.__doc__ is Command.__doc__:
313
265
            return None
314
266
        return getdoc(self)
348
300
        parsed = [spec, None]
349
301
    return parsed
350
302
 
351
 
 
352
 
# list of all available options; the rhs can be either None for an
353
 
# option that takes no argument, or a constructor function that checks
354
 
# the type.
355
 
OPTIONS = {
356
 
    'all':                    None,
357
 
    'diff-options':           str,
358
 
    'help':                   None,
359
 
    'file':                   unicode,
360
 
    'force':                  None,
361
 
    'format':                 unicode,
362
 
    'forward':                None,
363
 
    'message':                unicode,
364
 
    'no-recurse':             None,
365
 
    'profile':                None,
366
 
    'revision':               _parse_revision_str,
367
 
    'short':                  None,
368
 
    'show-ids':               None,
369
 
    'timezone':               str,
370
 
    'verbose':                None,
371
 
    'version':                None,
372
 
    'email':                  None,
373
 
    'unchanged':              None,
374
 
    'update':                 None,
375
 
    'long':                   None,
376
 
    'root':                   str,
377
 
    'no-backup':              None,
378
 
    'merge-type':             get_merge_type,
379
 
    'pattern':                str,
380
 
    }
381
 
 
382
 
SHORT_OPTIONS = {
383
 
    'F':                      'file', 
384
 
    'h':                      'help',
385
 
    'm':                      'message',
386
 
    'r':                      'revision',
387
 
    'v':                      'verbose',
388
 
    'l':                      'long',
389
 
}
390
 
 
391
 
 
392
 
def parse_args(argv):
 
303
def parse_args(command, argv, alias_argv=None):
393
304
    """Parse command line.
394
305
    
395
306
    Arguments and options are parsed at this level before being passed
396
307
    down to specific command handlers.  This routine knows, from a
397
308
    lookup table, something about the available options, what optargs
398
309
    they take, and which commands will accept them.
399
 
 
400
 
    >>> parse_args('--help'.split())
401
 
    ([], {'help': True})
402
 
    >>> parse_args('help -- --invalidcmd'.split())
403
 
    (['help', '--invalidcmd'], {})
404
 
    >>> parse_args('--version'.split())
405
 
    ([], {'version': True})
406
 
    >>> parse_args('status --all'.split())
407
 
    (['status'], {'all': True})
408
 
    >>> parse_args('commit --message=biter'.split())
409
 
    (['commit'], {'message': u'biter'})
410
 
    >>> parse_args('log -r 500'.split())
411
 
    (['log'], {'revision': [500]})
412
 
    >>> parse_args('log -r500..600'.split())
413
 
    (['log'], {'revision': [500, 600]})
414
 
    >>> parse_args('log -vr500..600'.split())
415
 
    (['log'], {'verbose': True, 'revision': [500, 600]})
416
 
    >>> parse_args('log -rv500..600'.split()) #the r takes an argument
417
 
    (['log'], {'revision': ['v500', 600]})
418
310
    """
 
311
    # TODO: chop up this beast; make it a method of the Command
419
312
    args = []
420
313
    opts = {}
 
314
    alias_opts = {}
421
315
 
 
316
    cmd_options = command.options()
422
317
    argsover = False
423
 
    while argv:
424
 
        a = argv.pop(0)
425
 
        if not argsover and a[0] == '-':
426
 
            # option names must not be unicode
427
 
            a = str(a)
428
 
            optarg = None
429
 
            if a[1] == '-':
430
 
                if a == '--':
431
 
                    # We've received a standalone -- No more flags
432
 
                    argsover = True
433
 
                    continue
434
 
                mutter("  got option %r" % a)
435
 
                if '=' in a:
436
 
                    optname, optarg = a[2:].split('=', 1)
437
 
                else:
438
 
                    optname = a[2:]
439
 
                if optname not in OPTIONS:
440
 
                    raise BzrError('unknown long option %r' % a)
441
 
            else:
442
 
                shortopt = a[1:]
443
 
                if shortopt in SHORT_OPTIONS:
444
 
                    # Multi-character options must have a space to delimit
445
 
                    # their value
446
 
                    optname = SHORT_OPTIONS[shortopt]
447
 
                else:
448
 
                    # Single character short options, can be chained,
449
 
                    # and have their value appended to their name
450
 
                    shortopt = a[1:2]
451
 
                    if shortopt not in SHORT_OPTIONS:
452
 
                        # We didn't find the multi-character name, and we
453
 
                        # didn't find the single char name
454
 
                        raise BzrError('unknown short option %r' % a)
455
 
                    optname = SHORT_OPTIONS[shortopt]
 
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
456
359
 
457
 
                    if a[2:]:
458
 
                        # There are extra things on this option
459
 
                        # see if it is the value, or if it is another
460
 
                        # short option
461
 
                        optargfn = OPTIONS[optname]
462
 
                        if optargfn is None:
463
 
                            # This option does not take an argument, so the
464
 
                            # next entry is another short option, pack it back
465
 
                            # into the list
466
 
                            argv.insert(0, '-' + a[2:])
 
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)
467
399
                        else:
468
 
                            # This option takes an argument, so pack it
469
 
                            # into the array
470
 
                            optarg = a[2:]
471
 
            
472
 
            if optname in opts:
473
 
                # XXX: Do we ever want to support this, e.g. for -r?
474
 
                raise BzrError('repeated option %r' % a)
475
 
                
476
 
            optargfn = OPTIONS[optname]
477
 
            if optargfn:
478
 
                if optarg == None:
479
 
                    if not argv:
480
 
                        raise BzrError('option %r needs an argument' % a)
481
 
                    else:
482
 
                        optarg = argv.pop(0)
483
 
                opts[optname] = optargfn(optarg)
 
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
484
410
            else:
485
 
                if optarg != None:
486
 
                    raise BzrError('option %r takes no argument' % optname)
487
 
                opts[optname] = True
488
 
        else:
489
 
            args.append(a)
490
 
 
 
411
                args.append(a)
 
412
        proc_aliasarg = False # Done with alias argv
491
413
    return args, opts
492
414
 
493
415
 
494
 
 
495
 
 
496
416
def _match_argform(cmd, takes_args, args):
497
417
    argdict = {}
498
418
 
541
461
def apply_profiled(the_callable, *args, **kwargs):
542
462
    import hotshot
543
463
    import tempfile
 
464
    import hotshot.stats
544
465
    pffileno, pfname = tempfile.mkstemp()
545
466
    try:
546
467
        prof = hotshot.Profile(pfname)
548
469
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
549
470
        finally:
550
471
            prof.close()
551
 
 
552
 
        import hotshot.stats
553
472
        stats = hotshot.stats.load(pfname)
554
 
        #stats.strip_dirs()
555
 
        stats.sort_stats('time')
 
473
        stats.strip_dirs()
 
474
        stats.sort_stats('cum')   # 'time'
556
475
        ## XXX: Might like to write to stderr or the trace file instead but
557
476
        ## print_stats seems hardcoded to stdout
558
477
        stats.print_stats(20)
559
 
 
560
478
        return ret
561
479
    finally:
562
480
        os.close(pffileno)
563
481
        os.remove(pfname)
564
482
 
565
483
 
 
484
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
485
    from bzrlib.lsprof import profile
 
486
    import cPickle
 
487
    ret, stats = profile(the_callable, *args, **kwargs)
 
488
    stats.sort()
 
489
    if filename is None:
 
490
        stats.pprint()
 
491
    else:
 
492
        stats.freeze()
 
493
        cPickle.dump(stats, open(filename, 'w'), 2)
 
494
        print 'Profile data written to %r.' % filename
 
495
    return ret
 
496
 
 
497
 
 
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)
 
502
    if (alias):
 
503
        return alias.split(' ')
 
504
    return None
 
505
 
 
506
 
566
507
def run_bzr(argv):
567
508
    """Execute a command.
568
509
 
580
521
    --no-plugins
581
522
        Do not load plugin modules at all
582
523
 
 
524
    --no-aliases
 
525
        Do not allow aliases
 
526
 
583
527
    --builtin
584
528
        Only use builtin commands.  (Plugins are still allowed to change
585
529
        other behaviour.)
586
530
 
587
531
    --profile
588
 
        Run under the Python profiler.
 
532
        Run under the Python hotshot profiler.
 
533
 
 
534
    --lsprof
 
535
        Run under the Python lsprof profiler.
589
536
    """
590
 
    # Load all of the transport methods
591
 
    import bzrlib.transport.local, bzrlib.transport.http
592
 
    
593
537
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
594
538
 
595
 
    opt_profile = opt_no_plugins = opt_builtin = False
 
539
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
540
                opt_no_aliases = False
 
541
    opt_lsprof_file = None
596
542
 
597
543
    # --no-plugins is handled specially at a very early stage. We need
598
544
    # to load plugins before doing other command parsing so that they
599
545
    # can override commands, but this needs to happen first.
600
546
 
601
 
    for a in argv:
 
547
    argv_copy = []
 
548
    i = 0
 
549
    while i < len(argv):
 
550
        a = argv[i]
602
551
        if a == '--profile':
603
552
            opt_profile = True
 
553
        elif a == '--lsprof':
 
554
            opt_lsprof = True
 
555
        elif a == '--lsprof-file':
 
556
            opt_lsprof_file = argv[i + 1]
 
557
            i += 1
604
558
        elif a == '--no-plugins':
605
559
            opt_no_plugins = True
 
560
        elif a == '--no-aliases':
 
561
            opt_no_aliases = True
606
562
        elif a == '--builtin':
607
563
            opt_builtin = True
 
564
        elif a in ('--quiet', '-q'):
 
565
            be_quiet()
608
566
        else:
609
 
            break
610
 
        argv.remove(a)
 
567
            argv_copy.append(a)
 
568
        i += 1
611
569
 
612
 
    if (not argv) or (argv[0] == '--help'):
613
 
        from bzrlib.help import help
614
 
        if len(argv) > 1:
615
 
            help(argv[1])
616
 
        else:
617
 
            help()
 
570
    argv = argv_copy
 
571
    if (not argv):
 
572
        from bzrlib.builtins import cmd_help
 
573
        cmd_help().run_argv_aliases([])
618
574
        return 0
619
575
 
620
576
    if argv[0] == '--version':
625
581
    if not opt_no_plugins:
626
582
        from bzrlib.plugin import load_plugins
627
583
        load_plugins()
 
584
    else:
 
585
        from bzrlib.plugin import disable_plugins
 
586
        disable_plugins()
 
587
 
 
588
    alias_argv = None
 
589
 
 
590
    if not opt_no_aliases:
 
591
        alias_argv = get_alias(argv[0])
 
592
        if alias_argv:
 
593
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
594
            argv[0] = alias_argv.pop(0)
628
595
 
629
596
    cmd = str(argv.pop(0))
630
597
 
631
598
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
632
 
 
633
 
    if opt_profile:
634
 
        ret = apply_profiled(cmd_obj.run_argv, argv)
 
599
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
600
        run = cmd_obj.run_argv
 
601
        run_argv = [argv]
635
602
    else:
636
 
        ret = cmd_obj.run_argv(argv)
637
 
    return ret or 0
 
603
        run = cmd_obj.run_argv_aliases
 
604
        run_argv = [argv, alias_argv]
 
605
 
 
606
    try:
 
607
        if opt_lsprof:
 
608
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
609
        elif opt_profile:
 
610
            ret = apply_profiled(run, *run_argv)
 
611
        else:
 
612
            ret = run(*run_argv)
 
613
        return ret or 0
 
614
    finally:
 
615
        # reset, in case we may do other commands later within the same process
 
616
        be_quiet(False)
 
617
 
 
618
def display_command(func):
 
619
    """Decorator that suppresses pipe/interrupt errors."""
 
620
    def ignore_pipe(*args, **kwargs):
 
621
        try:
 
622
            result = func(*args, **kwargs)
 
623
            sys.stdout.flush()
 
624
            return result
 
625
        except IOError, e:
 
626
            if not hasattr(e, 'errno'):
 
627
                raise
 
628
            if e.errno != errno.EPIPE:
 
629
                raise
 
630
            pass
 
631
        except KeyboardInterrupt:
 
632
            pass
 
633
    return ignore_pipe
638
634
 
639
635
 
640
636
def main(argv):
641
637
    import bzrlib.ui
 
638
    from bzrlib.ui.text import TextUIFactory
 
639
    ## bzrlib.trace.enable_default_logging()
642
640
    bzrlib.trace.log_startup(argv)
643
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
644
 
 
 
641
    bzrlib.ui.ui_factory = TextUIFactory()
 
642
    ret = run_bzr_catch_errors(argv[1:])
 
643
    mutter("return code %d", ret)
 
644
    return ret
 
645
 
 
646
 
 
647
def run_bzr_catch_errors(argv):
645
648
    try:
646
649
        try:
647
 
            try:
648
 
                return run_bzr(argv[1:])
649
 
            finally:
650
 
                # do this here inside the exception wrappers to catch EPIPE
651
 
                sys.stdout.flush()
652
 
        #wrap common errors as CommandErrors.
653
 
        except (NotBranchError,), e:
654
 
            raise BzrCommandError(str(e))
655
 
    except BzrCommandError, e:
656
 
        # command line syntax error, etc
657
 
        log_error(str(e))
658
 
        return 1
659
 
    except BzrError, e:
660
 
        bzrlib.trace.log_exception()
661
 
        return 1
662
 
    except AssertionError, e:
663
 
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
664
 
        return 3
665
 
    except KeyboardInterrupt, e:
666
 
        bzrlib.trace.note('interrupted')
667
 
        return 2
 
650
            return run_bzr(argv)
 
651
        finally:
 
652
            # do this here inside the exception wrappers to catch EPIPE
 
653
            sys.stdout.flush()
668
654
    except Exception, e:
 
655
        # used to handle AssertionError and KeyboardInterrupt
 
656
        # specially here, but hopefully they're handled ok by the logger now
669
657
        import errno
670
658
        if (isinstance(e, IOError) 
671
659
            and hasattr(e, 'errno')
672
660
            and e.errno == errno.EPIPE):
673
661
            bzrlib.trace.note('broken pipe')
674
 
            return 2
 
662
            return 3
675
663
        else:
676
664
            bzrlib.trace.log_exception()
677
 
            return 2
 
665
            if os.environ.get('BZR_PDB'):
 
666
                print '**** entering debugger'
 
667
                import pdb
 
668
                pdb.post_mortem(sys.exc_traceback)
 
669
            return 3
678
670
 
679
671
if __name__ == '__main__':
680
672
    sys.exit(main(sys.argv))