← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Aaron Bentley
  • Date: 2012-07-13 19:32:33 UTC
  • mto: This revision was merged to the branch mainline in revision 6540.
  • Revision ID: aaron@aaronbentley.com-20120713193233-l6y0l0twwhd3wmka
Switch to much simpler implementation of restore_uncommitted.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
# TODO: For things like --diff-prefix, we want a way to customize the display
18
18
# of the option argument.
19
19
 
 
20
from __future__ import absolute_import
 
21
 
 
22
import optparse
20
23
import re
21
24
 
22
25
from bzrlib.lazy_import import lazy_import
23
26
lazy_import(globals(), """
24
 
import optparse
25
 
 
26
27
from bzrlib import (
27
28
    errors,
28
 
    log,
29
 
    registry,
30
29
    revisionspec,
31
 
    symbol_versioning,
 
30
    i18n,
32
31
    )
33
32
""")
34
 
from bzrlib.trace import warning
 
33
 
 
34
from bzrlib import (
 
35
    registry as _mod_registry,
 
36
    )
35
37
 
36
38
 
37
39
def _parse_revision_str(revstr):
41
43
    each revision specifier supplied.
42
44
 
43
45
    >>> _parse_revision_str('234')
44
 
    [<RevisionSpec_revno 234>]
 
46
    [<RevisionSpec_dwim 234>]
45
47
    >>> _parse_revision_str('234..567')
46
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
 
48
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
47
49
    >>> _parse_revision_str('..')
48
50
    [<RevisionSpec None>, <RevisionSpec None>]
49
51
    >>> _parse_revision_str('..234')
50
 
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
 
52
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
51
53
    >>> _parse_revision_str('234..')
52
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
 
54
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
53
55
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
54
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
 
56
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
55
57
    >>> _parse_revision_str('234....789') #Error ?
56
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
 
58
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
57
59
    >>> _parse_revision_str('revid:test@other.com-234234')
58
60
    [<RevisionSpec_revid revid:test@other.com-234234>]
59
61
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
60
62
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
61
63
    >>> _parse_revision_str('revid:test@other.com-234234..23')
62
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
 
64
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
63
65
    >>> _parse_revision_str('date:2005-04-12')
64
66
    [<RevisionSpec_date date:2005-04-12>]
65
67
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
69
71
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
70
72
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
71
73
    >>> _parse_revision_str('-5..23')
72
 
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
 
74
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
73
75
    >>> _parse_revision_str('-5')
74
 
    [<RevisionSpec_revno -5>]
 
76
    [<RevisionSpec_dwim -5>]
75
77
    >>> _parse_revision_str('123a')
76
 
    Traceback (most recent call last):
77
 
      ...
78
 
    NoSuchRevisionSpec: No namespace registered for string: '123a'
 
78
    [<RevisionSpec_dwim 123a>]
79
79
    >>> _parse_revision_str('abc')
80
 
    Traceback (most recent call last):
81
 
      ...
82
 
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
 
80
    [<RevisionSpec_dwim abc>]
83
81
    >>> _parse_revision_str('branch:../branch2')
84
82
    [<RevisionSpec_branch branch:../branch2>]
85
83
    >>> _parse_revision_str('branch:../../branch2')
86
84
    [<RevisionSpec_branch branch:../../branch2>]
87
85
    >>> _parse_revision_str('branch:../../branch2..23')
88
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
 
86
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
89
87
    >>> _parse_revision_str('branch:..\\\\branch2')
90
88
    [<RevisionSpec_branch branch:..\\branch2>]
91
89
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
92
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
 
90
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
93
91
    """
94
92
    # TODO: Maybe move this into revisionspec.py
95
93
    revs = []
105
103
    parent of the revision.
106
104
 
107
105
    >>> _parse_change_str('123')
108
 
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
 
106
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
109
107
    >>> _parse_change_str('123..124')
110
108
    Traceback (most recent call last):
111
109
      ...
137
135
 
138
136
class Option(object):
139
137
    """Description of a command line option
140
 
    
 
138
 
141
139
    :ivar _short_name: If this option has a single-letter name, this is it.
142
140
    Otherwise None.
