/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-04-24 10:31:28 UTC
  • mfrom: (1684.1.2 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060424103128-a637f56a7c529bad
(mbp) tutorial improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/conflicts.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 by Aaron Bentley
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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: 'brz 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
 
from __future__ import absolute_import
21
 
 
22
22
import os
23
 
import re
24
 
 
25
 
from .lazy_import import lazy_import
26
 
lazy_import(globals(), """
27
23
import errno
28
24
 
29
 
from breezy import (
30
 
    osutils,
31
 
    rio,
32
 
    trace,
33
 
    transform,
34
 
    workingtree,
35
 
    )
36
 
from breezy.i18n import gettext, ngettext
37
 
""")
38
 
from . import (
39
 
    cache_utf8,
40
 
    errors,
41
 
    commands,
42
 
    option,
43
 
    registry,
44
 
    )
45
 
from .sixish import text_type
 
25
import bzrlib
 
26
from bzrlib.commands import register_command
 
27
from bzrlib.errors import BzrCommandError, NotConflicted, UnsupportedOperation
 
28
from bzrlib.option import Option
 
29
from bzrlib.osutils import rename, delete_any
 
30
from bzrlib.rio import Stanza
46
31
 
47
32
 
48
33
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
49
34
 
50
35
 
51
 
class cmd_conflicts(commands.Command):
52
 
    __doc__ = """List files with conflicts.
 
36
class cmd_conflicts(bzrlib.commands.Command):
 
37
    """List files with conflicts.
53
38
 
54
39
    Merge will do its best to combine the changes in two branches, but there
55
40
    are some kinds of problems only a human can fix.  When it encounters those,
56
41
    it will mark a conflict.  A conflict means that you need to fix something,
57
 
    before you can commit.
58
 
 
59
 
    Conflicts normally are listed as short, human-readable messages.  If --text
60
 
    is supplied, the pathnames of files with text conflicts are listed,
61
 
    instead.  (This is useful for editing all files with text conflicts.)
62
 
 
63
 
    Use brz resolve when you have fixed a problem.
 
42
    before you should commit.
 
43
 
 
44
    Use bzr resolve when you have fixed a problem.
 
45
 
 
46
    (conflicts are determined by the presence of .BASE .TREE, and .OTHER 
 
47
    files.)
 
48
 
 
49
    See also bzr resolve.
64
50
    """
65
 
    takes_options = [
66
 
        'directory',
67
 
        option.Option('text',
68
 
                      help='List paths of files with text conflicts.'),
69
 
        ]
70
 
    _see_also = ['resolve', 'conflict-types']
71
 
 
72
 
    def run(self, text=False, directory=u'.'):
73
 
        wt = workingtree.WorkingTree.open_containing(directory)[0]
 
51
    def run(self):
 
52
        from bzrlib.workingtree import WorkingTree
 
53
        wt = WorkingTree.open_containing(u'.')[0]
74
54
        for conflict in wt.conflicts():
75
 
            if text:
76
 
                if conflict.typestring != 'text conflict':
77
 
                    continue
78
 
                self.outf.write(conflict.path + '\n')
79
 
            else:
80
 
                self.outf.write(text_type(conflict) + '\n')
81
 
 
82
 
 
83
 
resolve_action_registry = registry.Registry()
84
 
 
85
 
 
86
 
resolve_action_registry.register(
87
 
    'auto', 'auto', 'Detect whether conflict has been resolved by user.')
88
 
resolve_action_registry.register(
89
 
    'done', 'done', 'Marks the conflict as resolved.')
90
 
resolve_action_registry.register(
91
 
    'take-this', 'take_this',
92
 
    'Resolve the conflict preserving the version in the working tree.')
93
 
resolve_action_registry.register(
94
 
    'take-other', 'take_other',
95
 
    'Resolve the conflict taking the merged version into account.')
96
 
resolve_action_registry.default_key = 'done'
97
 
 
98
 
 
99
 
class ResolveActionOption(option.RegistryOption):
100
 
 
101
 
    def __init__(self):
102
 
        super(ResolveActionOption, self).__init__(
103
 
            'action', 'How to resolve the conflict.',
104
 
            value_switches=True,
105
 
            registry=resolve_action_registry)
106
 
 
107
 
 
108
 
class cmd_resolve(commands.Command):
109
 
    __doc__ = """Mark a conflict as resolved.
 
55
            print conflict
 
56
 
 
57
 
 
58
class cmd_resolve(bzrlib.commands.Command):
 
59
    """Mark a conflict as resolved.
110
60
 
111
61
    Merge will do its best to combine the changes in two branches, but there
112
62
    are some kinds of problems only a human can fix.  When it encounters those,
113
63
    it will mark a conflict.  A conflict means that you need to fix something,
114
 
    before you can commit.
115
 
 
116
 
    Once you have fixed a problem, use "brz resolve" to automatically mark
117
 
    text conflicts as fixed, "brz resolve FILE" to mark a specific conflict as
118
 
    resolved, or "brz resolve --all" to mark all conflicts as resolved.
 
64
    before you should commit.
 
65
 
 
66
    Once you have fixed a problem, use "bzr resolve FILE.." to mark
 
67
    individual files as fixed, or "bzr resolve --all" to mark all conflicts as
 
68
    resolved.
 
69
 
 
70
    See also bzr conflicts.
119
71
    """
120
72
    aliases = ['resolved']
121
73
    takes_args = ['file*']
122
 
    takes_options = [
123
 
        'directory',
124
 
        option.Option('all', help='Resolve all conflicts in this tree.'),
125
 
        ResolveActionOption(),
126
 
        ]
127
 
    _see_also = ['conflicts']
128
 
 
129
 
    def run(self, file_list=None, all=False, action=None, directory=None):
 
74
    takes_options = [Option('all', help='Resolve all conflicts in this tree')]
 
75
    def run(self, file_list=None, all=False):
 
76
        from bzrlib.workingtree import WorkingTree
130
77
        if all:
131
78
            if file_list:
132
 
                raise errors.BzrCommandError(gettext("If --all is specified,"
133
 
                                                     " no FILE may be provided"))
134
 
            if directory is None:
135
 
                directory = u'.'
136
 
            tree = workingtree.WorkingTree.open_containing(directory)[0]
137
 
            if action is None:
138
 
                action = 'done'
139
 
        else:
140
 
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
141
 
                file_list, directory)
