← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-06-12 06:07:27 UTC
  • mfrom: (2522.1.1 bzr.dev)
  • Revision ID: pqm@pqm.ubuntu.com-20070612060727-v8nd5etbkay15fm2
prepare for 0.18 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
# TODO: probably should say which arguments are candidates for glob
19
19
# expansion on windows and do that at the command level.
20
20
 
21
 
# TODO: Help messages for options.
22
 
 
23
21
# TODO: Define arguments by objects, rather than just using names.
24
22
# Those objects can specify the expected type of the argument, which
25
 
# would help with validation and shell completion.
 
23
# would help with validation and shell completion.  They could also provide
 
24
# help/explanation for that argument in a structured way.
 
25
 
 
26
# TODO: Specific "examples" property on commands for consistent formatting.
26
27
 
27
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
28
29
# the profile output behind so it can be interactively examined?
29
30
 
 
31
import os
30
32
import sys
31
 
import os
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import codecs
 
37
import errno
32
38
from warnings import warn
33
 
from inspect import getdoc
34
 
import errno
35
39
 
36
40
import bzrlib
37
 
import bzrlib.trace
38
 
from bzrlib.trace import mutter, note, log_error, warning
39
 
from bzrlib.errors import (BzrError, 
40
 
                           BzrCheckError,
41
 
                           BzrCommandError,
42
 
                           BzrOptionError,
43
 
                           NotBranchError)
44
 
from bzrlib.revisionspec import RevisionSpec
45
 
from bzrlib import BZRDIR
 
41
from bzrlib import (
 
42
    debug,
 
43
    errors,
 
44
    option,
 
45
    osutils,
 
46
    trace,
 
47
    )
 
48
""")
 
49
 
 
50
from bzrlib.symbol_versioning import (
 
51
    deprecated_function,
 
52
    deprecated_method,
 
53
    zero_eight,
 
54
    zero_eleven,
 
55
    )
 
56
# Compatibility
46
57
from bzrlib.option import Option
47
58
 
 
59
 
48
60
plugin_cmds = {}
49
61
 
50
62
 
51
63
def register_command(cmd, decorate=False):
52
 
    "Utility function to help register a command"
 
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):
 
77
    if k_unsquished not in plugin_cmds:
60
78
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
79
        ## trace.mutter('registered plugin command %s', k_unsquished)
62
80
        if decorate and k_unsquished in builtin_command_names():
63
81
            return _builtin_commands()[k_unsquished]
64
82
    elif decorate:
66
84
        plugin_cmds[k_unsquished] = cmd
67
85
        return result
68
86
    else:
69
 
        log_error('Two plugins defined the same command: %r' % k)
70
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
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__])
71
89
 
72
90
 
73
91
def _squish_command_name(cmd):
85
103
    builtins = bzrlib.builtins.__dict__
86
104
    for name in builtins:
87
105
        if name.startswith("cmd_"):
88
 
            real_name = _unsquish_command_name(name)        
 
106
            real_name = _unsquish_command_name(name)
89
107
            r[real_name] = builtins[name]
90
108
    return r
91
 
 
92
109
            
93
110
 
94
111
def builtin_command_names():
120
137
    plugins_override
121
138
        If true, plugin commands can override builtins.
122
139
    """
 
140
    try:
 
141
        return _get_cmd_object(cmd_name, plugins_override)
 
142
    except KeyError:
 
143
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
144
 
 
145
 
 
146
def _get_cmd_object(cmd_name, plugins_override=True):
 
147
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
123
148
    from bzrlib.externalcommand import ExternalCommand
124
149
 
125
 
    cmd_name = str(cmd_name)            # not unicode
 
150
    # We want only 'ascii' command names, but the user may have typed
 
151
    # in a Unicode name. In that case, they should just get a
 
152
    # 'command not found' error later.
 
153
    # In the future, we may actually support Unicode command names.
126
154
 
127
155
    # first look up this command under the specified name
128
156
    cmds = _get_cmd_dict(plugins_override=plugins_override)
