← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-03-30 08:04:28 UTC
  • mfrom: (5117.2.4 doc)
  • Revision ID: pqm@pqm.ubuntu.com-20100330080428-sg126ybh11u7vqpx
(mbp) fix typo (thanks fullermd)

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