143
141
    """
144
142
 
145
 
    # TODO: Some way to show in help a description of the option argument
 
143
    # The dictionary of standard options. These are always legal.
 
144
    STD_OPTIONS = {}
146
145
 
 
146
    # The dictionary of commonly used options. these are only legal
 
147
    # if a command explicitly references them by name in the list
 
148
    # of supported options.
147
149
    OPTIONS = {}
148
150
 
149
151
    def __init__(self, name, help='', type=None, argname=None,
150
 
                 short_name=None, param_name=None):
 
152
                 short_name=None, param_name=None, custom_callback=None,
 
153
                 hidden=False):
151
154
        """Make a new command option.
152
155
 
153
 
        name -- regular name of the command, used in the double-dash
154
 
            form and also as the parameter to the command's run() 
 
156
        :param name: regular name of the command, used in the double-dash
 
157
            form and also as the parameter to the command's run()
155
158
            method (unless param_name is specified).
156
159
 
157
 
        help -- help message displayed in command help
 
160
        :param help: help message displayed in command help
158
161
 
159
 
        type -- function called to parse the option argument, or 
 
162
        :param type: function called to parse the option argument, or
160
163
            None (default) if this option doesn't take an argument.
161
164
 
162
 
        argname -- name of option argument, if any
163
 
 
164
 
        param_name -- name of the parameter which will be passed to
 
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
165
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).
 
176
        :param hidden: If True, the option should be hidden in help and
 
177
            documentation.
166
178
        """
167
179
        self.name = name
168
180
        self.help = help
169
181
        self.type = type
170
182
        self._short_name = short_name
171
183
        if type is None:
172
 
            assert argname is None
 
184
            if argname:
 
185
                raise ValueError('argname not valid for booleans')
173
186
        elif argname is None:
174
187
            argname = 'ARG'
175
188
        self.argname = argname
176
189
        if param_name is None:
177
 
            self._param_name = self.name
 
190
            self._param_name = self.name.replace('-', '_')
178
191
        else:
179
192
            self._param_name = param_name
 
193
        self.custom_callback = custom_callback
 
194
        self.hidden = hidden
180
195
 
181
196
    def short_name(self):
182
197
        if self._short_name:
196
211
        option_strings = ['--%s' % self.name]
197
212
        if short_name is not None:
198
213
            option_strings.append('-%s' % short_name)
 
214
        if self.hidden:
 
215
            help = optparse.SUPPRESS_HELP
 
216
        else:
 
217
            help = self.help
199
218
        optargfn = self.type
200
219
        if optargfn is None:
201
 
            parser.add_option(action='store_true', dest=self.name, 
202
 
                              help=self.help,
203
 
                              default=OptionParser.DEFAULT_VALUE,
 
220
            parser.add_option(action='callback',
 
221
                              callback=self._optparse_bool_callback,
 
222
                              callback_args=(True,),
 
223
                              help=help,
204
224
                              *option_strings)
205
225
            negation_strings = ['--%s' % self.get_negation_name()]
206
 
            parser.add_option(action='store_false', dest=self.name, 
 
226
            parser.add_option(action='callback',
 
227
                              callback=self._optparse_bool_callback,
 
228
                              callback_args=(False,),
207
229
                              help=optparse.SUPPRESS_HELP, *negation_strings)
208
230
        else:
209
 
            parser.add_option(action='callback', 
210
 
                              callback=self._optparse_callback, 
 
231
            parser.add_option(action='callback',
 
232
                              callback=self._optparse_callback,
211
233
                              type='string', metavar=self.argname.upper(),
212
 
                              help=self.help,
213
 
                              default=OptionParser.DEFAULT_VALUE, 
 
234
                              help=help,
 
235
                              default=OptionParser.DEFAULT_VALUE,
214
236
                              *option_strings)
215
237
 
 
238
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
 
239
        setattr(parser.values, self._param_name, bool_v)
 
240
        if self.custom_callback is not None:
 
241
            self.custom_callback(option, self._param_name, bool_v, parser)
 
242
 
216
243
    def _optparse_callback(self, option, opt, value, parser):
217
 
        setattr(parser.values, self._param_name, self.type(value))
 
244
        v = self.type(value)
 
245
        setattr(parser.values, self._param_name, v)
 
246
        if self.custom_callback is not None:
 
247
            self.custom_callback(option, self.name, v, parser)
218
248
 
219
249
    def iter_switches(self):
220
250
        """Iterate through the list of switches provided by the option
221
 
        
 
251
 
222
252
        :return: an iterator of (name, short_name, argname, help)
