← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Robert Collins
  • Date: 2009-07-07 04:32:13 UTC
  • mto: This revision was merged to the branch mainline in revision 4524.
  • Revision ID: robertc@robertcollins.net-20090707043213-4hjjhgr40iq7gk2d
More informative assertions in xml serialisation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
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
 
115
136
 
116
137
class Option(object):
117
138
    """Description of a command line option
118
 
    
 
139
 
119
140
    :ivar _short_name: If this option has a single-letter name, this is it.
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,
 
154
                 hidden=False):
129
155
        """Make a new command option.
130
156
 
131
 
        name -- regular name of the command, used in the double-dash
132
 
            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 
 
157
        :param name: regular name of the command, used in the double-dash
 
158
            form and also as the parameter to the command's run()
 
159
            method (unless param_name is specified).
 
160
 
 
161
        :param help: help message displayed in command help
 
162
 
 
163
        :param type: function called to parse the option argument, or
138
164
            None (default) if this option doesn't take an argument.
139
165
 
140
 
        argname -- name of option argument, if any
 
166
        :param argname: name of option argument, if any
 
167
 
 
168
        :param short_name: short option code for use with a single -, e.g.
 
169
            short_name="v" to enable parsing of -v.
 
170
 
 
171
        :param param_name: name of the parameter which will be passed to
 
172
            the command's run() method.
 
173
 
 
174
        :param custom_callback: a callback routine to be called after normal
 
175
            processing. The signature of the callback routine is
 
176
            (option, name, new_value, parser).
 
177
        :param hidden: If True, the option should be hidden in help and
 
178
            documentation.
141
179
        """
142
180
        self.name = name
143
181
        self.help = help
144
182
        self.type = type
145
183
        self._short_name = short_name
146
184
        if type is None:
147
 
            assert argname is None
 
185
            if argname:
 
186
                raise ValueError('argname not valid for booleans')
148
187
        elif argname is None:
149
188
            argname = 'ARG'
150
189
        self.argname = argname
 
190
        if param_name is None:
 
191
            self._param_name = self.name.replace('-', '_')
 
192
        else:
 
193
            self._param_name = param_name
 
194
        self.custom_callback = custom_callback
 
195
        self.hidden = hidden
151
196
 
152
197
    def short_name(self):
153
198
        if self._short_name:
167
212
        option_strings = ['--%s' % self.name]
168
213
        if short_name is not None:
169
214
            option_strings.append('-%s' % short_name)
 
215
        if self.hidden:
 
216
            help = optparse.SUPPRESS_HELP
 
217
        else:
 
218
            help = self.help
170
219
        optargfn = self.type
171
220
        if optargfn is None:
172
 
            parser.add_option(action='store_true', dest=self.name, 
173
 
                              help=self.help,
174
 
                              default=OptionParser.DEFAULT_VALUE,
 
221
            parser.add_option(action='callback',
 
222
                              callback=self._optparse_bool_callback,
 
223
                              callback_args=(True,),
 
224
                              help=help,
175
225
                              *option_strings)
176
226
            negation_strings = ['--%s' % self.get_negation_name()]
177
 
            parser.add_option(action='store_false', dest=self.name, 
 
227
            parser.add_option(action='callback',
 
228
                              callback=self._optparse_bool_callback,
 
229
                              callback_args=(False,),
178
230
                              help=optparse.SUPPRESS_HELP, *negation_strings)
179
231
        else:
180
 
            parser.add_option(action='callback', 
181
 
                              callback=self._optparse_callback, 
 
232
            parser.add_option(action='callback',
 
233
                              callback=self._optparse_callback,
182
234
                              type='string', metavar=self.argname.upper(),
183
 
                              help=self.help,
184
 
                              default=OptionParser.DEFAULT_VALUE, 
 
235
                              help=help,
 
236
                              default=OptionParser.DEFAULT_VALUE,
185
237
                              *option_strings)
186
238
 
 
239
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
 
240
        setattr(parser.values, self._param_name, bool_v)
 
241
        if self.custom_callback is not None:
 
242
            self.custom_callback(option, self._param_name, bool_v, parser)
 
243
 
187
244
    def _optparse_callback(self, option, opt, value, parser):
188
 
        setattr(parser.values, self.name, self.type(value))
 
245
        v = self.type(value)
 
246
        setattr(parser.values, self._param_name, v)
 
247
        if self.custom_callback is not None:
 
248
            self.custom_callback(option, self.name, v, parser)
189
249
 
190
250
    def iter_switches(self):
191
251
        """Iterate through the list of switches provided by the option
192
 
        
 
252
 
193
253
        :return: an iterator of (name, short_name, argname, help)
194
254
        """
195
255
        argname =  self.argname
197
257
            argname = argname.upper()
198
258
        yield self.name, self.short_name(), argname, self.help
199
259
 
 
260
    def is_hidden(self, name):
 
261
        return self.hidden
 
262
 
200
263
 
201
264
class ListOption(Option):
202
265
    """Option used to provide a list of values.
