/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-04 06:22:51 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100504062251-1ocjhrl53mum9ehw
Minor local_abspath docstring improvement.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2004, 2005, 2006 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.
19
19
 
 
20
import optparse
20
21
import re
21
22
 
22
23
from bzrlib.lazy_import import lazy_import
23
24
lazy_import(globals(), """
24
 
import optparse
25
 
 
26
25
from bzrlib import (
27
26
    errors,
28
 
    log,
29
 
    registry,
30
27
    revisionspec,
31
 
    symbol_versioning,
32
28
    )
33
29
""")
34
 
from bzrlib.trace import warning
 
30
 
 
31
from bzrlib import (
 
32
    registry as _mod_registry,
 
33
    )
35
34
 
36
35
 
37
36
def _parse_revision_str(revstr):
41
40
    each revision specifier supplied.
42
41
 
43
42
    >>> _parse_revision_str('234')
44
 
    [<RevisionSpec_revno 234>]
 
43
    [<RevisionSpec_dwim 234>]
45
44
    >>> _parse_revision_str('234..567')
46
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
 
45
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
47
46
    >>> _parse_revision_str('..')
48
47
    [<RevisionSpec None>, <RevisionSpec None>]
49
48
    >>> _parse_revision_str('..234')
50
 
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
 
49
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
51
50
    >>> _parse_revision_str('234..')
52
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
 
51
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
53
52
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
54
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
 
53
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
55
54
    >>> _parse_revision_str('234....789') #Error ?
56
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
 
55
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
57
56
    >>> _parse_revision_str('revid:test@other.com-234234')
58
57
    [<RevisionSpec_revid revid:test@other.com-234234>]
59
58
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
60
59
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
61
60
    >>> _parse_revision_str('revid:test@other.com-234234..23')
62
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
 
61
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
63
62
    >>> _parse_revision_str('date:2005-04-12')
64
63
    [<RevisionSpec_date date:2005-04-12>]
65
64
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
69
68
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
70
69
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
71
70
    >>> _parse_revision_str('-5..23')
72
 
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
 
71
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
73
72
    >>> _parse_revision_str('-5')
74
 
    [<RevisionSpec_revno -5>]
 
73
    [<RevisionSpec_dwim -5>]
75
74
    >>> _parse_revision_str('123a')
76
 
    Traceback (most recent call last):
77
 
      ...
78
 
    NoSuchRevisionSpec: No namespace registered for string: '123a'
 
75
    [<RevisionSpec_dwim 123a>]
79
76
    >>> _parse_revision_str('abc')
80
 
    Traceback (most recent call last):
81
 
      ...
82
 
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
 
77
    [<RevisionSpec_dwim abc>]
83
78
    >>> _parse_revision_str('branch:../branch2')
84
79
    [<RevisionSpec_branch branch:../branch2>]
85
80
    >>> _parse_revision_str('branch:../../branch2')
86
81
    [<RevisionSpec_branch branch:../../branch2>]
87
82
    >>> _parse_revision_str('branch:../../branch2..23')
88
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
 
83
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
 
84
    >>> _parse_revision_str('branch:..\\\\branch2')
 
85
    [<RevisionSpec_branch branch:..\\branch2>]
 
86
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
 
87
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
89
88
    """
90
89
    # TODO: Maybe move this into revisionspec.py
91
90
    revs = []
92
 
    # split on the first .. that is not followed by a / ?
93
 
    sep = re.compile("\\.\\.(?!/)")
 
91
    # split on .. that is not followed by a / or \
 
92
    sep = re.compile(r'\.\.(?![\\/])')
94
93
    for x in sep.split(revstr):
95
94
        revs.append(revisionspec.RevisionSpec.from_string(x or None))
96
95
    return revs
97
96
 
98
97
 
 
98
def _parse_change_str(revstr):
 
99
    """Parse the revision string and return a tuple with left-most
 
100
    parent of the revision.
 
101
 
 
102
    >>> _parse_change_str('123')
 
103
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
 
104
    >>> _parse_change_str('123..124')
 
105
    Traceback (most recent call last):
 
106
      ...
 
107
    RangeInChangeOption: Option --change does not accept revision ranges
 
