~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Robert Collins
  • Date: 2006-05-24 08:14:45 UTC
  • mfrom: (1725.1.1 benchmark)
  • mto: (1725.2.6 commit)
  • mto: This revision was merged to the branch mainline in revision 1729.
  • Revision ID: robertc@robertcollins.net-20060524081445-c046b4406ffc8dfa
(rbc)Merge in benchmark --lsprof-timed lsprofiling feature. (Robert Collins, Martin Pool).

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