← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

Late bind to PatienceSequenceMatcher to allow plugin to override.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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
 
from bzrlib.lazy_import import lazy_import
24
 
lazy_import(globals(), """
25
 
from bzrlib import (
26
 
    errors,
27
 
    revisionspec,
28
 
    )
29
 
""")
 
22
import bzrlib.commands
 
23
from bzrlib.trace import warning, mutter
 
24
from bzrlib.revisionspec import RevisionSpec
 
25
from bzrlib.errors import BzrCommandError
30
26
 
31
 
from bzrlib import (
32
 
    log,
33
 
    registry,
34
 
    )
35
27
 
36
28
def _parse_revision_str(revstr):
37
29
    """This handles a revision string -> revno.
40
32
    each revision specifier supplied.
41
33
 
42
34
    >>> _parse_revision_str('234')
43
 
    [<RevisionSpec_revno 234>]
 
35
    [<RevisionSpec_int 234>]
44
36
    >>> _parse_revision_str('234..567')
45
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
 
37
    [<RevisionSpec_int 234>, <RevisionSpec_int 567>]
46
38
    >>> _parse_revision_str('..')
47
39
    [<RevisionSpec None>, <RevisionSpec None>]
48
40
    >>> _parse_revision_str('..234')
49
 
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
 
41
    [<RevisionSpec None>, <RevisionSpec_int 234>]
50
42
    >>> _parse_revision_str('234..')
51
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
 
43
    [<RevisionSpec_int 234>, <RevisionSpec None>]
52
44
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
53
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
 
45
    [<RevisionSpec_int 234>, <RevisionSpec_int 456>, <RevisionSpec_int 789>]
54
46
    >>> _parse_revision_str('234....789') #Error ?
55
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
 
47
    [<RevisionSpec_int 234>, <RevisionSpec None>, <RevisionSpec_int 789>]
56
48
    >>> _parse_revision_str('revid:test@other.com-234234')
57
49
    [<RevisionSpec_revid revid:test@other.com-234234>]
58
50
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
59
51
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
60
52
    >>> _parse_revision_str('revid:test@other.com-234234..23')
61
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
 
53
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_int 23>]
62
54
    >>> _parse_revision_str('date:2005-04-12')
63
55
    [<RevisionSpec_date date:2005-04-12>]
64
56
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
68
60
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
69
61
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
70
62
    >>> _parse_revision_str('-5..23')
71
 
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
 
63
    [<RevisionSpec_int -5>, <RevisionSpec_int 23>]
72
64
    >>> _parse_revision_str('-5')
73
 
    [<RevisionSpec_revno -5>]
 
65
    [<RevisionSpec_int -5>]
74
66
    >>> _parse_revision_str('123a')
75
67
    Traceback (most recent call last):
76
68
      ...
77
 
    NoSuchRevisionSpec: No namespace registered for string: '123a'
 
69
    BzrError: No namespace registered for string: '123a'
78
70
    >>> _parse_revision_str('abc')
79
71
    Traceback (most recent call last):
80
72
      ...
81
 
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
 
73
    BzrError: No namespace registered for string: 'abc'
82
74
    >>> _parse_revision_str('branch:../branch2')
83
75
    [<RevisionSpec_branch branch:../branch2>]
84
76
    >>> _parse_revision_str('branch:../../branch2')
85
77
    [<RevisionSpec_branch branch:../../branch2>]
86
78
    >>> _parse_revision_str('branch:../../branch2..23')
87
 
    [<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>]
 
79
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_int 23>]
92
80
    """
93
81
    # TODO: Maybe move this into revisionspec.py
 
82
    old_format_re = re.compile('\d*:\d*')
 
83
    m = old_format_re.match(revstr)
94
84
    revs = []
95
 
    # split on .. that is not followed by a / or \
96
 
    sep = re.compile(r'\.\.(?![\\/])')
97
 
    for x in sep.split(revstr):