221
284
                          *option_strings)
222
285
 
223
286
    def _optparse_callback(self, option, opt, value, parser):
224
 
        values = getattr(parser.values, self.name)
 
287
        values = getattr(parser.values, self._param_name)
225
288
        if value == '-':
226
289
            del values[:]
227
290
        else:
228
291
            values.append(self.type(value))
 
292
        if self.custom_callback is not None:
 
293
            self.custom_callback(option, self._param_name, values, parser)
229
294
 
230
295
 
231
296
class RegistryOption(Option):
249
314
        else:
250
315
            return self.converter(value)
251
316
 
252
 
    def __init__(self, name, help, registry, converter=None,
253
 
        value_switches=False, title=None, enum_switch=True):
 
317
    def __init__(self, name, help, registry=None, converter=None,
 
318
        value_switches=False, title=None, enum_switch=True,
 
319
        lazy_registry=None):
254
320
        """
255
321
        Constructor.
256
322
 
264
330
            '--knit' can be used interchangeably.
265
331
        :param enum_switch: If true, a switch is provided with the option name,
266
332
            which takes a value.
 
333
        :param lazy_registry: A tuple of (module name, attribute name) for a
 
334
            registry to be lazily loaded.
267
335
        """
268
336
        Option.__init__(self, name, help, type=self.convert)
269
 
        self.registry = registry
 
337
        self._registry = registry
 
338
        if registry is None:
 
339
            if lazy_registry is None:
 
340
                raise AssertionError(
 
341
                    'One of registry or lazy_registry must be given.')
 
342
            self._lazy_registry = _mod_registry._LazyObjectGetter(
 
343
                *lazy_registry)
 
344
        if registry is not None and lazy_registry is not None:
 
345
            raise AssertionError(
 
346
                'registry and lazy_registry are mutually exclusive')
270
347
        self.name = name
271
348
        self.converter = converter
272
349
        self.value_switches = value_switches
275
352
        if self.title is None:
276
353
            self.title = name
277
354
 
 
355
    @property
 
356
    def registry(self):
 
357
        if self._registry is None:
 
358
            self._registry = self._lazy_registry.get_obj()
 
359
        return self._registry
 
360
 
278
361
    @staticmethod
279
362
    def from_kwargs(name_, help=None, title=None, value_switches=False,
280
363
                    enum_switch=True, **kwargs):
284
367
        RegistryOption constructor.  Any other keyword arguments are treated
285
368
        as values for the option, and they value is treated as the help.
