/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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) 2005-2010 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., 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.
29
29
""")
30
30
 
31
31
from bzrlib import (
32
 
    log,
33
 
    registry,
 
32
    registry as _mod_registry,
34
33
    )
35
34
 
 
35
 
36
36
def _parse_revision_str(revstr):
37
37
    """This handles a revision string -> revno.
38
38
 
40
40
    each revision specifier supplied.
41
41
 
42
42
    >>> _parse_revision_str('234')
43
 
    [<RevisionSpec_revno 234>]
 
43
    [<RevisionSpec_dwim 234>]
44
44
    >>> _parse_revision_str('234..567')
45
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
 
45
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
46
46
    >>> _parse_revision_str('..')
47
47
    [<RevisionSpec None>, <RevisionSpec None>]
48
48
    >>> _parse_revision_str('..234')
49
 
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
 
49
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
50
50
    >>> _parse_revision_str('234..')
51
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
 
51
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
52
52
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
53
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
 
53
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
54
54
    >>> _parse_revision_str('234....789') #Error ?
55
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
 
55
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
56
56
    >>> _parse_revision_str('revid:test@other.com-234234')
57
57
    [<RevisionSpec_revid revid:test@other.com-234234>]
58
58
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
59
59
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
60
60
    >>> _parse_revision_str('revid:test@other.com-234234..23')
61
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
 
61
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
62
62
    >>> _parse_revision_str('date:2005-04-12')
63
63
    [<RevisionSpec_date date:2005-04-12>]
64
64
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
68
68
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
69
69
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
70
70
    >>> _parse_revision_str('-5..23')
71
 
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
 
71
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
72
72
    >>> _parse_revision_str('-5')
73
 
    [<RevisionSpec_revno -5>]
 
73
    [<RevisionSpec_dwim -5>]
74
74
    >>> _parse_revision_str('123a')
75
 
    Traceback (most recent call last):
76
 
      ...
77
 
    NoSuchRevisionSpec: No namespace registered for string: '123a'
 
75
    [<RevisionSpec_dwim 123a>]
78
76
    >>> _parse_revision_str('abc')
79
 
    Traceback (most recent call last):
80
 
      ...
81
 
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
 
77
    [<RevisionSpec_dwim abc>]
82
78
    >>> _parse_revision_str('branch:../branch2')
83
79
    [<RevisionSpec_branch branch:../branch2>]
84
80
    >>> _parse_revision_str('branch:../../branch2')
85
81
    [<RevisionSpec_branch branch:../../branch2>]
86
82
    >>> _parse_revision_str('branch:../../branch2..23')
87
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
 
83
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
88
84
    >>> _parse_revision_str('branch:..\\\\branch2')
89
85
    [<RevisionSpec_branch branch:..\\branch2>]
90
86
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
91
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
 
87
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
92
88
    """
93
89
    # TODO: Maybe move this into revisionspec.py
94
90
    revs = []
104
100
    parent of the revision.
105
101
 
106
102
    >>> _parse_change_str('123')
107
 
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
 
103
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
108
104
    >>> _parse_change_str('123..124')
109
105
    Traceback (most recent call last):
110
106
      ...
136
132
 
137
133
class Option(object):
138
134
    """Description of a command line option
139
 
    
 
135
 
140
136
    :ivar _short_name: If this option has a single-letter name, this is it.
141
137
    Otherwise None.
142
138
    """
150
146
    OPTIONS = {}
151
147
 
152
148
    def __init__(self, name, help='', type=None, argname=None,
153
 
                 short_name=None, param_name=None, custom_callback=None):
 
149
                 short_name=None, param_name=None, custom_callback=None,
 
150
                 hidden=False):
154
151
        """Make a new command option.
155
152
 
156
153
        :param name: regular name of the command, used in the double-dash
157
 
            form and also as the parameter to the command's run() 
 
154
            form and also as the parameter to the command's run()
158
155
            method (unless param_name is specified).
159
156
 