108
    """
 
109
    revs = _parse_revision_str(revstr)
 
110
    if len(revs) > 1:
 
111
        raise errors.RangeInChangeOption()
 
112
    return (revisionspec.RevisionSpec.from_string('before:' + revstr),
 
113
            revs[0])
 
114
 
 
115
 
99
116
def _parse_merge_type(typestring):
100
117
    return get_merge_type(typestring)
101
118
 
115
132
 
116
133
class Option(object):
117
134
    """Description of a command line option
118
 
    
 
135
 
119
136
    :ivar _short_name: If this option has a single-letter name, this is it.
120
137
    Otherwise None.
121
138
    """
122
139
 
123
 
    # TODO: Some way to show in help a description of the option argument
 
140
    # The dictionary of standard options. These are always legal.
 
141
    STD_OPTIONS = {}
124
142
 
 
143
    # The dictionary of commonly used options. these are only legal
 
144
    # if a command explicitly references them by name in the list
 
145
    # of supported options.
125
146
    OPTIONS = {}
126
147
 
127
148
    def __init__(self, name, help='', type=None, argname=None,
128
 
                 short_name=None):
 
149
                 short_name=None, param_name=None, custom_callback=None,
 
150
                 hidden=False):
129
151
        """Make a new command option.
130
152
 
131
 
        name -- regular name of the command, used in the double-dash
132
 
            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 
 
153
        :param name: regular name of the command, used in the double-dash
 
154
            form and also as the parameter to the command's run()
 
155
            method (unless param_name is specified).
 
156
 
 
157
        :param help: help message displayed in command help
 
158
 
 
159
        :param type: function called to parse the option argument, or
138
160
            None (default) if this option doesn't take an argument.
139
161
 
140
 
        argname -- name of option argument, if any
 
162
        :param argname: name of option argument, if any
 
163
 
 
164
        :param short_name: short option code for use with a single -, e.g.
 
165
            short_name="v" to enable parsing of -v.
 
166
 
 
167
        :param param_name: name of the parameter which will be passed to
 
168
            the command's run() method.
 
169
 
 
170
        :param custom_callback: a callback routine to be called after normal
 
171
            processing. The signature of the callback routine is
 
172
            (option, name, new_value, parser).
 
173
        :param hidden: If True, the option should be hidden in help and
 
174
            documentation.
141
175
        """
142
176
        self.name = name
143
177
        self.help = help
144
178
        self.type = type
145
179
        self._short_name = short_name
146
180
        if type is None:
147
 
            assert argname is None
 
181
            if argname:
 
182
                raise ValueError('argname not valid for booleans')
148
183
        elif argname is None:
149
184
            argname = 'ARG'
150
185
        self.argname = argname
 
186
        if param_name is None:
 
187
            self._param_name = self.name.replace('-', '_')
 
188
        else:
 
189
            self._param_name = param_name
 
190
        self.custom_callback = custom_callback
 
191
        self.hidden = hidden
151
192
 
152
193
    def short_name(self):
153
194
        if self._short_name:
154
195
            return self._short_name
155
 
        else:
156
 
            # remove this when SHORT_OPTIONS is removed
157
 
            # XXX: This is accessing a DeprecatedDict, so we call the super 
158
 
            # method to avoid warnings
159
 
            for (k, v) in dict.iteritems(Option.SHORT_OPTIONS):
160
 
                if v == self:
161
 
                    return k
162
196
 
163
197
    def set_short_name(self, short_name):
164
198
        self._short_name = short_name
174
208
        option_strings = ['--%s' % self.name]
175
209
        if short_name is not None:
176
210
            option_strings.append('-%s' % short_name)
 
211
        if self.hidden:
 
212
            help = optparse.SUPPRESS_HELP
 
213
        else:
 
214
            help = self.help
177
215
        optargfn = self.type
178
216
        if optargfn is None:
179
 
            parser.add_option(action='store_true', dest=self.name, 
180
 
                              help=self.help,
181
 
                              default=OptionParser.DEFAULT_VALUE,
 
217
            parser.add_option(action='callback',
 
218
                              callback=self._optparse_bool_callback,
 
219
                              callback_args=(True,),
 
220
                              help=help,
182
221
                              *option_strings)
183
222
            negation_strings = ['--%s' % self.get_negation_name()]
184
 
            parser.add_option(action='store_false', dest=self.name, 
 
223
            parser.add_option(action='callback',
 
224
                              callback=self._optparse_bool_callback,
 
225
                              callback_args=(False,),
185
226
                              help=optparse.SUPPRESS_HELP, *negation_strings)
186
227
        else:
187
 
            parser.add_option(action='callback', 
188
 
                              callback=self._optparse_callback, 
 
228
            parser.add_option(action='callback',
 
229
                              callback=self._optparse_callback,
189
230
                              type='string', metavar=self.argname.upper(),
190
 
                              help=self.help,
191
 
                              default=OptionParser.DEFAULT_VALUE, 
 
231
                              help=help,
 
232
                              default=OptionParser.DEFAULT_VALUE,
192
233
                              *option_strings)
193
234
 
 
235
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
 
236
        setattr(parser.values, self._param_name, bool_v)
 
237
        if self.custom_callback is not None:
 
238
            self.custom_callback(option, self._param_name, bool_v, parser)
 
239
 
194
240
    def _optparse_callback(self, option, opt, value, parser):
195
 
        setattr(parser.values, self.name, self.type(value))
 
241
        v = self.type(value)
 
242
        setattr(parser.values, self._param_name, v)
 
243
        if self.custom_callback is not None:
 
244
            self.custom_callback(option, self.name, v, parser)
196
245
 
197
246
    def iter_switches(self):
198
247
        """Iterate through the list of switches provided by the option
