← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: John Arbash Meinel
  • Date: 2009-08-25 18:45:40 UTC
  • mto: (4634.6.15 2.0)
  • mto: This revision was merged to the branch mainline in revision 4667.
  • Revision ID: john@arbash-meinel.com-20090825184540-6dn3xjq62xhgj2gq
Add support for skipping ghost nodes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
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
import optparse
20
21
import re
21
22
 
22
23
from bzrlib.lazy_import import lazy_import
23
24
lazy_import(globals(), """
24
 
import optparse
25
 
 
26
25
from bzrlib import (
27
26
    errors,
28
 
    log,
29
 
    registry,
30
27
    revisionspec,
31
 
    symbol_versioning,
32
28
    )
33
29
""")
34
 
from bzrlib.trace import warning
 
30
 
 
31
from bzrlib import (
 
32
    registry as _mod_registry,
 
33
    )
35
34
 
36
35
 
37
36
def _parse_revision_str(revstr):
137
136
 
138
137
class Option(object):
139
138
    """Description of a command line option
140
 
    
 
139
 
141
140
    :ivar _short_name: If this option has a single-letter name, this is it.
142
141
    Otherwise None.
143
142
    """
144
143
 
145
 
    # TODO: Some way to show in help a description of the option argument
 
144
    # The dictionary of standard options. These are always legal.
 
145
    STD_OPTIONS = {}
146
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.
147
150
    OPTIONS = {}
148
151
 
149
152
    def __init__(self, name, help='', type=None, argname=None,
150
 
                 short_name=None, param_name=None):
 
153
                 short_name=None, param_name=None, custom_callback=None,
 
154
                 hidden=False):
151
155
        """Make a new command option.
152
156
 
153
 
        name -- regular name of the command, used in the double-dash
154
 
            form and also as the parameter to the command's run() 
 
157
        :param name: regular name of the command, used in the double-dash
 
158
            form and also as the parameter to the command's run()
155
159
            method (unless param_name is specified).
156
160
 
157
 
        help -- help message displayed in command help
 
161
        :param help: help message displayed in command help
158
162
 
159
 
        type -- function called to parse the option argument, or 
 
163
        :param type: function called to parse the option argument, or
160
164
            None (default) if this option doesn't take an argument.
161
165
 
162
 
        argname -- name of option argument, if any
163
 
 
164
 
        param_name -- name of the parameter which will be passed to
 
166
        :param argname: name of option argument, if any
 
167
 
 
168
        :param short_name: short option code for use with a single -, e.g.
 
169
            short_name="v" to enable parsing of -v.
 
170
 
 
171
        :param param_name: name of the parameter which will be passed to
165
172
            the command's run() method.
 
173
 
 
174
        :param custom_callback: a callback routine to be called after normal
 
175
            processing. The signature of the callback routine is
 
176
            (option, name, new_value, parser).
 
177
        :param hidden: If True, the option should be hidden in help and
 
178
            documentation.
166
179
        """
167
180
        self.name = name
168
181
        self.help = help
169
182
        self.type = type
170
183
        self._short_name = short_name
171
184
        if type is None:
172
 
            assert argname is None
 
185
            if argname:
 
186
                raise ValueError('argname not valid for booleans')
173
187
        elif argname is None:
174
188
            argname = 'ARG'
175
189
        self.argname = argname
176
190
        if param_name is None:
177
 
            self._param_name = self.name
 
191
            self._param_name = self.name.replace('-', '_')
178
192
        else:
179
193
            self._param_name = param_name
 
194
        self.custom_callback = custom_callback
 
195
        self.hidden = hidden
180
196
 
181
197
    def short_name(self):
182
198
        if self._short_name:
196
212
        option_strings = ['--%s' % self.name]
197
213
        if short_name is not None:
198
214
            option_strings.append('-%s' % short_name)
 
215
        if self.hidden:
 
216
            help = optparse.SUPPRESS_HELP
 
217
        else:
 
218
            help = self.help
199
219
        optargfn = self.type
200
220
        if optargfn is None:
