← 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-11-30 04:28:32 UTC
  • mto: (3054.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3055.
  • Revision ID: ian.clatworthy@internode.on.net-20071130042832-6prruj0kzg3fodm8
chapter 2 tweaks

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
 
from __future__ import absolute_import
21
 
 
22
 
import optparse
23
20
import re
24
21
 
25
22
from bzrlib.lazy_import import lazy_import
26
23
lazy_import(globals(), """
 
24
import optparse
 
25
 
27
26
from bzrlib import (
28
27
    errors,
 
28
    log,
 
29
    registry,
29
30
    revisionspec,
30
 
    i18n,
 
31
    symbol_versioning,
31
32
    )
32
33
""")
33
 
 
34
 
from bzrlib import (
35
 
    registry as _mod_registry,
36
 
    )
 
34
from bzrlib.trace import warning
37
35
 
38
36
 
39
37
def _parse_revision_str(revstr):
43
41
    each revision specifier supplied.
44
42
 
45
43
    >>> _parse_revision_str('234')
46
 
    [<RevisionSpec_dwim 234>]
 
44
    [<RevisionSpec_revno 234>]
47
45
    >>> _parse_revision_str('234..567')
48
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
 
46
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
49
47
    >>> _parse_revision_str('..')
50
48
    [<RevisionSpec None>, <RevisionSpec None>]
51
49
    >>> _parse_revision_str('..234')
52
 
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
 
50
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
53
51
    >>> _parse_revision_str('234..')
54
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
 
52
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
55
53
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
56
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
 
54
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
57
55
    >>> _parse_revision_str('234....789') #Error ?
58
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
 
56
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
59
57
    >>> _parse_revision_str('revid:test@other.com-234234')
60
58
    [<RevisionSpec_revid revid:test@other.com-234234>]
61
59
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
62
60
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
63
61
    >>> _parse_revision_str('revid:test@other.com-234234..23')
64
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
 
62
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
65
63
    >>> _parse_revision_str('date:2005-04-12')
66
64
    [<RevisionSpec_date date:2005-04-12>]
67
65
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
71
69
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
72
70
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
73
71
    >>> _parse_revision_str('-5..23')
74
 
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
 
72
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
75
73
    >>> _parse_revision_str('-5')
76
 
    [<RevisionSpec_dwim -5>]
 
74
    [<RevisionSpec_revno -5>]
77
75
    >>> _parse_revision_str('123a')
78
 
    [<RevisionSpec_dwim 123a>]
 
76
    Traceback (most recent call last):
 
77
      ...
 
78
    NoSuchRevisionSpec: No namespace registered for string: '123a'
79
79
    >>> _parse_revision_str('abc')
80
 
    [<RevisionSpec_dwim abc>]
 
80
    Traceback (most recent call last):
 
81
      ...
 
82
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
81
83
    >>> _parse_revision_str('branch:../branch2')
82
84
    [<RevisionSpec_branch branch:../branch2>]
83
85
    >>> _parse_revision_str('branch:../../branch2')
84
86
    [<RevisionSpec_branch branch:../../branch2>]
85
87
    >>> _parse_revision_str('branch:../../branch2..23')
86
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
 
88
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
87
89
    >>> _parse_revision_str('branch:..\\\\branch2')
88
90
    [<RevisionSpec_branch branch:..\\branch2>]
89
91
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
90
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
 
92
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
91
93
    """
92
94
    # TODO: Maybe move this into revisionspec.py
93
95
    revs = []
103
105
    parent of the revision.
104
106
 
105
107
    >>> _parse_change_str('123')
106
 
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
 
108
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
107
109
    >>> _parse_change_str('123..124')
108
110
    Traceback (most recent call last):
109
111
      ...
135
137
 
136
138
class Option(object):
137
139
    """Description of a command line option
138
 
 
 
140
    
139
141
    :ivar _short_name: If this option has a single-letter name, this is it.
140
142
    Otherwise None.
141
143
    """
149
151
    OPTIONS = {}
150
152
 
151
153
    def __init__(self, name, help='', type=None, argname=None,
152
 
                 short_name=None, param_name=None, custom_callback=None,
153
 
                 hidden=False):
 
154
                 short_name=None, param_name=None, custom_callback=None):
154
155
        """Make a new command option.
155
156
 
156
157
        :param name: regular name of the command, used in the double-dash
157
 
            form and also as the parameter to the command's run()
 
158
            form and also as the parameter to the command's run() 
158
159
            method (unless param_name is specified).
159
160
 
160
161
        :param help: help message displayed in command help
161
162
 
162
 
        :param type: function called to parse the option argument, or
 
163
        :param type: function called to parse the option argument, or 
163
164
            None (default) if this option doesn't take an argument.
164
165
 
165
166
        :param argname: name of option argument, if any
173
174
        :param custom_callback: a callback routine to be called after normal
174
175
            processing. The signature of the callback routine is
175
176
            (option, name, new_value, parser).
176
 
        :param hidden: If True, the option should be hidden in help and
177
 
            documentation.
178
177
        """
179
178
        self.name = name
180
179
        self.help = help
181
180
        self.type = type
182
181
        self._short_name = short_name
183
182
        if type is None:
184
 
            if argname:
185
 
                raise ValueError('argname not valid for booleans')
 
183
            assert argname is None
186
184
        elif argname is None:
187
185
            argname = 'ARG'
188
186
        self.argname = argname
189
187
        if param_name is None:
190
 
            self._param_name = self.name.replace('-', '_')
 
188
            self._param_name = self.name
191
189
        else:
192
190
            self._param_name = param_name
193
191
        self.custom_callback = custom_callback
194
 
        self.hidden = hidden
195
192
 
196
193
    def short_name(self):
197
194
        if self._short_name:
211
208
        option_strings = ['--%s' % self.name]
212
209
        if short_name is not None:
213
210
            option_strings.append('-%s' % short_name)
214
 
        if self.hidden:
215
 
            help = optparse.SUPPRESS_HELP
216
 
        else:
217
 
            help = self.help
218
211
        optargfn = self.type
219
212
        if optargfn is None:
220
 
            parser.add_option(action='callback',
221
 
                              callback=self._optparse_bool_callback,
 
213
            parser.add_option(action='callback', 
 
214
                              callback=self._optparse_bool_callback, 
222
215
                              callback_args=(True,),
223
 
                              help=help,
 
216
                              help=self.help,
224
217
                              *option_strings)
225
218
            negation_strings = ['--%s' % self.get_negation_name()]
226
 
            parser.add_option(action='callback',
227
 
                              callback=self._optparse_bool_callback,
 
219
            parser.add_option(action='callback', 
 
220
                              callback=self._optparse_bool_callback, 
228
221
                              callback_args=(False,),
229
222
                              help=optparse.SUPPRESS_HELP, *negation_strings)
230
223
        else:
231
 
            parser.add_option(action='callback',
232
 
                              callback=self._optparse_callback,
 
224
            parser.add_option(action='callback', 
 
225
                              callback=self._optparse_callback, 
233
226
                              type='string', metavar=self.argname.upper(),
234
 
                              help=help,
235
 
                              default=OptionParser.DEFAULT_VALUE,
 
227
                              help=self.help,
 
228
                              default=OptionParser.DEFAULT_VALUE, 
236
229
                              *option_strings)
237
230
 
238
231
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
248
241
 
249
242
    def iter_switches(self):
250
243
        """Iterate through the list of switches provided by the option
251
 
 
 
244
        
252
245
        :return: an iterator of (name, short_name, argname, help)
253
246
        """
254
247
        argname =  self.argname
257
250
        yield self.name, self.short_name(), argname, self.help
258
251
 
259
252
    def is_hidden(self, name):
260
 
        return self.hidden
 
253
        return False
261
254
 
262
255
 
263
256
class ListOption(Option):
279
272
        parser.add_option(action='callback',
280
273
                          callback=self._optparse_callback,
281
274
                          type='string', metavar=self.argname.upper(),
282
 
                          help=self.help, dest=self._param_name, default=[],
 
275
                          help=self.help, default=[],
283
276
                          *option_strings)
284
277
 
285
278
    def _optparse_callback(self, option, opt, value, parser):
313
306
        else:
314
307
            return self.converter(value)
315
308
 
316
 
    def __init__(self, name, help, registry=None, converter=None,
317
 
        value_switches=False, title=None, enum_switch=True,
318
 
        lazy_registry=None, short_name=None, short_value_switches=None):
 
309
    def __init__(self, name, help, registry, converter=None,
 
310
        value_switches=False, title=None, enum_switch=True):
319
311
        """
320
312
        Constructor.
321
313
 
329
321
            '--knit' can be used interchangeably.
330
322
        :param enum_switch: If true, a switch is provided with the option name,
331
323
            which takes a value.
332
 
        :param lazy_registry: A tuple of (module name, attribute name) for a
333
 
            registry to be lazily loaded.
334
 
        :param short_name: The short name for the enum switch, if any
335
 
        :param short_value_switches: A dict mapping values to short names
336
324
        """
337
 
        Option.__init__(self, name, help, type=self.convert,
338
 
                        short_name=short_name)
339
 
        self._registry = registry
340
 
        if registry is None:
341
 
            if lazy_registry is None:
342
 
                raise AssertionError(
343
 
                    'One of registry or lazy_registry must be given.')
344
 
            self._lazy_registry = _mod_registry._LazyObjectGetter(
345
 
                *lazy_registry)
346
 
        if registry is not None and lazy_registry is not None:
347
 
            raise AssertionError(
348
 
                'registry and lazy_registry are mutually exclusive')
 
325
        Option.__init__(self, name, help, type=self.convert)
 
326
        self.registry = registry
349
327
        self.name = name
350
328
        self.converter = converter
351
329
        self.value_switches = value_switches
352
330
        self.enum_switch = enum_switch
353
 
        self.short_value_switches = short_value_switches
354
331
        self.title = title
355
332
        if self.title is None:
356
333
            self.title = name
357
334
 
358
 
    @property
359
 
    def registry(self):
360
 
        if self._registry is None:
361
 
            self._registry = self._lazy_registry.get_obj()
362
 
        return self._registry
363
 
 
364
335
    @staticmethod
365
336
    def from_kwargs(name_, help=None, title=None, value_switches=False,
366
337
                    enum_switch=True, **kwargs):
368
339
 
369
340
        name, help, value_switches and enum_switch are passed to the
370
341
        RegistryOption constructor.  Any other keyword arguments are treated
371
 
        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.
372
343
        """
373
 
        reg = _mod_registry.Registry()
374
 
        for name, switch_help in sorted(kwargs.items()):
 
344
        reg = registry.Registry()
 
345
        for name, switch_help in kwargs.iteritems():
375
346
            name = name.replace('_', '-')
376
347
            reg.register(name, name, help=switch_help)
377
 
            if not value_switches:
378
 
                help = help + '  "' + name + '": ' + switch_help
379
 
                if not help.endswith("."):
380
 
                    help = help + "."
381
348
        return RegistryOption(name_, help, reg, title=title,
382
349
            value_switches=value_switches, enum_switch=enum_switch)
383
350
 
394
361
                    help = optparse.SUPPRESS_HELP
395
362
                else:
396
363
                    help = self.registry.get_help(key)
397
 
                if (self.short_value_switches and
398
 
                    key in self.short_value_switches):
399
 
                    option_strings.append('-%s' %
400
 
                                          self.short_value_switches[key])
401
364
                parser.add_option(action='callback',
402
365
                              callback=self._optparse_value_callback(key),
403
366
                                  help=help,
433
396
 
434
397
    DEFAULT_VALUE = object()
435
398
 
436
 
    def __init__(self):
437
 
        optparse.OptionParser.__init__(self)
438
 
        self.formatter = GettextIndentedHelpFormatter()
439
 
 
440
399
    def error(self, message):
441
400
        raise errors.BzrCommandError(message)
442
401
 
443
402
 
444
 
class GettextIndentedHelpFormatter(optparse.IndentedHelpFormatter):
445
 
    """Adds gettext() call to format_option()"""
446
 
    def __init__(self):
447
 
        optparse.IndentedHelpFormatter.__init__(self)
448
 
 
449
 
    def format_option(self, option):
450
 
        """code taken from Python's optparse.py"""
451
 
        if option.help:
452
 
            option.help = i18n.gettext(option.help)
453
 
        return optparse.IndentedHelpFormatter.format_option(self, option)
454
 
 
455
 
 
456
403
def get_optparser(options):
457
404
    """Generate an optparse parser for bzrlib-style options"""
458
405
 
477
424
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
478
425
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
479
426
 
480
 
def _standard_list_option(name, **kwargs):
481
 
    """Register a standard option."""
482
 
    # All standard options are implicitly 'global' ones
483
 
    Option.STD_OPTIONS[name] = ListOption(name, **kwargs)
484
 
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
485
 
 
486
427
 
487
428
def _global_option(name, **kwargs):
488
429
    """Register a global option."""
489
430
    Option.OPTIONS[name] = Option(name, **kwargs)
490
431
 
491
432
 
492
 
def _global_registry_option(name, help, registry=None, **kwargs):
 
433
def _global_registry_option(name, help, registry, **kwargs):
493
434
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
494
435
 
495
436
 
 
437
class MergeTypeRegistry(registry.Registry):
 
438
 
 
439
    pass
 
440
 
 
441
 
496
442
# This is the verbosity level detected during command line parsing.
497
443
# Note that the final value is dependent on the order in which the
498
444
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
521
467
            _verbosity_level = -1
522
468
 
523
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
 
524
478
# Declare the standard options
525
479
_standard_option('help', short_name='h',
526
480
                 help='Show help message.')
 
481
_standard_option('verbose', short_name='v',
 
482
                 help='Display more information.',
 
483
                 custom_callback=_verbosity_level_callback)
527
484
_standard_option('quiet', short_name='q',
528
485
                 help="Only display errors and warnings.",
529
486
                 custom_callback=_verbosity_level_callback)
530
 
_standard_option('usage',
531
 
                 help='Show usage message and options.')
532
 
_standard_option('verbose', short_name='v',
533
 
                 help='Display more information.',
534
 
                 custom_callback=_verbosity_level_callback)
535
487
 
536
488
# Declare commonly used options
537
 
_global_option('change',
538
 
               type=_parse_change_str,
539
 
               short_name='c',
540
 
               param_name='revision',
541
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
542
 
_global_option('directory', short_name='d', type=unicode,
543
 
               help='Branch to operate on, instead of working directory.')
 
489
_global_option('all')
 
490
_global_option('overwrite', help='Ignore differences between branches and '
 
491
               'overwrite unconditionally.')
 
492
_global_option('basis', type=str)
 
493
_global_option('bound')
 
494
_global_option('diff-options', type=str)
544
495
_global_option('file', type=unicode, short_name='F')
545
 
_global_registry_option('log-format', "Use specified log format.",
546
 
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
547
 
                        value_switches=True, title='Log format',
548
 
                        short_value_switches={'short': 'S'})
549
 
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
550
 
                        lazy_registry=('bzrlib.merge', 'merge_type_registry'),
551
 
                        value_switches=True, title='Merge algorithm')
 
496
_global_option('force')
 
497
_global_option('format', type=unicode)
 
498
_global_option('forward')
552
499
_global_option('message', type=unicode,
553
500
               short_name='m',
554
501
               help='Message string.')
555
 
_global_option('null', short_name='0',
556
 
                 help='Use an ASCII NUL (\\0) separator rather than '
557
 
                      'a newline.')
558
 
_global_option('overwrite', help='Ignore differences between branches and '
559
 
               'overwrite unconditionally.')
560
 
_global_option('remember', help='Remember the specified location as a'
561
 
               ' default.')
562
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
 
502
_global_option('no-recurse')
 
503
_global_option('profile',
 
504
               help='Show performance profiling information.')
563
505
_global_option('revision',
564
506
               type=_parse_revision_str,
565
507
               short_name='r',
566
508
               help='See "help revisionspec" for details.')
 
509
_global_option('change',
 
510
               type=_parse_change_str,
 
511
               short_name='c',
 
512
               param_name='revision',
 
513
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
567
514
_global_option('show-ids',
568
515
               help='Show internal object ids.')
569
 
_global_option('timezone',
 
516
_global_option('timezone', 
570
517
               type=str,
571
 
               help='Display timezone as local, original, or utc.')
572
 
 
573
 
diff_writer_registry = _mod_registry.Registry()
574
 
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
575
 
diff_writer_registry.default_key = 'plain'
 
518
               help='display timezone as local, original, or utc')
 
519
_global_option('unbound')
 
520
_global_option('version')
 
521
_global_option('email')
 
522
_global_option('update')
 
523
_global_registry_option('log-format', "Use specified log format.",
 
524
                        log.log_formatter_registry, value_switches=True,
 
525
                        title='Log format')
 
526
_global_option('long', help='Use detailed log format. Same as --log-format long',
 
527
               short_name='l')
 
528
_global_option('short', help='Use moderately short log format. Same as --log-format short')
 
529
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
 
530
_global_option('root', type=str)
 
531
_global_option('no-backup')
 
532
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
 
533
                        _merge_type_registry, value_switches=True,
 
534
                        title='Merge algorithm')
 
535
_global_option('pattern', type=str)
 
536
_global_option('remember', help='Remember the specified location as a'
 
537
               ' default.')
 
538
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
 
539
_global_option('kind', type=str)
 
540
_global_option('dry-run',
 
541
               help="Show what would be done, but don't actually do anything.")
 
542
_global_option('name-from-revision', help='The path name in the old tree.')