← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Patch Queue Manager
  • Date: 2015-09-30 16:43:21 UTC
  • mfrom: (6603.2.2 fix-keep-dirty)
  • Revision ID: pqm@pqm.ubuntu.com-20150930164321-ct2v2qnmvimqt8qf
(vila) Avoid associating dirty patch headers with the previous file in the
 patch. (Colin Watson)

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) 2005-2010 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
# TODO: For things like --diff-prefix, we want a way to customize the display
18
18
# of the option argument.
19
19
 
 
20
from __future__ import absolute_import
 
21
 
 
22
import optparse
20
23
import re
21
24
 
22
25
from bzrlib.lazy_import import lazy_import
23
26
lazy_import(globals(), """
24
 
import optparse
25
 
 
26
27
from bzrlib import (
27
28
    errors,
28
 
    log,
29
 
    registry,
30
29
    revisionspec,
31
 
    symbol_versioning,
 
30
    i18n,
32
31
    )
33
32
""")
34
 
from bzrlib.trace import warning
 
33
 
 
34
from bzrlib import (
 
35
    registry as _mod_registry,
 
36
    )
35
37
 
36
38
 
37
39
def _parse_revision_str(revstr):
41
43
    each revision specifier supplied.
42
44
 
43
45
    >>> _parse_revision_str('234')
44
 
    [<RevisionSpec_revno 234>]
 
46
    [<RevisionSpec_dwim 234>]
45
47
    >>> _parse_revision_str('234..567')
46
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
 
48
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
47
49
    >>> _parse_revision_str('..')
48
50
    [<RevisionSpec None>, <RevisionSpec None>]
49
51
    >>> _parse_revision_str('..234')
50
 
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
 
52
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
51
53
    >>> _parse_revision_str('234..')
52
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
 
54
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
53
55
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
54
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
 
56
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
55
57
    >>> _parse_revision_str('234....789') #Error ?
56
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
 
58
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
57
59
    >>> _parse_revision_str('revid:test@other.com-234234')
58
60
    [<RevisionSpec_revid revid:test@other.com-234234>]
59
61
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
60
62
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
61
63
    >>> _parse_revision_str('revid:test@other.com-234234..23')
62
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
 
64
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
63
65
    >>> _parse_revision_str('date:2005-04-12')
64
66
    [<RevisionSpec_date date:2005-04-12>]
65
67
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
69
71
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
70
72
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
71
73
    >>> _parse_revision_str('-5..23')
72
 
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
 
74
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
73
75
    >>> _parse_revision_str('-5')
74
 
    [<RevisionSpec_revno -5>]
 
76
    [<RevisionSpec_dwim -5>]
75
77
    >>> _parse_revision_str('123a')
76
 
    Traceback (most recent call last):
77
 
      ...
78
 
    NoSuchRevisionSpec: No namespace registered for string: '123a'
 
78
    [<RevisionSpec_dwim 123a>]
79
79
    >>> _parse_revision_str('abc')
80
 
    Traceback (most recent call last):
81
 
      ...
82
 
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
 
80
    [<RevisionSpec_dwim abc>]
83
81
    >>> _parse_revision_str('branch:../branch2')
84
82
    [<RevisionSpec_branch branch:../branch2>]
85
83
    >>> _parse_revision_str('branch:../../branch2')
86
84
    [<RevisionSpec_branch branch:../../branch2>]
87
85
    >>> _parse_revision_str('branch:../../branch2..23')
88
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
 
86
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
89
87
    >>> _parse_revision_str('branch:..\\\\branch2')
90
88
    [<RevisionSpec_branch branch:..\\branch2>]
91
89
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
92
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
 
90
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
93
91
    """
94
92
    # TODO: Maybe move this into revisionspec.py
95
93
    revs = []
105
103
    parent of the revision.
106
104
 
107
105
    >>> _parse_change_str('123')
108
 
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
 
106
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
109
107
    >>> _parse_change_str('123..124')
110
108
    Traceback (most recent call last):
111
109
      ...
137
135
 
138
136
class Option(object):
139
137
    """Description of a command line option
140
 
    
 
138
 
141
139
    :ivar _short_name: If this option has a single-letter name, this is it.
142
140
    Otherwise None.
143
141
    """
151
149
    OPTIONS = {}
152
150
 
153
151
    def __init__(self, name, help='', type=None, argname=None,
154
 
                 short_name=None, param_name=None, custom_callback=None):
 
152
                 short_name=None, param_name=None, custom_callback=None,
 
153
                 hidden=False):
155
154
        """Make a new command option.
156
155
 
157
156
        :param name: regular name of the command, used in the double-dash
158
 
            form and also as the parameter to the command's run() 
 
157
            form and also as the parameter to the command's run()
159
158
            method (unless param_name is specified).
160
159
 
161
160
        :param help: help message displayed in command help
162
161
 
163
 
        :param type: function called to parse the option argument, or 
 
162
        :param type: function called to parse the option argument, or
164
163
            None (default) if this option doesn't take an argument.
165
164
 
166
165
        :param argname: name of option argument, if any
