← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Vincent Ladeuil
  • Date: 2007-07-15 11:24:18 UTC
  • mfrom: (2617 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070715112418-9nn4n6esxv60ny4b
merge bzr.dev@1617

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
import errno
19
19
from stat import S_ISREG
20
20
 
 
21
from bzrlib.lazy_import import lazy_import
 
22
lazy_import(globals(), """
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    delta,
 
26
    errors,
 
27
    inventory
 
28
    )
 
29
""")
21
30
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
22
31
                           ReusingTransform, NotVersionedError, CantMoveRoot,
23
 
                           ExistingLimbo, ImmortalLimbo)
 
32
                           ExistingLimbo, ImmortalLimbo, NoFinalPath)
24
33
from bzrlib.inventory import InventoryEntry
25
34
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
26
35
                            delete_any)
27
36
from bzrlib.progress import DummyProgress, ProgressPhase
 
37
from bzrlib.symbol_versioning import deprecated_function, zero_fifteen
28
38
from bzrlib.trace import mutter, warning
29
39
from bzrlib import tree
30
 
import bzrlib.ui 
 
40
import bzrlib.ui
31
41
import bzrlib.urlutils as urlutils
32
42
 
33
43
 
41
51
 
42
52
 
43
53
class _TransformResults(object):
44
 
    def __init__(self, modified_paths):
 
54
    def __init__(self, modified_paths, rename_count):
45
55
        object.__init__(self)
46
56
        self.modified_paths = modified_paths
 
57
        self.rename_count = rename_count
47
58
 
48
59
 
49
60
class TreeTransform(object):
50
61
    """Represent a tree transformation.
51
62
    
52
63
    This object is designed to support incremental generation of the transform,
53
 
    in any order.  
 
64
    in any order.
 
65
 
 
66
    However, it gives optimum performance when parent directories are created
 
67
    before their contents.  The transform is then able to put child files
 
68
    directly in their parent directory, avoiding later renames.
54
69
    
55
70
    It is easy to produce malformed transforms, but they are generally
56
71
    harmless.  Attempting to apply a malformed transform will cause an
72
87
     * set_executability
73
88
    """
74
89
    def __init__(self, tree, pb=DummyProgress()):
75
 
        """Note: a write lock is taken on the tree.
 
90
        """Note: a tree_write lock is taken on the tree.
76
91
        
77
 
        Use TreeTransform.finalize() to release the lock
 
92
        Use TreeTransform.finalize() to release the lock (can be omitted if
 
93
        TreeTransform.apply() called).
78
94
        """
79
95
        object.__init__(self)
80
96
        self._tree = tree
81
 
        self._tree.lock_write()
 
97
        self._tree.lock_tree_write()
82
98
        try:
83
99
            control_files = self._tree._control_files
84
100
            self._limbodir = urlutils.local_path_from_url(
96
112
        self._new_name = {}
97
113
        self._new_parent = {}
98
114
        self._new_contents = {}
 
115
        # A mapping of transform ids to their limbo filename
 
116
        self._limbo_files = {}
 
117
        # A mapping of transform ids to a set of the transform ids of children
 
118
        # that their limbo directory has
 
119
        self._limbo_children = {}
 
120
        # Map transform ids to maps of child filename to child transform id
 
121
        self._limbo_children_names = {}
 
122
        # List of transform ids that need to be renamed from limbo into place
 
123
        self._needs_rename = set()
99
124
        self._removed_contents = set()
100
125
        self._new_executability = {}
 
126
        self._new_reference_revision = {}
101
127
        self._new_id = {}
102
128
        self._non_present_ids = {}
103
129
        self._r_new_id = {}
104
130
        self._removed_id = set()
105
131
        self._tree_path_ids = {}
106
132
        self._tree_id_paths = {}
 
133
        # Cache of realpath results, to speed up canonical_path
107
134
        self._realpaths = {}
108
 
        # Cache of realpath results, to speed up canonical_path
 
135
        # Cache of relpath results, to speed up canonical_path
109
136
        self._relpaths = {}
110
 
        # Cache of relpath results, to speed up canonical_path
111
137
        self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
112
138
        self.__done = False
113
139
        self._pb = pb
 
140
        self.rename_count = 0
114
141
 
115
142
    def __get_root(self):
116
143
        return self._new_root
118
145
    root = property(__get_root)
119
146
 
120
147
    def finalize(self):
121
 
        """Release the working tree lock, if held, clean up limbo dir."""
 
148
        """Release the working tree lock, if held, clean up limbo dir.
 
149
 
 
150
        This is required if apply has not been invoked, but can be invoked
 
151
        even after apply.
 
152
        """
122
153
        if self._tree is None:
123
154
            return
124
155
        try:
125
 
            for trans_id, kind in self._new_contents.iteritems():
126
 
                path = self._limbo_name(trans_id)
 
156
            entries = [(self._limbo_name(t), t, k) for t, k in
 
157
                       self._new_contents.iteritems()]
 
158
            entries.sort(reverse=True)
 
159
            for path, trans_id, kind in entries:
127
160
                if kind == "directory":
128
161
                    os.rmdir(path)
129
162
                else:
154
187
        """Change the path that is assigned to a transaction id."""
155
188
        if trans_id == self._new_root:
156
189
            raise CantMoveRoot
 
190
        previous_parent = self._new_parent.get(trans_id)
 
191
        previous_name = self._new_name.get(trans_id)
157
192
        self._new_name[trans_id] = name
158
193
        self._new_parent[trans_id] = parent
 
194
        if (trans_id in self._limbo_files and
 
195
            trans_id not in self._needs_rename):
 
196
            self._rename_in_limbo([trans_id])
 
197
            self._limbo_children[previous_parent].remove(trans_id)
 
198
            del self._limbo_children_names[previous_parent][previous_name]
 
199
 
 
200
    def _rename_in_limbo(self, trans_ids):
 
201
        """Fix limbo names so that the right final path is produced.
 
202
 
 
203
        This means we outsmarted ourselves-- we tried to avoid renaming
 
204
        these files later by creating them with their final names in their
 
205
        final parents.  But now the previous name or parent is no longer
 
206
        suitable, so we have to rename them.
 
207
 
 
208
        Even for trans_ids that have no new contents, we must remove their
 