98
 
        revs.append(revisionspec.RevisionSpec.from_string(x or None))
 
85
    if m:
 
86
        warning('Colon separator for revision numbers is deprecated.'
 
87
                ' Use .. instead')
 
88
        for rev in revstr.split(':'):
 
89
            if rev:
 
90
                revs.append(RevisionSpec(int(rev)))
 
91
            else:
 
92
                revs.append(RevisionSpec(None))
 
93
    else:
 
94
        sep = re.compile("\\.\\.(?!/)")
 
95
        for x in sep.split(revstr):
 
96
            revs.append(RevisionSpec(x or None))
99
97
    return revs
100
98
 
101
99
 
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
100
def _parse_merge_type(typestring):
121
101
    return get_merge_type(typestring)
122
102
 
131
111
        type_list = '\n'.join(lines)
132
112
        msg = "No known merge type %s. Supported types are:\n%s" %\
133
113
            (typestring, type_list)
134
 
        raise errors.BzrCommandError(msg)
135
 
 
 
114
        raise BzrCommandError(msg)
136
115
 
137
116
class Option(object):
138
 
    """Description of a command line option
139
 
    
140
 
    :ivar _short_name: If this option has a single-letter name, this is it.
141
 
    Otherwise None.
142
 
    """
143
 
 
144
 
    # The dictionary of standard options. These are always legal.
145
 
    STD_OPTIONS = {}
146
 
 
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.
 
117
    """Description of a command line option"""
 
118
    # TODO: Some way to show in help a description of the option argument
 
119
 
150
120
    OPTIONS = {}
 
121
    SHORT_OPTIONS = {}
151
122
 
152
 
    def __init__(self, name, help='', type=None, argname=None,
153
 
                 short_name=None, param_name=None, custom_callback=None):
 
123
    def __init__(self, name, help='', type=None, argname=None):
154
124
        """Make a new command option.
155
125
 
156
 
        :param name: regular name of the command, used in the double-dash
 
126
        name -- regular name of the command, used in the double-dash
157
127
            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 
 
128
            method.
 
129
 
 
130
        help -- help message displayed in command help
 
131
 
 
132
        type -- function called to parse the option argument, or 
163
133
            None (default) if this option doesn't take an argument.
164
134
 
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).
 
135
        argname -- name of option argument, if any
176
136
        """
 
137
        # TODO: perhaps a subclass that automatically does 
 
138
        # --option, --no-option for reversable booleans
177
139
        self.name = name
178
140
        self.help = help
179
141
        self.type = type
180
 
        self._short_name = short_name
181
142
        if type is None:
182
 
            if argname:
183
 
                raise ValueError('argname not valid for booleans')
 
143
            assert argname is None
184
144
        elif argname is None:
185
145
            argname = 'ARG'
186
146
        self.argname = argname
187
 
        if param_name is None:
188
 
            self._param_name = self.name.replace('-', '_')
189
 
        else:
190
 
            self._param_name = param_name
191
 
        self.custom_callback = custom_callback
192
147
 
193
148
    def short_name(self):
194
 
        if self._short_name:
195
 
            return self._short_name
196
 
 
197
 
    def set_short_name(self, short_name):
198
 
        self._short_name = short_name
199
 
 
200
 
    def get_negation_name(self):
201
 
        if self.name.startswith('no-'):
202
 
            return self.name[3:]
203
 
        else:
204
 
            return 'no-' + self.name
205
 
 
206
 
    def add_option(self, parser, short_name):
207
 
        """Add this option to an Optparse parser"""
208
 
        option_strings = ['--%s' % self.name]
209
 
        if short_name is not None:
210
 
            option_strings.append('-%s' % short_name)
211
 
        optargfn = self.type
212
 
        if optargfn is None:
213
 
            parser.add_option(action='callback',
214
 
                              callback=self._optparse_bool_callback,
215
 
                              callback_args=(True,),
216
 
                              help=self.help,
217
 
                              *option_strings)
