/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 breezy/transform.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
 
 
 
17
import contextlib
19
18
import os
20
19
import errno
21
20
from stat import S_ISREG, S_IEXEC
52
51
""")
53
52
from .errors import (DuplicateKey, MalformedTransform,
54
53
                     ReusingTransform, CantMoveRoot,
55
 
                     ImmortalLimbo, NoFinalPath,
56
 
                     UnableCreateSymlink)
 
54
                     ImmortalLimbo, NoFinalPath)
57
55
from .filters import filtered_output_bytes, ContentFilterContext
58
56
from .mutabletree import MutableTree
59
57
from .osutils import (
60
58
    delete_any,
61
59
    file_kind,
62
 
    has_symlinks,
63
60
    pathjoin,
64
61
    sha_file,
65
62
    splitpath,
 
63
    supports_symlinks,
66
64
    )
67
65
from .progress import ProgressPhase
68
 
from .sixish import (
69
 
    viewitems,
70
 
    viewvalues,
 
66
from .tree import (
 
67
    InterTree,
 
68
    TreeChange,
71
69
    )
72
70
 
73
71
 
74
72
ROOT_PARENT = "root-parent"
75
73
 
 
74
 
76
75
def unique_add(map, key, value):
77
76
    if key in map:
78
77
        raise DuplicateKey(key=key)
79
78
    map[key] = value
80
79
 
81
80
 
82
 
 
83
81
class _TransformResults(object):
84
82
    def __init__(self, modified_paths, rename_count):
85
83
        object.__init__(self)
90
88
class TreeTransformBase(object):
91
89
    """The base class for TreeTransform and its kin."""
92
90
 
93
 
    def __init__(self, tree, pb=None,
94
 
                 case_sensitive=True):
 
91
    def __init__(self, tree, pb=None, case_sensitive=True):
95
92
        """Constructor.
96
93
 
97
94
        :param tree: The tree that will be transformed, but not necessarily
130
127
        # Mapping trans_id -> path in old tree
131
128
        self._tree_id_paths = {}
132
129
        # The trans_id that will be used as the tree root
133
 
        root_id = tree.get_root_id()
134
 
        if root_id is not None:
135
 
            self._new_root = self.trans_id_tree_file_id(root_id)
 
130
        if tree.is_versioned(''):
 
131
            self._new_root = self.trans_id_tree_path('')
136
132
        else:
137
133
            self._new_root = None
138
134
        # Indicator of whether the transform has been applied
173
169
    def _assign_id(self):
174
170
        """Produce a new tranform id"""
175
171
        new_id = "new-%s" % self._id_number
176
 
        self._id_number +=1
 
172
        self._id_number += 1
177
173
        return new_id
178
174
 
179
175
    def create_path(self, name, parent):
216
212
        # the physical root needs a new transaction id
217
213
        self._tree_path_ids.pop("")
218
214
        self._tree_id_paths.pop(old_root)
219
 
        self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
 
215
        self._new_root = self.trans_id_tree_path('')
220
216
        if parent == old_root:
221
217
            parent = self._new_root
222
218
        self.adjust_path(name, parent, old_root)
236
232
        irrelevant.
237
233
 
238
234
        """
239
 
        new_roots = [k for k, v in viewitems(self._new_parent)
 
235
        new_roots = [k for k, v in self._new_parent.items()
240
236
                     if v == ROOT_PARENT]
241
237
        if len(new_roots) < 1:
242
238
            return
257
253
            self.unversion_file(old_new_root)
258
254
        # if, at this stage, root still has an old file_id, zap it so we can
259
255
        # stick a new one in.
260
 
        if (self.tree_file_id(self._new_root) is not None and
261
 
            self._new_root not in self._removed_id):
 
256
        if (self.tree_file_id(self._new_root) is not None
 
257
                and self._new_root not in self._removed_id):
262
258
            self.unversion_file(self._new_root)
263
259
        if file_id is not None:
264
260
            self.version_file(file_id, self._new_root)
285
281
        del self._new_parent[old_new_root]
286
282
        del self._new_name[old_new_root]
287
283
 
288
 
    def trans_id_tree_file_id(self, inventory_id):
289
 
        """Determine the transaction id of a working tree file.
290
 
 
291
 
        This reflects only files that already exist, not ones that will be
292
 
        added by transactions.
293
 
        """
294
 
        if inventory_id is None:
295
 
            raise ValueError('None is not a valid file id')
296
 
        path = self._tree.id2path(inventory_id)
297
 
        return self.trans_id_tree_path(path)
298
 
 
299
284
    def trans_id_file_id(self, file_id):
300
285
        """Determine or set the transaction id associated with a file ID.
301
286
        A new id is only created for file_ids that were never present.  If
308
293
            return self._r_new_id[file_id]
309
294
        else:
310
295
            try:
311
 
                next(self._tree.iter_entries_by_dir([file_id]))
312
 
            except StopIteration:
 
296
                path = self._tree.id2path(file_id)
 
297
            except errors.NoSuchId:
313
298
                if file_id in self._non_present_ids:
314
299
                    return self._non_present_ids[file_id]
315
300
                else:
317
302
                    self._non_present_ids[file_id] = trans_id
318
303
                    return trans_id
319
304
            else:
320
 
                return self.trans_id_tree_file_id(file_id)
 
305
                return self.trans_id_tree_path(path)
321
306
 
322
307
    def trans_id_tree_path(self, path):
323
308
        """Determine (and maybe set) the transaction ID for a tree path."""
434
419
        changed_ids.update(changed_kind)
435
420
        # To find entries with changed parent_ids, find parents which existed,
436
421
        # but changed file_id.
437
 
        changed_file_id = set(t for t in new_file_id if t in self._removed_id)
438
422
        # Now add all their children to the set.
439
423
        for parent_trans_id in new_file_id:
440
424
            changed_ids.update(self.iter_tree_children(parent_trans_id))
454
438
        else:
455
439
            return self.tree_kind(trans_id)
456
440
 
 
441
    def tree_path(self, trans_id):
 
442
        """Determine the tree path associated with the trans_id."""
 
443
        return self._tree_id_paths.get(trans_id)
 
444
 
457
445
    def tree_file_id(self, trans_id):
458
446
        """Determine the file id associated with the trans_id in the tree"""
459
 
        try:
460
 
            path = self._tree_id_paths[trans_id]
461
 
        except KeyError:
462
 
            # the file is a new, unversioned file, or invalid trans_id
 
447
        path = self.tree_path(trans_id)
 
448
        if path is None:
463
449
            return None
464
450
        # the file is old; the old id is still valid
465
451
        if self._new_root == trans_id:
466
 
            return self._tree.get_root_id()
 
452
            return self._tree.path2id('')
467
453
        return self._tree.path2id(path)
468
454
 
469
455
    def final_file_id(self, trans_id):
487
473
        file_id = self.tree_file_id(trans_id)
488
474
        if file_id is not None:
489
475
            return file_id
490
 
        for key, value in viewitems(self._non_present_ids):
 
476
        for key, value in self._non_present_ids.items():
491
477
            if value == trans_id:
492
478
                return key
493
479
 
517
503
        Only new paths and parents of tree files with assigned ids are used.
518
504
        """
519
505
        by_parent = {}
520
 
        items = list(viewitems(self._new_parent))
 
506
        items = list(self._new_parent.items())
521
507
        items.extend((t, self.final_parent(t))
522
 
            for t in list(self._tree_id_paths))
 
508
                     for t in list(self._tree_id_paths))
523
509
        for trans_id, parent_id in items:
524
510
            if parent_id not in by_parent:
525
511
                by_parent[parent_id] = set()
567
553
        parents.extend([t for t in self._removed_contents if
568
554
                        self.tree_kind(t) == 'directory'])
569
555
        for trans_id in self._removed_id:
570
 
            file_id = self.tree_file_id(trans_id)
571
 
            path = self._tree.id2path(file_id)
572
 
            if file_id is not None:
573
 
                if self._tree.stored_kind(path, file_id) == 'directory':
 
556
            path = self.tree_path(trans_id)
 
557
            if path is not None:
 
558
                if self._tree.stored_kind(path) == 'directory':
574
559
                    parents.append(trans_id)
575
560
            elif self.tree_kind(trans_id) == 'directory':
576
561
                parents.append(trans_id)
613
598
 
614
599
        :param name: The basename of the file.
615
600
 
616
 
        :param target_id: The directory trans_id where the backup should 
 
601
        :param target_id: The directory trans_id where the backup should
617
602
            be placed.
618
603
        """
619
604
        known_children = self.by_parent().get(target_id, [])
643
628
    def _unversioned_parents(self, by_parent):
644
629
        """If parent directories are versioned, children must be versioned."""
645
630
        conflicts = []
646
 
        for parent_id, children in viewitems(by_parent):
 
631
        for parent_id, children in by_parent.items():
647
632
            if parent_id == ROOT_PARENT:
648
633
                continue
649
634
            if self.final_file_id(parent_id) is not None:
651
636
            for child_id in children:
652
637
                if self.final_file_id(child_id) is not None:
653
638
                    conflicts.append(('unversioned parent', parent_id))
654
 
                    break;
 
639
                    break
655
640
        return conflicts
656
641
 
657
642
    def _improper_versioning(self):
662
647
        conflicts = []
663
648
        for trans_id in self._new_id:
664
649
            kind = self.final_kind(trans_id)
 
650
            if kind == 'symlink' and not self._tree.supports_symlinks():
 
651
                # Ignore symlinks as they are not supported on this platform
 
652
                continue
665
653
            if kind is None:
666
654
                conflicts.append(('versioning no contents', trans_id))
667
655
                continue
668
 
            if not inventory.InventoryEntry.versionable_kind(kind):
 
656
            if not self._tree.versionable_kind(kind):
669
657
                conflicts.append(('versioning bad kind', trans_id, kind))
670
658
        return conflicts
671
659
 
694
682
                continue
695
683
            if trans_id not in self._removed_contents:
696
684
                conflicts.append(('overwrite', trans_id,
697
 
                                 self.final_name(trans_id)))
 
685
                                  self.final_name(trans_id)))
698
686
        return conflicts
699
687
 
700
688
    def _duplicate_entries(self, by_parent):
702
690
        conflicts = []
703
691
        if (self._new_name, self._new_parent) == ({}, {}):
704
692
            return conflicts
705
 
        for children in viewvalues(by_parent):
 
693
        for children in by_parent.values():
706
694
            name_ids = []
707
695
            for child_tid in children:
708
696
                name = self.final_name(child_tid)
721
709
                    continue
722
710
                if name == last_name:
723
711
                    conflicts.append(('duplicate', last_trans_id, trans_id,
724
 
                    name))
 
712
                                      name))
725
713
                last_name = name
726
714
                last_trans_id = trans_id
727
715
        return conflicts
729
717
    def _duplicate_ids(self):
730
718
        """Each inventory id may only be used once"""
731
719
        conflicts = []
 
720
        try:
 
721
            all_ids = self._tree.all_file_ids()
 
722
        except errors.UnsupportedOperation:
 
723
            # it's okay for non-file-id trees to raise UnsupportedOperation.
 
724
            return []
732
725
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
733
726
                                self._removed_id))
734
 
        all_ids = self._tree.all_file_ids()
735
727
        active_tree_ids = all_ids.difference(removed_tree_ids)
736
 
        for trans_id, file_id in viewitems(self._new_id):
 
728
        for trans_id, file_id in self._new_id.items():
737
729
            if file_id in active_tree_ids:
738
 
                old_trans_id = self.trans_id_tree_file_id(file_id)
 
730
                path = self._tree.id2path(file_id)
 
731
                old_trans_id = self.trans_id_tree_path(path)
739
732
                conflicts.append(('duplicate id', old_trans_id, trans_id))
740
733
        return conflicts
741
734
 
742
735
    def _parent_type_conflicts(self, by_parent):
743
736
        """Children must have a directory parent"""
744
737
        conflicts = []
745
 
        for parent_id, children in viewitems(by_parent):
 
738
        for parent_id, children in by_parent.items():
746
739
            if parent_id == ROOT_PARENT:
747
740
                continue
748
741
            no_children = True
901
894
                to_trans_ids[to_file_id] = trans_id
902
895
        return from_trans_ids, to_trans_ids
903
896
 
