← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

Late bind to PatienceSequenceMatcher in merge3.py

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
from bzrlib.errors import (BzrError,
 
38
                           BzrCheckError,
 
39
                           BzrCommandError,
 
40
                           BzrOptionError,
 
41
                           NotBranchError)
 
42
from bzrlib.option import Option
 
43
from bzrlib.revisionspec import RevisionSpec
 
44
from bzrlib.symbol_versioning import *
37
45
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
 
46
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
43
47
 
44
48
plugin_cmds = {}
45
49
 
46
50
 
47
 
def register_command(cmd):
48
 
    "Utility function to help register a command"
 
51
def register_command(cmd, decorate=False):
 
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
    """
49
59
    global plugin_cmds
50
60
    k = cmd.__name__
51
61
    if k.startswith("cmd_"):
54
64
        k_unsquished = k
55
65
    if not plugin_cmds.has_key(k_unsquished):
56
66
        plugin_cmds[k_unsquished] = cmd
57
 
        mutter('registered plugin command %s', k_unsquished)      
 
67
        mutter('registered plugin command %s', k_unsquished)
 
68
        if decorate and k_unsquished in builtin_command_names():
 
69
            return _builtin_commands()[k_unsquished]
 
70
    elif decorate:
 
71
        result = plugin_cmds[k_unsquished]
 
72
        plugin_cmds[k_unsquished] = cmd
 
73
        return result
58
74
    else:
59
75
        log_error('Two plugins defined the same command: %r' % k)
60
76
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
75
91
    builtins = bzrlib.builtins.__dict__
76
92
    for name in builtins:
77
93
        if name.startswith("cmd_"):
78
 
            real_name = _unsquish_command_name(name)        
 
94
            real_name = _unsquish_command_name(name)
79
95
            r[real_name] = builtins[name]
80
96
    return r
81
 
 
82
97
            
83
98
 
84
99
def builtin_command_names():
158
173
        List of argument forms, marked with whether they are optional,
159
174
        repeated, etc.
160
175
 
 
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
 
183
 
161
184
    takes_options
162
185
        List of options that may be given for this command.  These can
163
186
        be either strings, referring to globally-defined options,
190
213
            r[o.name] = o
191
214
        return r
192
215
 
 
216
    @deprecated_method(zero_eight)
193
217
    def run_argv(self, argv):
194
 
        """Parse command line and run."""
195
 
        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)
196
227
        if 'help' in opts:  # e.g. bzr add --help
197
228
            from bzrlib.help import help_on_command
198
229
            help_on_command(self.name())
201
232
        allowed_names = self.options().keys()
202
233
        for oname in opts:
203
234
            if oname not in allowed_names:
204
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
205
 
                                      % (oname, self.name()))
 
235
                raise BzrCommandError("option '--%s' is not allowed for"
 
236
                                      " command %r" % (oname, self.name()))
206
237
        # mix arguments and options into one dictionary
207
238
        cmdargs = _match_argform(self.name(), self.takes_args, args)
208
239
        cmdopts = {}
213
244
        all_cmd_args.update(cmdopts)
214
245
 
215
246
        return self.run(**all_cmd_args)
216
 
 
217
247
    
218
248
    def run(self):
219
249
        """Actually run the command.
225
255
        shell error code if not.  It's OK for this method to allow
226
256
        an exception to raise up.
227
257
        """
228
 
        raise NotImplementedError()
229
 
 
 
258
        raise NotImplementedError('no implementation of command %r' 
 
259
                                  % self.name())
230
260
 
231
261
    def help(self):
232
262
        """Return help message for this class."""
 
263
        from inspect import getdoc
233
264
        if self.__doc__ is Command.__doc__:
234
265
            return None
235
266
        return getdoc(self)
269
300
        parsed = [spec, None]
270
301
    return parsed
271
302
 
272
 
def parse_args(command, argv):
 
303
def parse_args(command, argv, alias_argv=None):
273
304
    """Parse command line.
274
305
    
275
306
    Arguments and options are parsed at this level before being passed
280
311
    # TODO: chop up this beast; make it a method of the Command
281
312
    args = []
282
313
    opts = {}
 
314
    alias_opts = {}
283
315
 
284
316
    cmd_options = command.options()
285
317
    argsover = False
286
 
    while argv:
287
 
        a = argv.pop(0)
288
 
        if argsover:
