← 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: 2006-05-22 14:53:12 UTC
  • mfrom: (1707.3.30 ftp-server)
  • Revision ID: pqm@pqm.ubuntu.com-20060522145312-94c3c934d7cbd9ff
(jam) use medusa as an ftp-server provider, fix FtpTransport

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
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?
30
31
import sys
31
32
import os
32
33
from warnings import warn
33
 
from inspect import getdoc
34
34
import errno
35
35
 
36
36
import bzrlib
37
 
import bzrlib.trace
38
 
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
39
 
from bzrlib.errors import (BzrError, 
 
37
from bzrlib.errors import (BzrError,
40
38
                           BzrCheckError,
41
39
                           BzrCommandError,
42
40
                           BzrOptionError,
43
41
                           NotBranchError)
 
42
from bzrlib.option import Option
44
43
from bzrlib.revisionspec import RevisionSpec
45
 
from bzrlib import BZRDIR
46
 
from bzrlib.option import Option
 
44
from bzrlib.symbol_versioning import *
 
45
import bzrlib.trace
 
46
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
47
47
 
48
48
plugin_cmds = {}
49
49
 
50
50
 
51
51
def register_command(cmd, decorate=False):
52
 
    "Utility function to help register a command"
 
52
    """Utility function to help register a command
 
53
 
 
54
    :param cmd: Command subclass to register
 
55
    :param decorate: If true, allow overriding an existing command
 
56
        of the same name; the old command is returned by this function.
 
57
        Otherwise it is an error to try to override an existing command.
 
58
    """
53
59
    global plugin_cmds
54
60
    k = cmd.__name__
55
61
    if k.startswith("cmd_"):
58
64
        k_unsquished = k
59
65
    if not plugin_cmds.has_key(k_unsquished):
60
66
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
67
        mutter('registered plugin command %s', k_unsquished)
62
68
        if decorate and k_unsquished in builtin_command_names():
63
69
            return _builtin_commands()[k_unsquished]
64
70
    elif decorate:
85
91
    builtins = bzrlib.builtins.__dict__
86
92
    for name in builtins:
87
93
        if name.startswith("cmd_"):
88
 
            real_name = _unsquish_command_name(name)        
 
94
            real_name = _unsquish_command_name(name)
89
95
            r[real_name] = builtins[name]
90
96
    return r
91
 
 
92
97
            
93
98
 
94
99
def builtin_command_names():
168
173
        List of argument forms, marked with whether they are optional,
169
174
        repeated, etc.
170
175
 
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
 
176
                Examples:
 
177
 
 
178
                ['to_location', 'from_branch?', 'file*']
 
179
 
 
180
                'to_location' is required
 
181
                'from_branch' is optional
 
182
                'file' can be specified 0 or more times
178
183
 
179
184
    takes_options
180
185
        List of options that may be given for this command.  These can
208
213
            r[o.name] = o
209
214
        return r
210
215
 
 
216
    @deprecated_method(zero_eight)
211
217
    def run_argv(self, argv):
212
 
        """Parse command line and run."""
213
 
        args, opts = parse_args(self, argv)
 
218
        """Parse command line and run.
 
219
        
 
220
        See run_argv_aliases for the 0.8 and beyond api.
 
221
        """
 
222
        return self.run_argv_aliases(argv)
 
223
 
 
224
    def run_argv_aliases(self, argv, alias_argv=None):
 
225
        """Parse the command line and run with extra aliases in alias_argv."""
 
226
        args, opts = parse_args(self, argv, alias_argv)
214
227
        if 'help' in opts:  # e.g. bzr add --help
215
228
            from bzrlib.help import help_on_command
216
229
            help_on_command(self.name())
219
232
        allowed_names = self.options().keys()
220
233
        for oname in opts:
221
234
            if oname not in allowed_names:
222
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
223
 
                                      % (oname, self.name()))
 
235
                raise BzrCommandError("option '--%s' is not allowed for"
 
236
                                      " command %r" % (oname, self.name()))
224
237
        # mix arguments and options into one dictionary
225
238
        cmdargs = _match_argform(self.name(), self.takes_args, args)
226
239
        cmdopts = {}
242
255
        shell error code if not.  It's OK for this method to allow
243
256
        an exception to raise up.
244
257
        """
245
 
        raise NotImplementedError()
246
 
 
 
258
        raise NotImplementedError('no implementation of command %r' 
 
259
                                  % self.name())
247
260
 
248
261
    def help(self):
249
262
        """Return help message for this class."""
 
263
        from inspect import getdoc
250
264
        if self.__doc__ is Command.__doc__:
251
265
            return None
252
266
        return getdoc(self)
286
300
        parsed = [spec, None]
287
301
    return parsed
288
302
 
289
 
def parse_args(command, argv):
 
303
def parse_args(command, argv, alias_argv=None):
290
304
    """Parse command line.