139
167
    cmd_obj = ExternalCommand.find_command(cmd_name)
140
168
    if cmd_obj:
141
169
        return cmd_obj
142
 
 
143
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
170
    raise KeyError
144
171
 
145
172
 
146
173
class Command(object):
168
195
        List of argument forms, marked with whether they are optional,
169
196
        repeated, etc.
170
197
 
171
 
                Examples:
172
 
 
173
 
                ['to_location', 'from_branch?', 'file*']
174
 
 
175
 
                'to_location' is required
176
 
                'from_branch' is optional
177
 
                'file' can be specified 0 or more times
 
198
                Examples:
 
199
 
 
200
                ['to_location', 'from_branch?', 'file*']
 
201
 
 
202
                'to_location' is required
 
203
                'from_branch' is optional
 
204
                'file' can be specified 0 or more times
178
205
 
179
206
    takes_options
180
207
        List of options that may be given for this command.  These can
184
211
    hidden
185
212
        If true, this command isn't advertised.  This is typically
186
213
        for commands intended for expert users.
 
214
 
 
215
    encoding_type
 
216
        Command objects will get a 'outf' attribute, which has been
 
217
        setup to properly handle encoding of unicode strings.
 
218
        encoding_type determines what will happen when characters cannot
 
219
        be encoded
 
220
            strict - abort if we cannot decode
 
221
            replace - put in a bogus character (typically '?')
 
222
            exact - do not encode sys.stdout
 
223
 
 
224
            NOTE: by default on Windows, sys.stdout is opened as a text
 
225
            stream, therefore LF line-endings are converted to CRLF.
 
226
            When a command uses encoding_type = 'exact', then
 
227
            sys.stdout is forced to be a binary stream, and line-endings
 
228
            will not mangled.
 
229
 
187
230
    """
188
231
    aliases = []
189
232
    takes_args = []
190
233
    takes_options = []
 
234
    encoding_type = 'strict'
191
235
 
192
236
    hidden = False
193
237
    
196
240
        if self.__doc__ == Command.__doc__:
197
241
            warn("No help message set for %r" % self)
198
242
 
 
243
    def _usage(self):
 
244
        """Return single-line grammar for this command.
 
245
 
 
246
        Only describes arguments, not options.
 
247
        """
 
248
        s = 'bzr ' + self.name() + ' '
 
249
        for aname in self.takes_args:
 
250
            aname = aname.upper()
 
251
            if aname[-1] in ['$', '+']:
 
252
                aname = aname[:-1] + '...'
 
253
            elif aname[-1] == '?':
 
254
                aname = '[' + aname[:-1] + ']'
 
255
            elif aname[-1] == '*':
 
256
                aname = '[' + aname[:-1] + '...]'
 
257
            s += aname + ' '
 
258
                
 
259
        assert s[-1] == ' '
 
260
        s = s[:-1]
 
261
        return s
 
262
 
 
263
    def get_help_text(self, additional_see_also=None):
 
264
        """Return a text string with help for this command.
 
265
        
 
266
        :param additional_see_also: Additional help topics to be
 
267
            cross-referenced.
 
268
        """
 
269
        doc = self.help()
 
270
        if doc is None:
 
271
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
272
 
 
273
        result = ""
 
274
        result += 'usage: %s\n' % self._usage()
 
275
 
 
276
        if self.aliases:
 
277
            result += 'aliases: '
 
278
            result += ', '.join(self.aliases) + '\n'
 
279
 
 
280
        result += '\n'
 
281
 
 
282
        plugin_name = self.plugin_name()
 
283
        if plugin_name is not None:
 
284
            result += '(From plugin "%s")' % plugin_name
 
285
            result += '\n\n'
 
286
 
 
287
        result += doc
 
288
        if result[-1] != '\n':
 
289
            result += '\n'
 
290
        result += '\n'
 
291
        result += option.get_optparser(self.options()).format_option_help()
 
292
        see_also = self.get_see_also(additional_see_also)
 
293
        if see_also:
 
294
            result += '\nSee also: '
 
295
            result += ', '.join(see_also)
 
296
            result += '\n'
 
297
        return result
 
298
 
 
299
    def get_help_topic(self):
 
300
        """Return the commands help topic - its name."""
 
301
        return self.name()
 
302
 
 
303
    def get_see_also(self, additional_terms=None):
 
304
        """Return a list of help topics that are related to this ommand.
 
