/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/option.py

Merge from bzr.dev, resolving conflicts.

Show diffs side-by-side

added added

removed removed

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