223
253
        """
224
254
        argname =  self.argname
227
257
        yield self.name, self.short_name(), argname, self.help
228
258
 
229
259
    def is_hidden(self, name):
230
 
        return False
 
260
        return self.hidden
231
261
 
232
262
 
233
263
class ListOption(Option):
249
279
        parser.add_option(action='callback',
250
280
                          callback=self._optparse_callback,
251
281
                          type='string', metavar=self.argname.upper(),
252
 
                          help=self.help, default=[],
 
282
                          help=self.help, dest=self._param_name, default=[],
253
283
                          *option_strings)
254
284
 
255
285
    def _optparse_callback(self, option, opt, value, parser):
256
 
        values = getattr(parser.values, self.name)
 
286
        values = getattr(parser.values, self._param_name)
257
287
        if value == '-':
258
288
            del values[:]
259
289
        else:
260
290
            values.append(self.type(value))
 
291
        if self.custom_callback is not None:
 
292
            self.custom_callback(option, self._param_name, values, parser)
261
293
 
262
294
 
263
295
class RegistryOption(Option):
281
313
        else:
282
314
            return self.converter(value)
283
315
 
284
 
    def __init__(self, name, help, registry, converter=None,
285
 
        value_switches=False, title=None, enum_switch=True):
 
316
    def __init__(self, name, help, registry=None, converter=None,
 
317
        value_switches=False, title=None, enum_switch=True,
 
318
        lazy_registry=None, short_name=None, short_value_switches=None):
286
319
        """
287
320
        Constructor.
288
321
 
296
329
            '--knit' can be used interchangeably.
297
330
        :param enum_switch: If true, a switch is provided with the option name,
298
331
            which takes a value.
 
332
        :param lazy_registry: A tuple of (module name, attribute name) for a
 
333
            registry to be lazily loaded.
 
334
        :param short_name: The short name for the enum switch, if any
 
335
        :param short_value_switches: A dict mapping values to short names
299
336
        """
300
 
        Option.__init__(self, name, help, type=self.convert)
301
 
        self.registry = registry
 
337
        Option.__init__(self, name, help, type=self.convert,
 
338
                        short_name=short_name)
 
339
        self._registry = registry
 
340
        if registry is None:
 
341
            if lazy_registry is None:
 
342
                raise AssertionError(
 
343
                    'One of registry or lazy_registry must be given.')
 
344
            self._lazy_registry = _mod_registry._LazyObjectGetter(
 
345
                *lazy_registry)
 
346
        if registry is not None and lazy_registry is not None:
 
347
            raise AssertionError(
 
348
                'registry and lazy_registry are mutually exclusive')
302
349
        self.name = name
303
350
        self.converter = converter
304
351
        self.value_switches = value_switches
305
352
        self.enum_switch = enum_switch
 
353
        self.short_value_switches = short_value_switches
306
354
        self.title = title
307
355
        if self.title is None:
308
356
            self.title = name
309
357
 
 
358
    @property
 
359
    def registry(self):
 
360
        if self._registry is None:
 
361
            self._registry = self._lazy_registry.get_obj()
 
362
        return self._registry
 
363
 
310
364
    @staticmethod
311
365
    def from_kwargs(name_, help=None, title=None, value_switches=False,
312
366
                    enum_switch=True, **kwargs):
314
368
 
315
369
        name, help, value_switches and enum_switch are passed to the
316
370
        RegistryOption constructor.  Any other keyword arguments are treated
317
 
        as values for the option, and they value is treated as the help.
 
371
        as values for the option, and their value is treated as the help.
318
372
        """
319
 
        reg = registry.Registry()
320
 
        for name, switch_help in kwargs.iteritems():
 
373
        reg = _mod_registry.Registry()
 
374
        for name, switch_help in sorted(kwargs.items()):
321
375
            name = name.replace('_', '-')
322
376
            reg.register(name, name, help=switch_help)
 
377
            if not value_switches:
 
378
                help = help + '  "' + name + '": ' + switch_help
 
379
                if not help.endswith("."):
 
380
                    help = help + "."
323
381
        return RegistryOption(name_, help, reg, title=title,
324
382
            value_switches=value_switches, enum_switch=enum_switch)
325
383
 
336
394
                    help = optparse.SUPPRESS_HELP
337
395
                else:
338
396
                    help = self.registry.get_help(key)
 
