← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/option.py

  • Committer: Vincent Ladeuil
  • Date: 2009-10-06 14:40:37 UTC
  • mto: (4728.1.2 integration)
  • mto: This revision was merged to the branch mainline in revision 4731.
  • Revision ID: v.ladeuil+lp@free.fr-20091006144037-o76rgosv9hj3td0y
Simplify mutable_tree.has_changes() and update call sites.

* bzrlib/workingtree.py:
(WorkingTree.merge_from_branch): Add a force parameter. Replace
the check_basis() call by the corresponding code, taken the new
'force' parameter into account.

* bzrlib/tests/test_status.py:
(TestStatus.make_multiple_pending_tree): Add force=True on
supplementary merges.

* bzrlib/tests/test_reconfigure.py:
(TestReconfigure): Add a test for pending merges.

* bzrlib/tests/test_msgeditor.py:
(MsgEditorTest.make_multiple_pending_tree): Add force=True on
supplementary merges.

* bzrlib/tests/blackbox/test_uncommit.py:
(TestUncommit.test_uncommit_octopus_merge): Add force=True on
supplementary merges.

* bzrlib/send.py:
(send): Use the simplified has_changes(). Fix typo in comment too.

* bzrlib/reconfigure.py:
(Reconfigure._check): Use the simplified has_changes().

* bzrlib/mutabletree.py:
(MutableTree.has_changes): Make the tree parameter optional but
retain it for tests. Add a pending merges check.

* bzrlib/merge.py:
(Merger.ensure_revision_trees, Merger.file_revisions,
Merger.check_basis, Merger.compare_basis): Deprecate.

* bzrlib/bundle/apply_bundle.py:
(merge_bundle): Replace the check_basis() call by the
corresponding code.

* bzrlib/builtins.py:
(cmd_remove_tree.run, cmd_push.run, cmd_merge.run): Use the
simplified has_changes().
(cmd_merge.run): Replace the check_basis call() by the corresponding
code (minus the alredy done has_changes() check).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/option.py
1
 
# Copyright (C) 2004, 2005, 2006 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., 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):
86
85
    [<RevisionSpec_branch branch:../../branch2>]
87
86
    >>> _parse_revision_str('branch:../../branch2..23')
88
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>]
89
92
    """
90
93
    # TODO: Maybe move this into revisionspec.py
91
94
    revs = []
92
 
    # split on the first .. that is not followed by a / ?
93
 
    sep = re.compile("\\.\\.(?!/)")
 
95
    # split on .. that is not followed by a / or \
 
96
    sep = re.compile(r'\.\.(?![\\/])')
94
97
    for x in sep.split(revstr):
95
98
        revs.append(revisionspec.RevisionSpec.from_string(x or None))
96
99
    return revs
97
100
 
98
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
 
99
120
def _parse_merge_type(typestring):
100
121
    return get_merge_type(typestring)
101
122
 
115
136
 
116
137
class Option(object):
117
138
    """Description of a command line option
118
 
    
 
139
 
119
140
    :ivar _short_name: If this option has a single-letter name, this is it.
120
141
    Otherwise None.
121
142
    """
122
143
 
123
 
    # 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 = {}
124
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.
125
150
    OPTIONS = {}
126
151
 
127
152
    def __init__(self, name, help='', type=None, argname=None,
128
 
                 short_name=None):
 
153
                 short_name=None, param_name=None, custom_callback=None,
 
154
                 hidden=False):
129
155
        """Make a new command option.
130
156
 
131
 
        name -- regular name of the command, used in the double-dash
132
 
            form and also as the parameter to the command's run() 
133
 
            method.
134
 
 
135
 
        help -- help message displayed in command help
136
 
 
137
 
        type -- function called to parse the option argument, or 
 
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()
 
159
            method (unless param_name is specified).
 
160
 
 
161
        :param help: help message displayed in command help
 
162
 
 
163
        :param type: function called to parse the option argument, or
138
164
            None (default) if this option doesn't take an argument.
139
165
 