199
 
        
 
248
 
200
249
        :return: an iterator of (name, short_name, argname, help)
201
250
        """
202
251
        argname =  self.argname
204
253
            argname = argname.upper()
205
254
        yield self.name, self.short_name(), argname, self.help
206
255
 
 
256
    def is_hidden(self, name):
 
257
        return self.hidden
 
258
 
 
259
 
 
260
class ListOption(Option):
 
261
    """Option used to provide a list of values.
 
262
 
 
263
    On the command line, arguments are specified by a repeated use of the
 
264
    option. '-' is a special argument that resets the list. For example,
 
265
      --foo=a --foo=b
 
266
    sets the value of the 'foo' option to ['a', 'b'], and
 
267
      --foo=a --foo=b --foo=- --foo=c
 
268
    sets the value of the 'foo' option to ['c'].
 
269
    """
 
270
 
 
271
    def add_option(self, parser, short_name):
 
272
        """Add this option to an Optparse parser."""
 
273
        option_strings = ['--%s' % self.name]
 
274
        if short_name is not None:
 
275
            option_strings.append('-%s' % short_name)
 
276
        parser.add_option(action='callback',
 
277
                          callback=self._optparse_callback,
 
278
                          type='string', metavar=self.argname.upper(),
 
279
                          help=self.help, dest=self._param_name, default=[],
 
280
                          *option_strings)
 
281
 
 
282
    def _optparse_callback(self, option, opt, value, parser):
 
283
        values = getattr(parser.values, self._param_name)
 
284
        if value == '-':
 
285
            del values[:]
 
286
        else:
 
287
            values.append(self.type(value))
 
288
        if self.custom_callback is not None:
 
289
            self.custom_callback(option, self._param_name, values, parser)
 
290
 
207
291
 
208
292
class RegistryOption(Option):
209
293
    """Option based on a registry
226
310
        else:
227
311
            return self.converter(value)
228
312
 
229
 
    def __init__(self, name, help, registry, converter=None,
230
 
        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):
231
316
        """
232
317
        Constructor.
233
318
 
241
326
            '--knit' can be used interchangeably.
242
327
        :param enum_switch: If true, a switch is provided with the option name,
243
328
            which takes a value.
 
329
        :param lazy_registry: A tuple of (module name, attribute name) for a
 
330
            registry to be lazily loaded.
244
331
        """
245
332
        Option.__init__(self, name, help, type=self.convert)
246
 
        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')
247
343
        self.name = name
248
344
        self.converter = converter
249
345
        self.value_switches = value_switches
252
348
        if self.title is None:
253
349
            self.title = name
254
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
 
255
357
    @staticmethod
256
358
    def from_kwargs(name_, help=None, title=None, value_switches=False,
257
359
                    enum_switch=True, **kwargs):
259
361
 
260
362
        name, help, value_switches and enum_switch are passed to the
261
363
        RegistryOption constructor.  Any other keyword arguments are treated
262
 
        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.