174
173
        :param custom_callback: a callback routine to be called after normal
175
174
            processing. The signature of the callback routine is
176
175
            (option, name, new_value, parser).
 
176
        :param hidden: If True, the option should be hidden in help and
 
177
            documentation.
177
178
        """
178
179
        self.name = name
179
180
        self.help = help
180
181
        self.type = type
181
182
        self._short_name = short_name
182
183
        if type is None:
183
 
            assert argname is None
 
184
            if argname:
 
185
                raise ValueError('argname not valid for booleans')
184
186
        elif argname is None:
185
187
            argname = 'ARG'
186
188
        self.argname = argname
187
189
        if param_name is None:
188
 
            self._param_name = self.name
 
190
            self._param_name = self.name.replace('-', '_')
189
191
        else:
190
192
            self._param_name = param_name
191
193
        self.custom_callback = custom_callback
 
194
        self.hidden = hidden
192
195
 
193
196
    def short_name(self):
194
197
        if self._short_name:
208
211
        option_strings = ['--%s' % self.name]
209
212
        if short_name is not None:
210
213
            option_strings.append('-%s' % short_name)
 
214
        if self.hidden:
 
215
            help = optparse.SUPPRESS_HELP
 
216
        else:
 
217
            help = self.help
211
218
        optargfn = self.type
212
219
        if optargfn is None:
213
 
            parser.add_option(action='callback', 
214
 
                              callback=self._optparse_bool_callback, 
 
220
            parser.add_option(action='callback',
 
221
                              callback=self._optparse_bool_callback,
215
222
                              callback_args=(True,),
216
 
                              help=self.help,
 
223
                              help=help,
217
224
                              *option_strings)
218
225
            negation_strings = ['--%s' % self.get_negation_name()]
219
 
            parser.add_option(action='callback', 
220
 
                              callback=self._optparse_bool_callback, 
 
226
            parser.add_option(action='callback',
 
227
                              callback=self._optparse_bool_callback,
221
228
                              callback_args=(False,),
222
229
                              help=optparse.SUPPRESS_HELP, *negation_strings)
223
230
        else:
224
 
            parser.add_option(action='callback', 
225
 
                              callback=self._optparse_callback, 
 
231
            parser.add_option(action='callback',
 
232
                              callback=self._optparse_callback,
226
233
                              type='string', metavar=self.argname.upper(),
227
 
                              help=self.help,
228
 
                              default=OptionParser.DEFAULT_VALUE, 
 
234
                              help=help,
 
235
                              default=OptionParser.DEFAULT_VALUE,
229
236
                              *option_strings)
230
237
 
231
238
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
241
248
 
242
249
    def iter_switches(self):
243
250
        """Iterate through the list of switches provided by the option
244
 
        
 
251
 
245
252
        :return: an iterator of (name, short_name, argname, help)
246
253
        """
247
254
        argname =  self.argname
250
257
        yield self.name, self.short_name(), argname, self.help
251
258
 
252
259
    def is_hidden(self, name):
253
 
        return False
 
260
        return self.hidden
254
261
 
255
262
 
256
263
class ListOption(Option):
272
279
        parser.add_option(action='callback',
273
280
                          callback=self._optparse_callback,
274
281
                          type='string', metavar=self.argname.upper(),
275
 
                          help=self.help, default=[],
 
282
                          help=self.help, dest=self._param_name, default=[],
276
283
                          *option_strings)
277
284
 
278
285
    def _optparse_callback(self, option, opt, value, parser):
306
313
        else:
307
314
            return self.converter(value)
308
315
 
309
 
    def __init__(self, name, help, registry, converter=None,
310
 
        value_switches=False, title=None, enum_switch=True):
 
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):
311
319
        """
312
320
        Constructor.
313
321
 
321
329
            '--knit' can be used interchangeably.
322
330
        :param enum_switch: If true, a switch is provided with the option name,
323
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
324
336
        """
325
 
        Option.__init__(self, name, help, type=self.convert)
326
 
        self.registry = registry
 
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')
327
349
        self.name = name
328
350
        self.converter = converter
329
351
        self.value_switches = value_switches
330
352
        self.enum_switch = enum_switch
 
353
        self.short_value_switches = short_value_switches
331
354
        self.title = title
332
355
        if self.title is None:
333
356
            self.title = name
334
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
 
335
364
    @staticmethod
336
365
    def from_kwargs(name_, help=None, title=None, value_switches=False,
337
366
                    enum_switch=True, **kwargs):
339
368
 
340
369
        name, help, value_switches and enum_switch are passed to the
341
370
        RegistryOption constructor.  Any other keyword arguments are treated
342
 
        as values for the option, and they value is treated as the help.
 
371
        as values for the option, and their value is treated as the help.
343
372
        """
344
 
        reg = registry.Registry()
345
 
        for name, switch_help in kwargs.iteritems():
 
373
        reg = _mod_registry.Registry()
 
374
        for name, switch_help in sorted(kwargs.items()):
346
375
            name = name.replace('_', '-')