904
 
    def _from_file_data(self, from_trans_id, from_versioned, file_id):
 
897
    def _from_file_data(self, from_trans_id, from_versioned, from_path):
905
898
        """Get data about a file in the from (tree) state
906
899
 
907
900
        Return a (name, parent, kind, executable) tuple
909
902
        from_path = self._tree_id_paths.get(from_trans_id)
910
903
        if from_versioned:
911
904
            # get data from working tree if versioned
912
 
            from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
 
905
            from_entry = next(self._tree.iter_entries_by_dir(
 
906
                specific_files=[from_path]))[1]
913
907
            from_name = from_entry.name
914
908
            from_parent = from_entry.parent_id
915
909
        else:
978
972
            else:
979
973
                to_versioned = True
980
974
 
981
 
            from_name, from_parent, from_kind, from_executable = \
982
 
                self._from_file_data(from_trans_id, from_versioned, file_id)
983
 
 
984
 
            to_name, to_parent, to_kind, to_executable = \
985
 
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
986
 
 
987
975
            if not from_versioned:
988
976
                from_path = None
989
977
            else:
992
980
                to_path = None
993
981
            else:
994
982
                to_path = final_paths.get_path(to_trans_id)
 
983
 
 
984
            from_name, from_parent, from_kind, from_executable = \
 
985
                self._from_file_data(from_trans_id, from_versioned, from_path)
 
986
 
 
987
            to_name, to_parent, to_kind, to_executable = \
 
988
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
 
989
 
995
990
            if from_kind != to_kind:
996
991
                modified = True
997
992
            elif to_kind in ('file', 'symlink') and (
998
 
                to_trans_id != from_trans_id or
999
 
                to_trans_id in self._new_contents):
 
993
                    to_trans_id != from_trans_id
 
994
                    or to_trans_id in self._new_contents):
1000
995
                modified = True
1001
 
            if (not modified and from_versioned == to_versioned and
1002
 
                from_parent==to_parent and from_name == to_name and
1003
 
                from_executable == to_executable):
 
996
            if (not modified and from_versioned == to_versioned
 
997
                and from_parent == to_parent and from_name == to_name
 
998
                    and from_executable == to_executable):
1004
999
                continue
1005
 
            results.append((file_id, (from_path, to_path), modified,
1006
 
                   (from_versioned, to_versioned),
1007
 
                   (from_parent, to_parent),
1008
 
                   (from_name, to_name),
1009
 
                   (from_kind, to_kind),
1010
 
                   (from_executable, to_executable)))
1011
 
        return iter(sorted(results, key=lambda x:x[1]))
 
1000
            results.append(
 
1001
                TreeChange(
 
1002
                    file_id, (from_path, to_path), modified,
 
1003
                    (from_versioned, to_versioned),
 
1004
                    (from_parent, to_parent),
 
1005
                    (from_name, to_name),
 
1006
                    (from_kind, to_kind),
 
1007
                    (from_executable, to_executable)))
 
1008
 
 
1009
        def path_key(c):
 
1010
            return (c.path[0] or '', c.path[1] or '')
 
1011
        return iter(sorted(results, key=path_key))
1012
1012
 
1013
1013
    def get_preview_tree(self):
1014
1014
        """Return a tree representing the result of the transform.
1060
1060
                parent_ids.extend(merge_parents)
1061
1061
        if self._tree.get_revision_id() != last_rev_id:
1062
1062
            raise ValueError('TreeTransform not based on branch basis: %s' %
1063
 
                             self._tree.get_revision_id())
 
1063
                             self._tree.get_revision_id().decode('utf-8'))
1064
1064
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
1065
1065
        builder = branch.get_commit_builder(parent_ids,
1066
1066
                                            timestamp=timestamp,
1077
1077
        return revision_id
1078
1078
 
1079
1079
    def _text_parent(self, trans_id):
1080
 
        file_id = self.tree_file_id(trans_id)
 
1080
        path = self.tree_path(trans_id)
1081
1081
        try:
1082
 
            if (file_id is None or
1083
 
                    self._tree.kind(self._tree.id2path(file_id), file_id) != 'file'):
 
1082
            if path is None or self._tree.kind(path) != 'file':
1084
1083
                return None
1085
1084
        except errors.NoSuchFile:
1086
1085
            return None
1087
 
        return file_id
 
1086
        return path
1088
1087
 
1089
1088
    def _get_parents_texts(self, trans_id):
1090
1089
        """Get texts for compression parents of this file."""
1091
 
        file_id = self._text_parent(trans_id)
1092
 
        if file_id is None:
 
1090
        path = self._text_parent(trans_id)
 
1091
        if path is None:
1093
1092
            return ()
1094
 
        return (self._tree.get_file_text(self._tree.id2path(file_id), file_id),)
 
1093
        return (self._tree.get_file_text(path),)
1095
1094
 
1096
1095
    def _get_parents_lines(self, trans_id):
1097
1096
        """Get lines for compression parents of this file."""
1098
 
        file_id = self._text_parent(trans_id)
1099
 
        if file_id is None:
 
1097
        path = self._text_parent(trans_id)
 
1098
        if path is None:
1100
1099
            return ()
1101
 
        return (self._tree.get_file_lines(self._tree.id2path(file_id), file_id),)
 
1100
        return (self._tree.get_file_lines(path),)
1102
1101
 
1103
1102
    def serialize(self, serializer):
1104
1103
        """Serialize this TreeTransform.
1105
1104
 
1106
1105
        :param serializer: A Serialiser like pack.ContainerSerializer.
1107
1106
        """
1108
 
        new_name = dict((k, v.encode('utf-8')) for k, v in
1109
 
                        viewitems(self._new_name))
1110
 
        new_executability = dict((k, int(v)) for k, v in
1111
 
                                 viewitems(self._new_executability))
1112
 
        tree_path_ids = dict((k.encode('utf-8'), v)
1113
 
                             for k, v in viewitems(self._tree_path_ids))
 
1107
        new_name = {k.encode('utf-8'): v.encode('utf-8')
 
1108
                    for k, v in self._new_name.items()}
 
1109
        new_parent = {k.encode('utf-8'): v.encode('utf-8')
 
1110
                      for k, v in self._new_parent.items()}
 
1111
        new_id = {k.encode('utf-8'): v
 
1112
                  for k, v in self._new_id.items()}
 
1113
        new_executability = {k.encode('utf-8'): int(v)
 
1114
                             for k, v in self._new_executability.items()}
 
1115
        tree_path_ids = {k.encode('utf-8'): v.encode('utf-8')
 
1116
                         for k, v in self._tree_path_ids.items()}
 
1117
        non_present_ids = {k: v.encode('utf-8')
 
1118
                           for k, v in self._non_present_ids.items()}
 
1119
        removed_contents = [trans_id.encode('utf-8')
 
1120
                            for trans_id in self._removed_contents]
 
1121
        removed_id = [trans_id.encode('utf-8')
 
1122
                      for trans_id in self._removed_id]
1114
1123
        attribs = {
1115
 
            '_id_number': self._id_number,
1116
 
            '_new_name': new_name,
1117
 
            '_new_parent': self._new_parent,
1118
 
            '_new_executability': new_executability,
1119
 
            '_new_id': self._new_id,
1120
 
            '_tree_path_ids': tree_path_ids,
1121
 
            '_removed_id': list(self._removed_id),
1122
 
            '_removed_contents': list(self._removed_contents),
1123
 
            '_non_present_ids': self._non_present_ids,
 
1124
            b'_id_number': self._id_number,
 
1125
            b'_new_name': new_name,
 
1126
            b'_new_parent': new_parent,
 
1127
            b'_new_executability': new_executability,
 
1128
            b'_new_id': new_id,
 
1129
            b'_tree_path_ids': tree_path_ids,
 
1130
            b'_removed_id': removed_id,
 
1131
            b'_removed_contents': removed_contents,
 
1132
            b'_non_present_ids': non_present_ids,
1124
1133
            }
1125
1134
        yield serializer.bytes_record(bencode.bencode(attribs),
1126
 
                                      (('attribs',),))
1127
 
        for trans_id, kind in viewitems(self._new_contents):
 
1135
                                      ((b'attribs',),))
 
1136
        for trans_id, kind in sorted(self._new_contents.items()):
1128
1137
            if kind == 'file':
1129
 
                lines = osutils.chunks_to_lines(
1130
 
                    self._read_file_chunks(trans_id))
 
1138
                with open(self._limbo_name(trans_id), 'rb') as cur_file:
 
1139
                    lines = cur_file.readlines()
1131
1140
                parents = self._get_parents_lines(trans_id)
1132
1141
                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
1133
 
                content = ''.join(mpdiff.to_patch())
 
1142
                content = b''.join(mpdiff.to_patch())
1134
1143
            if kind == 'directory':
1135
 
                content = ''
 
1144
                content = b''
1136
1145
            if kind == 'symlink':
1137
1146
                content = self._read_symlink_target(trans_id)
1138
 
            yield serializer.bytes_record(content, ((trans_id, kind),))
 
1147
                if not isinstance(content, bytes):
 
1148
                    content = content.encode('utf-8')
 
1149
            yield serializer.bytes_record(
 
1150
                content, ((trans_id.encode('utf-8'), kind.encode('ascii')),))
1139
1151
 
1140
1152
    def deserialize(self, records):
1141
1153
        """Deserialize a stored TreeTransform.
1145
1157
        """
1146
1158
        names, content = next(records)
1147
1159
        attribs = bencode.bdecode(content)
1148
 
        self._id_number = attribs['_id_number']
1149
 
        self._new_name = dict((k, v.decode('utf-8'))
1150
 
                              for k, v in viewitems(attribs['_new_name']))
1151
 
        self._new_parent = attribs['_new_parent']
1152
 
        self._new_executability = dict((k, bool(v))
1153
 
            for k, v in viewitems(attribs['_new_executability']))
1154
 
        self._new_id = attribs['_new_id']
1155
 
        self._r_new_id = dict((v, k) for k, v in viewitems(self._new_id))
 
1160
        self._id_number = attribs[b'_id_number']
 
1161
        self._new_name = {k.decode('utf-8'): v.decode('utf-8')
 
1162
                          for k, v in attribs[b'_new_name'].items()}
 
1163
        self._new_parent = {k.decode('utf-8'): v.decode('utf-8')
 
1164
                            for k, v in attribs[b'_new_parent'].items()}
 
1165
        self._new_executability = {
 
1166
            k.decode('utf-8'): bool(v)
 
1167
            for k, v in attribs[b'_new_executability'].items()}
 
1168
        self._new_id = {k.decode('utf-8'): v
 
1169
                        for k, v in attribs[b'_new_id'].items()}
 
1170
        self._r_new_id = {v: k for k, v in self._new_id.items()}
1156
1171
        self._tree_path_ids = {}
1157
1172
        self._tree_id_paths = {}
1158
 
        for bytepath, trans_id in viewitems(attribs['_tree_path_ids']):
 
1173
        for bytepath, trans_id in attribs[b'_tree_path_ids'].items():
1159
1174
            path = bytepath.decode('utf-8')
 
1175
            trans_id = trans_id.decode('utf-8')
1160
1176
            self._tree_path_ids[path] = trans_id
1161
1177
            self._tree_id_paths[trans_id] = path
1162
 
        self._removed_id = set(attribs['_removed_id'])
1163
 
        self._removed_contents = set(attribs['_removed_contents'])
1164
 
        self._non_present_ids = attribs['_non_present_ids']
 
1178
        self._removed_id = {trans_id.decode('utf-8')
 
1179
                            for trans_id in attribs[b'_removed_id']}
 
1180
        self._removed_contents = set(
 
1181
            trans_id.decode('utf-8')
 
1182
            for trans_id in attribs[b'_removed_contents'])
 
1183
        self._non_present_ids = {
 
1184
            k: v.decode('utf-8')
 
1185
            for k, v in attribs[b'_non_present_ids'].items()}
1165
1186
        for ((trans_id, kind),), content in records:
 
1187
            trans_id = trans_id.decode('utf-8')
 
1188
            kind = kind.decode('ascii')
1166
1189
            if kind == 'file':
1167
1190
                mpdiff = multiparent.MultiParent.from_patch(content)
1168
1191
                lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
1172
1195
            if kind == 'symlink':
1173
1196
                self.create_symlink(content.decode('utf-8'), trans_id)
