/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Vincent Ladeuil
  • Date: 2007-07-18 09:43:41 UTC
  • mto: (2778.5.1 vila)
  • mto: This revision was merged to the branch mainline in revision 2789.
  • Revision ID: v.ladeuil+lp@free.fr-20070718094341-edmgsog3el06yqow
Add performance analysis of missing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
import errno
19
19
from stat import S_ISREG
20
20
 
21
 
from bzrlib import bzrdir, errors
 
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
""")
22
30
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
23
31
                           ReusingTransform, NotVersionedError, CantMoveRoot,
24
 
                           ExistingLimbo, ImmortalLimbo)
 
32
                           ExistingLimbo, ImmortalLimbo, NoFinalPath)
25
33
from bzrlib.inventory import InventoryEntry
26
34
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
27
35
                            delete_any)
28
36
from bzrlib.progress import DummyProgress, ProgressPhase
 
37
from bzrlib.symbol_versioning import deprecated_function, zero_fifteen
29
38
from bzrlib.trace import mutter, warning
30
39
from bzrlib import tree
31
 
import bzrlib.ui 
 
40
import bzrlib.ui
32
41
import bzrlib.urlutils as urlutils
33
42
 
34
43
 
42
51
 
43
52
 
44
53
class _TransformResults(object):
45
 
    def __init__(self, modified_paths):
 
54
    def __init__(self, modified_paths, rename_count):
46
55
        object.__init__(self)
47
56
        self.modified_paths = modified_paths
 
57
        self.rename_count = rename_count
48
58
 
49
59
 
50
60
class TreeTransform(object):
51
61
    """Represent a tree transformation.
52
62
    
53
63
    This object is designed to support incremental generation of the transform,
54
 
    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.
55
69
    
56
70
    It is easy to produce malformed transforms, but they are generally
57
71
    harmless.  Attempting to apply a malformed transform will cause an
75
89
    def __init__(self, tree, pb=DummyProgress()):
76
90
        """Note: a tree_write lock is taken on the tree.
77
91
        
78
 
        Use TreeTransform.finalize() to release the lock
 
92
        Use TreeTransform.finalize() to release the lock (can be omitted if
 
93
        TreeTransform.apply() called).
79
94
        """
80
95
        object.__init__(self)
81
96
        self._tree = tree
97
112
        self._new_name = {}
98
113
        self._new_parent = {}
99
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()
100
124
        self._removed_contents = set()
101
125
        self._new_executability = {}
 
126
        self._new_reference_revision = {}
102
127
        self._new_id = {}
103
128
        self._non_present_ids = {}
104
129
        self._r_new_id = {}
105
130
        self._removed_id = set()
106
131
        self._tree_path_ids = {}
107
132
        self._tree_id_paths = {}
 
133
        # Cache of realpath results, to speed up canonical_path
108
134
        self._realpaths = {}
109
 
        # Cache of realpath results, to speed up canonical_path
 
135
        # Cache of relpath results, to speed up canonical_path
110
136
        self._relpaths = {}
111
 
        # Cache of relpath results, to speed up canonical_path
112
137
        self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
113
138
        self.__done = False
114
139
        self._pb = pb
 
140
        self.rename_count = 0
115
141
 
116
142
    def __get_root(self):
117
143
        return self._new_root
119
145
    root = property(__get_root)
120
146
 
121
147
    def finalize(self):
122
 
        """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
        """
123
153
        if self._tree is None:
124
154
            return
125
155
        try:
126
 
            for trans_id, kind in self._new_contents.iteritems():
127
 
                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:
128
160
                if kind == "directory":
129
161
                    os.rmdir(path)
130
162
                else:
155
187
        """Change the path that is assigned to a transaction id."""
156
188
        if trans_id == self._new_root:
157
189
            raise CantMoveRoot
 
190
        previous_parent = self._new_parent.get(trans_id)
 
191
        previous_name = self._new_name.get(trans_id)
158
192
        self._new_name[trans_id] = name
159
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)
160
217
 
