← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-30 13:53:57 UTC
  • mto: (2779.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2783.
  • Revision ID: ian.clatworthy@internode.on.net-20070830135357-dqr7saq6ciipx09d
Fix existing option and help tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2005-2010 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
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
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,
 
28
    log,
 
29
    registry,
27
30
    revisionspec,
 
31
    symbol_versioning,
28
32
    )
29
33
""")
30
 
 
31
 
from bzrlib import (
32
 
    registry as _mod_registry,
33
 
    )
 
34
from bzrlib.trace import warning
34
35
 
35
36
 
36
37
def _parse_revision_str(revstr):
40
41
    each revision specifier supplied.
41
42
 
42
43
    >>> _parse_revision_str('234')
43
 
    [<RevisionSpec_dwim 234>]
 
44
    [<RevisionSpec_revno 234>]
44
45
    >>> _parse_revision_str('234..567')
45
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
 
46
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
46
47
    >>> _parse_revision_str('..')
47
48
    [<RevisionSpec None>, <RevisionSpec None>]
48
49
    >>> _parse_revision_str('..234')
49
 
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
 
50
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
50
51
    >>> _parse_revision_str('234..')
51
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
 
52
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
52
53
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
53
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
 
54
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
54
55
    >>> _parse_revision_str('234....789') #Error ?
55
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
 
56
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
56
57
    >>> _parse_revision_str('revid:test@other.com-234234')
57
58
    [<RevisionSpec_revid revid:test@other.com-234234>]
58
59
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
59
60
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
60
61
    >>> _parse_revision_str('revid:test@other.com-234234..23')
61
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
 
62
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
62
63
    >>> _parse_revision_str('date:2005-04-12')
63
64
    [<RevisionSpec_date date:2005-04-12>]
64
65
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
68
69
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
69
70
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
70
71
    >>> _parse_revision_str('-5..23')
71
 
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
 
72
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
72
73
    >>> _parse_revision_str('-5')
73
 
    [<RevisionSpec_dwim -5>]
 
74
    [<RevisionSpec_revno -5>]
74
75
    >>> _parse_revision_str('123a')
75
 
    [<RevisionSpec_dwim 123a>]
 
76
    Traceback (most recent call last):
 
77
      ...
 
78
    NoSuchRevisionSpec: No namespace registered for string: '123a'
76
79
    >>> _parse_revision_str('abc')
77
 
    [<RevisionSpec_dwim abc>]
 
80
    Traceback (most recent call last):
 
81
      ...
 
82
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
78
83
    >>> _parse_revision_str('branch:../branch2')
79
84
    [<RevisionSpec_branch branch:../branch2>]
80
85
    >>> _parse_revision_str('branch:../../branch2')
81
86
    [<RevisionSpec_branch branch:../../branch2>]
82
87
    >>> _parse_revision_str('branch:../../branch2..23')
83
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
 
88
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
84
89
    >>> _parse_revision_str('branch:..\\\\branch2')
85
90
    [<RevisionSpec_branch branch:..\\branch2>]
86
91
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
87
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
 
92
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
88
93
    """
89
94
    # TODO: Maybe move this into revisionspec.py
90
95
    revs = []
95
100
    return revs
96
101
 
97
102
 
98
 
def _parse_change_str(revstr):
99
 
    """Parse the revision string and return a tuple with left-most
100
 
    parent of the revision.
101
 
 
102
 
    >>> _parse_change_str('123')
103
 
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
104
 
    >>> _parse_change_str('123..124')
105
 
    Traceback (most recent call last):
106
 
      ...
107
 
    RangeInChangeOption: Option --change does not accept revision ranges
108
 
    """
109
 
    revs = _parse_revision_str(revstr)
110
 
    if len(revs) > 1:
111
 
        raise errors.RangeInChangeOption()
112
 
    return (revisionspec.RevisionSpec.from_string('before:' + revstr),
113
 
            revs[0])
114
 
 
115
 
 
116
103
def _parse_merge_type(typestring):
117
104
    return get_merge_type(typestring)
118
105
 
132
119
 