160
157
        :param help: help message displayed in command help
161
158
 
162
 
        :param type: function called to parse the option argument, or 
 
159
        :param type: function called to parse the option argument, or
163
160
            None (default) if this option doesn't take an argument.
164
161
 
165
162
        :param argname: name of option argument, if any
173
170
        :param custom_callback: a callback routine to be called after normal
174
171
            processing. The signature of the callback routine is
175
172
            (option, name, new_value, parser).
 
173
        :param hidden: If True, the option should be hidden in help and
 
174
            documentation.
176
175
        """
177
176
        self.name = name
178
177
        self.help = help
179
178
        self.type = type
180
179
        self._short_name = short_name
181
180
        if type is None:
182
 
            assert argname is None
 
181
            if argname:
 
182
                raise ValueError('argname not valid for booleans')
183
183
        elif argname is None:
184
184
            argname = 'ARG'
185
185
        self.argname = argname
186
186
        if param_name is None:
187
 
            self._param_name = self.name
 
187
            self._param_name = self.name.replace('-', '_')
188
188
        else:
189
189
            self._param_name = param_name
190
190
        self.custom_callback = custom_callback
 
191
        self.hidden = hidden
191
192
 
192
193
    def short_name(self):
193
194
        if self._short_name:
207
208
        option_strings = ['--%s' % self.name]
208
209
        if short_name is not None:
209
210
            option_strings.append('-%s' % short_name)
 
211
        if self.hidden:
 
212
            help = optparse.SUPPRESS_HELP
 
213
        else:
 
214
            help = self.help
210
215
        optargfn = self.type
211
216
        if optargfn is None:
212
 
            parser.add_option(action='callback', 
213
 
                              callback=self._optparse_bool_callback, 
 
217
            parser.add_option(action='callback',
 
218
                              callback=self._optparse_bool_callback,
214
219
                              callback_args=(True,),
215
 
                              help=self.help,
 
220
                              help=help,
216
221
                              *option_strings)
217
222
            negation_strings = ['--%s' % self.get_negation_name()]
218
 
            parser.add_option(action='callback', 
219
 
                              callback=self._optparse_bool_callback, 
 
223
            parser.add_option(action='callback',
 
224
                              callback=self._optparse_bool_callback,
220
225
                              callback_args=(False,),
221
226
                              help=optparse.SUPPRESS_HELP, *negation_strings)
222
227
        else:
223
 
            parser.add_option(action='callback', 
224
 
                              callback=self._optparse_callback, 
 
228
            parser.add_option(action='callback',
 
229
                              callback=self._optparse_callback,
225
230
                              type='string', metavar=self.argname.upper(),
226
 
                              help=self.help,
227
 
                              default=OptionParser.DEFAULT_VALUE, 
 
231
                              help=help,
 
232
                              default=OptionParser.DEFAULT_VALUE,
228
233
                              *option_strings)
229
234
 
230
235
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
240
245
 
241
246
    def iter_switches(self):
242
247
        """Iterate through the list of switches provided by the option
243
 
        
 
248
 
244
249
        :return: an iterator of (name, short_name, argname, help)
245
250
        """
246
251
        argname =  self.argname
249
254
        yield self.name, self.short_name(), argname, self.help
250
255
 
251
256
    def is_hidden(self, name):
252
 
        return False
 
257
        return self.hidden
253
258
 
254
259
 
255
260
class ListOption(Option):
271
276
        parser.add_option(action='callback',
272
277
                          callback=self._optparse_callback,
273
278
                          type='string', metavar=self.argname.upper(),
274
 
                          help=self.help, default=[],
 
279
                          help=self.help, dest=self._param_name, default=[],
275
280
                          *option_strings)
276
281
 
277
282
    def _optparse_callback(self, option, opt, value, parser):
305
310
        else:
306
311
            return self.converter(value)
307
312
 
308
 
    def __init__(self, name, help, registry, converter=None,
309
 
        value_switches=False, title=None, enum_switch=True):
 
313
    def __init__(self, name, help, registry=None, converter=None,
 
314
        value_switches=False, title=None, enum_switch=True,
 
315
        lazy_registry=None):
310
316
        """
