← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Aaron Bentley
  • Date: 2007-02-06 14:52:16 UTC
  • mfrom: (2266 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2268.
  • Revision ID: abentley@panoramicfeedback.com-20070206145216-fcpi8o3ufvuzwbp9
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006 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
21
20
import re
22
21
 
23
22
from bzrlib.lazy_import import lazy_import
24
23
lazy_import(globals(), """
 
24
import optparse
 
25
 
25
26
from bzrlib import (
26
27
    errors,
27
28
    revisionspec,
 
29
    symbol_versioning,
28
30
    )
29
31
""")
 
32
from bzrlib.trace import warning
30
33
 
31
 
from bzrlib import (
32
 
    log,
33
 
    registry,
34
 
    )
35
34
 
36
35
def _parse_revision_str(revstr):
37
36
    """This handles a revision string -> revno.
85
84
    [<RevisionSpec_branch branch:../../branch2>]
86
85
    >>> _parse_revision_str('branch:../../branch2..23')
87
86
    [<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>]
92
87
    """
93
88
    # TODO: Maybe move this into revisionspec.py
94
89
    revs = []
95
 
    # split on .. that is not followed by a / or \
96
 
    sep = re.compile(r'\.\.(?![\\/])')
 
90
    # split on the first .. that is not followed by a / ?
 
91
    sep = re.compile("\\.\\.(?!/)")
97
92
    for x in sep.split(revstr):
98
93
        revs.append(revisionspec.RevisionSpec.from_string(x or None))
99
94
    return revs
100
95
 
101
96
 
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
 
 
120
97
def _parse_merge_type(typestring):
121
98
    return get_merge_type(typestring)
122
99
 
141
118
    Otherwise None.
142
119
    """
143
120
 
144
 
    # The dictionary of standard options. These are always legal.
145
 
    STD_OPTIONS = {}
 
121
    # TODO: Some way to show in help a description of the option argument
146
122
 
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.
150
123
    OPTIONS = {}
151
124
 
152
125
    def __init__(self, name, help='', type=None, argname=None,
153
 
                 short_name=None, param_name=None, custom_callback=None):
 
126
                 short_name=None):
154
127
        """Make a new command option.
155
128
 
156
 
        :param name: regular name of the command, used in the double-dash
 
129
        name -- regular name of the command, used in the double-dash
157
130
            form and also as the parameter to the command's run() 
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 
 
131
            method.
 
132
 
 
133
        help -- help message displayed in command help
 
134
 
 
135
        type -- function called to parse the option argument, or 
163
136
            None (default) if this option doesn't take an argument.
164
137
 
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).
 
138
        argname -- name of option argument, if any
176
139
        """
177
140
        self.name = name
178
141
        self.help = help
179
142
        self.type = type
180
143
        self._short_name = short_name
181
144
        if type is None:
182
 
            if argname:
183
 
                raise ValueError('argname not valid for booleans')
 
145
            assert argname is None
184
146
        elif argname is None:
185
147
            argname = 'ARG'
186
148
        self.argname = argname
187
 
        if param_name is None:
188
 
            self._param_name = self.name
189
 
        else:
190
 
            self._param_name = param_name
191
 
        self.custom_callback = custom_callback
192
149
 
193
150
    def short_name(self):
194
151
        if self._short_name:
195
152
            return self._short_name
 
153
        else:
 
154
            # remove this when SHORT_OPTIONS is removed
 
155
            # XXX: This is accessing a DeprecatedDict, so we call the super 
 
156
            # method to avoid warnings
 
157
            for (k, v) in dict.iteritems(Option.SHORT_OPTIONS):
 
158
                if v == self:
 
159
                    return k
196
160
 
197
161
    def set_short_name(self, short_name):
198
162
        self._short_name = short_name
210
174
            option_strings.append('-%s' % short_name)
211
175
        optargfn = self.type
212
176
        if optargfn is None:
213
 
            parser.add_option(action='callback', 
214
 
                              callback=self._optparse_bool_callback, 
215
 
                              callback_args=(True,),
 
177
            parser.add_option(action='store_true', dest=self.name, 
216
178
                              help=self.help,
 
179
                              default=OptionParser.DEFAULT_VALUE,
217
180
                              *option_strings)
218
181
            negation_strings = ['--%s' % self.get_negation_name()]
219
 
            parser.add_option(action='callback', 
220
 
                              callback=self._optparse_bool_callback, 
221
 
                              callback_args=(False,),
 
182
            parser.add_option(action='store_false', dest=self.name, 
222
183
                              help=optparse.SUPPRESS_HELP, *negation_strings)
223
184
        else:
224
185
            parser.add_option(action='callback', 
228
189
                              default=OptionParser.DEFAULT_VALUE, 
229
190
                              *option_strings)
230
191
 
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
 
 
236
192
    def _optparse_callback(self, option, opt, value, parser):
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)
 
193
        setattr(parser.values, self.name, self.type(value))
241
194
 
242
195
    def iter_switches(self):
243
196
        """Iterate through the list of switches provided by the option