161
218
    def adjust_root_path(self, name, parent):
162
219
        """Emulate moving the root by moving all children, instead.
273
330
                os.unlink(name)
274
331
                raise
275
332
 
276
 
            for segment in contents:
277
 
                f.write(segment)
 
333
            f.writelines(contents)
278
334
        finally:
279
335
            f.close()
280
336
        self._set_mode(trans_id, mode_id, S_ISREG)
292
348
        except KeyError:
293
349
            return
294
350
        try:
295
 
            mode = os.stat(old_path).st_mode
 
351
            mode = os.stat(self._tree.abspath(old_path)).st_mode
296
352
        except OSError, e:
297
353
            if e.errno == errno.ENOENT:
298
354
                return
321
377
    def cancel_creation(self, trans_id):
322
378
        """Cancel the creation of new file contents."""
323
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]
324
387
        delete_any(self._limbo_name(trans_id))
325
388
 
326
389
    def delete_contents(self, trans_id):
350
413
        else:
351
414
            unique_add(self._new_executability, trans_id, executability)
352
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
 
353
420
    def version_file(self, file_id, trans_id):
354
421
        """Schedule a file to become versioned."""
355
422
        assert file_id is not None
457
524
        try:
458
525
            return self._new_name[trans_id]
459
526
        except KeyError:
460
 
            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)
461
531
 
462
532
    def by_parent(self):
463
533
        """Return a map of parent: children for known parents.
570
640
            parent_id = trans_id
571
641
            while parent_id is not ROOT_PARENT:
572
642
                seen.add(parent_id)
573
 
                parent_id = self.final_parent(parent_id)
 
643
                try:
 
644
                    parent_id = self.final_parent(parent_id)
 
645
                except KeyError:
 
646
                    break
574
647
                if parent_id == trans_id:
575
648
                    conflicts.append(('parent loop', trans_id))
576
649
                if parent_id in seen:
644
717
    def _duplicate_entries(self, by_parent):
645
718
        """No directory may have two entries with the same name."""
646
719
        conflicts = []
 
720
        if (self._new_name, self._new_parent) == ({}, {}):
 
721
            return conflicts
647
722
        for children in by_parent.itervalues():
648
723
            name_ids = [(self.final_name(t), t) for t in children]
649
724
            name_ids.sort()
710
785
            return True
711
786
        return False
712
787
            
713
 
    def apply(self):
 
788
    def apply(self, no_conflicts=False):
714
789
        """Apply all changes to the inventory and filesystem.
715
790
        
716
791
        If filesystem or inventory conflicts are present, MalformedTransform
717
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.
718
798
        """
719
 
        conflicts = self.find_conflicts()
720
 
        if len(conflicts) != 0:
721
 
            raise MalformedTransform(conflicts=conflicts)
722
 
        limbo_inv = {}
 
799
        if not no_conflicts:
 
800
            conflicts = self.find_conflicts()
 
801
            if len(conflicts) != 0:
 
802
                raise MalformedTransform(conflicts=conflicts)
723
803
        inv = self._tree.inventory
 
804
        inventory_delta = []
724
805
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
725
806
        try:
726
807
            child_pb.update('Apply phase', 0, 2)
727
 
            self._apply_removals(inv, limbo_inv)
 
808
            self._apply_removals(inv, inventory_delta)
728
809
            child_pb.update('Apply phase', 1, 2)
729
 
            modified_paths = self._apply_insertions(inv, limbo_inv)
 
810
            modified_paths = self._apply_insertions(inv, inventory_delta)
730
811
        finally:
731
812
            child_pb.finished()
732
 
        self._tree._write_inventory(inv)
 
813
        self._tree.apply_inventory_delta(inventory_delta)
733
814
        self.__done = True
734
815
        self.finalize()
735
 
        return _TransformResults(modified_paths)
 
816
        return _TransformResults(modified_paths, self.rename_count)
736
817
 
737
818
    def _limbo_name(self, trans_id):
738
819
        """Generate the limbo name of a file"""
739
 
        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