218
 
            negation_strings = ['--%s' % self.get_negation_name()]
219
 
            parser.add_option(action='callback',
220
 
                              callback=self._optparse_bool_callback,
221
 
                              callback_args=(False,),
222
 
                              help=optparse.SUPPRESS_HELP, *negation_strings)
223
 
        else:
224
 
            parser.add_option(action='callback',
225
 
                              callback=self._optparse_callback,
226
 
                              type='string', metavar=self.argname.upper(),
227
 
                              help=self.help,
228
 
                              default=OptionParser.DEFAULT_VALUE,
229
 
                              *option_strings)
230
 
 
231
 
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
232
 
        setattr(parser.values, self._param_name, bool_v)
233
 
        if self.custom_callback is not None:
234
 
            self.custom_callback(option, self._param_name, bool_v, parser)
235
 
 
236
 
    def _optparse_callback(self, option, opt, value, parser):
237
 
        v = self.type(value)
238
 
        setattr(parser.values, self._param_name, v)
239
 
        if self.custom_callback is not None:
240
 
            self.custom_callback(option, self.name, v, parser)
241
 
 
242
 
    def iter_switches(self):
243
 
        """Iterate through the list of switches provided by the option
244
 
        
245
 
        :return: an iterator of (name, short_name, argname, help)
246
 
        """
247
 
        argname =  self.argname
248
 
        if argname is not None:
249
 
            argname = argname.upper()
250
 
        yield self.name, self.short_name(), argname, self.help
251
 
 
252
 
    def is_hidden(self, name):
253
 
        return False
254
 
 
255
 
 
256
 
class ListOption(Option):
257
 
    """Option used to provide a list of values.
258
 
 
259
 
    On the command line, arguments are specified by a repeated use of the
260
 
    option. '-' is a special argument that resets the list. For example,
261
 
      --foo=a --foo=b
262
 
    sets the value of the 'foo' option to ['a', 'b'], and
263
 
      --foo=a --foo=b --foo=- --foo=c
264
 
    sets the value of the 'foo' option to ['c'].
265
 
    """
266
 
 
267
 
    def add_option(self, parser, short_name):
268
 
        """Add this option to an Optparse parser."""
269
 
        option_strings = ['--%s' % self.name]
270
 
        if short_name is not None:
271
 
            option_strings.append('-%s' % short_name)
272
 
        parser.add_option(action='callback',
273
 
                          callback=self._optparse_callback,
274
 
                          type='string', metavar=self.argname.upper(),
275
 
                          help=self.help, default=[],
276
 
                          *option_strings)
277
 
 
278
 
    def _optparse_callback(self, option, opt, value, parser):
279
 
        values = getattr(parser.values, self._param_name)
280
 
        if value == '-':
281
 
            del values[:]
282
 
        else:
283
 
            values.append(self.type(value))
284
 
        if self.custom_callback is not None:
285
 
            self.custom_callback(option, self._param_name, values, parser)
286
 
 
287
 
 
288
 
class RegistryOption(Option):
289
 
    """Option based on a registry
290
 
 
291
 
    The values for the options correspond to entries in the registry.  Input
292
 
    must be a registry key.  After validation, it is converted into an object
293
 
    using Registry.get or a caller-provided converter.
294
 
    """
295
 
 
296
 
    def validate_value(self, value):
297
 
        """Validate a value name"""
298
 
        if value not in self.registry:
299
 
            raise errors.BadOptionValue(self.name, value)
300
 
 
301
 
    def convert(self, value):
302
 
        """Convert a value name into an output type"""
303
 
        self.validate_value(value)
304
 
        if self.converter is None:
305
 
            return self.registry.get(value)
306
 
        else:
307
 
            return self.converter(value)
308
 
 
309
 
    def __init__(self, name, help, registry, converter=None,
310
 
        value_switches=False, title=None, enum_switch=True):
