/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Robert Collins
  • Date: 2005-10-30 01:40:16 UTC
  • Revision ID: robertc@robertcollins.net-20051030014016-98a4fba7d6a4176c
Support decoration of commands.

Commands.register_command now takes an optional flag to signal that the
registrant is planning to decorate an existing command. When given
multiple plugins registering a command is not an error, and the original
command class (whether built in or a plugin based one) is returned to the
caller. There is a new error 'MustUseDecorated' for signalling when a
wrapping command should switch to the original version. (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
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
# TODO: probably should say which arguments are candidates for glob
 
19
# expansion on windows and do that at the command level.
 
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
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
 
28
# the profile output behind so it can be interactively examined?
 
29
 
 
30
import sys
 
31
import os
 
32
from warnings import warn
 
33
from inspect import getdoc
 
34
import errno
 
35
 
 
36
import bzrlib
 
37
import bzrlib.trace
 
38
from bzrlib.trace import mutter, note, log_error, warning
 
39
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
 
40
from bzrlib.revisionspec import RevisionSpec
 
41
from bzrlib import BZRDIR
 
42
from bzrlib.option import Option
 
43
 
 
44
plugin_cmds = {}
 
45
 
 
46
 
 
47
def register_command(cmd, decorate=False):
 
48
    "Utility function to help register a command"
 
49
    global plugin_cmds
 
50
    k = cmd.__name__
 
51
    if k.startswith("cmd_"):
 
52
        k_unsquished = _unsquish_command_name(k)
 
53
    else:
 
54
        k_unsquished = k
 
55
    if not plugin_cmds.has_key(k_unsquished):
 
56
        plugin_cmds[k_unsquished] = cmd
 
57
        mutter('registered plugin command %s', k_unsquished)      
 
58
        if decorate and k_unsquished in builtin_command_names():
 
59
            return _builtin_commands()[k_unsquished]
 
60
    elif decorate:
 
61
        result = plugin_cmds[k_unsquished]
 
62
        plugin_cmds[k_unsquished] = cmd
 
63
        return result
 
64
    else:
 
65
        log_error('Two plugins defined the same command: %r' % k)
 
66
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
67
 
 
68
 
 
69
def _squish_command_name(cmd):
 
70
    return 'cmd_' + cmd.replace('-', '_')
 
71
 
 
72
 
 
73
def _unsquish_command_name(cmd):
 
74
    assert cmd.startswith("cmd_")
 
75
    return cmd[4:].replace('_','-')
 
76
 
 
77
 
 
78
def _builtin_commands():
 
79
    import bzrlib.builtins
 
80
    r = {}
 
81
    builtins = bzrlib.builtins.__dict__
 
82
    for name in builtins:
 
83
        if name.startswith("cmd_"):
 
84
            real_name = _unsquish_command_name(name)        
 
85
            r[real_name] = builtins[name]
 
86
    return r
 
87
 
 
88
            
 
89
 
 
90
def builtin_command_names():
 
91
    """Return list of builtin command names."""
 
92
    return _builtin_commands().keys()
 
93
    
 
94
 
 
95
def plugin_command_names():
 
96
    return plugin_cmds.keys()
 
97
 
 
98
 
 
99
def _get_cmd_dict(plugins_override=True):
 
100
    """Return name->class mapping for all commands."""
 
101
    d = _builtin_commands()
 
102
    if plugins_override:
 
103
        d.update(plugin_cmds)
 
104
    return d
 
105
 
 
106
    
 
107
def get_all_cmds(plugins_override=True):
 
108
    """Return canonical name and class for all registered commands."""
 
109
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
 
110
        yield k,v
 
111
 
 
112
 
 
113
def get_cmd_object(cmd_name, plugins_override=True):
 
114
    """Return the canonical name and command class for a command.
 
115
 
 
116
    plugins_override
 
117
        If true, plugin commands can override builtins.
 
118
    """
 
119
    from bzrlib.externalcommand import ExternalCommand
 
120
 
 
121
    cmd_name = str(cmd_name)            # not unicode
 
122
 
 
123
    # first look up this command under the specified name
 
124
    cmds = _get_cmd_dict(plugins_override=plugins_override)
 
125
    try:
 
126
        return cmds[cmd_name]()
 
127
    except KeyError:
 
128
        pass
 
129
 
 
130
    # look for any command which claims this as an alias
 
131
    for real_cmd_name, cmd_class in cmds.iteritems():
 
132
        if cmd_name in cmd_class.aliases:
 
133
            return cmd_class()
 
134
 
 
135
    cmd_obj = ExternalCommand.find_command(cmd_name)
 
136
    if cmd_obj:
 
137
        return cmd_obj
 
138
 
 
139
    raise BzrCommandError("unknown command %r" % cmd_name)
 
140
 
 
141
 
 
142
class Command(object):
 
143
    """Base class for commands.
 
144
 
 
145
    Commands are the heart of the command-line bzr interface.
 
146
 
 
147
    The command object mostly handles the mapping of command-line
 
148
    parameters into one or more bzrlib operations, and of the results
 
149
    into textual output.
 
150
 
 
151
    Commands normally don't have any state.  All their arguments are
 
152
    passed in to the run method.  (Subclasses may take a different
 
153
    policy if the behaviour of the instance needs to depend on e.g. a
 
154
    shell plugin and not just its Python class.)
 
155
 
 
156
    The docstring for an actual command should give a single-line
 
157
    summary, then a complete description of the command.  A grammar
 
158
    description will be inserted.
 
159
 
 
160
    aliases
 
161
        Other accepted names for this command.
 
162
 
 
163
    takes_args
 
164
        List of argument forms, marked with whether they are optional,
 
165
        repeated, etc.
 
166
 
 
167
    takes_options
 
168
        List of options that may be given for this command.  These can
 
169
        be either strings, referring to globally-defined options,
 
170
        or option objects.  Retrieve through options().
 
171
 
 
172
    hidden
 
173
        If true, this command isn't advertised.  This is typically
 
174
        for commands intended for expert users.
 
175
    """
 
176
    aliases = []
 
177
    takes_args = []
 
178
    takes_options = []
 
179
 
 
180
    hidden = False
 
181
    
 
182
    def __init__(self):
 
183
        """Construct an instance of this command."""
 
184
        if self.__doc__ == Command.__doc__:
 
185
            warn("No help message set for %r" % self)
 
186
 
 
187
    def options(self):
 
188
        """Return dict of valid options for this command.
 
189
 
 
190
        Maps from long option name to option object."""
 
191
        r = dict()
 
192
        r['help'] = Option.OPTIONS['help']
 
193
        for o in self.takes_options:
 
194
            if not isinstance(o, Option):
 
195
                o = Option.OPTIONS[o]
 
196
            r[o.name] = o
 
197
        return r
 
198
 
 
199
    def run_argv(self, argv):
 
200
        """Parse command line and run."""
 
201
        args, opts = parse_args(self, argv)
 
202
        if 'help' in opts:  # e.g. bzr add --help
 
203
            from bzrlib.help import help_on_command
 
204
            help_on_command(self.name())
 
205
            return 0
 
206
        # XXX: This should be handled by the parser
 
207
        allowed_names = self.options().keys()
 
208
        for oname in opts:
 
209
            if oname not in allowed_names:
 
210
                raise BzrCommandError("option '--%s' is not allowed for command %r"
 
211
                                      % (oname, self.name()))
 
212
        # mix arguments and options into one dictionary
 
213
        cmdargs = _match_argform(self.name(), self.takes_args, args)
 
214
        cmdopts = {}
 
215
        for k, v in opts.items():
 
216
            cmdopts[k.replace('-', '_')] = v
 
217
 
 
218
        all_cmd_args = cmdargs.copy()
 
219
        all_cmd_args.update(cmdopts)
 
220
 
 
221
        return self.run(**all_cmd_args)
 
222
    
 
223
    def run(self):
 
224
        """Actually run the command.
 
225
 
 
226
        This is invoked with the options and arguments bound to
 
227
        keyword parameters.
 
228
 
 
229
        Return 0 or None if the command was successful, or a non-zero
 
230
        shell error code if not.  It's OK for this method to allow
 
231
        an exception to raise up.
 
232
        """
 
233
        raise NotImplementedError()
 
234
 
 
235
 
 
236
    def help(self):
 
237
        """Return help message for this class."""
 
238
        if self.__doc__ is Command.__doc__:
 
239
            return None
 
240
        return getdoc(self)
 
241
 
 
242
    def name(self):
 
243
        return _unsquish_command_name(self.__class__.__name__)
 
244
 
 
245
 
 
246
def parse_spec(spec):
 
247
    """
 
248
    >>> parse_spec(None)
 
249
    [None, None]
 
250
    >>> parse_spec("./")
 
251
    ['./', None]
 
252
    >>> parse_spec("../@")
 
253
    ['..', -1]
 
254
    >>> parse_spec("../f/@35")
 
255
    ['../f', 35]
 
256
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
 
257
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
 
258
    """
 
259
    if spec is None:
 
260
        return [None, None]
 
261
    if '/@' in spec:
 
262
        parsed = spec.split('/@')
 
263
        assert len(parsed) == 2
 
264
        if parsed[1] == "":
 
265
            parsed[1] = -1
 
266
        else:
 
267
            try:
 
268
                parsed[1] = int(parsed[1])
 
269
            except ValueError:
 
270
                pass # We can allow stuff like ./@revid:blahblahblah
 
271
            else:
 
272
                assert parsed[1] >=0
 
273
    else:
 
274
        parsed = [spec, None]
 
275
    return parsed
 
276
 
 
277
def parse_args(command, argv):
 
278
    """Parse command line.
 
279
    
 
280
    Arguments and options are parsed at this level before being passed
 
281
    down to specific command handlers.  This routine knows, from a
 
282
    lookup table, something about the available options, what optargs
 
283
    they take, and which commands will accept them.
 
284
    """
 
285
    # TODO: chop up this beast; make it a method of the Command
 
286
    args = []
 
287
    opts = {}
 
288
 
 
289
    cmd_options = command.options()
 
290
    argsover = False
 
291
    while argv:
 
292
        a = argv.pop(0)
 
293
        if argsover:
 
294
            args.append(a)
 
295
            continue
 
296
        elif a == '--':
 
297
            # We've received a standalone -- No more flags
 
298
            argsover = True
 
299
            continue
 
300
        if a[0] == '-':
 
301
            # option names must not be unicode
 
302
            a = str(a)
 
303
            optarg = None
 
304
            if a[1] == '-':
 
305
                mutter("  got option %r" % a)
 
306
                if '=' in a:
 
307
                    optname, optarg = a[2:].split('=', 1)
 
308
                else:
 
309
                    optname = a[2:]
 
310
                if optname not in cmd_options:
 
311
                    raise BzrCommandError('unknown long option %r for command %s' 
 
312
                            % (a, command.name()))
 
313
            else:
 
314
                shortopt = a[1:]
 
315
                if shortopt in Option.SHORT_OPTIONS:
 
316
                    # Multi-character options must have a space to delimit
 
317
                    # their value
 
318
                    # ^^^ what does this mean? mbp 20051014
 
319
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
320
                else:
 
321
                    # Single character short options, can be chained,
 
322
                    # and have their value appended to their name
 
323
                    shortopt = a[1:2]
 
324
                    if shortopt not in Option.SHORT_OPTIONS:
 
325
                        # We didn't find the multi-character name, and we
 
326
                        # didn't find the single char name
 
327
                        raise BzrError('unknown short option %r' % a)
 
328
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
329
 
 
330
                    if a[2:]:
 
331
                        # There are extra things on this option
 
332
                        # see if it is the value, or if it is another
 
333
                        # short option
 
334
                        optargfn = Option.OPTIONS[optname].type
 
335
                        if optargfn is None:
 
336
                            # This option does not take an argument, so the
 
337
                            # next entry is another short option, pack it back
 
338
                            # into the list
 
339
                            argv.insert(0, '-' + a[2:])
 
340
                        else:
 
341
                            # This option takes an argument, so pack it
 
342
                            # into the array
 
343
                            optarg = a[2:]
 
344
            
 
345
            if optname in opts:
 
346
                # XXX: Do we ever want to support this, e.g. for -r?
 
347
                raise BzrError('repeated option %r' % a)
 
348
                
 
349
            option_obj = cmd_options[optname]
 
350
            optargfn = option_obj.type
 
351
            if optargfn:
 
352
                if optarg == None:
 
353
                    if not argv:
 
354
                        raise BzrError('option %r needs an argument' % a)
 
355
                    else:
 
356
                        optarg = argv.pop(0)
 
357
                opts[optname] = optargfn(optarg)
 
358
            else:
 
359
                if optarg != None:
 
360
                    raise BzrError('option %r takes no argument' % optname)
 
361
                opts[optname] = True
 
362
        else:
 
363
            args.append(a)
 
364
    return args, opts
 
365
 
 
366
 
 
367
def _match_argform(cmd, takes_args, args):
 
368
    argdict = {}
 
369
 
 
370
    # step through args and takes_args, allowing appropriate 0-many matches
 
371
    for ap in takes_args:
 
372
        argname = ap[:-1]
 
373
        if ap[-1] == '?':
 
374
            if args:
 
375
                argdict[argname] = args.pop(0)
 
376
        elif ap[-1] == '*': # all remaining arguments
 
377
            if args:
 
378
                argdict[argname + '_list'] = args[:]
 
379
                args = []
 
380
            else:
 
381
                argdict[argname + '_list'] = None
 
382
        elif ap[-1] == '+':
 
383
            if not args:
 
384
                raise BzrCommandError("command %r needs one or more %s"
 
385
                        % (cmd, argname.upper()))
 
386
            else:
 
387
                argdict[argname + '_list'] = args[:]
 
388
                args = []
 
389
        elif ap[-1] == '$': # all but one
 
390
            if len(args) < 2:
 
391
                raise BzrCommandError("command %r needs one or more %s"
 
392
                        % (cmd, argname.upper()))
 
393
            argdict[argname + '_list'] = args[:-1]
 
394
            args[:-1] = []                
 
395
        else:
 
396
            # just a plain arg
 
397
            argname = ap
 
398
            if not args:
 
399
                raise BzrCommandError("command %r requires argument %s"
 
400
                        % (cmd, argname.upper()))
 
401
            else:
 
402
                argdict[argname] = args.pop(0)
 
403
            
 
404
    if args:
 
405
        raise BzrCommandError("extra argument to command %s: %s"
 
406
                              % (cmd, args[0]))
 
407
 
 
408
    return argdict
 
409
 
 
410
 
 
411
 
 
412
def apply_profiled(the_callable, *args, **kwargs):
 
413
    import hotshot
 
414
    import tempfile
 
415
    import hotshot.stats
 
416
    pffileno, pfname = tempfile.mkstemp()
 
417
    try:
 
418
        prof = hotshot.Profile(pfname)
 
419
        try:
 
420
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
 
421
        finally:
 
422
            prof.close()
 
423
        stats = hotshot.stats.load(pfname)
 
424
        stats.strip_dirs()
 
425
        stats.sort_stats('cum')   # 'time'
 
426
        ## XXX: Might like to write to stderr or the trace file instead but
 
427
        ## print_stats seems hardcoded to stdout
 
428
        stats.print_stats(20)
 
429
        return ret
 
430
    finally:
 
431
        os.close(pffileno)
 
432
        os.remove(pfname)
 
433
 
 
434
 
 
435
def run_bzr(argv):
 
436
    """Execute a command.
 
437
 
 
438
    This is similar to main(), but without all the trappings for
 
439
    logging and error handling.  
 
440
    
 
441
    argv
 
442
       The command-line arguments, without the program name from argv[0]
 
443
    
 
444
    Returns a command status or raises an exception.
 
445
 
 
446
    Special master options: these must come before the command because
 
447
    they control how the command is interpreted.
 
448
 
 
449
    --no-plugins
 
450
        Do not load plugin modules at all
 
451
 
 
452
    --builtin
 
453
        Only use builtin commands.  (Plugins are still allowed to change
 
454
        other behaviour.)
 
455
 
 
456
    --profile
 
457
        Run under the Python profiler.
 
458
    """
 
459
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
460
 
 
461
    opt_profile = opt_no_plugins = opt_builtin = False
 
462
 
 
463
    # --no-plugins is handled specially at a very early stage. We need
 
464
    # to load plugins before doing other command parsing so that they
 
465
    # can override commands, but this needs to happen first.
 
466
 
 
467
    for a in argv:
 
468
        if a == '--profile':
 
469
            opt_profile = True
 
470
        elif a == '--no-plugins':
 
471
            opt_no_plugins = True
 
472
        elif a == '--builtin':
 
473
            opt_builtin = True
 
474
        else:
 
475
            break
 
476
        argv.remove(a)
 
477
 
 
478
    if (not argv) or (argv[0] == '--help'):
 
479
        from bzrlib.help import help
 
480
        if len(argv) > 1:
 
481
            help(argv[1])
 
482
        else:
 
483
            help()
 
484
        return 0
 
485
 
 
486
    if argv[0] == '--version':
 
487
        from bzrlib.builtins import show_version
 
488
        show_version()
 
489
        return 0
 
490
        
 
491
    if not opt_no_plugins:
 
492
        from bzrlib.plugin import load_plugins
 
493
        load_plugins()
 
494
 
 
495
    cmd = str(argv.pop(0))
 
496
 
 
497
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
498
 
 
499
    if opt_profile:
 
500
        ret = apply_profiled(cmd_obj.run_argv, argv)
 
501
    else:
 
502
        ret = cmd_obj.run_argv(argv)
 
503
    return ret or 0
 
504
 
 
505
def display_command(func):
 
506
    def ignore_pipe(*args, **kwargs):
 
507
        try:
 
508
            return func(*args, **kwargs)
 
509
        except IOError, e:
 
510
            if e.errno != errno.EPIPE:
 
511
                raise
 
512
        except KeyboardInterrupt:
 
513
            pass
 
514
    return ignore_pipe
 
515
 
 
516
def main(argv):
 
517
    import bzrlib.ui
 
518
    bzrlib.trace.log_startup(argv)
 
519
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
 
520
 
 
521
    return run_bzr_catch_errors(argv[1:])
 
522
 
 
523
 
 
524
def run_bzr_catch_errors(argv):
 
525
    try:
 
526
        try:
 
527
            return run_bzr(argv)
 
528
        finally:
 
529
            # do this here inside the exception wrappers to catch EPIPE
 
530
            sys.stdout.flush()
 
531
    except BzrCommandError, e:
 
532
        # command line syntax error, etc
 
533
        log_error(str(e))
 
534
        return 1
 
535
    except BzrError, e:
 
536
        bzrlib.trace.log_exception()
 
537
        return 1
 
538
    except AssertionError, e:
 
539
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
 
540
        return 3
 
541
    except KeyboardInterrupt, e:
 
542
        bzrlib.trace.log_exception('interrupted')
 
543
        return 2
 
544
    except Exception, e:
 
545
        import errno
 
546
        if (isinstance(e, IOError) 
 
547
            and hasattr(e, 'errno')
 
548
            and e.errno == errno.EPIPE):
 
549
            bzrlib.trace.note('broken pipe')
 
550
            return 2
 
551
        else:
 
552
            ## import pdb
 
553
            ## pdb.pm()
 
554
            bzrlib.trace.log_exception()
 
555
            return 2
 
556
 
 
557
if __name__ == '__main__':
 
558
    sys.exit(main(sys.argv))