305
        
 
306
        The list is derived from the content of the _see_also attribute. Any
 
307
        duplicates are removed and the result is in lexical order.
 
308
        :param additional_terms: Additional help topics to cross-reference.
 
309
        :return: A list of help topics.
 
310
        """
 
311
        see_also = set(getattr(self, '_see_also', []))
 
312
        if additional_terms:
 
313
            see_also.update(additional_terms)
 
314
        return sorted(see_also)
 
315
 
199
316
    def options(self):
200
317
        """Return dict of valid options for this command.
201
318
 
202
319
        Maps from long option name to option object."""
203
320
        r = dict()
204
 
        r['help'] = Option.OPTIONS['help']
 
321
        r['help'] = option.Option.OPTIONS['help']
205
322
        for o in self.takes_options:
206
 
            if not isinstance(o, Option):
207
 
                o = Option.OPTIONS[o]
 
323
            if isinstance(o, basestring):
 
324
                o = option.Option.OPTIONS[o]
208
325
            r[o.name] = o
209
326
        return r
210
327
 
211
 
    def run_argv(self, argv):
212
 
        """Parse command line and run."""
213
 
        args, opts = parse_args(self, argv)
 
328
    def _setup_outf(self):
 
329
        """Return a file linked to stdout, which has proper encoding."""
 
330
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
331
 
 
332
        # Originally I was using self.stdout, but that looks
 
333
        # *way* too much like sys.stdout
 
334
        if self.encoding_type == 'exact':
 
335
            # force sys.stdout to be binary stream on win32
 
336
            if sys.platform == 'win32':
 
337
                fileno = getattr(sys.stdout, 'fileno', None)
 
338
                if fileno:
 
339
                    import msvcrt
 
340
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
341
            self.outf = sys.stdout
 
342
            return
 
343
 
 
344
        output_encoding = osutils.get_terminal_encoding()
 
345
 
 
346
        # use 'replace' so that we don't abort if trying to write out
 
347
        # in e.g. the default C locale.
 
348
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
 
349
        # For whatever reason codecs.getwriter() does not advertise its encoding
 
350
        # it just returns the encoding of the wrapped file, which is completely
 
351
        # bogus. So set the attribute, so we can find the correct encoding later.
 
352
        self.outf.encoding = output_encoding
 
353
 
 
354
    def run_argv_aliases(self, argv, alias_argv=None):
 
355
        """Parse the command line and run with extra aliases in alias_argv."""
 
356
        if argv is None:
 
357
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
358
                 DeprecationWarning, stacklevel=2)
 
359
            argv = []
 
360
        args, opts = parse_args(self, argv, alias_argv)
214
361
        if 'help' in opts:  # e.g. bzr add --help
215
 
            from bzrlib.help import help_on_command
216
 
            help_on_command(self.name())
 
362
            sys.stdout.write(self.get_help_text())
217
363
            return 0
218
 
        # XXX: This should be handled by the parser
219
 
        allowed_names = self.options().keys()
220
 
        for oname in opts:
221
 
            if oname not in allowed_names:
222
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
223
 
                                      % (oname, self.name()))
224
364
        # mix arguments and options into one dictionary
225
365
        cmdargs = _match_argform(self.name(), self.takes_args, args)
226
366
        cmdopts = {}
230
370
        all_cmd_args = cmdargs.copy()
231
371
        all_cmd_args.update(cmdopts)
232
372
 
 
373
        self._setup_outf()
 
374
 
233
375
        return self.run(**all_cmd_args)
234
376
    
235
377
    def run(self):
242
384
        shell error code if not.  It's OK for this method to allow
243
385
        an exception to raise up.
244
386
        """