311
 
        """
312
 
        Constructor.
313
 
 
314
 
        :param name: The option name.
315
 
        :param help: Help for the option.
316
 
        :param registry: A Registry containing the values
317
 
        :param converter: Callable to invoke with the value name to produce
318
 
            the value.  If not supplied, self.registry.get is used.
319
 
        :param value_switches: If true, each possible value is assigned its
320
 
            own switch.  For example, instead of '--format knit',
321
 
            '--knit' can be used interchangeably.
322
 
        :param enum_switch: If true, a switch is provided with the option name,
323
 
            which takes a value.
324
 
        """
325
 
        Option.__init__(self, name, help, type=self.convert)
326
 
        self.registry = registry
327
 
        self.name = name
328
 
        self.converter = converter
329
 
        self.value_switches = value_switches
330
 
        self.enum_switch = enum_switch
331
 
        self.title = title
332
 
        if self.title is None:
333
 
            self.title = name
334
 
 
335
 
    @staticmethod
336
 
    def from_kwargs(name_, help=None, title=None, value_switches=False,
337
 
                    enum_switch=True, **kwargs):
338
 
        """Convenience method to generate string-map registry options
339
 
 
340
 
        name, help, value_switches and enum_switch are passed to the
341
 
        RegistryOption constructor.  Any other keyword arguments are treated
342
 
        as values for the option, and they value is treated as the help.
343
 
        """
344
 
        reg = registry.Registry()
345
 
        for name, switch_help in kwargs.iteritems():
346
 
            name = name.replace('_', '-')
347
 
            reg.register(name, name, help=switch_help)
348
 
            if not value_switches:
349
 
                help = help + '  "' + name + '": ' + switch_help
350
 
                if not help.endswith("."):
351
 
                    help = help + "."
352
 
        return RegistryOption(name_, help, reg, title=title,
353
 
            value_switches=value_switches, enum_switch=enum_switch)
354
 
 
355
 
    def add_option(self, parser, short_name):
356
 
        """Add this option to an Optparse parser"""
357
 
        if self.value_switches:
358
 
            parser = parser.add_option_group(self.title)
359
 
        if self.enum_switch:
360
 
            Option.add_option(self, parser, short_name)
361
 
        if self.value_switches:
362
 
            for key in self.registry.keys():
363
 
                option_strings = ['--%s' % key]
364
 
                if self.is_hidden(key):
365
 
                    help = optparse.SUPPRESS_HELP
366
 
                else:
367
 
                    help = self.registry.get_help(key)
368
 
                parser.add_option(action='callback',
369
 
                              callback=self._optparse_value_callback(key),
370
 
                                  help=help,
371
 
                                  *option_strings)
372
 
 
373
 
    def _optparse_value_callback(self, cb_value):
374
 
        def cb(option, opt, value, parser):
375
 
            v = self.type(cb_value)
376
 
            setattr(parser.values, self._param_name, v)
377
 
            if self.custom_callback is not None:
378
 
                self.custom_callback(option, self._param_name, v, parser)
379
 
        return cb
380
 
 
381
 
    def iter_switches(self):
382
 
        """Iterate through the list of switches provided by the option
383
 
 
384
 
        :return: an iterator of (name, short_name, argname, help)
385
 
        """
386
 
        for value in Option.iter_switches(self):
387
 
            yield value
388
 
        if self.value_switches:
389
 
            for key in sorted(self.registry.keys()):
390
 
                yield key, None, None, self.registry.get_help(key)
391
 
 
392
 
    def is_hidden(self, name):
393
 
        if name == self.name:
394
 
            return Option.is_hidden(self, name)
395
 
        return getattr(self.registry.get_info(name), 'hidden', False)
396
 
 
397
 
 
398
 
class OptionParser(optparse.OptionParser):
399
 
    """OptionParser that raises exceptions instead of exiting"""
