/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

First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

Show diffs side-by-side

added added

removed removed

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