740
850
 
741
 
    def _apply_removals(self, inv, limbo_inv):
 
851
    def _apply_removals(self, inv, inventory_delta):
742
852
        """Perform tree operations that remove directory/inventory names.
743
853
        
744
854
        That is, delete files that are to be deleted, and put any files that
762
872
                    except OSError, e:
763
873
                        if e.errno != errno.ENOENT:
764
874
                            raise
 
875
                    else:
 
876
                        self.rename_count += 1
765
877
                if trans_id in self._removed_id:
766
878
                    if trans_id == self._new_root:
767
879
                        file_id = self._tree.inventory.root.file_id
768
880
                    else:
769
881
                        file_id = self.tree_file_id(trans_id)
770
 
                    del inv[file_id]
771
 
                elif trans_id in self._new_name or trans_id in self._new_parent:
772
 
                    file_id = self.tree_file_id(trans_id)
773
 
                    if file_id is not None:
774
 
                        limbo_inv[trans_id] = inv[file_id]
775
 
                        del inv[file_id]
 
882
                    assert file_id is not None
 
883
                    inventory_delta.append((path, None, file_id, None))
776
884
        finally:
777
885
            child_pb.finished()
778
886
 
779
 
    def _apply_insertions(self, inv, limbo_inv):
 
887
    def _apply_insertions(self, inv, inventory_delta):
780
888
        """Perform tree operations that insert directory/inventory names.
781
889
        
782
890
        That is, create any files that need to be created, and restore from
788
896
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
789
897
        try:
790
898
            for num, (path, trans_id) in enumerate(new_paths):
 
899
                new_entry = None
791
900
                child_pb.update('adding file', num, len(new_paths))
792
901
                try:
793
902
                    kind = self._new_contents[trans_id]
796
905
                if trans_id in self._new_contents or \
797
906
                    self.path_changed(trans_id):
798
907
                    full_path = self._tree.abspath(path)
799
 
                    try:
800
 
                        os.rename(self._limbo_name(trans_id), full_path)
801
 
                    except OSError, e:
802
 
                        # We may be renaming a dangling inventory id
803
 
                        if e.errno != errno.ENOENT:
804
 
                            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
805
917
                    if trans_id in self._new_contents:
806
918
                        modified_paths.append(full_path)
807
919
                        del self._new_contents[trans_id]
809
921
                if trans_id in self._new_id:
810
922
                    if kind is None:
811
923
                        kind = file_kind(self._tree.abspath(path))
812
 
                    inv.add_path(path, kind, self._new_id[trans_id])
813
 
                elif trans_id in self._new_name or trans_id in\
814
 
                    self._new_parent:
815
 
                    entry = limbo_inv.get(trans_id)
816
 
                    if entry is not None:
817
 
                        entry.name = self.final_name(trans_id)
818
 
                        parent_path = os.path.dirname(path)
819
 
                        entry.parent_id = \
820
 
                            self._tree.inventory.path2id(parent_path)
821
 
                        inv.add(entry)
822
 
 
823
 
                # 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
 
824
952
                if trans_id in self._new_executability:
825
 
                    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))
826
962
        finally:
827
963
            child_pb.finished()
828
964
        return modified_paths
829
965
 
830
 
    def _set_executability(self, path, inv, trans_id):
 
966
    def _set_executability(self, path, entry, trans_id):
831
967
        """Set the executability of versioned files """
832
 
        file_id = inv.path2id(path)
833
968
        new_executability = self._new_executability[trans_id]
834
 
        inv[file_id].executable = new_executability
 
969
        entry.executable = new_executability
835
970
        if supports_executable():
836
971
            abspath = self._tree.abspath(path)
837
972
            current_mode = os.stat(abspath).st_mode
898
1033
        self.create_symlink(target, trans_id)
899
1034
        return trans_id
900
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
 
901
1176
def joinpath(parent, child):
902
1177
    """Join tree-relative paths, handling the tree root specially"""
903
1178
    if parent is None or parent == "":
954
1229
      it is silently replaced.
