← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

Merge from bzr.dev.

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 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
 
 
35
 
 
36
 
import sys
 
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?
 
30
 
 
31
import codecs
 
32
import errno
37
33
import os
38
34
from warnings import warn
39
 
from inspect import getdoc
 
35
import sys
40
36
 
41
37
import bzrlib
 
38
import bzrlib.errors as errors
 
39
from bzrlib.errors import (BzrError,
 
40
                           BzrCommandError,
 
41
                           BzrCheckError,
 
42
                           NotBranchError)
 
43
from bzrlib import option
 
44
from bzrlib.option import Option
 
45
import bzrlib.osutils
 
46
from bzrlib.revisionspec import RevisionSpec
 
47
from bzrlib.symbol_versioning import (deprecated_method, zero_eight)
42
48
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
 
49
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
47
50
 
48
51
plugin_cmds = {}
49
52
 
50
53
 
51
 
def register_command(cmd):
52
 
    "Utility function to help register a command"
 
54
def register_command(cmd, decorate=False):
 
55
    """Utility function to help register a command
 
56
 
 
57
    :param cmd: Command subclass to register
 
58
    :param decorate: If true, allow overriding an existing command
 
59
        of the same name; the old command is returned by this function.
 
60
        Otherwise it is an error to try to override an existing command.
 
61
    """
53
62
    global plugin_cmds
54
63
    k = cmd.__name__
55
64
    if k.startswith("cmd_"):
58
67
        k_unsquished = k
59
68
    if not plugin_cmds.has_key(k_unsquished):
60
69
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
70
        mutter('registered plugin command %s', k_unsquished)
 
71
        if decorate and k_unsquished in builtin_command_names():
 
72
            return _builtin_commands()[k_unsquished]
 
73
    elif decorate:
 
74
        result = plugin_cmds[k_unsquished]
 
75
        plugin_cmds[k_unsquished] = cmd
 
76
        return result
62
77
    else:
63
78
        log_error('Two plugins defined the same command: %r' % k)
64
79
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
73
88
    return cmd[4:].replace('_','-')
74
89
 
75
90
 
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
91
def _builtin_commands():
161
92
    import bzrlib.builtins
162
93
    r = {}
163
94
    builtins = bzrlib.builtins.__dict__
164
95
    for name in builtins:
165
96
        if name.startswith("cmd_"):
166
 
            real_name = _unsquish_command_name(name)        
 
97
            real_name = _unsquish_command_name(name)
167
98
            r[real_name] = builtins[name]
168
99
    return r
169
 
 
170
100
            
171
101
 
172
102
def builtin_command_names():
200
130
    """
201
131
    from bzrlib.externalcommand import ExternalCommand
202
132
 
203
 
    cmd_name = str(cmd_name)            # not unicode
 
133
    # We want only 'ascii' command names, but the user may have typed
 
134
    # in a Unicode name. In that case, they should just get a
 
135
    # 'command not found' error later.
 
136
    # In the future, we may actually support Unicode command names.
204
137
 
205
138
    # first look up this command under the specified name
206
139
    cmds = _get_cmd_dict(plugins_override=plugins_override)
218
151
    if cmd_obj:
219
152
        return cmd_obj
220
153
 
221
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
154
    raise BzrCommandError('unknown command "%s"' % cmd_name)
222
155
 
223
156
 
224
157
class Command(object):
246
179
        List of argument forms, marked with whether they are optional,
247
180
        repeated, etc.
248
181
 
 
182
                Examples:
 
183
 
 
184
                ['to_location', 'from_branch?', 'file*']
 
185
 
 
186
                'to_location' is required
 
187
                'from_branch' is optional
 
188
                'file' can be specified 0 or more times
 
189
 
249
190
    takes_options
250
 
        List of options that may be given for this command.
 
191
        List of options that may be given for this command.  These can
 
192
        be either strings, referring to globally-defined options,
 
193
        or option objects.  Retrieve through options().
251
194
 
252
195
    hidden
253
196
        If true, this command isn't advertised.  This is typically
254
197
        for commands intended for expert users.
 
198
 
 
199
    encoding_type
 
200
        Command objects will get a 'outf' attribute, which has been
 
201
        setup to properly handle encoding of unicode strings.
 
202
        encoding_type determines what will happen when characters cannot
 
203
        be encoded
 
204
            strict - abort if we cannot decode
 
205
            replace - put in a bogus character (typically '?')
 
206
            exact - do not encode sys.stdout
 
207
 
255
208
    """
256
209
    aliases = []
257
 
    
258
210
    takes_args = []
259
211
    takes_options = []
 
212
    encoding_type = 'strict'
260
213
 
261
214
    hidden = False
262
215
    
265
218
        if self.__doc__ == Command.__doc__:
