← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Jelmer Vernooij
  • Date: 2009-01-28 18:42:55 UTC
  • mto: This revision was merged to the branch mainline in revision 3968.
  • Revision ID: jelmer@samba.org-20090128184255-bdmklkvm83ltk191
https://launchpad.net/bugs/321183
Update NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2004, 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
2
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
17
17
# TODO: For things like --diff-prefix, we want a way to customize the display
18
18
# of the option argument.
19
19
 
 
20
import optparse
20
21
import re
21
22
 
22
23
from bzrlib.lazy_import import lazy_import
23
24
lazy_import(globals(), """
24
 
import optparse
25
 
 
26
25
from bzrlib import (
27
26
    errors,
28
 
    log,
29
 
    registry,
30
27
    revisionspec,
31
 
    symbol_versioning,
32
28
    )
33
29
""")
34
 
from bzrlib.trace import warning
 
30
 
 
31
from bzrlib import (
 
32
    registry as _mod_registry,
 
33
    )
35
34
 
36
35
 
37
36
def _parse_revision_str(revstr):
86
85
    [<RevisionSpec_branch branch:../../branch2>]
87
86
    >>> _parse_revision_str('branch:../../branch2..23')
88
87
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
 
88
    >>> _parse_revision_str('branch:..\\\\branch2')
 
89
    [<RevisionSpec_branch branch:..\\branch2>]
 
90
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
 
91
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
89
92
    """
90
93
    # TODO: Maybe move this into revisionspec.py
91
94
    revs = []
92
 
    # split on the first .. that is not followed by a / ?
93
 
    sep = re.compile("\\.\\.(?!/)")
 
95
    # split on .. that is not followed by a / or \
 
96
    sep = re.compile(r'\.\.(?![\\/])')
94
97
    for x in sep.split(revstr):
95
98
        revs.append(revisionspec.RevisionSpec.from_string(x or None))
96
99
    return revs
97
100
 
98
101
 
 
102
def _parse_change_str(revstr):
 
103
    """Parse the revision string and return a tuple with left-most
 
104
    parent of the revision.
 
105
 
 
106
    >>> _parse_change_str('123')
 
107
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
 
108
    >>> _parse_change_str('123..124')
 
109
    Traceback (most recent call last):
 
110
      ...
 
111
    RangeInChangeOption: Option --change does not accept revision ranges
 
112
    """
 
113
    revs = _parse_revision_str(revstr)
 
114
    if len(revs) > 1:
 
115
        raise errors.RangeInChangeOption()
 
116
    return (revisionspec.RevisionSpec.from_string('before:' + revstr),
 
117
            revs[0])
 
118
 
 
119
 
99
120
def _parse_merge_type(typestring):
100
121
    return get_merge_type(typestring)
101
122
 
120
141
    Otherwise None.
121
142
    """
122
143
 
123
 
    # TODO: Some way to show in help a description of the option argument
 
144
    # The dictionary of standard options. These are always legal.
 
145
    STD_OPTIONS = {}
124
146
 
 
147
    # The dictionary of commonly used options. these are only legal
 
148
    # if a command explicitly references them by name in the list
 
149
    # of supported options.
125
150
    OPTIONS = {}
126
151
 
127
152
    def __init__(self, name, help='', type=None, argname=None,
128
 
                 short_name=None):
 
153
                 short_name=None, param_name=None, custom_callback=None):
129
154
        """Make a new command option.
130
155
 
131
 
        name -- regular name of the command, used in the double-dash
 
156
        :param name: regular name of the command, used in the double-dash
132
157
            form and also as the parameter to the command's run() 
133
 
            method.
134
 
 
135
 
        help -- help message displayed in command help
136
 
 
137
 
        type -- function called to parse the option argument, or 
 
158
            method (unless param_name is specified).
 
159
 
 
160
        :param help: help message displayed in command help
 
161
 
 
162
        :param type: function called to parse the option argument, or 
138
163
            None (default) if this option doesn't take an argument.
139
164
 
140
 
        argname -- name of option argument, if any
 
165
        :param argname: name of option argument, if any
 
166
 
 
167
        :param short_name: short option code for use with a single -, e.g.
 
168
            short_name="v" to enable parsing of -v.
 
169
 
 
170
        :param param_name: name of the parameter which will be passed to
 
171
            the command's run() method.
 
172
 
 
173
        :param custom_callback: a callback routine to be called after normal
 
174
            processing. The signature of the callback routine is
 
175
            (option, name, new_value, parser).
141
176
        """