955
1230
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
956
1231
    """
957
 
    assert 2 > len(wt.inventory)
 
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)
958
1246
    file_trans_id = {}
959
1247
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
960
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()
961
1260
    tt = TreeTransform(wt)
962
1261
    divert = set()
963
1262
    try:
993
1292
                        if kind == 'directory':
994
1293
                            reparent = True
995
1294
                if entry.parent_id not in file_trans_id:
996
 
                    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))
997
1298
                parent_id = file_trans_id[entry.parent_id]
998
1299
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
999
1300
                                                      tree)
1014
1315
            wt.add_conflicts(conflicts)
1015
1316
        except errors.UnsupportedOperation:
1016
1317
            pass
1017
 
        tt.apply()
 
1318
        result = tt.apply()
1018
1319
    finally:
1019
1320
        tt.finalize()
1020
1321
        top_pb.finished()
 
1322
    return result
1021
1323
 
1022
1324
 
1023
1325
def _reparent_children(tt, old_parent, new_parent):
1077
1379
        executable = tree.is_executable(entry.file_id)
1078
1380
        return tt.new_file(name, parent_id, contents, entry.file_id, 
1079
1381
                           executable)
1080
 
    elif kind == 'directory':
1081
 
        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 
1082
1387
    elif kind == 'symlink':
1083
1388
        target = tree.get_symlink_target(entry.file_id)
1084
1389
        return tt.new_symlink(name, parent_id, target, entry.file_id)
 
1390
    else:
 
1391
        raise errors.BadFileKindError(name, kind)
1085
1392
 
1086
1393
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1087
1394
    """Create new file contents according to an inventory entry."""
1100
1407
        tt.set_executability(entry.executable, trans_id)
1101
1408
 
1102
1409
 
 
1410
@deprecated_function(zero_fifteen)
1103
1411
def find_interesting(working_tree, target_tree, filenames):
1104
 
    """Find the ids corresponding to specified filenames."""
1105
 
    trees = (working_tree, target_tree)
1106
 
    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()
1107
1425
 
1108
1426
 
1109
1427
def change_entry(tt, file_id, working_tree, target_tree, 
1147
1465
 
1148
1466
 
1149
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):
1150
1472
    """Produce a backup-style name that appears to be available"""
1151
1473
    def name_gen():
1152
1474
        counter = 1
1153
1475
        while True:
1154
 
            yield "%s.~%d~" % (entry.name, counter)
 
1476
            yield "%s.~%d~" % (name, counter)
1155
1477
            counter += 1
1156
 
    for name in name_gen():
1157
 
        if not tt.has_named_child(by_parent, parent_trans_id, name):
1158
 
            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
 
1159
1482
 
1160
1483
def _entry_changes(file_id, entry, working_tree):
1161
1484
    """Determine in which ways the inventory entry has changed.
1184
1507
    return has_contents, contents_mod, meta_mod
1185
1508
 
1186
1509
 
1187
 
def revert(working_tree, target_tree, filenames, backups=False, 
1188
 
           pb=DummyProgress()):
 
1510
def revert(working_tree, target_tree, filenames, backups=False,
 
1511
           pb=DummyProgress(), change_reporter=None):
1189
1512
    """Revert a working tree's contents to those of a target tree."""
1190
 
    interesting_ids = find_interesting(working_tree, target_tree, filenames)
1191
 
    def interesting(file_id):
1192
 
        return interesting_ids is None or (file_id in interesting_ids)
1193
 
 
 
1513
    target_tree.lock_read()
1194
1514
    tt = TreeTransform(working_tree, pb)
1195
1515
    try:
1196
 
        merge_modified = working_tree.merge_modified()
1197
 
        trans_id = {}
1198
 
        def trans_id_file_id(file_id):
1199
 
            try:
1200
 
                return trans_id[file_id]
1201
 
            except KeyError:
1202
 
                return tt.trans_id_tree_file_id(file_id)
1203
 
 
1204
 
        pp = ProgressPhase("Revert phase", 4, pb)