133
120
class Option(object):
134
121
    """Description of a command line option
135
 
 
 
122
    
136
123
    :ivar _short_name: If this option has a single-letter name, this is it.
137
124
    Otherwise None.
138
125
    """
146
133
    OPTIONS = {}
147
134
 
148
135
    def __init__(self, name, help='', type=None, argname=None,
149
 
                 short_name=None, param_name=None, custom_callback=None,
150
 
                 hidden=False):
 
136
                 short_name=None, custom_callback=None):
151
137
        """Make a new command option.
152
138
 
153
139
        :param name: regular name of the command, used in the double-dash
154
 
            form and also as the parameter to the command's run()
155
 
            method (unless param_name is specified).
 
140
            form and also as the parameter to the command's run() 
 
141
            method.
156
142
 
157
143
        :param help: help message displayed in command help
158
144
 
159
 
        :param type: function called to parse the option argument, or
 
145
        :param type: function called to parse the option argument, or 
160
146
            None (default) if this option doesn't take an argument.
161
147
 
162
148
        :param argname: name of option argument, if any
164
150
        :param short_name: short option code for use with a single -, e.g.
165
151
            short_name="v" to enable parsing of -v.
166
152
 
167
 
        :param param_name: name of the parameter which will be passed to
168
 
            the command's run() method.
169
 
 
170
153
        :param custom_callback: a callback routine to be called after normal
171
 
            processing. The signature of the callback routine is
172
 
            (option, name, new_value, parser).
173
 
        :param hidden: If True, the option should be hidden in help and
174
 
            documentation.
 
154
            processing. The signature of the callback routine is the same
 
155
            as that for normal option callbacks. See optparse in the standard
 
156
            Python library for details.
175
157
        """
176
158
        self.name = name
177
159
        self.help = help
178
160
        self.type = type
179
161
        self._short_name = short_name
180
162
        if type is None:
181
 
            if argname:
182
 
                raise ValueError('argname not valid for booleans')
 
163
            assert argname is None
183
164
        elif argname is None:
184
165
            argname = 'ARG'
185
166
        self.argname = argname
186
 
        if param_name is None:
187
 
            self._param_name = self.name.replace('-', '_')
188
 
        else:
189
 
            self._param_name = param_name
190
167
        self.custom_callback = custom_callback
191
 
        self.hidden = hidden
192
168
 
193
169
    def short_name(self):
194
170
        if self._short_name:
208
184
        option_strings = ['--%s' % self.name]
209
185
        if short_name is not None:
210
186
            option_strings.append('-%s' % short_name)
211
 
        if self.hidden:
212
 
            help = optparse.SUPPRESS_HELP
213
 
        else:
214
 
            help = self.help
215
187
        optargfn = self.type
216
188
        if optargfn is None:
