← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: John Arbash Meinel
  • Date: 2007-11-13 20:37:09 UTC
  • mto: This revision was merged to the branch mainline in revision 3001.
  • Revision ID: john@arbash-meinel.com-20071113203709-kysdte0emqv84pnj
https://launchpad.net/bugs/162486
Fix bug #162486, by having RemoteBranch properly initialize self._revision_id_to_revno_map.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2004, 2005, 2006, 2007 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
16
16
 
 
17
# TODO: For things like --diff-prefix, we want a way to customize the display
 
18
# of the option argument.
17
19
 
18
20
import re
19
21
 
20
 
import bzrlib.commands
21
 
from bzrlib.trace import warning, mutter
22
 
from bzrlib.revisionspec import RevisionSpec
23
 
from bzrlib.errors import BzrCommandError
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
 
24
import optparse
 
25
 
 
26
from bzrlib import (
 
27
    errors,
 
28
    log,
 
29
    registry,
 
30
    revisionspec,
 
31
    symbol_versioning,
 
32
    )
 
33
""")
 
34
from bzrlib.trace import warning
24
35
 
25
36
 
26
37
def _parse_revision_str(revstr):
30
41
    each revision specifier supplied.
31
42
 
32
43
    >>> _parse_revision_str('234')
33
 
    [<RevisionSpec_int 234>]
 
44
    [<RevisionSpec_revno 234>]
34
45
    >>> _parse_revision_str('234..567')
35
 
    [<RevisionSpec_int 234>, <RevisionSpec_int 567>]
 
46
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
36
47
    >>> _parse_revision_str('..')
37
48
    [<RevisionSpec None>, <RevisionSpec None>]
38
49
    >>> _parse_revision_str('..234')
39
 
    [<RevisionSpec None>, <RevisionSpec_int 234>]
 
50
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
40
51
    >>> _parse_revision_str('234..')
41
 
    [<RevisionSpec_int 234>, <RevisionSpec None>]
 
52
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
42
53
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
43
 
    [<RevisionSpec_int 234>, <RevisionSpec_int 456>, <RevisionSpec_int 789>]
 
54
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
44
55
    >>> _parse_revision_str('234....789') #Error ?
45
 
    [<RevisionSpec_int 234>, <RevisionSpec None>, <RevisionSpec_int 789>]
 
56
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
46
57
    >>> _parse_revision_str('revid:test@other.com-234234')
47
58
    [<RevisionSpec_revid revid:test@other.com-234234>]
48
59
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
49
60
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
50
61
    >>> _parse_revision_str('revid:test@other.com-234234..23')
51
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_int 23>]
 
62
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
52
63
    >>> _parse_revision_str('date:2005-04-12')
53
64
    [<RevisionSpec_date date:2005-04-12>]
54
65
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
58
69
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
59
70
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
60
71
    >>> _parse_revision_str('-5..23')
61
 
    [<RevisionSpec_int -5>, <RevisionSpec_int 23>]
 
72
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
62
73
    >>> _parse_revision_str('-5')
63
 
    [<RevisionSpec_int -5>]
 
74
    [<RevisionSpec_revno -5>]
64
75
    >>> _parse_revision_str('123a')
65
76
    Traceback (most recent call last):
66
77
      ...
67
 
    BzrError: No namespace registered for string: '123a'
 
78
    NoSuchRevisionSpec: No namespace registered for string: '123a'
68
79
    >>> _parse_revision_str('abc')
69
80
    Traceback (most recent call last):
70
81
      ...
71
 
    BzrError: No namespace registered for string: 'abc'
 
82
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
72
83
    >>> _parse_revision_str('branch:../branch2')
73
84
    [<RevisionSpec_branch branch:../branch2>]
 
85
    >>> _parse_revision_str('branch:../../branch2')
 
86
    [<RevisionSpec_branch branch:../../branch2>]
 
87
    >>> _parse_revision_str('branch:../../branch2..23')
 
88
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
 
89
    >>> _parse_revision_str('branch:..\\\\branch2')
 
90
    [<RevisionSpec_branch branch:..\\branch2>]
 
91
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
 
92
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
74
93
    """
75
94
    # TODO: Maybe move this into revisionspec.py
76
 
    old_format_re = re.compile('\d*:\d*')
77
 
    m = old_format_re.match(revstr)
78
95
    revs = []
79
 
    if m:
80
 
        warning('Colon separator for revision numbers is deprecated.'
81
 
                ' Use .. instead')
