← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

Fix up inter_changes with dirstate both C and python.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2005-2010 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
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.
29
29
""")
30
30
 
31
31
from bzrlib import (
32
 
    registry as _mod_registry,
 
32
    log,
 
33
    registry,
33
34
    )
34
35
 
35
 
 
36
36
def _parse_revision_str(revstr):
37
37
    """This handles a revision string -> revno.
38
38
 
40
40
    each revision specifier supplied.
41
41
 
42
42
    >>> _parse_revision_str('234')
43
 
    [<RevisionSpec_dwim 234>]
 
43
    [<RevisionSpec_revno 234>]
44
44
    >>> _parse_revision_str('234..567')
45
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
 
45
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
46
46
    >>> _parse_revision_str('..')
47
47
    [<RevisionSpec None>, <RevisionSpec None>]
48
48
    >>> _parse_revision_str('..234')
49
 
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
 
49
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
50
50
    >>> _parse_revision_str('234..')
51
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
 
51
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
52
52
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
53
 
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
 
53
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
54
54
    >>> _parse_revision_str('234....789') #Error ?
55
 
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 789>]
 
55
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
56
56
    >>> _parse_revision_str('revid:test@other.com-234234')
57
57
    [<RevisionSpec_revid revid:test@other.com-234234>]
58
58
    >>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
59
59
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
60
60
    >>> _parse_revision_str('revid:test@other.com-234234..23')
61
 
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 23>]
 
61
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revno 23>]
62
62
    >>> _parse_revision_str('date:2005-04-12')
63
63
    [<RevisionSpec_date date:2005-04-12>]
64
64
    >>> _parse_revision_str('date:2005-04-12 12:24:33')
68
68
    >>> _parse_revision_str('date:2005-04-12,12:24:33')
69
69
    [<RevisionSpec_date date:2005-04-12,12:24:33>]
70
70
    >>> _parse_revision_str('-5..23')
71
 
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
 
71
    [<RevisionSpec_revno -5>, <RevisionSpec_revno 23>]
72
72
    >>> _parse_revision_str('-5')
73
 
    [<RevisionSpec_dwim -5>]
 
73
    [<RevisionSpec_revno -5>]
74
74
    >>> _parse_revision_str('123a')
75
 
    [<RevisionSpec_dwim 123a>]
 
75
    Traceback (most recent call last):
 
76
      ...
 
77
    NoSuchRevisionSpec: No namespace registered for string: '123a'
76
78
    >>> _parse_revision_str('abc')
77
 
    [<RevisionSpec_dwim abc>]
 
79
    Traceback (most recent call last):
 
80
      ...
 
81
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
78
82
    >>> _parse_revision_str('branch:../branch2')
79
83
    [<RevisionSpec_branch branch:../branch2>]
80
84
    >>> _parse_revision_str('branch:../../branch2')
81
85
    [<RevisionSpec_branch branch:../../branch2>]
82
86
    >>> _parse_revision_str('branch:../../branch2..23')
83
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
 
87
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
84
88
    >>> _parse_revision_str('branch:..\\\\branch2')
85
89
    [<RevisionSpec_branch branch:..\\branch2>]
86
90
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
87
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
 
91
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
88
92
    """
89
93
    # TODO: Maybe move this into revisionspec.py
90
94
    revs = []
100
104
    parent of the revision.
101
105
 
102
106
    >>> _parse_change_str('123')
103
 
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
 
107
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
104
108
    >>> _parse_change_str('123..124')
105
109
    Traceback (most recent call last):
106
110
      ...
132
136
 
133
137
class Option(object):
134
138
    """Description of a command line option
135
 
 
 
139
    
136
140
    :ivar _short_name: If this option has a single-letter name, this is it.
137
141
    Otherwise None.
138
142
    """
146
150
    OPTIONS = {}
147
151
 
148
152
    def __init__(self, name, help='', type=None, argname=None,
149
 
                 short_name=None, param_name=None, custom_callback=None,
150
 
                 hidden=False):
 
153
                 short_name=None, param_name=None, custom_callback=None):
151
154
        """Make a new command option.
152
155
 
153
156
        :param name: regular name of the command, used in the double-dash
154
 
            form and also as the parameter to the command's run()
 
157
            form and also as the parameter to the command's run() 
155
158
            method (unless param_name is specified).
156
159
 
157
160
        :param help: help message displayed in command help
158
161
 
159
 
        :param type: function called to parse the option argument, or
 
