← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

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