82
 
        for rev in revstr.split(':'):
83
 
            if rev:
84
 
                revs.append(RevisionSpec(int(rev)))
85
 
            else:
86
 
                revs.append(RevisionSpec(None))
87
 
    else:
88
 
        next_prefix = None
89
 
        for x in revstr.split('..'):
90
 
            if not x:
91
 
                revs.append(RevisionSpec(None))
92
 
            elif x[-1] == ':':
93
 
                # looks like a namespace:.. has happened
94
 
                next_prefix = x + '..'
95
 
            else:
96
 
                if next_prefix is not None:
97
 
                    x = next_prefix + x
98
 
                revs.append(RevisionSpec(x))
99
 
                next_prefix = None
100
 
        if next_prefix is not None:
101
 
            revs.append(RevisionSpec(next_prefix))
 
96
    # split on .. that is not followed by a / or \
 
97
    sep = re.compile(r'\.\.(?![\\/])')
 
98
    for x in sep.split(revstr):
 
99
        revs.append(revisionspec.RevisionSpec.from_string(x or None))
102
100
    return revs
103
101
 
104
102
 
 
103
def _parse_change_str(revstr):
 
104
    """Parse the revision string and return a tuple with left-most
 
105
    parent of the revision.
 
106
 
 
107
    >>> _parse_change_str('123')
 
108
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
 
109
    >>> _parse_change_str('123..124')
 
110
    Traceback (most recent call last):
 
111
      ...
 
112
    RangeInChangeOption: Option --change does not accept revision ranges
 
113
    """
 
114
    revs = _parse_revision_str(revstr)
 
115
    if len(revs) > 1:
 
116
        raise errors.RangeInChangeOption()
 
117
    return (revisionspec.RevisionSpec.from_string('before:' + revstr),
 
118
            revs[0])
 
119
 
 
120
 
105
121
def _parse_merge_type(typestring):
106
122
    return get_merge_type(typestring)
107
123
 
116
132
        type_list = '\n'.join(lines)
117
133
        msg = "No known merge type %s. Supported types are:\n%s" %\
118
134
            (typestring, type_list)
119
 
        raise BzrCommandError(msg)
 
135
        raise errors.BzrCommandError(msg)
 
136
 
120
137
 
121
138
class Option(object):
122
 
    """Description of a command line option"""
123
 
    # TODO: Some way to show in help a description of the option argument
124
 
 
 
139
    """Description of a command line option
 
140
    
 
141
    :ivar _short_name: If this option has a single-letter name, this is it.
 
142
    Otherwise None.
 
143
    """
 
144
 
 
145
    # The dictionary of standard options. These are always legal.
 
146
    STD_OPTIONS = {}
 
147
 
 
148
    # The dictionary of commonly used options. these are only legal
 
149
    # if a command explicitly references them by name in the list
 
150
    # of supported options.
125
151
    OPTIONS = {}
126
 
    SHORT_OPTIONS = {}
127
152
 
128
 
    def __init__(self, name, help='', type=None, argname=None):
 
153
    def __init__(self, name, help='', type=None, argname=None,
 
154
                 short_name=None, param_name=None, custom_callback=None):
129
155
        """Make a new command option.
130
156
 
131
 
        name -- regular name of the command, used in the double-dash
 
157
        :param name: regular name of the command, used in the double-dash
132
158
            form and also as the parameter to the command's run() 
133
 
            method.
134
 
 
135
 
        help -- help message displayed in command help
136
 
 
137
 
        type -- function called to parse the option argument, or 
 
159
            method (unless param_name is specified).
 
160
 
 
161
        :param help: help message displayed in command help
 
162
 
 
163
        :param type: function called to parse the option argument, or 
138
164
            None (default) if this option doesn't take an argument.
139
165
 
140
 
        argname -- name of option argument, if any
 
166
        :param argname: name of option argument, if any
 
167
 
 
168
        :param short_name: short option code for use with a single -, e.g.
 
169
            short_name="v" to enable parsing of -v.
 
170
 
 
171
        :param param_name: name of the parameter which will be passed to
 
172
            the command's run() method.
 
173
 
 
174
        :param custom_callback: a callback routine to be called after normal
 
175
            processing. The signature of the callback routine is
 
176
            (option, name, new_value, parser).
141
177
        """
142
 
        # TODO: perhaps a subclass that automatically does 
143
 
        # --option, --no-option for reversable booleans
144
178
        self.name = name
145
179
        self.help = help
146
180
        self.type = type
 