142
 
            if action is None:
143
 
                if file_list is None:
144
 
                    action = 'auto'
145
 
                else:
146
 
                    action = 'done'
147
 
        before, after = resolve(tree, file_list, action=action)
148
 
        # GZ 2012-07-27: Should unify UI below now that auto is less magical.
149
 
        if action == 'auto' and file_list is None:
150
 
            if after > 0:
151
 
                trace.note(
152
 
                    ngettext('%d conflict auto-resolved.',
153
 
                             '%d conflicts auto-resolved.', before - after),
154
 
                    before - after)
155
 
                trace.note(gettext('Remaining conflicts:'))
156
 
                for conflict in tree.conflicts():
157
 
                    trace.note(text_type(conflict))
158
 
                return 1
159
 
            else:
160
 
                trace.note(gettext('All conflicts resolved.'))
161
 
                return 0
162
 
        else:
163
 
            trace.note(ngettext('{0} conflict resolved, {1} remaining',
164
 
                                '{0} conflicts resolved, {1} remaining',
165
 
                                before - after).format(before - after, after))
166
 
 
167
 
 
168
 
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
169
 
            action='done'):
170
 
    """Resolve some or all of the conflicts in a working tree.
171
 
 
172
 
    :param paths: If None, resolve all conflicts.  Otherwise, select only
173
 
        specified conflicts.
174
 
    :param recursive: If True, then elements of paths which are directories
175
 
        have all their children resolved, etc.  When invoked as part of
176
 
        recursive commands like revert, this should be True.  For commands
177
 
        or applications wishing finer-grained control, like the resolve
178
 
        command, this should be False.
179
 
    :param ignore_misses: If False, warnings will be printed if the supplied
180
 
        paths do not have conflicts.
181
 
    :param action: How the conflict should be resolved,
182
 
    """
183
 
    nb_conflicts_after = None
184
 
    with tree.lock_tree_write():
 
79
                raise BzrCommandError("If --all is specified, no FILE may be provided")
 
80
            tree = WorkingTree.open_containing('.')[0]
 
81
            resolve(tree)
 
82
        else:
 
83
            if file_list is None:
 
84
                raise BzrCommandError("command 'resolve' needs one or more FILE, or --all")
 
85
            tree = WorkingTree.open_containing(file_list[0])[0]
 
86
            to_resolve = [tree.relpath(p) for p in file_list]
 
87
            resolve(tree, to_resolve)
 
88
 
 
89
 
 
90
def resolve(tree, paths=None, ignore_misses=False):
 
91
    tree.lock_write()
 
