~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

remove diff.py shebang

Show diffs side-by-side

added added

removed removed

Lines of Context:
24
24
# Those objects can specify the expected type of the argument, which
25
25
# would help with validation and shell completion.
26
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?
 
27
 
 
28
# TODO: Help messages for options.
 
29
 
 
30
# TODO: Define arguments by objects, rather than just using names.
 
31
# Those objects can specify the expected type of the argument, which
 
32
# would help with validation and shell completion.
 
33
 
 
34
 
29
35
 
30
36
import sys
31
37
import os
32
38
from warnings import warn
33
39
from inspect import getdoc
34
 
import errno
35
40
 
36
41
import bzrlib
37
42
import bzrlib.trace
38
 
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
39
 
from bzrlib.errors import (BzrError, 
40
 
                           BzrCheckError,
41
 
                           BzrCommandError,
42
 
                           BzrOptionError,
43
 
                           NotBranchError)
44
 
from bzrlib.revisionspec import RevisionSpec
 
43
from bzrlib.trace import mutter, note, log_error, warning
 
44
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
 
45
from bzrlib.branch import find_branch
45
46
from bzrlib import BZRDIR
46
 
from bzrlib.option import Option
47
47
 
48
48
plugin_cmds = {}
49
49
 
50
50
 
51
 
def register_command(cmd, decorate=False):
 
51
def register_command(cmd):
52
52
    "Utility function to help register a command"
53
53
    global plugin_cmds
54
54
    k = cmd.__name__
59
59
    if not plugin_cmds.has_key(k_unsquished):
60
60
        plugin_cmds[k_unsquished] = cmd
61
61
        mutter('registered plugin command %s', k_unsquished)      
62
 
        if decorate and k_unsquished in builtin_command_names():
63
 
            return _builtin_commands()[k_unsquished]
64
 
    elif decorate:
65
 
        result = plugin_cmds[k_unsquished]
66
 
        plugin_cmds[k_unsquished] = cmd
67
 
        return result
68
62
    else:
69
63
        log_error('Two plugins defined the same command: %r' % k)
70
64
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
79
73
    return cmd[4:].replace('_','-')
80
74
 
81
75
 
 
76
def _parse_revision_str(revstr):
 
77
    """This handles a revision string -> revno.
 
78
 
 
79
    This always returns a list.  The list will have one element for 
 
80
 
 
81
    It supports integers directly, but everything else it
 
82
    defers for passing to Branch.get_revision_info()
 
83
 
 
84
    >>> _parse_revision_str('234')
 
85
    [234]
 
86
    >>> _parse_revision_str('234..567')
 
87
    [234, 567]
 
88
    >>> _parse_revision_str('..')
 
89
    [None, None]
 
90
    >>> _parse_revision_str('..234')
 
91
    [None, 234]
 
92
    >>> _parse_revision_str('234..')
 
93
    [234, None]
 
94
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
 
95
    [234, 456, 789]
 
96
    >>> _parse_revision_str('234....789') # Error?
 
97
    [234, None, 789]
 
98
    >>> _parse_revision_str('revid:test@other.com-234234')
 
99
    ['revid:test@other.com-234234']
 
100
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
 
101
    ['revid:test@other.com-234234', 'revid:test@other.com-234235']
 
102
    >>> _parse_revision_str('revid:test@other.com-234234..23')
 
103
    ['revid:test@other.com-234234', 23]
 
104
    >>> _parse_revision_str('date:2005-04-12')
 
105
    ['date:2005-04-12']
 
106
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
 
107
    ['date:2005-04-12 12:24:33']
 
108
    >>> _parse_revision_str('date:2005-04-12T12:24:33')
 
109
    ['date:2005-04-12T12:24:33']
 
110
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
 
111
    ['date:2005-04-12,12:24:33']
 
112
    >>> _parse_revision_str('-5..23')
 
113
    [-5, 23]
 
114
    >>> _parse_revision_str('-5')
 
115
    [-5]
 
116
    >>> _parse_revision_str('123a')
 
117
    ['123a']
 
118
    >>> _parse_revision_str('abc')
 
119
    ['abc']
 
120
    """
 
