← 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-12-11 02:07:30 UTC
  • mto: (3119.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3120.
  • Revision ID: ian.clatworthy@internode.on.net-20071211020730-sdj4kj794dw0628e
make help topics more discoverable

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 = []
100
105
    parent of the revision.
101
106
 
102
107
    >>> _parse_change_str('123')
103
 
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
 
108
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
104
109
    >>> _parse_change_str('123..124')
105
110
    Traceback (most recent call last):
106
111
      ...
132
137
 
133
138
class Option(object):
134
139
    """Description of a command line option
135
 
 
 
140
    
136
141
    :ivar _short_name: If this option has a single-letter name, this is it.
137
142
    Otherwise None.
138
143
    """
146
151
    OPTIONS = {}
147
152
 
148
153
    def __init__(self, name, help='', type=None, argname=None,
149
 
                 short_name=None, param_name=None, custom_callback=None,
150
 
                 hidden=False):
 
154
                 short_name=None, param_name=None, custom_callback=None):
151
155
        """Make a new command option.
152
156
 
153
157
        :param name: regular name of the command, used in the double-dash
154
 
            form and also as the parameter to the command's run()
 
158
            form and also as the parameter to the command's run() 
155
159
            method (unless param_name is specified).
156
160
 
157
161
        :param help: help message displayed in command help
158
162
 
159
 
        :param type: function called to parse the option argument, or
 
163
        :param type: function called to parse the option argument, or 
160
164
            None (default) if this option doesn't take an argument.
161
165
 
162
166
        :param argname: name of option argument, if any
170
174
        :param custom_callback: a callback routine to be called after normal
171
175
            processing. The signature of the callback routine is
172
176
            (option, name, new_value, parser).
173
 
        :param hidden: If True, the option should be hidden in help and
174
 
            documentation.
175
177
        """
176
178
        self.name = name
177
179
        self.help = help
178
180
        self.type = type
179
181
        self._short_name = short_name
180
182
        if type is None:
181
 
            if argname:
182
 
                raise ValueError('argname not valid for booleans')
 
183
            assert argname is None
183
184
        elif argname is None:
184
185
            argname = 'ARG'
185
186
        self.argname = argname
186
187
        if param_name is None:
187
 
            self._param_name = self.name.replace('-', '_')
 
188
            self._param_name = self.name
188
189
        else:
189
190
            self._param_name = param_name
190
191
        self.custom_callback = custom_callback
191
 
        self.hidden = hidden
192
192
 
193
193
    def short_name(self):
194
194
        if self._short_name:
208
208
        option_strings = ['--%s' % self.name]
209
209
        if short_name is not None:
210
210
            option_strings.append('-%s' % short_name)
211
 
        if self.hidden:
212
 
            help = optparse.SUPPRESS_HELP
213
 
        else:
214
 
            help = self.help
215
211
        optargfn = self.type
216
212
        if optargfn is None:
