← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-13 14:33:10 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813143310-twhj4la0qnupvze8
Added Quick Start Summary

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