← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Martin Pool
  • Date: 2011-07-04 21:15:24 UTC
  • mto: (6034.1.1 filter-tree)
  • mto: This revision was merged to the branch mainline in revision 6035.
  • Revision ID: mbp@canonical.com-20110704211524-ilb7l6g4i3iizke7
Test exporting filtered tree to a zip (already works)

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.
40
40
    each revision specifier supplied.
41
41
 
42
42
    >>> _parse_revision_str('234')
43
 
    [<RevisionSpec_revno 234>]
 
43
    [<RevisionSpec_dwim 234>]
44
44
    >>> _parse_revision_str('234..567')
45
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 567>]
 
45
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 567>]
46
46
    >>> _parse_revision_str('..')
47
47
    [<RevisionSpec None>, <RevisionSpec None>]
48
48
    >>> _parse_revision_str('..234')
49
 
    [<RevisionSpec None>, <RevisionSpec_revno 234>]
 
49
    [<RevisionSpec None>, <RevisionSpec_dwim 234>]
50
50
    >>> _parse_revision_str('234..')
51
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>]
 
51
    [<RevisionSpec_dwim 234>, <RevisionSpec None>]
52
52
    >>> _parse_revision_str('234..456..789') # Maybe this should be an error
53
 
    [<RevisionSpec_revno 234>, <RevisionSpec_revno 456>, <RevisionSpec_revno 789>]
 
53
    [<RevisionSpec_dwim 234>, <RevisionSpec_dwim 456>, <RevisionSpec_dwim 789>]
54
54
    >>> _parse_revision_str('234....789') #Error ?
55
 
    [<RevisionSpec_revno 234>, <RevisionSpec None>, <RevisionSpec_revno 789>]
 
55
    [<RevisionSpec_dwim 234>, <RevisionSpec None>, <RevisionSpec_dwim 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_revno 23>]
 
61
    [<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_dwim 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_revno -5>, <RevisionSpec_revno 23>]
 
71
    [<RevisionSpec_dwim -5>, <RevisionSpec_dwim 23>]
72
72
    >>> _parse_revision_str('-5')
73
 
    [<RevisionSpec_revno -5>]
 
73
    [<RevisionSpec_dwim -5>]
74
74
    >>> _parse_revision_str('123a')
75
 
    Traceback (most recent call last):
76
 
      ...
77
 
    NoSuchRevisionSpec: No namespace registered for string: '123a'
 
75
    [<RevisionSpec_dwim 123a>]
78
76
    >>> _parse_revision_str('abc')
79
 
    Traceback (most recent call last):
80
 
      ...
81
 
    NoSuchRevisionSpec: No namespace registered for string: 'abc'
 
77
    [<RevisionSpec_dwim abc>]
82
78
    >>> _parse_revision_str('branch:../branch2')
83
79
    [<RevisionSpec_branch branch:../branch2>]
84
80
    >>> _parse_revision_str('branch:../../branch2')
85
81
    [<RevisionSpec_branch branch:../../branch2>]
86
82
    >>> _parse_revision_str('branch:../../branch2..23')
87
 
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_revno 23>]
 
83
    [<RevisionSpec_branch branch:../../branch2>, <RevisionSpec_dwim 23>]
88
84
    >>> _parse_revision_str('branch:..\\\\branch2')
89
85
    [<RevisionSpec_branch branch:..\\branch2>]
90
86
    >>> _parse_revision_str('branch:..\\\\..\\\\branch2..23')
91
 
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_revno 23>]
 
87
    [<RevisionSpec_branch branch:..\\..\\branch2>, <RevisionSpec_dwim 23>]
92
88
    """
93
89
    # TODO: Maybe move this into revisionspec.py
94
90
    revs = []
104
100
    parent of the revision.
105
101
 
106
102
    >>> _parse_change_str('123')
107
 
    (<RevisionSpec_before before:123>, <RevisionSpec_revno 123>)
 
103
    (<RevisionSpec_before before:123>, <RevisionSpec_dwim 123>)
108
104
    >>> _parse_change_str('123..124')
109
105
    Traceback (most recent call last):
110
106
      ...
136
132
 
137
133
class Option(object):
138
134
    """Description of a command line option
139
 
    
 
135
 
140
136
    :ivar _short_name: If this option has a single-letter name, this is it.
141
137
    Otherwise None.
142
138
    """
150
146
    OPTIONS = {}
151
147
 
152
148
    def __init__(self, name, help='', type=None, argname=None,
153
 
                 short_name=None, param_name=None, custom_callback=None):
 
149
                 short_name=None, param_name=None, custom_callback=None,
 
150
                 hidden=False):
154
151
        """Make a new command option.
155
152
 
156
153
        :param name: regular name of the command, used in the double-dash
157
 
            form and also as the parameter to the command's run() 
 
154
            form and also as the parameter to the command's run()
158
155
            method (unless param_name is specified).
159
156
 
160
157
        :param help: help message displayed in command help
161
158
 
162
 
        :param type: function called to parse the option argument, or 
 
159
        :param type: function called to parse the option argument, or
163
160
            None (default) if this option doesn't take an argument.
164
161
 
165
162
        :param argname: name of option argument, if any
173
170
        :param custom_callback: a callback routine to be called after normal
174
171
            processing. The signature of the callback routine is
175
172
            (option, name, new_value, parser).
 
