← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

Merge the 0.17 fixes back into bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/conflicts.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2005 Aaron Bentley, 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
16
 
 
17
 
# TODO: 'bzr resolve' should accept a directory name and work from that
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
# TODO: Move this into builtins
 
18
 
 
19
# TODO: 'bzr resolve' should accept a directory name and work from that 
18
20
# point down
19
21
 
20
22
import os
21
 
import re
22
23
 
23
24
from bzrlib.lazy_import import lazy_import
24
25
lazy_import(globals(), """
31
32
    osutils,
32
33
    rio,
33
34
    trace,
34
 
    transform,
35
 
    workingtree,
36
35
    )
37
36
""")
38
 
from bzrlib import (
39
 
    option,
40
 
    registry,
41
 
    )
 
37
from bzrlib.option import Option
42
38
 
43
39
 
44
40
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
57
53
    instead.  (This is useful for editing all files with text conflicts.)
58
54
 
59
55
    Use bzr resolve when you have fixed a problem.
 
56
 
 
57
    See also bzr resolve.
60
58
    """
61
 
    takes_options = [
62
 
            option.Option('text',
63
 
                          help='List paths of files with text conflicts.'),
64
 
        ]
65
 
    _see_also = ['resolve', 'conflict-types']
 
59
    takes_options = [Option('text', help='list text conflicts by pathname')]
66
60
 
67
61
    def run(self, text=False):
68
 
        wt = workingtree.WorkingTree.open_containing(u'.')[0]
 
62
        from bzrlib.workingtree import WorkingTree
 
63
        wt = WorkingTree.open_containing(u'.')[0]
69
64
        for conflict in wt.conflicts():
70
65
            if text:
71
66
                if conflict.typestring != 'text conflict':
75
70
                self.outf.write(str(conflict) + '\n')
76
71
 
77
72
 
78
 
resolve_action_registry = registry.Registry()
79
 
 
80
 
 
81
 
resolve_action_registry.register(
82
 
    'done', 'done', 'Marks the conflict as resolved' )
83
 
resolve_action_registry.register(
84
 
    'take-this', 'take_this',
85
 
    'Resolve the conflict preserving the version in the working tree' )
86
 
resolve_action_registry.register(
87
 
    'take-other', 'take_other',
88
 
    'Resolve the conflict taking the merged version into account' )
89
 
resolve_action_registry.default_key = 'done'
90
 
 
91
 
class ResolveActionOption(option.RegistryOption):
92
 
 
93
 
    def __init__(self):
94
 
        super(ResolveActionOption, self).__init__(
95
 
            'action', 'How to resolve the conflict.',
96
 
            value_switches=True,
97
 
            registry=resolve_action_registry)
98
 
 
99
 
 
100
73
class cmd_resolve(commands.Command):
101
74
    """Mark a conflict as resolved.
102
75
 
106
79
    before you should commit.
107
80
 
108
81
    Once you have fixed a problem, use "bzr resolve" to automatically mark
109
 
    text conflicts as fixed, "bzr resolve FILE" to mark a specific conflict as
 
82
    text conflicts as fixed, resolve FILE to mark a specific conflict as
110
83
    resolved, or "bzr resolve --all" to mark all conflicts as resolved.
 
84
 
 
85
    See also bzr conflicts.