347
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 + "."
348
381
        return RegistryOption(name_, help, reg, title=title,
349
382
            value_switches=value_switches, enum_switch=enum_switch)
350
383
 
361
394
                    help = optparse.SUPPRESS_HELP
362
395
                else:
363
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])
364
401
                parser.add_option(action='callback',
365
402
                              callback=self._optparse_value_callback(key),
366
403
                                  help=help,
396
433
 
397
434
    DEFAULT_VALUE = object()
398
435
 
 
436
    def __init__(self):
 
437
        optparse.OptionParser.__init__(self)
 
438
        self.formatter = GettextIndentedHelpFormatter()
 
439
 
399
440
    def error(self, message):
400
441
        raise errors.BzrCommandError(message)
401
442
 
402
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
 
403
456
def get_optparser(options):
404
457
    """Generate an optparse parser for bzrlib-style options"""
405
458
 
424
477
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
425
478
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
426
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]
 
485
 
427
486
 
428
487
def _global_option(name, **kwargs):
429
488
    """Register a global option."""
430
489
    Option.OPTIONS[name] = Option(name, **kwargs)
431
490
 
432
491
 
433
 
def _global_registry_option(name, help, registry, **kwargs):
 
492
def _global_registry_option(name, help, registry=None, **kwargs):
434
493
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
435
494
 
436
495
 
437
 
class MergeTypeRegistry(registry.Registry):
438
 
 
439
 
    pass
440
 
 
441
 
 
442
496
# This is the verbosity level detected during command line parsing.
443
497
# Note that the final value is dependent on the order in which the
444
498
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
467
521
            _verbosity_level = -1
468
522
 
469
523
 
470
 
_merge_type_registry = MergeTypeRegistry()
471
 
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
472
 
                                   "Native diff3-style merge")
473
 
_merge_type_registry.register_lazy('diff3', 'bzrlib.merge', 'Diff3Merger',
474
 
                                   "Merge using external diff3")
475
 
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
476
 
                                   "Weave-based merge")
477
 
 
478
524
# Declare the standard options
479
525
_standard_option('help', short_name='h',
480
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.')
481
532
_standard_option('verbose', short_name='v',
482
533
                 help='Display more information.',
483
534
                 custom_callback=_verbosity_level_callback)
484
 
_standard_option('quiet', short_name='q',
485
 
                 help="Only display errors and warnings.",
486
 
                 custom_callback=_verbosity_level_callback)
487
535
 
488
536
# Declare commonly used options
489
 
_global_option('all')
490
 
_global_option('overwrite', help='Ignore differences between branches and '
491
 
               'overwrite unconditionally.')
492
 
_global_option('basis', type=str)
493
 
_global_option('bound')
494
 
_global_option('diff-options', type=str)
 
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.')
495
544
_global_option('file', type=unicode, short_name='F')
496
 
_global_option('force')
497
 
_global_option('format', type=unicode)
498
 
_global_option('forward')
 
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')
499
552
_global_option('message', type=unicode,
500
553
               short_name='m',
501
554
               help='Message string.')
502
 
_global_option('no-recurse')
503
 
_global_option('profile',
504
 
               help='Show performance profiling information.')
 
555
_global_option('null', short_name='0',
 
556
                 help='Use an ASCII NUL (\\0) separator rather than '
 
557
                      'a newline.')
 
558
_global_option('overwrite', help='Ignore differences between branches and '
 
559
               'overwrite unconditionally.')
 
560
_global_option('remember', help='Remember the specified location as a'
 
561
               ' default.')
 
562
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
505
563
_global_option('revision',
506
564
               type=_parse_revision_str,
507
565
               short_name='r',
508
566
               help='See "help revisionspec" for details.')
509
 
_global_option('change',
510
 
               type=_parse_change_str,
511
 
               short_name='c',
512
 
               param_name='revision',
513
 
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
514
567
_global_option('show-ids',
515
568
               help='Show internal object ids.')
516
 
_global_option('timezone', 
 
569
_global_option('timezone',
517
570
               type=str,
518
 
               help='display timezone as local, original, or utc')
519
 
_global_option('unbound')
520
 
_global_option('version')
521
 
_global_option('email')
522
 
_global_option('update')
523
 
_global_registry_option('log-format', "Use specified log format.",
524
 
                        log.log_formatter_registry, value_switches=True,
525
 
                        title='Log format')
526
 
_global_option('long', help='Use detailed log format. Same as --log-format long',
527
 
               short_name='l')
528
 
_global_option('short', help='Use moderately short log format. Same as --log-format short')
529
 
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
530
 
_global_option('root', type=str)
531
 
_global_option('no-backup')
532
 
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
533
 
                        _merge_type_registry, value_switches=True,
534
 
                        title='Merge algorithm')
535
 
_global_option('pattern', type=str)
536
 
_global_option('remember', help='Remember the specified location as a'
537
 
               ' default.')
538
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
539
 
_global_option('kind', type=str)
540
 
_global_option('dry-run',
541
 
               help="Show what would be done, but don't actually do anything.")
542
 
_global_option('name-from-revision', help='The path name in the old tree.')
 
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'