1174
1197
 
 
1198
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
 
1199
        """Schedule creation of a new file.
 
1200
 
 
1201
        :seealso: new_file.
 
1202
 
 
1203
        :param contents: an iterator of strings, all of which will be written
 
1204
            to the target destination.
 
1205
        :param trans_id: TreeTransform handle
 
1206
        :param mode_id: If not None, force the mode of the target file to match
 
1207
            the mode of the object referenced by mode_id.
 
1208
            Otherwise, we will try to preserve mode bits of an existing file.
 
1209
        :param sha1: If the sha1 of this content is already known, pass it in.
 
1210
            We can use it to prevent future sha1 computations.
 
1211
        """
 
1212
        raise NotImplementedError(self.create_file)
 
1213
 
 
1214
    def create_directory(self, trans_id):
 
1215
        """Schedule creation of a new directory.
 
1216
 
 
1217
        See also new_directory.
 
1218
        """
 
1219
        raise NotImplementedError(self.create_directory)
 
1220
 
 
1221
    def create_symlink(self, target, trans_id):
 
1222
        """Schedule creation of a new symbolic link.
 
1223
 
 
1224
        target is a bytestring.
 
1225
        See also new_symlink.
 
1226
        """
 
1227
        raise NotImplementedError(self.create_symlink)
 
1228
 
 
1229
    def create_hardlink(self, path, trans_id):
 
1230
        """Schedule creation of a hard link"""
 
1231
        raise NotImplementedError(self.create_hardlink)
 
1232
 
 
1233
    def cancel_creation(self, trans_id):
 
1234
        """Cancel the creation of new file contents."""
 
1235
        raise NotImplementedError(self.cancel_creation)
 
1236
 
1175
1237
 
1176
1238
class DiskTreeTransform(TreeTransformBase):
1177
1239
    """Tree transform storing its contents on disk."""
1178
1240
 
1179
 
    def __init__(self, tree, limbodir, pb=None,
1180
 
                 case_sensitive=True):
 
1241
    def __init__(self, tree, limbodir, pb=None, case_sensitive=True):
1181
1242
        """Constructor.
1182
1243
        :param tree: The tree that will be transformed, but not necessarily
1183
1244
            the output tree.
1201
1262
        # List of transform ids that need to be renamed from limbo into place
1202
1263
        self._needs_rename = set()
1203
1264
        self._creation_mtime = None
 
1265
        self._create_symlinks = osutils.supports_symlinks(self._limbodir)
1204
1266
 
1205
1267
    def finalize(self):
1206
1268
        """Release the working tree lock, if held, clean up limbo dir.
1211
1273
        if self._tree is None:
1212
1274
            return
1213
1275
        try:
1214
 
            limbo_paths = list(viewvalues(self._limbo_files))
 
1276
            limbo_paths = list(self._limbo_files.values())
1215
1277
            limbo_paths.extend(self._possibly_stale_limbo_files)
1216
1278
            limbo_paths.sort(reverse=True)
1217
1279
            for path in limbo_paths:
1238
1300
 
1239
1301
    def _limbo_supports_executable(self):
1240
1302
        """Check if the limbo path supports the executable bit."""
1241
 
        # FIXME: Check actual file system capabilities of limbodir
1242
 
        return osutils.supports_executable()
 
1303
        return osutils.supports_executable(self._limbodir)
1243
1304
 
1244
1305
    def _limbo_name(self, trans_id):
1245
1306
        """Generate the limbo name of a file"""
1262
1323
        previous_parent = self._new_parent.get(trans_id)
1263
1324
        previous_name = self._new_name.get(trans_id)
1264
1325
        TreeTransformBase.adjust_path(self, name, parent, trans_id)
1265
 
        if (trans_id in self._limbo_files and
1266
 
            trans_id not in self._needs_rename):
 
1326
        if (trans_id in self._limbo_files
 
1327
                and trans_id not in self._needs_rename):
1267
1328
            self._rename_in_limbo([trans_id])
1268
1329
            if previous_parent != parent:
1269
1330
                self._limbo_children[previous_parent].remove(trans_id)
1317
1378
            We can use it to prevent future sha1 computations.
1318
1379
        """
1319
1380
        name = self._limbo_name(trans_id)
1320
 
        f = open(name, 'wb')
1321
 
        try:
 
1381
        with open(name, 'wb') as f:
1322
1382
            unique_add(self._new_contents, trans_id, 'file')
1323
1383
            f.writelines(contents)
1324
 
        finally:
1325
 
            f.close()
1326
1384
        self._set_mtime(name)
1327
1385
        self._set_mode(trans_id, mode_id, S_ISREG)
1328
1386
        # It is unfortunate we have to use lstat instead of fstat, but we just
1331
1389
        if sha1 is not None:
1332
1390
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1333
1391
 
1334
 
    def _read_file_chunks(self, trans_id):
1335
 
        cur_file = open(self._limbo_name(trans_id), 'rb')
1336
 
        try:
1337
 
            return cur_file.readlines()
1338
 
        finally:
1339
 
            cur_file.close()
1340
 
 
1341
1392
    def _read_symlink_target(self, trans_id):
1342
1393
        return os.readlink(self._limbo_name(trans_id))
1343
1394
 
1361
1412
            raise errors.HardLinkNotSupported(path)
1362
1413
        try:
1363
1414
            unique_add(self._new_contents, trans_id, 'file')
1364
 
        except:
 
1415
        except BaseException:
1365
1416
            # Clean up the file, it never got registered so
1366
1417
            # TreeTransform.finalize() won't clean it up.
1367
1418
            os.unlink(name)
1381
1432
        target is a bytestring.
1382
1433
        See also new_symlink.
1383
1434
        """
1384
 
        if has_symlinks():
 
1435
        if self._create_symlinks:
1385
1436
            os.symlink(target, self._limbo_name(trans_id))
1386
 
            unique_add(self._new_contents, trans_id, 'symlink')
1387
1437
        else:
1388
1438
            try:
1389
1439
                path = FinalPaths(self).get_path(trans_id)
1390
1440
            except KeyError:
1391
1441
                path = None
1392
 
            raise UnableCreateSymlink(path=path)
 
1442
            trace.warning(
 
1443
                'Unable to create symlink "%s" on this filesystem.' % (path,))
 
1444
        # We add symlink to _new_contents even if they are unsupported
 
1445
        # and not created. These entries are subsequently used to avoid
 
1446
        # conflicts on platforms that don't support symlink
 
1447
        unique_add(self._new_contents, trans_id, 'symlink')
1393
1448
 
1394
1449
    def cancel_creation(self, trans_id):
1395
1450
        """Cancel the creation of new file contents."""
1407
1462
 
1408
1463
    def new_orphan(self, trans_id, parent_id):
1409
1464
        conf = self._tree.get_config_stack()
1410
 
        handle_orphan = conf.get('bzr.transform.orphan_policy')
 
1465
        handle_orphan = conf.get('transform.orphan_policy')
1411
1466
        handle_orphan(self, trans_id, parent_id)
1412
1467
 
1413
1468
 
1468
1523
 
1469
1524
orphaning_registry = registry.Registry()
1470
1525
orphaning_registry.register(
1471
 
    'conflict', refuse_orphan,
 
1526
    u'conflict', refuse_orphan,
1472
1527
    'Leave orphans in place and create a conflict on the directory.')
1473
1528
orphaning_registry.register(
1474
 
    'move', move_orphan,
 
1529
    u'move', move_orphan,
1475
1530
    'Move orphans into the brz-orphans directory.')
1476
 
orphaning_registry._set_default_key('conflict')
 
1531
orphaning_registry._set_default_key(u'conflict')
1477
1532
 
1478
1533
 
1479
1534
opt_transform_orphan = _mod_config.RegistryOption(
1480
 
    'bzr.transform.orphan_policy', orphaning_registry,
 
1535
    'transform.orphan_policy', orphaning_registry,
1481
1536
    help='Policy for orphaned files during transform operations.',
1482
1537
    invalid='warning')
1483
1538
 
1547
1602
    FileMover does not delete files until it is sure that a rollback will not
1548
1603
    happen.
1549
1604
    """
 
1605
 
1550
1606
    def __init__(self, tree, pb=None):
1551
1607
        """Note: a tree_write lock is taken on the tree.
1552
1608
 
1565
1621
            osutils.ensure_empty_directory_exists(
1566
1622
                deletiondir,
1567
1623
                errors.ExistingPendingDeletion)
1568
 
        except:
 
1624
        except BaseException:
1569
1625
            tree.unlock()
1570
1626
            raise
1571
1627
 
1644
1700
        try:
1645
1701
            children = os.listdir(self._tree.abspath(path))
1646
1702
        except OSError as e:
1647
 
            if not (osutils._is_error_enotdir(e)
1648
 
                    or e.errno in (errno.ENOENT, errno.ESRCH)):
 
1703
            if not (osutils._is_error_enotdir(e) or
 
1704
                    e.errno in (errno.ENOENT, errno.ESRCH)):
1649
1705
                raise
1650
1706
            return
1651
1707
 
1682
1738
                # if it is already associated with this trans_id.
1683
1739
                elif self._case_sensitive_target:
1684
1740
                    if (self._limbo_children_names[parent].get(filename)
1685
 
                        in (trans_id, None)):
 
1741
                            in (trans_id, None)):
1686
1742
                        use_direct_path = True
1687
1743
                else:
1688
 
                    for l_filename, l_trans_id in viewitems(
1689
 
                            self._limbo_children_names[parent]):
 
1744
                    for l_filename, l_trans_id in (
 
1745
                            self._limbo_children_names[parent].items()):
1690
1746
                        if l_trans_id == trans_id:
1691
1747
                            continue
1692
1748
                        if l_filename.lower() == filename.lower():
1702
1758
        self._limbo_children_names[parent][filename] = trans_id
1703
1759
        return limbo_name
1704
1760
 
1705
 
 
1706
1761
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1707
1762
        """Apply all changes to the inventory and filesystem.
1708
1763
 
1721
1776
            hook(self._tree, self)
1722
1777
        if not no_conflicts:
1723
1778
            self._check_malformed()
1724
 
        child_pb = ui.ui_factory.nested_progress_bar()
1725
 
        try:
 
1779
        with ui.ui_factory.nested_progress_bar() as child_pb:
1726
1780
            if precomputed_delta is None:
1727
1781
                child_pb.update(gettext('Apply phase'), 0, 2)
1728
1782
                inventory_delta = self._generate_inventory_delta()
1739
1793
                self._apply_removals(mover)
1740
1794
                child_pb.update(gettext('Apply phase'), 1 + offset, 2 + offset)
1741
1795
                modified_paths = self._apply_insertions(mover)
1742
 
            except:
 
1796
            except BaseException:
1743
1797
                mover.rollback()
1744
1798
                raise
1745
1799
            else:
1746
1800
                mover.apply_deletions()
1747
 
        finally:
1748
 
            child_pb.finished()
1749
1801
        if self.final_file_id(self.root) is None:
1750
1802
            inventory_delta = [e for e in inventory_delta if e[0] != '']
1751
1803
        self._tree.apply_inventory_delta(inventory_delta)
1757
1809
    def _generate_inventory_delta(self):
1758
1810
        """Generate an inventory delta for the current transform."""
1759
1811
        inventory_delta = []
1760
 
        child_pb = ui.ui_factory.nested_progress_bar()
1761
1812
        new_paths = self._inventory_altered()
1762
1813
        total_entries = len(new_paths) + len(self._removed_id)
1763
 
        try:
 
1814
        with ui.ui_factory.nested_progress_bar() as child_pb:
1764
1815
            for num, trans_id in enumerate(self._removed_id):
1765
1816
                if (num % 10) == 0:
1766
 
                    child_pb.update(gettext('removing file'), num, total_entries)
 
1817
                    child_pb.update(gettext('removing file'),
 
1818
                                    num, total_entries)
1767
1819
                if trans_id == self._new_root:
1768
 
                    file_id = self._tree.get_root_id()
 
1820
                    file_id = self._tree.path2id('')
1769
1821
                else:
1770
1822
                    file_id = self.tree_file_id(trans_id)
1771
1823
                # File-id isn't really being deleted, just moved
1775
1827
                inventory_delta.append((path, None, file_id, None))
1776
1828
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1777
1829
                                     new_paths)
1778
 
            entries = self._tree.iter_entries_by_dir(
1779
 
                viewvalues(new_path_file_ids))
1780
 
            old_paths = dict((e.file_id, p) for p, e in entries)
1781
 
            final_kinds = {}
1782
1830
            for num, (path, trans_id) in enumerate(new_paths):
1783
1831
                if (num % 10) == 0:
1784
1832
                    child_pb.update(gettext('adding file'),
1786
1834
                file_id = new_path_file_ids[trans_id]
1787
1835
                if file_id is None:
1788
1836
                    continue
1789
 
                needs_entry = False
1790
1837
                kind = self.final_kind(trans_id)
1791
1838
                if kind is None:
1792
 
                    kind = self._tree.stored_kind(
1793
 
                            self._tree.id2path(file_id), file_id)
 
1839
                    kind = self._tree.stored_kind(self._tree.id2path(file_id))
1794
1840
                parent_trans_id = self.final_parent(trans_id)
1795
1841
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1796
1842
                if parent_file_id is None:
1803
1849
                        None, self._new_reference_revision[trans_id])
1804
1850
                else:
1805
1851
                    new_entry = inventory.make_entry(kind,
1806
 
                        self.final_name(trans_id),
1807
 
                        parent_file_id, file_id)
1808
 
                old_path = old_paths.get(new_entry.file_id)
 
1852
                                                     self.final_name(trans_id),
 
1853
                                                     parent_file_id, file_id)
 
1854
                try:
 
1855
                    old_path = self._tree.id2path(new_entry.file_id)
 
1856
                except errors.NoSuchId:
 
1857
                    old_path = None
1809
1858
                new_executability = self._new_executability.get(trans_id)
1810
1859
                if new_executability is not None:
1811
1860
                    new_entry.executable = new_executability
1812
1861
                inventory_delta.append(
1813
1862
                    (old_path, path, new_entry.file_id, new_entry))
1814
 
        finally:
1815
 
            child_pb.finished()
1816
1863
        return inventory_delta
1817
1864
 
1818
1865
    def _apply_removals(self, mover):
1824
1871
 
1825
1872
        If inventory_delta is None, no inventory delta generation is performed.
1826
1873
        """
