← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: John Arbash Meinel
  • Date: 2009-10-02 20:32:50 UTC
  • mto: (4679.6.1 2.1-export-c-api)
  • mto: This revision was merged to the branch mainline in revision 4735.
  • Revision ID: john@arbash-meinel.com-20091002203250-q6iv6o2mwjqp4g53
Add __iter__ support.

Show diffs side-by-side

added added

removed removed

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