← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Jelmer Vernooij
  • Date: 2011-08-19 22:34:02 UTC
  • mto: This revision was merged to the branch mainline in revision 6089.
  • Revision ID: jelmer@samba.org-20110819223402-wjywqb0fa1xxx522
Use get_transport_from_{url,path} in more places.

Show diffs side-by-side

added added

removed removed

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