291
305
    
292
306
    Arguments and options are parsed at this level before being passed
297
311
    # TODO: chop up this beast; make it a method of the Command
298
312
    args = []
299
313
    opts = {}
 
314
    alias_opts = {}
300
315
 
301
316
    cmd_options = command.options()
302
317
    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
 
318
    proc_aliasarg = True # Are we processing alias_argv now?
 
319
    for proc_argv in alias_argv, argv:
 
320
        while proc_argv:
 
321
            a = proc_argv.pop(0)
 
322
            if argsover:
 
323
                args.append(a)
 
324
                continue
 
325
            elif a == '--':
 
326
                # We've received a standalone -- No more flags
 
327
                argsover = True
 
328
                continue
 
329
            if a[0] == '-':
 
330
                # option names must not be unicode
 
331
                a = str(a)
 
332
                optarg = None
 
333
                if a[1] == '-':
 
334
                    mutter("  got option %r", a)
 
335
                    if '=' in a:
 
336
                        optname, optarg = a[2:].split('=', 1)
 
337
                    else:
 
338
                        optname = a[2:]
 
339
                    if optname not in cmd_options:
 
340
                        raise BzrOptionError('unknown long option %r for'
 
341
                                             ' command %s' % 
 
342
                                             (a, command.name()))
 
343
                else:
 
344
                    shortopt = a[1:]
 
345
                    if shortopt in Option.SHORT_OPTIONS:
 
346
                        # Multi-character options must have a space to delimit
 
347
                        # their value
 
348
                        # ^^^ what does this mean? mbp 20051014
 
349
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
350
                    else:
 
351
                        # Single character short options, can be chained,
 
352
                        # and have their value appended to their name
 
353
                        shortopt = a[1:2]
 
354
                        if shortopt not in Option.SHORT_OPTIONS:
 
355
                            # We didn't find the multi-character name, and we
 
356
                            # didn't find the single char name
 
357
                            raise BzrError('unknown short option %r' % a)
 
358
                        optname = Option.SHORT_OPTIONS[shortopt].name
341
359
 
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:])
 
360
                        if a[2:]:
 
361
                            # There are extra things on this option
 
362
                            # see if it is the value, or if it is another
 
363
                            # short option
 
364
                            optargfn = Option.OPTIONS[optname].type
 
365
                            if optargfn is None:
 
366
                                # This option does not take an argument, so the
 
367
                                # next entry is another short option, pack it
 
368
                                # back into the list
 
369
                                proc_argv.insert(0, '-' + a[2:])
 
370
                            else:
 
371
                                # This option takes an argument, so pack it
 
372
                                # into the array
 
373
                                optarg = a[2:]
 
374
                
 
375
                    if optname not in cmd_options:
 
376
                        raise BzrOptionError('unknown short option %r for'
 
377
                                             ' command %s' % 
 
378
                                             (shortopt, command.name()))
 
379
                if optname in opts:
 
380
                    # XXX: Do we ever want to support this, e.g. for -r?
 
381
                    if proc_aliasarg:
 
382
                        raise BzrError('repeated option %r' % a)
 
383
                    elif optname in alias_opts:
 
384
                        # Replace what's in the alias with what's in the real
 
385
                        # argument
 
386
                        del alias_opts[optname]
 
387
                        del opts[optname]
 
388
                        proc_argv.insert(0, a)
 
389
                        continue
 
390
                    else:
 
391
                        raise BzrError('repeated option %r' % a)
 
392
                    
 
393
                option_obj = cmd_options[optname]
 
394
                optargfn = option_obj.type
 
395
                if optargfn:
 
396
                    if optarg == None:
 
397
                        if not proc_argv:
 
398
                            raise BzrError('option %r needs an argument' % a)
352
399
                        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)
 
400
                            optarg = proc_argv.pop(0)
 
401
                    opts[optname] = optargfn(optarg)
 
402
                    if proc_aliasarg:
 
403
                        alias_opts[optname] = optargfn(optarg)
 
404
                else:
 
405
                    if optarg != None:
 
406
                        raise BzrError('option %r takes no argument' % optname)
 
407
                    opts[optname] = True
 
408
                    if proc_aliasarg:
 
409
                        alias_opts[optname] = True
373
410
            else:
374
 
                if optarg != None:
375
 
                    raise BzrError('option %r takes no argument' % optname)
376
 
                opts[optname] = True
377
 
        else:
378
 
            args.append(a)
 
411
                args.append(a)
 