1827
 
        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
1828
 
        child_pb = ui.ui_factory.nested_progress_bar()
1829
 
        try:
 
1874
        tree_paths = sorted(self._tree_path_ids.items(), reverse=True)
 
1875
        with ui.ui_factory.nested_progress_bar() as child_pb:
1830
1876
            for num, (path, trans_id) in enumerate(tree_paths):
1831
1877
                # do not attempt to move root into a subdirectory of itself.
1832
1878
                if path == '':
1836
1882
                if trans_id in self._removed_contents:
1837
1883
                    delete_path = os.path.join(self._deletiondir, trans_id)
1838
1884
                    mover.pre_delete(full_path, delete_path)
1839
 
                elif (trans_id in self._new_name
1840
 
                      or trans_id in self._new_parent):
 
1885
                elif (trans_id in self._new_name or
 
1886
                      trans_id in self._new_parent):
1841
1887
                    try:
1842
1888
                        mover.rename(full_path, self._limbo_name(trans_id))
1843
1889
                    except errors.TransformRenameFailed as e:
1845
1891
                            raise
1846
1892
                    else:
1847
1893
                        self.rename_count += 1
1848
 
        finally:
1849
 
            child_pb.finished()
1850
1894
 
1851
1895
    def _apply_insertions(self, mover):
1852
1896
        """Perform tree operations that insert directory/inventory names.
1860
1904
        """
1861
1905
        new_paths = self.new_paths(filesystem_only=True)
1862
1906
        modified_paths = []
1863
 
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1864
 
                                 new_paths)
1865
 
        child_pb = ui.ui_factory.nested_progress_bar()
1866
 
        try:
 
1907
        with ui.ui_factory.nested_progress_bar() as child_pb:
1867
1908
            for num, (path, trans_id) in enumerate(new_paths):
1868
1909
                if (num % 10) == 0:
1869
 
                    child_pb.update(gettext('adding file'), num, len(new_paths))
 
1910
                    child_pb.update(gettext('adding file'),
 
1911
                                    num, len(new_paths))
1870
1912
                full_path = self._tree.abspath(path)
1871
1913
                if trans_id in self._needs_rename:
1872
1914
                    try:
1880
1922
                    # TODO: if trans_id in self._observed_sha1s, we should
1881
1923
                    #       re-stat the final target, since ctime will be
1882
1924
                    #       updated by the change.
1883
 
                if (trans_id in self._new_contents or
1884
 
                    self.path_changed(trans_id)):
 
1925
                if (trans_id in self._new_contents
 
1926
                        or self.path_changed(trans_id)):
1885
1927
                    if trans_id in self._new_contents:
1886
1928
                        modified_paths.append(full_path)
1887
1929
                if trans_id in self._new_executability:
1890
1932
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
1891
1933
                    st = osutils.lstat(full_path)
1892
1934
                    self._observed_sha1s[trans_id] = (o_sha1, st)
1893
 
        finally:
1894
 
            child_pb.finished()
1895
1935
        for path, trans_id in new_paths:
1896
1936
            # new_paths includes stuff like workingtree conflicts. Only the
1897
1937
            # stuff in new_contents actually comes from limbo.
1916
1956
        #       problems. (we could observe start time, and finish time, and if
1917
1957
        #       it is less than eg 10% overhead, add a sleep call.)
1918
1958
        paths = FinalPaths(self)
1919
 
        for trans_id, observed in viewitems(self._observed_sha1s):
 
1959
        for trans_id, observed in self._observed_sha1s.items():
1920
1960
            path = paths.get_path(trans_id)
1921
 
            # We could get the file_id, but dirstate prefers to use the path
1922
 
            # anyway, and it is 'cheaper' to determine.
1923
 
            # file_id = self._new_id[trans_id]
1924
 
            self._tree._observed_sha1(None, path, observed)
 
1961
            self._tree._observed_sha1(path, observed)
1925
1962
 
1926
1963
 
1927
1964
class TransformPreview(DiskTreeTransform):
1964
2001
            path = self._tree_id_paths[parent_id]
1965
2002
        except KeyError:
1966
2003
            return
1967
 
        file_id = self.tree_file_id(parent_id)
1968
 
        if file_id is None:
 
2004
        try:
 
2005
            entry = next(self._tree.iter_entries_by_dir(
 
2006
                specific_files=[path]))[1]
 
2007
        except StopIteration:
1969
2008
            return
1970
 
        entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1971
2009
        children = getattr(entry, 'children', {})
1972
2010
        for child in children:
1973
2011
            childpath = joinpath(path, child)
1988
2026
        self._all_children_cache = {}
1989
2027
        self._path2trans_id_cache = {}
1990
2028
        self._final_name_cache = {}
1991
 
        self._iter_changes_cache = dict((c[0], c) for c in
 
2029
        self._iter_changes_cache = dict((c.file_id, c) for c in
1992
2030
                                        self._transform.iter_changes())
1993
2031
 
 
2032
    def supports_tree_reference(self):
 
2033
        # TODO(jelmer): Support tree references in _PreviewTree.
 
2034
        # return self._transform._tree.supports_tree_reference()
 
2035
        return False
 
2036
 
1994
2037
    def _content_change(self, file_id):
1995
2038
        """Return True if the content of this file changed"""
1996
2039
        changes = self._iter_changes_cache.get(file_id)
1997
 
        # changes[2] is true if the file content changed.  See
1998
 
        # InterTree.iter_changes.
1999
 
        return (changes is not None and changes[2])
 
2040
        return (changes is not None and changes.changed_content)
2000
2041
 
2001
2042
    def _get_repository(self):
2002
2043
        repo = getattr(self._transform._tree, '_repository', None)
2013
2054
 
2014
2055
    def _get_file_revision(self, path, file_id, vf, tree_revision):
2015
2056
        parent_keys = [
2016
 
                (file_id, t.get_file_revision(t.id2path(file_id), file_id))
2017
 
                for t in self._iter_parent_trees()]
 
2057
            (file_id, t.get_file_revision(t.id2path(file_id)))
 
2058
            for t in self._iter_parent_trees()]
2018
2059
        vf.add_lines((file_id, tree_revision), parent_keys,
2019
 
                     self.get_file_lines(path, file_id))
 
2060
                     self.get_file_lines(path))
2020
2061
        repo = self._get_repository()
2021
2062
        base_vf = repo.texts
2022
2063
        if base_vf not in vf.fallback_versionedfiles:
2023
2064
            vf.fallback_versionedfiles.append(base_vf)
2024
2065
        return tree_revision
2025
2066
 
2026
 
    def _stat_limbo_file(self, file_id=None, trans_id=None):
2027
 
        if trans_id is None:
2028
 
            trans_id = self._transform.trans_id_file_id(file_id)
 
2067
    def _stat_limbo_file(self, trans_id):
2029
2068
        name = self._transform._limbo_name(trans_id)
2030
2069
        return os.lstat(name)
2031
2070
 
2042
2081
            executable = False
2043
2082
        else:
2044
2083
            file_id = self._transform.final_file_id(self._path2trans_id(path))
2045
 
            executable = self.is_executable(path, file_id)
 
2084
            executable = self.is_executable(path)
2046
2085
        return kind, executable, None
2047
2086
 
2048
2087
    def is_locked(self):
2060
2099
        """This Tree does not use inventory as its backing data."""
2061
2100
        raise NotImplementedError(_PreviewTree.root_inventory)
2062
2101
 
2063
 
    def get_root_id(self):
2064
 
        return self._transform.final_file_id(self._transform.root)
2065
 
 
2066
2102
    def all_file_ids(self):
2067
2103
        tree_ids = set(self._transform._tree.all_file_ids())
2068
2104
        tree_ids.difference_update(self._transform.tree_file_id(t)
2069
2105
                                   for t in self._transform._removed_id)
2070
 
        tree_ids.update(viewvalues(self._transform._new_id))
 
2106
        tree_ids.update(self._transform._new_id.values())
2071
2107
        return tree_ids
2072
2108
 
2073
2109
    def all_versioned_paths(self):
2074
 
        return {self.id2path(fid) for fid in self.all_file_ids()}
2075
 
 
2076
 
    def _has_id(self, file_id, fallback_check):
2077
 
        if file_id in self._transform._r_new_id:
2078
 
            return True
2079
 
        elif file_id in {self._transform.tree_file_id(trans_id) for
2080
 
            trans_id in self._transform._removed_id}:
2081
 
            return False
2082
 
        else:
2083
 
            return fallback_check(file_id)
2084
 
 
2085
 
    def has_id(self, file_id):
2086
 
        return self._has_id(file_id, self._transform._tree.has_id)
2087
 
 
2088
 
    def has_or_had_id(self, file_id):
2089
 
        return self._has_id(file_id, self._transform._tree.has_or_had_id)
 
2110
        tree_paths = set(self._transform._tree.all_versioned_paths())
 
2111
 
 
2112
        tree_paths.difference_update(
 
2113
            self._transform.trans_id_tree_path(t)
 
2114
            for t in self._transform._removed_id)
 
2115
 
 
2116
        tree_paths.update(
 
2117
            self._final_paths._determine_path(t)
 
2118
            for t in self._transform._new_id)
 
2119
 
 
2120
        return tree_paths
2090
2121
 
2091
2122
    def _path2trans_id(self, path):
2092
2123
        # We must not use None here, because that is a valid value to store.
2117
2148
            path = osutils.pathjoin(*path)
2118
2149
        return self._transform.final_file_id(self._path2trans_id(path))
2119
2150
 
2120
 
    def id2path(self, file_id):
 
2151
    def id2path(self, file_id, recurse='down'):
2121
2152
        trans_id = self._transform.trans_id_file_id(file_id)
2122
2153
        try:
2123
2154
            return self._final_paths._determine_path(trans_id)
2135
2166
        self._all_children_cache[trans_id] = children
2136
2167
        return children
2137
2168
 
2138
 
    def iter_children(self, file_id):
2139
 
        trans_id = self._transform.trans_id_file_id(file_id)
2140
 
        for child_trans_id in self._all_children(trans_id):
2141
 
            yield self._transform.final_file_id(child_trans_id)