181
        self._short_name = short_name
147
182
        if type is None:
148
183
            assert argname is None
149
184
        elif argname is None:
150
185
            argname = 'ARG'
151
186
        self.argname = argname
 
187
        if param_name is None:
 
188
            self._param_name = self.name
 
189
        else:
 
190
            self._param_name = param_name
 
191
        self.custom_callback = custom_callback
152
192
 
153
193
    def short_name(self):
154
 
        """Return the single character option for this command, if any.
155
 
 
156
 
        Short options are globally registered.
157
 
        """
158
 
        for short, option in Option.SHORT_OPTIONS.iteritems():
159
 
            if option is self:
160
 
                return short
 
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
        return RegistryOption(name_, help, reg, title=title,
 
349
            value_switches=value_switches, enum_switch=enum_switch)
 
350
 
 
351
    def add_option(self, parser, short_name):
 
352
        """Add this option to an Optparse parser"""
 
353
        if self.value_switches:
 
354
            parser = parser.add_option_group(self.title)
 
355
        if self.enum_switch:
 
356
            Option.add_option(self, parser, short_name)
 
357
        if self.value_switches:
 
358
            for key in self.registry.keys():
 
359
                option_strings = ['--%s' % key]
 
360
                if self.is_hidden(key):
 
361
                    help = optparse.SUPPRESS_HELP
 
362
                else:
 
363
                    help = self.registry.get_help(key)
 
364
                parser.add_option(action='callback',
 
365
                              callback=self._optparse_value_callback(key),
 
366
                                  help=help,
 
367
                                  *option_strings)
 
368
 
 
369
    def _optparse_value_callback(self, cb_value):
 
370
        def cb(option, opt, value, parser):
 
371
            v = self.type(cb_value)
 
372
            setattr(parser.values, self._param_name, v)
 
373
            if self.custom_callback is not None:
 
374
                self.custom_callback(option, self._param_name, v, parser)
 
375
        return cb
 
376
 
 
377
    def iter_switches(self):
 
378
        """Iterate through the list of switches provided by the option
 
379
 
 
380
        :return: an iterator of (name, short_name, argname, help)
 
381
        """
 
382
        for value in Option.iter_switches(self):
 
383
            yield value
 
384
        if self.value_switches:
 
385
            for key in sorted(self.registry.keys()):
 
386
                yield key, None, None, self.registry.get_help(key)
 
387
 
 
388
    def is_hidden(self, name):
 
389
        if name == self.name:
 
390
            return Option.is_hidden(self, name)
 
391
        return getattr(self.registry.get_info(name), 'hidden', False)
 
392
 
 
393
 
 
394
class OptionParser(optparse.OptionParser):
 
395
    """OptionParser that raises exceptions instead of exiting"""
 
396
 
 
397
    DEFAULT_VALUE = object()
 
398
 
 
399
    def error(self, message):
 
400
        raise errors.BzrCommandError(message)
 
401
 
 
402
 
 
403
def get_optparser(options):
 
404
    """Generate an optparse parser for bzrlib-style options"""
 
405
 
 
406
    parser = OptionParser()
 
407
    parser.remove_option('--help')
 
408
    for option in options.itervalues():
 
409
        option.add_option(parser, option.short_name())
 
410
    return parser
 
411
 
 
412
 
 
413
def custom_help(name, help):
 
414
    """Clone a common option overriding the help."""
 
415
    import copy
 
416
    o = copy.copy(Option.OPTIONS[name])
 
417
    o.help = help
 
418
    return o
 
419
 
 
420
 
 
421
def _standard_option(name, **kwargs):
 
422
    """Register a standard option."""
 
423
    # All standard options are implicitly 'global' ones
 
424
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
 
425
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
161
426
 
162
427
 
163
428
def _global_option(name, **kwargs):
164
 
    """Register o as a global option."""
 
429
    """Register a global option."""
165
430
    Option.OPTIONS[name] = Option(name, **kwargs)
166
431
 
 
432
 
 
433
def _global_registry_option(name, help, registry, **kwargs):
 
434
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
 
435
 
 
436
 
 
437
class MergeTypeRegistry(registry.Registry):
 
438
 
 
439
    pass
 
440
 
 
441
 
 
442
# This is the verbosity level detected during command line parsing.
 
443
# Note that the final value is dependent on the order in which the
 
444
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
 
445
# The final value will be one of the following:
 
446
#
 
447
# * -ve for quiet
 
448
# * 0 for normal
 
449
# * +ve for verbose
 