92
    try:
185
93
        tree_conflicts = tree.conflicts()
186
 
        nb_conflicts_before = len(tree_conflicts)
187
94
        if paths is None:
188
95
            new_conflicts = ConflictList()
189
 
            to_process = tree_conflicts
 
96
            selected_conflicts = tree_conflicts
190
97
        else:
191
 
            new_conflicts, to_process = tree_conflicts.select_conflicts(
192
 
                tree, paths, ignore_misses, recursive)
193
 
        for conflict in to_process:
194
 
            try:
195
 
                conflict._do(action, tree)
196
 
                conflict.cleanup(tree)
197
 
            except NotImplementedError:
198
 
                new_conflicts.append(conflict)
 
98
            new_conflicts, selected_conflicts = \
 
99
                tree_conflicts.select_conflicts(tree, paths, ignore_misses)
199
100
        try:
200
 
            nb_conflicts_after = len(new_conflicts)
201
101
            tree.set_conflicts(new_conflicts)
202
 
        except errors.UnsupportedOperation:
 
102
        except UnsupportedOperation:
203
103
            pass
204
 
    if nb_conflicts_after is None:
205
 
        nb_conflicts_after = nb_conflicts_before
206
 
    return nb_conflicts_before, nb_conflicts_after
 
104
        selected_conflicts.remove_files(tree)
 
105
    finally:
 
106
        tree.unlock()
207
107
 
208
108
 
209
109
def restore(filename):
210
 
    """Restore a conflicted file to the state it was in before merging.
211
 
 
212
 
    Only text restoration is supported at present.
 
110
    """\
 
111
    Restore a conflicted file to the state it was in before merging.
 
112
    Only text restoration supported at present.
213
113
    """
214
114
    conflicted = False
215
115
    try:
216
 
        osutils.rename(filename + ".THIS", filename)
 
116
        rename(filename + ".THIS", filename)
217
117
        conflicted = True
218
 
    except OSError as e:
 
118
    except OSError, e:
219
119
        if e.errno != errno.ENOENT:
220
120
            raise
221
121
    try:
222
122
        os.unlink(filename + ".BASE")
223
123
        conflicted = True
224
 
    except OSError as e:
 
124
    except OSError, e:
225
125
        if e.errno != errno.ENOENT:
226
126
            raise
227
127
    try:
228
128
        os.unlink(filename + ".OTHER")
229
129
        conflicted = True
230
 
    except OSError as e:
 
130
    except OSError, e:
231
131
        if e.errno != errno.ENOENT:
232
132
            raise
233
133
    if not conflicted:
234
 
        raise errors.NotConflicted(filename)
 
134
        raise NotConflicted(filename)
235
135
 
236
136
 
237
137
class ConflictList(object):
285
185
        """Generator of stanzas"""
286
186
        for conflict in self:
287
187
            yield conflict.as_stanza()
288
 
 
 
188
            
289
189
    def to_strings(self):
290
190
        """Generate strings for the provided conflicts"""
291
191
        for conflict in self:
292
 
            yield text_type(conflict)
 
192
            yield str(conflict)
293
193
 
294
194
    def remove_files(self, tree):
295
195
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
296
196
        for conflict in self:
297
197
            if not conflict.has_files:
298
198
                continue
299
 
            conflict.cleanup(tree)
 
199
            for suffix in CONFLICT_SUFFIXES:
 
200
                try:
 
201
                    delete_any(tree.abspath(conflict.path+suffix))
 
202
                except OSError, e:
 
203
                    if e.errno != errno.ENOENT:
 
204
                        raise
300
205
 
301
 
    def select_conflicts(self, tree, paths, ignore_misses=False,
302
 
                         recurse=False):
 
206
    def select_conflicts(self, tree, paths, ignore_misses=False):
303
207
        """Select the conflicts associated with paths in a tree.
304
 
 
 
208
        
305
209
        File-ids are also used for this.
306
 
        :return: a pair of ConflictLists: (not_selected, selected)