2142
 
 
2143
2169
    def extras(self):
2144
2170
        possible_extras = set(self._transform.trans_id_tree_path(p) for p
2145
2171
                              in self._transform._tree.extras())
2149
2175
            if self._transform.final_file_id(trans_id) is None:
2150
2176
                yield self._final_paths._determine_path(trans_id)
2151
2177
 
2152
 
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
2153
 
        yield_parents=False):
 
2178
    def _make_inv_entries(self, ordered_entries, specific_files=None):
2154
2179
        for trans_id, parent_file_id in ordered_entries:
2155
2180
            file_id = self._transform.final_file_id(trans_id)
2156
2181
            if file_id is None:
2157
2182
                continue
2158
 
            if (specific_file_ids is not None
2159
 
                and file_id not in specific_file_ids):
 
2183
            if (specific_files is not None
 
2184
                    and self._final_paths.get_path(trans_id) not in specific_files):
2160
2185
                continue
2161
2186
            kind = self._transform.final_kind(trans_id)
2162
2187
            if kind is None:
2163
2188
                kind = self._transform._tree.stored_kind(
2164
 
                    self._transform._tree.id2path(file_id),
2165
 
                    file_id)
 
2189
                    self._transform._tree.id2path(file_id))
2166
2190
            new_entry = inventory.make_entry(
2167
2191
                kind,
2168
2192
                self._transform.final_name(trans_id),
2183
2207
                ordered_ids.append((trans_id, parent_file_id))
2184
2208
        return ordered_ids
2185
2209
 
2186
 
    def iter_child_entries(self, path, file_id=None):
2187
 
        if file_id is None:
2188
 
            file_id = self.path2id(path)
2189
 
        if file_id is None:
 
2210
    def iter_child_entries(self, path):
 
2211
        trans_id = self._path2trans_id(path)
 
2212
        if trans_id is None:
2190
2213
            raise errors.NoSuchFile(path)
2191
 
        trans_id = self._transform.trans_id_file_id(file_id)
2192
2214
        todo = [(child_trans_id, trans_id) for child_trans_id in
2193
2215
                self._all_children(trans_id)]
2194
2216
        for entry, trans_id in self._make_inv_entries(todo):
2195
2217
            yield entry
2196
2218
 
2197
 
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
2219
    def iter_entries_by_dir(self, specific_files=None, recurse_nested=False):
 
2220
        if recurse_nested:
 
2221
            raise NotImplementedError(
 
2222
                'follow tree references not yet supported')
 
2223
 
2198
2224
        # This may not be a maximally efficient implementation, but it is
2199
2225
        # reasonably straightforward.  An implementation that grafts the
2200
2226
        # TreeTransform changes onto the tree's iter_entries_by_dir results
2202
2228
        # position.
2203
2229
        ordered_ids = self._list_files_by_dir()
2204
2230
        for entry, trans_id in self._make_inv_entries(ordered_ids,
2205
 
            specific_file_ids, yield_parents=yield_parents):
2206
 
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
2231
                                                      specific_files):
 
2232
            yield self._final_paths.get_path(trans_id), entry
2207
2233
 
2208
2234
    def _iter_entries_for_dir(self, dir_path):
2209
2235
        """Return path, entry for items in a directory without recursing down."""
2210
 
        dir_file_id = self.path2id(dir_path)
2211
2236
        ordered_ids = []
2212
 
        for file_id in self.iter_children(dir_file_id):
2213
 
            trans_id = self._transform.trans_id_file_id(file_id)
2214
 
            ordered_ids.append((trans_id, file_id))
 
2237
        dir_trans_id = self._path2trans_id(dir_path)
 
2238
        dir_id = self._transform.final_file_id(dir_trans_id)
 
2239
        for child_trans_id in self._all_children(dir_trans_id):
 
2240
            ordered_ids.append((child_trans_id, dir_id))
 
2241
        path_entries = []
2215
2242
        for entry, trans_id in self._make_inv_entries(ordered_ids):
2216
 
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
2243
            path_entries.append((self._final_paths.get_path(trans_id), entry))
 
2244
        path_entries.sort()
 
2245
        return path_entries
2217
2246
 
2218
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
2247
    def list_files(self, include_root=False, from_dir=None, recursive=True,
 
2248
                   recurse_nested=False):
2219
2249
        """See WorkingTree.list_files."""
 
2250
        if recurse_nested:
 
2251
            raise NotImplementedError(
 
2252
                'follow tree references not yet supported')
 
2253
 
2220
2254
        # XXX This should behave like WorkingTree.list_files, but is really
2221
2255
        # more like RevisionTree.list_files.
 
2256
        if from_dir == '.':
 
2257
            from_dir = None
2222
2258
        if recursive:
2223
2259
            prefix = None
2224
2260
            if from_dir:
2231
2267
                    if not path.startswith(prefix):
2232
2268
                        continue
2233
2269
                    path = path[len(prefix):]
2234
 
                yield path, 'V', entry.kind, entry.file_id, entry
 
2270
                yield path, 'V', entry.kind, entry
2235
2271
        else:
2236
2272
            if from_dir is None and include_root is True:
2237
 
                root_entry = inventory.make_entry('directory', '',
2238
 
                    ROOT_PARENT, self.get_root_id())
2239
 
                yield '', 'V', 'directory', root_entry.file_id, root_entry
 
2273
                root_entry = inventory.make_entry(
 
2274
                    'directory', '', ROOT_PARENT, self.path2id(''))
 
2275
                yield '', 'V', 'directory', root_entry
2240
2276
            entries = self._iter_entries_for_dir(from_dir or '')
2241
2277
            for path, entry in entries:
2242
 
                yield path, 'V', entry.kind, entry.file_id, entry
 
2278
                yield path, 'V', entry.kind, entry
2243
2279
 
2244
 
    def kind(self, path, file_id=None):
2245
 
        if file_id is None:
2246
 
            file_id = self.path2id(path)
2247
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2280
    def kind(self, path):
 
2281
        trans_id = self._path2trans_id(path)
 
2282
        if trans_id is None:
 
2283
            raise errors.NoSuchFile(path)
2248
2284
        return self._transform.final_kind(trans_id)
2249
2285
 
2250
 
    def stored_kind(self, path, file_id=None):
2251
 
        if file_id is None:
2252
 
            file_id = self.path2id(path)
2253
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2286
    def stored_kind(self, path):
 
2287
        trans_id = self._path2trans_id(path)
 
2288
        if trans_id is None:
 
2289
            raise errors.NoSuchFile(path)
2254
2290
        try:
2255
2291
            return self._transform._new_contents[trans_id]
2256
2292
        except KeyError:
2257
 
            return self._transform._tree.stored_kind(path, file_id)
 
2293
            return self._transform._tree.stored_kind(path)
2258
2294
 
2259
 
    def get_file_mtime(self, path, file_id=None):
 
2295
    def get_file_mtime(self, path):
2260
2296
        """See Tree.get_file_mtime"""
2261
 
        if file_id is None:
2262
 
            file_id = self.path2id(path)
 
2297
        file_id = self.path2id(path)
2263
2298
        if file_id is None:
2264
2299
            raise errors.NoSuchFile(path)
2265
2300
        if not self._content_change(file_id):
2266
2301
            return self._transform._tree.get_file_mtime(
2267
 
                    self._transform._tree.id2path(file_id), file_id)
2268
 
        return self._stat_limbo_file(file_id).st_mtime
2269
 
 
2270
 
    def _file_size(self, entry, stat_value):
2271
 
        path = self.id2path(entry.file_id)
2272
 
        return self.get_file_size(path, entry.file_id)
2273
 
 
2274
 
    def get_file_size(self, path, file_id=None):
 
2302
                self._transform._tree.id2path(file_id))
 
2303
        trans_id = self._path2trans_id(path)
 
2304
        return self._stat_limbo_file(trans_id).st_mtime
 
2305
 
 
2306
    def get_file_size(self, path):
2275
2307
        """See Tree.get_file_size"""
2276
 
        if file_id is None:
2277
 
            file_id = self.path2id(path)
2278
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2308
        trans_id = self._path2trans_id(path)
 
2309
        if trans_id is None:
 
2310
            raise errors.NoSuchFile(path)
2279
2311
        kind = self._transform.final_kind(trans_id)
2280
2312
        if kind != 'file':
2281
2313
            return None
2282
2314
        if trans_id in self._transform._new_contents:
2283
 
            return self._stat_limbo_file(trans_id=trans_id).st_size
2284
 
        if self.kind(path, file_id) == 'file':
2285
 
            return self._transform._tree.get_file_size(path, file_id)
 
2315
            return self._stat_limbo_file(trans_id).st_size
 
2316
        if self.kind(path) == 'file':
 
2317
            return self._transform._tree.get_file_size(path)
2286
2318
        else:
2287
2319
            return None
2288
2320
 
2289
 
    def get_file_verifier(self, path, file_id=None, stat_value=None):
2290
 
        if file_id is None:
2291
 
            file_id = self.path2id(path)
2292
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2321
    def get_file_verifier(self, path, stat_value=None):
 
2322
        trans_id = self._path2trans_id(path)
 
2323
        if trans_id is None:
 
2324
            raise errors.NoSuchFile(path)
2293
2325
        kind = self._transform._new_contents.get(trans_id)
2294
2326
        if kind is None:
2295
 
            return self._transform._tree.get_file_verifier(path, file_id)
 
2327
            return self._transform._tree.get_file_verifier(path)
2296
2328
        if kind == 'file':
2297
 
            fileobj = self.get_file(path, file_id)
2298
 
            try:
 
2329
            with self.get_file(path) as fileobj:
2299
2330
                return ("SHA1", sha_file(fileobj))
2300
 
            finally:
2301
 
                fileobj.close()
2302
2331
 
2303
 
    def get_file_sha1(self, path, file_id=None, stat_value=None):
2304
 
        if file_id is None:
2305
 
            file_id = self.path2id(path)
2306
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2332
    def get_file_sha1(self, path, stat_value=None):
 
2333
        trans_id = self._path2trans_id(path)
 
2334
        if trans_id is None:
 
2335
            raise errors.NoSuchFile(path)
2307
2336
        kind = self._transform._new_contents.get(trans_id)
2308
2337
        if kind is None:
2309
 
            return self._transform._tree.get_file_sha1(path, file_id)
 
2338
            return self._transform._tree.get_file_sha1(path)
2310
2339
        if kind == 'file':
2311
 
            fileobj = self.get_file(path, file_id)
2312
 
            try:
 
2340
            with self.get_file(path) as fileobj:
2313
2341
                return sha_file(fileobj)
2314
 
            finally:
2315
 
                fileobj.close()
2316
 
 
2317
 
    def is_executable(self, path, file_id=None):
2318
 
        if file_id is None:
2319
 
            file_id = self.path2id(path)
2320
 
        if file_id is None:
 
2342
 
 
2343
    def get_reference_revision(self, path):
 
2344
        trans_id = self._path2trans_id(path)
 
2345
        if trans_id is None:
 
2346
            raise errors.NoSuchFile(path)
 
2347
        reference_revision = self._transform._new_reference_revision.get(trans_id)
 
2348
        if reference_revision is None:
 
2349
            return self._transform._tree.get_reference_revision(path)
 
2350
        return reference_revision
 
2351
 
 
2352
    def is_executable(self, path):
 
2353
        trans_id = self._path2trans_id(path)
 
2354
        if trans_id is None:
2321
2355
            return False
2322
 
        trans_id = self._transform.trans_id_file_id(file_id)
2323
2356
        try:
2324
2357
            return self._transform._new_executability[trans_id]
2325
2358
        except KeyError:
2326
2359
            try:
2327
 
                return self._transform._tree.is_executable(path, file_id)
 
2360
                return self._transform._tree.is_executable(path)
2328
2361
            except OSError as e:
2329
2362
                if e.errno == errno.ENOENT:
2330
2363
                    return False
2331
2364
                raise
2332
 
            except errors.NoSuchId:
 
2365
            except errors.NoSuchFile:
2333
2366
                return False
2334
2367
 
2335
2368
    def has_filename(self, path):
2367
2400
                size = None
2368
2401
                executable = None
2369
2402
            if kind == 'symlink':
2370
 
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
 
2403
                link_or_sha1 = os.readlink(limbo_name)
 