397
                if (self.short_value_switches and
 
398
                    key in self.short_value_switches):
 
399
                    option_strings.append('-%s' %
 
400
                                          self.short_value_switches[key])
339
401
                parser.add_option(action='callback',
340
402
                              callback=self._optparse_value_callback(key),
341
403
                                  help=help,
343
405
 
344
406
    def _optparse_value_callback(self, cb_value):
345
407
        def cb(option, opt, value, parser):
346
 
            setattr(parser.values, self.name, self.type(cb_value))
 
408
            v = self.type(cb_value)
 
409
            setattr(parser.values, self._param_name, v)
 
410
            if self.custom_callback is not None:
 
411
                self.custom_callback(option, self._param_name, v, parser)
347
412
        return cb
348
413
 
349
414
    def iter_switches(self):
368
433
 
369
434
    DEFAULT_VALUE = object()
370
435
 
 
436
    def __init__(self):
 
437
        optparse.OptionParser.__init__(self)
 
438
        self.formatter = GettextIndentedHelpFormatter()
 
439
 
371
440
    def error(self, message):
372
441
        raise errors.BzrCommandError(message)
373
442
 
374
443
 
 
444
class GettextIndentedHelpFormatter(optparse.IndentedHelpFormatter):
 
445
    """Adds gettext() call to format_option()"""
 
446
    def __init__(self):
 
447
        optparse.IndentedHelpFormatter.__init__(self)
 
448
 
 
449
    def format_option(self, option):
 
450
        """code taken from Python's optparse.py"""
 
451
        if option.help:
 
452
            option.help = i18n.gettext(option.help)
 
453
        return optparse.IndentedHelpFormatter.format_option(self, option)
 
454
 
 
455
 
375
456
def get_optparser(options):
376
457
    """Generate an optparse parser for bzrlib-style options"""
377
458
 
382
463
    return parser
383
464
 
384
465
 
 
466
def custom_help(name, help):
 
467
    """Clone a common option overriding the help."""
 
468
    import copy
 
469
    o = copy.copy(Option.OPTIONS[name])
 
470
    o.help = help
 
471
    return o
 
472
 
 
473
 
 
474
def _standard_option(name, **kwargs):
 
475
    """Register a standard option."""
 
476
    # All standard options are implicitly 'global' ones
 
477
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
 
478
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
 
479
 
 
480
def _standard_list_option(name, **kwargs):
 
481
    """Register a standard option."""
 
482
    # All standard options are implicitly 'global' ones
 
483
    Option.STD_OPTIONS[name] = ListOption(name, **kwargs)
 
484
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
 
485
 
 
486
 
385
487
def _global_option(name, **kwargs):
386
 
    """Register o as a global option."""
 
488
    """Register a global option."""
387
489
    Option.OPTIONS[name] = Option(name, **kwargs)
388
490
 
389
491
 
390
 
def _global_registry_option(name, help, registry, **kwargs):
 
492
def _global_registry_option(name, help, registry=None, **kwargs):
391
493
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
392
494
 
393
495
 
394
 
class MergeTypeRegistry(registry.Registry):
395
 
 
396
 
    pass
397
 
 
398
 
 
399
 
_merge_type_registry = MergeTypeRegistry()
400
 
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
401
 
                                   "Native diff3-style merge")
402
 
_merge_type_registry.register_lazy('diff3', 'bzrlib.merge', 'Diff3Merger',
403
 
                                   "Merge using external diff3")
404
 
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
405
 
                                   "Weave-based merge")
406
 
 
407
 
_global_option('all')
408
 
_global_option('overwrite', help='Ignore differences between branches and '
409
 
               'overwrite unconditionally.')
410
 
_global_option('basis', type=str)
411
 
_global_option('bound')
412
 
_global_option('diff-options', type=str)
 
496
# This is the verbosity level detected during command line parsing.
 
497
# Note that the final value is dependent on the order in which the
 
498
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
 
499
# The final value will be one of the following:
 
500
#
 
501
# * -ve for quiet
 
502
# * 0 for normal
 
503
# * +ve for verbose
 
504
_verbosity_level = 0
 
505
 
 
506
 
 
507
def _verbosity_level_callback(option, opt_str, value, parser):
 
508
    global _verbosity_level
 
509
    if not value:
 
510
        # Either --no-verbose or --no-quiet was specified
 
511
        _verbosity_level = 0
 
512
    elif opt_str == "verbose":
 