121
    import re
 
122
    old_format_re = re.compile('\d*:\d*')
 
123
    m = old_format_re.match(revstr)
 
124
    if m:
 
125
        warning('Colon separator for revision numbers is deprecated.'
 
126
                ' Use .. instead')
 
127
        revs = []
 
128
        for rev in revstr.split(':'):
 
129
            if rev:
 
130
                revs.append(int(rev))
 
131
            else:
 
132
                revs.append(None)
 
133
        return revs
 
134
    revs = []
 
135
    for x in revstr.split('..'):
 
136
        if not x:
 
137
            revs.append(None)
 
138
        else:
 
139
            try:
 
140
                revs.append(int(x))
 
141
            except ValueError:
 
142
                revs.append(x)
 
143
    return revs
 
144
 
 
145
 
 
146
def get_merge_type(typestring):
 
147
    """Attempt to find the merge class/factory associated with a string."""
 
148
    from merge import merge_types
 
149
    try:
 
150
        return merge_types[typestring][0]
 
151
    except KeyError:
 
152
        templ = '%s%%7s: %%s' % (' '*12)
 
153
        lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
 
154
        type_list = '\n'.join(lines)
 
155
        msg = "No known merge type %s. Supported types are:\n%s" %\
 
156
            (typestring, type_list)
 
157
        raise BzrCommandError(msg)
 
158
 
 
159
 
82
160
def _builtin_commands():
83
161
    import bzrlib.builtins
84
162
    r = {}
168
246
        List of argument forms, marked with whether they are optional,
169
247
        repeated, etc.
170
248
 
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
178
 
 
179
249
    takes_options
180
 
        List of options that may be given for this command.  These can
181
 
        be either strings, referring to globally-defined options,
182
 
        or option objects.  Retrieve through options().
 
250
        List of options that may be given for this command.
183
251
 
184
252
    hidden
185
253
        If true, this command isn't advertised.  This is typically
186
254
        for commands intended for expert users.
187
255
    """
188
256
    aliases = []
 
257
    
189
258
    takes_args = []
190
259
    takes_options = []
191
260
 
196
265
        if self.__doc__ == Command.__doc__:
197
266
            warn("No help message set for %r" % self)
198
267
 
199
 
    def options(self):
200
 
        """Return dict of valid options for this command.
201
 
 
202
 
        Maps from long option name to option object."""
203
 
        r = dict()
204
 
        r['help'] = Option.OPTIONS['help']
205
 
        for o in self.takes_options:
206
 
            if not isinstance(o, Option):
207
 
                o = Option.OPTIONS[o]
208
 
            r[o.name] = o
209
 
        return r
210
268
 
211
269
    def run_argv(self, argv):
212
270
        """Parse command line and run."""
213
 
        args, opts = parse_args(self, argv)
 
271
        args, opts = parse_args(argv)
 
272
 
214
273
        if 'help' in opts:  # e.g. bzr add --help
215
274
            from bzrlib.help import help_on_command
216
275
            help_on_command(self.name())
217
276
            return 0
218
 
        # XXX: This should be handled by the parser
219
 
        allowed_names = self.options().keys()
 
277
 
 
278
        # check options are reasonable
 
279
        allowed = self.takes_options
220
280
        for oname in opts:
221
 
            if oname not in allowed_names:
 
281
            if oname not in allowed:
222
282
                raise BzrCommandError("option '--%s' is not allowed for command %r"
223
283
                                      % (oname, self.name()))
 
284
 
224
285
        # mix arguments and options into one dictionary
225
286
        cmdargs = _match_argform(self.name(), self.takes_args, args)
226
287
        cmdopts = {}
231
292
        all_cmd_args.update(cmdopts)
232
293
 
233
294
        return self.run(**all_cmd_args)
 
295
 
234
296
    
235
297
    def run(self):
236
298
        """Actually run the command.
286
348
        parsed = [spec, None]
287
349
    return parsed
288
350
 
289
 
def parse_args(command, argv):
 
351
 
 
352
# list of all available options; the rhs can be either None for an
 
353
# option that takes no argument, or a constructor function that checks
 
354
# the type.
 