266
219
            warn("No help message set for %r" % self)
267
220
 
268
 
 
 
221
    def options(self):
 
222
        """Return dict of valid options for this command.
 
223
 
 
224
        Maps from long option name to option object."""
 
225
        r = dict()
 
226
        r['help'] = Option.OPTIONS['help']
 
227
        for o in self.takes_options:
 
228
            if isinstance(o, basestring):
 
229
                o = Option.OPTIONS[o]
 
230
            r[o.name] = o
 
231
        return r
 
232
 
 
233
    def _setup_outf(self):
 
234
        """Return a file linked to stdout, which has proper encoding."""
 
235
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
236
 
 
237
        # Originally I was using self.stdout, but that looks
 
238
        # *way* too much like sys.stdout
 
239
        if self.encoding_type == 'exact':
 
240
            self.outf = sys.stdout
 
241
            return
 
242
 
 
243
        output_encoding = bzrlib.osutils.get_terminal_encoding()
 
244
 
 
245
        # use 'replace' so that we don't abort if trying to write out
 
246
        # in e.g. the default C locale.
 
247
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
 
248
        # For whatever reason codecs.getwriter() does not advertise its encoding
 
249
        # it just returns the encoding of the wrapped file, which is completely
 
250
        # bogus. So set the attribute, so we can find the correct encoding later.
 
251
        self.outf.encoding = output_encoding
 
252
 
 
253
    @deprecated_method(zero_eight)
269
254
    def run_argv(self, argv):
270
 
        """Parse command line and run."""
271
 
        args, opts = parse_args(argv)
 
255
        """Parse command line and run.
 
256
        
 
257
        See run_argv_aliases for the 0.8 and beyond api.
 
258
        """
 
259
        return self.run_argv_aliases(argv)
272
260
 
 
261
    def run_argv_aliases(self, argv, alias_argv=None):
 
262
        """Parse the command line and run with extra aliases in alias_argv."""
 
263
        if argv is None:
 
264
            warn("Passing None for [] is deprecated from bzrlib 0.10", 
 
265
                 DeprecationWarning, stacklevel=2)
 
266
            argv = []
 
267
        args, opts = parse_args(self, argv, alias_argv)
273
268
        if 'help' in opts:  # e.g. bzr add --help
274
269
            from bzrlib.help import help_on_command
275
270
            help_on_command(self.name())
276
271
            return 0
277
 
 
278
 
        # check options are reasonable
279
 
        allowed = self.takes_options
280
 
        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
 
 
285
272
        # mix arguments and options into one dictionary
286
273
        cmdargs = _match_argform(self.name(), self.takes_args, args)
287
274
        cmdopts = {}
291
278
        all_cmd_args = cmdargs.copy()
292
279
        all_cmd_args.update(cmdopts)
293
280
 
 
281
        self._setup_outf()
 
282
 
294
283
        return self.run(**all_cmd_args)
295
 
 
296
284
    
297
285
    def run(self):
298
286
        """Actually run the command.
304
292
        shell error code if not.  It's OK for this method to allow
305
293
        an exception to raise up.
306
294
        """
307
 
        raise NotImplementedError()
308
 
 
 
295
        raise NotImplementedError('no implementation of command %r' 
 
296
                                  % self.name())
309
297
 
310
298
    def help(self):
311
299
        """Return help message for this class."""
 
300
        from inspect import getdoc
312
301
        if self.__doc__ is Command.__doc__:
313
302
            return None
314
303
        return getdoc(self)
316
305
    def name(self):
317
306
        return _unsquish_command_name(self.__class__.__name__)
318
307
 
 
308
    def plugin_name(self):
 
309
        """Get the name of the plugin that provides this command.
 
310
 
 
311
        :return: The name of the plugin or None if the command is builtin.
 
312
        """
 
313
        mod_parts = self.__module__.split('.')
 
314
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
315
            return mod_parts[2]
 
316
        else:
 
317
            return None
 
318
 
319
319
 
320
320
def parse_spec(spec):
321
321
    """
348
348
        parsed = [spec, None]
349
349
    return parsed
350
350
 
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):
 
351
def parse_args(command, argv, alias_argv=None):
393
352
    """Parse command line.
394
353
    
395
354
    Arguments and options are parsed at this level before being passed
396
355
    down to specific command handlers.  This routine knows, from a
397
356
    lookup table, something about the available options, what optargs
398
357
    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