201
 
            parser.add_option(action='store_true', dest=self.name, 
202
 
                              help=self.help,
203
 
                              default=OptionParser.DEFAULT_VALUE,
 
221
            parser.add_option(action='callback',
 
222
                              callback=self._optparse_bool_callback,
 
223
                              callback_args=(True,),
 
224
                              help=help,
204
225
                              *option_strings)
205
226
            negation_strings = ['--%s' % self.get_negation_name()]
206
 
            parser.add_option(action='store_false', dest=self.name, 
 
227
            parser.add_option(action='callback',
 
228
                              callback=self._optparse_bool_callback,
 
229
                              callback_args=(False,),
207
230
                              help=optparse.SUPPRESS_HELP, *negation_strings)
208
231
        else:
209
 
            parser.add_option(action='callback', 
210
 
                              callback=self._optparse_callback, 
 
232
            parser.add_option(action='callback',
 
233
                              callback=self._optparse_callback,
211
234
                              type='string', metavar=self.argname.upper(),
212
 
                              help=self.help,
213
 
                              default=OptionParser.DEFAULT_VALUE, 
 
235
                              help=help,
 
236
                              default=OptionParser.DEFAULT_VALUE,
214
237
                              *option_strings)
215
238
 
 
239
    def _optparse_bool_callback(self, option, opt_str, value, parser, bool_v):
 
240
        setattr(parser.values, self._param_name, bool_v)
 
241
        if self.custom_callback is not None:
 
242
            self.custom_callback(option, self._param_name, bool_v, parser)
 
243
 
216
244
    def _optparse_callback(self, option, opt, value, parser):
217
 
        setattr(parser.values, self._param_name, self.type(value))
 
245
        v = self.type(value)
 
246
        setattr(parser.values, self._param_name, v)
 
247
        if self.custom_callback is not None:
 
248
            self.custom_callback(option, self.name, v, parser)
218
249
 
219
250
    def iter_switches(self):
220
251
        """Iterate through the list of switches provided by the option
221
 
        
 
252
 
222
253
        :return: an iterator of (name, short_name, argname, help)
223
254
        """
224
255
        argname =  self.argname
227
258
        yield self.name, self.short_name(), argname, self.help
228
259
 
229
260
    def is_hidden(self, name):
230
 
        return False
 
261
        return self.hidden
231
262
 
232
263
 
233
264
class ListOption(Option):
253
284
                          *option_strings)
254
285
 
255
286
    def _optparse_callback(self, option, opt, value, parser):
256
 
        values = getattr(parser.values, self.name)
 
287
        values = getattr(parser.values, self._param_name)
257
288
        if value == '-':
258
289
            del values[:]
259
290
        else:
260
291
            values.append(self.type(value))
 
292
        if self.custom_callback is not None:
 
293
            self.custom_callback(option, self._param_name, values, parser)
261
294
 
262
295
 
263
296
class RegistryOption(Option):
281
314
        else:
282
315
            return self.converter(value)
283
316
 
284
 
    def __init__(self, name, help, registry, converter=None,
285
 
        value_switches=False, title=None, enum_switch=True):
 
317
    def __init__(self, name, help, registry=None, converter=None,
 
318
        value_switches=False, title=None, enum_switch=True,
 
319
        lazy_registry=None):
286
320
        """
287
321
        Constructor.
288
322
 
296
330
            '--knit' can be used interchangeably.
297
331
        :param enum_switch: If true, a switch is provided with the option name,
298
332
            which takes a value.
 
333
        :param lazy_registry: A tuple of (module name, attribute name) for a
 
334
            registry to be lazily loaded.
299
335
        """
300
336
        Option.__init__(self, name, help, type=self.convert)
301
 
        self.registry = registry
 
337
        self._registry = registry
 
338
        if registry is None:
 
339
            if lazy_registry is None:
 
340
                raise AssertionError(
 
341
                    'One of registry or lazy_registry must be given.')
 
342
            self._lazy_registry = _mod_registry._LazyObjectGetter(
 
343
                *lazy_registry)
 
344
        if registry is not None and lazy_registry is not None:
 
345
            raise AssertionError(
 
346
                'registry and lazy_registry are mutually exclusive')
302
347
        self.name = name
303
348
        self.converter = converter
304
349
        self.value_switches = value_switches
307
352
        if self.title is None:
308
353
            self.title = name
309
354
 
 
355
    @property
 
356
    def registry(self):
 
357
        if self._registry is None:
 
358
            self._registry = self._lazy_registry.get_obj()
 
359
        return self._registry
 
360
 
310
361
    @staticmethod
311
362
    def from_kwargs(name_, help=None, title=None, value_switches=False,
312
363
                    enum_switch=True, **kwargs):
316
367
        RegistryOption constructor.  Any other keyword arguments are treated
317
368
        as values for the option, and they value is treated as the help.
318
369
        """
319
 
        reg = registry.Registry()
 
370
        reg = _mod_registry.Registry()
320
371
        for name, switch_help in kwargs.iteritems():
321
372
            name = name.replace('_', '-')
322
373
            reg.register(name, name, help=switch_help)
 
374
            if not value_switches:
 
375
                help = help + '  "' + name + '": ' + switch_help
 
376
                if not help.endswith("."):
 
377
                    help = help + "."
323
378
        return RegistryOption(name_, help, reg, title=title,
324
379
            value_switches=value_switches, enum_switch=enum_switch)
325
380
 
343
398
 
344
399
    def _optparse_value_callback(self, cb_value):
345
400
        def cb(option, opt, value, parser):
346
 
            setattr(parser.values, self.name, self.type(cb_value))
 
401
            v = self.type(cb_value)
 
402
            setattr(parser.values, self._param_name, v)
 
403
            if self.custom_callback is not None:
 
404
                self.custom_callback(option, self._param_name, v, parser)
347
405
        return cb
348
406
 
349
407
    def iter_switches(self):
382
440
    return parser
383
441
 
384
442
 
 
443
def custom_help(name, help):
 
444
    """Clone a common option overriding the help."""
 
445
    import copy
 
446
    o = copy.copy(Option.OPTIONS[name])
 
447
    o.help = help
 
448
    return o
 
449
 
 
450
 
 
451
def _standard_option(name, **kwargs):
 
452
    """Register a standard option."""
 
453
    # All standard options are implicitly 'global' ones
 
454
    Option.STD_OPTIONS[name] = Option(name, **kwargs)
 
455
    Option.OPTIONS[name] = Option.STD_OPTIONS[name]
 
456
 
 
457
 
385
458
def _global_option(name, **kwargs):
386
 
    """Register o as a global option."""
 
459
    """Register a global option."""
387
460
    Option.OPTIONS[name] = Option(name, **kwargs)
388
461
 
389
462
 
390
 
def _global_registry_option(name, help, registry, **kwargs):
 
463
def _global_registry_option(name, help, registry=None, **kwargs):
391
464
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
392
465
 
393
466
 
394
 
class MergeTypeRegistry(registry.Registry):
 
467
# This is the verbosity level detected during command line parsing.
 
468
# Note that the final value is dependent on the order in which the
 
469
# various flags (verbose, quiet, no-verbose, no-quiet) are given.
 
470
# The final value will be one of the following:
 
471
#
 
472
# * -ve for quiet
 
473
# * 0 for normal
 
474
# * +ve for verbose
 
475
_verbosity_level = 0
 
476
 
 
477
 
 
478
def _verbosity_level_callback(option, opt_str, value, parser):
 
479
    global _verbosity_level
 
480
    if not value:
 
481
        # Either --no-verbose or --no-quiet was specified
 
482
        _verbosity_level = 0
 
483
    elif opt_str == "verbose":
 
484
        if _verbosity_level > 0:
 
485
            _verbosity_level += 1
 
486
        else:
 
487
            _verbosity_level = 1
 
488
    else:
 
489
        if _verbosity_level < 0:
 
490
            _verbosity_level -= 1
 
491
        else:
 
492
            _verbosity_level = -1
 
493
 
 
494
 
 
495
class MergeTypeRegistry(_mod_registry.Registry):
395
496
 
396
497
    pass
397
498
 
403
504
                                   "Merge using external diff3")
404
505
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
405
506
                                   "Weave-based merge")
406
 
 
 
507
_merge_type_registry.register_lazy('lca', 'bzrlib.merge', 'LCAMerger',
 
508
                                   "LCA-newness merge")
 
509
 
 
510
# Declare the standard options
 
511
_standard_option('help', short_name='h',
 
512
                 help='Show help message.')
 
513
_standard_option('usage',
 
514
                 help='Show usage message and options.')
 
515
_standard_option('verbose', short_name='v',
 
516
                 help='Display more information.',
 
517
                 custom_callback=_verbosity_level_callback)
 
518
_standard_option('quiet', short_name='q',
 
519
                 help="Only display errors and warnings.",
 
520
                 custom_callback=_verbosity_level_callback)
 
521
 
 
522
# Declare commonly used options
407
523
_global_option('all')
408
524
_global_option('overwrite', help='Ignore differences between branches and '
409
525
               'overwrite unconditionally.')
431
547
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
432
548
_global_option('show-ids',
433
549
               help='Show internal object ids.')
434
 
_global_option('timezone', 
 
550
_global_option('timezone',
435
551
               type=str,
436
 
               help='display timezone as local, original, or utc')
 
552
               help='Display timezone as local, original, or utc.')
437
553
_global_option('unbound')
438
 
_global_option('verbose',
439
 
               help='Display more information.',
440
 
               short_name='v')
441
554
_global_option('version')
442
555
_global_option('email')
443
556
_global_option('update')
444
557
_global_registry_option('log-format', "Use specified log format.",
445
 
                        log.log_formatter_registry, value_switches=True,
446
 
                        title='Log format')
 
558
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
 
559
                        value_switches=True, title='Log format')
447
560
_global_option('long', help='Use detailed log format. Same as --log-format long',
448
561
               short_name='l')
449
562
_global_option('short', help='Use moderately short log format. Same as --log-format short')
454
567
                        _merge_type_registry, value_switches=True,
455
568
                        title='Merge algorithm')
456
569
_global_option('pattern', type=str)
457
 
_global_option('quiet', short_name='q')
458
570
_global_option('remember', help='Remember the specified location as a'
459
571
               ' default.')
460
572
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
463
575
               help="Show what would be done, but don't actually do anything.")
464
576
_global_option('name-from-revision', help='The path name in the old tree.')
465
577
 
466
 
_help_option = Option('help',
467
 
                      help='Show help message.',
468
 
                      short_name='h')
 
578
diff_writer_registry = _mod_registry.Registry()
 
579
diff_writer_registry.register('plain', lambda x: x, 'Plaintext diff output.')
 
580
diff_writer_registry.default_key = 'plain'