289
 
            args.append(a)
290
 
            continue
291
 
        elif a == '--':
292
 
            # We've received a standalone -- No more flags
293
 
            argsover = True
294
 
            continue
295
 
        if a[0] == '-':
296
 
            # option names must not be unicode
297
 
            a = str(a)
298
 
            optarg = None
299
 
            if a[1] == '-':
300
 
                mutter("  got option %r" % a)
301
 
                if '=' in a:
302
 
                    optname, optarg = a[2:].split('=', 1)
303
 
                else:
304
 
                    optname = a[2:]
305
 
                if optname not in cmd_options:
306
 
                    raise BzrCommandError('unknown long option %r for command %s' 
307
 
                            % (a, command.name()))
308
 
            else:
309
 
                shortopt = a[1:]
310
 
                if shortopt in Option.SHORT_OPTIONS:
311
 
                    # Multi-character options must have a space to delimit
312
 
                    # their value
313
 
                    # ^^^ what does this mean? mbp 20051014
314
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
315
 
                else:
316
 
                    # Single character short options, can be chained,
317
 
                    # and have their value appended to their name
318
 
                    shortopt = a[1:2]
319
 
                    if shortopt not in Option.SHORT_OPTIONS:
320
 
                        # We didn't find the multi-character name, and we
321
 
                        # didn't find the single char name
322
 
                        raise BzrError('unknown short option %r' % a)
323
 
                    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
324
359
 
325
 
                    if a[2:]:
326
 
                        # There are extra things on this option
327
 
                        # see if it is the value, or if it is another
328
 
                        # short option
329
 
                        optargfn = Option.OPTIONS[optname].type
330
 
                        if optargfn is None:
331
 
                            # This option does not take an argument, so the
332
 
                            # next entry is another short option, pack it back
333
 
                            # into the list
334
 
                            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)
335
399
                        else:
336
 
                            # This option takes an argument, so pack it
337
 
                            # into the array
338
 
                            optarg = a[2:]
339
 
            
340
 
            if optname in opts:
341
 
                # XXX: Do we ever want to support this, e.g. for -r?
342
 
                raise BzrError('repeated option %r' % a)
343
 
                
344
 
            option_obj = cmd_options[optname]
345
 
            optargfn = option_obj.type
346
 
            if optargfn:
347
 
                if optarg == None:
348
 
                    if not argv:
349
 
                        raise BzrError('option %r needs an argument' % a)
350
 
                    else:
351
 
                        optarg = argv.pop(0)
352
 
                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
353
410
            else:
354
 
                if optarg != None:
355
 
                    raise BzrError('option %r takes no argument' % optname)
356
 
                opts[optname] = True
357
 
        else:
358
 
            args.append(a)
 
411
                args.append(a)
 
412
        proc_aliasarg = False # Done with alias argv
359
413
    return args, opts
360
414
 
361
415
 
427
481
        os.remove(pfname)
428
482
 
429
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
 
430
507
def run_bzr(argv):
431
508
    """Execute a command.
432
509
 
444
521
    --no-plugins
445
522
        Do not load plugin modules at all
446
523
 
 
524
    --no-aliases
 
525
        Do not allow aliases
 
526
 
447
527
    --builtin
448
528
        Only use builtin commands.  (Plugins are still allowed to change
449
529
        other behaviour.)
450
530
 
451
531
    --profile
452
 
        Run under the Python profiler.
 
532
        Run under the Python hotshot profiler.
 
533
 
 
534
    --lsprof
 
535
        Run under the Python lsprof profiler.
453
536
    """
454
537
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
455
538
 
456
 
    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
457
542
 
458
543
    # --no-plugins is handled specially at a very early stage. We need
459
544
    # to load plugins before doing other command parsing so that they
460
545
    # can override commands, but this needs to happen first.
461
546
 
462
 
    for a in argv:
 
547
    argv_copy = []
 
548
    i = 0
 
549
    while i < len(argv):
 
550
        a = argv[i]
463
551
        if a == '--profile':
464
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
465
558
        elif a == '--no-plugins':
466
559
            opt_no_plugins = True
 
560
        elif a == '--no-aliases':
 
561
            opt_no_aliases = True
467
562
        elif a == '--builtin':
468
563
            opt_builtin = True
 
564
        elif a in ('--quiet', '-q'):
 
565
            be_quiet()
