← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Robert Collins
  • Date: 2007-03-21 01:34:41 UTC
  • mto: (2376.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 2377.
  • Revision ID: robertc@robertcollins.net-20070321013441-x99h538fq62wwt46
Remove bzrlib 0.8 compatability where it was making the code unclear or messy. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
# TODO: probably should say which arguments are candidates for glob
19
19
# expansion on windows and do that at the command level.
20
20
 
21
 
# TODO: Help messages for options.
22
 
 
23
 
# 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
 
 
 
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 os
36
32
import sys
37
 
import os
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import codecs
 
37
import errno
38
38
from warnings import warn
39
 
from inspect import getdoc
40
39
 
41
40
import bzrlib
42
 
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
 
41
from bzrlib import (
 
42
    debug,
 
43
    errors,
 
44
    option,
 
45
    osutils,
 
46
    trace,
 
47
    )
 
48
""")
 
49
 
 
50
from bzrlib.symbol_versioning import (
 
51
    deprecated_function,
 
52
    deprecated_method,
 
53
    zero_eight,
 
54
    zero_eleven,
 
55
    )
 
56
# Compatibility
 
57
from bzrlib.option import Option
 
58
 
47
59
 
48
60
plugin_cmds = {}
49
61
 
50
62
 
51
 
def register_command(cmd):
52
 
    "Utility function to help register a command"
 
63
def register_command(cmd, decorate=False):
 
64
    """Utility function to help register a command
 
65
 
 
66
    :param cmd: Command subclass to register
 
67
    :param decorate: If true, allow overriding an existing command
 
68
        of the same name; the old command is returned by this function.
 
69
        Otherwise it is an error to try to override an existing command.
 
70
    """
53
71
    global plugin_cmds
54
72
    k = cmd.__name__
55
73
    if k.startswith("cmd_"):
56
74
        k_unsquished = _unsquish_command_name(k)
57
75
    else:
58
76
        k_unsquished = k
59
 
    if not plugin_cmds.has_key(k_unsquished):
60
 
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
77
    if k_unsquished not in plugin_cmds:
 
78
        plugin_cmds[k_unsquished] = cmd
 
79
        ## trace.mutter('registered plugin command %s', k_unsquished)
 
80
        if decorate and k_unsquished in builtin_command_names():
 
81
            return _builtin_commands()[k_unsquished]
 
82
    elif decorate:
 
83
        result = plugin_cmds[k_unsquished]
 
84
        plugin_cmds[k_unsquished] = cmd
 
85
        return result
62
86
    else:
63
 
        log_error('Two plugins defined the same command: %r' % k)
64
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
87
        trace.log_error('Two plugins defined the same command: %r' % k)
 
88
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
65
89
 
66
90
 
67
91
def _squish_command_name(cmd):
73
97
    return cmd[4:].replace('_','-')
74
98
 
75
99
 
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
100
def _builtin_commands():
161
101
    import bzrlib.builtins
162
102
    r = {}
163
103
    builtins = bzrlib.builtins.__dict__
164
104
    for name in builtins:
165
105
        if name.startswith("cmd_"):
166
 
            real_name = _unsquish_command_name(name)        
 
106
            real_name = _unsquish_command_name(name)
167
107
            r[real_name] = builtins[name]
168
108
    return r
169
 
 
170
109
            
171
110
 
172
111
def builtin_command_names():
200
139
    """
201
140
    from bzrlib.externalcommand import ExternalCommand
202
141
 
203
 
    cmd_name = str(cmd_name)            # not unicode
 
142
    # We want only 'ascii' command names, but the user may have typed
 
143
    # in a Unicode name. In that case, they should just get a
 
144
    # 'command not found' error later.
 
145
    # In the future, we may actually support Unicode command names.
204
146
 
205
147
    # first look up this command under the specified name
206
148
    cmds = _get_cmd_dict(plugins_override=plugins_override)
218
160
    if cmd_obj:
219
161
        return cmd_obj
220
162
 
221
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
163
    raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
222
164
 
223
165
 
224
166
class Command(object):
246
188
        List of argument forms, marked with whether they are optional,
247
189
        repeated, etc.
248
190
 
 
191
                Examples:
 
192
 
 
193
                ['to_location', 'from_branch?', 'file*']
 
194
 
 
195
                'to_location' is required
 
196
                'from_branch' is optional
 
197
                'file' can be specified 0 or more times
 
198
 
249
199
    takes_options
250
 
        List of options that may be given for this command.
 
200
        List of options that may be given for this command.  These can
 
201
        be either strings, referring to globally-defined options,
 
202
        or option objects.  Retrieve through options().
251
203
 
252
204
    hidden
253
205
        If true, this command isn't advertised.  This is typically
254
206
        for commands intended for expert users.
 
207
 
 
208
    encoding_type
 
209
        Command objects will get a 'outf' attribute, which has been
 
210
        setup to properly handle encoding of unicode strings.
 
211
        encoding_type determines what will happen when characters cannot
 
212
        be encoded
 
213
            strict - abort if we cannot decode
 
214
            replace - put in a bogus character (typically '?')
 
215
            exact - do not encode sys.stdout
 
216
 
 
217
            NOTE: by default on Windows, sys.stdout is opened as a text
 
218
            stream, therefore LF line-endings are converted to CRLF.
 
219
            When a command uses encoding_type = 'exact', then
 
220
            sys.stdout is forced to be a binary stream, and line-endings
 
221
            will not mangled.
 
222
 
255
223
    """
256
224
    aliases = []
257
 
    
258
225
    takes_args = []
259
226
    takes_options = []
 
227
    encoding_type = 'strict'
260
228
 
261
229
    hidden = False
262
230
    
265
233
        if self.__doc__ == Command.__doc__:
266
234
            warn("No help message set for %r" % self)
267
235
 
268
 
 
269
 
    def run_argv(self, argv):
270
 
        """Parse command line and run."""
271
 
        args, opts = parse_args(argv)
272
 
 
 
236
    def options(self):
 
237
        """Return dict of valid options for this command.
 
238
 
 
239
        Maps from long option name to option object."""
 
240
        r = dict()
 
241
        r['help'] = option.Option.OPTIONS['help']
 
242
        for o in self.takes_options:
 
243
            if isinstance(o, basestring):
 
244
                o = option.Option.OPTIONS[o]
 
245
            r[o.name] = o
 
246
        return r
 
247
 
 
248
    def _setup_outf(self):
 
249
        """Return a file linked to stdout, which has proper encoding."""
 
250
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
251
 
 
252
        # Originally I was using self.stdout, but that looks
 
253
        # *way* too much like sys.stdout
 
254
        if self.encoding_type == 'exact':
 
255
            # force sys.stdout to be binary stream on win32
 
256
            if sys.platform == 'win32':
 
257
                fileno = getattr(sys.stdout, 'fileno', None)
 
258
                if fileno:
 
259
                    import msvcrt
 
260
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
261
            self.outf = sys.stdout
 
262
            return
 
263
 
 
264
        output_encoding = osutils.get_terminal_encoding()
 
265
 
 
266
        # use 'replace' so that we don't abort if trying to write out
 
267
        # in e.g. the default C locale.
 
268
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
 
269
        # For whatever reason codecs.getwriter() does not advertise its encoding
 
270
        # it just returns the encoding of the wrapped file, which is completely
 
271
        # bogus. So set the attribute, so we can find the correct encoding later.
 
272
        self.outf.encoding = output_encoding
 
273
 
 
274
    def run_argv_aliases(self, argv, alias_argv=None):
 
275
        """Parse the command line and run with extra aliases in alias_argv."""
 
276
        if argv is None:
 
277
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
278
                 DeprecationWarning, stacklevel=2)
 
279
            argv = []
 
280
        args, opts = parse_args(self, argv, alias_argv)
273
281
        if 'help' in opts:  # e.g. bzr add --help
274
282
            from bzrlib.help import help_on_command
275
283
            help_on_command(self.name())
276
284
            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
285
        # mix arguments and options into one dictionary
286
286
        cmdargs = _match_argform(self.name(), self.takes_args, args)
287
287
        cmdopts = {}
291
291
        all_cmd_args = cmdargs.copy()
292
292
        all_cmd_args.update(cmdopts)
293
293
 
 
294
        self._setup_outf()
 
295
 
294
296
        return self.run(**all_cmd_args)
295
 
 
296
297
    
297
298
    def run(self):
298
299
        """Actually run the command.
304
305
        shell error code if not.  It's OK for this method to allow
305
306
        an exception to raise up.
306
307
        """
307
 
        raise NotImplementedError()
308
 
 
 
308
        raise NotImplementedError('no implementation of command %r'
 
309
                                  % self.name())
309
310
 
310
311
    def help(self):
311
312
        """Return help message for this class."""
 
313
        from inspect import getdoc
312
314
        if self.__doc__ is Command.__doc__:
313
315
            return None
314
316
        return getdoc(self)
316
318
    def name(self):
317
319
        return _unsquish_command_name(self.__class__.__name__)
318
320
 
319
 
 
 
321
    def plugin_name(self):
 
322
        """Get the name of the plugin that provides this command.
 
323
 
 
324
        :return: The name of the plugin or None if the command is builtin.
 
325
        """
 
326
        mod_parts = self.__module__.split('.')
 
327
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
328
            return mod_parts[2]
 
329
        else:
 
330
            return None
 
331
 
 
332
 
 
333
# Technically, this function hasn't been use in a *really* long time
 
334
# but we are only deprecating it now.
 
335
@deprecated_function(zero_eleven)
320
336
def parse_spec(spec):
321
337
    """
322
338
    >>> parse_spec(None)
348
364
        parsed = [spec, None]
349
365
    return parsed
350
366
 
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):
 
