← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Robert Collins
  • Date: 2005-12-02 03:23:47 UTC
  • Revision ID: robertc@robertcollins.net-20051202032347-ba08123207a945a0
Test for Jeff Bailey.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2004, 2005 by 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., 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
 
import optparse
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
21
18
import re
22
19
 
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
 
    )
 
20
import bzrlib.commands
 
21
from bzrlib.trace import warning, mutter
 
22
from bzrlib.revisionspec import RevisionSpec
 
23
from bzrlib.errors import BzrCommandError
34
24
 
35
25
 
36
26
def _parse_revision_str(revstr):
40
30
    each revision specifier supplied.
41
31
 
42
32
    >>> _parse_revision_str('234')
43
 
    [<RevisionSpec_dwim 234>]
 
33
    [<RevisionSpec_int 234>]
44
34
    >>> _parse_revision_str('234..567')
45
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
 
35
    [<RevisionSpec_int 234>, <RevisionSpec_int 567>]
46
36
    >>> _parse_revision_str('..')
47
37
    [<RevisionSpec None>, <RevisionSpec None>]
48
38
    >>> _parse_revision_str('..234')
49
 
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
 
39
    [<RevisionSpec None>, <RevisionSpec_int 234>]
50
40
    >>> _parse_revision_str('234..')
51
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
 
41
    [<RevisionSpec_int 234>, <RevisionSpec None>]
52
42
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
53
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
 
43
    [<RevisionSpec_int 234>, <RevisionSpec_int 456>, <RevisionSpec_int 789>]
54
44
    >>> _parse_revision_str('234....789') #Error ?
55
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
 
45
    [<RevisionSpec_int 234>, <RevisionSpec None>, <RevisionSpec_int 789>]
56
46
    >>> _parse_revision_str('revid:test@other.com-234234')
57
47
    [<RevisionSpec_revid revid:test@other.com-234234>]
58
48
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
59
49
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
60
50
    >>> _parse_revision_str('revid:test@other.com-234234..23')
61
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
 
51
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_int 23>]
62
52
    >>> _parse_revision_str('date:2005-04-12')
63
53
    [<RevisionSpec_date date:2005-04-12>]
64
54
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
68
58
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
69
59
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
70
60
    >>> _parse_revision_str('-5..23')
71
 
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
 
61
    [<RevisionSpec_int -5>, <RevisionSpec_int 23>]
72
62
    >>> _parse_revision_str('-5')
73
 
    [<RevisionSpec_dwim -5>]
 
63
    [<RevisionSpec_int -5>]
74
64
    >>> _parse_revision_str('123a')
75
 
    [<RevisionSpec_dwim 123a>]
 
65
    Traceback (most recent call last):
 
66
      ...
 
67
    BzrError: No namespace registered for string: '123a'
76
68
    >>> _parse_revision_str('abc')
77
 
    [<RevisionSpec_dwim abc>]
 
69
    Traceback (most recent call last):
 
70
      ...
 
71
    BzrError: No namespace registered for string: 'abc'
78
72
    >>> _parse_revision_str('branch:../branch2')
79
73
    [<RevisionSpec_branch branch:../branch2>]
80
 
    >>> _parse_revision_str('branch:../../branch2')
81
 
    [<RevisionSpec_branch branch:../../branch2>]