400
 
 
401
 
    DEFAULT_VALUE = object()
402
 
 
403
 
    def error(self, message):
404
 
        raise errors.BzrCommandError(message)
405
 
 
406
 
 
407
 
def get_optparser(options):
408
 
    """Generate an optparse parser for bzrlib-style options"""
409
 
 
410
 
    parser = OptionParser()
411
 
    parser.remove_option('--help')
412
 
    for option in options.itervalues():
413
 
        option.add_option(parser, option.short_name())
414
 
    return parser
415
 
 
416
 
 
417
 
def custom_help(name, help):
418
 
    """Clone a common option overriding the help."""
419
 
    import copy
420
 
    o = copy.copy(Option.OPTIONS[name])
421
 
    o.help = help
422
 
    return o
423
 
 
424
 
 
425
 
def _standard_option(name, **kwargs):
426
 
    """Register a standard option."""
427
 
    # All standard options are implicitly 'global' ones
428
 
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
429
 
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
 
149
        """Return the single character option for this command, if any.
 
150
 
 
151
        Short options are globally registered.
 
152
        """
 
153
        for short, option in Option.SHORT_OPTIONS.iteritems():
 
154
            if option is self:
 
155
                return short
430
156
 
431
157
 
432
158
def _global_option(name, **kwargs):
433
 
    """Register a global option."""
 
159
    """Register o as a global option."""
434
160
    Option.OPTIONS[name] = Option(name, **kwargs)
435
161
 
436
 
 
437
 
def _global_registry_option(name, help, registry, **kwargs):
438
 
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
439
 
 
440
 
 
441
 
class MergeTypeRegistry(registry.Registry):
442
 
 
443
 
    pass
444
 
 
445
 
 
446
 
# This is the verbosity level detected during command line parsing.
447
 
# Note that the final value is dependent on the order in which the
448
 
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
449
 
# The final value will be one of the following:
450
 
#
451
 
# * -ve for quiet
452
 
# * 0 for normal
453
 
# * +ve for verbose
454
 
_verbosity_level = 0
455
 
 
456
 
 
457
 
def _verbosity_level_callback(option, opt_str, value, parser):
458
 
    global _verbosity_level
459
 
    if not value:
460
 
        # Either --no-verbose or --no-quiet was specified
461
 
        _verbosity_level = 0
462
 
    elif opt_str == "verbose":
463
 
        if _verbosity_level > 0:
464
 
            _verbosity_level += 1
465
 
        else:
466
 
            _verbosity_level = 1
467
 
    else:
468
 
        if _verbosity_level < 0:
469
 
            _verbosity_level -= 1
470
 
        else:
471
 
            _verbosity_level = -1
472
 
 
473
 
 
474
 
_merge_type_registry = MergeTypeRegistry()
475
 
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
476
 
                                   "Native diff3-style merge")
477
 
_merge_type_registry.register_lazy('diff3', 'bzrlib.merge', 'Diff3Merger',
478
 
                                   "Merge using external diff3")
479
 
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
480
 
                                   "Weave-based merge")
481
 
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
482
 
                                   "LCA-newness merge")
483
 
 
484
 
# Declare the standard options
485
 
_standard_option('help', short_name='h',
486
 
                 help='Show help message.')
487
 
_standard_option('verbose', short_name='v',
488
 
                 help='Display more information.',
489
 
                 custom_callback=_verbosity_level_callback)
490
 
_standard_option('quiet', short_name='q',
491
 
                 help="Only display errors and warnings.",
492
 
                 custom_callback=_verbosity_level_callback)
493
 
 
494
 
# Declare commonly used options
495
162
_global_option('all')
496
163
_global_option('overwrite', help='Ignore differences between branches and '
497
 
               'overwrite unconditionally.')
 
164
               'overwrite unconditionally')
498
165
_global_option('basis', type=str)
499
166
_global_option('bound')
500
167
_global_option('diff-options', type=str)
501
 