217
 
            parser.add_option(action='callback',
218
 
                              callback=self._optparse_bool_callback,
 
189
            parser.add_option(action='callback', 
 
190
                              callback=self._optparse_bool_callback, 
219
191
                              callback_args=(True,),
220
 
                              help=help,
 
192
                              help=self.help,
221
193
                              *option_strings)
222
194
            negation_strings = ['--%s' % self.get_negation_name()]
223
 
            parser.add_option(action='callback',
224
 
                              callback=self._optparse_bool_callback,
 
195
            parser.add_option(action='callback', 
 
196
                              callback=self._optparse_bool_callback, 
225
197
                              callback_args=(False,),
226
198
                              help=optparse.SUPPRESS_HELP, *negation_strings)
227
199
        else:
228
 
            parser.add_option(action='callback',
229
 
                              callback=self._optparse_callback,
 
200
            parser.add_option(action='callback', 
 
201
                              callback=self._optparse_callback, 
230
202
                              type='string', metavar=self.argname.upper(),
231
 
                              help=help,
232
 
                              default=OptionParser.DEFAULT_VALUE,
 
203
                              help=self.help,
 
204
                              default=OptionParser.DEFAULT_VALUE, 
233
205
                              *option_strings)
234
206
 
235
207
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
236
 
        setattr(parser.values, self._param_name, bool_v)
 
208
        setattr(parser.values, self.name, bool_v)
237
209
        if self.custom_callback is not None:
238
 
            self.custom_callback(option, self._param_name, bool_v, parser)
 
210
            self.custom_callback(option, self.name, bool_v, parser)
239
211
 
240
212
    def _optparse_callback(self, option, opt, value, parser):
241
 
        v = self.type(value)
242
 
        setattr(parser.values, self._param_name, v)
 
213
        setattr(parser.values, self.name, self.type(value))
243
214
        if self.custom_callback is not None:
244
 
            self.custom_callback(option, self.name, v, parser)
 
215
            self.custom_callback(option, opt, value, parser)
245
216
 
246
217
    def iter_switches(self):
247
218
        """Iterate through the list of switches provided by the option
248
 
 
 
219
        
249
220
        :return: an iterator of (name, short_name, argname, help)
250
221
        """
251
222
        argname =  self.argname
254
225
        yield self.name, self.short_name(), argname, self.help
255
226
 
256
227
    def is_hidden(self, name):
257
 
        return self.hidden
 
228
        return False
258
229
 
259
230
 
260
231
class ListOption(Option):
276
247
        parser.add_option(action='callback',
277
248
                          callback=self._optparse_callback,
278
249
                          type='string', metavar=self.argname.upper(),
279
 
                          help=self.help, dest=self._param_name, default=[],
 
250
                          help=self.help, default=[],
280
251
                          *option_strings)
281
252
 
282
253
    def _optparse_callback(self, option, opt, value, parser):
283
 
        values = getattr(parser.values, self._param_name)
 
254
        values = getattr(parser.values, self.name)
284
255
        if value == '-':
285
256
            del values[:]
286
257
        else:
287
258
            values.append(self.type(value))
288
259
        if self.custom_callback is not None:
289
 
            self.custom_callback(option, self._param_name, values, parser)
 
260
            self.custom_callback(option, opt, value, parser)
290
261
 
291
262
 
292
263
class RegistryOption(Option):
310
281
        else:
311
282
            return self.converter(value)
312
283
 
313
 
    def __init__(self, name, help, registry=None, converter=None,
314
 
        value_switches=False, title=None, enum_switch=True,
315
 
        lazy_registry=None):
 
284
    def __init__(self, name, help, registry, converter=None,
 
285
        value_switches=False, title=None, enum_switch=True):
316
286
        """
317
287
        Constructor.
318
288
 
326
296
            '--knit' can be used interchangeably.
327
297
        :param enum_switch: If true, a switch is provided with the option name,
328
298
            which takes a value.
329
 
        :param lazy_registry: A tuple of (module name, attribute name) for a
330
 
            registry to be lazily loaded.
331
299
        """
332
300
        Option.__init__(self, name, help, type=self.convert)
333
 
        self._registry = registry
334
 
        if registry is None:
335
 
            if lazy_registry is None:
336
 
                raise AssertionError(
337
 
                    'One of registry or lazy_registry must be given.')
338
 
            self._lazy_registry = _mod_registry._LazyObjectGetter(
339
 
                *lazy_registry)
340
 
        if registry is not None and lazy_registry is not None:
341
 
            raise AssertionError(
342
 
                'registry and lazy_registry are mutually exclusive')
 
301
        self.registry = registry
343
302
        self.name = name
344
303
        self.converter = converter
345
304
        self.value_switches = value_switches
348
307
        if self.title is None:
349
308
            self.title = name
350
309
 
351
 
    @property
352
 
    def registry(self):
353
 
        if self._registry is None:
354
 
            self._registry = self._lazy_registry.get_obj()
355
 
        return self._registry
356
 
 
357
310
    @staticmethod
358
311
    def from_kwargs(name_, help=None, title=None, value_switches=False,
359
312
                    enum_switch=True, **kwargs):
361
314
 
362
315
        name, help, value_switches and enum_switch are passed to the
363
316
        RegistryOption constructor.  Any other keyword arguments are treated
364
 
        as values for the option, and their value is treated as the help.
 
317
        as values for the option, and they value is treated as the help.
365
318
        """
366
 
        reg = _mod_registry.Registry()
367
 
        for name, switch_help in sorted(kwargs.items()):
 
319
        reg = registry.Registry()
 
320
        for name, switch_help in kwargs.iteritems():
368
321
            name = name.replace('_', '-')
369
322
            reg.register(name, name, help=switch_help)
370
 
            if not value_switches:
371
 
                help = help + '  "' + name + '": ' + switch_help
372
 
                if not help.endswith("."):
373
 
                    help = help + "."
374
323
        return RegistryOption(name_, help, reg, title=title,
375
324
            value_switches=value_switches, enum_switch=enum_switch)
376
325
 
394
343
 
395
344
    def _optparse_value_callback(self, cb_value):
396
345
        def cb(option, opt, value, parser):
397
 
            v = self.type(cb_value)
398
 
            setattr(parser.values, self._param_name, v)
 
346
            setattr(parser.values, self.name, self.type(cb_value))
399
347
            if self.custom_callback is not None:
400
 
                self.custom_callback(option, self._param_name, v, parser)
 
348
                self.custom_callback(option, opt, value, parser)
401
349
        return cb
402
350
 
403
351
    def iter_switches(self):
456
404
    Option.OPTIONS[name] = Option(name, **kwargs)
457
405
 
458
406
 
459
 
def _global_registry_option(name, help, registry=None, **kwargs):
 
407
def _global_registry_option(name, help, registry, **kwargs):
460
408
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
461
409
 
462
410
 
 
411
class MergeTypeRegistry(registry.Registry):
 
412
 
 
413
    pass
 
414
 
 
415
 
463
416
# This is the verbosity level detected during command line parsing.
464
417
# Note that the final value is dependent on the order in which the
465
418
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
488
441
            _verbosity_level = -1
489
442
 
490
443
 
491
 
class MergeTypeRegistry(_mod_registry.Registry):
492
 
 
493
 
    pass
494
 
 
495
 
 
496
444
_merge_type_registry = MergeTypeRegistry()
497
445
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
498
446
                                   "Native diff3-style merge")
500
448
                                   "Merge using external diff3")
501
449
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
502
450
                                   "Weave-based merge")
503
 
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
504
 
                                   "LCA-newness merge")
505
451
 
506
452
# Declare the standard options
507
453
_standard_option('help', short_name='h',
508
454
                 help='Show help message.')
509
 
_standard_option('usage',
510
 
                 help='Show usage message and options.')
511
455
_standard_option('verbose', short_name='v',
512
456
                 help='Display more information.',
513
457
                 custom_callback=_verbosity_level_callback)
535
479
_global_option('revision',
536
480
               type=_parse_revision_str,
537
481
               short_name='r',
538
 
               help='See "help revisionspec" for details.')
539
 
_global_option('change',
540
 
               type=_parse_change_str,
541
 
               short_name='c',
542
 
               param_name='revision',
543
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
 
482
               help='See \'help revisionspec\' for details.')
544
483
_global_option('show-ids',
545
484
               help='Show internal object ids.')
546
 
_global_option('timezone',
 
485
_global_option('timezone', 
547
486
               type=str,
548
 
               help='Display timezone as local, original, or utc.')
 
487
               help='display timezone as local, original, or utc')
549
488
_global_option('unbound')
550
489
_global_option('version')
551
490
_global_option('email')
552
491
_global_option('update')
553
492
_global_registry_option('log-format', "Use specified log format.",
554
 
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
555
 
                        value_switches=True, title='Log format')
 
493
                        log.log_formatter_registry, value_switches=True,
 
494
                        title='Log format')
556
495
_global_option('long', help='Use detailed log format. Same as --log-format long',
557
496
               short_name='l')
558
497
_global_option('short', help='Use moderately short log format. Same as --log-format short')
570
509
_global_option('dry-run',
571
510
               help="Show what would be done, but don't actually do anything.")
572
511
_global_option('name-from-revision', help='The path name in the old tree.')
573
 
 
574
 
diff_writer_registry = _mod_registry.Registry()
575
 
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
576
 
diff_writer_registry.default_key = 'plain'