412
        proc_aliasarg = False # Done with alias argv
379
413
    return args, opts
380
414
 
381
415
 
447
481
        os.remove(pfname)
448
482
 
449
483
 
 
484
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
485
    from bzrlib.lsprof import profile
 
486
    import cPickle
 
487
    ret, stats = profile(the_callable, *args, **kwargs)
 
488
    stats.sort()
 
489
    if filename is None:
 
490
        stats.pprint()
 
491
    else:
 
492
        stats.freeze()
 
493
        cPickle.dump(stats, open(filename, 'w'), 2)
 
494
        print 'Profile data written to %r.' % filename
 
495
    return ret
 
496
 
 
497
 
 
498
def get_alias(cmd):
 
499
    """Return an expanded alias, or None if no alias exists"""
 
500
    import bzrlib.config
 
501
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
502
    if (alias):
 
503
        return alias.split(' ')
 
504
    return None
 
505
 
 
506
 
450
507
def run_bzr(argv):
451
508
    """Execute a command.
452
509
 
464
521
    --no-plugins
465
522
        Do not load plugin modules at all
466
523
 
 
524
    --no-aliases
 
525
        Do not allow aliases
 
526
 
467
527
    --builtin
468
528
        Only use builtin commands.  (Plugins are still allowed to change
469
529
        other behaviour.)
470
530
 
471
531
    --profile
472
 
        Run under the Python profiler.
 
532
        Run under the Python hotshot profiler.
 
533
 
 
534
    --lsprof
 
535
        Run under the Python lsprof profiler.
473
536
    """
474
537
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
475
538
 
476
 
    opt_profile = opt_no_plugins = opt_builtin = False
 
539
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
540
                opt_no_aliases = False
 
541
    opt_lsprof_file = None
477
542
 
478
543
    # --no-plugins is handled specially at a very early stage. We need
479
544
    # to load plugins before doing other command parsing so that they
480
545
    # can override commands, but this needs to happen first.
481
546
 
482
 
    for a in argv:
 
547
    argv_copy = []
 
548
    i = 0
 
549
    while i < len(argv):
 
550
        a = argv[i]
483
551
        if a == '--profile':
484
552
            opt_profile = True
 
553
        elif a == '--lsprof':
 
554
            opt_lsprof = True
 
555
        elif a == '--lsprof-file':
 
556
            opt_lsprof_file = argv[i + 1]
 
557
            i += 1
485
558
        elif a == '--no-plugins':
486
559
            opt_no_plugins = True
 
560
        elif a == '--no-aliases':
 
561
            opt_no_aliases = True
487
562
        elif a == '--builtin':
488
563
            opt_builtin = True
489
564
        elif a in ('--quiet', '-q'):
490
565
            be_quiet()
491
566
        else:
492
 
            continue
493
 
        argv.remove(a)
 
567
            argv_copy.append(a)
 
568
        i += 1
494
569
 
495
 
    if (not argv) or (argv[0] == '--help'):
496
 
        from bzrlib.help import help
497
 
        if len(argv) > 1:
498
 
            help(argv[1])
499
 
        else:
500
 
            help()
 
570
    argv = argv_copy
 
571
    if (not argv):
 
572
        from bzrlib.builtins import cmd_help
 
573
        cmd_help().run_argv_aliases([])
501
574
        return 0
502
575
 
503
576
    if argv[0] == '--version':
508
581
    if not opt_no_plugins:
509
582
        from bzrlib.plugin import load_plugins
510
583
        load_plugins()
 
584
    else:
 
585
        from bzrlib.plugin import disable_plugins
 
586
        disable_plugins()
 
587
 
 
588
    alias_argv = None
 
589
 
 
590
    if not opt_no_aliases:
 
591
        alias_argv = get_alias(argv[0])
 
592
        if alias_argv:
 
593
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
594
            argv[0] = alias_argv.pop(0)
511
595
 
512
596
    cmd = str(argv.pop(0))
513
597
 
514
598
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
599
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
600
        run = cmd_obj.run_argv
 
601
        run_argv = [argv]
 
602
    else:
 
603
        run = cmd_obj.run_argv_aliases
 
604
        run_argv = [argv, alias_argv]
515
605
 
516
606
    try:
517
 
        if opt_profile:
518
 
            ret = apply_profiled(cmd_obj.run_argv, argv)
 
607
        if opt_lsprof:
 
608
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
609
        elif opt_profile:
 
610
            ret = apply_profiled(run, *run_argv)
519
611
        else:
520
 
            ret = cmd_obj.run_argv(argv)
 
612
            ret = run(*run_argv)
521
613
        return ret or 0
522
614
    finally:
523
615
        # reset, in case we may do other commands later within the same process