← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Martin Pool
  • Date: 2007-08-21 05:29:59 UTC
  • mto: This revision was merged to the branch mainline in revision 2779.
  • Revision ID: mbp@sourcefrog.net-20070821052959-5odvyjziwyuaeo3d
Move per-inventory tests from test_inv to tests.inventory_implementations

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
23
20
import re
24
21
 
25
22
from bzrlib.lazy_import import lazy_import
26
23
lazy_import(globals(), """
 
24
import optparse
 
25
 
27
26
from bzrlib import (
28
27
    errors,
 
28
    log,
 
29
    registry,
29
30
    revisionspec,
30
 
    i18n,
 
31
    symbol_versioning,
31
32
    )
32
33
""")
33
 
 
34
 
from bzrlib import (
35
 
    registry as _mod_registry,
36
 
    )
 
34
from bzrlib.trace import warning
37
35
 
38
36
 
39
37
def _parse_revision_str(revstr):
43
41
    each revision specifier supplied.
44
42
 
45
43
    >>> _parse_revision_str('234')
46
 
    [<RevisionSpec_dwim 234>]
 
44
    [<RevisionSpec_revno 234>]
47
45
    >>> _parse_revision_str('234..567')
48
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
 
46
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
49
47
    >>> _parse_revision_str('..')
50
48
    [<RevisionSpec None>, <RevisionSpec None>]
51
49
    >>> _parse_revision_str('..234')
52
 
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
 
50
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
53
51
    >>> _parse_revision_str('234..')
54
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
 
52
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
55
53
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
56
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
 
54
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
57
55
    >>> _parse_revision_str('234....789') #Error ?
58
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
 
56
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
59
57
    >>> _parse_revision_str('revid:test@other.com-234234')
60
58
    [<RevisionSpec_revid revid:test@other.com-234234>]
61
59
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
62
60
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
63
61
    >>> _parse_revision_str('revid:test@other.com-234234..23')
64
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
 
62
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
65
63
    >>> _parse_revision_str('date:2005-04-12')
66
64
    [<RevisionSpec_date date:2005-04-12>]
67
65
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
71
69
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
72
70
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
73
71
    >>> _parse_revision_str('-5..23')
74
 
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
 
72
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
75
73
    >>> _parse_revision_str('-5')
76
 
    [<RevisionSpec_dwim -5>]
 
74
    [<RevisionSpec_revno -5>]
77
75
    >>> _parse_revision_str('123a')
78
 
    [<RevisionSpec_dwim 123a>]
 
76
    Traceback (most recent call last):
 
77
      ...
 
78
    NoSuchRevisionSpec: No namespace registered for string: '123a'
79
79
    >>> _parse_revision_str('abc')
80
 
    [<RevisionSpec_dwim abc>]
 
80
    Traceback (most recent call last):
 
81
      ...
 
82
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
81
83
    >>> _parse_revision_str('branch:../branch2')
82
84
    [<RevisionSpec_branch branch:../branch2>]
83
85
    >>> _parse_revision_str('branch:../../branch2')
84
86
    [<RevisionSpec_branch branch:../../branch2>]
85
87
    >>> _parse_revision_str('branch:../../branch2..23')
86
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
87
 
    >>> _parse_revision_str('branch:..\\\\branch2')
88
 
    [<RevisionSpec_branch branch:..\\branch2>]
89
 
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
90
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
 
88
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
91
89
    """
92
90
    # TODO: Maybe move this into revisionspec.py
93
91
    revs = []
94
 
    # split on .. that is not followed by a / or \
95
 
    sep = re.compile(r'\.\.(?![\\/])')
 
92
    # split on the first .. that is not followed by a / ?
 
93
    sep = re.compile("\\.\\.(?!/)")
96
94
    for x in sep.split(revstr):
97
95
        revs.append(revisionspec.RevisionSpec.from_string(x or None))
98
96
    return revs
99
97
 
100
98
 
101
 
def _parse_change_str(revstr):
102
 
    """Parse the revision string and return a tuple with left-most
103
 
    parent of the revision.
104
 
 
105
 
    >>> _parse_change_str('123')