311
317
        Constructor.
312
318
 
320
326
            '--knit' can be used interchangeably.
321
327
        :param enum_switch: If true, a switch is provided with the option name,
322
328
            which takes a value.
 
329
        :param lazy_registry: A tuple of (module name, attribute name) for a
 
330
            registry to be lazily loaded.
323
331
        """
324
332
        Option.__init__(self, name, help, type=self.convert)
325
 
        self.registry = registry
 
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')
326
343
        self.name = name
327
344
        self.converter = converter
328
345
        self.value_switches = value_switches
331
348
        if self.title is None:
332
349
            self.title = name
333
350
 
 
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
 
334
357
    @staticmethod
335
358
    def from_kwargs(name_, help=None, title=None, value_switches=False,
336
359
                    enum_switch=True, **kwargs):
338
361
 
339
362
        name, help, value_switches and enum_switch are passed to the
340
363
        RegistryOption constructor.  Any other keyword arguments are treated
341
 
        as values for the option, and they value is treated as the help.
 
364
        as values for the option, and their value is treated as the help.
342
365
        """
343
 
        reg = registry.Registry()
344
 
        for name, switch_help in kwargs.iteritems():
 
366
        reg = _mod_registry.Registry()
 
367
        for name, switch_help in sorted(kwargs.items()):
345
368
            name = name.replace('_', '-')
346
369
            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 + "."
347
374
        return RegistryOption(name_, help, reg, title=title,
348
375
            value_switches=value_switches, enum_switch=enum_switch)
349
376
 
429
456
    Option.OPTIONS[name] = Option(name, **kwargs)
430
457
 
431
458
 
432
 
def _global_registry_option(name, help, registry, **kwargs):
 
459
def _global_registry_option(name, help, registry=None, **kwargs):
433
460
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
434
461
 
435
462
 
436
 
class MergeTypeRegistry(registry.Registry):
437
 
 
438
 
    pass
439
 
 
440
 
 
441
463
# This is the verbosity level detected during command line parsing.
442
464
# Note that the final value is dependent on the order in which the
443
465
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
466
488
            _verbosity_level = -1
467
489
 
468
490
 
 
491
class MergeTypeRegistry(_mod_registry.Registry):
 
492
 
 
493
    pass
 
494
 
 
495
 
469
496
_merge_type_registry = MergeTypeRegistry()
470
497
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
471
498
                                   "Native diff3-style merge")
479
506
# Declare the standard options
480
507
_standard_option('help', short_name='h',
481
508
                 help='Show help message.')
 
509
_standard_option('usage',
 
510
                 help='Show usage message and options.')
482
511
_standard_option('verbose', short_name='v',
483
512
                 help='Display more information.',
484
513
                 custom_callback=_verbosity_level_callback)
514
543
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
515
544
_global_option('show-ids',
516
545
               help='Show internal object ids.')
517
 
_global_option('timezone', 
 
546
_global_option('timezone',
518
547
               type=str,
519
 
               help='display timezone as local, original, or utc')
 
548
               help='Display timezone as local, original, or utc.')
520
549
_global_option('unbound')
521
550
_global_option('version')
522
551
_global_option('email')
523
552
_global_option('update')
524
553
_global_registry_option('log-format', "Use specified log format.",
525
 
                        log.log_formatter_registry, value_switches=True,
526
 
                        title='Log format')
 
554
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
 
555
                        value_switches=True, title='Log format')
527
556
_global_option('long', help='Use detailed log format. Same as --log-format long',
528
557
               short_name='l')
529
558
_global_option('short', help='Use moderately short log format. Same as --log-format short')
541
570
_global_option('dry-run',
542
571
               help="Show what would be done, but don't actually do anything.")
543
572
_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'