358
    """
419
 
    args = []
420
 
    opts = {}
421
 
 
422
 
    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]
456
 
 
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:])
467
 
                        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)
484
 
            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
 
 
 
359
    # TODO: make it a method of the Command?
 
360
    parser = option.get_optparser(command.options())
 
361
    if alias_argv is not None:
 
362
        args = alias_argv + argv
 
363
    else:
 
364
        args = argv
 
365
 
 
366
    options, args = parser.parse_args(args)
 
367
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if 
 
368
                 v is not option.OptionParser.DEFAULT_VALUE])
491
369
    return args, opts
492
370
 
493
371
 
494
 
 
495
 
 
496
372
def _match_argform(cmd, takes_args, args):
497
373
    argdict = {}
498
374
 
520
396
                raise BzrCommandError("command %r needs one or more %s"
521
397
                        % (cmd, argname.upper()))
522
398
            argdict[argname + '_list'] = args[:-1]
523
 
            args[:-1] = []                
 
399
            args[:-1] = []
524
400
        else:
525
401
            # just a plain arg
526
402
            argname = ap
541
417
def apply_profiled(the_callable, *args, **kwargs):
542
418
    import hotshot
543
419
    import tempfile
 
420
    import hotshot.stats
544
421
    pffileno, pfname = tempfile.mkstemp()
545
422
    try:
546
423
        prof = hotshot.Profile(pfname)
548
425
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
549
426
        finally:
550
427
            prof.close()
551
 
 
552
 
        import hotshot.stats
553
428
        stats = hotshot.stats.load(pfname)
554
 
        #stats.strip_dirs()
555
 
        stats.sort_stats('time')
 
429
        stats.strip_dirs()
 
430
        stats.sort_stats('cum')   # 'time'
556
431
        ## XXX: Might like to write to stderr or the trace file instead but
557
432
        ## print_stats seems hardcoded to stdout
558
433
        stats.print_stats(20)
559
 
 
560
434
        return ret
561
435
    finally:
562
436
        os.close(pffileno)
563
437
        os.remove(pfname)
564
438
 
565
439
 
 
440
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
441
    from bzrlib.lsprof import profile
 
442
    import cPickle
 
443
    ret, stats = profile(the_callable, *args, **kwargs)
 
444
    stats.sort()
 
445
    if filename is None:
 
446
        stats.pprint()
 
447
    else:
 
448
        stats.freeze()
 
449
        cPickle.dump(stats, open(filename, 'w'), 2)
 
450
        print 'Profile data written to %r.' % filename
 
451
    return ret
 
452
 
 
453
 
 
454
def get_alias(cmd):
 
455
    """Return an expanded alias, or None if no alias exists"""
 
456
    import bzrlib.config
 
457
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
458
    if (alias):
 
459
        return alias.split(' ')
 
460
    return None
 
461
 
 
462
 
566
463
def run_bzr(argv):
567
464
    """Execute a command.
568
465
 
571
468
    
572
469
    argv
573
470
       The command-line arguments, without the program name from argv[0]
 
471
       These should already be decoded. All library/test code calling
 