111
86
    """
112
87
    aliases = ['resolved']
113
88
    takes_args = ['file*']
114
 
    takes_options = [
115
 
            option.Option('all', help='Resolve all conflicts in this tree.'),
116
 
            ResolveActionOption(),
117
 
            ]
118
 
    _see_also = ['conflicts']
119
 
    def run(self, file_list=None, all=False, action=None):
 
89
    takes_options = [Option('all', help='Resolve all conflicts in this tree')]
 
90
    def run(self, file_list=None, all=False):
 
91
        from bzrlib.workingtree import WorkingTree
120
92
        if all:
121
93
            if file_list:
122
94
                raise errors.BzrCommandError("If --all is specified,"
123
95
                                             " no FILE may be provided")
124
 
            tree = workingtree.WorkingTree.open_containing('.')[0]
125
 
            if action is None:
126
 
                action = 'done'
 
96
            tree = WorkingTree.open_containing('.')[0]
 
97
            resolve(tree)
127
98
        else:
128
99
            tree, file_list = builtins.tree_files(file_list)
129
100
            if file_list is None:
130
 
                if action is None:
131
 
                    # FIXME: There is a special case here related to the option
132
 
                    # handling that could be clearer and easier to discover by
133
 
                    # providing an --auto action (bug #344013 and #383396) and
134
 
                    # make it mandatory instead of implicit and active only
135
 
                    # when no file_list is provided -- vila 091229
136
 
                    action = 'auto'
137
 
            else:
138
 
                if action is None:
139
 
                    action = 'done'
140
 
        if action == 'auto':
141
 
            if file_list is None:
142
101
                un_resolved, resolved = tree.auto_resolve()
143
102
                if len(un_resolved) > 0:
144
103
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
150
109
                    trace.note('All conflicts resolved.')
151
110
                    return 0
152
111
            else:
153
 
                # FIXME: This can never occur but the block above needs some
154
 
                # refactoring to transfer tree.auto_resolve() to
155
 
                # conflict.auto(tree) --vila 091242
156
 
                pass
157
 
        else:
158
 
            resolve(tree, file_list, action=action)
159
 
 
160
 
 
161
 
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
162
 
            action='done'):
163
 
    """Resolve some or all of the conflicts in a working tree.
164
 
 
165
 
    :param paths: If None, resolve all conflicts.  Otherwise, select only
166
 
        specified conflicts.
167
 
    :param recursive: If True, then elements of paths which are directories
168
 
        have all their children resolved, etc.  When invoked as part of
169
 
        recursive commands like revert, this should be True.  For commands
170
 
        or applications wishing finer-grained control, like the resolve
171
 
        command, this should be False.
172
 
    :param ignore_misses: If False, warnings will be printed if the supplied
173
 
        paths do not have conflicts.
174
 
    :param action: How the conflict should be resolved,
175
 
    """
 
112
                resolve(tree, file_list)
 
113
 
 
114
 
 
115
def resolve(tree, paths=None, ignore_misses=False):
176
116
    tree.lock_tree_write()
177
117
    try:
178
118
        tree_conflicts = tree.conflicts()
179
119
        if paths is None:
180
120
            new_conflicts = ConflictList()
181
 
            to_process = tree_conflicts
 
121
            selected_conflicts = tree_conflicts
182
122
        else:
183
 
            new_conflicts, to_process = tree_conflicts.select_conflicts(
184
 
                tree, paths, ignore_misses, recursive)
185
 
        for conflict in to_process:
186
 
            try:
187
 
                conflict._do(action, tree)
188
 
                conflict.cleanup(tree)
189
 
            except NotImplementedError:
190
 
                new_conflicts.append(conflict)
 
123
            new_conflicts, selected_conflicts = \
 
124
                tree_conflicts.select_conflicts(tree, paths, ignore_misses)
191
125
        try:
192
126
            tree.set_conflicts(new_conflicts)
193
127
        except errors.UnsupportedOperation:
194
128
            pass
 
129
        selected_conflicts.remove_files(tree)
195
130
    finally:
196
131
        tree.unlock()
197
132
 
198
133
 
199
134
def restore(filename):
200
 
    """Restore a conflicted file to the state it was in before merging.
201
 
 
202
 
    Only text restoration is supported at present.
 
135
    """\
 
136
    Restore a conflicted file to the state it was in before merging.
 
137
    Only text restoration supported at present.
203
138
    """
204
139
    conflicted = False
205
140
    try:
275
210
        """Generator of stanzas"""
276
211
        for conflict in self:
277
212
            yield conflict.as_stanza()
278
 
 
 
213
            
279
214
    def to_strings(self):
280
215
        """Generate strings for the provided conflicts"""
281
216
        for conflict in self:
286
221
        for conflict in self:
287
222
            if not conflict.has_files:
288
223
                continue
289
 
            conflict.cleanup(tree)
 
224
            for suffix in CONFLICT_SUFFIXES:
 
225
                try:
 
226
                    osutils.delete_any(tree.abspath(conflict.path+suffix))
 
227
                except OSError, e:
 
228
                    if e.errno != errno.ENOENT:
 