_global_option('file', type=unicode, short_name='F')
 
168
_global_option('help',
 
169
               help='show help message')
 
170
_global_option('file', type=unicode)
502
171
_global_option('force')
503
172
_global_option('format', type=unicode)
504
173
_global_option('forward')
505
 
_global_option('message', type=unicode,
506
 
               short_name='m',
507
 
               help='Message string.')
 
174
_global_option('message', type=unicode)
508
175
_global_option('no-recurse')
 
176
_global_option('prefix', type=str, 
 
177
               help='Set prefixes to added to old and new filenames, as '
 
178
                    'two values separated by a colon.')
509
179
_global_option('profile',
510
 
               help='Show performance profiling information.')
511
 
_global_option('revision',
512
 
               type=_parse_revision_str,
513
 
               short_name='r',
514
 
               help='See "help revisionspec" for details.')
515
 
_global_option('change',
516
 
               type=_parse_change_str,
517
 
               short_name='c',
518
 
               param_name='revision',
519
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
520
 
_global_option('show-ids',
521
 
               help='Show internal object ids.')
 
180
               help='show performance profiling information')
 
181
_global_option('revision', type=_parse_revision_str)
 
182
_global_option('show-ids', 
 
183
               help='show internal object ids')
522
184
_global_option('timezone', 
523
185
               type=str,
524
186
               help='display timezone as local, original, or utc')
525
187
_global_option('unbound')
 
188
_global_option('verbose',
 
189
               help='display more information')
526
190
_global_option('version')
527
191
_global_option('email')
528
192
_global_option('update')
529
 
_global_registry_option('log-format', "Use specified log format.",
530
 
                        log.log_formatter_registry, value_switches=True,
531
 
                        title='Log format')
532
 
_global_option('long', help='Use detailed log format. Same as --log-format long',
533
 
               short_name='l')
 
193
_global_option('log-format', type=str, help="Use this log format")
 
194
_global_option('long', help='Use detailed log format. Same as --log-format long')
534
195
_global_option('short', help='Use moderately short log format. Same as --log-format short')
535
196
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
536
197
_global_option('root', type=str)
537
198
_global_option('no-backup')
538
 
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
539
 
                        _merge_type_registry, value_switches=True,
540
 
                        title='Merge algorithm')
 
199
_global_option('merge-type', type=_parse_merge_type, 
 
200
               help='Select a particular merge algorithm')
541
201
_global_option('pattern', type=str)
 
202
_global_option('quiet')
542
203
_global_option('remember', help='Remember the specified location as a'
543
204
               ' default.')
544
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
 
205
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
545
206
_global_option('kind', type=str)
546
207
_global_option('dry-run',
547
 
               help="Show what would be done, but don't actually do anything.")
548
 
_global_option('name-from-revision', help='The path name in the old tree.')
 
208
               help="show what would be done, but don't actually do anything")
 
209
 
 
210
 
 
211
def _global_short(short_name, long_name):
 
212
    assert short_name not in Option.SHORT_OPTIONS
 
213
    Option.SHORT_OPTIONS[short_name] = Option.OPTIONS[long_name]
 
214
    
 
215
 
 
216
Option.SHORT_OPTIONS['F'] = Option.OPTIONS['file']
 
217
Option.SHORT_OPTIONS['h'] = Option.OPTIONS['help']
 
218
Option.SHORT_OPTIONS['m'] = Option.OPTIONS['message']
 
219
Option.SHORT_OPTIONS['r'] = Option.OPTIONS['revision']
 
220
Option.SHORT_OPTIONS['v'] = Option.OPTIONS['verbose']
 
221
Option.SHORT_OPTIONS['l'] = Option.OPTIONS['long']
 
222
Option.SHORT_OPTIONS['q'] = Option.OPTIONS['quiet']
 
223
Option.SHORT_OPTIONS['p'] = Option.OPTIONS['prefix']