← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Alexander Belchenko
  • Date: 2007-01-30 23:05:35 UTC
  • mto: This revision was merged to the branch mainline in revision 2259.
  • Revision ID: bialix@ukr.net-20070130230535-kx1rd478rtigyc3v
standalone installer: win98 support

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
183
146
        elif argname is None:
184
147
            argname = 'ARG'
185
148
        self.argname = argname
186
 
        if param_name is None:
187
 
            self._param_name = self.name
188
 
        else:
189
 
            self._param_name = param_name
190
 
        self.custom_callback = custom_callback
191
149
 
192
150
    def short_name(self):
193
151
        if self._short_name:
194
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
195
160
 
196
161
    def set_short_name(self, short_name):
197
162
        self._short_name = short_name
209
174
            option_strings.append('-%s' % short_name)
210
175
        optargfn = self.type
211
176
        if optargfn is None:
212
 
            parser.add_option(action='callback', 
213
 
                              callback=self._optparse_bool_callback, 
214
 
                              callback_args=(True,),
 
177
            parser.add_option(action='store_true', dest=self.name, 
215
178
                              help=self.help,
 
179
                              default=OptionParser.DEFAULT_VALUE,
216
180
                              *option_strings)
217
181
            negation_strings = ['--%s' % self.get_negation_name()]
218
 
            parser.add_option(action='callback', 
219
 
                              callback=self._optparse_bool_callback, 
220
 
                              callback_args=(False,),
 
182
            parser.add_option(action='store_false', dest=self.name, 
221
183
                              help=optparse.SUPPRESS_HELP, *negation_strings)
222
184
        else:
223
185
            parser.add_option(action='callback', 
227
189
                              default=OptionParser.DEFAULT_VALUE, 
228
190
                              *option_strings)
229
191
 
230
 
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
231
 
        setattr(parser.values, self._param_name, bool_v)
232
 
        if self.custom_callback is not None:
233
 
            self.custom_callback(option, self._param_name, bool_v, parser)
234
 
 
235
192
    def _optparse_callback(self, option, opt, value, parser):
236
 
        v = self.type(value)
237
 
        setattr(parser.values, self._param_name, v)
238
 
        if self.custom_callback is not None:
239
 
            self.custom_callback(option, self.name, v, parser)
 
193
        setattr(parser.values, self.name, self.type(value))
240
194
 
241
195
    def iter_switches(self):
242
196
        """Iterate through the list of switches provided by the option
248
202
            argname = argname.upper()
249
203
        yield self.name, self.short_name(), argname, self.help
250
204
 
251
 
    def is_hidden(self, name):
252
 
        return False
253
 
 
254
 
 
255
 
class ListOption(Option):
256
 
    """Option used to provide a list of values.
257
 
 
258
 
    On the command line, arguments are specified by a repeated use of the
259
 
    option. '-' is a special argument that resets the list. For example,
260
 
      --foo=a --foo=b
261
 
    sets the value of the 'foo' option to ['a', 'b'], and
262
 
      --foo=a --foo=b --foo=- --foo=c
263
 
    sets the value of the 'foo' option to ['c'].
264
 
    """
265
 
 
266
 
    def add_option(self, parser, short_name):
267
 
        """Add this option to an Optparse parser."""
268
 
        option_strings = ['--%s' % self.name]
269
 
        if short_name is not None:
270
 
            option_strings.append('-%s' % short_name)
271
 
        parser.add_option(action='callback',
272
 
                          callback=self._optparse_callback,
273
 
                          type='string', metavar=self.argname.upper(),
274
 
                          help=self.help, default=[],
275
 
                          *option_strings)
276
 
 
277
 
    def _optparse_callback(self, option, opt, value, parser):
278
 
        values = getattr(parser.values, self._param_name)
279
 
        if value == '-':
280
 
            del values[:]
281
 
        else:
282
 
            values.append(self.type(value))
283
 
        if self.custom_callback is not None:
284
 
            self.custom_callback(option, self._param_name, values, parser)
285
 
 
286
205
 
287
206
class RegistryOption(Option):
288
207
    """Option based on a registry
306
225
            return self.converter(value)
307
226
 
308
227
    def __init__(self, name, help, registry, converter=None,
309
 
        value_switches=False, title=None, enum_switch=True):
 
228
        value_switches=False):
310
229
        """
311
230
        Constructor.
312
231
 
316
235
        :param converter: Callable to invoke with the value name to produce
317
236
            the value.  If not supplied, self.registry.get is used.
318
237
        :param value_switches: If true, each possible value is assigned its
319
 
            own switch.  For example, instead of '--format knit',
320
 
            '--knit' can be used interchangeably.
321
 
        :param enum_switch: If true, a switch is provided with the option name,
322
 
            which takes a value.
 
238
            own switch.  For example, instead of '--format metaweave',
 
239
            '--metaweave' can be used interchangeably.
323
240
        """
324
241
        Option.__init__(self, name, help, type=self.convert)
325
242
        self.registry = registry
326
243
        self.name = name
327
244
        self.converter = converter
328
245
        self.value_switches = value_switches
329
 
        self.enum_switch = enum_switch
330
 
        self.title = title
331
 
        if self.title is None:
332
 
            self.title = name
333
 
 
334
 
    @staticmethod
335
 
    def from_kwargs(name_, help=None, title=None, value_switches=False,
336
 
                    enum_switch=True, **kwargs):
337
 
        """Convenience method to generate string-map registry options
338
 
 
339
 
        name, help, value_switches and enum_switch are passed to the
340
 
        RegistryOption constructor.  Any other keyword arguments are treated
341
 
        as values for the option, and they value is treated as the help.
342
 
        """
343
 
        reg = registry.Registry()
344
 
        for name, switch_help in kwargs.iteritems():
345
 
            name = name.replace('_', '-')
346
 
            reg.register(name, name, help=switch_help)
347
 
        return RegistryOption(name_, help, reg, title=title,
348
 
            value_switches=value_switches, enum_switch=enum_switch)
349
246
 
350
247
    def add_option(self, parser, short_name):
351
248
        """Add this option to an Optparse parser"""
352
 
        if self.value_switches:
353
 
            parser = parser.add_option_group(self.title)
354
 
        if self.enum_switch:
355
 
            Option.add_option(self, parser, short_name)
 
249
        Option.add_option(self, parser, short_name)
356
250
        if self.value_switches:
357
251
            for key in self.registry.keys():
358
252
                option_strings = ['--%s' % key]
359
 
                if self.is_hidden(key):
360
 
                    help = optparse.SUPPRESS_HELP
361
 
                else:
362
 
                    help = self.registry.get_help(key)
363
253
                parser.add_option(action='callback',
364
254
                              callback=self._optparse_value_callback(key),
365
 
                                  help=help,
 
255
                                  help=self.registry.get_help(key),
366
256
                                  *option_strings)
367
257
 
368
258
    def _optparse_value_callback(self, cb_value):
369
259
        def cb(option, opt, value, parser):
370
 
            v = self.type(cb_value)
371
 
            setattr(parser.values, self._param_name, v)
372
 
            if self.custom_callback is not None:
373
 
                self.custom_callback(option, self._param_name, v, parser)
 
260
            setattr(parser.values, self.name, self.type(cb_value))
374
261
        return cb
375
262
 
376
263
    def iter_switches(self):
384
271
            for key in sorted(self.registry.keys()):
385
272
                yield key, None, None, self.registry.get_help(key)
386
273
 
387
 
    def is_hidden(self, name):
388
 
        if name == self.name:
389
 
            return Option.is_hidden(self, name)
390
 
        return getattr(self.registry.get_info(name), 'hidden', False)
391
 
 
392
274
 
393
275
class OptionParser(optparse.OptionParser):
394
276
    """OptionParser that raises exceptions instead of exiting"""
409
291
    return parser
410
292
 
411
293
 
412
 
def custom_help(name, help):
413
 
    """Clone a common option overriding the help."""
414
 
    import copy
415
 
    o = copy.copy(Option.OPTIONS[name])
416
 
    o.help = help
417
 
    return o
418
 
 
419
 
 
420
 
def _standard_option(name, **kwargs):
421
 
    """Register a standard option."""
422
 
    # All standard options are implicitly 'global' ones
423
 
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
424
 
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
425
 
 
426
 
 
427
294
def _global_option(name, **kwargs):
428
 
    """Register a global option."""
 
295
    """Register o as a global option."""
429
296
    Option.OPTIONS[name] = Option(name, **kwargs)
430
297
 
431
 
 
432
 
def _global_registry_option(name, help, registry, **kwargs):
433
 
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
434
 
 
435
 
 
436
 
class MergeTypeRegistry(registry.Registry):
437
 
 
438
 
    pass
439
 
 
440
 
 
441
 
# This is the verbosity level detected during command line parsing.
442
 
# Note that the final value is dependent on the order in which the
443
 
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
444
 
# The final value will be one of the following:
445
 
#
446
 
# * -ve for quiet
447
 
# * 0 for normal
448
 
# * +ve for verbose
449
 
_verbosity_level = 0
450
 
 
451
 
 
452
 
def _verbosity_level_callback(option, opt_str, value, parser):
453
 
    global _verbosity_level
454
 
    if not value:
455
 
        # Either --no-verbose or --no-quiet was specified
456
 
        _verbosity_level = 0
457
 
    elif opt_str == "verbose":
458
 
        if _verbosity_level > 0:
459
 
            _verbosity_level += 1
460
 
        else:
461
 
            _verbosity_level = 1
462
 
    else:
463
 
        if _verbosity_level < 0:
464
 
            _verbosity_level -= 1
465
 
        else:
466
 
            _verbosity_level = -1
467
 
 
468
 
 
469
 
_merge_type_registry = MergeTypeRegistry()
470
 
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
471
 
                                   "Native diff3-style merge")