209
        entries from _limbo_files, because they are now stale.
 
210
        """
 
211
        for trans_id in trans_ids:
 
212
            old_path = self._limbo_files.pop(trans_id)
 
213
            if trans_id not in self._new_contents:
 
214
                continue
 
215
            new_path = self._limbo_name(trans_id)
 
216
            os.rename(old_path, new_path)
159
217
 
160
218
    def adjust_root_path(self, name, parent):
161
219
        """Emulate moving the root by moving all children, instead.
272
330
                os.unlink(name)
273
331
                raise
274
332
 
275
 
            for segment in contents:
276
 
                f.write(segment)
 
333
            f.writelines(contents)
277
334
        finally:
278
335
            f.close()
279
336
        self._set_mode(trans_id, mode_id, S_ISREG)
291
348
        except KeyError:
292
349
            return
293
350
        try:
294
 
            mode = os.stat(old_path).st_mode
 
351
            mode = os.stat(self._tree.abspath(old_path)).st_mode
295
352
        except OSError, e:
296
353
            if e.errno == errno.ENOENT:
297
354
                return
320
377
    def cancel_creation(self, trans_id):
321
378
        """Cancel the creation of new file contents."""
322
379
        del self._new_contents[trans_id]
 
380
        children = self._limbo_children.get(trans_id)
 
381
        # if this is a limbo directory with children, move them before removing
 
382
        # the directory
 
383
        if children is not None:
 
384
            self._rename_in_limbo(children)
 
385
            del self._limbo_children[trans_id]
 
386
            del self._limbo_children_names[trans_id]
323
387
        delete_any(self._limbo_name(trans_id))
324
388
 
325
389
    def delete_contents(self, trans_id):
349
413
        else:
350
414
            unique_add(self._new_executability, trans_id, executability)
351
415
 
 
416
    def set_tree_reference(self, revision_id, trans_id):
 
417
        """Set the reference associated with a directory"""
 
418
        unique_add(self._new_reference_revision, trans_id, revision_id)
 
419
 
352
420
    def version_file(self, file_id, trans_id):
353
421
        """Schedule a file to become versioned."""
354
422
        assert file_id is not None
456
524
        try:
457
525
            return self._new_name[trans_id]
458
526
        except KeyError:
459
 
            return os.path.basename(self._tree_id_paths[trans_id])
 
527
            try:
 
528
                return os.path.basename(self._tree_id_paths[trans_id])
 
529
            except KeyError:
 
530
                raise NoFinalPath(trans_id, self)
460
531
 
461
532
    def by_parent(self):
462
533
        """Return a map of parent: children for known parents.
475
546
 
476
547
    def path_changed(self, trans_id):
477
548
        """Return True if a trans_id's path has changed."""
478
 
        return trans_id in self._new_name or trans_id in self._new_parent
 
549
        return (trans_id in self._new_name) or (trans_id in self._new_parent)
 
550
 
 
551
    def new_contents(self, trans_id):
 
552
        return (trans_id in self._new_contents)
479
553
 
480
554
    def find_conflicts(self):
481
555
        """Find any violations of inventory or filesystem invariants"""
507
581
                        self.tree_kind(t) == 'directory'])
508
582
        for trans_id in self._removed_id:
509
583
            file_id = self.tree_file_id(trans_id)
510
 
            if self._tree.inventory[file_id].kind in ('directory', 
511
 
                                                      'root_directory'):
 
584
            if self._tree.inventory[file_id].kind == 'directory':
512
585
                parents.append(trans_id)
513
586
 
514
587
        for parent_id in parents:
567
640
            parent_id = trans_id
568
641
            while parent_id is not ROOT_PARENT:
569
642
                seen.add(parent_id)
570
 
                parent_id = self.final_parent(parent_id)
 
643
                try:
 
644
                    parent_id = self.final_parent(parent_id)
 
645
                except KeyError:
 
646
                    break
571
647
                if parent_id == trans_id:
572
648
                    conflicts.append(('parent loop', trans_id))
573
649
                if parent_id in seen:
641
717
    def _duplicate_entries(self, by_parent):
642
718
        """No directory may have two entries with the same name."""
643
719
        conflicts = []
 
720
        if (self._new_name, self._new_parent) == ({}, {}):
 
721
            return conflicts
644
722
        for children in by_parent.itervalues():
645
723
            name_ids = [(self.final_name(t), t) for t in children]
646
724
            name_ids.sort()
647
725
            last_name = None
648
726
            last_trans_id = None
649
727
            for name, trans_id in name_ids:
 
728
                try:
 
729
                    kind = self.final_kind(trans_id)
 
730
                except NoSuchFile:
 
731
                    kind = None
 
732
                file_id = self.final_file_id(trans_id)
 
733
                if kind is None and file_id is None:
 
734
                    continue
650
735
                if name == last_name:
651
736
                    conflicts.append(('duplicate', last_trans_id, trans_id,
652
737
                    name))
653
 
                try:
654
 
                    kind = self.final_kind(trans_id)
655
 
                except NoSuchFile:
656
 
                    kind = None
657
 
                file_id = self.final_file_id(trans_id)
658
 
                if kind is not None or file_id is not None:
659
 
                    last_name = name
660
 
                    last_trans_id = trans_id
 
738
                last_name = name
 
739
                last_trans_id = trans_id
661
740
        return conflicts
662
741
 
663
742
    def _duplicate_ids(self):
706
785
            return True
707
786
        return False
708
787
            
709
 
    def apply(self):
 
788
    def apply(self, no_conflicts=False):
710
789
        """Apply all changes to the inventory and filesystem.
711
790
        
712
791
        If filesystem or inventory conflicts are present, MalformedTransform
713
792
        will be thrown.
 
793
 
 
794
        If apply succeeds, finalize is not necessary.
 
795
 
 
796
        :param no_conflicts: if True, the caller guarantees there are no
 
797
            conflicts, so no check is made.
714
798
        """
715
 
        conflicts = self.find_conflicts()
716
 
        if len(conflicts) != 0:
717
 
            raise MalformedTransform(conflicts=conflicts)
718
 
        limbo_inv = {}
 
799
        if not no_conflicts:
 
800
            conflicts = self.find_conflicts()
 
801
            if len(conflicts) != 0:
 