140
 
        argname -- name of option argument, if any
 
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
 
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.
141
179
        """
142
180
        self.name = name
143
181
        self.help = help
144
182
        self.type = type
145
183
        self._short_name = short_name
146
184
        if type is None:
147
 
            assert argname is None
 
185
            if argname:
 
186
                raise ValueError('argname not valid for booleans')
148
187
        elif argname is None:
149
188
            argname = 'ARG'
150
189
        self.argname = argname
 
190
        if param_name is None:
 
191
            self._param_name = self.name.replace('-', '_')
 
192
        else:
 
193
            self._param_name = param_name
 
194
        self.custom_callback = custom_callback
 
195
        self.hidden = hidden
151
196
 
152
197
    def short_name(self):
153
198
        if self._short_name:
154
199
            return self._short_name
155
 
        else:
156
 
            # remove this when SHORT_OPTIONS is removed
157
 
            # XXX: This is accessing a DeprecatedDict, so we call the super 
158
 
            # method to avoid warnings
159
 
            for (k, v) in dict.iteritems(Option.SHORT_OPTIONS):
160
 
                if v == self:
161
 
                    return k
162
200
 
163
201
    def set_short_name(self, short_name):
164
202
        self._short_name = short_name
174
212
        option_strings = ['--%s' % self.name]
175
213
        if short_name is not None:
176
214
            option_strings.append('-%s' % short_name)
 
215
        if self.hidden:
 
216
            help = optparse.SUPPRESS_HELP
 
217
        else:
 
218
            help = self.help
177
219
        optargfn = self.type
178
220
        if optargfn is None:
179
 
            parser.add_option(action='store_true', dest=self.name, 
180
 
                              help=self.help,
181
 
                              default=OptionParser.DEFAULT_VALUE,
 
221
            parser.add_option(action='callback',
 
222
                              callback=self._optparse_bool_callback,
 
223
                              callback_args=(True,),
 
224
                              help=help,
182
225
                              *option_strings)
183
226
            negation_strings = ['--%s' % self.get_negation_name()]
184
 
            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,),
185
230
                              help=optparse.SUPPRESS_HELP, *negation_strings)
186
231
        else:
187
 
            parser.add_option(action='callback', 
188
 
                              callback=self._optparse_callback, 
 
232
            parser.add_option(action='callback',
 
233
                              callback=self._optparse_callback,
189
234
                              type='string', metavar=self.argname.upper(),
190
 
                              help=self.help,
191
 
                              default=OptionParser.DEFAULT_VALUE, 
 
235
                              help=help,
 
236
                              default=OptionParser.DEFAULT_VALUE,
192
237
                              *option_strings)
193
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
 
194
244
    def _optparse_callback(self, option, opt, value, parser):
195
 
        setattr(parser.values, self.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)
196
249
 
197
250
    def iter_switches(self):
198
251
        """Iterate through the list of switches provided by the option
199
 
        
 
252
 
200
253
        :return: an iterator of (name, short_name, argname, help)
201
254
        """
202
255
        argname =  self.argname
204
257
            argname = argname.upper()
205
258
        yield self.name, self.short_name(), argname, self.help
206
259
 
 
260
    def is_hidden(self, name):
 
261
        return self.hidden
 
262
 
 
263
 
 
264
class ListOption(Option):
 
265
    """Option used to provide a list of values.
 
266
 
 
267
    On the command line, arguments are specified by a repeated use of the
 
268
    option. '-' is a special argument that resets the list. For example,
 
269
      --foo=a --foo=b
 
270
    sets the value of the 'foo' option to ['a', 'b'], and
 
271
      --foo=a --foo=b --foo=- --foo=c
 
272
    sets the value of the 'foo' option to ['c'].
 
273
    """
 
274
 
 
275
    def add_option(self, parser, short_name):
 
276
        """Add this option to an Optparse parser."""
 
277
        option_strings = ['--%s' % self.name]
 
278
        if short_name is not None:
 
279
            option_strings.append('-%s' % short_name)
 
280
        parser.add_option(action='callback',
 
281
                          callback=self._optparse_callback,
 
282
                          type='string', metavar=self.argname.upper(),
 
283
                          help=self.help, default=[],
 
284
                          *option_strings)
 
285
 
 
286
    def _optparse_callback(self, option, opt, value, parser):
 
287
        values = getattr(parser.values, self._param_name)
 
288
        if value == '-':
 
289
            del values[:]
 
290
        else:
 
291
            values.append(self.type(value))
 
292
        if self.custom_callback is not None:
 
293
            self.custom_callback(option, self._param_name, values, parser)
 
294
 
207
295
 
208
296
class RegistryOption(Option):
209
297
    """Option based on a registry