472
       run_bzr should be passing valid strings (don't need decoding).
574
473
    
575
474
    Returns a command status or raises an exception.
576
475
 
580
479
    --no-plugins
581
480
        Do not load plugin modules at all
582
481
 
 
482
    --no-aliases
 
483
        Do not allow aliases
 
484
 
583
485
    --builtin
584
486
        Only use builtin commands.  (Plugins are still allowed to change
585
487
        other behaviour.)
586
488
 
587
489
    --profile
588
 
        Run under the Python profiler.
 
490
        Run under the Python hotshot profiler.
 
491
 
 
492
    --lsprof
 
493
        Run under the Python lsprof profiler.
589
494
    """
590
 
    # Load all of the transport methods
591
 
    import bzrlib.transport.local, bzrlib.transport.http
592
 
    
593
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
495
    argv = list(argv)
594
496
 
595
 
    opt_profile = opt_no_plugins = opt_builtin = False
 
497
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
498
                opt_no_aliases = False
 
499
    opt_lsprof_file = None
596
500
 
597
501
    # --no-plugins is handled specially at a very early stage. We need
598
502
    # to load plugins before doing other command parsing so that they
599
503
    # can override commands, but this needs to happen first.
600
504
 
601
 
    for a in argv:
 
505
    argv_copy = []
 
506
    i = 0
 
507
    while i < len(argv):
 
508
        a = argv[i]
602
509
        if a == '--profile':
603
510
            opt_profile = True
 
511
        elif a == '--lsprof':
 
512
            opt_lsprof = True
 
513
        elif a == '--lsprof-file':
 
514
            opt_lsprof = True
 
515
            opt_lsprof_file = argv[i + 1]
 
516
            i += 1
604
517
        elif a == '--no-plugins':
605
518
            opt_no_plugins = True
 
519
        elif a == '--no-aliases':
 
520
            opt_no_aliases = True
606
521
        elif a == '--builtin':
607
522
            opt_builtin = True
 
523
        elif a in ('--quiet', '-q'):
 
524
            be_quiet()
608
525
        else:
609
 
            break
610
 
        argv.remove(a)
 
526
            argv_copy.append(a)
 
527
        i += 1
611
528
 
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()
 
529
    argv = argv_copy
 
530
    if (not argv):
 
531
        from bzrlib.builtins import cmd_help
 
532
        cmd_help().run_argv_aliases([])
618
533
        return 0
619
534
 
620
535
    if argv[0] == '--version':
621
 
        from bzrlib.builtins import show_version
 
536
        from bzrlib.version import show_version
622
537
        show_version()
623
538
        return 0
624
539
        
625
540
    if not opt_no_plugins:
626
541
        from bzrlib.plugin import load_plugins
627
542
        load_plugins()
628
 
 
629
 
    cmd = str(argv.pop(0))
 
543
    else:
 
544
        from bzrlib.plugin import disable_plugins
 
545
        disable_plugins()
 
546
 
 
547
    alias_argv = None
 
548
 
 
549
    if not opt_no_aliases:
 
550
        alias_argv = get_alias(argv[0])
 
551
        if alias_argv:
 
552
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
553
            argv[0] = alias_argv.pop(0)
 
554
 
 
555
    cmd = argv.pop(0)
 
556
    # We want only 'ascii' command names, but the user may have typed
 
557
    # in a Unicode name. In that case, they should just get a
 
558
    # 'command not found' error later.
630
559
 
631
560
    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)
 
561
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
562
        run = cmd_obj.run_argv
 
563
        run_argv = [argv]
635
564
    else:
636
 
        ret = cmd_obj.run_argv(argv)
637
 
    return ret or 0
 
565
        run = cmd_obj.run_argv_aliases
 
566
        run_argv = [argv, alias_argv]
 
567
 
 
568
    try:
 
569
        if opt_lsprof:
 
570
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
571
        elif opt_profile:
 
572
            ret = apply_profiled(run, *run_argv)
 
573
        else:
 
574
            ret = run(*run_argv)
 
575
        return ret or 0
 
576
    finally:
 
577
        # reset, in case we may do other commands later within the same process
 
578
        be_quiet(False)
 
579
 
 
580
def display_command(func):
 
581
    """Decorator that suppresses pipe/interrupt errors."""
 
582
    def ignore_pipe(*args, **kwargs):
 
583
        try:
 
584
            result = func(*args, **kwargs)
 
585
            sys.stdout.flush()
 
586
            return result
 
587
        except IOError, e:
 
588
            if not hasattr(e, 'errno'):
 
589
                raise
 
590
            if e.errno != errno.EPIPE:
 
591
                # Win32 raises IOError with errno=0 on a broken pipe
 
592
                if sys.platform != 'win32' or e.errno != 0:
 
593
                    raise
 
594
            pass
 
595
        except KeyboardInterrupt:
 
596
            pass
 
597
    return ignore_pipe
638
598
 
639
599
 
640
600
def main(argv):
641
601
    import bzrlib.ui
642
 
    bzrlib.trace.log_startup(argv)
643
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
644
 
 
 
602
    from bzrlib.ui.text import TextUIFactory
 
603
    bzrlib.ui.ui_factory = TextUIFactory()
 
604
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
605
    ret = run_bzr_catch_errors(argv)
 
606
    mutter("return code %d", ret)
 
607
    return ret
 
608
 
 
609
 
 
610
def run_bzr_catch_errors(argv):
645
611
    try:
646
 
        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))
 
612
        return run_bzr(argv)
 
613
        # do this here inside the exception wrappers to catch EPIPE
 
614
        sys.stdout.flush()
 
615
    except Exception, e:
 
616
        # used to handle AssertionError and KeyboardInterrupt
 
617
        # specially here, but hopefully they're handled ok by the logger now
 
618
        bzrlib.trace.report_exception(sys.exc_info(), sys.stderr)
 
619
        if os.environ.get('BZR_PDB'):
 
620
            print '**** entering debugger'
 
621
            import pdb
 
622
            pdb.post_mortem(sys.exc_traceback)
664
623
        return 3
665
 
    except KeyboardInterrupt, e:
666
 
        bzrlib.trace.note('interrupted')
667
 
        return 2
668
 
    except Exception, e:
669
 
        import errno
670
 
        if (isinstance(e, IOError) 
671
 
            and hasattr(e, 'errno')
672
 
            and e.errno == errno.EPIPE):
673
 
            bzrlib.trace.note('broken pipe')
674
 
            return 2
675
 
        else:
676
 
            bzrlib.trace.log_exception()
677
 
            return 2
678
624
 
679
625
if __name__ == '__main__':
680
626
    sys.exit(main(sys.argv))