← 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: 2009-03-24 15:47:32 UTC
  • mto: This revision was merged to the branch mainline in revision 4241.
  • Revision ID: aaron@aaronbentley.com-20090324154732-bwkvi4dx3o90a7dq
Add output, emit minimal inventory delta.

Show diffs side-by-side

added added

removed removed

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