469
566
        else:
470
 
            break
471
 
        argv.remove(a)
 
567
            argv_copy.append(a)
 
568
        i += 1
472
569
 
473
 
    if (not argv) or (argv[0] == '--help'):
474
 
        from bzrlib.help import help
475
 
        if len(argv) > 1:
476
 
            help(argv[1])
477
 
        else:
478
 
            help()
 
570
    argv = argv_copy
 
571
    if (not argv):
 
572
        from bzrlib.builtins import cmd_help
 
573
        cmd_help().run_argv_aliases([])
479
574
        return 0
480
575
 
481
576
    if argv[0] == '--version':
486
581
    if not opt_no_plugins:
487
582
        from bzrlib.plugin import load_plugins
488
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)
489
595
 
490
596
    cmd = str(argv.pop(0))
491
597
 
492
598
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
493
 
 
494
 
    if opt_profile:
495
 
        ret = apply_profiled(cmd_obj.run_argv, argv)
 
599
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
600
        run = cmd_obj.run_argv
 
601
        run_argv = [argv]
496
602
    else:
497
 
        ret = cmd_obj.run_argv(argv)
498
 
    return ret or 0
 
603
        run = cmd_obj.run_argv_aliases
 
604
        run_argv = [argv, alias_argv]
 
605
 
 
606
    try:
 
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)
 
611
        else:
 
612
            ret = run(*run_argv)
 
613
        return ret or 0
 
614
    finally:
 
615
        # reset, in case we may do other commands later within the same process
 
616
        be_quiet(False)
499
617
 
500
618
def display_command(func):
 
619
    """Decorator that suppresses pipe/interrupt errors."""
501
620
    def ignore_pipe(*args, **kwargs):
502
621
        try:
503
 
            func(*args, **kwargs)
 
622
            result = func(*args, **kwargs)
 
623
            sys.stdout.flush()
 
624
            return result
504
625
        except IOError, e:
 
626
            if not hasattr(e, 'errno'):
 
627
                raise
505
628
            if e.errno != errno.EPIPE:
506
629
                raise
 
630
            pass
 
631
        except KeyboardInterrupt:
 
632
            pass
507
633
    return ignore_pipe
508
634
 
 
635
 
509
636
def main(argv):
510
637
    import bzrlib.ui
 
638
    from bzrlib.ui.text import TextUIFactory
 
639
    ## bzrlib.trace.enable_default_logging()
511
640
    bzrlib.trace.log_startup(argv)
512
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
513
 
 
514
 
    return run_bzr_catch_errors(argv[1:])
 
641
    bzrlib.ui.ui_factory = TextUIFactory()
 
642
    ret = run_bzr_catch_errors(argv[1:])
 
643
    mutter("return code %d", ret)
 
644
    return ret
515
645
 
516
646
 
517
647
def run_bzr_catch_errors(argv):
521
651
        finally:
522
652
            # do this here inside the exception wrappers to catch EPIPE
523
653
            sys.stdout.flush()
524
 
    except BzrCommandError, e:
525
 
        # command line syntax error, etc
526
 
        log_error(str(e))
527
 
        return 1
528
 
    except BzrError, e:
529
 
        bzrlib.trace.log_exception()
530
 
        return 1
531
 
    except AssertionError, e:
532
 
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
533
 
        return 3
534
 
    except KeyboardInterrupt, e:
535
 
        bzrlib.trace.log_exception('interrupted')
536
 
        return 2
537
654
    except Exception, e:
 
655
        # used to handle AssertionError and KeyboardInterrupt
 
656
        # specially here, but hopefully they're handled ok by the logger now
538
657
        import errno
539
658
        if (isinstance(e, IOError) 
540
659
            and hasattr(e, 'errno')
541
660
            and e.errno == errno.EPIPE):
542
661
            bzrlib.trace.note('broken pipe')
543
 
            return 2
 
662
            return 3
544
663
        else:
545
 
            ## import pdb
546
 
            ## pdb.pm()
547
664
            bzrlib.trace.log_exception()
548
 
            return 2
 
665
            if os.environ.get('BZR_PDB'):
 
666
                print '**** entering debugger'
 
667
                import pdb
 
668
                pdb.post_mortem(sys.exc_traceback)
 
669
            return 3
549
670
 
550
671
if __name__ == '__main__':
551
672
    sys.exit(main(sys.argv))