802
                raise MalformedTransform(conflicts=conflicts)
719
803
        inv = self._tree.inventory
 
804
        inventory_delta = []
720
805
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
721
806
        try:
722
807
            child_pb.update('Apply phase', 0, 2)
723
 
            self._apply_removals(inv, limbo_inv)
 
808
            self._apply_removals(inv, inventory_delta)
724
809
            child_pb.update('Apply phase', 1, 2)
725
 
            modified_paths = self._apply_insertions(inv, limbo_inv)
 
810
            modified_paths = self._apply_insertions(inv, inventory_delta)
726
811
        finally:
727
812
            child_pb.finished()
728
 
        self._tree._write_inventory(inv)
 
813
        self._tree.apply_inventory_delta(inventory_delta)
729
814
        self.__done = True
730
815
        self.finalize()
731
 
        return _TransformResults(modified_paths)
 
816
        return _TransformResults(modified_paths, self.rename_count)
732
817
 
733
818
    def _limbo_name(self, trans_id):
734
819
        """Generate the limbo name of a file"""
735
 
        return pathjoin(self._limbodir, trans_id)
 
820
        limbo_name = self._limbo_files.get(trans_id)
 
821
        if limbo_name is not None:
 
822
            return limbo_name
 
823
        parent = self._new_parent.get(trans_id)
 
824
        # if the parent directory is already in limbo (e.g. when building a
 
825
        # tree), choose a limbo name inside the parent, to reduce further
 
826
        # renames.
 
827
        use_direct_path = False
 
828
        if self._new_contents.get(parent) == 'directory':
 
829
            filename = self._new_name.get(trans_id)
 
830
            if filename is not None:
 
831
                if parent not in self._limbo_children:
 
832
                    self._limbo_children[parent] = set()
 
833
                    self._limbo_children_names[parent] = {}
 
834
                    use_direct_path = True
 
835
                # the direct path can only be used if no other file has
 
836
                # already taken this pathname, i.e. if the name is unused, or
 
837
                # if it is already associated with this trans_id.
 
838
                elif (self._limbo_children_names[parent].get(filename)
 
839
                      in (trans_id, None)):
 
840
                    use_direct_path = True
 
841
        if use_direct_path:
 
842
            limbo_name = pathjoin(self._limbo_files[parent], filename)
 
843
            self._limbo_children[parent].add(trans_id)
 
844
            self._limbo_children_names[parent][filename] = trans_id
 
845
        else:
 
846
            limbo_name = pathjoin(self._limbodir, trans_id)
 
847
            self._needs_rename.add(trans_id)
 
848
        self._limbo_files[trans_id] = limbo_name
 
849
        return limbo_name
736
850
 
737
 
    def _apply_removals(self, inv, limbo_inv):
 
851
    def _apply_removals(self, inv, inventory_delta):
738
852
        """Perform tree operations that remove directory/inventory names.
739
853
        
740
854
        That is, delete files that are to be deleted, and put any files that
758
872
                    except OSError, e:
759
873
                        if e.errno != errno.ENOENT:
760
874
                            raise
 
875
                    else:
 
876
                        self.rename_count += 1
761
877
                if trans_id in self._removed_id:
762
878
                    if trans_id == self._new_root:
763
879
                        file_id = self._tree.inventory.root.file_id
764
880
                    else:
765
881
                        file_id = self.tree_file_id(trans_id)
766
 
                    del inv[file_id]
767
 
                elif trans_id in self._new_name or trans_id in self._new_parent:
768
 
                    file_id = self.tree_file_id(trans_id)
769
 
                    if file_id is not None:
770
 
                        limbo_inv[trans_id] = inv[file_id]
771
 
                        del inv[file_id]
 
882
                    assert file_id is not None
 
883
                    inventory_delta.append((path, None, file_id, None))
772
884
        finally:
773
885
            child_pb.finished()
774
886
 
775
 
    def _apply_insertions(self, inv, limbo_inv):
 
887
    def _apply_insertions(self, inv, inventory_delta):
776
888
        """Perform tree operations that insert directory/inventory names.
777
889
        
778
890
        That is, create any files that need to be created, and restore from
784
896
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
785
897
        try:
786
898
            for num, (path, trans_id) in enumerate(new_paths):
 
899
                new_entry = None
787
900
                child_pb.update('adding file', num, len(new_paths))
788
901
                try:
789
902
                    kind = self._new_contents[trans_id]
792
905
                if trans_id in self._new_contents or \
793
906
                    self.path_changed(trans_id):
794
907
                    full_path = self._tree.abspath(path)
795
 
                    try:
796
 
                        os.rename(self._limbo_name(trans_id), full_path)
797
 
                    except OSError, e:
798
 
                        # We may be renaming a dangling inventory id
799
 
                        if e.errno != errno.ENOENT:
800
 
                            raise
 
908
                    if trans_id in self._needs_rename:
 
909
                        try:
 
910
                            os.rename(self._limbo_name(trans_id), full_path)
 
911
                        except OSError, e:
 
912
                            # We may be renaming a dangling inventory id
 
913
                            if e.errno != errno.ENOENT:
 
914
                                raise
 
915
                        else:
 
916
                            self.rename_count += 1
801
917
                    if trans_id in self._new_contents:
802
918
                        modified_paths.append(full_path)
803
919
                        del self._new_contents[trans_id]
805
921
                if trans_id in self._new_id:
806
922
                    if kind is None:
807
923
                        kind = file_kind(self._tree.abspath(path))
808
 
                    inv.add_path(path, kind, self._new_id[trans_id])
809
 
                elif trans_id in self._new_name or trans_id in\
810
 
                    self._new_parent:
811
 
                    entry = limbo_inv.get(trans_id)
812
 
                    if entry is not None:
813
 
                        entry.name = self.final_name(trans_id)
814
 
                        parent_path = os.path.dirname(path)
815
 
                        entry.parent_id = \
816
 
                            self._tree.inventory.path2id(parent_path)
817
 
                        inv.add(entry)
818
 
 
819
 
                # requires files and inventory entries to be in place
 
924
                    if trans_id in self._new_reference_revision:
 