142
177
        self.name = name
143
178
        self.help = help
144
179
        self.type = type
145
180
        self._short_name = short_name
146
181
        if type is None:
147
 
            assert argname is None
 
182
            if argname:
 
183
                raise ValueError('argname not valid for booleans')
148
184
        elif argname is None:
149
185
            argname = 'ARG'
150
186
        self.argname = argname
 
187
        if param_name is None:
 
188
            self._param_name = self.name.replace('-', '_')
 
189
        else:
 
190
            self._param_name = param_name
 
191
        self.custom_callback = custom_callback
151
192
 
152
193
    def short_name(self):
153
194
        if self._short_name:
154
195
            return self._short_name
155
 
        else:
156
 
            # remove this when SHORT_OPTIONS is removed
157
 
            # XXX: This is accessing a DeprecatedDict, so we call the super 
158
 
            # method to avoid warnings
159
 
            for (k, v) in dict.iteritems(Option.SHORT_OPTIONS):
160
 
                if v == self:
161
 
                    return k
162
196
 
163
197
    def set_short_name(self, short_name):
164
198
        self._short_name = short_name
176
210
            option_strings.append('-%s' % short_name)
177
211
        optargfn = self.type
178
212
        if optargfn is None:
179
 
            parser.add_option(action='store_true', dest=self.name, 
 
213
            parser.add_option(action='callback',
 
214
                              callback=self._optparse_bool_callback,
 
215
                              callback_args=(True,),
180
216
                              help=self.help,
181
 
                              default=OptionParser.DEFAULT_VALUE,
182
217
                              *option_strings)
183
218
            negation_strings = ['--%s' % self.get_negation_name()]
184
 
            parser.add_option(action='store_false', dest=self.name, 
 
219
            parser.add_option(action='callback',
 
220
                              callback=self._optparse_bool_callback,
 
221
                              callback_args=(False,),
185
222
                              help=optparse.SUPPRESS_HELP, *negation_strings)
186
223
        else:
187
 
            parser.add_option(action='callback', 
188
 
                              callback=self._optparse_callback, 
 
224
            parser.add_option(action='callback',
 
225
                              callback=self._optparse_callback,
189
226
                              type='string', metavar=self.argname.upper(),
190
227
                              help=self.help,
191
 
                              default=OptionParser.DEFAULT_VALUE, 
 
228
                              default=OptionParser.DEFAULT_VALUE,
192
229
                              *option_strings)
193
230
 
 
231
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
 
232
        setattr(parser.values, self._param_name, bool_v)
 
233
        if self.custom_callback is not None:
 
234
            self.custom_callback(option, self._param_name, bool_v, parser)
 
235
 
194
236
    def _optparse_callback(self, option, opt, value, parser):
195
 
        setattr(parser.values, self.name, self.type(value))
 
237
        v = self.type(value)
 
238
        setattr(parser.values, self._param_name, v)
 
239
        if self.custom_callback is not None:
 
240
            self.custom_callback(option, self.name, v, parser)
196
241
 
197
242
    def iter_switches(self):
198
243
        """Iterate through the list of switches provided by the option
204
249
            argname = argname.upper()
205
250
        yield self.name, self.short_name(), argname, self.help
206
251
 
 
252
    def is_hidden(self, name):
 
253
        return False
 
254
 
 
255
 
 
256
class ListOption(Option):
 
257
    """Option used to provide a list of values.
 
258
 
 
259
    On the command line, arguments are specified by a repeated use of the
 
260
    option. '-' is a special argument that resets the list. For example,
 
261
      --foo=a --foo=b
 
262
    sets the value of the 'foo' option to ['a', 'b'], and
 
263
      --foo=a --foo=b --foo=- --foo=c
 
264
    sets the value of the 'foo' option to ['c'].
 
265
    """
 
266
 
 
267
    def add_option(self, parser, short_name):
 
268
        """Add this option to an Optparse parser."""
 
269
        option_strings = ['--%s' % self.name]
 
270
        if short_name is not None:
 
271
            option_strings.append('-%s' % short_name)
 
272
        parser.add_option(action='callback',
 
273
                          callback=self._optparse_callback,
 
274
                          type='string', metavar=self.argname.upper(),
 
275
                          help=self.help, default=[],
 
276
                          *option_strings)
 
277
 
 
278
    def _optparse_callback(self, option, opt, value, parser):
 
279
        values = getattr(parser.values, self._param_name)
 
280
        if value == '-':
 
281
            del values[:]
 
282
        else:
 
283
            values.append(self.type(value))
 
284
        if self.custom_callback is not None:
 
285
            self.custom_callback(option, self._param_name, values, parser)
 
286
 
207
287
 
208
288
class RegistryOption(Option):
209
289
    """Option based on a registry
226
306
        else:
227
307
            return self.converter(value)
228
308
 
229
 
    def __init__(self, name, help, registry, converter=None,
230
 
        value_switches=False, title=None):
 
309
    def __init__(self, name, help, registry=None, converter=None,
 
310
        value_switches=False, title=None, enum_switch=True,
 
311
        lazy_registry=None):
231
312
        """
232
313
        Constructor.
233
314
 
239
320
        :param value_switches: If true, each possible value is assigned its
240
321
            own switch.  For example, instead of '--format knit',
241
322
            '--knit' can be used interchangeably.
 
323
        :param enum_switch: If true, a switch is provided with the option name,
 
324
            which takes a value.
 
325
        :param lazy_registry: A tuple of (module name, attribute name) for a
 
326
            registry to be lazily loaded.
242
327
        """
243
328
        Option.__init__(self, name, help, type=self.convert)
244
 
        self.registry = registry
 
329
        self._registry = registry
 
330
        if registry is None:
 
331
            if lazy_registry is None:
 
332
                raise AssertionError(
 
333
                    'One of registry or lazy_registry must be given.')
 
334
            self._lazy_registry = _mod_registry._LazyObjectGetter(
 
335
                *lazy_registry)
 
336
        if registry is not None and lazy_registry is not None:
 
337
            raise AssertionError(
 
338
                'registry and lazy_registry are mutually exclusive')
245
339
        self.name = name
246
340
        self.converter = converter
247
341
        self.value_switches = value_switches
 
342
        self.enum_switch = enum_switch
248
343
        self.title = title
249
344
        if self.title is None:
250
345
            self.title = name
251
346
 
 
347
    @property
 
348
    def registry(self):
 
349
        if self._registry is None:
 
350
            self._registry = self._lazy_registry.get_obj()
 
351
        return self._registry
 
352
    
 
353
    @staticmethod
 
354
    def from_kwargs(name_, help=None, title=None, value_switches=False,
 
355
                    enum_switch=True, **kwargs):
 
356
        """Convenience method to generate string-map registry options
 
357
 
 
358
        name, help, value_switches and enum_switch are passed to the
 
359
        RegistryOption constructor.  Any other keyword arguments are treated
 
360
        as values for the option, and they value is treated as the help.
 
361
        """
 
362
        reg = _mod_registry.Registry()
 
363
        for name, switch_help in kwargs.iteritems():
 
364
            name = name.replace('_', '-')
 
365
            reg.register(name, name, help=switch_help)
 
366
            if not value_switches:
 
367
                help = help + '  "' + name + '": ' + switch_help
 
368
                if not help.endswith("."):
 
369
                    help = help + "."
 
370
        return RegistryOption(name_, help, reg, title=title,
 
371
            value_switches=value_switches, enum_switch=enum_switch)
 
372
 
252
373
    def add_option(self, parser, short_name):
253
374
        """Add this option to an Optparse parser"""
254
375
        if self.value_switches:
255
376
            parser = parser.add_option_group(self.title)
256
 
        Option.add_option(self, parser, short_name)
 
377
        if self.enum_switch:
 
378
            Option.add_option(self, parser, short_name)
257
379
        if self.value_switches:
258
380
            for key in self.registry.keys():
259
381
                option_strings = ['--%s' % key]
 
382
                if self.is_hidden(key):
 
383
                    help = optparse.SUPPRESS_HELP
 
384
                else:
 
385
                    help = self.registry.get_help(key)
260
386
                parser.add_option(action='callback',
261
387
                              callback=self._optparse_value_callback(key),
262
 
                                  help=self.registry.get_help(key),
 
388
                                  help=help,
263
389
                                  *option_strings)
264
390
 
265
391
    def _optparse_value_callback(self, cb_value):
266
392
        def cb(option, opt, value, parser):
267
 
            setattr(parser.values, self.name, self.type(cb_value))
 
393
            v = self.type(cb_value)
 
394
            setattr(parser.values, self._param_name, v)
 
395
            if self.custom_callback is not None:
 
396
                self.custom_callback(option, self._param_name, v, parser)
268
397
        return cb
269
398
 
270
399
    def iter_switches(self):
278
407
            for key in sorted(self.registry.keys()):
279
408
                yield key, None, None, self.registry.get_help(key)
280
409
 
 
410
    def is_hidden(self, name):
 
411
        if name == self.name:
 
412
            return Option.is_hidden(self, name)
 
413
        return getattr(self.registry.get_info(name), 'hidden', False)
 
414
 
281
415
 
282
416
class OptionParser(optparse.OptionParser):
283
417
    """OptionParser that raises exceptions instead of exiting"""
298
432
    return parser
299
433
 
300
434
 
 
435
def custom_help(name, help):
 
436
    """Clone a common option overriding the help."""
 
437
    import copy
 
438
    o = copy.copy(Option.OPTIONS[name])
 
439
    o.help = help
 
440
    return o
 
441
 
 
442
 
 
443
def _standard_option(name, **kwargs):
 
444
    """Register a standard option."""
 
445
    # All standard options are implicitly 'global' ones
 
446
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
 
447
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
 
448
 
 
449
 
301
450
def _global_option(name, **kwargs):
302
 
    """Register o as a global option."""
 
451
    """Register a global option."""
303
452
    Option.OPTIONS[name] = Option(name, **kwargs)
304
453
 
305
454
 
306
 
def _global_registry_option(name, help, registry, **kwargs):
 
455
def _global_registry_option(name, help, registry=None, **kwargs):
307
456
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
308
457
 
309
458
 
310
 
class MergeTypeRegistry(registry.Registry):
 
459
# This is the verbosity level detected during command line parsing.
 
460
# Note that the final value is dependent on the order in which the
 
461
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
 
462
# The final value will be one of the following:
 
463
#
 
464
# * -ve for quiet
 
465
# * 0 for normal
 
466
# * +ve for verbose
 
467
_verbosity_level = 0
 
468
 
 
469
 
 
470
def _verbosity_level_callback(option, opt_str, value, parser):
 
471
    global _verbosity_level
 
472
    if not value:
 
473
        # Either --no-verbose or --no-quiet was specified
 
474
        _verbosity_level = 0
 
475
    elif opt_str == "verbose":
 
476
        if _verbosity_level > 0:
 
477
            _verbosity_level += 1
 
478
        else:
 
479
            _verbosity_level = 1
 
480
    else:
 
481
        if _verbosity_level < 0:
 
482
            _verbosity_level -= 1
 
483
        else:
 
484
            _verbosity_level = -1
 
485
 
 
486
 
 
487
class MergeTypeRegistry(_mod_registry.Registry):
311
488
 
312
489
    pass
313
490
 
319
496
                                   "Merge using external diff3")
320
497
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
321
498
                                   "Weave-based merge")
322
 
 
 
499
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
 
500
                                   "LCA-newness merge")
 
