← 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
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

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
 
 
20
import optparse
18
21
import re
19
22
 
20
 
import bzrlib.commands
21
 
from bzrlib.trace import warning, mutter
22
 
from bzrlib.revisionspec import RevisionSpec
23
 
from bzrlib.errors import BzrCommandError
 
23
from bzrlib.lazy_import import lazy_import
 
24
lazy_import(globals(), """
 
25
from bzrlib import (
 
26
    errors,
 
27
    revisionspec,
 
28
    )
 
29
""")
24
30
 
 
31
from bzrlib import (
 
32
    log,
 
33
    registry,
 
34
    )
25
35
 
26
36
def _parse_revision_str(revstr):
27
37
    """This handles a revision string -> revno.
30
40
    each revision specifier supplied.
31
41
 
32
42
    >>> _parse_revision_str('234')
33
 
    [<RevisionSpec_int 234>]
 
43
    [<RevisionSpec_revno 234>]
34
44
    >>> _parse_revision_str('234..567')
35
 
    [<RevisionSpec_int 234>, <RevisionSpec_int 567>]
 
45
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
36
46
    >>> _parse_revision_str('..')
37
47
    [<RevisionSpec None>, <RevisionSpec None>]
38
48
    >>> _parse_revision_str('..234')
39
 
    [<RevisionSpec None>, <RevisionSpec_int 234>]
 
49
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
40
50
    >>> _parse_revision_str('234..')
41
 
    [<RevisionSpec_int 234>, <RevisionSpec None>]
 
51
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
42
52
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
43
 
    [<RevisionSpec_int 234>, <RevisionSpec_int 456>, <RevisionSpec_int 789>]
 
53
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
44
54
    >>> _parse_revision_str('234....789') #Error ?
45
 
    [<RevisionSpec_int 234>, <RevisionSpec None>, <RevisionSpec_int 789>]
 
55
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
46
56
    >>> _parse_revision_str('revid:test@other.com-234234')
47
57
    [<RevisionSpec_revid revid:test@other.com-234234>]
48
58
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
49
59
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
50
60
    >>> _parse_revision_str('revid:test@other.com-234234..23')
51
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_int 23>]
 
61
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
52
62
    >>> _parse_revision_str('date:2005-04-12')
53
63
    [<RevisionSpec_date date:2005-04-12>]
54
64
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
58
68
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
59
69
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
60
70
    >>> _parse_revision_str('-5..23')
61
 
    [<RevisionSpec_int -5>, <RevisionSpec_int 23>]
 
71
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
62
72
    >>> _parse_revision_str('-5')
63
 
    [<RevisionSpec_int -5>]
 
73
    [<RevisionSpec_revno -5>]
64
74
    >>> _parse_revision_str('123a')
65
75
    Traceback (most recent call last):
66
76
      ...
67
 
    BzrError: No namespace registered for string: '123a'
 
77
    NoSuchRevisionSpec: No namespace registered for string: '123a'
68
78
    >>> _parse_revision_str('abc')
69
79
    Traceback (most recent call last):
70
80
      ...
71
 
    BzrError: No namespace registered for string: 'abc'
 
81
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
72
82
    >>> _parse_revision_str('branch:../branch2')
73
83
    [<RevisionSpec_branch branch:../branch2>]
74
84
    >>> _parse_revision_str('branch:../../branch2')
75
85
    [<RevisionSpec_branch branch:../../branch2>]
76
86
    >>> _parse_revision_str('branch:../../branch2..23')
77
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_int 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>]
78
92
    """
79
93
    # TODO: Maybe move this into revisionspec.py
80
 
    old_format_re = re.compile('\d*:\d*')
81
 
    m = old_format_re.match(revstr)
82
94
    revs = []
83
 
    if m:
84
 
        warning('Colon separator for revision numbers is deprecated.'
85
 
                ' Use .. instead')
86
 
        for rev in revstr.split(':'):
87
 
            if rev:
88
 
                revs.append(RevisionSpec(int(rev)))
89
 
            else:
90
 
                revs.append(RevisionSpec(None))
91
 
    else:
92
 
        sep = re.compile("\\.\\.(?!/)")
93
 
        for x in sep.split(revstr):
94
 
            revs.append(RevisionSpec(x or None))
 
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))
95
99
    return revs
96
100
 
97
101
 
 
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
 
98
120
def _parse_merge_type(typestring):
99
121
    return get_merge_type(typestring)
100
122
 
109
131
        type_list = '\n'.join(lines)
110
132
        msg = "No known merge type %s. Supported types are:\n%s" %\
111
133
            (typestring, type_list)
112
 
        raise BzrCommandError(msg)
 
134
        raise errors.BzrCommandError(msg)
 
135
 
113
136
 
114
137
class Option(object):
115
 
    """Description of a command line option"""
116
 
    # TODO: Some way to show in help a description of the option argument
117
 
 
 
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.
118
150
    OPTIONS = {}