229
                        raise
290
230
 
291
 
    def select_conflicts(self, tree, paths, ignore_misses=False,
292
 
                         recurse=False):
 
231
    def select_conflicts(self, tree, paths, ignore_misses=False):
293
232
        """Select the conflicts associated with paths in a tree.
294
 
 
 
233
        
295
234
        File-ids are also used for this.
296
235
        :return: a pair of ConflictLists: (not_selected, selected)
297
236
        """
314
253
                if cpath in path_set:
315
254
                    selected = True
316
255
                    selected_paths.add(cpath)
317
 
                if recurse:
318
 
                    if osutils.is_inside_any(path_set, cpath):
319
 
                        selected = True
320
 
                        selected_paths.add(cpath)
321
 
 
322
256
            for key in ('file_id', 'conflict_file_id'):
323
257
                cfile_id = getattr(conflict, key, None)
324
258
                if cfile_id is None:
341
275
                    print "%s is not conflicted" % path
342
276
        return new_conflicts, selected_conflicts
343
277
 
344
 
 
 
278
 
345
279
class Conflict(object):
346
280
    """Base class for all types of conflict"""
347
281
 
348
 
    # FIXME: cleanup should take care of that ? -- vila 091229
349
282
    has_files = False
350
283
 
351
284
    def __init__(self, path, file_id=None):
400
333
        else:
401
334
            return None, conflict.typestring
402
335
 
403
 
    def _do(self, action, tree):
404
 
        """Apply the specified action to the conflict.
405
 
 
406
 
        :param action: The method name to call.
407
 
 
408
 
        :param tree: The tree passed as a parameter to the method.
409
 
        """
410
 
        meth = getattr(self, 'action_%s' % action, None)
411
 
        if meth is None:
412
 
            raise NotImplementedError(self.__class__.__name__ + '.' + action)
413
 
        meth(tree)
414
 
 
415
 
    def associated_filenames(self):
416
 
        """The names of the files generated to help resolve the conflict."""
417
 
        raise NotImplementedError(self.associated_filenames)
418
 
 
419
 
    def cleanup(self, tree):
420
 
        for fname in self.associated_filenames():
421
 
            try:
422
 
                osutils.delete_any(tree.abspath(fname))
423
 
            except OSError, e:
424
 
                if e.errno != errno.ENOENT:
425
 
                    raise
426
 
 
427
 
    def action_done(self, tree):
428
 
        """Mark the conflict as solved once it has been handled."""
429
 
        # This method does nothing but simplifies the design of upper levels.
430
 
        pass
431
 
 
432
 
    def action_take_this(self, tree):
433
 
        raise NotImplementedError(self.action_take_this)
434
 
 
435
 
    def action_take_other(self, tree):
436
 
        raise NotImplementedError(self.action_take_other)
437
 
 
438
336
 
439
337
class PathConflict(Conflict):
440
338
    """A conflict was encountered merging file paths"""
444
342
    format = 'Path conflict: %(path)s / %(conflict_path)s'
445
343
 
446
344
    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
447
 
 
448
345
    def __init__(self, path, conflict_path=None, file_id=None):
449
346
        Conflict.__init__(self, path, file_id)
450
347
        self.conflict_path = conflict_path
455
352
            s.add('conflict_path', self.conflict_path)
456
353
        return s
457
354
 
458
 
    def associated_filenames(self):
459
 
        # No additional files have been generated here
460
 
        return []
461
 
 
462
 
    def action_take_this(self, tree):
463
 
        tree.rename_one(self.conflict_path, self.path)
464
 
 
465
 
    def action_take_other(self, tree):
466
 
        # just acccept bzr proposal
467
 
        pass
468
 
 
469
355
 
470
356
class ContentsConflict(PathConflict):
471
357
    """The files are of different types, or not present"""
476
362
 
477
363
    format = 'Contents conflict in %(path)s'
478
364
 
479
 
    def associated_filenames(self):
480
 
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
481
 
 
482
 
    # FIXME: I smell something weird here and it seems we should be able to be
483
 
    # more coherent with some other conflict ? bzr *did* a choice there but
484
 
    # neither action_take_this nor action_take_other reflect that...