286
369
        """
287
 
        reg = registry.Registry()
288
 
        for name, help in kwargs.iteritems():
 
370
        reg = _mod_registry.Registry()
 
371
        for name, switch_help in kwargs.iteritems():
289
372
            name = name.replace('_', '-')
290
 
            reg.register(name, name, help=help)
 
373
            reg.register(name, name, help=switch_help)
 
374
            if not value_switches:
 
375
                help = help + '  "' + name + '": ' + switch_help
 
376
                if not help.endswith("."):
 
377
                    help = help + "."
291
378
        return RegistryOption(name_, help, reg, title=title,
292
379
            value_switches=value_switches, enum_switch=enum_switch)
293
380
 
300
387
        if self.value_switches:
301
388
            for key in self.registry.keys():
302
389
                option_strings = ['--%s' % key]
303
 
                if getattr(self.registry.get_info(key), 'hidden', False):
 
390
                if self.is_hidden(key):
304
391
                    help = optparse.SUPPRESS_HELP
305
392
                else:
306
393
                    help = self.registry.get_help(key)
311
398
 
312
399
    def _optparse_value_callback(self, cb_value):
313
400
        def cb(option, opt, value, parser):
314
 
            setattr(parser.values, self.name, self.type(cb_value))
 
401
            v = self.type(cb_value)
 
402
            setattr(parser.values, self._param_name, v)
 
403
            if self.custom_callback is not None:
 
404
                self.custom_callback(option, self._param_name, v, parser)
315
405
        return cb
316
406
 
317
407
    def iter_switches(self):
325
415
            for key in sorted(self.registry.keys()):
326
416
                yield key, None, None, self.registry.get_help(key)
327
417
 
 
418
    def is_hidden(self, name):
 
419
        if name == self.name:
 
420
            return Option.is_hidden(self, name)
 
421
        return getattr(self.registry.get_info(name), 'hidden', False)
 
422
 
328
423
 
329
424
class OptionParser(optparse.OptionParser):
330
425
    """OptionParser that raises exceptions instead of exiting"""
345
440
    return parser
346
441
 
347
442
 
 
443
def custom_help(name, help):
 
444
    """Clone a common option overriding the help."""
 
445
    import copy
 
446
    o = copy.copy(Option.OPTIONS[name])
 
447
    o.help = help
 
448
    return o
 
449
 
 
450
 
 
451
def _standard_option(name, **kwargs):
 
452
    """Register a standard option."""
 
453
    # All standard options are implicitly 'global' ones
 
454
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
 
455
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
 
456
 
 
457
 
348
458
def _global_option(name, **kwargs):
349
 
    """Register o as a global option."""
 
459
    """Register a global option."""
350
460
    Option.OPTIONS[name] = Option(name, **kwargs)
351
461
 
352
462
 
353
 
def _global_registry_option(name, help, registry, **kwargs):
 
463
def _global_registry_option(name, help, registry=None, **kwargs):
354
464
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
355
465
 
356
466
 
357
 
class MergeTypeRegistry(registry.Registry):
 
467
# This is the verbosity level detected during command line parsing.
 
468
# Note that the final value is dependent on the order in which the
 
469
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
 
470
# The final value will be one of the following:
 
471
#
 
472
# * -ve for quiet
 
473
# * 0 for normal
 
474
# * +ve for verbose
 
475
_verbosity_level = 0
 
476
 
 
477
 
 
478
def _verbosity_level_callback(option, opt_str, value, parser):
 
479
    global _verbosity_level
 
480
    if not value:
 
481
        # Either --no-verbose or --no-quiet was specified
 
482
        _verbosity_level = 0
 
483
    elif opt_str == "verbose":
 
484
        if _verbosity_level > 0:
 
485
            _verbosity_level += 1
 
486
        else:
 
487
            _verbosity_level = 1
 
488
    else:
 
489
        if _verbosity_level < 0:
 
490
            _verbosity_level -= 1
 
491
        else:
 
492
            _verbosity_level = -1
 
493
 
 
494
 
 
495
class MergeTypeRegistry(_mod_registry.Registry):
358
496
 
359
497
    pass
360
498
 
366
504
                                   "Merge using external diff3")
367
505
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
368
506
                                   "Weave-based merge")
369
 
 
 
507
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
 
508
                                   "LCA-newness merge")
 
509
 
 
510
# Declare the standard options
 
511
_standard_option('help', short_name='h',
 
512
                 help='Show help message.')
 
513
_standard_option('usage',
 
514
                 help='Show usage message and options.')
 
515
_standard_option('verbose', short_name='v',
 
516
                 help='Display more information.',
 
517
                 custom_callback=_verbosity_level_callback)
 
518
_standard_option('quiet', short_name='q',
 
519
                 help="Only display errors and warnings.",
 
520
                 custom_callback=_verbosity_level_callback)
 
521
 
 
522
# Declare commonly used options
370
523
_global_option('all')
371
524
_global_option('overwrite', help='Ignore differences between branches and '
372
525
               'overwrite unconditionally.')
386
539
_global_option('revision',
387
540
               type=_parse_revision_str,
388
541
               short_name='r',
389
 
               help='See \'help revisionspec\' for details.')
 
542
               help='See "help revisionspec" for details.')
 
543
_global_option('change',
 
544
               type=_parse_change_str,
 
545
               short_name='c',
 
546
               param_name='revision',
 
547
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
390
548
_global_option('show-ids',
391
549
               help='Show internal object ids.')
392
 
_global_option('timezone', 
 
550
_global_option('timezone',
393
551
               type=str,
394
 
               help='display timezone as local, original, or utc')
 
552
               help='Display timezone as local, original, or utc.')
395
553
_global_option('unbound')
396
 
_global_option('verbose',
397
 
               help='Display more information.',
398
 
               short_name='v')
399
554
_global_option('version')
400
555
_global_option('email')
401
556
_global_option('update')
402
557
_global_registry_option('log-format', "Use specified log format.",
403
 
                        log.log_formatter_registry, value_switches=True,
404
 
                        title='Log format')
 
558
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
 
559
                        value_switches=True, title='Log format')
405
560
_global_option('long', help='Use detailed log format. Same as --log-format long',
406
561
               short_name='l')
407
562
_global_option('short', help='Use moderately short log format. Same as --log-format short')
412
567
                        _merge_type_registry, value_switches=True,
413
568
                        title='Merge algorithm')
414
569
_global_option('pattern', type=str)
415
 
_global_option('quiet', short_name='q')
416
570
_global_option('remember', help='Remember the specified location as a'
417
571
               ' default.')
418
572
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
421
575
               help="Show what would be done, but don't actually do anything.")
422
576
_global_option('name-from-revision', help='The path name in the old tree.')
423
577
 
424
 
_help_option = Option('help',
425
 
                      help='Show help message.',
426
 
                      short_name='h')
 
578
diff_writer_registry = _mod_registry.Registry()
 
579
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
 
580
diff_writer_registry.default_key = 'plain'