307
210
        """
308
211
        path_set = set(paths)
309
212
        ids = {}
324
227
                if cpath in path_set:
325
228
                    selected = True
326
229
                    selected_paths.add(cpath)
327
 
                if recurse:
328
 
                    if osutils.is_inside_any(path_set, cpath):
329
 
                        selected = True
330
 
                        selected_paths.add(cpath)
331
 
 
332
230
            for key in ('file_id', 'conflict_file_id'):
333
231
                cfile_id = getattr(conflict, key, None)
334
232
                if cfile_id is None:
346
244
        if ignore_misses is not True:
347
245
            for path in [p for p in paths if p not in selected_paths]:
348
246
                if not os.path.exists(tree.abspath(path)):
349
 
                    print("%s does not exist" % path)
 
247
                    print "%s does not exist" % path
350
248
                else:
351
 
                    print("%s is not conflicted" % path)
 
249
                    print "%s is not conflicted" % path
352
250
        return new_conflicts, selected_conflicts
353
251
 
354
 
 
 
252
 
355
253
class Conflict(object):
356
254
    """Base class for all types of conflict"""
357
255
 
358
 
    # FIXME: cleanup should take care of that ? -- vila 091229
359
256
    has_files = False
360
257
 
361
258
    def __init__(self, path, file_id=None):
362
259
        self.path = path
363
 
        # the factory blindly transfers the Stanza values to __init__ and
364
 
        # Stanza is purely a Unicode api.
365
 
        if isinstance(file_id, text_type):
366
 
            file_id = cache_utf8.encode(file_id)
367
 
        self.file_id = osutils.safe_file_id(file_id)
 
260
        self.file_id = file_id
368
261
 
369
262
    def as_stanza(self):
370
 
        s = rio.Stanza(type=self.typestring, path=self.path)
 
263
        s = Stanza(type=self.typestring, path=self.path)
371
264
        if self.file_id is not None:
372
 
            # Stanza requires Unicode apis
373
 
            s.add('file_id', self.file_id.decode('utf8'))
 
265
            s.add('file_id', self.file_id)
374
266
        return s
375
267
 
376
268
    def _cmp_list(self):
379
271
    def __cmp__(self, other):
380
272
        if getattr(other, "_cmp_list", None) is None:
381
273
            return -1
382
 
        x = self._cmp_list()
383
 
        y = other._cmp_list()
384
 
        return (x > y) - (x < y)
385
 
 
386
 
    def __hash__(self):
387
 
        return hash((type(self), self.path, self.file_id))
 
274
        return cmp(self._cmp_list(), other._cmp_list())
388
275
 
389
276
    def __eq__(self, other):
390
277
        return self.__cmp__(other) == 0
392
279
    def __ne__(self, other):
393
280
        return not self.__eq__(other)
394
281
 
395
 
    def __unicode__(self):
396
 
        return self.describe()
397
 
 
398
282
    def __str__(self):
399
 
        return self.describe()
400
 
 
401
 
    def describe(self):
402
283
        return self.format % self.__dict__
403
284
 
404
285
    def __repr__(self):
420
301
        else:
421
302
            return None, conflict.typestring
422
303
 
423
 
    def _do(self, action, tree):
424
 
        """Apply the specified action to the conflict.
425
 
 
426
 
        :param action: The method name to call.
427
 
 
428
 
        :param tree: The tree passed as a parameter to the method.
429
 
        """
430
 
        meth = getattr(self, 'action_%s' % action, None)
431
 
        if meth is None:
432
 
            raise NotImplementedError(self.__class__.__name__ + '.' + action)
433
 
        meth(tree)
434
 
 
435
 
    def associated_filenames(self):
436
 
        """The names of the files generated to help resolve the conflict."""
437
 
        raise NotImplementedError(self.associated_filenames)
438
 
 
439
 
    def cleanup(self, tree):
440
 
        for fname in self.associated_filenames():
441
 
            try:
442
 
                osutils.delete_any(tree.abspath(fname))
443
 
            except OSError as e:
444
 
                if e.errno != errno.ENOENT:
445
 
                    raise
446
 
 
447
 
    def action_auto(self, tree):
448
 
        raise NotImplementedError(self.action_auto)
449
 
 
450
 
    def action_done(self, tree):
451
 
        """Mark the conflict as solved once it has been handled."""
452
 
        # This method does nothing but simplifies the design of upper levels.
453
 
        pass
454
 
 
455
 
    def action_take_this(self, tree):
456
 
        raise NotImplementedError(self.action_take_this)
457
 
 
458
 
    def action_take_other(self, tree):
459
 
        raise NotImplementedError(self.action_take_other)
460
 
 
461
 
    def _resolve_with_cleanups(self, tree, *args, **kwargs):
462
 
        with tree.get_transform() as tt:
463
 
            self._resolve(tt, *args, **kwargs)
464
 
 
465
304
 
466
305
class PathConflict(Conflict):
467
306
    """A conflict was encountered merging file paths"""
471
310
    format = 'Path conflict: %(path)s / %(conflict_path)s'
472
311
 
473
312
    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
474
 
 
475
313
    def __init__(self, path, conflict_path=None, file_id=None):
476
314
        Conflict.__init__(self, path, file_id)
477
315
        self.conflict_path = conflict_path
482
320
            s.add('conflict_path', self.conflict_path)
483
321
        return s
484
322
 
485
 
    def associated_filenames(self):
486
 
        # No additional files have been generated here
487
 
        return []
488
 
 
489
 
    def _resolve(self, tt, file_id, path, winner):
490
 
        """Resolve the conflict.