82
 
    >>> _parse_revision_str('branch:../../branch2..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>]
88
74
    """
89
75
    # TODO: Maybe move this into revisionspec.py
 
76
    old_format_re = re.compile('\d*:\d*')
 
77
    m = old_format_re.match(revstr)
90
78
    revs = []
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))
 
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))
95
102
    return revs
96
103
 
97
104
 
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
 
 
116
105
def _parse_merge_type(typestring):
117
106
    return get_merge_type(typestring)
118
107
 
127
116
        type_list = '\n'.join(lines)
128
117
        msg = "No known merge type %s. Supported types are:\n%s" %\
129
118
            (typestring, type_list)
130
 
        raise errors.BzrCommandError(msg)
131
 
 
 
119
        raise BzrCommandError(msg)
132
120
 
133
121
class Option(object):
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.
 
122
    """Description of a command line option"""
 
123
    # TODO: Some way to show in help a description of the option argument
 
124
 
146
125
    OPTIONS = {}
 
126
    SHORT_OPTIONS = {}
147
127
 
148
 
    def __init__(self, name, help='', type=None, argname=None,
149
 
                 short_name=None, param_name=None, custom_callback=None,
150
 
                 hidden=False):
 
128
    def __init__(self, name, help='', type=None, argname=None):
151
129
        """Make a new command option.
152
130
 
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
 
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 
160
138
            None (default) if this option doesn't take an argument.
161
139
 
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.
 
140
        argname -- name of option argument, if any
175
141
        """
 
142
        # TODO: perhaps a subclass that automatically does 
 
143
        # --option, --no-option for reversable booleans
176
144
        self.name = name
177
145
        self.help = help
178
146
        self.type = type
179
 
        self._short_name = short_name
180
147
        if type is None:
181
 
            if argname:
182
 
                raise ValueError('argname not valid for booleans')
 
148
            assert argname is None
183
149
        elif argname is None:
184
150
            argname = 'ARG'
185
151
        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
192
152
 
193
153
    def short_name(self):
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, 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
 
 
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 sorted(kwargs.items()):
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]
 
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
452
161
 
453
162
 
454
163
def _global_option(name, **kwargs):
455
 
    """Register a global option."""
 
164
    """Register o as a global option."""
456
165
    Option.OPTIONS[name] = Option(name, **kwargs)
457
166
 
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
519
167
_global_option('all')
520
168
_global_option('overwrite', help='Ignore differences between branches and '
521
 
               'overwrite unconditionally.')
 
169
               'overwrite unconditionally')
522
170
_global_option('basis', type=str)
523
 
_global_option('bound')
524
171
_global_option('diff-options', type=str)
525
 
_global_option('file', type=unicode, short_name='F')
 
172
_global_option('help',
 
173
               help='show help message')
 
174
_global_option('file', type=unicode)
526
175
_global_option('force')
527
176
_global_option('format', type=unicode)
528
177
_global_option('forward')
529
 
_global_option('message', type=unicode,
530
 
               short_name='m',
531
 
               help='Message string.')
 
178
_global_option('message', type=unicode)
532
179
_global_option('no-recurse')
533
 
_global_option('null', short_name='0',
534
 
                 help='Use an ASCII NUL (\\0) separator rather than '
535
 
                      'a newline.')
536
180
_global_option('profile',
537
 
               help='Show performance profiling information.')
538
 
_global_option('revision',
539
 
               type=_parse_revision_str,
540
 
               short_name='r',
541
 
               help='See "help revisionspec" for details.')
542
 
_global_option('change',
543
 
               type=_parse_change_str,
544
 
               short_name='c',
545
 
               param_name='revision',
546
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
547
 
_global_option('show-ids',
548
 
               help='Show internal object ids.')
549
 
_global_option('timezone',
 
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', 
550
187
               type=str,
551
 
               help='Display timezone as local, original, or utc.')
552
 
_global_option('unbound')
 
188
               help='display timezone as local, original, or utc')
 
189
_global_option('verbose',
 
190
               help='display more information')
553
191
_global_option('version')
554
192
_global_option('email')
555
193
_global_option('update')
556
 
_global_registry_option('log-format', "Use specified log format.",
557
 
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
558
 
                        value_switches=True, title='Log format')
559
 
_global_option('long', help='Use detailed log format. Same as --log-format long',
560
 
               short_name='l')
561
 
_global_option('short', help='Use moderately short log format. Same as --log-format short')
562
 
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
 
194
_global_option('long')
563
195
_global_option('root', type=str)
564
196
_global_option('no-backup')
565
 
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
566
 
                        _merge_type_registry, value_switches=True,
567
 
                        title='Merge algorithm')
 
197
_global_option('merge-type', type=_parse_merge_type)
568
198
_global_option('pattern', type=str)
 
199
_global_option('quiet')
569
200
_global_option('remember', help='Remember the specified location as a'
570
201
               ' default.')
571
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
 
202
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
572
203
_global_option('kind', type=str)
573
 
_global_option('dry-run',
574
 
               help="Show what would be done, but don't actually do anything.")
575
 
_global_option('name-from-revision', help='The path name in the old tree.')
576
 
_global_option('directory', short_name='d', type=unicode,
577
 
               help='Branch to operate on, instead of working directory')
578
 
 
579
 
diff_writer_registry = _mod_registry.Registry()
580
 
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
581
 
diff_writer_registry.default_key = 'plain'
 
204
 
 
205
 
 
206
def _global_short(short_name, long_name):
 
207
    assert short_name not in Option.SHORT_OPTIONS
 
208
    Option.SHORT_OPTIONS[short_name] = Option.OPTIONS[long_name]
 
209
    
 
210
 
 
211
Option.SHORT_OPTIONS['F'] = Option.OPTIONS['file']
 
212
Option.SHORT_OPTIONS['h'] = Option.OPTIONS['help']
 
213
Option.SHORT_OPTIONS['m'] = Option.OPTIONS['message']
 
214
Option.SHORT_OPTIONS['r'] = Option.OPTIONS['revision']
 
215
Option.SHORT_OPTIONS['v'] = Option.OPTIONS['verbose']
 
216
Option.SHORT_OPTIONS['l'] = Option.OPTIONS['long']
 
217
Option.SHORT_OPTIONS['q'] = Option.OPTIONS['quiet']