925
                        new_entry = inventory.TreeReference(
 
926
                            self._new_id[trans_id],
 
927
                            self._new_name[trans_id], 
 
928
                            self.final_file_id(self._new_parent[trans_id]),
 
929
                            None, self._new_reference_revision[trans_id])
 
930
                    else:
 
931
                        new_entry = inventory.make_entry(kind,
 
932
                            self.final_name(trans_id),
 
933
                            self.final_file_id(self.final_parent(trans_id)),
 
934
                            self._new_id[trans_id])
 
935
                else:
 
936
                    if trans_id in self._new_name or trans_id in\
 
937
                        self._new_parent or\
 
938
                        trans_id in self._new_executability:
 
939
                        file_id = self.final_file_id(trans_id)
 
940
                        if file_id is not None:
 
941
                            entry = inv[file_id]
 
942
                            new_entry = entry.copy()
 
943
 
 
944
                    if trans_id in self._new_name or trans_id in\
 
945
                        self._new_parent:
 
946
                            if new_entry is not None:
 
947
                                new_entry.name = self.final_name(trans_id)
 
948
                                parent = self.final_parent(trans_id)
 
949
                                parent_id = self.final_file_id(parent)
 
950
                                new_entry.parent_id = parent_id
 
951
 
820
952
                if trans_id in self._new_executability:
821
 
                    self._set_executability(path, inv, trans_id)
 
953
                    self._set_executability(path, new_entry, trans_id)
 
954
                if new_entry is not None:
 
955
                    if new_entry.file_id in inv:
 
956
                        old_path = inv.id2path(new_entry.file_id)
 
957
                    else:
 
958
                        old_path = None
 
959
                    inventory_delta.append((old_path, path,
 
960
                                            new_entry.file_id,
 
961
                                            new_entry))
822
962
        finally:
823
963
            child_pb.finished()
824
964
        return modified_paths
825
965
 
826
 
    def _set_executability(self, path, inv, trans_id):
 
966
    def _set_executability(self, path, entry, trans_id):
827
967
        """Set the executability of versioned files """
828
 
        file_id = inv.path2id(path)
829
968
        new_executability = self._new_executability[trans_id]
830
 
        inv[file_id].executable = new_executability
 
969
        entry.executable = new_executability
831
970
        if supports_executable():
832
971
            abspath = self._tree.abspath(path)
833
972
            current_mode = os.stat(abspath).st_mode
894
1033
        self.create_symlink(target, trans_id)
895
1034
        return trans_id
896
1035
 
 
1036
    def _affected_ids(self):
 
1037
        """Return the set of transform ids affected by the transform"""
 
1038
        trans_ids = set(self._removed_id)
 
1039
        trans_ids.update(self._new_id.keys())
 
1040
        trans_ids.update(self._removed_contents)
 
1041
        trans_ids.update(self._new_contents.keys())
 
1042
        trans_ids.update(self._new_executability.keys())
 
1043
        trans_ids.update(self._new_name.keys())
 
1044
        trans_ids.update(self._new_parent.keys())
 
1045
        return trans_ids
 
1046
 
 
1047
    def _get_file_id_maps(self):
 
1048
        """Return mapping of file_ids to trans_ids in the to and from states"""
 
1049
        trans_ids = self._affected_ids()
 
1050
        from_trans_ids = {}
 
1051
        to_trans_ids = {}
 
1052
        # Build up two dicts: trans_ids associated with file ids in the
 
1053
        # FROM state, vs the TO state.
 
1054
        for trans_id in trans_ids:
 
1055
            from_file_id = self.tree_file_id(trans_id)
 
1056
            if from_file_id is not None:
 
1057
                from_trans_ids[from_file_id] = trans_id
 
1058
            to_file_id = self.final_file_id(trans_id)
 
1059
            if to_file_id is not None:
 
1060
                to_trans_ids[to_file_id] = trans_id
 
1061
        return from_trans_ids, to_trans_ids
 
1062
 
 
1063
    def _from_file_data(self, from_trans_id, from_versioned, file_id):
 
1064
        """Get data about a file in the from (tree) state
 
1065
 
 
1066
        Return a (name, parent, kind, executable) tuple
 
1067
        """
 
1068
        from_path = self._tree_id_paths.get(from_trans_id)
 
1069
        if from_versioned:
 
1070
            # get data from working tree if versioned
 
1071
            from_entry = self._tree.inventory[file_id]
 
1072
            from_name = from_entry.name
 
1073
            from_parent = from_entry.parent_id
 
1074
        else:
 
1075
            from_entry = None
 
1076
            if from_path is None:
 
1077
                # File does not exist in FROM state
 
1078
                from_name = None
 
1079
                from_parent = None
 
1080
            else:
 
1081
                # File exists, but is not versioned.  Have to use path-
 
1082
                # splitting stuff
 
1083
                from_name = os.path.basename(from_path)
 
1084
                tree_parent = self.get_tree_parent(from_trans_id)
 
1085
                from_parent = self.tree_file_id(tree_parent)
 
1086
        if from_path is not None:
 
1087
            from_kind, from_executable, from_stats = \
 
1088
                self._tree._comparison_data(from_entry, from_path)
 
1089
        else:
 
1090
            from_kind = None
 
1091
            from_executable = False
 
1092
        return from_name, from_parent, from_kind, from_executable
 
1093
 
 
1094
    def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
 
1095
        """Get data about a file in the to (target) state
 
1096
 
 
1097
        Return a (name, parent, kind, executable) tuple
 
1098
        """
 
1099
        to_name = self.final_name(to_trans_id)
 
1100
        try:
 
1101
            to_kind = self.final_kind(to_trans_id)
 
1102
        except NoSuchFile:
 
1103
            to_kind = None
 
1104
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
 
1105
        if to_trans_id in self._new_executability:
 
1106
            to_executable = self._new_executability[to_trans_id]
 
1107
        elif to_trans_id == from_trans_id:
 
1108
            to_executable = from_executable
 
1109
        else:
 
1110
            to_executable = False
 
1111
        return to_name, to_parent, to_kind, to_executable
 
1112
 
 
1113
    def _iter_changes(self):
 
1114
        """Produce output in the same format as Tree._iter_changes.
 
1115
 
 
1116
        Will produce nonsensical results if invoked while inventory/filesystem
 
1117
        conflicts (as reported by TreeTransform.find_conflicts()) are present.
 
1118
 
 
1119
        This reads the Transform, but only reproduces changes involving a
 
1120
        file_id.  Files that are not versioned in either of the FROM or TO
 
1121
        states are not reflected.
 
1122
        """
 