162
        :param type: function called to parse the option argument, or 
160
163
            None (default) if this option doesn't take an argument.
161
164
 
162
165
        :param argname: name of option argument, if any
170
173
        :param custom_callback: a callback routine to be called after normal
171
174
            processing. The signature of the callback routine is
172
175
            (option, name, new_value, parser).
173
 
        :param hidden: If True, the option should be hidden in help and
174
 
            documentation.
175
176
        """
176
177
        self.name = name
177
178
        self.help = help
188
189
        else:
189
190
            self._param_name = param_name
190
191
        self.custom_callback = custom_callback
191
 
        self.hidden = hidden
192
192
 
193
193
    def short_name(self):
194
194
        if self._short_name:
208
208
        option_strings = ['--%s' % self.name]
209
209
        if short_name is not None:
210
210
            option_strings.append('-%s' % short_name)
211
 
        if self.hidden:
212
 
            help = optparse.SUPPRESS_HELP
213
 
        else:
214
 
            help = self.help
215
211
        optargfn = self.type
216
212
        if optargfn is None:
217
213
            parser.add_option(action='callback',
218
214
                              callback=self._optparse_bool_callback,
219
215
                              callback_args=(True,),
220
 
                              help=help,
 
216
                              help=self.help,
221
217
                              *option_strings)
222
218
            negation_strings = ['--%s' % self.get_negation_name()]
223
219
            parser.add_option(action='callback',
228
224
            parser.add_option(action='callback',
229
225
                              callback=self._optparse_callback,
230
226
                              type='string', metavar=self.argname.upper(),
231
 
                              help=help,
 
227
                              help=self.help,
232
228
                              default=OptionParser.DEFAULT_VALUE,
233
229
                              *option_strings)
234
230
 
245
241
 
246
242
    def iter_switches(self):
247
243
        """Iterate through the list of switches provided by the option
248
 
 
 
244
        
249
245
        :return: an iterator of (name, short_name, argname, help)
250
246
        """
251
247
        argname =  self.argname
254
250
        yield self.name, self.short_name(), argname, self.help
255
251
 
256
252
    def is_hidden(self, name):
257
 
        return self.hidden
 
253
        return False
258
254
 
259
255
 
260
256
class ListOption(Option):
276
272
        parser.add_option(action='callback',
277
273
                          callback=self._optparse_callback,
278
274
                          type='string', metavar=self.argname.upper(),
279
 
                          help=self.help, dest=self._param_name, default=[],
 
275
                          help=self.help, default=[],
280
276
                          *option_strings)
281
277
 
282
278
    def _optparse_callback(self, option, opt, value, parser):
310
306
        else:
311
307
            return self.converter(value)
312
308
 
313
 
    def __init__(self, name, help, registry=None, converter=None,
314
 
        value_switches=False, title=None, enum_switch=True,
315
 
        lazy_registry=None, short_name=None, short_value_switches=None):
 
309
    def __init__(self, name, help, registry, converter=None,
 
310
        value_switches=False, title=None, enum_switch=True):
316
311
        """
317
312
        Constructor.
318
313
 
326
321
            '--knit' can be used interchangeably.
327
322
        :param enum_switch: If true, a switch is provided with the option name,
328
323
            which takes a value.
329
 
        :param lazy_registry: A tuple of (module name, attribute name) for a
330
 
            registry to be lazily loaded.
331
 
        :param short_name: The short name for the enum switch, if any
332
 
        :param short_value_switches: A dict mapping values to short names
333
324
        """
334
 
        Option.__init__(self, name, help, type=self.convert, short_name=short_name)
335
 
        self._registry = registry
336
 
        if registry is None:
337
 
            if lazy_registry is None:
338
 
                raise AssertionError(
339
 
                    'One of registry or lazy_registry must be given.')
340
 
            self._lazy_registry = _mod_registry._LazyObjectGetter(
341
 
                *lazy_registry)
342
 
        if registry is not None and lazy_registry is not None:
343
 
            raise AssertionError(
344
 
                'registry and lazy_registry are mutually exclusive')
 
325
        Option.__init__(self, name, help, type=self.convert)
 
326
        self.registry = registry
345
327
        self.name = name
346
328
        self.converter = converter
347
329
        self.value_switches = value_switches
348
330
        self.enum_switch = enum_switch
349
 
        self.short_value_switches = short_value_switches
350
331
        self.title = title
351
332
        if self.title is None:
352
333
            self.title = name
353
334
 
354
 
    @property
355
 
    def registry(self):
356
 
        if self._registry is None:
357
 
            self._registry = self._lazy_registry.get_obj()
358
 
        return self._registry
359
 
 
360
335
    @staticmethod
361
336
    def from_kwargs(name_, help=None, title=None, value_switches=False,
362
337
                    enum_switch=True, **kwargs):
364
339
 
365
340
        name, help, value_switches and enum_switch are passed to the
366
341
        RegistryOption constructor.  Any other keyword arguments are treated
367
 
        as values for the option, and their value is treated as the help.
 
342
        as values for the option, and they value is treated as the help.
368
343
        """