245
 
        raise NotImplementedError()
246
 
 
 
387
        raise NotImplementedError('no implementation of command %r'
 
388
                                  % self.name())
247
389
 
248
390
    def help(self):
249
391
        """Return help message for this class."""
 
392
        from inspect import getdoc
250
393
        if self.__doc__ is Command.__doc__:
251
394
            return None
252
395
        return getdoc(self)
254
397
    def name(self):
255
398
        return _unsquish_command_name(self.__class__.__name__)
256
399
 
257
 
 
 
400
    def plugin_name(self):
 
401
        """Get the name of the plugin that provides this command.
 
402
 
 
403
        :return: The name of the plugin or None if the command is builtin.
 
404
        """
 
405
        mod_parts = self.__module__.split('.')
 
406
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
407
            return mod_parts[2]
 
408
        else:
 
409
            return None
 
410
 
 
411
 
 
412
# Technically, this function hasn't been use in a *really* long time
 
413
# but we are only deprecating it now.
 
414
@deprecated_function(zero_eleven)
258
415
def parse_spec(spec):
259
416
    """
260
417
    >>> parse_spec(None)
286
443
        parsed = [spec, None]
287
444
    return parsed
288
445
 
289
 
def parse_args(command, argv):
 
446
def parse_args(command, argv, alias_argv=None):
290
447
    """Parse command line.
291
448
    
292
449
    Arguments and options are parsed at this level before being passed
294
451
    lookup table, something about the available options, what optargs
295
452
    they take, and which commands will accept them.