1123
        final_paths = FinalPaths(self)
 
1124
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
 
1125
        results = []
 
1126
        # Now iterate through all active file_ids
 
1127
        for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
 
1128
            modified = False
 
1129
            from_trans_id = from_trans_ids.get(file_id)
 
1130
            # find file ids, and determine versioning state
 
1131
            if from_trans_id is None:
 
1132
                from_versioned = False
 
1133
                from_trans_id = to_trans_ids[file_id]
 
1134
            else:
 
1135
                from_versioned = True
 
1136
            to_trans_id = to_trans_ids.get(file_id)
 
1137
            if to_trans_id is None:
 
1138
                to_versioned = False
 
1139
                to_trans_id = from_trans_id
 
1140
            else:
 
1141
                to_versioned = True
 
1142
 
 
1143
            from_name, from_parent, from_kind, from_executable = \
 
1144
                self._from_file_data(from_trans_id, from_versioned, file_id)
 
1145
 
 
1146
            to_name, to_parent, to_kind, to_executable = \
 
1147
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
 
1148
 
 
1149
            if not from_versioned:
 
1150
                from_path = None
 
1151
            else:
 
1152
                from_path = self._tree_id_paths.get(from_trans_id)
 
1153
            if not to_versioned:
 
1154
                to_path = None
 
1155
            else:
 
1156
                to_path = final_paths.get_path(to_trans_id)
 
1157
            if from_kind != to_kind:
 
1158
                modified = True
 
1159
            elif to_kind in ('file', 'symlink') and (
 
1160
                to_trans_id != from_trans_id or
 
1161
                to_trans_id in self._new_contents):
 
1162
                modified = True
 
1163
            if (not modified and from_versioned == to_versioned and
 
1164
                from_parent==to_parent and from_name == to_name and
 
1165
                from_executable == to_executable):
 
1166
                continue
 
1167
            results.append((file_id, (from_path, to_path), modified,
 
1168
                   (from_versioned, to_versioned),
 
1169
                   (from_parent, to_parent),
 
1170
                   (from_name, to_name),
 
1171
                   (from_kind, to_kind),
 
1172
                   (from_executable, to_executable)))
 
1173
        return iter(sorted(results, key=lambda x:x[1]))
 
1174
 
 
1175
 
897
1176
def joinpath(parent, child):
898
1177
    """Join tree-relative paths, handling the tree root specially"""
899
1178
    if parent is None or parent == "":
935
1214
    file_ids.sort(key=tree.id2path)
936
1215
    return file_ids
937
1216
 
 
1217
 
938
1218
def build_tree(tree, wt):
939
 
    """Create working tree for a branch, using a Transaction."""
 
1219
    """Create working tree for a branch, using a TreeTransform.
 
1220
    
 
1221
    This function should be used on empty trees, having a tree root at most.
 
1222
    (see merge and revert functionality for working with existing trees)
 
1223
 
 
1224
    Existing files are handled like so:
 
1225
    
 
1226
    - Existing bzrdirs take precedence over creating new items.  They are
 
1227
      created as '%s.diverted' % name.
 
1228
    - Otherwise, if the content on disk matches the content we are building,
 
1229
      it is silently replaced.
 
1230
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
 
1231
    """
 
1232
    wt.lock_tree_write()
 
1233
    try:
 
1234
        tree.lock_read()
 
1235
        try:
 
1236
            return _build_tree(tree, wt)
 
1237
        finally:
 
1238
            tree.unlock()
 
1239
    finally:
 
1240
        wt.unlock()
 
1241
 
 
1242
def _build_tree(tree, wt):
 
1243
    """See build_tree."""
 
1244
    if len(wt.inventory) > 1:  # more than just a root
 
1245
        raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
940
1246
    file_trans_id = {}
941
1247
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
942
1248
    pp = ProgressPhase("Build phase", 2, top_pb)
 
1249
    if tree.inventory.root is not None:
 
1250
        # This is kind of a hack: we should be altering the root
 
1251
        # as part of the regular tree shape diff logic.
 
1252
        # The conditional test here is to avoid doing an
 
1253
        # expensive operation (flush) every time the root id
 
1254
        # is set within the tree, nor setting the root and thus
 
1255
        # marking the tree as dirty, because we use two different
 
1256
        # idioms here: tree interfaces and inventory interfaces.
 
1257
        if wt.path2id('') != tree.inventory.root.file_id:
 
1258
            wt.set_root_id(tree.inventory.root.file_id)
 
1259
            wt.flush()
943
1260
    tt = TreeTransform(wt)
 
1261
    divert = set()
944
1262
    try:
945
1263
        pp.next_phase()
946
 
        file_trans_id[wt.get_root_id()] = tt.trans_id_tree_file_id(wt.get_root_id())
947
 
        file_ids = topology_sorted_ids(tree)
 
1264
        file_trans_id[wt.get_root_id()] = \
 
1265
            tt.trans_id_tree_file_id(wt.get_root_id())
948
1266
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
949
1267
        try:
950
 
            for num, file_id in enumerate(file_ids):
951
 
                pb.update("Building tree", num, len(file_ids))
952
 
                entry = tree.inventory[file_id]
 
1268
            for num, (tree_path, entry) in \
 
1269
                enumerate(tree.inventory.iter_entries_by_dir()):
 
1270
                pb.update("Building tree", num, len(tree.inventory))
953
1271
                if entry.parent_id is None:
954
1272
                    continue
 
1273
                reparent = False
 
1274
                file_id = entry.file_id
 
1275
                target_path = wt.abspath(tree_path)
 
1276
                try:
 
1277
                    kind = file_kind(target_path)
 
1278
                except NoSuchFile:
 
1279
                    pass
 
1280
                else:
 
1281
                    if kind == "directory":
 
1282
                        try:
 
1283
                            bzrdir.BzrDir.open(target_path)
 
1284
                        except errors.NotBranchError:
 
1285
                            pass
 
1286
                        else:
 
1287
                            divert.add(file_id)
 