491
 
 
492
 
        :param tt: The TreeTransform where the conflict is resolved.
493
 
        :param file_id: The retained file id.
494
 
        :param path: The retained path.
495
 
        :param winner: 'this' or 'other' indicates which side is the winner.
496
 
        """
497
 
        path_to_create = None
498
 
        if winner == 'this':
499
 
            if self.path == '<deleted>':
500
 
                return  # Nothing to do
501
 
            if self.conflict_path == '<deleted>':
502
 
                path_to_create = self.path
503
 
                revid = tt._tree.get_parent_ids()[0]
504
 
        elif winner == 'other':
505
 
            if self.conflict_path == '<deleted>':
506
 
                return  # Nothing to do
507
 
            if self.path == '<deleted>':
508
 
                path_to_create = self.conflict_path
509
 
                # FIXME: If there are more than two parents we may need to
510
 
                # iterate. Taking the last parent is the safer bet in the mean
511
 
                # time. -- vila 20100309
512
 
                revid = tt._tree.get_parent_ids()[-1]
513
 
        else:
514
 
            # Programmer error
515
 
            raise AssertionError('bad winner: %r' % (winner,))
516
 
        if path_to_create is not None:
517
 
            tid = tt.trans_id_tree_path(path_to_create)
518
 
            tree = self._revision_tree(tt._tree, revid)
519
 
            transform.create_from_tree(
520
 
                tt, tid, tree, tree.id2path(file_id))
521
 
            tt.version_file(file_id, tid)
522
 
        else:
523
 
            tid = tt.trans_id_file_id(file_id)
524
 
        # Adjust the path for the retained file id
525
 
        parent_tid = tt.get_tree_parent(tid)
526
 
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
527
 
        tt.apply()
528
 
 
529
 
    def _revision_tree(self, tree, revid):
530
 
        return tree.branch.repository.revision_tree(revid)
531
 
 
532
 
    def _infer_file_id(self, tree):
533
 
        # Prior to bug #531967, file_id wasn't always set, there may still be
534
 
        # conflict files in the wild so we need to cope with them
535
 
        # Establish which path we should use to find back the file-id
536
 
        possible_paths = []
537
 
        for p in (self.path, self.conflict_path):
538
 
            if p == '<deleted>':
539
 
                # special hard-coded path
540
 
                continue
541
 
            if p is not None:
542
 
                possible_paths.append(p)
543
 
        # Search the file-id in the parents with any path available
544
 
        file_id = None
545
 
        for revid in tree.get_parent_ids():
546
 
            revtree = self._revision_tree(tree, revid)
547
 
            for p in possible_paths:
548
 
                file_id = revtree.path2id(p)
549
 
                if file_id is not None:
550
 
                    return revtree, file_id
551
 
        return None, None
552
 
 
553
 
    def action_take_this(self, tree):
554
 
        if self.file_id is not None:
555
 
            self._resolve_with_cleanups(tree, self.file_id, self.path,
556
 
                                        winner='this')
557
 
        else:
558
 
            # Prior to bug #531967 we need to find back the file_id and restore
559
 
            # the content from there
560
 
            revtree, file_id = self._infer_file_id(tree)
561
 
            tree.revert([revtree.id2path(file_id)],
562
 
                        old_tree=revtree, backups=False)
563
 
 
564
 
    def action_take_other(self, tree):
565
 
        if self.file_id is not None:
566
 
            self._resolve_with_cleanups(tree, self.file_id,
567
 
                                        self.conflict_path,
568
 
                                        winner='other')
569
 
        else:
570
 
            # Prior to bug #531967 we need to find back the file_id and restore
571
 
            # the content from there
572
 
            revtree, file_id = self._infer_file_id(tree)
573
 
            tree.revert([revtree.id2path(file_id)],
574
 
                        old_tree=revtree, backups=False)
575
 
 
576
323
 
577
324
class ContentsConflict(PathConflict):
578
 
    """The files are of different types (or both binary), or not present"""
 
325
    """The files are of different types, or not present"""
579
326
 
580
327
    has_files = True
581
328
 
583
330
 
584
331
    format = 'Contents conflict in %(path)s'
585
332
 
586
 
    def associated_filenames(self):
587
 
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
588
 
 
589
 
    def _resolve(self, tt, suffix_to_remove):
590
 
        """Resolve the conflict.