249
202
            argname = argname.upper()
250
203
        yield self.name, self.short_name(), argname, self.help
251
204
 
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
 
 
287
205
 
288
206
class RegistryOption(Option):
289
207
    """Option based on a registry
307
225
            return self.converter(value)
308
226
 
309
227
    def __init__(self, name, help, registry, converter=None,
310
 
        value_switches=False, title=None, enum_switch=True):
 
228
        value_switches=False):
311
229
        """
312
230
        Constructor.
313
231
 
317
235
        :param converter: Callable to invoke with the value name to produce
318
236
            the value.  If not supplied, self.registry.get is used.
319
237
        :param value_switches: If true, each possible value is assigned its
320
 
            own switch.  For example, instead of '--format knit',
321
 
            '--knit' can be used interchangeably.
322
 
        :param enum_switch: If true, a switch is provided with the option name,
323
 
            which takes a value.
 
238
            own switch.  For example, instead of '--format metaweave',
 
239
            '--metaweave' can be used interchangeably.
324
240
        """
325
241
        Option.__init__(self, name, help, type=self.convert)
326
242
        self.registry = registry
327
243
        self.name = name
328
244
        self.converter = converter
329
245
        self.value_switches = value_switches
330
 
        self.enum_switch = enum_switch
331
 
        self.title = title
332
 
        if self.title is None:
333
 
            self.title = name
334
 
 
335
 
    @staticmethod
336
 
    def from_kwargs(name_, help=None, title=None, value_switches=False,
337
 
                    enum_switch=True, **kwargs):
338
 
        """Convenience method to generate string-map registry options
339
 
 
340
 
        name, help, value_switches and enum_switch are passed to the
341
 
        RegistryOption constructor.  Any other keyword arguments are treated
342
 
        as values for the option, and they value is treated as the help.