1288
                    if (file_id not in divert and
 
1289
                        _content_match(tree, entry, file_id, kind,
 
1290
                        target_path)):
 
1291
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
 
1292
                        if kind == 'directory':
 
1293
                            reparent = True
955
1294
                if entry.parent_id not in file_trans_id:
956
 
                    raise repr(entry.parent_id)
 
1295
                    raise AssertionError(
 
1296
                        'entry %s parent id %r is not in file_trans_id %r'
 
1297
                        % (entry, entry.parent_id, file_trans_id))
957
1298
                parent_id = file_trans_id[entry.parent_id]
958
 
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id, 
 
1299
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
959
1300
                                                      tree)
 
1301
                if reparent:
 
1302
                    new_trans_id = file_trans_id[file_id]
 
1303
                    old_parent = tt.trans_id_tree_path(tree_path)
 
1304
                    _reparent_children(tt, old_parent, new_trans_id)
960
1305
        finally:
961
1306
            pb.finished()
962
1307
        pp.next_phase()
963
 
        tt.apply()
 
1308
        divert_trans = set(file_trans_id[f] for f in divert)
 
1309
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
 
1310
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
 
1311
        conflicts = cook_conflicts(raw_conflicts, tt)
 
1312
        for conflict in conflicts:
 
1313
            warning(conflict)
 
1314
        try:
 
1315
            wt.add_conflicts(conflicts)
 
1316
        except errors.UnsupportedOperation:
 
1317
            pass
 
1318
        result = tt.apply()
964
1319
    finally:
965
1320
        tt.finalize()
966
1321
        top_pb.finished()
 
1322
    return result
 
1323
 
 
1324
 
 
1325
def _reparent_children(tt, old_parent, new_parent):
 
1326
    for child in tt.iter_tree_children(old_parent):
 
1327
        tt.adjust_path(tt.final_name(child), new_parent, child)
 
1328
 
 
1329
 
 
1330
def _content_match(tree, entry, file_id, kind, target_path):
 
1331
    if entry.kind != kind:
 
1332
        return False
 
1333
    if entry.kind == "directory":
 
1334
        return True
 
1335
    if entry.kind == "file":
 
1336
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
 
1337
            return True
 
1338
    elif entry.kind == "symlink":
 
1339
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
 
1340
            return True
 
1341
    return False
 
1342
 
 
1343
 
 
1344
def resolve_checkout(tt, conflicts, divert):
 
1345
    new_conflicts = set()
 
1346
    for c_type, conflict in ((c[0], c) for c in conflicts):
 
1347
        # Anything but a 'duplicate' would indicate programmer error
 
1348
        assert c_type == 'duplicate', c_type
 
1349
        # Now figure out which is new and which is old
 
1350
        if tt.new_contents(conflict[1]):
 
1351
            new_file = conflict[1]
 
1352
            old_file = conflict[2]
 
1353
        else:
 
1354
            new_file = conflict[2]
 
1355
            old_file = conflict[1]
 
1356
 
 
1357
        # We should only get here if the conflict wasn't completely
 
1358
        # resolved
 
1359
        final_parent = tt.final_parent(old_file)
 
1360
        if new_file in divert:
 
1361
            new_name = tt.final_name(old_file)+'.diverted'
 
1362
            tt.adjust_path(new_name, final_parent, new_file)
 
1363
            new_conflicts.add((c_type, 'Diverted to',
 
1364
                               new_file, old_file))
 
1365
        else:
 
1366
            new_name = tt.final_name(old_file)+'.moved'
 
1367
            tt.adjust_path(new_name, final_parent, old_file)
 
1368
            new_conflicts.add((c_type, 'Moved existing file to',
 
1369
                               old_file, new_file))
 
1370
    return new_conflicts
 
1371
 
967
1372
 
968
1373
def new_by_entry(tt, entry, parent_id, tree):
969
1374
    """Create a new file according to its inventory entry"""
974
1379
        executable = tree.is_executable(entry.file_id)
975
1380
        return tt.new_file(name, parent_id, contents, entry.file_id, 
976
1381
                           executable)
977
 
    elif kind == 'directory':
978
 
        return tt.new_directory(name, parent_id, entry.file_id)
 
1382
    elif kind in ('directory', 'tree-reference'):
 
1383
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
 
1384
        if kind == 'tree-reference':
 
1385
            tt.set_tree_reference(entry.reference_revision, trans_id)
 
1386
        return trans_id 
979
1387
    elif kind == 'symlink':
980
1388
        target = tree.get_symlink_target(entry.file_id)
981
1389
        return tt.new_symlink(name, parent_id, target, entry.file_id)
 
1390
    else:
 
1391
        raise errors.BadFileKindError(name, kind)
982
1392
 
983
1393
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
984
1394
    """Create new file contents according to an inventory entry."""
985
1395
    if entry.kind == "file":
986
 
        if lines == None:
 
1396
        if lines is None:
987
1397
            lines = tree.get_file(entry.file_id).readlines()
988
1398
        tt.create_file(lines, trans_id, mode_id=mode_id)
989
1399
    elif entry.kind == "symlink":
997
1407
        tt.set_executability(entry.executable, trans_id)
998
1408
 
999
1409
 
 
1410
@deprecated_function(zero_fifteen)
1000
1411
def find_interesting(working_tree, target_tree, filenames):
1001
 
    """Find the ids corresponding to specified filenames."""
1002
 
    trees = (working_tree, target_tree)
1003
 
    return tree.find_ids_across_trees(filenames, trees)
 
1412
    """Find the ids corresponding to specified filenames.
 
1413
    
 
1414
    Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
 
1415
    """
 
1416
    working_tree.lock_read()
 
1417
    try:
 
1418
        target_tree.lock_read()
 
1419
        try:
 
1420
            return working_tree.paths2ids(filenames, [target_tree])
 
1421
        finally:
 
1422
            target_tree.unlock()
 
1423
    finally:
 
1424
        working_tree.unlock()
1004
1425
 
1005
1426
 
