← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 16:43:12 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename  gpl.txt => COPYING.txt

Show diffs side-by-side

added added

removed removed

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