367
def parse_args(command, argv, alias_argv=None):
393
368
    """Parse command line.
394
369
    
395
370
    Arguments and options are parsed at this level before being passed
396
371
    down to specific command handlers.  This routine knows, from a
397
372
    lookup table, something about the available options, what optargs
398
373
    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
374
    """
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
 
 
 
375
    # TODO: make it a method of the Command?
 
376
    parser = option.get_optparser(command.options())
 
377
    if alias_argv is not None:
 
378
        args = alias_argv + argv
 
379
    else:
 
380
        args = argv
 
381
 
 
382
    options, args = parser.parse_args(args)
 
383
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
384
                 v is not option.OptionParser.DEFAULT_VALUE])
491
385
    return args, opts
492
386
 
493
387
 
494
 
 
495
 
 
496
388
def _match_argform(cmd, takes_args, args):
497
389
    argdict = {}
498
390
 
510
402
                argdict[argname + '_list'] = None
511
403
        elif ap[-1] == '+':
512
404
            if not args:
513
 
                raise BzrCommandError("command %r needs one or more %s"
514
 
                        % (cmd, argname.upper()))
 
405
                raise errors.BzrCommandError("command %r needs one or more %s"
 
406
                                             % (cmd, argname.upper()))
515
407
            else:
516
408
                argdict[argname + '_list'] = args[:]