2404
                if not isinstance(link_or_sha1, str):
 
2405
                    link_or_sha1 = link_or_sha1.decode(osutils._fs_enc)
2371
2406
        executable = tt._new_executability.get(trans_id, executable)
2372
2407
        return kind, size, executable, link_or_sha1
2373
2408
 
2374
2409
    def iter_changes(self, from_tree, include_unchanged=False,
2375
 
                      specific_files=None, pb=None, extra_trees=None,
2376
 
                      require_versioned=True, want_unversioned=False):
 
2410
                     specific_files=None, pb=None, extra_trees=None,
 
2411
                     require_versioned=True, want_unversioned=False):
2377
2412
        """See InterTree.iter_changes.
2378
2413
 
2379
2414
        This has a fast path that is only used when the from_tree matches
2380
2415
        the transform tree, and no fancy options are supplied.
2381
2416
        """
2382
 
        if (from_tree is not self._transform._tree or include_unchanged or
2383
 
            specific_files or want_unversioned):
 
2417
        if (from_tree is not self._transform._tree or include_unchanged
 
2418
                or specific_files or want_unversioned):
2384
2419
            return tree.InterTree(from_tree, self).iter_changes(
2385
2420
                include_unchanged=include_unchanged,
2386
2421
                specific_files=specific_files,
2392
2427
            raise ValueError('want_unversioned is not supported')
2393
2428
        return self._transform.iter_changes()
2394
2429
 
2395
 
    def get_file(self, path, file_id=None):
 
2430
    def get_file(self, path):
2396
2431
        """See Tree.get_file"""
2397
 
        if file_id is None:
2398
 
            file_id = self.path2id(path)
 
2432
        file_id = self.path2id(path)
2399
2433
        if not self._content_change(file_id):
2400
 
            return self._transform._tree.get_file(path, file_id)
2401
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2434
            return self._transform._tree.get_file(path)
 
2435
        trans_id = self._path2trans_id(path)
2402
2436
        name = self._transform._limbo_name(trans_id)
2403
2437
        return open(name, 'rb')
2404
2438
 
2405
 
    def get_file_with_stat(self, path, file_id=None):
2406
 
        return self.get_file(path, file_id), None
 
2439
    def get_file_with_stat(self, path):
 
2440
        return self.get_file(path), None
2407
2441
 
2408
 
    def annotate_iter(self, path, file_id=None,
 
2442
    def annotate_iter(self, path,
2409
2443
                      default_revision=_mod_revision.CURRENT_REVISION):
2410
 
        if file_id is None:
2411
 
            file_id = self.path2id(path)
 
2444
        file_id = self.path2id(path)
2412
2445
        changes = self._iter_changes_cache.get(file_id)
2413
2446
        if changes is None:
2414
2447
            get_old = True
2415
2448
        else:
2416
 
            changed_content, versioned, kind = (changes[2], changes[3],
2417
 
                                                changes[6])
 
2449
            changed_content, versioned, kind = (
 
2450
                changes.changed_content, changes.versioned, changes.kind)
2418
2451
            if kind[1] is None:
2419
2452
                return None
2420
2453
            get_old = (kind[0] == 'file' and versioned[0])
2421
2454
        if get_old:
2422
2455
            old_annotation = self._transform._tree.annotate_iter(
2423
 
                    path, file_id=file_id, default_revision=default_revision)
 
2456
                path, default_revision=default_revision)
2424
2457
        else:
2425
2458
            old_annotation = []
2426
2459
        if changes is None:
2435
2468
        #       It would be nice to be able to use the new Annotator based
2436
2469
        #       approach, as well.
2437
2470
        return annotate.reannotate([old_annotation],
2438
 
                                   self.get_file(path, file_id).readlines(),
 
2471
                                   self.get_file(path).readlines(),
2439
2472
                                   default_revision)
2440
2473
 
2441
 
    def get_symlink_target(self, path, file_id=None):
 
2474
    def get_symlink_target(self, path):
2442
2475
        """See Tree.get_symlink_target"""
2443
 
        if file_id is None:
2444
 
            file_id = self.path2id(path)
 
2476
        file_id = self.path2id(path)
2445
2477
        if not self._content_change(file_id):
2446
2478
            return self._transform._tree.get_symlink_target(path)
2447
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2479
        trans_id = self._path2trans_id(path)
2448
2480
        name = self._transform._limbo_name(trans_id)
2449
2481
        return osutils.readlink(name)
2450
2482
 
2461
2493
                path_from_root = self._final_paths.get_path(child_id)
2462
2494
                basename = self._transform.final_name(child_id)
2463
2495
                file_id = self._transform.final_file_id(child_id)
2464
 
                kind  = self._transform.final_kind(child_id)
 
2496
                kind = self._transform.final_kind(child_id)
2465
2497
                if kind is not None:
2466
2498
                    versioned_kind = kind
2467
2499
                else:
2468
2500
                    kind = 'unknown'
2469
2501
                    versioned_kind = self._transform._tree.stored_kind(
2470
 
                            self._transform._tree.id2path(file_id),
2471
 
                            file_id)
 
2502
                        self._transform._tree.id2path(file_id))
2472
2503
                if versioned_kind == 'directory':
2473
2504
                    subdirs.append(child_id)