501
 
 
502
# Declare the standard options
 
503
_standard_option('help', short_name='h',
 
504
                 help='Show help message.')
 
505
_standard_option('verbose', short_name='v',
 
506
                 help='Display more information.',
 
507
                 custom_callback=_verbosity_level_callback)
 
508
_standard_option('quiet', short_name='q',
 
509
                 help="Only display errors and warnings.",
 
510
                 custom_callback=_verbosity_level_callback)
 
511
 
 
512
# Declare commonly used options
323
513
_global_option('all')
324
514
_global_option('overwrite', help='Ignore differences between branches and '
325
 
               'overwrite unconditionally')
 
515
               'overwrite unconditionally.')
326
516
_global_option('basis', type=str)
327
517
_global_option('bound')
328
518
_global_option('diff-options', type=str)
329
 
_global_option('help',
330
 
               help='show help message',
331
 
               short_name='h')
332
519
_global_option('file', type=unicode, short_name='F')
333
520
_global_option('force')
334
521
_global_option('format', type=unicode)
335
522
_global_option('forward')
336
523
_global_option('message', type=unicode,
337
 
               short_name='m')
 
524
               short_name='m',
 
525
               help='Message string.')
338
526
_global_option('no-recurse')
339
527
_global_option('profile',
340
 
               help='show performance profiling information')
 