106
 
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
107
 
    >>> _parse_change_str('123..124')
108
 
    Traceback (most recent call last):
109
 
      ...
110
 
    RangeInChangeOption: Option --change does not accept revision ranges
111
 
    """
112
 
    revs = _parse_revision_str(revstr)
113
 
    if len(revs) > 1:
114
 
        raise errors.RangeInChangeOption()
115
 
    return (revisionspec.RevisionSpec.from_string('before:' + revstr),
116
 
            revs[0])
117
 
 
118
 
 
119
99
def _parse_merge_type(typestring):
120
100
    return get_merge_type(typestring)
121
101
 
135
115
 
136
116
class Option(object):
137
117
    """Description of a command line option
138
 
 
 
118
    
139
119
    :ivar _short_name: If this option has a single-letter name, this is it.
140
120
    Otherwise None.
141
121
    """
142
122
 
143
 
    # The dictionary of standard options. These are always legal.
144
 
    STD_OPTIONS = {}
 
123
    # TODO: Some way to show in help a description of the option argument
145
124
 
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.
149
125
    OPTIONS = {}
150
126
 
151
127
    def __init__(self, name, help='', type=None, argname=None,
152
 
                 short_name=None, param_name=None, custom_callback=None,
153
 
                 hidden=False):
 
128
                 short_name=None):
154
129
        """Make a new command option.
155
130
 
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()
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
        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 
163
138
            None (default) if this option doesn't take an argument.
164
139
 
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).
176
 
        :param hidden: If True, the option should be hidden in help and
177
 
            documentation.
 
140
        argname -- name of option argument, if any
178
141
        """
179
142
        self.name = name
180
143
        self.help = help
181
144
        self.type = type
182
145
        self._short_name = short_name
183
146
        if type is None:
184
 
            if argname:
185
 
                raise ValueError('argname not valid for booleans')
 
147
            assert argname is None
186
148
        elif argname is None:
187
149
            argname = 'ARG'
188
150
        self.argname = argname
189
 
        if param_name is None:
190
 
            self._param_name = self.name.replace('-', '_')
191
 
        else:
192
 
            self._param_name = param_name
193
 
        self.custom_callback = custom_callback
194
 
        self.hidden = hidden
195
151
 
196
152
    def short_name(self):
197
153
        if self._short_name:
211
167
        option_strings = ['--%s' % self.name]
212
168
        if short_name is not None:
213
169
            option_strings.append('-%s' % short_name)
214
 
        if self.hidden:
215
 
            help = optparse.SUPPRESS_HELP
216
 
        else:
217
 
            help = self.help
218
170
        optargfn = self.type
219
171
        if optargfn is None:
220
 
            parser.add_option(action='callback',
221
 
                              callback=self._optparse_bool_callback,
222
 
                              callback_args=(True,),
223
 
                              help=help,
 
172
            parser.add_option(action='store_true', dest=self.name, 
 
173
                              help=self.help,
 
174
                              default=OptionParser.DEFAULT_VALUE,
224
175
                              *option_strings)
225
176
            negation_strings = ['--%s' % self.get_negation_name()]
226
 
            parser.add_option(action='callback',
227
 
                              callback=self._optparse_bool_callback,
228
 
                              callback_args=(False,),
 
177
            parser.add_option(action='store_false', dest=self.name, 
229
178
                              help=optparse.SUPPRESS_HELP, *negation_strings)
230
179
        else:
231
 
            parser.add_option(action='callback',
232
 
                              callback=self._optparse_callback,
 
180
            parser.add_option(action='callback', 
 
181
                              callback=self._optparse_callback, 
233
182
                              type='string', metavar=self.argname.upper(),
234
 
                              help=help,
235
 
                              default=OptionParser.DEFAULT_VALUE,
 
183
                              help=self.help,
 
184
                              default=OptionParser.DEFAULT_VALUE, 
236
185
                              *option_strings)
237
186
 
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
 
 
243
187
    def _optparse_callback(self, option, opt, value, parser):
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)
 
188
        setattr(parser.values, self.name, self.type(value))
248
189
 
249
190
    def iter_switches(self):
250
191
        """Iterate through the list of switches provided by the option