485
 
    # -- vila 20091224
486
 
    def action_take_this(self, tree):
487
 
        tree.remove([self.path + '.OTHER'], force=True, keep_files=False)
488
 
 
489
 
    def action_take_other(self, tree):
490
 
        tree.remove([self.path], force=True, keep_files=False)
491
 
 
492
 
 
493
 
 
494
 
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
495
 
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
496
 
 
497
 
# TODO: There should be a base revid attribute to better inform the user about
498
 
# how the conflicts were generated.
 
365
 
499
366
class TextConflict(PathConflict):
500
367
    """The merge algorithm could not resolve all differences encountered."""
501
368
 
505
372
 
506
373
    format = 'Text conflict in %(path)s'
507
374
 
508
 
    def associated_filenames(self):
509
 
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
510
 
 
511
375
 
512
376
class HandledConflict(Conflict):
513
377
    """A path problem that has been provisionally resolved.
515
379
    """
516
380
 
517
381
    rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
518
 
 
 
382
    
519
383
    def __init__(self, action, path, file_id=None):
520
384
        Conflict.__init__(self, path, file_id)
521
385
        self.action = action
528
392
        s.add('action', self.action)
529
393
        return s
530
394
 
531
 
    def associated_filenames(self):
532
 
        # Nothing has been generated here
533
 
        return []
534
 
 
535
395
 
536
396
class HandledPathConflict(HandledConflict):
537
397
    """A provisionally-resolved path problem involving two paths.
544
404
    def __init__(self, action, path, conflict_path, file_id=None,
545
405
                 conflict_file_id=None):
546
406
        HandledConflict.__init__(self, action, path, file_id)
547
 
        self.conflict_path = conflict_path
 
407
        self.conflict_path = conflict_path 
548
408
        # warn turned off, because the factory blindly transfers the Stanza
549
409
        # values to __init__.
550
410
        self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
551
411
                                                     warn=False)
552
 
 
 
412
        
553
413
    def _cmp_list(self):
554
 
        return HandledConflict._cmp_list(self) + [self.conflict_path,
 
414
        return HandledConflict._cmp_list(self) + [self.conflict_path, 
555
415
                                                  self.conflict_file_id]
556
416
 
557
417
    def as_stanza(self):
559
419
        s.add('conflict_path', self.conflict_path)
560
420
        if self.conflict_file_id is not None:
561
421
            s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
562
 
 
 
422
            
563
423
        return s
564
424
 
565
425
 
578
438
 
579
439
    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
580
440
 
581
 
    def action_take_this(self, tree):
582
 
        tree.remove([self.conflict_path], force=True, keep_files=False)
583
 
        tree.rename_one(self.path, self.conflict_path)
584
 
 
585
 
    def action_take_other(self, tree):
586
 
        tree.remove([self.path], force=True, keep_files=False)
587
 
 
588
441
 
589
442
class ParentLoop(HandledPathConflict):
590
443
    """An attempt to create an infinitely-looping directory structure.
591
444
    This is rare, but can be produced like so:
592
445
 
593
446
    tree A:
594
 
      mv foo bar
 
447
      mv foo/bar
595
448
    tree B:
596
 
      mv bar foo
 
449
      mv bar/foo
597
450
    merge A and B
598
451
    """
599
452
 
601
454
 
602
455
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
603
456
 
604
 
    def action_take_this(self, tree):
605
 
        # just acccept bzr proposal
606
 
        pass
607
 
 
608
 
    def action_take_other(self, tree):
609
 
        # FIXME: We shouldn't have to manipulate so many paths here (and there
610
 
        # is probably a bug or two...)
611
 
        base_path = osutils.basename(self.path)
612
 
        conflict_base_path = osutils.basename(self.conflict_path)
613
 
        tt = transform.TreeTransform(tree)
614
 
        try:
615
 
            p_tid = tt.trans_id_file_id(self.file_id)
616
 
            parent_tid = tt.get_tree_parent(p_tid)
617
 
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
618
 
            cparent_tid = tt.get_tree_parent(cp_tid)
619
 
            tt.adjust_path(base_path, cparent_tid, cp_tid)
620
 
            tt.adjust_path(conflict_base_path, parent_tid, p_tid)
621
 
            tt.apply()
622
 
        finally:
623
 
            tt.finalize()
624
 
 
625
457
 
626
458
class UnversionedParent(HandledConflict):
627
 
    """An attempt to version a file whose parent directory is not versioned.
 