296
453
    """
297
 
    # TODO: chop up this beast; make it a method of the Command
298
 
    args = []
299
 
    opts = {}
300
 
 
301
 
    cmd_options = command.options()
302
 
    argsover = False
303
 
    while argv:
304
 
        a = argv.pop(0)
305
 
        if argsover:
306
 
            args.append(a)
307
 
            continue
308
 
        elif a == '--':
309
 
            # We've received a standalone -- No more flags
310
 
            argsover = True
311
 
            continue
312
 
        if a[0] == '-':
313
 
            # option names must not be unicode
314
 
            a = str(a)
315
 
            optarg = None
316
 
            if a[1] == '-':
317
 
                mutter("  got option %r", a)
318
 
                if '=' in a:
319
 
                    optname, optarg = a[2:].split('=', 1)
320
 
                else:
321
 
                    optname = a[2:]
322
 
                if optname not in cmd_options:
323
 
                    raise BzrOptionError('unknown long option %r for command %s'
324
 
                        % (a, command.name()))
325
 
            else:
326
 
                shortopt = a[1:]
327
 
                if shortopt in Option.SHORT_OPTIONS:
328
 
                    # Multi-character options must have a space to delimit
329
 
                    # their value
330
 
                    # ^^^ what does this mean? mbp 20051014
331
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
332
 
                else:
333
 
                    # Single character short options, can be chained,
334
 
                    # and have their value appended to their name
335
 
                    shortopt = a[1:2]
336
 
                    if shortopt not in Option.SHORT_OPTIONS:
337
 
                        # We didn't find the multi-character name, and we
338
 
                        # didn't find the single char name
339
 
                        raise BzrError('unknown short option %r' % a)
340
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
341
 
 
342
 
                    if a[2:]:
343
 
                        # There are extra things on this option
344
 
                        # see if it is the value, or if it is another
345
 
                        # short option
346
 
                        optargfn = Option.OPTIONS[optname].type
347
 
                        if optargfn is None:
348
 
                            # This option does not take an argument, so the
349
 
                            # next entry is another short option, pack it back
350
 
                            # into the list
351
 
                            argv.insert(0, '-' + a[2:])
352
 
                        else:
353
 
                            # This option takes an argument, so pack it
354
 
                            # into the array
355
 
                            optarg = a[2:]
356
 
            
357
 
                if optname not in cmd_options:
358
 
                    raise BzrOptionError('unknown short option %r for command'
359
 
                        ' %s' % (shortopt, command.name()))
360
 
            if optname in opts:
361
 
                # XXX: Do we ever want to support this, e.g. for -r?
362
 
                raise BzrError('repeated option %r' % a)
363
 
                
364
 
            option_obj = cmd_options[optname]
365
 
            optargfn = option_obj.type
366
 
            if optargfn:
367
 
                if optarg == None:
368
 
                    if not argv:
369
 
                        raise BzrError('option %r needs an argument' % a)
370
 
                    else:
371
 
                        optarg = argv.pop(0)
372
 
                opts[optname] = optargfn(optarg)
373
 
            else:
374
 
                if optarg != None:
375
 
                    raise BzrError('option %r takes no argument' % optname)
376
 
                opts[optname] = True
377
 
        else:
378
 
            args.append(a)
 
454
    # TODO: make it a method of the Command?
 
455
    parser = option.get_optparser(command.options())
 
456
    if alias_argv is not None:
 
457
        args = alias_argv + argv
 
458
    else:
 
459
        args = argv
 
460
 
 
461
    options, args = parser.parse_args(args)
 
462
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
463
                 v is not option.OptionParser.DEFAULT_VALUE])
379
464
    return args, opts
380
465
 
381
466
 
396
481
                argdict[argname + '_list'] = None
397
482
        elif ap[-1] == '+':
398
483
            if not args:
399
 
                raise BzrCommandError("command %r needs one or more %s"
400
 
                        % (cmd, argname.upper()))
 
484
                raise errors.BzrCommandError("command %r needs one or more %s"
 
485
                                             % (cmd, argname.upper()))
401
486
            else:
402
487
                argdict[argname + '_list'] = args[:]
403
488
                args = []
404
489
        elif ap[-1] == '$': # all but one
405
490
            if len(args) < 2:
406
 
                raise BzrCommandError("command %r needs one or more %s"
407
 
                        % (cmd, argname.upper()))
 
491
                raise errors.BzrCommandError("command %r needs one or more %s"
 
492
                                             % (cmd, argname.upper()))
408
493
            argdict[argname + '_list'] = args[:-1]
409
 
            args[:-1] = []                
 
494
            args[:-1] = []
410
495
        else:
411
496
            # just a plain arg
412
497
            argname = ap
413
498
            if not args:
414
 
                raise BzrCommandError("command %r requires argument %s"
415
 
                        % (cmd, argname.upper()))
 
499
                raise errors.BzrCommandError("command %r requires argument %s"
 
500
                               % (cmd, argname.upper()))
416
501
            else:
417
502
                argdict[argname] = args.pop(0)
418
503
            
419
504
    if args:
420
 
        raise BzrCommandError("extra argument to command %s: %s"
421
 
                              % (cmd, args[0]))
 
505
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
506
                                     % (cmd, args[0]))
422
507
 
423
508
    return argdict
424
509
 
447
532
        os.remove(pfname)
448
533
 
449
534
 
 
535
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
536
    from bzrlib.lsprof import profile
 
537
    import cPickle
 
538
    ret, stats = profile(the_callable, *args, **kwargs)
 
539
    stats.sort()
 
540
    if filename is None:
 
541
        stats.pprint()
 
542
    else:
 
543
        stats.freeze()
 
544
        cPickle.dump(stats, open(filename, 'w'), 2)
 
545
        print 'Profile data written to %r.' % filename
 
546
    return ret
 
547
 
 
548
 
 
549
def get_alias(cmd, config=None):
 
550
    """Return an expanded alias, or None if no alias exists.
 
551
 
 
552
    cmd
 
553
        Command to be checked for an alias.
 
554
    config
 
555
        Used to specify an alternative config to use,
 
556
        which is especially useful for testing.
 
557
        If it is unspecified, the global config will be used.
 
558
    """
 
559
    if config is None:
 
560
        import bzrlib.config
 
561
        config = bzrlib.config.GlobalConfig()
 
562
    alias = config.get_alias(cmd)
 
563
    if (alias):
 
564
        import shlex
 
565
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
566
    return None
 
567
 
 
568
 
450
569
def run_bzr(argv):
451
570
    """Execute a command.