226
314
        else:
227
315
            return self.converter(value)
228
316
 
229
 
    def __init__(self, name, help, registry, converter=None,
230
 
        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):
231
320
        """
232
321
        Constructor.
233
322
 
241
330
            '--knit' can be used interchangeably.
242
331
        :param enum_switch: If true, a switch is provided with the option name,
243
332
            which takes a value.
 
333
        :param lazy_registry: A tuple of (module name, attribute name) for a
 
334
            registry to be lazily loaded.
244
335
        """
245
336
        Option.__init__(self, name, help, type=self.convert)
246
 
        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')
247
347
        self.name = name
248
348
        self.converter = converter
249
349
        self.value_switches = value_switches
252
352
        if self.title is None:
253
353
            self.title = name
254
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
 
255
361
    @staticmethod
256
362
    def from_kwargs(name_, help=None, title=None, value_switches=False,
257
363
                    enum_switch=True, **kwargs):
261
367
        RegistryOption constructor.  Any other keyword arguments are treated
262
368
        as values for the option, and they value is treated as the help.
263
369
        """
264
 
        reg = registry.Registry()
265
 
        for name, help in kwargs.iteritems():
 
370
        reg = _mod_registry.Registry()
 
371
        for name, switch_help in kwargs.iteritems():
266
372
            name = name.replace('_', '-')
267
 
            reg.register(name, name, help=help)
 
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 + "."
268
378
        return RegistryOption(name_, help, reg, title=title,
269
379
            value_switches=value_switches, enum_switch=enum_switch)
270
380
 
277
387
        if self.value_switches:
278
388
            for key in self.registry.keys():
279
389
                option_strings = ['--%s' % key]
280
 
                if getattr(self.registry.get_info(key), 'hidden', False):
 
390
                if self.is_hidden(key):
281
391
                    help = optparse.SUPPRESS_HELP
282
392
                else:
283
393
                    help = self.registry.get_help(key)
288
398
 
289
399
    def _optparse_value_callback(self, cb_value):
290
400
        def cb(option, opt, value, parser):
291
 
            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)
292
405
        return cb
293
406
 
294
407
    def iter_switches(self):
302
415
            for key in sorted(self.registry.keys()):
303
416
                yield key, None, None, self.registry.get_help(key)
304
417
 
 
418
    def is_hidden(self, name):
 
419
        if name == self.name:
 
420
            return Option.is_hidden(self, name)
 
421
        return getattr(self.registry.get_info(name), 'hidden', False)
 
422
 
305
423
 
306
424
class OptionParser(optparse.OptionParser):
307
425
    """OptionParser that raises exceptions instead of exiting"""
322
440
    return parser
323
441
 
324
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
 
325
458
def _global_option(name, **kwargs):
326
 
    """Register o as a global option."""
 
459
    """Register a global option."""
327
460
    Option.OPTIONS[name] = Option(name, **kwargs)
328
461
 
329
462
 
330
 
def _global_registry_option(name, help, registry, **kwargs):
 
463
def _global_registry_option(name, help, registry=None, **kwargs):
331
464
    Option.OPTIONS[name] = RegistryOption(name, help, registry, **kwargs)
332
465
 
333
466
 
334
 
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):
335
496
 
336
497
    pass
337
498
 
343
504
                                   "Merge using external diff3")
344
505
_merge_type_registry.register_lazy('weave', 'bzrlib.merge', 'WeaveMerger',
345
506
                                   "Weave-based merge")
346
 
 
 
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
347
523
_global_option('all')
348
524
_global_option('overwrite', help='Ignore differences between branches and '
349
 
               'overwrite unconditionally')
 
525
               'overwrite unconditionally.')
350
526
_global_option('basis', type=str)
351
527
_global_option('bound')
352
528
_global_option('diff-options', type=str)
353
 
_global_option('help',
354
 
               help='show help message',
355
 
               short_name='h')
356
529
_global_option('file', type=unicode, short_name='F')
357
530
_global_option('force')
358
531
_global_option('format', type=unicode)
359
532
_global_option('forward')
360
533
_global_option('message', type=unicode,
361
 
               short_name='m')
 
534
               short_name='m',
 
535
               help='Message string.')
362
536
_global_option('no-recurse')
363
537
_global_option('profile',
364
 
               help='show performance profiling information')
 
538
               help='Show performance profiling information.')
365
539
_global_option('revision',
366
540
               type=_parse_revision_str,
367
541
               short_name='r',
368
 
               help='See \'help revisionspec\' for details')
369
 
_global_option('show-ids', 
370
 
               help='show internal object ids')
371
 
_global_option('timezone', 
 
542
               help='See "help revisionspec" for details.')
 
543
_global_option('change',
 
544
               type=_parse_change_str,
 
545
               short_name='c',
 
546
               param_name='revision',
 
547
               help='Select changes introduced by the specified revision. See also "help revisionspec".')
 
548
_global_option('show-ids',
 
549
               help='Show internal object ids.')
 
550
_global_option('timezone',
372
551
               type=str,
373
 
               help='display timezone as local, original, or utc')
 
552
               help='Display timezone as local, original, or utc.')
374
553
_global_option('unbound')
375
 
_global_option('verbose',
376
 
               help='display more information',
377
 
               short_name='v')
378
554
_global_option('version')
379
555
_global_option('email')
380
556
_global_option('update')
381
 
_global_registry_option('log-format', "Use this log format",
382
 
                        log.log_formatter_registry, value_switches=True,
383
 
                        title='Log format')
 
557
_global_registry_option('log-format', "Use specified log format.",
 
558
                        lazy_registry=('bzrlib.log', 'log_formatter_registry'),
 
559
                        value_switches=True, title='Log format')
384
560
_global_option('long', help='Use detailed log format. Same as --log-format long',
385
561
               short_name='l')
386
562
_global_option('short', help='Use moderately short log format. Same as --log-format short')
387
563
_global_option('line', help='Use log format with one line per revision. Same as --log-format line')
388
564
_global_option('root', type=str)
389
565
_global_option('no-backup')
390
 
_global_registry_option('merge-type', 'Select a particular merge algorithm',
 
566
_global_registry_option('merge-type', 'Select a particular merge algorithm.',
391
567
                        _merge_type_registry, value_switches=True,
392
568
                        title='Merge algorithm')
393
569
_global_option('pattern', type=str)
394
 
_global_option('quiet', short_name='q')
395
570
_global_option('remember', help='Remember the specified location as a'
396
571
               ' default.')
397
 
_global_option('reprocess', help='Reprocess to reduce spurious conflicts')
 
572
_global_option('reprocess', help='Reprocess to reduce spurious conflicts.')
398
573
_global_option('kind', type=str)
399
574
_global_option('dry-run',
400
 
               help="show what would be done, but don't actually do anything")
 
575
               help="Show what would be done, but don't actually do anything.")
401
576
_global_option('name-from-revision', help='The path name in the old tree.')
402
577
 
403
 
 
404
 
# prior to 0.14 these were always globally registered; the old dict is
405
 
# available for plugins that use it but it should not be used.
406
 
Option.SHORT_OPTIONS = symbol_versioning.DeprecatedDict(
407
 
    symbol_versioning.zero_fourteen,
408
 
    'SHORT_OPTIONS',
409
 
    {
410
 
        'F': Option.OPTIONS['file'],
411
 
        'h': Option.OPTIONS['help'],
412
 
        'm': Option.OPTIONS['message'],
413
 
        'r': Option.OPTIONS['revision'],
414
 
        'v': Option.OPTIONS['verbose'],
415
 
        'l': Option.OPTIONS['long'],
416
 
        'q': Option.OPTIONS['quiet'],
417
 
    },
418
 
    'Set the short option name when constructing the Option.',
419
 
    )
 
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'