528
               help='Show performance profiling information.')
341
529
_global_option('revision',
342
530
               type=_parse_revision_str,
343
531
               short_name='r',
344
 
               help='See \'help revisionspec\' for details')
345
 
_global_option('show-ids', 
346
 
               help='show internal object ids')
347
 
_global_option('timezone', 
 
532
               help='See "help revisionspec" for details.')
 
533
_global_option('change',
 
534
               type=_parse_change_str,
 
535
               short_name='c',
 
536
               param_name='revision',
 
537
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
 
538
_global_option('show-ids',
 
539
               help='Show internal object ids.')
 
540
_global_option('timezone',
348
541
               type=str,
349
 
               help='display timezone as local, original, or utc')
 
542
               help='Display timezone as local, original, or utc.')
350
543
_global_option('unbound')
351
 
_global_option('verbose',
352
 
               help='display more information',
353
 
               short_name='v')
354
544
_global_option('version')
355
545
_global_option('email')
356
546
_global_option('update')
357
 
_global_registry_option('log-format', "Use this log format",
358
 
                        log.log_formatter_registry, value_switches=True,
359
 
                        title='Log format')
 
547
_global_registry_option('log-format', "Use specified log format.",
 
548
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
 
549
                        value_switches=True, title='Log format')
360
550
_global_option('long', help='Use detailed log format. Same as --log-format long',
361
551
               short_name='l')