591
 
 
592
 
        :param tt: The TreeTransform where the conflict is resolved.
593
 
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
594
 
 
595
 
        The resolution is symmetric: when taking THIS, OTHER is deleted and
596
 
        item.THIS is renamed into item and vice-versa.
597
 
        """
598
 
        try:
599
 
            # Delete 'item.THIS' or 'item.OTHER' depending on
600
 
            # suffix_to_remove
601
 
            tt.delete_contents(
602
 
                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
603
 
        except errors.NoSuchFile:
604
 
            # There are valid cases where 'item.suffix_to_remove' either
605
 
            # never existed or was already deleted (including the case
606
 
            # where the user deleted it)
607
 
            pass
608
 
        try:
609
 
            this_path = tt._tree.id2path(self.file_id)
610
 
        except errors.NoSuchId:
611
 
            # The file is not present anymore. This may happen if the user
612
 
            # deleted the file either manually or when resolving a conflict on
613
 
            # the parent.  We may raise some exception to indicate that the
614
 
            # conflict doesn't exist anymore and as such doesn't need to be
615
 
            # resolved ? -- vila 20110615
616
 
            this_tid = None
617
 
        else:
618
 
            this_tid = tt.trans_id_tree_path(this_path)
619
 
        if this_tid is not None:
620
 
            # Rename 'item.suffix_to_remove' (note that if
621
 
            # 'item.suffix_to_remove' has been deleted, this is a no-op)
622
 
            parent_tid = tt.get_tree_parent(this_tid)
623
 
            tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
624
 
            tt.apply()
625
 
 
626
 
    def action_take_this(self, tree):
627
 
        self._resolve_with_cleanups(tree, 'OTHER')
628
 
 
629
 
    def action_take_other(self, tree):
630
 
        self._resolve_with_cleanups(tree, 'THIS')
631
 
 
632
 
 
633
 
# TODO: There should be a base revid attribute to better inform the user about
634
 
# how the conflicts were generated.
635
 
class TextConflict(Conflict):
 
333
 
 
334
class TextConflict(PathConflict):
636
335
    """The merge algorithm could not resolve all differences encountered."""
637
336
 
638
337
    has_files = True
641
340
 
642
341
    format = 'Text conflict in %(path)s'
643
342
 
644
 
    rformat = '%(class)s(%(path)r, %(file_id)r)'
645
 
 
646
 
    _conflict_re = re.compile(b'^(<{7}|={7}|>{7})')
647
 
 
648
 
    def associated_filenames(self):
649
 
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
650
 
 
651
 
    def _resolve(self, tt, winner_suffix):
652
 
        """Resolve the conflict by copying one of .THIS or .OTHER into file.
653
 
 
654
 
        :param tt: The TreeTransform where the conflict is resolved.
655
 
        :param winner_suffix: Either 'THIS' or 'OTHER'
656
 
 
657
 
        The resolution is symmetric, when taking THIS, item.THIS is renamed
658
 
        into item and vice-versa. This takes one of the files as a whole
659
 
        ignoring every difference that could have been merged cleanly.