517
409
                args = []
518
410
        elif ap[-1] == '$': # all but one
519
411
            if len(args) < 2:
520
 
                raise BzrCommandError("command %r needs one or more %s"
521
 
                        % (cmd, argname.upper()))
 
412
                raise errors.BzrCommandError("command %r needs one or more %s"
 
413
                                             % (cmd, argname.upper()))
522
414
            argdict[argname + '_list'] = args[:-1]
523
 
            args[:-1] = []                
 
415
            args[:-1] = []
524
416
        else:
525
417
            # just a plain arg
526
418
            argname = ap
527
419
            if not args:
528
 
                raise BzrCommandError("command %r requires argument %s"
529
 
                        % (cmd, argname.upper()))
 
420
                raise errors.BzrCommandError("command %r requires argument %s"
 
421
                               % (cmd, argname.upper()))
530
422
            else:
531
423
                argdict[argname] = args.pop(0)
532
424
            
533
425
    if args:
534
 
        raise BzrCommandError("extra argument to command %s: %s"
535
 
                              % (cmd, args[0]))
 
426
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
427
                                     % (cmd, args[0]))
536
428
 
537
429
    return argdict
538
430
 
541
433
def apply_profiled(the_callable, *args, **kwargs):
542
434
    import hotshot
543
435
    import tempfile
 