513
        if _verbosity_level > 0:
 
514
            _verbosity_level += 1
 
515
        else:
 
516
            _verbosity_level = 1
 
517
    else:
 
518
        if _verbosity_level < 0:
 
519
            _verbosity_level -= 1
 
520
        else:
 
521
            _verbosity_level = -1
 
522
 
 
523
 
 
524
# Declare the standard options
 
525
_standard_option('help', short_name='h',
 
526
                 help='Show help message.')
 
527
_standard_option('quiet', short_name='q',
 
528
                 help="Only display errors and warnings.",
 
529
                 custom_callback=_verbosity_level_callback)
 
530
_standard_option('usage',
 
531
                 help='Show usage message and options.')
 
532
_standard_option('verbose', short_name='v',
 
533
                 help='Display more information.',
 
534
                 custom_callback=_verbosity_level_callback)
 
535
 
 
536
# Declare commonly used options
 
537
_global_option('change',
 
538
               type=_parse_change_str,
 
539
               short_name='c',
 
540
               param_name='revision',
 
541
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
 
542
_global_option('directory', short_name='d', type=unicode,
 
543
               help='Branch to operate on, instead of working directory.')
413
544
_global_option('file', type=unicode, short_name='F')
414
 
_global_option('force')
415
 
_global_option('format', type=unicode)
416
 
_global_option('forward')
 
545
_global_registry_option('log-format', "Use specified log format.",
 
546
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
 
547
                        value_switches=True, title='Log format',
 
548
                        short_value_switches={'short': 'S'})
 
549
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
 
550
                        lazy_registry=('bzrlib.merge', 'merge_type_registry'),
 
551
                        value_switches=True, title='Merge algorithm')
417
552
_global_option('message', type=unicode,
418
553
               short_name='m',
419
554
               help='Message string.')
420
 
_global_option('no-recurse')
421
 
_global_option('profile',
422
 
               help='Show performance profiling information.')
 
555
_global_option('null', short_name='0',
 
556
                 help='Use an ASCII NUL (\\0) separator rather than '
 
557
                      'a newline.')
 
558
_global_option('overwrite', help='Ignore differences between branches and '
 
559
               'overwrite unconditionally.')
 
560
_global_option('remember', help='Remember the specified location as a'
 
561
               ' default.')
 
562
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
423
563
_global_option('revision',
424
564
               type=_parse_revision_str,
425
565
               short_name='r',
426
566
               help='See "help revisionspec" for details.')
427
 
_global_option('change',
428
 
               type=_parse_change_str,
429
 
               short_name='c',
430
 
               param_name='revision',
431
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
432
567
_global_option('show-ids',
433
568
               help='Show internal object ids.')
434
 
_global_option('timezone', 
 
569
_global_option('timezone',
435
570
               type=str,
436
 
               help='display timezone as local, original, or utc')
437
 
_global_option('unbound')
438
 
_global_option('verbose',
439
 
               help='Display more information.',
440
 
               short_name='v')
441
 
_global_option('version')
442
 
_global_option('email')
443
 
_global_option('update')
444
 
_global_registry_option('log-format', "Use specified log format.",
445
 
                        log.log_formatter_registry, value_switches=True,
446
 
                        title='Log format')
447
 
_global_option('long', help='Use detailed log format. Same as --log-format long',
448
 
               short_name='l')
449
 
_global_option('short', help='Use moderately short log format. Same as --log-format short')
450
 
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
451
 
_global_option('root', type=str)
452
 
_global_option('no-backup')
453
 
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
454
 
                        _merge_type_registry, value_switches=True,
455
 
                        title='Merge algorithm')
456
 
_global_option('pattern', type=str)
457
 
_global_option('quiet', short_name='q')
458
 
_global_option('remember', help='Remember the specified location as a'
459
 
               ' default.')
460
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
461
 
_global_option('kind', type=str)
462
 
_global_option('dry-run',
463
 
               help="Show what would be done, but don't actually do anything.")
464
 
_global_option('name-from-revision', help='The path name in the old tree.')
 
571
               help='Display timezone as local, original, or utc.')
465
572
 
466
 
_help_option = Option('help',
467
 
                      help='Show help message.',
468
 
                      short_name='h')
 
573
diff_writer_registry = _mod_registry.Registry()
 
574
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
 
575
diff_writer_registry.default_key = 'plain'