362
552
_global_option('short', help='Use moderately short log format. Same as --log-format short')
363
553
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
364
554
_global_option('root', type=str)
365
555
_global_option('no-backup')
366
 
_global_registry_option('merge-type', 'Select a particular merge algorithm',
 
556
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
367
557
                        _merge_type_registry, value_switches=True,
368
558
                        title='Merge algorithm')
369
559
_global_option('pattern', type=str)
370
 
_global_option('quiet', short_name='q')
371
560
_global_option('remember', help='Remember the specified location as a'
372
561
               ' default.')
373
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
 
562
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
374
563
_global_option('kind', type=str)
375
564
_global_option('dry-run',
376
 
               help="show what would be done, but don't actually do anything")
 
565
               help="Show what would be done, but don't actually do anything.")
377
566
_global_option('name-from-revision', help='The path name in the old tree.')
378
567
 
379
 
 
380
 
# prior to 0.14 these were always globally registered; the old dict is
381
 
# available for plugins that use it but it should not be used.
382
 
Option.SHORT_OPTIONS = symbol_versioning.DeprecatedDict(
383
 
    symbol_versioning.zero_fourteen,
384
 
    'SHORT_OPTIONS',
385
 
    {
386
 
        'F': Option.OPTIONS['file'],
387
 
        'h': Option.OPTIONS['help'],
388
 
        'm': Option.OPTIONS['message'],
389
 
        'r': Option.OPTIONS['revision'],
390
 
        'v': Option.OPTIONS['verbose'],
391
 
        'l': Option.OPTIONS['long'],
392
 
        'q': Option.OPTIONS['quiet'],
393
 
    },
394
 
    'Set the short option name when constructing the Option.',
395
 
    )
 
568
diff_writer_registry = _mod_registry.Registry()
 
569
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
 
570
diff_writer_registry.default_key = 'plain'