436
    import hotshot.stats
544
437
    pffileno, pfname = tempfile.mkstemp()
545
438
    try:
546
439
        prof = hotshot.Profile(pfname)
548
441
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
549
442
        finally:
550
443
            prof.close()
551
 
 
552
 
        import hotshot.stats
553
444
        stats = hotshot.stats.load(pfname)
554
 
        #stats.strip_dirs()
555
 
        stats.sort_stats('time')
 
445
        stats.strip_dirs()
 
446
        stats.sort_stats('cum')   # 'time'
556
447
        ## XXX: Might like to write to stderr or the trace file instead but
557
448
        ## print_stats seems hardcoded to stdout
558
449
        stats.print_stats(20)
559
 
 
560
450
        return ret
561
451
    finally:
562
452
        os.close(pffileno)
563
453
        os.remove(pfname)
564
454
 
565
455
 
 
456
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
457
    from bzrlib.lsprof import profile
 
458
    import cPickle
 
459
    ret, stats = profile(the_callable, *args, **kwargs)
 
460
    stats.sort()
 
461
    if filename is None:
 
462
        stats.pprint()
 
463
    else:
 
464
        stats.freeze()
 
465
        cPickle.dump(stats, open(filename, 'w'), 2)
 
466
        print 'Profile data written to %r.' % filename
 
467
    return ret
 
468
 
 
469
 
 
470
def get_alias(cmd, config=None):
 
471
    """Return an expanded alias, or None if no alias exists.
 
472
 
 
473
    cmd
 
474
        Command to be checked for an alias.
 
475
    config
 
476
        Used to specify an alternative config to use,
 
477
        which is especially useful for testing.
 
478
        If it is unspecified, the global config will be used.
 
479
    """
 
480
    if config is None:
 
481
        import bzrlib.config
 
482
        config = bzrlib.config.GlobalConfig()
 
483
    alias = config.get_alias(cmd)
 
484
    if (alias):
 
485
        import shlex
 
486
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
487
    return None
 
488
 
 
489
 
566
490
def run_bzr(argv):
567
491
    """Execute a command.
568
492
 
571
495
    
572
496
    argv
573
497
       The command-line arguments, without the program name from argv[0]
 
498
       These should already be decoded. All library/test code calling
 
499
       run_bzr should be passing valid strings (don't need decoding).
574
500
    
575
501
    Returns a command status or raises an exception.
576
502
 
580
506
    --no-plugins
581
507
        Do not load plugin modules at all
582
508
 
 
509
    --no-aliases
 
510
        Do not allow aliases
 
511
 
583
512
    --builtin
584
513
        Only use builtin commands.  (Plugins are still allowed to change
585
514
        other behaviour.)
586
515
 
587
516
    --profile
588
 
        Run under the Python profiler.
 
517
        Run under the Python hotshot profiler.
 
518
 
 
519
    --lsprof
 
520
        Run under the Python lsprof profiler.
589
521
    """
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]
 
522
    argv = list(argv)
 
523
    trace.mutter("bzr arguments: %r", argv)
594
524
 
595
 
    opt_profile = opt_no_plugins = opt_builtin = False
 
525
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
526
                opt_no_aliases = False
 
527
    opt_lsprof_file = None
596
528
 
597
529
    # --no-plugins is handled specially at a very early stage. We need
598
530
    # to load plugins before doing other command parsing so that they
599
531
    # can override commands, but this needs to happen first.
600
532
 
601
 
    for a in argv:
 
533
    argv_copy = []
 
534
    i = 0
 
535
    while i < len(argv):
 
536
        a = argv[i]
602
537
        if a == '--profile':
603
538
            opt_profile = True
 
539
        elif a == '--lsprof':
 
540
            opt_lsprof = True
 
541
        elif a == '--lsprof-file':
 
542
            opt_lsprof = True
 
543
            opt_lsprof_file = argv[i + 1]
 
544
            i += 1
604
545
        elif a == '--no-plugins':
605
546
            opt_no_plugins = True
 
547
        elif a == '--no-aliases':
 
548
            opt_no_aliases = True
606
549
        elif a == '--builtin':
607
550
            opt_builtin = True
 