173
        :param hidden: If True, the option should be hidden in help and
 
174
            documentation.
176
175
        """
177
176
        self.name = name
178
177
        self.help = help
189
188
        else:
190
189
            self._param_name = param_name
191
190
        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
211
215
        optargfn = self.type
212
216
        if optargfn is None:
213
217
            parser.add_option(action='callback',
214
218
                              callback=self._optparse_bool_callback,
215
219
                              callback_args=(True,),
216
 
                              help=self.help,
 
220
                              help=help,
217
221
                              *option_strings)
218
222
            negation_strings = ['--%s' % self.get_negation_name()]
219
223
            parser.add_option(action='callback',
224
228
            parser.add_option(action='callback',
225
229
                              callback=self._optparse_callback,
226
230
                              type='string', metavar=self.argname.upper(),
227
 
                              help=self.help,
 
231
                              help=help,
228
232
                              default=OptionParser.DEFAULT_VALUE,
229
233
                              *option_strings)
230
234
 
241
245
 
242
246
    def iter_switches(self):
243
247
        """Iterate through the list of switches provided by the option
244
 
        
 
248
 
245
249
        :return: an iterator of (name, short_name, argname, help)
246
250
        """
247
251
        argname =  self.argname
250
254
        yield self.name, self.short_name(), argname, self.help
251
255
 
252
256
    def is_hidden(self, name):
253
 
        return False
 
257
        return self.hidden
254
258
 
255
259
 
256
260
class ListOption(Option):
272
276
        parser.add_option(action='callback',
273
277
                          callback=self._optparse_callback,
274
278
                          type='string', metavar=self.argname.upper(),
275
 
                          help=self.help, default=[],
 
279
                          help=self.help, dest=self._param_name, default=[],
276
280
                          *option_strings)
277
281
 
278
282
    def _optparse_callback(self, option, opt, value, parser):
308
312
 
309
313
    def __init__(self, name, help, registry=None, converter=None,
310
314
        value_switches=False, title=None, enum_switch=True,
311
 
        lazy_registry=None):
 
315
        lazy_registry=None, short_name=None, short_value_switches=None):
312
316
        """
313
317
        Constructor.
314
318
 
324
328
            which takes a value.
325
329
        :param lazy_registry: A tuple of (module name, attribute name) for a
326
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
327
333
        """
328
 
        Option.__init__(self, name, help, type=self.convert)
 
334
        Option.__init__(self, name, help, type=self.convert, short_name=short_name)
329
335
        self._registry = registry
330
336
        if registry is None:
331
337
            if lazy_registry is None:
340
346
        self.converter = converter
341
347
        self.value_switches = value_switches
342
348
        self.enum_switch = enum_switch
 
349
        self.short_value_switches = short_value_switches
343
350
        self.title = title
344
351
        if self.title is None:
345
352
            self.title = name
349
356
        if self._registry is None:
350
357
            self._registry = self._lazy_registry.get_obj()
351
358
        return self._registry
352
 
    
 
359
 
353
360
    @staticmethod
354
361
    def from_kwargs(name_, help=None, title=None, value_switches=False,
355
362
                    enum_switch=True, **kwargs):
357
364
 
358
365
        name, help, value_switches and enum_switch are passed to the
359
366
        RegistryOption constructor.  Any other keyword arguments are treated
360
 
        as values for the option, and they value is treated as the help.
 
367
        as values for the option, and their value is treated as the help.
361
368
        """
362
369
        reg = _mod_registry.Registry()
363
 
        for name, switch_help in kwargs.iteritems():
 
370
        for name, switch_help in sorted(kwargs.items()):
364
371
            name = name.replace('_', '-')
365
372
            reg.register(name, name, help=switch_help)
366
373
            if not value_switches:
383
390
                    help = optparse.SUPPRESS_HELP
384
391
                else:
385
392
                    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])
386
397
                parser.add_option(action='callback',
387
398
                              callback=self._optparse_value_callback(key),
388
399
                                  help=help,
502
513
# Declare the standard options
503
514
_standard_option('help', short_name='h',
504
515
                 help='Show help message.')
 
516
_standard_option('usage',
 
517
                 help='Show usage message and options.')
505
518
_standard_option('verbose', short_name='v',
506
519
                 help='Display more information.',
507
520
                 custom_callback=_verbosity_level_callback)
524
537
               short_name='m',
525
538
               help='Message string.')
526
539
_global_option('no-recurse')
 
540
_global_option('null', short_name='0',
 
541
                 help='Use an ASCII NUL (\\0) separator rather than '
 
542
                      'a newline.')
527
543
_global_option('profile',
528
544
               help='Show performance profiling information.')
529
545
_global_option('revision',
546
562
_global_option('update')
547
563
_global_registry_option('log-format', "Use specified log format.",
548
564
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
549
 
                        value_switches=True, title='Log format')
 
565
                        value_switches=True, title='Log format',
 
566
                        short_value_switches={'short': 'S'})
550
567
_global_option('long', help='Use detailed log format. Same as --log-format long',
551
568
               short_name='l')
552
569
_global_option('short', help='Use moderately short log format. Same as --log-format short')
564
581
_global_option('dry-run',
565
582
               help="Show what would be done, but don't actually do anything.")
566
583
_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')
567
586
 
568
587
diff_writer_registry = _mod_registry.Registry()
569
588
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')