251
 
 
 
192
        
252
193
        :return: an iterator of (name, short_name, argname, help)
253
194
        """
254
195
        argname =  self.argname
256
197
            argname = argname.upper()
257
198
        yield self.name, self.short_name(), argname, self.help
258
199
 
259
 
    def is_hidden(self, name):
260
 
        return self.hidden
261
 
 
262
200
 
263
201
class ListOption(Option):
264
202
    """Option used to provide a list of values.
279
217
        parser.add_option(action='callback',
280
218
                          callback=self._optparse_callback,
281
219
                          type='string', metavar=self.argname.upper(),
282
 
                          help=self.help, dest=self._param_name, default=[],
 
220
                          help=self.help, default=[],
283
221
                          *option_strings)
284
222
 
285
223
    def _optparse_callback(self, option, opt, value, parser):
286
 
        values = getattr(parser.values, self._param_name)
 
224
        values = getattr(parser.values, self.name)
287
225
        if value == '-':
288
226
            del values[:]
289
227
        else:
290
228
            values.append(self.type(value))
291
 
        if self.custom_callback is not None:
292
 
            self.custom_callback(option, self._param_name, values, parser)
293
229
 
294
230
 
295
231
class RegistryOption(Option):
313
249
        else:
314
250
            return self.converter(value)
315
251
 
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):
 
252
    def __init__(self, name, help, registry, converter=None,
 
253
        value_switches=False, title=None, enum_switch=True):
319
254
        """
320
255
        Constructor.
321
256
 
329
264
            '--knit' can be used interchangeably.
330
265
        :param enum_switch: If true, a switch is provided with the option name,
331
266
            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
336
267
        """
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')
 
268
        Option.__init__(self, name, help, type=self.convert)
 
269
        self.registry = registry
349
270
        self.name = name
350
271
        self.converter = converter
351
272
        self.value_switches = value_switches
352
273
        self.enum_switch = enum_switch
353
 
        self.short_value_switches = short_value_switches
354
274
        self.title = title
355
275
        if self.title is None:
356
276
            self.title = name
357
277
 
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
 
 
364
278
    @staticmethod
365
279
    def from_kwargs(name_, help=None, title=None, value_switches=False,
366
280
                    enum_switch=True, **kwargs):
368
282
 
369
283
        name, help, value_switches and enum_switch are passed to the
370
284
        RegistryOption constructor.  Any other keyword arguments are treated
371
 
        as values for the option, and their value is treated as the help.
 
285
        as values for the option, and they value is treated as the help.