660
 
        """
661
 
        # To avoid useless copies, we switch item and item.winner_suffix, only
662
 
        # item will exist after the conflict has been resolved anyway.
663
 
        item_tid = tt.trans_id_file_id(self.file_id)
664
 
        item_parent_tid = tt.get_tree_parent(item_tid)
665
 
        winner_path = self.path + '.' + winner_suffix
666
 
        winner_tid = tt.trans_id_tree_path(winner_path)
667
 
        winner_parent_tid = tt.get_tree_parent(winner_tid)
668
 
        # Switch the paths to preserve the content
669
 
        tt.adjust_path(osutils.basename(self.path),
670
 
                       winner_parent_tid, winner_tid)
671
 
        tt.adjust_path(osutils.basename(winner_path),
672
 
                       item_parent_tid, item_tid)
673
 
        # Associate the file_id to the right content
674
 
        tt.unversion_file(item_tid)
675
 
        tt.version_file(self.file_id, winner_tid)
676
 
        tt.apply()
677
 
 
678
 
    def action_auto(self, tree):
679
 
        # GZ 2012-07-27: Using NotImplementedError to signal that a conflict
680
 
        #                can't be auto resolved does not seem ideal.
681
 
        try:
682
 
            kind = tree.kind(self.path)
683
 
        except errors.NoSuchFile:
684
 
            return
685
 
        if kind != 'file':
686
 
            raise NotImplementedError("Conflict is not a file")
687
 
        conflict_markers_in_line = self._conflict_re.search
688
 
        # GZ 2012-07-27: What if not tree.has_id(self.file_id) due to removal?
689
 
        with tree.get_file(self.path) as f:
690
 
            for line in f:
691
 
                if conflict_markers_in_line(line):
692
 
                    raise NotImplementedError("Conflict markers present")
693
 
 
694
 
    def action_take_this(self, tree):
695
 
        self._resolve_with_cleanups(tree, 'THIS')
696
 
 
697
 
    def action_take_other(self, tree):
698
 
        self._resolve_with_cleanups(tree, 'OTHER')
699
 
 
700
343
 
701
344
class HandledConflict(Conflict):
702
345
    """A path problem that has been provisionally resolved.
704
347
    """
705
348
 
706
349
    rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
707
 
 
 
350
    
708
351
    def __init__(self, action, path, file_id=None):
709
352
        Conflict.__init__(self, path, file_id)
710
353
        self.action = action
717
360
        s.add('action', self.action)
718
361
        return s
719
362
 
720
 
    def associated_filenames(self):
721
 
        # Nothing has been generated here
722
 
        return []
723
 
 
724
363
 
725
364
class HandledPathConflict(HandledConflict):
726
365
    """A provisionally-resolved path problem involving two paths.
733
372
    def __init__(self, action, path, conflict_path, file_id=None,
734
373
                 conflict_file_id=None):
735
374
        HandledConflict.__init__(self, action, path, file_id)
736
 
        self.conflict_path = conflict_path
737
 
        # the factory blindly transfers the Stanza values to __init__,
738
 
        # so they can be unicode.
739
 
        if isinstance(conflict_file_id, text_type):
740
 
            conflict_file_id = cache_utf8.encode(conflict_file_id)
741
 
        self.conflict_file_id = osutils.safe_file_id(conflict_file_id)
742
 
 
 
375
        self.conflict_path = conflict_path 
 
376
        self.conflict_file_id = conflict_file_id
 
377
        
743
378
    def _cmp_list(self):
