← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Aaron Bentley
  • Date: 2006-07-12 18:29:14 UTC
  • mto: This revision was merged to the branch mainline in revision 1934.
  • Revision ID: abentley@panoramicfeedback.com-20060712182914-07828d7ebd523ead
Use optparse for parsing options

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
28
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
29
# the profile output behind so it can be interactively examined?
30
30
 
31
 
import sys
 
31
import codecs
 
32
import errno
 
33
import optparse
32
34
import os
33
35
from warnings import warn
34
 
import errno
35
 
import codecs
 
36
import sys
36
37
 
37
38
import bzrlib
38
39
import bzrlib.errors as errors
261
262
            from bzrlib.help import help_on_command
262
263
            help_on_command(self.name())
263
264
            return 0
264
 
        # XXX: This should be handled by the parser
265
 
        allowed_names = self.options().keys()
266
 
        for oname in opts:
267
 
            if oname not in allowed_names:
268
 
                raise BzrOptionError("option '--%s' is not allowed for"
269
 
                                " command %r" % (oname, self.name()))
270
265
        # mix arguments and options into one dictionary
271
266
        cmdargs = _match_argform(self.name(), self.takes_args, args)
272
267
        cmdopts = {}
346
341
        parsed = [spec, None]
347
342
    return parsed
348
343
 
 
344
 
 
345
class OptionParser(optparse.OptionParser):
 
346
    """OptionParser that raises exceptions instead of exiting"""
 
347
 
 
348
    DEFAULT_VALUE = "DEFAULT"
 
349
 
 
350
    def error(self, message):
 
351
        raise BzrCommandError(message)
 
352
 
 
353
 
 
354
def get_optparser(options):
 
355
    """Generate an optparse parser for bzrlib-style options"""
 
356
    def type_callback(option, opt, value, parser, name, optargfn):
 
357
        setattr(parser.values, name, optargfn(value))
 
358
 
 
359
    parser = OptionParser()
 
360
    parser.remove_option('--help')
 
361
    short_options = dict((k.name, (v, k)) for v, k in 
 
362
                         Option.SHORT_OPTIONS.iteritems())
 
363
    for name, option in options.iteritems():
 
364
        option_strings = ['--%s' % name]
 
365
        if name in short_options:
 
366
            short_name, short_option = short_options[name]
 
367
            option_strings.append('-%s' % short_name)
 
368
        optargfn = option.type
 
369
        if optargfn is None:
 
370
            parser.add_option(action='store_true', dest=name, 
 
371
                              default=OptionParser.DEFAULT_VALUE, 
 
372
                              *option_strings)
 
373
        else:
 
374
            parser.add_option(action='callback', callback=type_callback, 
 
375
                              type='string',
 
376
                              default=OptionParser.DEFAULT_VALUE, 
 
377
                              callback_args=(name, optargfn), *option_strings)
 
378
    return parser
 
379
 
 
380
 
349
381
def parse_args(command, argv, alias_argv=None):
350
382
    """Parse command line.
351
383
    
354
386
    lookup table, something about the available options, what optargs
355
387
    they take, and which commands will accept them.
356
388
    """
357
 
    # TODO: chop up this beast; make it a method of the Command
358
 
    args = []
359
 
    opts = {}
360
 
    alias_opts = {}
361
 
 
362
 
    cmd_options = command.options()
 
389
    # TODO: make it a method of the Command?
 
390
    parser = get_optparser(command.options())
363
391
    argsover = False
364
 
    proc_aliasarg = True # Are we processing alias_argv now?
365
 
    for proc_argv in alias_argv, argv:
366
 
        while proc_argv:
367
 
            a = proc_argv.pop(0)
368
 
            if argsover:
369
 
                args.append(a)
370
 
                continue
371
 
            elif a == '-':
372
 
                args.append(a)
373
 
                continue
374
 
            elif a == '--':