472
 
_merge_type_registry.register_lazy('diff3', 'bzrlib.merge', 'Diff3Merger',
473
 
                                   "Merge using external diff3")
474
 
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
475
 
                                   "Weave-based merge")
476
 
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
477
 
                                   "LCA-newness merge")
478
 
 
479
 
# Declare the standard options
480
 
_standard_option('help', short_name='h',
481
 
                 help='Show help message.')
482
 
_standard_option('verbose', short_name='v',
483
 
                 help='Display more information.',
484
 
                 custom_callback=_verbosity_level_callback)
485
 
_standard_option('quiet', short_name='q',
486
 
                 help="Only display errors and warnings.",
487
 
                 custom_callback=_verbosity_level_callback)
488
 
 
489
 
# Declare commonly used options
490
298
_global_option('all')
491
299
_global_option('overwrite', help='Ignore differences between branches and '
492
 
               'overwrite unconditionally.')
 
300
               'overwrite unconditionally')
493
301
_global_option('basis', type=str)
494
302
_global_option('bound')
495
303
_global_option('diff-options', type=str)
 
304
_global_option('help',
 
305
               help='show help message',
 
306
               short_name='h')
496
307
_global_option('file', type=unicode, short_name='F')
497
308
_global_option('force')
498
309
_global_option('format', type=unicode)
499
310
_global_option('forward')
500
311
_global_option('message', type=unicode,
501
 
               short_name='m',
502
 
               help='Message string.')
 