2474
2505
                children.append((path_from_root, basename, kind, None,
2503
2534
    The underlying tree must not be manipulated between calls, or else
2504
2535
    the results will likely be incorrect.
2505
2536
    """
 
2537
 
2506
2538
    def __init__(self, transform):
2507
2539
        object.__init__(self)
2508
2540
        self._known_paths = {}
2510
2542
 
2511
2543
    def _determine_path(self, trans_id):
2512
2544
        if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
2513
 
            return ""
 
2545
            return u""
2514
2546
        name = self.transform.final_name(trans_id)
2515
2547
        parent_id = self.transform.final_parent(trans_id)
2516
2548
        if parent_id == self.transform.root:
2528
2560
        return [(self.get_path(t), t) for t in trans_ids]
2529
2561
 
2530
2562
 
2531
 
 
2532
 
def topology_sorted_ids(tree):
2533
 
    """Determine the topological order of the ids in a tree"""
2534
 
    file_ids = list(tree)
2535
 
    file_ids.sort(key=tree.id2path)
2536
 
    return file_ids
2537
 
 
2538
 
 
2539
2563
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
2540
2564
               delta_from_tree=False):
2541
2565
    """Create working tree for a branch, using a TreeTransform.
2562
2586
    :param delta_from_tree: If true, build_tree may use the input Tree to
2563
2587
        generate the inventory delta.
2564
2588
    """
2565
 
    with wt.lock_tree_write(), tree.lock_read():
 
2589
    with contextlib.ExitStack() as exit_stack:
 
2590
        exit_stack.enter_context(wt.lock_tree_write())
 
2591
        exit_stack.enter_context(tree.lock_read())
2566
2592
        if accelerator_tree is not None:
2567
 
            accelerator_tree.lock_read()
2568
 
        try:
2569
 
            return _build_tree(tree, wt, accelerator_tree, hardlink,
2570
 
                               delta_from_tree)
2571
 
        finally:
2572
 
            if accelerator_tree is not None:
2573
 
                accelerator_tree.unlock()
 
2593
            exit_stack.enter_context(accelerator_tree.lock_read())
 
2594
        return _build_tree(tree, wt, accelerator_tree, hardlink,
 
2595
                           delta_from_tree)
2574
2596
 
2575
2597
 
2576
2598
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
2581
2603
    file_trans_id = {}
2582
2604
    top_pb = ui.ui_factory.nested_progress_bar()
2583
2605
    pp = ProgressPhase("Build phase", 2, top_pb)
2584
 
    if tree.get_root_id() is not None:
 
2606
    if tree.path2id('') is not None:
2585
2607
        # This is kind of a hack: we should be altering the root
2586
2608
        # as part of the regular tree shape diff logic.
2587
2609
        # The conditional test here is to avoid doing an
2589
2611
        # is set within the tree, nor setting the root and thus
2590
2612
        # marking the tree as dirty, because we use two different
2591
2613
        # idioms here: tree interfaces and inventory interfaces.
2592
 
        if wt.get_root_id() != tree.get_root_id():
2593
 
            wt.set_root_id(tree.get_root_id())
 
2614
        if wt.path2id('') != tree.path2id(''):
 
2615
            wt.set_root_id(tree.path2id(''))
2594
2616
            wt.flush()
2595
 
    tt = TreeTransform(wt)
 
2617
    tt = wt.get_transform()
2596
2618
    divert = set()
2597
2619
    try:
2598
2620
        pp.next_phase()
2599
 
        file_trans_id[wt.get_root_id()] = \
2600
 
            tt.trans_id_tree_file_id(wt.get_root_id())
2601
 
        pb = ui.ui_factory.nested_progress_bar()
2602
 
        try:
 
2621
        file_trans_id[wt.path2id('')] = tt.trans_id_tree_path('')
 
2622
        with ui.ui_factory.nested_progress_bar() as pb:
2603
2623
            deferred_contents = []
2604
2624
            num = 0
2605
2625
            total = len(tree.all_versioned_paths())
2617
2637
                for dir, files in wt.walkdirs():
2618
2638
                    existing_files.update(f[0] for f in files)
2619
2639
            for num, (tree_path, entry) in \
2620
 
                enumerate(tree.iter_entries_by_dir()):
2621
 
                pb.update(gettext("Building tree"), num - len(deferred_contents), total)
 
2640
                    enumerate(tree.iter_entries_by_dir()):
 
2641
                pb.update(gettext("Building tree"), num
 
2642
                          - len(deferred_contents), total)
2622
2643
                if entry.parent_id is None:
2623
2644
                    continue
2624
2645
                reparent = False
2635
2656
                            pass
2636
2657
                        else:
2637
2658
                            divert.add(file_id)
2638
 
                    if (file_id not in divert and
2639
 
                        _content_match(tree, entry, file_id, kind,
2640
 
                        target_path)):
 
2659
                    if (file_id not in divert
 
2660
                        and _content_match(
 
2661
                            tree, entry, tree_path, kind, target_path)):
2641
2662
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
2642
2663
                        if kind == 'directory':
2643
2664
                            reparent = True
2648
2669
                    trans_id = tt.create_path(entry.name, parent_id)
2649
2670
                    file_trans_id[file_id] = trans_id
2650
2671
                    tt.version_file(file_id, trans_id)
2651
 
                    executable = tree.is_executable(tree_path, file_id)
 
2672
                    executable = tree.is_executable(tree_path)
2652
2673
                    if executable:
2653
2674
                        tt.set_executability(executable, trans_id)
2654
 
                    trans_data = (trans_id, tree_path, entry.text_sha1)
2655
 
                    deferred_contents.append((file_id, trans_data))
 
2675
                    trans_data = (trans_id, file_id,
 
2676
                                  tree_path, entry.text_sha1)
 
2677
                    deferred_contents.append((tree_path, trans_data))
2656
2678
                else:
2657
2679
                    file_trans_id[file_id] = new_by_entry(
2658
 
                            tree_path, tt, entry, parent_id, tree)
 
2680
                        tree_path, tt, entry, parent_id, tree)
2659
2681
                if reparent:
2660
2682
                    new_trans_id = file_trans_id[file_id]
2661
2683
                    old_parent = tt.trans_id_tree_path(tree_path)
2663
2685
            offset = num + 1 - len(deferred_contents)
2664
2686
            _create_files(tt, tree, deferred_contents, pb, offset,
2665
2687
                          accelerator_tree, hardlink)
2666
 
        finally:
2667
 
            pb.finished()
2668
2688
        pp.next_phase()
2669
2689
        divert_trans = set(file_trans_id[f] for f in divert)
2670
 
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
 
2690
 
 
2691
        def resolver(t, c):
 
2692
            return resolve_checkout(t, c, divert_trans)
2671
2693
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
2672
2694
        if len(raw_conflicts) > 0:
2673
2695
            precomputed_delta = None
2674
2696
        conflicts = cook_conflicts(raw_conflicts, tt)
2675
2697
        for conflict in conflicts:
2676
 
            trace.warning(unicode(conflict))
 
2698
            trace.warning(str(conflict))
2677
2699
        try:
2678
2700
            wt.add_conflicts(conflicts)
2679
2701
        except errors.UnsupportedOperation:
2694
2716
        new_desired_files = desired_files
2695
2717
    else:
2696
2718
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2697
 
        unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2698
 
                     in iter if not (c or e[0] != e[1])]
 
2719
        unchanged = [
 
2720
            change.path for change in iter
 
2721
            if not (change.changed_content or change.executable[0] != change.executable[1])]
2699
2722
        if accelerator_tree.supports_content_filtering():
2700
 
            unchanged = [(f, p) for (f, p) in unchanged
2701
 
                         if not next(accelerator_tree.iter_search_rules([p]))]
 
2723
            unchanged = [(tp, ap) for (tp, ap) in unchanged
 
2724
                         if not next(accelerator_tree.iter_search_rules([ap]))]
2702
2725
        unchanged = dict(unchanged)
2703
2726
        new_desired_files = []
2704
2727
        count = 0
2705
 
        for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2706
 
            accelerator_path = unchanged.get(file_id)
 
2728
        for unused_tree_path, (trans_id, file_id, tree_path, text_sha1) in desired_files:
 
2729
            accelerator_path = unchanged.get(tree_path)
2707
2730
            if accelerator_path is None:
2708
 
                new_desired_files.append((file_id,
2709
 
                    (trans_id, tree_path, text_sha1)))
 
2731
                new_desired_files.append((tree_path,
 
2732
                                          (trans_id, file_id, tree_path, text_sha1)))
2710
2733
                continue
2711
2734
            pb.update(gettext('Adding file contents'), count + offset, total)
2712
2735
            if hardlink:
2713
2736
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2714
2737
                                   trans_id)
2715
2738
            else:
2716
 
                contents = accelerator_tree.get_file(accelerator_path, file_id)
2717
 
                if wt.supports_content_filtering():
2718
 
                    filters = wt._content_filter_stack(tree_path)
2719
 
                    contents = filtered_output_bytes(contents, filters,
2720
 
                        ContentFilterContext(tree_path, tree))
2721
 
                try:
2722
 
                    tt.create_file(contents, trans_id, sha1=text_sha1)
2723
 
                finally:
2724
 
                    try:
2725
 
                        contents.close()
2726
 
                    except AttributeError:
2727
 
                        # after filtering, contents may no longer be file-like
2728
 
                        pass
 
2739
                with accelerator_tree.get_file(accelerator_path) as f:
 
2740
                    chunks = osutils.file_iterator(f)
 
2741
                    if wt.supports_content_filtering():
 
2742
                        filters = wt._content_filter_stack(tree_path)
 
2743
                        chunks = filtered_output_bytes(chunks, filters,
 
2744
                                                       ContentFilterContext(tree_path, tree))
 
2745
                    tt.create_file(chunks, trans_id, sha1=text_sha1)
2729
2746
            count += 1
2730
2747
        offset += count
2731
 
    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
 
2748
    for count, ((trans_id, file_id, tree_path, text_sha1), contents) in enumerate(
2732
2749
            tree.iter_files_bytes(new_desired_files)):
2733
2750
        if wt.supports_content_filtering():
2734
2751
            filters = wt._content_filter_stack(tree_path)
2735
2752
            contents = filtered_output_bytes(contents, filters,
2736
 
                ContentFilterContext(tree_path, tree))
 
2753
                                             ContentFilterContext(tree_path, tree))
2737
2754
        tt.create_file(contents, trans_id, sha1=text_sha1)
2738
2755
        pb.update(gettext('Adding file contents'), count + offset, total)
2739
2756
 
2750
2767
    return by_parent[old_parent]
2751
2768
 
2752
2769
 
2753
 
def _content_match(tree, entry, file_id, kind, target_path):
 
2770
def _content_match(tree, entry, tree_path, kind, target_path):
2754
2771
    if entry.kind != kind:
2755
2772
        return False
2756
2773
    if entry.kind == "directory":
2757
2774
        return True
2758
 
    path = tree.id2path(file_id)
2759
2775
    if entry.kind == "file":
2760
 
        f = file(target_path, 'rb')
2761
 
        try:
2762
 
            if tree.get_file_text(path, file_id) == f.read():
 
2776
        with open(target_path, 'rb') as f1, \
 
2777
                tree.get_file(tree_path) as f2:
 
2778
            if osutils.compare_files(f1, f2):
2763
2779
                return True
2764
 
        finally:
2765
 
            f.close()
2766
2780
    elif entry.kind == "symlink":
2767
 
        if tree.get_symlink_target(path, file_id) == os.readlink(target_path):
 
2781
        if tree.get_symlink_target(tree_path) == os.readlink(target_path):
2768
2782
            return True
2769
2783
    return False
2770
2784
 
2787
2801
        # resolved
2788
2802
        final_parent = tt.final_parent(old_file)
2789
2803
        if new_file in divert:
2790
 
            new_name = tt.final_name(old_file)+'.diverted'
 
2804
            new_name = tt.final_name(old_file) + '.diverted'
2791
2805
            tt.adjust_path(new_name, final_parent, new_file)
2792
2806
            new_conflicts.add((c_type, 'Diverted to',
2793
2807
                               new_file, old_file))
2794
2808
        else:
2795
 
            new_name = tt.final_name(old_file)+'.moved'
 
2809
            new_name = tt.final_name(old_file) + '.moved'
2796
2810
            tt.adjust_path(new_name, final_parent, old_file)
2797
2811
            new_conflicts.add((c_type, 'Moved existing file to',
2798
2812
                               old_file, new_file))
2804
2818
    name = entry.name
2805
2819
    kind = entry.kind
2806
2820
    if kind == 'file':
2807
 
        contents = tree.get_file(path, entry.file_id).readlines()
2808
 
        executable = tree.is_executable(path, entry.file_id)
2809
 
        return tt.new_file(name, parent_id, contents, entry.file_id,
2810
 
                           executable)
 
2821
        with tree.get_file(path) as f:
 
2822
            executable = tree.is_executable(path)
 
2823
            return tt.new_file(
 
2824
                name, parent_id, osutils.file_iterator(f), entry.file_id,
 
2825
                executable)
2811
2826
    elif kind in ('directory', 'tree-reference'):
2812
2827
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
2813
2828
        if kind == 'tree-reference':
2814
2829
            tt.set_tree_reference(entry.reference_revision, trans_id)
2815
2830
        return trans_id
2816
2831
    elif kind == 'symlink':
2817
 
        target = tree.get_symlink_target(path, entry.file_id)
 
2832
        target = tree.get_symlink_target(path)
2818
2833
        return tt.new_symlink(name, parent_id, target, entry.file_id)
2819
2834
    else:
2820
2835
        raise errors.BadFileKindError(name, kind)
2821
2836
 
2822
2837
 
2823
 
def create_from_tree(tt, trans_id, tree, path, file_id=None, bytes=None,
2824
 
    filter_tree_path=None):
 
2838
def create_from_tree(tt, trans_id, tree, path, chunks=None,
 
2839
                     filter_tree_path=None):
2825
2840
    """Create new file contents according to tree contents.
2826
2841
 
2827
2842
    :param filter_tree_path: the tree path to use to lookup
2828
2843
      content filters to apply to the bytes output in the working tree.
2829
2844
      This only applies if the working tree supports content filtering.
2830
2845
    """
2831
 
    kind = tree.kind(path, file_id)
 
2846
    kind = tree.kind(path)
2832
2847
    if kind == 'directory':
2833
2848
        tt.create_directory(trans_id)
2834
2849
    elif kind == "file":
2835
 
        if bytes is None:
2836
 
            tree_file = tree.get_file(path, file_id)
2837
 
            try:
2838
 
                bytes = tree_file.readlines()
2839
 
            finally:
2840
 
                tree_file.close()
2841
 
        wt = tt._tree
2842
 
        if wt.supports_content_filtering() and filter_tree_path is not None:
2843
 
            filters = wt._content_filter_stack(filter_tree_path)
2844
 
            bytes = filtered_output_bytes(bytes, filters,
2845
 
                ContentFilterContext(filter_tree_path, tree))
2846
 
        tt.create_file(bytes, trans_id)
 
2850
        if chunks is None:
 
2851
            f = tree.get_file(path)
 
2852
            chunks = osutils.file_iterator(f)
 
2853
        else:
 
2854
            f = None
 
2855
        try:
 
2856
            wt = tt._tree
 
2857
            if wt.supports_content_filtering() and filter_tree_path is not None:
 
2858
                filters = wt._content_filter_stack(filter_tree_path)
 
2859
                chunks = filtered_output_bytes(
 
2860
                    chunks, filters,
 
2861
                    ContentFilterContext(filter_tree_path, tree))
 
2862
            tt.create_file(chunks, trans_id)
 
2863
        finally:
 
2864
            if f is not None:
 
2865
                f.close()
2847
2866
    elif kind == "symlink":
2848
 
        tt.create_symlink(tree.get_symlink_target(path, file_id), trans_id)
 
2867
        tt.create_symlink(tree.get_symlink_target(path), trans_id)
2849
2868
    else:
2850
2869
        raise AssertionError('Unknown kind %r' % kind)
2851
2870
 
2859
2878
def revert(working_tree, target_tree, filenames, backups=False,
2860
2879
           pb=None, change_reporter=None):
2861
2880
    """Revert a working tree's contents to those of a target tree."""
2862
 
    target_tree.lock_read()
2863
2881
    pb = ui.ui_factory.nested_progress_bar()
2864
 
    tt = TreeTransform(working_tree, pb)
2865
2882
    try:
2866
 
        pp = ProgressPhase("Revert phase", 3, pb)
2867
 
        conflicts, merge_modified = _prepare_revert_transform(
2868
 
            working_tree, target_tree, tt, filenames, backups, pp)
2869
 
        if change_reporter:
2870
 
            change_reporter = delta._ChangeReporter(
2871
 
                unversioned_filter=working_tree.is_ignored)
2872
 
            delta.report_changes(tt.iter_changes(), change_reporter)
2873
 
        for conflict in conflicts:
2874
 
            trace.warning(unicode(conflict))
2875
 
        pp.next_phase()
2876
 
        tt.apply()
2877
 
        working_tree.set_merge_modified(merge_modified)
 
2883
        with target_tree.lock_read(), working_tree.get_transform(pb) as tt:
 
2884
            pp = ProgressPhase("Revert phase", 3, pb)
 
2885
            conflicts, merge_modified = _prepare_revert_transform(
 
2886
                working_tree, target_tree, tt, filenames, backups, pp)
 
2887
            if change_reporter:
 
2888
                change_reporter = delta._ChangeReporter(
 
2889
                    unversioned_filter=working_tree.is_ignored)
 
2890
                delta.report_changes(tt.iter_changes(), change_reporter)
 
2891
            for conflict in conflicts:
 
2892
                trace.warning(str(conflict))
 
2893
            pp.next_phase()
 
2894
            tt.apply()
 
2895
            if working_tree.supports_merge_modified():
 
2896
                working_tree.set_merge_modified(merge_modified)
2878
2897
    finally:
2879
 
        target_tree.unlock()
2880
 
        tt.finalize()
2881
2898
        pb.clear()
2882
2899
    return conflicts
2883
2900
 
2885
2902
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2886
2903
                              backups, pp, basis_tree=None,
2887
2904
                              merge_modified=None):
2888
 
    child_pb = ui.ui_factory.nested_progress_bar()
2889
 
    try:
 
2905
    with ui.ui_factory.nested_progress_bar() as child_pb:
2890
2906
        if merge_modified is None:
2891
2907
            merge_modified = working_tree.merge_modified()
2892
2908
        merge_modified = _alter_files(working_tree, target_tree, tt,
2893
2909
                                      child_pb, filenames, backups,
2894
2910
                                      merge_modified, basis_tree)
2895
 
    finally:
2896
 
        child_pb.finished()
2897
 
    child_pb = ui.ui_factory.nested_progress_bar()
2898
 
    try:
2899
 
        raw_conflicts = resolve_conflicts(tt, child_pb,
2900
 
            lambda t, c: conflict_pass(t, c, target_tree))
2901
 
    finally:
2902
 
        child_pb.finished()
 
2911
    with ui.ui_factory.nested_progress_bar() as child_pb:
 
2912
        raw_conflicts = resolve_conflicts(
 
2913
            tt, child_pb, lambda t, c: conflict_pass(t, c, target_tree))
2903
2914
    conflicts = cook_conflicts(raw_conflicts, tt)
2904
2915
    return conflicts, merge_modified
2905
2916
 
2912
2923
    # than the target changes relative to the working tree. Because WT4 has an
2913
2924
    # optimizer to compare itself to a target, but no optimizer for the
2914
2925
    # reverse.
2915
 
    change_list = working_tree.iter_changes(target_tree,
2916
 
        specific_files=specific_files, pb=pb)
2917
 
    if target_tree.get_root_id() is None:
 
2926
    change_list = working_tree.iter_changes(
 
2927
        target_tree, specific_files=specific_files, pb=pb)
 
2928
    if not target_tree.is_versioned(u''):
2918
2929
        skip_root = True
2919
2930
    else:
2920
2931
        skip_root = False
2921
2932
    try:
2922
2933
        deferred_files = []
2923
 
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2924
 
                kind, executable) in enumerate(change_list):
