← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

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