459
    """An attempt to version an file whose parent directory is not versioned.
628
460
    Typically, the result of a merge where one tree unversioned the directory
629
461
    and the other added a versioned file to it.
630
462
    """
634
466
    format = 'Conflict because %(path)s is not versioned, but has versioned'\
635
467
             ' children.  %(action)s.'
636
468
 
637
 
    # FIXME: We silently do nothing to make tests pass, but most probably the
638
 
    # conflict shouldn't exist (the long story is that the conflict is
639
 
    # generated with another one that can be resolved properly) -- vila 091224
640
 
    def action_take_this(self, tree):
641
 
        pass
642
 
 
643
 
    def action_take_other(self, tree):
644
 
        pass
645
 
 
646
469
 
647
470
class MissingParent(HandledConflict):
648
471
    """An attempt to add files to a directory that is not present.
649
472
    Typically, the result of a merge where THIS deleted the directory and
650
473
    the OTHER added a file to it.
651
 
    See also: DeletingParent (same situation, THIS and OTHER reversed)
 
474
    See also: DeletingParent (same situation, reversed THIS and OTHER)
652
475
    """
653
476
 
654
477
    typestring = 'missing parent'
655
478
 
656
479
    format = 'Conflict adding files to %(path)s.  %(action)s.'
657
480
 
658
 
    def action_take_this(self, tree):
659
 
        tree.remove([self.path], force=True, keep_files=False)
660
 
 
661
 
    def action_take_other(self, tree):
662
 
        # just acccept bzr proposal
663
 
        pass
664
 
 
665
481
 
666
482
class DeletingParent(HandledConflict):
667
483
    """An attempt to add files to a directory that is not present.
674
490
    format = "Conflict: can't delete %(path)s because it is not empty.  "\
675
491
             "%(action)s."
676
492
 
677
 
    # FIXME: It's a bit strange that the default action is not coherent with
678
 
    # MissingParent from the *user* pov.
679
 
 
680
 
    def action_take_this(self, tree):
681
 
        # just acccept bzr proposal
682
 
        pass
683
 
 
684
 
    def action_take_other(self, tree):
685
 
        tree.remove([self.path], force=True, keep_files=False)
686
 
 
687
 
 
688
 
class NonDirectoryParent(HandledConflict):
689
 
    """An attempt to add files to a directory that is not a directory or
690
 
    an attempt to change the kind of a directory with files.
691
 
    """
692
 
 
693
 
    typestring = 'non-directory parent'
694
 
 
695
 
    format = "Conflict: %(path)s is not a directory, but has files in it."\
696
 
             "  %(action)s."
697
 
 
698
 
    # FIXME: .OTHER should be used instead of .new when the conflict is created
699
 
 
700
 
    def action_take_this(self, tree):
701
 
        # FIXME: we should preserve that path when the conflict is generated !
702
 
        if self.path.endswith('.new'):
703
 
            conflict_path = self.path[:-(len('.new'))]
704
 
            tree.remove([self.path], force=True, keep_files=False)
705
 
            tree.add(conflict_path)
706
 
        else:
707
 
            raise NotImplementedError(self.action_take_this)
708
 
 
709
 
    def action_take_other(self, tree):
710
 
        # FIXME: we should preserve that path when the conflict is generated !
711
 
        if self.path.endswith('.new'):
712
 
            conflict_path = self.path[:-(len('.new'))]
713
 
            tree.remove([conflict_path], force=True, keep_files=False)
714
 
            tree.rename_one(self.path, conflict_path)
715
 
        else:
716
 
            raise NotImplementedError(self.action_take_other)
717
 
 
718
493
 
719
494
ctype = {}
720
495
 
725
500
    for conflict_type in conflict_types:
726
501
        ctype[conflict_type.typestring] = conflict_type
727
502
 
 
503
 
728
504
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
729
505
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
730
 
               DeletingParent, NonDirectoryParent)
 
506
               DeletingParent,)