1006
1427
def change_entry(tt, file_id, working_tree, target_tree, 
1044
1465
 
1045
1466
 
1046
1467
def get_backup_name(entry, by_parent, parent_trans_id, tt):
 
1468
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
 
1469
 
 
1470
 
 
1471
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1047
1472
    """Produce a backup-style name that appears to be available"""
1048
1473
    def name_gen():
1049
1474
        counter = 1
1050
1475
        while True:
1051
 
            yield "%s.~%d~" % (entry.name, counter)
 
1476
            yield "%s.~%d~" % (name, counter)
1052
1477
            counter += 1
1053
 
    for name in name_gen():
1054
 
        if not tt.has_named_child(by_parent, parent_trans_id, name):
1055
 
            return name
 
1478
    for new_name in name_gen():
 
1479
        if not tt.has_named_child(by_parent, parent_trans_id, new_name):
 
1480
            return new_name
 
1481
 
1056
1482
 
1057
1483
def _entry_changes(file_id, entry, working_tree):
1058
1484
    """Determine in which ways the inventory entry has changed.
1071
1497
        contents_mod = True
1072
1498
        meta_mod = False
1073
1499
    if has_contents is True:
1074
 
        real_e_kind = entry.kind
1075
 
        if real_e_kind == 'root_directory':
1076
 
            real_e_kind = 'directory'
1077
 
        if real_e_kind != working_kind:
 
1500
        if entry.kind != working_kind:
1078
1501
            contents_mod, meta_mod = True, False
1079
1502
        else:
1080
1503
            cur_entry._read_tree_state(working_tree.id2path(file_id), 
1084
1507
    return has_contents, contents_mod, meta_mod
1085
1508
 
1086
1509
 
1087
 
def revert(working_tree, target_tree, filenames, backups=False, 
1088
 
           pb=DummyProgress()):
 
1510
def revert(working_tree, target_tree, filenames, backups=False,
 
1511
           pb=DummyProgress(), change_reporter=None):
1089
1512
    """Revert a working tree's contents to those of a target tree."""
1090
 
    interesting_ids = find_interesting(working_tree, target_tree, filenames)
1091
 
    def interesting(file_id):
1092
 
        return interesting_ids is None or file_id in interesting_ids
1093
 
 
 
1513
    target_tree.lock_read()
1094
1514
    tt = TreeTransform(working_tree, pb)
1095
1515
    try:
1096
 
        merge_modified = working_tree.merge_modified()
1097
 
        trans_id = {}
1098
 
        def trans_id_file_id(file_id):
1099
 
            try:
1100
 
                return trans_id[file_id]
1101
 
            except KeyError:
1102
 
                return tt.trans_id_tree_file_id(file_id)
1103
 
 
1104
 
        pp = ProgressPhase("Revert phase", 4, pb)
1105
 
        pp.next_phase()
1106
 
        sorted_interesting = [i for i in topology_sorted_ids(target_tree) if
1107
 
                              interesting(i)]
1108
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1109
 
        try:
1110
 
            by_parent = tt.by_parent()
1111
 
            for id_num, file_id in enumerate(sorted_interesting):
1112
 
                child_pb.update("Reverting file", id_num+1, 
1113
 
                                len(sorted_interesting))
1114
 
                if file_id not in working_tree.inventory:
1115
 
                    entry = target_tree.inventory[file_id]
1116
 
                    parent_id = trans_id_file_id(entry.parent_id)
1117
 
                    e_trans_id = new_by_entry(tt, entry, parent_id, target_tree)
1118
 
                    trans_id[file_id] = e_trans_id
1119
 
                else:
1120
 
                    backup_this = backups
1121
 
                    if file_id in merge_modified:
1122
 
                        backup_this = False
1123
 
                        del merge_modified[file_id]
1124
 
                    change_entry(tt, file_id, working_tree, target_tree, 
1125
 
                                 trans_id_file_id, backup_this, trans_id,
1126
 
                                 by_parent)
1127
 
        finally:
1128
 
            child_pb.finished()
1129
 
        pp.next_phase()
1130
 
        wt_interesting = [i for i in working_tree.inventory if interesting(i)]
1131
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1132
 
        try:
1133
 
            for id_num, file_id in enumerate(wt_interesting):
1134
 
                child_pb.update("New file check", id_num+1, 
1135
 
                                len(sorted_interesting))
1136
 
                if file_id not in target_tree:
1137
 
                    trans_id = tt.trans_id_tree_file_id(file_id)
1138
 
                    tt.unversion_file(trans_id)
1139
 
                    if file_id in merge_modified:
1140
 
                        tt.delete_contents(trans_id)
1141
 
                        del merge_modified[file_id]
 
1516
        pp = ProgressPhase("Revert phase", 3, pb)
 
1517
        pp.next_phase()
 
1518
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1519
        try:
 
1520
            merge_modified = _alter_files(working_tree, target_tree, tt,
 
1521
                                          child_pb, filenames, backups)
1142
1522
        finally:
1143
1523
            child_pb.finished()
1144
1524
        pp.next_phase()
1148
1528
        finally:
1149
1529
            child_pb.finished()
1150
1530
        conflicts = cook_conflicts(raw_conflicts, tt)
 
1531
        if change_reporter:
 
1532
            change_reporter = delta._ChangeReporter(
 
1533
                unversioned_filter=working_tree.is_ignored)
 
1534
            delta.report_changes(tt._iter_changes(), change_reporter)
1151
1535
        for conflict in conflicts:
1152
1536
            warning(conflict)
1153
1537
        pp.next_phase()
1154
1538
        tt.apply()
1155
 
        working_tree.set_merge_modified({})
 
1539
        working_tree.set_merge_modified(merge_modified)
1156
1540
    finally:
 
1541
        target_tree.unlock()
1157
1542
        tt.finalize()
1158
1543
        pb.clear()
1159
1544
    return conflicts
1160
1545
 
1161
1546
 
1162
 
def resolve_conflicts(tt, pb=DummyProgress()):
 
1547
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
 
1548
                 backups):
 
1549
    merge_modified = working_tree.merge_modified()
 
1550
    change_list = target_tree._iter_changes(working_tree,
 
1551
        specific_files=specific_files, pb=pb)
 
1552
    if target_tree.inventory.root is None:
 
1553
        skip_root = True
 
1554
    else:
 
1555
        skip_root = False
 
1556
    basis_tree = None
 
1557
    try:
 
1558
        for id_num, (file_id, path, changed_content, versioned, parent, name,
 
1559
                kind, executable) in enumerate(change_list):
 