343
 
        """
344
 
        reg = registry.Registry()
345
 
        for name, switch_help in kwargs.iteritems():
346
 
            name = name.replace('_', '-')
347
 
            reg.register(name, name, help=switch_help)
348
 
        return RegistryOption(name_, help, reg, title=title,
349
 
            value_switches=value_switches, enum_switch=enum_switch)
350
246
 
351
247
    def add_option(self, parser, short_name):
352
248
        """Add this option to an Optparse parser"""
353
 
        if self.value_switches:
354
 
            parser = parser.add_option_group(self.title)
355
 
        if self.enum_switch:
356
 
            Option.add_option(self, parser, short_name)
 
249
        Option.add_option(self, parser, short_name)
357
250
        if self.value_switches:
358
251
            for key in self.registry.keys():
359
252
                option_strings = ['--%s' % key]
360
 
                if self.is_hidden(key):
361
 
                    help = optparse.SUPPRESS_HELP
362
 
                else:
363
 
                    help = self.registry.get_help(key)
364
253
                parser.add_option(action='callback',
365
254
                              callback=self._optparse_value_callback(key),
366
 
                                  help=help,
 
255
                                  help=self.registry.get_help(key),
367
256
                                  *option_strings)
368
257
 
369
258
    def _optparse_value_callback(self, cb_value):
370
259
        def cb(option, opt, value, parser):
371
 
            v = self.type(cb_value)
372
 
            setattr(parser.values, self._param_name, v)
373
 
            if self.custom_callback is not None:
374
 
                self.custom_callback(option, self._param_name, v, parser)
 
260
            setattr(parser.values, self.name, self.type(cb_value))
375
261
        return cb
376
262
 
377
263
    def iter_switches(self):
385
271
            for key in sorted(self.registry.keys()):
386
272
                yield key, None, None, self.registry.get_help(key)
387
273
 
388
 
    def is_hidden(self, name):
389
 
        if name == self.name:
390
 
            return Option.is_hidden(self, name)
391
 
        return getattr(self.registry.get_info(name), 'hidden', False)
392
 
 
393
274
 
394
275
class OptionParser(optparse.OptionParser):
395
276
    """OptionParser that raises exceptions instead of exiting"""
410
291
    return parser
411
292
 
412
293
 
413
 
def custom_help(name, help):
414
 
    """Clone a common option overriding the help."""
415
 
    import copy
416
 
    o = copy.copy(Option.OPTIONS[name])
417
 
    o.help = help
418
 
    return o
419
 
 
420
 
 
421
 
def _standard_option(name, **kwargs):
422
 
    """Register a standard option."""
423
 
    # All standard options are implicitly 'global' ones
424
 
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
425
 
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
426
 
 
427
 
 
428
294
def _global_option(name, **kwargs):
429
 
    """Register a global option."""
 
295
    """Register o as a global option."""
430
296
    Option.OPTIONS[name] = Option(name, **kwargs)
431
297
 
432
 
 
433
 
def _global_registry_option(name, help, registry, **kwargs):
434
 
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
435
 
 
436
 
 
437
 
class MergeTypeRegistry(registry.Registry):
438
 
 
439
 
    pass
440
 
 
441
 
 
442
 
# This is the verbosity level detected during command line parsing.
443
 
# Note that the final value is dependent on the order in which the
444
 
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
445
 
# The final value will be one of the following:
446
 
#
447
 
# * -ve for quiet
448
 
# * 0 for normal
449
 
# * +ve for verbose
450
 
_verbosity_level = 0
451
 
 
452
 
 
453
 
def _verbosity_level_callback(option, opt_str, value, parser):
454
 
    global _verbosity_level
455
 
    if not value:
456
 
        # Either --no-verbose or --no-quiet was specified
457
 
        _verbosity_level = 0
458
 
    elif opt_str == "verbose":
459
 
        if _verbosity_level > 0:
460
 
            _verbosity_level += 1
461
 
        else:
462
 
            _verbosity_level = 1
463
 
    else:
464
 
        if _verbosity_level < 0:
465
 
            _verbosity_level -= 1
466
 
        else:
467
 
            _verbosity_level = -1
468
 
 
469
 
 
470
 
_merge_type_registry = MergeTypeRegistry()
471
 
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
472
 
                                   "Native diff3-style merge")
473
 
_merge_type_registry.register_lazy('diff3', 'bzrlib.merge', 'Diff3Merger',
474
 
                                   "Merge using external diff3")
475
 
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
476
 
                                   "Weave-based merge")
477
 
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
478
 
                                   "LCA-newness merge")
479
 
 
480
 
# Declare the standard options
481
 
_standard_option('help', short_name='h',
482
 
                 help='Show help message.')
483
 
_standard_option('verbose', short_name='v',
484
 
                 help='Display more information.',
485
 
                 custom_callback=_verbosity_level_callback)
486
 
_standard_option('quiet', short_name='q',
487
 
                 help="Only display errors and warnings.",
488
 
                 custom_callback=_verbosity_level_callback)
489
 
 
490
 
# Declare commonly used options
491
298
_global_option('all')
492
299
_global_option('overwrite', help='Ignore differences between branches and '
493
 
               'overwrite unconditionally.')
 
300
               'overwrite unconditionally')
494
301
_global_option('basis', type=str)
495
302
_global_option('bound')
496
303
_global_option('diff-options', type=str)
 
304
_global_option('help',
 
305
               help='show help message',
 
306
               short_name='h')
497
307
_global_option('file', type=unicode, short_name='F')
498
308
_global_option('force')
499
309
_global_option('format', type=unicode)
500
310
_global_option('forward')
501
311
_global_option('message', type=unicode,
502
 
               short_name='m',
503
 
               help='Message string.')
 
312
               short_name='m')
504
313
_global_option('no-recurse')
505
314
_global_option('profile',
506
 
               help='Show performance profiling information.')
 
315
               help='show performance profiling information')
507
316
_global_option('revision',
508
317
               type=_parse_revision_str,
509
318
               short_name='r',
510
 
               help='See "help revisionspec" for details.')
511
 
_global_option('change',
512
 
               type=_parse_change_str,
513
 
               short_name='c',
514
 
               param_name='revision',
515
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
516
 
_global_option('show-ids',
517
 
               help='Show internal object ids.')
 
319
               help='See \'help revisionspec\' for details')
 
320
_global_option('show-ids', 
 
321
               help='show internal object ids')
518
322
_global_option('timezone', 
519
323
               type=str,
520
324
               help='display timezone as local, original, or utc')
521
325
_global_option('unbound')
 
326
_global_option('verbose',
 
327
               help='display more information',
 
328
               short_name='v')
522
329
_global_option('version')
523
330
_global_option('email')
524
331
_global_option('update')
525
 
_global_registry_option('log-format', "Use specified log format.",
526
 
                        log.log_formatter_registry, value_switches=True,
527
 
                        title='Log format')
 
332
_global_option('log-format', type=str, help="Use this log format")
528
333
_global_option('long', help='Use detailed log format. Same as --log-format long',
529
334
               short_name='l')
530
335
_global_option('short', help='Use moderately short log format. Same as --log-format short')
531
336
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
532
337
_global_option('root', type=str)
533
338
_global_option('no-backup')
534
 
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
535
 
                        _merge_type_registry, value_switches=True,
536
 
                        title='Merge algorithm')
 
339
_global_option('merge-type', type=_parse_merge_type, 
 
340
               help='Select a particular merge algorithm')
537
341
_global_option('pattern', type=str)
 
342
_global_option('quiet', short_name='q')
538
343
_global_option('remember', help='Remember the specified location as a'
539
344
               ' default.')
540
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
 
345
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
541
346
_global_option('kind', type=str)
542
347
_global_option('dry-run',
543
 
               help="Show what would be done, but don't actually do anything.")
 
348
               help="show what would be done, but don't actually do anything")
544
349
_global_option('name-from-revision', help='The path name in the old tree.')
 
350
 
 
351
 
 
352
# prior to 0.14 these were always globally registered; the old dict is
 
353
# available for plugins that use it but it should not be used.
 
354
Option.SHORT_OPTIONS = symbol_versioning.DeprecatedDict(
 
355
    symbol_versioning.zero_fourteen,
 
356
    'SHORT_OPTIONS',
 
357
    {
 
358
        'F': Option.OPTIONS['file'],
 
359
        'h': Option.OPTIONS['help'],
 
360
        'm': Option.OPTIONS['message'],
 
361
        'r': Option.OPTIONS['revision'],
 
362
        'v': Option.OPTIONS['verbose'],
 
363
        'l': Option.OPTIONS['long'],
 
364
        'q': Option.OPTIONS['quiet'],
 
365
    },
 
366
    'Set the short option name when constructing the Option.',
 
367
    )