369
 
        reg = _mod_registry.Registry()
370
 
        for name, switch_help in sorted(kwargs.items()):
 
344
        reg = registry.Registry()
 
345
        for name, switch_help in kwargs.iteritems():
371
346
            name = name.replace('_', '-')
372
347
            reg.register(name, name, help=switch_help)
373
348
            if not value_switches:
390
365
                    help = optparse.SUPPRESS_HELP
391
366
                else:
392
367
                    help = self.registry.get_help(key)
393
 
                if (self.short_value_switches and
394
 
                    key in self.short_value_switches):
395
 
                    option_strings.append('-%s' %
396
 
                                          self.short_value_switches[key])
397
368
                parser.add_option(action='callback',
398
369
                              callback=self._optparse_value_callback(key),
399
370
                                  help=help,
463
434
    Option.OPTIONS[name] = Option(name, **kwargs)
464
435
 
465
436
 
466
 
def _global_registry_option(name, help, registry=None, **kwargs):
 
437
def _global_registry_option(name, help, registry, **kwargs):
467
438
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
468
439
 
469
440
 
 
441
class MergeTypeRegistry(registry.Registry):
 
442
 
 
443
    pass
 
444
 
 
445
 
470
446
# This is the verbosity level detected during command line parsing.
471
447
# Note that the final value is dependent on the order in which the
472
448
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
495
471
            _verbosity_level = -1
496
472
 
497
473
 
498
 
class MergeTypeRegistry(_mod_registry.Registry):
499
 
 
500
 
    pass
501
 
 
502
 
 
503
474
_merge_type_registry = MergeTypeRegistry()
504
475
_merge_type_registry.register_lazy('merge3', 'bzrlib.merge', 'Merge3Merger',
505
476
                                   "Native diff3-style merge")
513
484
# Declare the standard options
514
485
_standard_option('help', short_name='h',
515
486
                 help='Show help message.')
516
 
_standard_option('usage',
517
 
                 help='Show usage message and options.')
518
487
_standard_option('verbose', short_name='v',
519
488
                 help='Display more information.',
520
489
                 custom_callback=_verbosity_level_callback)
537
506
               short_name='m',
538
507
               help='Message string.')
539
508
_global_option('no-recurse')
540
 
_global_option('null', short_name='0',
541
 
                 help='Use an ASCII NUL (\\0) separator rather than '
542
 
                      'a newline.')
543
509
_global_option('profile',
544
510
               help='Show performance profiling information.')
545
511
_global_option('revision',
553
519
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
554
520
_global_option('show-ids',
555
521
               help='Show internal object ids.')
556
 
_global_option('timezone',
 
522
_global_option('timezone', 
557
523
               type=str,
558
 
               help='Display timezone as local, original, or utc.')
 
524
               help='display timezone as local, original, or utc')
559
525
_global_option('unbound')
560
526
_global_option('version')
561
527
_global_option('email')
562
528
_global_option('update')
563
529
_global_registry_option('log-format', "Use specified log format.",
564
 
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
565
 
                        value_switches=True, title='Log format',
566
 
                        short_value_switches={'short': 'S'})
 
530
                        log.log_formatter_registry, value_switches=True,
 
531
                        title='Log format')
567
532
_global_option('long', help='Use detailed log format. Same as --log-format long',
568
533
               short_name='l')
569
534
_global_option('short', help='Use moderately short log format. Same as --log-format short')
581
546
_global_option('dry-run',
582
547
               help="Show what would be done, but don't actually do anything.")
583
548
_global_option('name-from-revision', help='The path name in the old tree.')
584
 
_global_option('directory', short_name='d', type=unicode,
585
 
               help='Branch to operate on, instead of working directory')
586
 
 
587
 
diff_writer_registry = _mod_registry.Registry()
588
 
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
589
 
diff_writer_registry.default_key = 'plain'