372
286
        """
373
 
        reg = _mod_registry.Registry()
374
 
        for name, switch_help in sorted(kwargs.items()):
 
287
        reg = registry.Registry()
 
288
        for name, switch_help in kwargs.iteritems():
375
289
            name = name.replace('_', '-')
376
290
            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 + "."
381
291
        return RegistryOption(name_, help, reg, title=title,
382
292
            value_switches=value_switches, enum_switch=enum_switch)
383
293
 
390
300
        if self.value_switches:
391
301
            for key in self.registry.keys():
392
302
                option_strings = ['--%s' % key]
393
 
                if self.is_hidden(key):
 
303
                if getattr(self.registry.get_info(key), 'hidden', False):
394
304
                    help = optparse.SUPPRESS_HELP
395
305
                else:
396
306
                    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])
401
307
                parser.add_option(action='callback',
402
308
                              callback=self._optparse_value_callback(key),
403
309
                                  help=help,
405
311
 
406
312
    def _optparse_value_callback(self, cb_value):
407
313
        def cb(option, opt, value, parser):
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)
 
314
            setattr(parser.values, self.name, self.type(cb_value))
412
315
        return cb
413
316
 
414
317
    def iter_switches(self):
422
325
            for key in sorted(self.registry.keys()):
423
326
                yield key, None, None, self.registry.get_help(key)
424
327
 
425
 
    def is_hidden(self, name):
426
 
        if name == self.name:
427
 
            return Option.is_hidden(self, name)
428
 
        return getattr(self.registry.get_info(name), 'hidden', False)
429
 
 
430
328
 
431
329
class OptionParser(optparse.OptionParser):
432
330
    """OptionParser that raises exceptions instead of exiting"""
433
331
 
434
332
    DEFAULT_VALUE = object()
435
333
 
436
 
    def __init__(self):
437
 
        optparse.OptionParser.__init__(self)
438
 
        self.formatter = GettextIndentedHelpFormatter()
439
 
 
440
334
    def error(self, message):
441
335
        raise errors.BzrCommandError(message)
442
336
 
443
337
 
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
 
 
456
338
def get_optparser(options):
457
339
    """Generate an optparse parser for bzrlib-style options"""
458
340
 
463
345
    return parser
464
346
 
465
347
 
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
 
 
487
348
def _global_option(name, **kwargs):
488
 
    """Register a global option."""
 
349
    """Register o as a global option."""
489
350
    Option.OPTIONS[name] = Option(name, **kwargs)
490
351
 
491
352
 
492
 
def _global_registry_option(name, help, registry=None, **kwargs):
 
353
def _global_registry_option(name, help, registry, **kwargs):
493
354
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
494
355
 
495
356
 
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.')
 
357
class MergeTypeRegistry(registry.Registry):
 
358
 
 
359
    pass
 
360
 
 
361
 
 
362
_merge_type_registry = MergeTypeRegistry()
 
363
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
 
364
                                   "Native diff3-style merge")
 
365
_merge_type_registry.register_lazy('diff3', 'bzrlib.merge', 'Diff3Merger',
 
366
                                   "Merge using external diff3")
 
367
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
 
368
                                   "Weave-based merge")
 
369
 
 
370
_global_option('all')
 
371
_global_option('overwrite', help='Ignore differences between branches and '
 
372
               'overwrite unconditionally.')
 
373
_global_option('basis', type=str)
 
374
_global_option('bound')
 
375
_global_option('diff-options', type=str)
544
376
_global_option('file', type=unicode, short_name='F')
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')
 
377
_global_option('force')
 
378
_global_option('format', type=unicode)
 
379
_global_option('forward')
552
380
_global_option('message', type=unicode,
553
381
               short_name='m',
554
382
               help='Message string.')
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.')
 
383
_global_option('no-recurse')
 
384
_global_option('profile',
 
385
               help='Show performance profiling information.')
563
386
_global_option('revision',
564
387
               type=_parse_revision_str,
565
388
               short_name='r',
566
 
               help='See "help revisionspec" for details.')
 
389
               help='See \'help revisionspec\' for details.')
567
390
_global_option('show-ids',
568
391
               help='Show internal object ids.')
569
 
_global_option('timezone',
 
392
_global_option('timezone', 
570
393
               type=str,
571
 
               help='Display timezone as local, original, or utc.')
 
394
               help='display timezone as local, original, or utc')
 
395
_global_option('unbound')
 
396
_global_option('verbose',
 
397
               help='Display more information.',
 
398
               short_name='v')
 
399
_global_option('version')
 
400
_global_option('email')
 
401
_global_option('update')
 
402
_global_registry_option('log-format', "Use specified log format.",
 
403
                        log.log_formatter_registry, value_switches=True,
 
404
                        title='Log format')
 
405
_global_option('long', help='Use detailed log format. Same as --log-format long',
 
406
               short_name='l')
 
407
_global_option('short', help='Use moderately short log format. Same as --log-format short')
 
408
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
 
409
_global_option('root', type=str)
 
410
_global_option('no-backup')
 
411
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
 
412
                        _merge_type_registry, value_switches=True,
 
413
                        title='Merge algorithm')
 
414
_global_option('pattern', type=str)
 
415
_global_option('quiet', short_name='q')
 
416
_global_option('remember', help='Remember the specified location as a'
 
417
               ' default.')
 
418
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
 
419
_global_option('kind', type=str)
 
420
_global_option('dry-run',
 
421
               help="Show what would be done, but don't actually do anything.")
 
422
_global_option('name-from-revision', help='The path name in the old tree.')
572
423
 
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'
 
424
_help_option = Option('help',
 
425
                      help='Show help message.',
 
426
                      short_name='h')