551
        elif a in ('--quiet', '-q'):
 
552
            trace.be_quiet()
 
553
        elif a.startswith('-D'):
 
554
            debug.debug_flags.add(a[2:])
608
555
        else:
609
 
            break
610
 
        argv.remove(a)
 
556
            argv_copy.append(a)
 
557
        i += 1
611
558
 
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()
 
559
    argv = argv_copy
 
560
    if (not argv):
 
561
        from bzrlib.builtins import cmd_help
 
562
        cmd_help().run_argv_aliases([])
618
563
        return 0
619
564
 
620
565
    if argv[0] == '--version':
621
 
        from bzrlib.builtins import show_version
 
566
        from bzrlib.version import show_version
622
567
        show_version()
623
568
        return 0
624
569
        
625
570
    if not opt_no_plugins:
626
571
        from bzrlib.plugin import load_plugins
627
572
        load_plugins()
628
 
 
629
 
    cmd = str(argv.pop(0))
 
573
    else:
 
574
        from bzrlib.plugin import disable_plugins
 
575
        disable_plugins()
 
576
 
 
577
    alias_argv = None
 
578
 
 
579
    if not opt_no_aliases:
 
580
        alias_argv = get_alias(argv[0])
 
581
        if alias_argv:
 
582
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
583
            argv[0] = alias_argv.pop(0)
 
584
 
 
585
    cmd = argv.pop(0)
 
586
    # We want only 'ascii' command names, but the user may have typed
 
587
    # in a Unicode name. In that case, they should just get a
 
588
    # 'command not found' error later.
630
589
 
631
590
    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)
635
 
    else:
636
 
        ret = cmd_obj.run_argv(argv)
637
 
    return ret or 0
 
591
    run = cmd_obj.run_argv_aliases
 
592
    run_argv = [argv, alias_argv]
 
593
 
 
594
    try:
 
595
        if opt_lsprof:
 
596
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
597
        elif opt_profile:
 
598
            ret = apply_profiled(run, *run_argv)
 
599
        else:
 
600
            ret = run(*run_argv)
 
601
        return ret or 0
 
602
    finally:
 
603
        # reset, in case we may do other commands later within the same process
 
604
        trace.be_quiet(False)
 
605
 
 
606
def display_command(func):
 
607
    """Decorator that suppresses pipe/interrupt errors."""
 
608
    def ignore_pipe(*args, **kwargs):
 
609
        try:
 
610
            result = func(*args, **kwargs)
 
611
            sys.stdout.flush()
 
612
            return result
 
613
        except IOError, e:
 
614
            if getattr(e, 'errno', None) is None:
 
615
                raise
 
616
            if e.errno != errno.EPIPE:
 
617
                # Win32 raises IOError with errno=0 on a broken pipe
 
618
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
619
                    raise
 
620
            pass
 
621
        except KeyboardInterrupt:
 
622
            pass
 
623
    return ignore_pipe
638
624
 
639
625
 
640
626
def main(argv):
641
627
    import bzrlib.ui
642
 
    bzrlib.trace.log_startup(argv)
643
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
644
 
 
 
628
    from bzrlib.ui.text import TextUIFactory
 
629
    bzrlib.ui.ui_factory = TextUIFactory()
 
630
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
631
    ret = run_bzr_catch_errors(argv)
 
632
    trace.mutter("return code %d", ret)
 
633
    return ret
 
634
 
 
635
 
 
636
def run_bzr_catch_errors(argv):
645
637
    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))
 
638
        return run_bzr(argv)
 
639
        # do this here inside the exception wrappers to catch EPIPE
 
640
        sys.stdout.flush()
 
641
    except (KeyboardInterrupt, Exception), e:
 
642
        # used to handle AssertionError and KeyboardInterrupt
 
643
        # specially here, but hopefully they're handled ok by the logger now
 
644
        trace.report_exception(sys.exc_info(), sys.stderr)
 
645
        if os.environ.get('BZR_PDB'):
 
646
            print '**** entering debugger'
 
647
            import pdb
 
648
            pdb.post_mortem(sys.exc_traceback)
664
649
        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
650
 
679
651
if __name__ == '__main__':
680
652
    sys.exit(main(sys.argv))