355
OPTIONS = {
 
356
    'all':                    None,
 
357
    'diff-options':           str,
 
358
    'help':                   None,
 
359
    'file':                   unicode,
 
360
    'force':                  None,
 
361
    'format':                 unicode,
 
362
    'forward':                None,
 
363
    'message':                unicode,
 
364
    'no-recurse':             None,
 
365
    'profile':                None,
 
366
    'revision':               _parse_revision_str,
 
367
    'short':                  None,
 
368
    'show-ids':               None,
 
369
    'timezone':               str,
 
370
    'verbose':                None,
 
371
    'version':                None,
 
372
    'email':                  None,
 
373
    'unchanged':              None,
 
374
    'update':                 None,
 
375
    'long':                   None,
 
376
    'root':                   str,
 
377
    'no-backup':              None,
 
378
    'merge-type':             get_merge_type,
 
379
    'pattern':                str,
 
380
    }
 
381
 
 
382
SHORT_OPTIONS = {
 
383
    'F':                      'file', 
 
384
    'h':                      'help',
 
385
    'm':                      'message',
 
386
    'r':                      'revision',
 
387
    'v':                      'verbose',
 
388
    'l':                      'long',
 
389
}
 
390
 
 
391
 
 
392
def parse_args(argv):
290
393
    """Parse command line.
291
394
    
292
395
    Arguments and options are parsed at this level before being passed
293
396
    down to specific command handlers.  This routine knows, from a
294
397
    lookup table, something about the available options, what optargs
295
398
    they take, and which commands will accept them.
 
399
 
 
400
    >>> parse_args('--help'.split())
 
401
    ([], {'help': True})
 
402
    >>> parse_args('help -- --invalidcmd'.split())
 
403
    (['help', '--invalidcmd'], {})
 
404
    >>> parse_args('--version'.split())
 
405
    ([], {'version': True})
 
406
    >>> parse_args('status --all'.split())
 
407
    (['status'], {'all': True})
 
408
    >>> parse_args('commit --message=biter'.split())
 
409
    (['commit'], {'message': u'biter'})
 
410
    >>> parse_args('log -r 500'.split())
 
411
    (['log'], {'revision': [500]})
 
412
    >>> parse_args('log -r500..600'.split())
 
413
    (['log'], {'revision': [500, 600]})
 
414
    >>> parse_args('log -vr500..600'.split())
 
415
    (['log'], {'verbose': True, 'revision': [500, 600]})
 
416
    >>> parse_args('log -rv500..600'.split()) #the r takes an argument
 
417
    (['log'], {'revision': ['v500', 600]})
296
418
    """
297
 
    # TODO: chop up this beast; make it a method of the Command
298
419
    args = []
299
420
    opts = {}
300
421
 
301
 
    cmd_options = command.options()
302
422
    argsover = False
303
423
    while argv:
304
424
        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] == '-':
 
425
        if not argsover and a[0] == '-':
313
426
            # option names must not be unicode
314
427
            a = str(a)
315
428
            optarg = None
316
429
            if a[1] == '-':
317
 
                mutter("  got option %r", a)
 
430
                if a == '--':
 
431
                    # We've received a standalone -- No more flags
 
432
                    argsover = True
 
433
                    continue
 
434
                mutter("  got option %r" % a)
318
435
                if '=' in a:
319
436
                    optname, optarg = a[2:].split('=', 1)
320
437
                else:
321
438
                    optname = a[2:]
322
 
                if optname not in cmd_options:
323
 
                    raise BzrOptionError('unknown long option %r for command %s'
324
 
                        % (a, command.name()))
 
439
                if optname not in OPTIONS:
 
440
                    raise BzrError('unknown long option %r' % a)
325
441
            else:
326
442
                shortopt = a[1:]
327
 
                if shortopt in Option.SHORT_OPTIONS:
 
443
                if shortopt in SHORT_OPTIONS:
328
444
                    # Multi-character options must have a space to delimit
329
445
                    # their value
330
 
                    # ^^^ what does this mean? mbp 20051014
331
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
446
                    optname = SHORT_OPTIONS[shortopt]
332
447
                else:
333
448
                    # Single character short options, can be chained,
334
449
                    # and have their value appended to their name
335
450
                    shortopt = a[1:2]
336
 
                    if shortopt not in Option.SHORT_OPTIONS:
 
451
                    if shortopt not in SHORT_OPTIONS:
337
452
                        # We didn't find the multi-character name, and we
338
453
                        # didn't find the single char name
339
454
                        raise BzrError('unknown short option %r' % a)
340
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
455
                    optname = SHORT_OPTIONS[shortopt]
341
456
 
342
457
                    if a[2:]:
343
458
                        # There are extra things on this option
344
459
                        # see if it is the value, or if it is another
345
460
                        # short option
346
 
                        optargfn = Option.OPTIONS[optname].type
 
461
                        optargfn = OPTIONS[optname]
347
462
                        if optargfn is None:
348
463
                            # This option does not take an argument, so the
349
464
                            # next entry is another short option, pack it back
354
469
                            # into the array
355
470
                            optarg = a[2:]
356
471
            
357
 
                if optname not in cmd_options:
358
 
                    raise BzrOptionError('unknown short option %r for command'
359
 
                        ' %s' % (shortopt, command.name()))
360
472
            if optname in opts:
361
473
                # XXX: Do we ever want to support this, e.g. for -r?
362
474
                raise BzrError('repeated option %r' % a)
363
475
                
364
 
            option_obj = cmd_options[optname]
365
 
            optargfn = option_obj.type
 
476
            optargfn = OPTIONS[optname]
366
477
            if optargfn:
367
478
                if optarg == None:
368
479
                    if not argv:
376
487
                opts[optname] = True
377
488
        else:
378
489
            args.append(a)
 
490
 
379
491
    return args, opts
380
492
 
381
493
 
 
494
 
 
495
 
382
496
def _match_argform(cmd, takes_args, args):
383
497
    argdict = {}
384
498
 
427
541
def apply_profiled(the_callable, *args, **kwargs):
428
542
    import hotshot
429
543
    import tempfile
430
 
    import hotshot.stats
431
544
    pffileno, pfname = tempfile.mkstemp()
432
545
    try:
433
546
        prof = hotshot.Profile(pfname)
435
548
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
436
549
        finally:
437
550
            prof.close()
 
551
 
 
552
        import hotshot.stats
438
553
        stats = hotshot.stats.load(pfname)
439
 
        stats.strip_dirs()
440
 
        stats.sort_stats('cum')   # 'time'
 
554
        #stats.strip_dirs()
 
555
        stats.sort_stats('time')
441
556
        ## XXX: Might like to write to stderr or the trace file instead but
442
557
        ## print_stats seems hardcoded to stdout
443
558
        stats.print_stats(20)
 
559
 
444
560
        return ret
445
561
    finally:
446
562
        os.close(pffileno)
447
563
        os.remove(pfname)
448
564
 
449
565
 
450
 
def apply_lsprofiled(the_callable, *args, **kwargs):
451
 
    from bzrlib.lsprof import profile
452
 
    ret,stats = profile(the_callable,*args,**kwargs)
453
 
    stats.sort()
454
 
    stats.pprint()
455
 
    return ret
456
 
 
457
566
def run_bzr(argv):
458
567
    """Execute a command.
459
568
 
476
585
        other behaviour.)
477
586
 
478
587
    --profile
479
 
        Run under the Python hotshot profiler.
480
 
 
481
 
    --lsprof
482
 
        Run under the Python lsprof profiler.
 
588
        Run under the Python profiler.
483
589
    """
 
590
    
484
591
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
485
592
 
486
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = False
 
593
    opt_profile = opt_no_plugins = opt_builtin = False
487
594
 
488
595
    # --no-plugins is handled specially at a very early stage. We need
489
596
    # to load plugins before doing other command parsing so that they
492
599
    for a in argv:
493
600
        if a == '--profile':
494
601
            opt_profile = True
495
 
        elif a == '--lsprof':
496
 
            opt_lsprof = True
497
602
        elif a == '--no-plugins':
498
603
            opt_no_plugins = True
499
604
        elif a == '--builtin':