1560
            if skip_root and file_id[0] is not None and parent[0] is None:
 
1561
                continue
 
1562
            trans_id = tt.trans_id_file_id(file_id)
 
1563
            mode_id = None
 
1564
            if changed_content:
 
1565
                keep_content = False
 
1566
                if kind[0] == 'file' and (backups or kind[1] is None):
 
1567
                    wt_sha1 = working_tree.get_file_sha1(file_id)
 
1568
                    if merge_modified.get(file_id) != wt_sha1:
 
1569
                        # acquire the basis tree lazily to prevent the
 
1570
                        # expense of accessing it when it's not needed ?
 
1571
                        # (Guessing, RBC, 200702)
 
1572
                        if basis_tree is None:
 
1573
                            basis_tree = working_tree.basis_tree()
 
1574
                            basis_tree.lock_read()
 
1575
                        if file_id in basis_tree:
 
1576
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
 
1577
                                keep_content = True
 
1578
                        elif kind[1] is None and not versioned[1]:
 
1579
                            keep_content = True
 
1580
                if kind[0] is not None:
 
1581
                    if not keep_content:
 
1582
                        tt.delete_contents(trans_id)
 
1583
                    elif kind[1] is not None:
 
1584
                        parent_trans_id = tt.trans_id_file_id(parent[0])
 
1585
                        by_parent = tt.by_parent()
 
1586
                        backup_name = _get_backup_name(name[0], by_parent,
 
1587
                                                       parent_trans_id, tt)
 
1588
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
 
1589
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
 
1590
                        if versioned == (True, True):
 
1591
                            tt.unversion_file(trans_id)
 
1592
                            tt.version_file(file_id, new_trans_id)
 
1593
                        # New contents should have the same unix perms as old
 
1594
                        # contents
 
1595
                        mode_id = trans_id
 
1596
                        trans_id = new_trans_id
 
1597
                if kind[1] == 'directory':
 
1598
                    tt.create_directory(trans_id)
 
1599
                elif kind[1] == 'symlink':
 
1600
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
 
1601
                                      trans_id)
 
1602
                elif kind[1] == 'file':
 
1603
                    tt.create_file(target_tree.get_file_lines(file_id),
 
1604
                                   trans_id, mode_id)
 
1605
                    if basis_tree is None:
 
1606
                        basis_tree = working_tree.basis_tree()
 
1607
                        basis_tree.lock_read()
 
1608
                    new_sha1 = target_tree.get_file_sha1(file_id)
 
1609
                    if (file_id in basis_tree and new_sha1 ==
 
1610
                        basis_tree.get_file_sha1(file_id)):
 
1611
                        if file_id in merge_modified:
 
1612
                            del merge_modified[file_id]
 
1613
                    else:
 
1614
                        merge_modified[file_id] = new_sha1
 
1615
 
 
1616
                    # preserve the execute bit when backing up
 
1617
                    if keep_content and executable[0] == executable[1]:
 
1618
                        tt.set_executability(executable[1], trans_id)
 
1619
                else:
 
1620
                    assert kind[1] is None
 
1621
            if versioned == (False, True):
 
1622
                tt.version_file(file_id, trans_id)
 
1623
            if versioned == (True, False):
 
1624
                tt.unversion_file(trans_id)
 
1625
            if (name[1] is not None and 
 
1626
                (name[0] != name[1] or parent[0] != parent[1])):
 
1627
                tt.adjust_path(
 
1628
                    name[1], tt.trans_id_file_id(parent[1]), trans_id)
 
1629
            if executable[0] != executable[1] and kind[1] == "file":
 
1630
                tt.set_executability(executable[1], trans_id)
 
1631
    finally:
 
1632
        if basis_tree is not None:
 
1633
            basis_tree.unlock()
 
1634
    return merge_modified
 
1635
 
 
1636
 
 
1637
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1163
1638
    """Make many conflict-resolution attempts, but die if they fail"""
 
1639
    if pass_func is None:
 
1640
        pass_func = conflict_pass
1164
1641
    new_conflicts = set()
1165
1642
    try:
1166
1643
        for n in range(10):
1168
1645
            conflicts = tt.find_conflicts()
1169
1646
            if len(conflicts) == 0:
1170
1647
                return new_conflicts
1171
 
            new_conflicts.update(conflict_pass(tt, conflicts))
 
1648
            new_conflicts.update(pass_func(tt, conflicts))
1172
1649
        raise MalformedTransform(conflicts=conflicts)
1173
1650
    finally:
1174
1651
        pb.clear()
1175
1652
 
1176
1653
 
1177
 
def conflict_pass(tt, conflicts):
1178
 
    """Resolve some classes of conflicts."""
 
1654
def conflict_pass(tt, conflicts, path_tree=None):
 
1655
    """Resolve some classes of conflicts.
 
1656
 
 
1657
    :param tt: The transform to resolve conflicts in
 
1658
    :param conflicts: The conflicts to resolve
 
1659
    :param path_tree: A Tree to get supplemental paths from
 
1660
    """
1179
1661
    new_conflicts = set()
1180
1662
    for c_type, conflict in ((c[0], c) for c in conflicts):
1181
1663
        if c_type == 'duplicate id':
1207
1689
            trans_id = conflict[1]
1208
1690
            try:
1209
1691
                tt.cancel_deletion(trans_id)
1210
 
                new_conflicts.add((c_type, 'Not deleting', trans_id))
 
1692
                new_conflicts.add(('deleting parent', 'Not deleting', 
 
1693
                                   trans_id))
1211
1694
            except KeyError:
1212
1695
                tt.create_directory(trans_id)
1213
 
                new_conflicts.add((c_type, 'Created directory.', trans_id))
 
1696
                new_conflicts.add((c_type, 'Created directory', trans_id))
 
1697
                try:
 
1698
                    tt.final_name(trans_id)
 
1699
                except NoFinalPath:
 
1700
                    file_id = tt.final_file_id(trans_id)
 
1701
                    entry = path_tree.inventory[file_id]
 
1702
                    parent_trans_id = tt.trans_id_file_id(entry.parent_id)
 
1703
                    tt.adjust_path(entry.name, parent_trans_id, trans_id)
1214
1704
        elif c_type == 'unversioned parent':
1215
1705
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1216
1706
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))