452
571
 
455
574
    
456
575
    argv
457
576
       The command-line arguments, without the program name from argv[0]
 
577
       These should already be decoded. All library/test code calling
 
578
       run_bzr should be passing valid strings (don't need decoding).
458
579
    
459
580
    Returns a command status or raises an exception.
460
581
 
464
585
    --no-plugins
465
586
        Do not load plugin modules at all
466
587
 
 
588
    --no-aliases
 
589
        Do not allow aliases
 
590
 
467
591
    --builtin
468
592
        Only use builtin commands.  (Plugins are still allowed to change
469
593
        other behaviour.)
470
594
 
471
595
    --profile
472
 
        Run under the Python profiler.
 
596
        Run under the Python hotshot profiler.
 
597
 
 
598
    --lsprof
 
599
        Run under the Python lsprof profiler.
473
600
    """
474
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
601
    argv = list(argv)
 
602
    trace.mutter("bzr arguments: %r", argv)
475
603
 
476
 
    opt_profile = opt_no_plugins = opt_builtin = False
 
604
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
605
                opt_no_aliases = False
 
606
    opt_lsprof_file = None
477
607
 
478
608
    # --no-plugins is handled specially at a very early stage. We need
479
609
    # to load plugins before doing other command parsing so that they
480
610
    # can override commands, but this needs to happen first.
481
611
 
482
 
    for a in argv:
 
612
    argv_copy = []
 
613
    i = 0
 
614
    while i < len(argv):
 
615
        a = argv[i]
483
616
        if a == '--profile':
484
617
            opt_profile = True
 
618
        elif a == '--lsprof':
 
619
            opt_lsprof = True
 
620
        elif a == '--lsprof-file':
 
621
            opt_lsprof = True
 
622
            opt_lsprof_file = argv[i + 1]
 
623
            i += 1
485
624
        elif a == '--no-plugins':
486
625
            opt_no_plugins = True
 
626
        elif a == '--no-aliases':
 
627
            opt_no_aliases = True
487
628
        elif a == '--builtin':
488
629
            opt_builtin = True
 
630
        elif a in ('--quiet', '-q'):
 
631
            trace.be_quiet()
 
632
        elif a.startswith('-D'):
 
633
            debug.debug_flags.add(a[2:])
489
634
        else:
490
 
            break
491
 
        argv.remove(a)
 
635
            argv_copy.append(a)
 
636
        i += 1
492
637
 
493
 
    if (not argv) or (argv[0] == '--help'):
494
 
        from bzrlib.help import help
495
 
        if len(argv) > 1:
496
 
            help(argv[1])
497
 
        else:
498
 
            help()
 
638
    argv = argv_copy
 
639
    if (not argv):
 
640
        from bzrlib.builtins import cmd_help
 
641
        cmd_help().run_argv_aliases([])
499
642
        return 0
500
643
 
501
644
    if argv[0] == '--version':
502
 
        from bzrlib.builtins import show_version
 
645
        from bzrlib.version import show_version
503
646
        show_version()
504
647
        return 0
505
648
        
506
649
    if not opt_no_plugins:
507
650
        from bzrlib.plugin import load_plugins
508
651
        load_plugins()
509
 
 
510
 
    cmd = str(argv.pop(0))
 
652
    else:
 
653
        from bzrlib.plugin import disable_plugins
 
654
        disable_plugins()
 
655
 
 
656
    alias_argv = None
 
657
 
 
658
    if not opt_no_aliases:
 
659
        alias_argv = get_alias(argv[0])
 
660
        if alias_argv:
 
661
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
662
            argv[0] = alias_argv.pop(0)
 
663
 
 
664
    cmd = argv.pop(0)
 
665
    # We want only 'ascii' command names, but the user may have typed
 
666
    # in a Unicode name. In that case, they should just get a
 
667
    # 'command not found' error later.
511
668
 
512
669
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
670
    run = cmd_obj.run_argv_aliases
 
671
    run_argv = [argv, alias_argv]
513
672
 
514
 
    if opt_profile:
515
 
        ret = apply_profiled(cmd_obj.run_argv, argv)
516
 
    else:
517
 
        ret = cmd_obj.run_argv(argv)
518
 
    return ret or 0
 
673
    try:
 
674
        if opt_lsprof:
 
675
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
676
        elif opt_profile:
 
677
            ret = apply_profiled(run, *run_argv)
 
678
        else:
 
679
            ret = run(*run_argv)
 
680
        return ret or 0
 
681
    finally:
 
682
        # reset, in case we may do other commands later within the same process
 
683
        trace.be_quiet(False)
519
684
 
520
685
def display_command(func):
521
686
    """Decorator that suppresses pipe/interrupt errors."""
525
690
            sys.stdout.flush()
526
691
            return result
527
692
        except IOError, e:
528
 
            if not hasattr(e, 'errno'):
 
693
            if getattr(e, 'errno', None) is None:
529
694
                raise
530
695
            if e.errno != errno.EPIPE:
531
 
                raise
 
696
                # Win32 raises IOError with errno=0 on a broken pipe
 
697
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
698
                    raise
532
699
            pass
533
700
        except KeyboardInterrupt:
534
701
            pass
535
702
    return ignore_pipe
536
703
 
 
704
 
537
705
def main(argv):
538
706
    import bzrlib.ui
539
 
    bzrlib.trace.log_startup(argv)
540
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
541
 
 
542
 
    return run_bzr_catch_errors(argv[1:])
 
707
    from bzrlib.ui.text import TextUIFactory
 
708
    bzrlib.ui.ui_factory = TextUIFactory()
 
709
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
710
    ret = run_bzr_catch_errors(argv)
 
711
    trace.mutter("return code %d", ret)
 
712
    return ret
543
713
 
544
714
 
545
715
def run_bzr_catch_errors(argv):
549
719
        finally:
550
720
            # do this here inside the exception wrappers to catch EPIPE
551
721
            sys.stdout.flush()
552
 
    except Exception, e:
 
722
    except (KeyboardInterrupt, Exception), e:
553
723
        # used to handle AssertionError and KeyboardInterrupt
554
724
        # specially here, but hopefully they're handled ok by the logger now
555
 
        import errno
556
 
        if (isinstance(e, IOError) 
557
 
            and hasattr(e, 'errno')
558
 
            and e.errno == errno.EPIPE):
559
 
            bzrlib.trace.note('broken pipe')
560
 
            return 3
 
725
        trace.report_exception(sys.exc_info(), sys.stderr)
 
726
        if os.environ.get('BZR_PDB'):
 
727
            print '**** entering debugger'
 
728
            import pdb
 
729
            pdb.post_mortem(sys.exc_traceback)
 
730
        return 3
 
731
 
 
732
 
 
733
class HelpCommandIndex(object):
 
734
    """A index for bzr help that returns commands."""
 
735
 
 
736
    def __init__(self):
 
737
        self.prefix = 'commands/'
 
738
 
 
739
    def get_topics(self, topic):
 
740
        """Search for topic amongst commands.
 
741
 
 
742
        :param topic: A topic to search for.
 
743
        :return: A list which is either empty or contains a single
 
744
            Command entry.
 
745
        """
 
746
        if topic and topic.startswith(self.prefix):
 
747
            topic = topic[len(self.prefix):]
 
748
        try:
 
749
            cmd = _get_cmd_object(topic)
 
750
        except KeyError:
 
751
            return []
561
752
        else:
562
 
            bzrlib.trace.log_exception()
563
 
            if os.environ.get('BZR_PDB'):
564
 
                print '**** entering debugger'
565
 
                import pdb
566
 
                pdb.post_mortem(sys.exc_traceback)
567
 
            return 3
 
753
            return [cmd]
 
754
 
568
755
 
569
756
if __name__ == '__main__':
570
757
    sys.exit(main(sys.argv))