375
 
                # We've received a standalone -- No more flags
376
 
                argsover = True
377
 
                continue
378
 
            if a[0] == '-':
379
 
                # option names must not be unicode
380
 
                a = str(a)
381
 
                optarg = None
382
 
                if a[1] == '-':
383
 
                    mutter("  got option %r", a)
384
 
                    if '=' in a:
385
 
                        optname, optarg = a[2:].split('=', 1)
386
 
                    else:
387
 
                        optname = a[2:]
388
 
                    if optname not in cmd_options:
389
 
                        raise BzrCommandError('unknown option "%s"' % a)
390
 
                else:
391
 
                    shortopt = a[1:]
392
 
                    if shortopt in Option.SHORT_OPTIONS:
393
 
                        # Multi-character options must have a space to delimit
394
 
                        # their value
395
 
                        # ^^^ what does this mean? mbp 20051014
396
 
                        optname = Option.SHORT_OPTIONS[shortopt].name
397
 
                    else:
398
 
                        # Single character short options, can be chained,
399
 
                        # and have their value appended to their name
400
 
                        shortopt = a[1:2]
401
 
                        if shortopt not in Option.SHORT_OPTIONS:
402
 
                            # We didn't find the multi-character name, and we
403
 
                            # didn't find the single char name
404
 
                            raise BzrCommandError('unknown option "%s"' % a)
405
 
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
392
    if alias_argv is not None:
 
393
        args = alias_argv + argv
 
394
    else:
 
395
        args = argv
406
396
 
407
 
                        if a[2:]:
408
 
                            # There are extra things on this option
409
 
                            # see if it is the value, or if it is another
410
 
                            # short option
411
 
                            optargfn = Option.OPTIONS[optname].type
412
 
                            if optargfn is None:
413
 
                                # This option does not take an argument, so the
414
 
                                # next entry is another short option, pack it
415
 
                                # back into the list
416
 
                                proc_argv.insert(0, '-' + a[2:])
417
 
                            else:
418
 
                                # This option takes an argument, so pack it
419
 
                                # into the array
420
 
                                optarg = a[2:]
421
 
                    if optname not in cmd_options:
422
 
                        raise BzrCommandError('unknown option "%s"' % shortopt)
423
 
                if optname in opts:
424
 
                    # XXX: Do we ever want to support this, e.g. for -r?
425
 
                    if proc_aliasarg:
426
 
                        raise BzrCommandError('repeated option %r' % a)
427
 
                    elif optname in alias_opts:
428
 
                        # Replace what's in the alias with what's in the real
429
 
                        # argument
430
 
                        del alias_opts[optname]
431
 
                        del opts[optname]
432
 
                        proc_argv.insert(0, a)
433
 
                        continue
434
 
                    else:
435
 
                        raise BzrCommandError('repeated option %r' % a)
436
 
                    
437
 
                option_obj = cmd_options[optname]
438
 
                optargfn = option_obj.type
439
 
                if optargfn:
440
 
                    if optarg == None:
441
 
                        if not proc_argv:
442
 
                            raise BzrCommandError('option %r needs an argument' % a)
443
 
                        else:
444
 
                            optarg = proc_argv.pop(0)
445
 
                    opts[optname] = optargfn(optarg)
446
 
                    if proc_aliasarg:
447
 
                        alias_opts[optname] = optargfn(optarg)
448
 
                else:
449
 
                    if optarg != None:
450
 
                        raise BzrCommandError('option %r takes no argument' % optname)
451
 
                    opts[optname] = True
452
 
                    if proc_aliasarg:
453
 
                        alias_opts[optname] = True
454
 
            else:
455
 
                args.append(a)
456
 
        proc_aliasarg = False # Done with alias argv
 
397
    options, args = parser.parse_args(args)
 
398
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if 
 
399
                 v is not OptionParser.DEFAULT_VALUE])
457
400
    return args, opts
458
401
 
459
402