500
605
            opt_builtin = True
501
 
        elif a in ('--quiet', '-q'):
502
 
            be_quiet()
503
606
        else:
504
 
            continue
 
607
            break
505
608
        argv.remove(a)
506
609
 
507
610
    if (not argv) or (argv[0] == '--help'):
525
628
 
526
629
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
527
630
 
528
 
    try:
529
 
        if opt_lsprof:
530
 
            ret = apply_lsprofiled(cmd_obj.run_argv, argv)
531
 
        elif opt_profile:
532
 
            ret = apply_profiled(cmd_obj.run_argv, argv)
533
 
        else:
534
 
            ret = cmd_obj.run_argv(argv)
535
 
        return ret or 0
536
 
    finally:
537
 
        # reset, in case we may do other commands later within the same process
538
 
        be_quiet(False)
539
 
 
540
 
def display_command(func):
541
 
    """Decorator that suppresses pipe/interrupt errors."""
542
 
    def ignore_pipe(*args, **kwargs):
543
 
        try:
544
 
            result = func(*args, **kwargs)
545
 
            sys.stdout.flush()
546
 
            return result
547
 
        except IOError, e:
548
 
            if not hasattr(e, 'errno'):
549
 
                raise
550
 
            if e.errno != errno.EPIPE:
551
 
                raise
552
 
            pass
553
 
        except KeyboardInterrupt:
554
 
            pass
555
 
    return ignore_pipe
 
631
    if opt_profile:
 
632
        ret = apply_profiled(cmd_obj.run_argv, argv)
 
633
    else:
 
634
        ret = cmd_obj.run_argv(argv)
 
635
    return ret or 0
556
636
 
557
637
 
558
638
def main(argv):
559
639
    import bzrlib.ui
560
 
    from bzrlib.ui.text import TextUIFactory
561
 
    ## bzrlib.trace.enable_default_logging()
562
640
    bzrlib.trace.log_startup(argv)
563
 
    bzrlib.ui.ui_factory = TextUIFactory()
564
 
    ret = run_bzr_catch_errors(argv[1:])
565
 
    mutter("return code %d", ret)
566
 
    return ret
567
 
 
568
 
 
569
 
def run_bzr_catch_errors(argv):
 
641
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
 
642
 
570
643
    try:
571
644
        try:
572
 
            return run_bzr(argv)
573
 
        finally:
574
 
            # do this here inside the exception wrappers to catch EPIPE
575
 
            sys.stdout.flush()
 
645
            try:
 
646
                return run_bzr(argv[1:])
 
647
            finally:
 
648
                # do this here inside the exception wrappers to catch EPIPE
 
649
                sys.stdout.flush()
 
650
        #wrap common errors as CommandErrors.
 
651
        except (NotBranchError,), e:
 
652
            raise BzrCommandError(str(e))
 
653
    except BzrCommandError, e:
 
654
        # command line syntax error, etc
 
655
        log_error(str(e))
 
656
        return 1
 
657
    except BzrError, e:
 
658
        bzrlib.trace.log_exception()
 
659
        return 1
 
660
    except AssertionError, e:
 
661
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
 
662
        return 3
 
663
    except KeyboardInterrupt, e:
 
664
        bzrlib.trace.note('interrupted')
 
665
        return 2
576
666
    except Exception, e:
577
 
        # used to handle AssertionError and KeyboardInterrupt
578
 
        # specially here, but hopefully they're handled ok by the logger now
579
667
        import errno
580
668
        if (isinstance(e, IOError) 
581
669
            and hasattr(e, 'errno')
582
670
            and e.errno == errno.EPIPE):
583
671
            bzrlib.trace.note('broken pipe')
584
 
            return 3
 
672
            return 2
585
673
        else:
586
674
            bzrlib.trace.log_exception()
587
 
            if os.environ.get('BZR_PDB'):
588
 
                print '**** entering debugger'
589
 
                import pdb
590
 
                pdb.post_mortem(sys.exc_traceback)
591
 
            return 3
 
675
            return 2
 
676
 
592
677
 
593
678
if __name__ == '__main__':
594
679
    sys.exit(main(sys.argv))