119
 
    SHORT_OPTIONS = {}
120
151
 
121
 
    def __init__(self, name, help='', type=None, argname=None):
 
152
    def __init__(self, name, help='', type=None, argname=None,
 
153
                 short_name=None, param_name=None, custom_callback=None):
122
154
        """Make a new command option.
123
155
 
124
 
        name -- regular name of the command, used in the double-dash
 
156
        :param name: regular name of the command, used in the double-dash
125
157
            form and also as the parameter to the command's run() 
126
 
            method.
127
 
 
128
 
        help -- help message displayed in command help
129
 
 
130
 
        type -- function called to parse the option argument, or 
 
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 
131
163
            None (default) if this option doesn't take an argument.
132
164
 
133
 
        argname -- name of option argument, if any
 
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).
134
176
        """
135
 
        # TODO: perhaps a subclass that automatically does 
136
 
        # --option, --no-option for reversable booleans
137
177
        self.name = name
138
178
        self.help = help
139
179
        self.type = type
 
180
        self._short_name = short_name
140
181
        if type is None:
141
 
            assert argname is None
 
182
            if argname:
 
183
                raise ValueError('argname not valid for booleans')
142
184
        elif argname is None:
143
185
            argname = 'ARG'
144
186
        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
145
192
 
146
193
    def short_name(self):
147
 
        """Return the single character option for this command, if any.
148
 
 
149
 
        Short options are globally registered.
150
 
        """
151
 
        for short, option in Option.SHORT_OPTIONS.iteritems():
152
 
            if option is self:
153
 
                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
            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]
154
430
 
155
431
 
156
432
def _global_option(name, **kwargs):
157
 
    """Register o as a global option."""
 
433
    """Register a global option."""
158
434
    Option.OPTIONS[name] = Option(name, **kwargs)
159
435
 
 
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
160
495
_global_option('all')
161
496
_global_option('overwrite', help='Ignore differences between branches and '
162
 
               'overwrite unconditionally')
 
497
               'overwrite unconditionally.')
163
498
_global_option('basis', type=str)
 
499
_global_option('bound')
164
500
_global_option('diff-options', type=str)
165
 
_global_option('help',
166
 
               help='show help message')
167
 
_global_option('file', type=unicode)
 
501
_global_option('file', type=unicode, short_name='F')
168
502
_global_option('force')
169
503
_global_option('format', type=unicode)
170
504
_global_option('forward')
171
 
_global_option('message', type=unicode)
 
505
_global_option('message', type=unicode,
 
506
               short_name='m',
 
507
               help='Message string.')
172
508
_global_option('no-recurse')
173
509
_global_option('profile',
174
 
               help='show performance profiling information')
175
 
_global_option('revision', type=_parse_revision_str)
176
 
_global_option('short')
177
 
_global_option('show-ids', 
178
 
               help='show internal object ids')
 
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.')
179
522
_global_option('timezone', 
180
523
               type=str,
181
524
               help='display timezone as local, original, or utc')
182
 
_global_option('verbose',
183
 
               help='display more information')
 
525
_global_option('unbound')
184
526
_global_option('version')
185
527
_global_option('email')
186
528
_global_option('update')
187
 
_global_option('long', help='Use detailed log format')
188
 
_global_option('short', help='Use moderately short log format')
189
 
_global_option('line', help='Use log format with one line per revision')
 
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')
 
534
_global_option('short', help='Use moderately short log format. Same as --log-format short')
 
535
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
190
536
_global_option('root', type=str)
191
537
_global_option('no-backup')
192
 
_global_option('merge-type', type=_parse_merge_type)
 
538
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
 
539
                        _merge_type_registry, value_switches=True,
 
540
                        title='Merge algorithm')
193
541
_global_option('pattern', type=str)
194
 
_global_option('quiet')
195
542
_global_option('remember', help='Remember the specified location as a'
196
543
               ' default.')
197
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
 
544
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
198
545
_global_option('kind', type=str)
199
546
_global_option('dry-run',
200
 
               help="show what would be done, but don't actually do anything")
201
 
 
202
 
 
203
 
def _global_short(short_name, long_name):
204
 
    assert short_name not in Option.SHORT_OPTIONS
205
 
    Option.SHORT_OPTIONS[short_name] = Option.OPTIONS[long_name]
206
 
    
207
 
 
208
 
Option.SHORT_OPTIONS['F'] = Option.OPTIONS['file']
209
 
Option.SHORT_OPTIONS['h'] = Option.OPTIONS['help']
210
 
Option.SHORT_OPTIONS['m'] = Option.OPTIONS['message']
211
 
Option.SHORT_OPTIONS['r'] = Option.OPTIONS['revision']
212
 
Option.SHORT_OPTIONS['v'] = Option.OPTIONS['verbose']
213
 
Option.SHORT_OPTIONS['l'] = Option.OPTIONS['long']
214
 
Option.SHORT_OPTIONS['q'] = Option.OPTIONS['quiet']
 
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.')