1205
 
        pp.next_phase()
1206
 
        sorted_interesting = [i for i in topology_sorted_ids(target_tree) if
1207
 
                              interesting(i)]
1208
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1209
 
        try:
1210
 
            by_parent = tt.by_parent()
1211
 
            for id_num, file_id in enumerate(sorted_interesting):
1212
 
                child_pb.update("Reverting file", id_num+1, 
1213
 
                                len(sorted_interesting))
1214
 
                if file_id not in working_tree.inventory:
1215
 
                    entry = target_tree.inventory[file_id]
1216
 
                    parent_id = trans_id_file_id(entry.parent_id)
1217
 
                    e_trans_id = new_by_entry(tt, entry, parent_id, target_tree)
1218
 
                    trans_id[file_id] = e_trans_id
1219
 
                else:
1220
 
                    backup_this = backups
1221
 
                    if file_id in merge_modified:
1222
 
                        backup_this = False
1223
 
                        del merge_modified[file_id]
1224
 
                    change_entry(tt, file_id, working_tree, target_tree, 
1225
 
                                 trans_id_file_id, backup_this, trans_id,
1226
 
                                 by_parent)
1227
 
        finally:
1228
 
            child_pb.finished()
1229
 
        pp.next_phase()
1230
 
        wt_interesting = [i for i in working_tree.inventory if interesting(i)]
1231
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1232
 
        try:
1233
 
            for id_num, file_id in enumerate(wt_interesting):
1234
 
                child_pb.update("New file check", id_num+1, 
1235
 
                                len(sorted_interesting))
1236
 
                if file_id not in target_tree:
1237
 
                    trans_id = tt.trans_id_tree_file_id(file_id)
1238
 
                    tt.unversion_file(trans_id)
1239
 
                    try:
1240
 
                        file_kind = working_tree.kind(file_id)
1241
 
                    except NoSuchFile:
1242
 
                        file_kind = None
1243
 
                    if file_kind != 'file' and file_kind is not None:
1244
 
                        keep_contents = False
1245
 
                        delete_merge_modified = False
1246
 
                    else:
1247
 
                        if (file_id in merge_modified and 
1248
 
                            merge_modified[file_id] == 
1249
 
                            working_tree.get_file_sha1(file_id)):
1250
 
                            keep_contents = False
1251
 
                            delete_merge_modified = True
1252
 
                        else:
1253
 
                            keep_contents = True
1254
 
                            delete_merge_modified = False
1255
 
                    if not keep_contents:
1256
 
                        tt.delete_contents(trans_id)
1257
 
                    if delete_merge_modified:
1258
 
                        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)
1259
1522
        finally:
1260
1523
            child_pb.finished()
1261
1524
        pp.next_phase()
1265
1528
        finally:
1266
1529
            child_pb.finished()
1267
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)
1268
1535
        for conflict in conflicts:
1269
1536
            warning(conflict)
1270
1537
        pp.next_phase()
1271
1538
        tt.apply()
1272
 
        working_tree.set_merge_modified({})
 
1539
        working_tree.set_merge_modified(merge_modified)
1273
1540
    finally:
 
1541
        target_tree.unlock()
1274
1542
        tt.finalize()
1275
1543
        pb.clear()
1276
1544
    return conflicts
1277
1545
 
1278
1546
 
 
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
 
1279
1637
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1280
1638
    """Make many conflict-resolution attempts, but die if they fail"""
1281
1639
    if pass_func is None:
1293
1651
        pb.clear()
1294
1652
 
1295
1653
 
1296
 
def conflict_pass(tt, conflicts):
1297
 
    """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
    """
1298
1661
    new_conflicts = set()
1299
1662
    for c_type, conflict in ((c[0], c) for c in conflicts):
1300
1663
        if c_type == 'duplicate id':
1331
1694
            except KeyError:
1332
1695
                tt.create_directory(trans_id)
1333
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)
1334
1704
        elif c_type == 'unversioned parent':
1335
1705
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1336
1706
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))