744
 
        return HandledConflict._cmp_list(self) + [self.conflict_path,
 
379
        return HandledConflict._cmp_list(self) + [self.conflict_path, 
745
380
                                                  self.conflict_file_id]
746
381
 
747
382
    def as_stanza(self):
748
383
        s = HandledConflict.as_stanza(self)
749
384
        s.add('conflict_path', self.conflict_path)
750
385
        if self.conflict_file_id is not None:
751
 
            s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
752
 
 
 
386
            s.add('conflict_file_id', self.conflict_file_id)
 
387
            
753
388
        return s
754
389
 
755
390
 
768
403
 
769
404
    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
770
405
 
771
 
    def action_take_this(self, tree):
772
 
        tree.remove([self.conflict_path], force=True, keep_files=False)
773
 
        tree.rename_one(self.path, self.conflict_path)
774
 
 
775
 
    def action_take_other(self, tree):
776
 
        tree.remove([self.path], force=True, keep_files=False)
777
 
 
778
406
 
779
407
class ParentLoop(HandledPathConflict):
780
408
    """An attempt to create an infinitely-looping directory structure.
781
409
    This is rare, but can be produced like so:
782
410
 
783
411
    tree A:
784
 
      mv foo bar
 
412
      mv foo/bar
785
413
    tree B:
786
 
      mv bar foo
 
414
      mv bar/foo
787
415
    merge A and B
788
416
    """
789
417
 
790
418
    typestring = 'parent loop'
791
419
 
792
 
    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
793
 
 
794
 
    def action_take_this(self, tree):
795
 
        # just acccept brz proposal
796
 
        pass
797
 
 
798
 
    def action_take_other(self, tree):
799
 
        with tree.get_transform() as tt:
800
 
            p_tid = tt.trans_id_file_id(self.file_id)
801
 
            parent_tid = tt.get_tree_parent(p_tid)
802
 
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
803
 
            cparent_tid = tt.get_tree_parent(cp_tid)
804
 
            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
805
 
            tt.adjust_path(osutils.basename(self.conflict_path),
806
 
                           parent_tid, p_tid)
807
 
            tt.apply()
 
420
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
808
421
 
809
422
 
810
423
class UnversionedParent(HandledConflict):
811
 
    """An attempt to version a file whose parent directory is not versioned.
 
424
    """An attempt to version an file whose parent directory is not versioned.
812
425
    Typically, the result of a merge where one tree unversioned the directory
813
426
    and the other added a versioned file to it.
814
427
    """
815
428
 
816
429
    typestring = 'unversioned parent'
817
430
 
818
 
    format = 'Conflict because %(path)s is not versioned, but has versioned'\
819
 
             ' children.  %(action)s.'
820
 
 
821
 
    # FIXME: We silently do nothing to make tests pass, but most probably the
822
 
    # conflict shouldn't exist (the long story is that the conflict is
823
 
    # generated with another one that can be resolved properly) -- vila 091224
824
 
    def action_take_this(self, tree):
825
 
        pass
826
 
 
827
 
    def action_take_other(self, tree):
828
 
        pass
 
431
    format = 'Conflict adding versioned files to %(path)s.  %(action)s.'
829
432
 
830
433
 
831
434
class MissingParent(HandledConflict):
832
435
    """An attempt to add files to a directory that is not present.
833
 
    Typically, the result of a merge where THIS deleted the directory and
834
 
    the OTHER added a file to it.
835
 
    See also: DeletingParent (same situation, THIS and OTHER reversed)
 
436
    Typically, the result of a merge where one tree deleted the directory and
 
437
    the other added a file to it.
836
438
    """
837
439
 
838
440
    typestring = 'missing parent'
839
441
 
840
442
    format = 'Conflict adding files to %(path)s.  %(action)s.'
841
443
 
842
 
    def action_take_this(self, tree):
843
 
        tree.remove([self.path], force=True, keep_files=False)
844
 
 
845
 
    def action_take_other(self, tree):
846
 
        # just acccept brz proposal
847
 
        pass
848
 
 
849
 
 
850
 
class DeletingParent(HandledConflict):
851
 
    """An attempt to add files to a directory that is not present.
852
 
    Typically, the result of a merge where one OTHER deleted the directory and
853
 
    the THIS added a file to it.
854
 
    """
855
 
 
856
 
    typestring = 'deleting parent'
857
 
 
858
 
    format = "Conflict: can't delete %(path)s because it is not empty.  "\
859
 
             "%(action)s."
860
 
 
861
 
    # FIXME: It's a bit strange that the default action is not coherent with
862
 
    # MissingParent from the *user* pov.
863
 
 
864
 
    def action_take_this(self, tree):
865
 
        # just acccept brz proposal
866
 
        pass
867
 
 
868
 
    def action_take_other(self, tree):
869
 
        tree.remove([self.path], force=True, keep_files=False)
870
 
 
871
 
 
872
 
class NonDirectoryParent(HandledConflict):
873
 
    """An attempt to add files to a directory that is not a directory or
874
 
    an attempt to change the kind of a directory with files.
875
 
    """
876
 
 
877
 
    typestring = 'non-directory parent'
878
 
 
879
 
    format = "Conflict: %(path)s is not a directory, but has files in it."\
880
 
             "  %(action)s."
881
 
 
882
 
    # FIXME: .OTHER should be used instead of .new when the conflict is created
883
 
 
884
 
    def action_take_this(self, tree):
885
 
        # FIXME: we should preserve that path when the conflict is generated !
886
 
        if self.path.endswith('.new'):
887
 
            conflict_path = self.path[:-(len('.new'))]
888
 
            tree.remove([self.path], force=True, keep_files=False)
889
 
            tree.add(conflict_path)
890
 
        else:
891
 
            raise NotImplementedError(self.action_take_this)
892
 
 
893
 
    def action_take_other(self, tree):
894
 
        # FIXME: we should preserve that path when the conflict is generated !
895
 
        if self.path.endswith('.new'):
896
 
            conflict_path = self.path[:-(len('.new'))]
897
 
            tree.remove([conflict_path], force=True, keep_files=False)
898
 
            tree.rename_one(self.path, conflict_path)
899
 
        else:
900
 
            raise NotImplementedError(self.action_take_other)
901
444
 
902
445
 
903
446
ctype = {}
911
454
 
912
455
 
913
456
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
914
 
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
915
 
               DeletingParent, NonDirectoryParent)
 
457
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,)