312
               short_name='m')
503
313
_global_option('no-recurse')
504
314
_global_option('profile',
505
 
               help='Show performance profiling information.')
 
315
               help='show performance profiling information')
506
316
_global_option('revision',
507
317
               type=_parse_revision_str,
508
318
               short_name='r',
509
 
               help='See "help revisionspec" for details.')
510
 
_global_option('change',
511
 
               type=_parse_change_str,
512
 
               short_name='c',
513
 
               param_name='revision',
514
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
515
 
_global_option('show-ids',
516
 
               help='Show internal object ids.')
 
319
               help='See \'help revisionspec\' for details')
 
320
_global_option('show-ids', 
 
321
               help='show internal object ids')
517
322
_global_option('timezone', 
518
323
               type=str,
519
324
               help='display timezone as local, original, or utc')
520
325
_global_option('unbound')
 
326
_global_option('verbose',
 
327
               help='display more information',
 
328
               short_name='v')
521
329
_global_option('version')
522
330
_global_option('email')
523
331
_global_option('update')
524
 
_global_registry_option('log-format', "Use specified log format.",
525
 
                        log.log_formatter_registry, value_switches=True,
526
 
                        title='Log format')
 
332
_global_option('log-format', type=str, help="Use this log format")
527
333
_global_option('long', help='Use detailed log format. Same as --log-format long',
528
334
               short_name='l')
529
335
_global_option('short', help='Use moderately short log format. Same as --log-format short')
530
336
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
531
337
_global_option('root', type=str)
532
338
_global_option('no-backup')
533
 
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
534
 
                        _merge_type_registry, value_switches=True,
535
 
                        title='Merge algorithm')
 
339
_global_option('merge-type', type=_parse_merge_type, 
 
340
               help='Select a particular merge algorithm')
536
341
_global_option('pattern', type=str)
 
342
_global_option('quiet', short_name='q')
537
343
_global_option('remember', help='Remember the specified location as a'
538
344
               ' default.')
539
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
 
345
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
540
346
_global_option('kind', type=str)
541
347
_global_option('dry-run',
542
 
               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")
543
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
    )