217
 
            parser.add_option(action='callback',
218
 
                              callback=self._optparse_bool_callback,
 
213
            parser.add_option(action='callback', 
 
214
                              callback=self._optparse_bool_callback, 
219
215
                              callback_args=(True,),
220
 
                              help=help,
 
216
                              help=self.help,
221
217
                              *option_strings)
222
218
            negation_strings = ['--%s' % self.get_negation_name()]
223
 
            parser.add_option(action='callback',
224
 
                              callback=self._optparse_bool_callback,
 
219
            parser.add_option(action='callback', 
 
220
                              callback=self._optparse_bool_callback, 
225
221
                              callback_args=(False,),
226
222
                              help=optparse.SUPPRESS_HELP, *negation_strings)
227
223
        else:
228
 
            parser.add_option(action='callback',
229
 
                              callback=self._optparse_callback,
 
224
            parser.add_option(action='callback', 
 
225
                              callback=self._optparse_callback, 
230
226
                              type='string', metavar=self.argname.upper(),
231
 
                              help=help,
232
 
                              default=OptionParser.DEFAULT_VALUE,
 
227
                              help=self.help,
 
228
                              default=OptionParser.DEFAULT_VALUE, 
233
229
                              *option_strings)
234
230
 
235
231
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
245
241
 
246
242
    def iter_switches(self):
247
243
        """Iterate through the list of switches provided by the option
248
 
 
 
244
        
249
245
        :return: an iterator of (name, short_name, argname, help)
250
246
        """
251
247
        argname =  self.argname
254
250
        yield self.name, self.short_name(), argname, self.help
255
251
 
256
252
    def is_hidden(self, name):
257
 
        return self.hidden
 
253
        return False
258
254
 
259
255
 
260
256
class ListOption(Option):
276
272
        parser.add_option(action='callback',
277
273
                          callback=self._optparse_callback,
278
274
                          type='string', metavar=self.argname.upper(),
279
 
                          help=self.help, dest=self._param_name, default=[],
 
275
                          help=self.help, default=[],
280
276
                          *option_strings)
281
277
 
282
278
    def _optparse_callback(self, option, opt, value, parser):
310
306
        else:
311
307
            return self.converter(value)
312
308
 
313
 
    def __init__(self, name, help, registry=None, converter=None,
314
 
        value_switches=False, title=None, enum_switch=True,
315
 
        lazy_registry=None, short_name=None):
 
309
    def __init__(self, name, help, registry, converter=None,
 
310
        value_switches=False, title=None, enum_switch=True):
316
311
        """
317
312
        Constructor.
318
313
 
326
321
            '--knit' can be used interchangeably.
327
322
        :param enum_switch: If true, a switch is provided with the option name,
328
323
            which takes a value.
329
 
        :param lazy_registry: A tuple of (module name, attribute name) for a
330
 
            registry to be lazily loaded.
331
324
        """
332
 
        Option.__init__(self, name, help, type=self.convert, short_name=short_name)
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')
 
325
        Option.__init__(self, name, help, type=self.convert)
 
326
        self.registry = registry
343
327
        self.name = name
344
328
        self.converter = converter
345
329
        self.value_switches = value_switches
348
332
        if self.title is None:
349
333
            self.title = name
350
334
 
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
335
    @staticmethod
358
336
    def from_kwargs(name_, help=None, title=None, value_switches=False,
359
337
                    enum_switch=True, **kwargs):
361
339
 
362
340
        name, help, value_switches and enum_switch are passed to the
363
341
        RegistryOption constructor.  Any other keyword arguments are treated
364
 
        as values for the option, and their value is treated as the help.
 
342
        as values for the option, and they value is treated as the help.
365
343
        """
366
 
        reg = _mod_registry.Registry()
367
 
        for name, switch_help in sorted(kwargs.items()):
 
344
        reg = registry.Registry()
 
345
        for name, switch_help in kwargs.iteritems():
368
346
            name = name.replace('_', '-')
369
347
            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
348
        return RegistryOption(name_, help, reg, title=title,
375
349
            value_switches=value_switches, enum_switch=enum_switch)
376
350
 
456
430
    Option.OPTIONS[name] = Option(name, **kwargs)
457
431
 
458
432
 
459
 
def _global_registry_option(name, help, registry=None, **kwargs):
 
433
def _global_registry_option(name, help, registry, **kwargs):
460
434
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
461
435
 
462
436
 
 
437
class MergeTypeRegistry(registry.Registry):
 
438
 
 
439
    pass
 
440
 
 
441
 
463
442
# This is the verbosity level detected during command line parsing.
464
443
# Note that the final value is dependent on the order in which the
465
444
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
488
467
            _verbosity_level = -1
489
468
 
490
469
 
491
 
class MergeTypeRegistry(_mod_registry.Registry):
492
 
 
493
 
    pass
494
 
 
495
 
 
496
470
_merge_type_registry = MergeTypeRegistry()
497
471
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
498
472
                                   "Native diff3-style merge")
500
474
                                   "Merge using external diff3")
501
475
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
502
476
                                   "Weave-based merge")
503
 
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
504
 
                                   "LCA-newness merge")
505
477
 
506
478
# Declare the standard options
507
479
_standard_option('help', short_name='h',
508
480
                 help='Show help message.')
509
 
_standard_option('usage',
510
 
                 help='Show usage message and options.')
511
481
_standard_option('verbose', short_name='v',
512
482
                 help='Display more information.',
513
483
                 custom_callback=_verbosity_level_callback)
530
500
               short_name='m',
531
501
               help='Message string.')
532
502
_global_option('no-recurse')
533
 
_global_option('null', short_name='0',
534
 
                 help='Use an ASCII NUL (\\0) separator rather than '
535
 
                      'a newline.')
536
503
_global_option('profile',
537
504
               help='Show performance profiling information.')
538
505
_global_option('revision',
546
513
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
547
514
_global_option('show-ids',
548
515
               help='Show internal object ids.')
549
 
_global_option('timezone',
 
516
_global_option('timezone', 
550
517
               type=str,
551
 
               help='Display timezone as local, original, or utc.')
 
518
               help='display timezone as local, original, or utc')
552
519
_global_option('unbound')
553
520
_global_option('version')
554
521
_global_option('email')
555
522
_global_option('update')
556
523
_global_registry_option('log-format', "Use specified log format.",
557
 
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
558
 
                        value_switches=True, title='Log format')
 
524
                        log.log_formatter_registry, value_switches=True,
 
525
                        title='Log format')
559
526
_global_option('long', help='Use detailed log format. Same as --log-format long',
560
527
               short_name='l')
561
528
_global_option('short', help='Use moderately short log format. Same as --log-format short')
573
540
_global_option('dry-run',
574
541
               help="Show what would be done, but don't actually do anything.")
575
542
_global_option('name-from-revision', help='The path name in the old tree.')
576
 
_global_option('directory', short_name='d', type=unicode,
577
 
               help='Branch to operate on, instead of working directory')
578
 
 
579
 
diff_writer_registry = _mod_registry.Registry()
580
 
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
581
 
diff_writer_registry.default_key = 'plain'