263
365
        """
264
 
        reg = registry.Registry()
265
 
        for name, help in kwargs.iteritems():
 
366
        reg = _mod_registry.Registry()
 
367
        for name, switch_help in sorted(kwargs.items()):
266
368
            name = name.replace('_', '-')
267
 
            reg.register(name, name, help=help)
 
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 + "."
268
374
        return RegistryOption(name_, help, reg, title=title,
269
375
            value_switches=value_switches, enum_switch=enum_switch)
270
376
 
277
383
        if self.value_switches:
278
384
            for key in self.registry.keys():
279
385
                option_strings = ['--%s' % key]
280
 
                if getattr(self.registry.get_info(key), 'hidden', False):
 
386
                if self.is_hidden(key):
281
387
                    help = optparse.SUPPRESS_HELP
282
388
                else:
283
389
                    help = self.registry.get_help(key)
288
394
 
289
395
    def _optparse_value_callback(self, cb_value):
290
396
        def cb(option, opt, value, parser):
291
 
            setattr(parser.values, self.name, self.type(cb_value))
 
397
            v = self.type(cb_value)
 
398
            setattr(parser.values, self._param_name, v)
 
399
            if self.custom_callback is not None:
 
400
                self.custom_callback(option, self._param_name, v, parser)
292
401
        return cb
293
402
 
294
403
    def iter_switches(self):
302
411
            for key in sorted(self.registry.keys()):
303
412
                yield key, None, None, self.registry.get_help(key)
304
413
 
 
414
    def is_hidden(self, name):
 
415
        if name == self.name:
 
416
            return Option.is_hidden(self, name)
 
417
        return getattr(self.registry.get_info(name), 'hidden', False)
 
418
 
305
419
 
306
420
class OptionParser(optparse.OptionParser):
307
421
    """OptionParser that raises exceptions instead of exiting"""
322
436
    return parser
323
437
 
324
438
 
 
439
def custom_help(name, help):
 
440
    """Clone a common option overriding the help."""
 
441
    import copy
 
442
    o = copy.copy(Option.OPTIONS[name])
 
443
    o.help = help
 
444
    return o
 
445
 
 
446
 
 
447
def _standard_option(name, **kwargs):
 
448
    """Register a standard option."""
 
449
    # All standard options are implicitly 'global' ones
 
450
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
 
451
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
 
452
 
 
453
 
325
454
def _global_option(name, **kwargs):
326
 
    """Register o as a global option."""
 
455
    """Register a global option."""
327
456
    Option.OPTIONS[name] = Option(name, **kwargs)
328
457
 
329
458
 
330
 
def _global_registry_option(name, help, registry, **kwargs):
 
459
def _global_registry_option(name, help, registry=None, **kwargs):
331
460
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
332
461
 
333
462
 
334
 
class MergeTypeRegistry(registry.Registry):
 
463
# This is the verbosity level detected during command line parsing.
 
464
# Note that the final value is dependent on the order in which the
 
465
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
 
466
# The final value will be one of the following:
 
467
#
 
468
# * -ve for quiet
 
469
# * 0 for normal
 
470
# * +ve for verbose
 
471
_verbosity_level = 0
 
472
 
 
473
 
 
474
def _verbosity_level_callback(option, opt_str, value, parser):
 
475
    global _verbosity_level
 
476
    if not value:
 
477
        # Either --no-verbose or --no-quiet was specified
 
478
        _verbosity_level = 0
 
479
    elif opt_str == "verbose":
 
480
        if _verbosity_level > 0:
 
481
            _verbosity_level += 1
 
482
        else:
 
483
            _verbosity_level = 1
 
484
    else:
 
485
        if _verbosity_level < 0:
 
486
            _verbosity_level -= 1
 
487
        else:
 
488
            _verbosity_level = -1
 
489
 
 
490
 
 
491
class MergeTypeRegistry(_mod_registry.Registry):
335
492
 
336
493
    pass
337
494
 
343
500
                                   "Merge using external diff3")
344
501
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
345
502
                                   "Weave-based merge")
346
 
 
 
503
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
 
504
                                   "LCA-newness merge")
 
505
 
 
506
# Declare the standard options
 
507
_standard_option('help', short_name='h',
 
508
                 help='Show help message.')
 
509
_standard_option('usage',
 
510
                 help='Show usage message and options.')
 
511
_standard_option('verbose', short_name='v',
 
512
                 help='Display more information.',
 
513
                 custom_callback=_verbosity_level_callback)
 
514
_standard_option('quiet', short_name='q',
 
515
                 help="Only display errors and warnings.",
 
516
                 custom_callback=_verbosity_level_callback)
 
517
 
 
518
# Declare commonly used options
347
519
_global_option('all')
348
520
_global_option('overwrite', help='Ignore differences between branches and '
349
 
               'overwrite unconditionally')
 
521
               'overwrite unconditionally.')
350
522
_global_option('basis', type=str)
351
523
_global_option('bound')
352
524
_global_option('diff-options', type=str)
353
 
_global_option('help',
354
 
               help='show help message',
355
 
               short_name='h')
356
525
_global_option('file', type=unicode, short_name='F')
357
526
_global_option('force')
358
527
_global_option('format', type=unicode)
359
528
_global_option('forward')
360
529
_global_option('message', type=unicode,
361
 
               short_name='m')
 
530
               short_name='m',
 
531
               help='Message string.')
362
532
_global_option('no-recurse')
363
533
_global_option('profile',
364
 
               help='show performance profiling information')
 
534
               help='Show performance profiling information.')
365
535
_global_option('revision',
366
536
               type=_parse_revision_str,
367
537
               short_name='r',
368
 
               help='See \'help revisionspec\' for details')
369
 
_global_option('show-ids', 
370
 
               help='show internal object ids')
371
 
_global_option('timezone', 
 
538
               help='See "help revisionspec" for details.')
 
539
_global_option('change',
 
540
               type=_parse_change_str,
 
541
               short_name='c',
 
542
               param_name='revision',
 
543
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
 
544
_global_option('show-ids',
 
545
               help='Show internal object ids.')
 
546
_global_option('timezone',
372
547
               type=str,
373
 
               help='display timezone as local, original, or utc')
 
548
               help='Display timezone as local, original, or utc.')
374
549
_global_option('unbound')
375
 
_global_option('verbose',
376
 
               help='display more information',
377
 
               short_name='v')
378
550
_global_option('version')
379
551
_global_option('email')
380
552
_global_option('update')
381
 
_global_registry_option('log-format', "Use this log format",
382
 
                        log.log_formatter_registry, value_switches=True,
383
 
                        title='Log format')
 
553
_global_registry_option('log-format', "Use specified log format.",
 
554
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
 
555
                        value_switches=True, title='Log format')
384
556
_global_option('long', help='Use detailed log format. Same as --log-format long',
385
557
               short_name='l')
386
558
_global_option('short', help='Use moderately short log format. Same as --log-format short')
387
559
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
388
560
_global_option('root', type=str)
389
561
_global_option('no-backup')
390
 
_global_registry_option('merge-type', 'Select a particular merge algorithm',
 
562
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
391
563
                        _merge_type_registry, value_switches=True,
392
564
                        title='Merge algorithm')
393
565
_global_option('pattern', type=str)
394
 
_global_option('quiet', short_name='q')
395
566
_global_option('remember', help='Remember the specified location as a'
396
567
               ' default.')
397
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
 
568
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
398
569
_global_option('kind', type=str)
399
570
_global_option('dry-run',
400
 
               help="show what would be done, but don't actually do anything")
 
571
               help="Show what would be done, but don't actually do anything.")
401
572
_global_option('name-from-revision', help='The path name in the old tree.')
402
573
 
403
 
 
404
 
# prior to 0.14 these were always globally registered; the old dict is
405
 
# available for plugins that use it but it should not be used.
406
 
Option.SHORT_OPTIONS = symbol_versioning.DeprecatedDict(
407
 
    symbol_versioning.zero_fourteen,
408
 
    'SHORT_OPTIONS',
409
 
    {
410
 
        'F': Option.OPTIONS['file'],
411
 
        'h': Option.OPTIONS['help'],
412
 
        'm': Option.OPTIONS['message'],
413
 
        'r': Option.OPTIONS['revision'],
414
 
        'v': Option.OPTIONS['verbose'],
415
 
        'l': Option.OPTIONS['long'],
416
 
        'q': Option.OPTIONS['quiet'],
417
 
    },
418
 
    'Set the short option name when constructing the Option.',
419
 
    )
 
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'