2925
 
            target_path, wt_path = path
2926
 
            target_versioned, wt_versioned = versioned
2927
 
            target_parent, wt_parent = parent
2928
 
            target_name, wt_name = name
2929
 
            target_kind, wt_kind = kind
2930
 
            target_executable, wt_executable = executable
 
2934
        for id_num, change in enumerate(change_list):
 
2935
            file_id = change.file_id
 
2936
            target_path, wt_path = change.path
 
2937
            target_versioned, wt_versioned = change.versioned
 
2938
            target_parent, wt_parent = change.parent_id
 
2939
            target_name, wt_name = change.name
 
2940
            target_kind, wt_kind = change.kind
 
2941
            target_executable, wt_executable = change.executable
2931
2942
            if skip_root and wt_parent is None:
2932
2943
                continue
2933
2944
            trans_id = tt.trans_id_file_id(file_id)
2934
2945
            mode_id = None
2935
 
            if changed_content:
 
2946
            if change.changed_content:
2936
2947
                keep_content = False
2937
2948
                if wt_kind == 'file' and (backups or target_kind is None):
2938
 
                    wt_sha1 = working_tree.get_file_sha1(wt_path, file_id)
2939
 
                    if merge_modified.get(file_id) != wt_sha1:
 
2949
                    wt_sha1 = working_tree.get_file_sha1(wt_path)
 
2950
                    if merge_modified.get(wt_path) != wt_sha1:
2940
2951
                        # acquire the basis tree lazily to prevent the
2941
2952
                        # expense of accessing it when it's not needed ?
2942
2953
                        # (Guessing, RBC, 200702)
2943
2954
                        if basis_tree is None:
2944
2955
                            basis_tree = working_tree.basis_tree()
2945
2956
                            basis_tree.lock_read()
2946
 
                        try:
2947
 
                            basis_path = basis_tree.id2path(file_id)
2948
 
                        except errors.NoSuchId:
 
2957
                        basis_inter = InterTree.get(basis_tree, working_tree)
 
2958
                        basis_path = basis_inter.find_source_path(wt_path)
 
2959
                        if basis_path is None:
2949
2960
                            if target_kind is None and not target_versioned:
2950
2961
                                keep_content = True
2951
2962
                        else:
2952
 
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path, file_id):
 
2963
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path):
2953
2964
                                keep_content = True
2954
2965
                if wt_kind is not None:
2955
2966
                    if not keep_content:
2971
2982
                    tt.create_directory(trans_id)
2972
2983
                    if target_kind == 'tree-reference':
2973
2984
                        revision = target_tree.get_reference_revision(
2974
 
                                target_path, file_id)
 
2985
                            target_path)
2975
2986
                        tt.set_tree_reference(revision, trans_id)
2976
2987
                elif target_kind == 'symlink':
2977
2988
                    tt.create_symlink(target_tree.get_symlink_target(
2978
 
                            target_path, file_id), trans_id)
 
2989
                        target_path), trans_id)
2979
2990
                elif target_kind == 'file':
2980
 
                    deferred_files.append((file_id, (trans_id, mode_id)))
 
2991
                    deferred_files.append(
 
2992
                        (target_path, (trans_id, mode_id, file_id)))
2981
2993
                    if basis_tree is None:
2982
2994
                        basis_tree = working_tree.basis_tree()
2983
2995
                        basis_tree.lock_read()
2984
 
                    new_sha1 = target_tree.get_file_sha1(target_path, file_id)
2985
 
                    try:
2986
 
                        basis_path = basis_tree.id2path(file_id)
2987
 
                    except errors.NoSuchId:
2988
 
                        basis_path = None
 
2996
                    new_sha1 = target_tree.get_file_sha1(target_path)
 
2997
                    basis_inter = InterTree.get(basis_tree, target_tree)
 
2998
                    basis_path = basis_inter.find_source_path(target_path)
2989
2999
                    if (basis_path is not None and
2990
 
                        new_sha1 == basis_tree.get_file_sha1(basis_path, file_id)):
2991
 
                        if file_id in merge_modified:
2992
 
                            del merge_modified[file_id]
 
3000
                            new_sha1 == basis_tree.get_file_sha1(basis_path)):
 
3001
                        # If the new contents of the file match what is in basis,
 
3002
                        # then there is no need to store in merge_modified.
 
3003
                        if basis_path in merge_modified:
 
3004
                            del merge_modified[basis_path]
2993
3005
                    else:
2994
 
                        merge_modified[file_id] = new_sha1
 
3006
                        merge_modified[target_path] = new_sha1
2995
3007
 
2996
3008
                    # preserve the execute bit when backing up
2997
3009
                    if keep_content and wt_executable == target_executable:
3002
3014
                tt.version_file(file_id, trans_id)
3003
3015
            if wt_versioned and not target_versioned:
3004
3016
                tt.unversion_file(trans_id)
3005
 
            if (target_name is not None and
3006
 
                (wt_name != target_name or wt_parent != target_parent)):
 
3017
            if (target_name is not None
 
3018
                    and (wt_name != target_name or wt_parent != target_parent)):
3007
3019
                if target_name == '' and target_parent is None:
3008
3020
                    parent_trans = ROOT_PARENT
3009
3021
                else:
3015
3027
            if wt_executable != target_executable and target_kind == "file":
3016
3028
                tt.set_executability(target_executable, trans_id)
3017
3029
        if working_tree.supports_content_filtering():
3018
 
            for index, ((trans_id, mode_id), bytes) in enumerate(
3019
 
                target_tree.iter_files_bytes(deferred_files)):
3020
 
                file_id = deferred_files[index][0]
 
3030
            for (trans_id, mode_id, file_id), bytes in (
 
3031
                    target_tree.iter_files_bytes(deferred_files)):
3021
3032
                # We're reverting a tree to the target tree so using the
3022
3033
                # target tree to find the file path seems the best choice
3023
3034
                # here IMO - Ian C 27/Oct/2009
3024
3035
                filter_tree_path = target_tree.id2path(file_id)
3025
3036
                filters = working_tree._content_filter_stack(filter_tree_path)
3026
 
                bytes = filtered_output_bytes(bytes, filters,
 
3037
                bytes = filtered_output_bytes(
 
3038
                    bytes, filters,
3027
3039
                    ContentFilterContext(filter_tree_path, working_tree))
3028
3040
                tt.create_file(bytes, trans_id, mode_id)
3029
3041
        else:
3030
 
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
3031
 
                deferred_files):
 
3042
            for (trans_id, mode_id, file_id), bytes in target_tree.iter_files_bytes(
 
3043
                    deferred_files):
3032
3044
                tt.create_file(bytes, trans_id, mode_id)
3033
3045
        tt.fixup_new_roots()
3034
3046
    finally:
3042
3054
    if pass_func is None:
3043
3055
        pass_func = conflict_pass
3044
3056
    new_conflicts = set()
3045
 
    pb = ui.ui_factory.nested_progress_bar()
3046
 
    try:
 
3057
    with ui.ui_factory.nested_progress_bar() as pb:
3047
3058
        for n in range(10):
3048
 
            pb.update(gettext('Resolution pass'), n+1, 10)
 
3059
            pb.update(gettext('Resolution pass'), n + 1, 10)
3049
3060
            conflicts = tt.find_conflicts()
3050
3061
            if len(conflicts) == 0:
3051
3062
                return new_conflicts
3052
3063
            new_conflicts.update(pass_func(tt, conflicts))
3053
3064
        raise MalformedTransform(conflicts=conflicts)
3054
 
    finally:
3055
 
        pb.finished()
3056
3065
 
3057
3066
 
3058
3067
def conflict_pass(tt, conflicts, path_tree=None):
3123
3132
                        if file_id is None:
3124
3133
                            file_id = tt.inactive_file_id(trans_id)
3125
3134
                        _, entry = next(path_tree.iter_entries_by_dir(
3126
 
                            [file_id]))
 
3135
                            specific_files=[path_tree.id2path(file_id)]))
3127
3136
                        # special-case the other tree root (move its
3128
3137
                        # children to current root)
3129
3138
                        if entry.parent_id is None:
3144
3153
        elif c_type == 'unversioned parent':
3145
3154
            file_id = tt.inactive_file_id(conflict[1])
3146
3155
            # special-case the other tree root (move its children instead)
3147
 
            if path_tree and path_tree.has_id(file_id):
3148
 
                if path_tree.path2id('') == file_id:
3149
 
                    # This is the root entry, skip it
3150
 
                    continue
 
3156
            if path_tree and path_tree.path2id('') == file_id:
 
3157
                # This is the root entry, skip it
 
3158
                continue
3151
3159
            tt.version_file(file_id, conflict[1])
3152
3160
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
3153
3161
        elif c_type == 'non-directory parent':
3156
3164
            parent_name = tt.final_name(parent_id)
3157
3165
            parent_file_id = tt.final_file_id(parent_id)
3158
3166
            new_parent_id = tt.new_directory(parent_name + '.new',
3159
 
                parent_parent, parent_file_id)
 
3167
                                             parent_parent, parent_file_id)
3160
3168
            _reparent_transform_children(tt, parent_id, new_parent_id)
3161
3169
            if parent_file_id is not None:
3162
3170
                tt.unversion_file(parent_id)
3230
3238
            except OSError as e:
3231
3239
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
3232
3240
        # after rollback, don't reuse _FileMover
3233
 
        past_renames = None
3234
 
        pending_deletions = None
 
3241
        self.past_renames = None
 
3242
        self.pending_deletions = None
3235
3243
 
3236
3244
    def apply_deletions(self):
3237
3245
        """Apply all marked deletions"""
3238
3246
        for path in self.pending_deletions:
3239
3247
            delete_any(path)
3240
3248
        # after apply_deletions, don't reuse _FileMover
3241
 
        past_renames = None
3242
 
        pending_deletions = None
 
3249
        self.past_renames = None
 
3250
        self.pending_deletions = None
3243
3251
 
3244
3252
 
3245
3253
def link_tree(target_tree, source_tree):
3248
3256
    :param target_tree: Tree to change
3249
3257
    :param source_tree: Tree to hard-link from
3250
3258
    """
3251
 
    tt = TreeTransform(target_tree)
3252
 
    try:
3253
 
        for (file_id, paths, changed_content, versioned, parent, name, kind,
3254
 
             executable) in target_tree.iter_changes(source_tree,
3255
 
             include_unchanged=True):
3256
 
            if changed_content:
3257
 
                continue
3258
 
            if kind != ('file', 'file'):
3259
 
                continue
3260
 
            if executable[0] != executable[1]:
3261
 
                continue
3262
 
            trans_id = tt.trans_id_tree_file_id(file_id)
 
3259
    with target_tree.get_transform() as tt:
 
3260
        for change in target_tree.iter_changes(source_tree, include_unchanged=True):
 
3261
            if change.changed_content:
 
3262
                continue
 
3263
            if change.kind != ('file', 'file'):
 
3264
                continue
 
3265
            if change.executable[0] != change.executable[1]:
 
3266
                continue
 
3267
            trans_id = tt.trans_id_tree_path(change.path[1])
3263
3268
            tt.delete_contents(trans_id)
3264
 
            tt.create_hardlink(source_tree.id2abspath(file_id), trans_id)
 
3269
            tt.create_hardlink(source_tree.abspath(change.path[0]), trans_id)
3265
3270
        tt.apply()
3266
 
    finally:
3267
 
        tt.finalize()