450
_verbosity_level = 0
 
451
 
 
452
 
 
453
def _verbosity_level_callback(option, opt_str, value, parser):
 
454
    global _verbosity_level
 
455
    if not value:
 
456
        # Either --no-verbose or --no-quiet was specified
 
457
        _verbosity_level = 0
 
458
    elif opt_str == "verbose":
 
459
        if _verbosity_level > 0:
 
460
            _verbosity_level += 1
 
461
        else:
 
462
            _verbosity_level = 1
 
463
    else:
 
464
        if _verbosity_level < 0:
 
465
            _verbosity_level -= 1
 
466
        else:
 
467
            _verbosity_level = -1
 
468
 
 
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
 
 
478
# Declare the standard options
 
479
_standard_option('help', short_name='h',
 
480
                 help='Show help message.')
 
481
_standard_option('verbose', short_name='v',
 
482
                 help='Display more information.',
 
483
                 custom_callback=_verbosity_level_callback)
 
484
_standard_option('quiet', short_name='q',
 
485
                 help="Only display errors and warnings.",
 
486
                 custom_callback=_verbosity_level_callback)
 
487
 
 
488
# Declare commonly used options
167
489
_global_option('all')
168
490
_global_option('overwrite', help='Ignore differences between branches and '
169
 
               'overwrite unconditionally')
 
491
               'overwrite unconditionally.')
170
492
_global_option('basis', type=str)
 
493
_global_option('bound')
171
494
_global_option('diff-options', type=str)
172
 
_global_option('help',
173
 
               help='show help message')
174
 
_global_option('file', type=unicode)
 
495
_global_option('file', type=unicode, short_name='F')
175
496
_global_option('force')
176
497
_global_option('format', type=unicode)
177
498
_global_option('forward')
178
 
_global_option('message', type=unicode)
 
499
_global_option('message', type=unicode,
 
500
               short_name='m',
 
501
               help='Message string.')
179
502
_global_option('no-recurse')
180
503
_global_option('profile',
181
 
               help='show performance profiling information')
182
 
_global_option('revision', type=_parse_revision_str)
183
 
_global_option('short')
184
 
_global_option('show-ids', 
185
 
               help='show internal object ids')
 
504
               help='Show performance profiling information.')
 
505
_global_option('revision',
 
506
               type=_parse_revision_str,
 
507
               short_name='r',
 
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".')
 
514
_global_option('show-ids',
 
515
               help='Show internal object ids.')
186
516
_global_option('timezone', 
187
517
               type=str,
188
518
               help='display timezone as local, original, or utc')
189
 
_global_option('verbose',
190
 
               help='display more information')
 
519
_global_option('unbound')
191
520
_global_option('version')
192
521
_global_option('email')
193
522
_global_option('update')
194
 
_global_option('long', help='Use detailed log format')
195
 
_global_option('short', help='Use moderately short log format')
196
 
_global_option('line', help='Use log format with one line per revision')
 
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')
197
530
_global_option('root', type=str)
198
531
_global_option('no-backup')
199
 
_global_option('merge-type', type=_parse_merge_type)
 
532
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
 
533
                        _merge_type_registry, value_switches=True,
 
534
                        title='Merge algorithm')
200
535
_global_option('pattern', type=str)
201
 
_global_option('quiet')
202
536
_global_option('remember', help='Remember the specified location as a'
203
537
               ' default.')
204
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
 
538
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
205
539
_global_option('kind', type=str)
206
540
_global_option('dry-run',
207
 
               help="show what would be done, but don't actually do anything")
208
 
 
209
 
 
210
 
def _global_short(short_name, long_name):
211
 
    assert short_name not in Option.SHORT_OPTIONS
212
 
    Option.SHORT_OPTIONS[short_name] = Option.OPTIONS[long_name]
213
 
    
214
 
 
215
 
Option.SHORT_OPTIONS['F'] = Option.OPTIONS['file']
216
 
Option.SHORT_OPTIONS['h'] = Option.OPTIONS['help']
217
 
Option.SHORT_OPTIONS['m'] = Option.OPTIONS['message']
218
 
Option.SHORT_OPTIONS['r'] = Option.OPTIONS['revision']
219
 
Option.SHORT_OPTIONS['v'] = Option.OPTIONS['verbose']
220
 
Option.SHORT_OPTIONS['l'] = Option.OPTIONS['long']
221
 
Option.SHORT_OPTIONS['q'] = Option.OPTIONS['quiet']
 
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.')