← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
import os
18
18
import errno
19
19
from stat import S_ISREG
 
20
import tempfile
20
21
 
21
22
from bzrlib.lazy_import import lazy_import
22
23
lazy_import(globals(), """
29
30
""")
30
31
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
31
32
                           ReusingTransform, NotVersionedError, CantMoveRoot,
32
 
                           ExistingLimbo, ImmortalLimbo, NoFinalPath)
 
33
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
 
34
                           UnableCreateSymlink)
33
35
from bzrlib.inventory import InventoryEntry
34
36
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
35
 
                            delete_any)
 
37
                            delete_any, has_symlinks)
36
38
from bzrlib.progress import DummyProgress, ProgressPhase
37
 
from bzrlib.symbol_versioning import deprecated_function, zero_fifteen
 
39
from bzrlib.symbol_versioning import (
 
40
        deprecated_function,
 
41
        zero_fifteen,
 
42
        zero_ninety,
 
43
        )
38
44
from bzrlib.trace import mutter, warning
39
45
from bzrlib import tree
40
46
import bzrlib.ui
51
57
 
52
58
 
53
59
class _TransformResults(object):
54
 
    def __init__(self, modified_paths):
 
60
    def __init__(self, modified_paths, rename_count):
55
61
        object.__init__(self)
56
62
        self.modified_paths = modified_paths
57
 
 
58
 
 
59
 
class TreeTransform(object):
60
 
    """Represent a tree transformation.
61
 
    
62
 
    This object is designed to support incremental generation of the transform,
63
 
    in any order.  
64
 
    
65
 
    It is easy to produce malformed transforms, but they are generally
66
 
    harmless.  Attempting to apply a malformed transform will cause an
67
 
    exception to be raised before any modifications are made to the tree.  
68
 
 
69
 
    Many kinds of malformed transforms can be corrected with the 
70
 
    resolve_conflicts function.  The remaining ones indicate programming error,
71
 
    such as trying to create a file with no path.
72
 
 
73
 
    Two sets of file creation methods are supplied.  Convenience methods are:
74
 
     * new_file
75
 
     * new_directory
76
 
     * new_symlink
77
 
 
78
 
    These are composed of the low-level methods:
79
 
     * create_path
80
 
     * create_file or create_directory or create_symlink
81
 
     * version_file
82
 
     * set_executability
83
 
    """
84
 
    def __init__(self, tree, pb=DummyProgress()):
85
 
        """Note: a tree_write lock is taken on the tree.
86
 
        
87
 
        Use TreeTransform.finalize() to release the lock
 
63
        self.rename_count = rename_count
 
64
 
 
65
 
 
66
class TreeTransformBase(object):
 
67
    """The base class for TreeTransform and TreeTransformBase"""
 
68
 
 
69
    def __init__(self, tree, limbodir, pb=DummyProgress(),
 
70
                 case_sensitive=True):
 
71
        """Constructor.
 
72
 
 
73
        :param tree: The tree that will be transformed, but not necessarily
 
74
            the output tree.
 
75
        :param limbodir: A directory where new files can be stored until
 
76
            they are installed in their proper places
 
77
        :param pb: A ProgressBar indicating how much progress is being made
 
78
        :param case_sensitive: If True, the target of the transform is
 
79
            case sensitive, not just case preserving.
88
80
        """
89
81
        object.__init__(self)
90
82
        self._tree = tree
91
 
        self._tree.lock_tree_write()
92
 
        try:
93
 
            control_files = self._tree._control_files
94
 
            self._limbodir = urlutils.local_path_from_url(
95
 
                control_files.controlfilename('limbo'))
96
 
            try:
97
 
                os.mkdir(self._limbodir)
98
 
            except OSError, e:
99
 
                if e.errno == errno.EEXIST:
100
 
                    raise ExistingLimbo(self._limbodir)
101
 
        except: 
102
 
            self._tree.unlock()
103
 
            raise
104
 
 
 
83
        self._limbodir = limbodir
 
84
        self._deletiondir = None
105
85
        self._id_number = 0
 
86
        # mapping of trans_id -> new basename
106
87
        self._new_name = {}
 
88
        # mapping of trans_id -> new parent trans_id
107
89
        self._new_parent = {}
 
90
        # mapping of trans_id with new contents -> new file_kind
108
91
        self._new_contents = {}
 
92
        # A mapping of transform ids to their limbo filename
 
93
        self._limbo_files = {}
 
94
        # A mapping of transform ids to a set of the transform ids of children
 
95
        # that their limbo directory has
 
96
        self._limbo_children = {}
 
97
        # Map transform ids to maps of child filename to child transform id
 
98
        self._limbo_children_names = {}
 
99
        # List of transform ids that need to be renamed from limbo into place
 
100
        self._needs_rename = set()
 
101
        # Set of trans_ids whose contents will be removed
109
102
        self._removed_contents = set()
 
103
        # Mapping of trans_id -> new execute-bit value
110
104
        self._new_executability = {}
 
105
        # Mapping of trans_id -> new tree-reference value
111
106
        self._new_reference_revision = {}
 
107
        # Mapping of trans_id -> new file_id
112
108
        self._new_id = {}
 
109
        # Mapping of old file-id -> trans_id
113
110
        self._non_present_ids = {}
 
111
        # Mapping of new file_id -> trans_id
114
112
        self._r_new_id = {}
 
113
        # Set of file_ids that will be removed
115
114
        self._removed_id = set()
 
115
        # Mapping of path in old tree -> trans_id
116
116
        self._tree_path_ids = {}
 
117
        # Mapping trans_id -> path in old tree
117
118
        self._tree_id_paths = {}
 
119
        # Cache of realpath results, to speed up canonical_path
118
120
        self._realpaths = {}
119
 
        # Cache of realpath results, to speed up canonical_path
 
121
        # Cache of relpath results, to speed up canonical_path
120
122
        self._relpaths = {}
121
 
        # Cache of relpath results, to speed up canonical_path
 
123
        # The trans_id that will be used as the tree root
122
124
        self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
123
 
        self.__done = False
 
125
        # Indictor of whether the transform has been applied
 
126
        self._done = False
 
127
        # A progress bar
124
128
        self._pb = pb
 
129
        # Whether the target is case sensitive
 
130
        self._case_sensitive_target = case_sensitive
 
131
        # A counter of how many files have been renamed
 
132
        self.rename_count = 0
125
133
 
126
134
    def __get_root(self):
127
135
        return self._new_root
129
137
    root = property(__get_root)
130
138
 
131
139
    def finalize(self):
132
 
        """Release the working tree lock, if held, clean up limbo dir."""
 
140
        """Release the working tree lock, if held, clean up limbo dir.
 
141
 
 
142
        This is required if apply has not been invoked, but can be invoked
 
143
        even after apply.
 
144
        """
133
145
        if self._tree is None:
134
146
            return
135
147
        try:
136
 
            for trans_id, kind in self._new_contents.iteritems():
137
 
                path = self._limbo_name(trans_id)
 
148
            entries = [(self._limbo_name(t), t, k) for t, k in
 
149
                       self._new_contents.iteritems()]
 
150
            entries.sort(reverse=True)
 
151
            for path, trans_id, kind in entries:
138
152
                if kind == "directory":
139
153
                    os.rmdir(path)
140
154
                else:
144
158
            except OSError:
145
159
                # We don't especially care *why* the dir is immortal.
146
160
                raise ImmortalLimbo(self._limbodir)
 
161
            try:
 
162
                if self._deletiondir is not None:
 
163
                    os.rmdir(self._deletiondir)
 
164
            except OSError:
 
165
                raise errors.ImmortalPendingDeletion(self._deletiondir)
147
166
        finally:
148
167
            self._tree.unlock()
149
168
            self._tree = None
165
184
        """Change the path that is assigned to a transaction id."""
166
185
        if trans_id == self._new_root:
167
186
            raise CantMoveRoot
 
187
        previous_parent = self._new_parent.get(trans_id)
 
188
        previous_name = self._new_name.get(trans_id)
168
189
        self._new_name[trans_id] = name
169
190
        self._new_parent[trans_id] = parent
 
191
        if (trans_id in self._limbo_files and
 
192
            trans_id not in self._needs_rename):
 
193
            self._rename_in_limbo([trans_id])
 
194
            self._limbo_children[previous_parent].remove(trans_id)
 
195
            del self._limbo_children_names[previous_parent][previous_name]
 
196
 
 
197
    def _rename_in_limbo(self, trans_ids):
 
198
        """Fix limbo names so that the right final path is produced.
 
199
 
 
200
        This means we outsmarted ourselves-- we tried to avoid renaming
 
201
        these files later by creating them with their final names in their
 
202
        final parents.  But now the previous name or parent is no longer
 
203
        suitable, so we have to rename them.
 
204
 
 
205
        Even for trans_ids that have no new contents, we must remove their
 
206
        entries from _limbo_files, because they are now stale.
 
207
        """
 
208
        for trans_id in trans_ids:
 
209
            old_path = self._limbo_files.pop(trans_id)
 
210
            if trans_id not in self._new_contents:
 
211
                continue
 
212
            new_path = self._limbo_name(trans_id)
 
213
            os.rename(old_path, new_path)
170
214
 
171
215
    def adjust_root_path(self, name, parent):
172
216
        """Emulate moving the root by moving all children, instead.
206
250
        This reflects only files that already exist, not ones that will be
207
251
        added by transactions.
208
252
        """
209
 
        path = self._tree.inventory.id2path(inventory_id)
 
253
        path = self._tree.id2path(inventory_id)
210
254
        return self.trans_id_tree_path(path)
211
255
 
212
256
    def trans_id_file_id(self, file_id):
310
354
        if typefunc(mode):
311
355
            os.chmod(self._limbo_name(trans_id), mode)
312
356
 
 
357
    def create_hardlink(self, path, trans_id):
 
358
        """Schedule creation of a hard link"""
 
359
        name = self._limbo_name(trans_id)
 
360
        try:
 
361
            os.link(path, name)
 
362
        except OSError, e:
 
363
            if e.errno != errno.EPERM:
 
364
                raise
 
365
            raise errors.HardLinkNotSupported(path)
 
366
        try:
 
367
            unique_add(self._new_contents, trans_id, 'file')
 
368
        except:
 
369
            # Clean up the file, it never got registered so
 
370
            # TreeTransform.finalize() won't clean it up.
 
371
            os.unlink(name)
 
372
            raise
 
373
 
313
374
    def create_directory(self, trans_id):
314
375
        """Schedule creation of a new directory.
315
376
        
324
385
        target is a bytestring.
325
386
        See also new_symlink.
326
387
        """
327
 
        os.symlink(target, self._limbo_name(trans_id))
328
 
        unique_add(self._new_contents, trans_id, 'symlink')
 
388
        if has_symlinks():
 
389
            os.symlink(target, self._limbo_name(trans_id))
 
390
            unique_add(self._new_contents, trans_id, 'symlink')
 
391
        else:
 
392
            try:
 
393
                path = FinalPaths(self).get_path(trans_id)
 
394
            except KeyError:
 
395
                path = None
 
396
            raise UnableCreateSymlink(path=path)
329
397
 
330
398
    def cancel_creation(self, trans_id):
331
399
        """Cancel the creation of new file contents."""
332
400
        del self._new_contents[trans_id]
 
401
        children = self._limbo_children.get(trans_id)
 
402
        # if this is a limbo directory with children, move them before removing
 
403
        # the directory
 
404
        if children is not None:
 
405
            self._rename_in_limbo(children)
 
406
            del self._limbo_children[trans_id]
 
407
            del self._limbo_children_names[trans_id]
333
408
        delete_any(self._limbo_name(trans_id))
334
409
 
335
410
    def delete_contents(self, trans_id):
425
500
            return None
426
501
        # the file is old; the old id is still valid
427
502
        if self._new_root == trans_id:
428
 
            return self._tree.inventory.root.file_id
 
503
            return self._tree.get_root_id()
429
504
        return self._tree.inventory.path2id(path)
430
505
 
431
506
    def final_file_id(self, trans_id):
499
574
 
500
575
    def find_conflicts(self):
501
576
        """Find any violations of inventory or filesystem invariants"""
502
 
        if self.__done is True:
 
577
        if self._done is True:
503
578
            raise ReusingTransform()
504
579
        conflicts = []
505
580
        # ensure all children of all existent parents are known
527
602
                        self.tree_kind(t) == 'directory'])
528
603
        for trans_id in self._removed_id:
529
604
            file_id = self.tree_file_id(trans_id)
530
 
            if self._tree.inventory[file_id].kind == 'directory':
 
605
            if file_id is not None:
 
606
                if self._tree.inventory[file_id].kind == 'directory':
 
607
                    parents.append(trans_id)
 
608
            elif self.tree_kind(trans_id) == 'directory':
531
609
                parents.append(trans_id)
532
610
 
533
611
        for parent_id in parents:
543
621
        try:
544
622
            children = os.listdir(self._tree.abspath(path))
545
623
        except OSError, e:
546
 
            if e.errno != errno.ENOENT and e.errno != errno.ESRCH:
 
624
            if e.errno not in (errno.ENOENT, errno.ESRCH, errno.ENOTDIR):
547
625
                raise
548
626
            return
549
627
            
663
741
    def _duplicate_entries(self, by_parent):
664
742
        """No directory may have two entries with the same name."""
665
743
        conflicts = []
 
744
        if (self._new_name, self._new_parent) == ({}, {}):
 
745
            return conflicts
666
746
        for children in by_parent.itervalues():
667
747
            name_ids = [(self.final_name(t), t) for t in children]
 
748
            if not self._case_sensitive_target:
 
749
                name_ids = [(n.lower(), t) for n, t in name_ids]
668
750
            name_ids.sort()
669
751
            last_name = None
670
752
            last_trans_id = None
688
770
        conflicts = []
689
771
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
690
772
                                self._removed_id))
691
 
        active_tree_ids = set((f for f in self._tree.inventory if
692
 
                               f not in removed_tree_ids))
 
773
        all_ids = self._tree.all_file_ids()
 
774
        active_tree_ids = all_ids.difference(removed_tree_ids)
693
775
        for trans_id, file_id in self._new_id.iteritems():
694
776
            if file_id in active_tree_ids:
695
777
                old_trans_id = self.trans_id_tree_file_id(file_id)
728
810
                continue
729
811
            return True
730
812
        return False
731
 
            
732
 
    def apply(self):
733
 
        """Apply all changes to the inventory and filesystem.
734
 
        
735
 
        If filesystem or inventory conflicts are present, MalformedTransform
736
 
        will be thrown.
737
 
        """
738
 
        conflicts = self.find_conflicts()
739
 
        if len(conflicts) != 0:
740
 
            raise MalformedTransform(conflicts=conflicts)
741
 
        inv = self._tree.inventory
742
 
        inventory_delta = []
743
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
744
 
        try:
745
 
            child_pb.update('Apply phase', 0, 2)
746
 
            self._apply_removals(inv, inventory_delta)
747
 
            child_pb.update('Apply phase', 1, 2)
748
 
            modified_paths = self._apply_insertions(inv, inventory_delta)
749
 
        finally:
750
 
            child_pb.finished()
751
 
        self._tree.apply_inventory_delta(inventory_delta)
752
 
        self.__done = True
753
 
        self.finalize()
754
 
        return _TransformResults(modified_paths)
755
813
 
756
814
    def _limbo_name(self, trans_id):
757
815
        """Generate the limbo name of a file"""
758
 
        return pathjoin(self._limbodir, trans_id)
759
 
 
760
 
    def _apply_removals(self, inv, inventory_delta):
761
 
        """Perform tree operations that remove directory/inventory names.
762
 
        
763
 
        That is, delete files that are to be deleted, and put any files that
764
 
        need renaming into limbo.  This must be done in strict child-to-parent
765
 
        order.
766
 
        """
767
 
        tree_paths = list(self._tree_path_ids.iteritems())
768
 
        tree_paths.sort(reverse=True)
769
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
770
 
        try:
771
 
            for num, data in enumerate(tree_paths):
772
 
                path, trans_id = data
773
 
                child_pb.update('removing file', num, len(tree_paths))
774
 
                full_path = self._tree.abspath(path)
775
 
                if trans_id in self._removed_contents:
776
 
                    delete_any(full_path)
777
 
                elif trans_id in self._new_name or trans_id in \
778
 
                    self._new_parent:
779
 
                    try:
780
 
                        os.rename(full_path, self._limbo_name(trans_id))
781
 
                    except OSError, e:
782
 
                        if e.errno != errno.ENOENT:
783
 
                            raise
784
 
                if trans_id in self._removed_id:
785
 
                    if trans_id == self._new_root:
786
 
                        file_id = self._tree.inventory.root.file_id
787
 
                    else:
788
 
                        file_id = self.tree_file_id(trans_id)
789
 
                    assert file_id is not None
790
 
                    inventory_delta.append((path, None, file_id, None))
791
 
        finally:
792
 
            child_pb.finished()
793
 
 
794
 
    def _apply_insertions(self, inv, inventory_delta):
795
 
        """Perform tree operations that insert directory/inventory names.
796
 
        
797
 
        That is, create any files that need to be created, and restore from
798
 
        limbo any files that needed renaming.  This must be done in strict
799
 
        parent-to-child order.
800
 
        """
801
 
        new_paths = self.new_paths()
802
 
        modified_paths = []
803
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
804
 
        try:
805
 
            for num, (path, trans_id) in enumerate(new_paths):
806
 
                new_entry = None
807
 
                child_pb.update('adding file', num, len(new_paths))
808
 
                try:
809
 
                    kind = self._new_contents[trans_id]
810
 
                except KeyError:
811
 
                    kind = contents = None
812
 
                if trans_id in self._new_contents or \
813
 
                    self.path_changed(trans_id):
814
 
                    full_path = self._tree.abspath(path)
815
 
                    try:
816
 
                        os.rename(self._limbo_name(trans_id), full_path)
817
 
                    except OSError, e:
818
 
                        # We may be renaming a dangling inventory id
819
 
                        if e.errno != errno.ENOENT:
820
 
                            raise
821
 
                    if trans_id in self._new_contents:
822
 
                        modified_paths.append(full_path)
823
 
                        del self._new_contents[trans_id]
824
 
 
825
 
                if trans_id in self._new_id:
826
 
                    if kind is None:
827
 
                        kind = file_kind(self._tree.abspath(path))
828
 
                    if trans_id in self._new_reference_revision:
829
 
                        new_entry = inventory.TreeReference(
830
 
                            self._new_id[trans_id],
831
 
                            self._new_name[trans_id], 
832
 
                            self.final_file_id(self._new_parent[trans_id]),
833
 
                            None, self._new_reference_revision[trans_id])
834
 
                    else:
835
 
                        new_entry = inventory.make_entry(kind,
836
 
                            self.final_name(trans_id),
837
 
                            self.final_file_id(self.final_parent(trans_id)),
838
 
                            self._new_id[trans_id])
 
816
        limbo_name = self._limbo_files.get(trans_id)
 
817
        if limbo_name is not None:
 
818
            return limbo_name
 
819
        parent = self._new_parent.get(trans_id)
 
820
        # if the parent directory is already in limbo (e.g. when building a
 
821
        # tree), choose a limbo name inside the parent, to reduce further
 
822
        # renames.
 
823
        use_direct_path = False
 
824
        if self._new_contents.get(parent) == 'directory':
 
825
            filename = self._new_name.get(trans_id)
 
826
            if filename is not None:
 
827
                if parent not in self._limbo_children:
 
828
                    self._limbo_children[parent] = set()
 
829
                    self._limbo_children_names[parent] = {}
 
830
                    use_direct_path = True
 
831
                # the direct path can only be used if no other file has
 
832
                # already taken this pathname, i.e. if the name is unused, or
 
833
                # if it is already associated with this trans_id.
 
834
                elif self._case_sensitive_target:
 
835
                    if (self._limbo_children_names[parent].get(filename)
 
836
                        in (trans_id, None)):
 
837
                        use_direct_path = True
839
838
                else:
840
 
                    if trans_id in self._new_name or trans_id in\
841
 
                        self._new_parent or\
842
 
                        trans_id in self._new_executability:
843
 
                        file_id = self.final_file_id(trans_id)
844
 
                        if file_id is not None:
845
 
                            entry = inv[file_id]
846
 
                            new_entry = entry.copy()
847
 
 
848
 
                    if trans_id in self._new_name or trans_id in\
849
 
                        self._new_parent:
850
 
                            if new_entry is not None:
851
 
                                new_entry.name = self.final_name(trans_id)
852
 
                                parent = self.final_parent(trans_id)
853
 
                                parent_id = self.final_file_id(parent)
854
 
                                new_entry.parent_id = parent_id
855
 
 
856
 
                if trans_id in self._new_executability:
857
 
                    self._set_executability(path, new_entry, trans_id)
858
 
                if new_entry is not None:
859
 
                    if new_entry.file_id in inv:
860
 
                        old_path = inv.id2path(new_entry.file_id)
 
839
                    for l_filename, l_trans_id in\
 
840
                        self._limbo_children_names[parent].iteritems():
 
841
                        if l_trans_id == trans_id:
 
842
                            continue
 
843
                        if l_filename.lower() == filename.lower():
 
844
                            break
861
845
                    else:
862
 
                        old_path = None
863
 
                    inventory_delta.append((old_path, path,
864
 
                                            new_entry.file_id,
865
 
                                            new_entry))
866
 
        finally:
867
 
            child_pb.finished()
868
 
        return modified_paths
 
846
                        use_direct_path = True
 
847
 
 
848
        if use_direct_path:
 
849
            limbo_name = pathjoin(self._limbo_files[parent], filename)
 
850
            self._limbo_children[parent].add(trans_id)
 
851
            self._limbo_children_names[parent][filename] = trans_id
 
852
        else:
 
853
            limbo_name = pathjoin(self._limbodir, trans_id)
 
854
            self._needs_rename.add(trans_id)
 
855
        self._limbo_files[trans_id] = limbo_name
 
856
        return limbo_name
869
857
 
870
858
    def _set_executability(self, path, entry, trans_id):
871
859
        """Set the executability of versioned files """
1014
1002
            to_executable = False
1015
1003
        return to_name, to_parent, to_kind, to_executable
1016
1004
 
1017
 
    def _iter_changes(self):
1018
 
        """Produce output in the same format as Tree._iter_changes.
 
1005
    def iter_changes(self):
 
1006
        """Produce output in the same format as Tree.iter_changes.
1019
1007
 
1020
1008
        Will produce nonsensical results if invoked while inventory/filesystem
1021
1009
        conflicts (as reported by TreeTransform.find_conflicts()) are present.
1076
1064
                   (from_executable, to_executable)))
1077
1065
        return iter(sorted(results, key=lambda x:x[1]))
1078
1066
 
 
1067
    def get_preview_tree(self):
 
1068
        """Return a tree representing the result of the transform.
 
1069
 
 
1070
        This tree only supports the subset of Tree functionality required
 
1071
        by show_diff_trees.  It must only be compared to tt._tree.
 
1072
        """
 
1073
        return _PreviewTree(self)
 
1074
 
 
1075
 
 
1076
class TreeTransform(TreeTransformBase):
 
1077
    """Represent a tree transformation.
 
1078
 
 
1079
    This object is designed to support incremental generation of the transform,
 
1080
    in any order.
 
1081
 
 
1082
    However, it gives optimum performance when parent directories are created
 
1083
    before their contents.  The transform is then able to put child files
 
1084
    directly in their parent directory, avoiding later renames.
 
1085
 
 
1086
    It is easy to produce malformed transforms, but they are generally
 
1087
    harmless.  Attempting to apply a malformed transform will cause an
 
1088
    exception to be raised before any modifications are made to the tree.
 
1089
 
 
1090
    Many kinds of malformed transforms can be corrected with the
 
1091
    resolve_conflicts function.  The remaining ones indicate programming error,
 
1092
    such as trying to create a file with no path.
 
1093
 
 
1094
    Two sets of file creation methods are supplied.  Convenience methods are:
 
1095
     * new_file
 
1096
     * new_directory
 
1097
     * new_symlink
 
1098
 
 
1099
    These are composed of the low-level methods:
 
1100
     * create_path
 
1101
     * create_file or create_directory or create_symlink
 
1102
     * version_file
 
1103
     * set_executability
 
1104
 
 
1105
    Transform/Transaction ids
 
1106
    -------------------------
 
1107
    trans_ids are temporary ids assigned to all files involved in a transform.
 
1108
    It's possible, even common, that not all files in the Tree have trans_ids.
 
1109
 
 
1110
    trans_ids are used because filenames and file_ids are not good enough
 
1111
    identifiers; filenames change, and not all files have file_ids.  File-ids
 
1112
    are also associated with trans-ids, so that moving a file moves its
 
1113
    file-id.
 
1114
 
 
1115
    trans_ids are only valid for the TreeTransform that generated them.
 
1116
 
 
1117
    Limbo
 
1118
    -----
 
1119
    Limbo is a temporary directory use to hold new versions of files.
 
1120
    Files are added to limbo by create_file, create_directory, create_symlink,
 
1121
    and their convenience variants (new_*).  Files may be removed from limbo
 
1122
    using cancel_creation.  Files are renamed from limbo into their final
 
1123
    location as part of TreeTransform.apply
 
1124
 
 
1125
    Limbo must be cleaned up, by either calling TreeTransform.apply or
 
1126
    calling TreeTransform.finalize.
 
1127
 
 
1128
    Files are placed into limbo inside their parent directories, where
 
1129
    possible.  This reduces subsequent renames, and makes operations involving
 
1130
    lots of files faster.  This optimization is only possible if the parent
 
1131
    directory is created *before* creating any of its children, so avoid
 
1132
    creating children before parents, where possible.
 
1133
 
 
1134
    Pending-deletion
 
1135
    ----------------
 
1136
    This temporary directory is used by _FileMover for storing files that are
 
1137
    about to be deleted.  In case of rollback, the files will be restored.
 
1138
    FileMover does not delete files until it is sure that a rollback will not
 
1139
    happen.
 
1140
    """
 
1141
    def __init__(self, tree, pb=DummyProgress()):
 
1142
        """Note: a tree_write lock is taken on the tree.
 
1143
 
 
1144
        Use TreeTransform.finalize() to release the lock (can be omitted if
 
1145
        TreeTransform.apply() called).
 
1146
        """
 
1147
        tree.lock_tree_write()
 
1148
 
 
1149
        try:
 
1150
            control_files = tree._control_files
 
1151
            limbodir = urlutils.local_path_from_url(
 
1152
                control_files.controlfilename('limbo'))
 
1153
            try:
 
1154
                os.mkdir(limbodir)
 
1155
            except OSError, e:
 
1156
                if e.errno == errno.EEXIST:
 
1157
                    raise ExistingLimbo(limbodir)
 
1158
            deletiondir = urlutils.local_path_from_url(
 
1159
                control_files.controlfilename('pending-deletion'))
 
1160
            try:
 
1161
                os.mkdir(deletiondir)
 
1162
            except OSError, e:
 
1163
                if e.errno == errno.EEXIST:
 
1164
                    raise errors.ExistingPendingDeletion(deletiondir)
 
1165
        except:
 
1166
            tree.unlock()
 
1167
            raise
 
1168
 
 
1169
        TreeTransformBase.__init__(self, tree, limbodir, pb,
 
1170
                                   tree.case_sensitive)
 
1171
        self._deletiondir = deletiondir
 
1172
 
 
1173
    def apply(self, no_conflicts=False, _mover=None):
 
1174
        """Apply all changes to the inventory and filesystem.
 
1175
 
 
1176
        If filesystem or inventory conflicts are present, MalformedTransform
 
1177
        will be thrown.
 
1178
 
 
1179
        If apply succeeds, finalize is not necessary.
 
1180
 
 
1181
        :param no_conflicts: if True, the caller guarantees there are no
 
1182
            conflicts, so no check is made.
 
1183
        :param _mover: Supply an alternate FileMover, for testing
 
1184
        """
 
1185
        if not no_conflicts:
 
1186
            conflicts = self.find_conflicts()
 
1187
            if len(conflicts) != 0:
 
1188
                raise MalformedTransform(conflicts=conflicts)
 
1189
        inventory_delta = []
 
1190
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1191
        try:
 
1192
            if _mover is None:
 
1193
                mover = _FileMover()
 
1194
            else:
 
1195
                mover = _mover
 
1196
            try:
 
1197
                child_pb.update('Apply phase', 0, 2)
 
1198
                self._apply_removals(inventory_delta, mover)
 
1199
                child_pb.update('Apply phase', 1, 2)
 
1200
                modified_paths = self._apply_insertions(inventory_delta, mover)
 
1201
            except:
 
1202
                mover.rollback()
 
1203
                raise
 
1204
            else:
 
1205
                mover.apply_deletions()
 
1206
        finally:
 
1207
            child_pb.finished()
 
1208
        self._tree.apply_inventory_delta(inventory_delta)
 
1209
        self._done = True
 
1210
        self.finalize()
 
1211
        return _TransformResults(modified_paths, self.rename_count)
 
1212
 
 
1213
    def _apply_removals(self, inventory_delta, mover):
 
1214
        """Perform tree operations that remove directory/inventory names.
 
1215
 
 
1216
        That is, delete files that are to be deleted, and put any files that
 
1217
        need renaming into limbo.  This must be done in strict child-to-parent
 
1218
        order.
 
1219
        """
 
1220
        tree_paths = list(self._tree_path_ids.iteritems())
 
1221
        tree_paths.sort(reverse=True)
 
1222
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1223
        try:
 
1224
            for num, data in enumerate(tree_paths):
 
1225
                path, trans_id = data
 
1226
                child_pb.update('removing file', num, len(tree_paths))
 
1227
                full_path = self._tree.abspath(path)
 
1228
                if trans_id in self._removed_contents:
 
1229
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
 
1230
                                     trans_id))
 
1231
                elif trans_id in self._new_name or trans_id in \
 
1232
                    self._new_parent:
 
1233
                    try:
 
1234
                        mover.rename(full_path, self._limbo_name(trans_id))
 
1235
                    except OSError, e:
 
1236
                        if e.errno != errno.ENOENT:
 
1237
                            raise
 
1238
                    else:
 
1239
                        self.rename_count += 1
 
1240
                if trans_id in self._removed_id:
 
1241
                    if trans_id == self._new_root:
 
1242
                        file_id = self._tree.get_root_id()
 
1243
                    else:
 
1244
                        file_id = self.tree_file_id(trans_id)
 
1245
                    assert file_id is not None
 
1246
                    # File-id isn't really being deleted, just moved
 
1247
                    if file_id in self._r_new_id:
 
1248
                        continue
 
1249
                    inventory_delta.append((path, None, file_id, None))
 
1250
        finally:
 
1251
            child_pb.finished()
 
1252
 
 
1253
    def _apply_insertions(self, inventory_delta, mover):
 
1254
        """Perform tree operations that insert directory/inventory names.
 
1255
 
 
1256
        That is, create any files that need to be created, and restore from
 
1257
        limbo any files that needed renaming.  This must be done in strict
 
1258
        parent-to-child order.
 
1259
        """
 
1260
        new_paths = self.new_paths()
 
1261
        modified_paths = []
 
1262
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1263
        completed_new = []
 
1264
        try:
 
1265
            for num, (path, trans_id) in enumerate(new_paths):
 
1266
                new_entry = None
 
1267
                child_pb.update('adding file', num, len(new_paths))
 
1268
                if trans_id in self._new_contents or \
 
1269
                    self.path_changed(trans_id):
 
1270
                    full_path = self._tree.abspath(path)
 
1271
                    if trans_id in self._needs_rename:
 
1272
                        try:
 
1273
                            mover.rename(self._limbo_name(trans_id), full_path)
 
1274
                        except OSError, e:
 
1275
                            # We may be renaming a dangling inventory id
 
1276
                            if e.errno != errno.ENOENT:
 
1277
                                raise
 
1278
                        else:
 
1279
                            self.rename_count += 1
 
1280
                    if trans_id in self._new_contents:
 
1281
                        modified_paths.append(full_path)
 
1282
                        completed_new.append(trans_id)
 
1283
                file_id = self.final_file_id(trans_id)
 
1284
                if file_id is not None and (trans_id in self._new_id or
 
1285
                    trans_id in self._new_name or trans_id in self._new_parent
 
1286
                    or trans_id in self._new_executability):
 
1287
                    try:
 
1288
                        kind = self.final_kind(trans_id)
 
1289
                    except NoSuchFile:
 
1290
                        kind = self._tree.stored_kind(file_id)
 
1291
                    if trans_id in self._new_reference_revision:
 
1292
                        new_entry = inventory.TreeReference(
 
1293
                            self.final_file_id(trans_id),
 
1294
                            self._new_name[trans_id],
 
1295
                            self.final_file_id(self._new_parent[trans_id]),
 
1296
                            None, self._new_reference_revision[trans_id])
 
1297
                    else:
 
1298
                        new_entry = inventory.make_entry(kind,
 
1299
                            self.final_name(trans_id),
 
1300
                            self.final_file_id(self.final_parent(trans_id)),
 
1301
                            self.final_file_id(trans_id))
 
1302
                    try:
 
1303
                        old_path = self._tree.id2path(new_entry.file_id)
 
1304
                    except errors.NoSuchId:
 
1305
                        old_path = None
 
1306
                    inventory_delta.append((old_path, path, new_entry.file_id,
 
1307
                                            new_entry))
 
1308
 
 
1309
                if trans_id in self._new_executability:
 
1310
                    self._set_executability(path, new_entry, trans_id)
 
1311
        finally:
 
1312
            child_pb.finished()
 
1313
        for trans_id in completed_new:
 
1314
            del self._new_contents[trans_id]
 
1315
        return modified_paths
 
1316
 
 
1317
 
 
1318
class TransformPreview(TreeTransformBase):
 
1319
    """A TreeTransform for generating preview trees.
 
1320
 
 
1321
    Unlike TreeTransform, this version works when the input tree is a
 
1322
    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
 
1323
    unversioned files in the input tree.
 
1324
    """
 
1325
 
 
1326
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
 
1327
        tree.lock_read()
 
1328
        limbodir = tempfile.mkdtemp(prefix='bzr-limbo-')
 
1329
        TreeTransformBase.__init__(self, tree, limbodir, pb, case_sensitive)
 
1330
 
 
1331
    def canonical_path(self, path):
 
1332
        return path
 
1333
 
 
1334
    def tree_kind(self, trans_id):
 
1335
        path = self._tree_id_paths.get(trans_id)
 
1336
        if path is None:
 
1337
            raise NoSuchFile(None)
 
1338
        file_id = self._tree.path2id(path)
 
1339
        return self._tree.kind(file_id)
 
1340
 
 
1341
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1342
        """Set the mode of new file contents.
 
1343
        The mode_id is the existing file to get the mode from (often the same
 
1344
        as trans_id).  The operation is only performed if there's a mode match
 
1345
        according to typefunc.
 
1346
        """
 
1347
        # is it ok to ignore this?  probably
 
1348
        pass
 
1349
 
 
1350
    def iter_tree_children(self, parent_id):
 
1351
        """Iterate through the entry's tree children, if any"""
 
1352
        try:
 
1353
            path = self._tree_id_paths[parent_id]
 
1354
        except KeyError:
 
1355
            return
 
1356
        file_id = self.tree_file_id(parent_id)
 
1357
        for child in self._tree.inventory[file_id].children.iterkeys():
 
1358
            childpath = joinpath(path, child)
 
1359
            yield self.trans_id_tree_path(childpath)
 
1360
 
 
1361
 
 
1362
class _PreviewTree(object):
 
1363
    """Partial implementation of Tree to support show_diff_trees"""
 
1364
 
 
1365
    def __init__(self, transform):
 
1366
        self._transform = transform
 
1367
 
 
1368
    def lock_read(self):
 
1369
        # Perhaps in theory, this should lock the TreeTransform?
 
1370
        pass
 
1371
 
 
1372
    def unlock(self):
 
1373
        pass
 
1374
 
 
1375
    def iter_changes(self, from_tree, include_unchanged=False,
 
1376
                      specific_files=None, pb=None, extra_trees=None,
 
1377
                      require_versioned=True, want_unversioned=False):
 
1378
        """See InterTree.iter_changes.
 
1379
 
 
1380
        This implementation does not support include_unchanged, specific_files,
 
1381
        or want_unversioned.  extra_trees, require_versioned, and pb are
 
1382
        ignored.
 
1383
        """
 
1384
        if from_tree is not self._transform._tree:
 
1385
            raise ValueError('from_tree must be transform source tree.')
 
1386
        if include_unchanged:
 
1387
            raise ValueError('include_unchanged is not supported')
 
1388
        if specific_files is not None:
 
1389
            raise ValueError('specific_files is not supported')
 
1390
        if want_unversioned:
 
1391
            raise ValueError('want_unversioned is not supported')
 
1392
        return self._transform.iter_changes()
 
1393
 
 
1394
    def kind(self, file_id):
 
1395
        trans_id = self._transform.trans_id_file_id(file_id)
 
1396
        return self._transform.final_kind(trans_id)
 
1397
 
 
1398
    def get_file_mtime(self, file_id, path=None):
 
1399
        """See Tree.get_file_mtime"""
 
1400
        trans_id = self._transform.trans_id_file_id(file_id)
 
1401
        name = self._transform._limbo_name(trans_id)
 
1402
        return os.stat(name).st_mtime
 
1403
 
 
1404
    def get_file(self, file_id):
 
1405
        """See Tree.get_file"""
 
1406
        trans_id = self._transform.trans_id_file_id(file_id)
 
1407
        name = self._transform._limbo_name(trans_id)
 
1408
        return open(name, 'rb')
 
1409
 
 
1410
    def get_symlink_target(self, file_id):
 
1411
        """See Tree.get_symlink_target"""
 
1412
        trans_id = self._transform.trans_id_file_id(file_id)
 
1413
        name = self._transform._limbo_name(trans_id)
 
1414
        return os.readlink(name)
 
1415
 
 
1416
    def paths2ids(self, specific_files, trees=None, require_versioned=False):
 
1417
        """See Tree.paths2ids"""
 
1418
        return 'not_empty'
 
1419
 
1079
1420
 
1080
1421
def joinpath(parent, child):
1081
1422
    """Join tree-relative paths, handling the tree root specially"""
1112
1453
            self._known_paths[trans_id] = self._determine_path(trans_id)
1113
1454
        return self._known_paths[trans_id]
1114
1455
 
 
1456
 
1115
1457
def topology_sorted_ids(tree):
1116
1458
    """Determine the topological order of the ids in a tree"""
1117
1459
    file_ids = list(tree)
1119
1461
    return file_ids
1120
1462
 
1121
1463
 
1122
 
def build_tree(tree, wt):
 
1464
def build_tree(tree, wt, accelerator_tree=None, hardlink=False):
1123
1465
    """Create working tree for a branch, using a TreeTransform.
1124
1466
    
1125
1467
    This function should be used on empty trees, having a tree root at most.
1132
1474
    - Otherwise, if the content on disk matches the content we are building,
1133
1475
      it is silently replaced.
1134
1476
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
 
1477
 
 
1478
    :param tree: The tree to convert wt into a copy of
 
1479
    :param wt: The working tree that files will be placed into
 
1480
    :param accelerator_tree: A tree which can be used for retrieving file
 
1481
        contents more quickly than tree itself, i.e. a workingtree.  tree
 
1482
        will be used for cases where accelerator_tree's content is different.
 
1483
    :param hardlink: If true, hard-link files to accelerator_tree, where
 
1484
        possible.  accelerator_tree must implement abspath, i.e. be a
 
1485
        working tree.
1135
1486
    """
1136
1487
    wt.lock_tree_write()
1137
1488
    try:
1138
1489
        tree.lock_read()
1139
1490
        try:
1140
 
            return _build_tree(tree, wt)
 
1491
            if accelerator_tree is not None:
 
1492
                accelerator_tree.lock_read()
 
1493
            try:
 
1494
                return _build_tree(tree, wt, accelerator_tree, hardlink)
 
1495
            finally:
 
1496
                if accelerator_tree is not None:
 
1497
                    accelerator_tree.unlock()
1141
1498
        finally:
1142
1499
            tree.unlock()
1143
1500
    finally:
1144
1501
        wt.unlock()
1145
1502
 
1146
 
def _build_tree(tree, wt):
 
1503
 
 
1504
def _build_tree(tree, wt, accelerator_tree, hardlink):
1147
1505
    """See build_tree."""
1148
 
    if len(wt.inventory) > 1:  # more than just a root
1149
 
        raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
1506
    for num, _unused in enumerate(wt.all_file_ids()):
 
1507
        if num > 0:  # more than just a root
 
1508
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
1150
1509
    file_trans_id = {}
1151
1510
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1152
1511
    pp = ProgressPhase("Build phase", 2, top_pb)
1153
1512
    if tree.inventory.root is not None:
1154
 
        # this is kindof a hack: we should be altering the root 
1155
 
        # as partof the regular tree shape diff logic.
1156
 
        # the conditional test hereis to avoid doing an
 
1513
        # This is kind of a hack: we should be altering the root
 
1514
        # as part of the regular tree shape diff logic.
 
1515
        # The conditional test here is to avoid doing an
1157
1516
        # expensive operation (flush) every time the root id
1158
1517
        # is set within the tree, nor setting the root and thus
1159
1518
        # marking the tree as dirty, because we use two different
1160
1519
        # idioms here: tree interfaces and inventory interfaces.
1161
 
        if wt.path2id('') != tree.inventory.root.file_id:
1162
 
            wt.set_root_id(tree.inventory.root.file_id)
 
1520
        if wt.get_root_id() != tree.get_root_id():
 
1521
            wt.set_root_id(tree.get_root_id())
1163
1522
            wt.flush()
1164
1523
    tt = TreeTransform(wt)
1165
1524
    divert = set()
1169
1528
            tt.trans_id_tree_file_id(wt.get_root_id())
1170
1529
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
1171
1530
        try:
 
1531
            deferred_contents = []
 
1532
            num = 0
1172
1533
            for num, (tree_path, entry) in \
1173
1534
                enumerate(tree.inventory.iter_entries_by_dir()):
1174
 
                pb.update("Building tree", num, len(tree.inventory))
 
1535
                pb.update("Building tree", num - len(deferred_contents),
 
1536
                          len(tree.inventory))
1175
1537
                if entry.parent_id is None:
1176
1538
                    continue
1177
1539
                reparent = False
1200
1562
                        'entry %s parent id %r is not in file_trans_id %r'
1201
1563
                        % (entry, entry.parent_id, file_trans_id))
1202
1564
                parent_id = file_trans_id[entry.parent_id]
1203
 
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1204
 
                                                      tree)
 
1565
                if entry.kind == 'file':
 
1566
                    # We *almost* replicate new_by_entry, so that we can defer
 
1567
                    # getting the file text, and get them all at once.
 
1568
                    trans_id = tt.create_path(entry.name, parent_id)
 
1569
                    file_trans_id[file_id] = trans_id
 
1570
                    tt.version_file(entry.file_id, trans_id)
 
1571
                    executable = tree.is_executable(entry.file_id, tree_path)
 
1572
                    if executable is not None:
 
1573
                        tt.set_executability(executable, trans_id)
 
1574
                    deferred_contents.append((entry.file_id, trans_id))
 
1575
                else:
 
1576
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
 
1577
                                                          tree)
1205
1578
                if reparent:
1206
1579
                    new_trans_id = file_trans_id[file_id]
1207
1580
                    old_parent = tt.trans_id_tree_path(tree_path)
1208
1581
                    _reparent_children(tt, old_parent, new_trans_id)
 
1582
            offset = num + 1 - len(deferred_contents)
 
1583
            _create_files(tt, tree, deferred_contents, pb, offset,
 
1584
                          accelerator_tree, hardlink)
1209
1585
        finally:
1210
1586
            pb.finished()
1211
1587
        pp.next_phase()
1219
1595
            wt.add_conflicts(conflicts)
1220
1596
        except errors.UnsupportedOperation:
1221
1597
            pass
1222
 
        tt.apply()
 
1598
        result = tt.apply(no_conflicts=True)
1223
1599
    finally:
1224
1600
        tt.finalize()
1225
1601
        top_pb.finished()
 
1602
    return result
 
1603
 
 
1604
 
 
1605
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
 
1606
                  hardlink):
 
1607
    total = len(desired_files) + offset
 
1608
    if accelerator_tree is None:
 
1609
        new_desired_files = desired_files
 
1610
    else:
 
1611
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
 
1612
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
 
1613
                         in iter if not (c or e[0] != e[1]))
 
1614
        new_desired_files = []
 
1615
        count = 0
 
1616
        for file_id, trans_id in desired_files:
 
1617
            accelerator_path = unchanged.get(file_id)
 
1618
            if accelerator_path is None:
 
1619
                new_desired_files.append((file_id, trans_id))
 
1620
                continue
 
1621
            pb.update('Adding file contents', count + offset, total)
 
1622
            if hardlink:
 
1623
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
 
1624
                                   trans_id)
 
1625
            else:
 
1626
                contents = accelerator_tree.get_file(file_id, accelerator_path)
 
1627
                try:
 
1628
                    tt.create_file(contents, trans_id)
 
1629
                finally:
 
1630
                    contents.close()
 
1631
            count += 1
 
1632
        offset += count
 
1633
    for count, (trans_id, contents) in enumerate(tree.iter_files_bytes(
 
1634
                                                 new_desired_files)):
 
1635
        tt.create_file(contents, trans_id)
 
1636
        pb.update('Adding file contents', count + offset, total)
1226
1637
 
1227
1638
 
1228
1639
def _reparent_children(tt, old_parent, new_parent):
1229
1640
    for child in tt.iter_tree_children(old_parent):
1230
1641
        tt.adjust_path(tt.final_name(child), new_parent, child)
1231
1642
 
 
1643
def _reparent_transform_children(tt, old_parent, new_parent):
 
1644
    by_parent = tt.by_parent()
 
1645
    for child in by_parent[old_parent]:
 
1646
        tt.adjust_path(tt.final_name(child), new_parent, child)
1232
1647
 
1233
1648
def _content_match(tree, entry, file_id, kind, target_path):
1234
1649
    if entry.kind != kind:
1293
1708
    else:
1294
1709
        raise errors.BadFileKindError(name, kind)
1295
1710
 
 
1711
 
1296
1712
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1297
1713
    """Create new file contents according to an inventory entry."""
1298
1714
    if entry.kind == "file":
1304
1720
    elif entry.kind == "directory":
1305
1721
        tt.create_directory(trans_id)
1306
1722
 
 
1723
 
1307
1724
def create_entry_executability(tt, entry, trans_id):
1308
1725
    """Set the executability of a trans_id according to an inventory entry"""
1309
1726
    if entry.kind == "file":
1327
1744
        working_tree.unlock()
1328
1745
 
1329
1746
 
 
1747
@deprecated_function(zero_ninety)
1330
1748
def change_entry(tt, file_id, working_tree, target_tree, 
1331
1749
                 trans_id_file_id, backups, trans_id, by_parent):
1332
1750
    """Replace a file_id's contents with those from a target tree."""
 
1751
    if file_id is None and target_tree is None:
 
1752
        # skip the logic altogether in the deprecation test
 
1753
        return
1333
1754
    e_trans_id = trans_id_file_id(file_id)
1334
1755
    entry = target_tree.inventory[file_id]
1335
1756
    has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry, 
1420
1841
        pp.next_phase()
1421
1842
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1422
1843
        try:
1423
 
            _alter_files(working_tree, target_tree, tt, child_pb,
1424
 
                         filenames, backups)
 
1844
            merge_modified = _alter_files(working_tree, target_tree, tt,
 
1845
                                          child_pb, filenames, backups)
1425
1846
        finally:
1426
1847
            child_pb.finished()
1427
1848
        pp.next_phase()
1428
1849
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1429
1850
        try:
1430
 
            raw_conflicts = resolve_conflicts(tt, child_pb)
 
1851
            raw_conflicts = resolve_conflicts(tt, child_pb,
 
1852
                lambda t, c: conflict_pass(t, c, target_tree))
1431
1853
        finally:
1432
1854
            child_pb.finished()
1433
1855
        conflicts = cook_conflicts(raw_conflicts, tt)
1434
1856
        if change_reporter:
1435
1857
            change_reporter = delta._ChangeReporter(
1436
1858
                unversioned_filter=working_tree.is_ignored)
1437
 
            delta.report_changes(tt._iter_changes(), change_reporter)
 
1859
            delta.report_changes(tt.iter_changes(), change_reporter)
1438
1860
        for conflict in conflicts:
1439
1861
            warning(conflict)
1440
1862
        pp.next_phase()
1441
1863
        tt.apply()
1442
 
        working_tree.set_merge_modified({})
 
1864
        working_tree.set_merge_modified(merge_modified)
1443
1865
    finally:
1444
1866
        target_tree.unlock()
1445
1867
        tt.finalize()
1450
1872
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1451
1873
                 backups):
1452
1874
    merge_modified = working_tree.merge_modified()
1453
 
    change_list = target_tree._iter_changes(working_tree,
 
1875
    change_list = target_tree.iter_changes(working_tree,
1454
1876
        specific_files=specific_files, pb=pb)
1455
1877
    if target_tree.inventory.root is None:
1456
1878
        skip_root = True
1458
1880
        skip_root = False
1459
1881
    basis_tree = None
1460
1882
    try:
 
1883
        deferred_files = []
1461
1884
        for id_num, (file_id, path, changed_content, versioned, parent, name,
1462
1885
                kind, executable) in enumerate(change_list):
1463
1886
            if skip_root and file_id[0] is not None and parent[0] is None:
1469
1892
                if kind[0] == 'file' and (backups or kind[1] is None):
1470
1893
                    wt_sha1 = working_tree.get_file_sha1(file_id)
1471
1894
                    if merge_modified.get(file_id) != wt_sha1:
1472
 
                        # acquire the basis tree lazyily to prevent the expense
1473
 
                        # of accessing it when its not needed ? (Guessing, RBC,
1474
 
                        # 200702)
 
1895
                        # acquire the basis tree lazily to prevent the
 
1896
                        # expense of accessing it when it's not needed ?
 
1897
                        # (Guessing, RBC, 200702)
1475
1898
                        if basis_tree is None:
1476
1899
                            basis_tree = working_tree.basis_tree()
1477
1900
                            basis_tree.lock_read()
1503
1926
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
1504
1927
                                      trans_id)
1505
1928
                elif kind[1] == 'file':
1506
 
                    tt.create_file(target_tree.get_file_lines(file_id),
1507
 
                                   trans_id, mode_id)
 
1929
                    deferred_files.append((file_id, (trans_id, mode_id)))
 
1930
                    if basis_tree is None:
 
1931
                        basis_tree = working_tree.basis_tree()
 
1932
                        basis_tree.lock_read()
 
1933
                    new_sha1 = target_tree.get_file_sha1(file_id)
 
1934
                    if (file_id in basis_tree and new_sha1 ==
 
1935
                        basis_tree.get_file_sha1(file_id)):
 
1936
                        if file_id in merge_modified:
 
1937
                            del merge_modified[file_id]
 
1938
                    else:
 
1939
                        merge_modified[file_id] = new_sha1
 
1940
 
1508
1941
                    # preserve the execute bit when backing up
1509
1942
                    if keep_content and executable[0] == executable[1]:
1510
1943
                        tt.set_executability(executable[1], trans_id)
1520
1953
                    name[1], tt.trans_id_file_id(parent[1]), trans_id)
1521
1954
            if executable[0] != executable[1] and kind[1] == "file":
1522
1955
                tt.set_executability(executable[1], trans_id)
 
1956
        for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
 
1957
            deferred_files):
 
1958
            tt.create_file(bytes, trans_id, mode_id)
1523
1959
    finally:
1524
1960
        if basis_tree is not None:
1525
1961
            basis_tree.unlock()
 
1962
    return merge_modified
1526
1963
 
1527
1964
 
1528
1965
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1542
1979
        pb.clear()
1543
1980
 
1544
1981
 
1545
 
def conflict_pass(tt, conflicts):
1546
 
    """Resolve some classes of conflicts."""
 
1982
def conflict_pass(tt, conflicts, path_tree=None):
 
1983
    """Resolve some classes of conflicts.
 
1984
 
 
1985
    :param tt: The transform to resolve conflicts in
 
1986
    :param conflicts: The conflicts to resolve
 
1987
    :param path_tree: A Tree to get supplemental paths from
 
1988
    """
1547
1989
    new_conflicts = set()
1548
1990
    for c_type, conflict in ((c[0], c) for c in conflicts):
1549
1991
        if c_type == 'duplicate id':
1552
1994
                               conflict[1], conflict[2], ))
1553
1995
        elif c_type == 'duplicate':
1554
1996
            # files that were renamed take precedence
1555
 
            new_name = tt.final_name(conflict[1])+'.moved'
1556
1997
            final_parent = tt.final_parent(conflict[1])
1557
1998
            if tt.path_changed(conflict[1]):
1558
 
                tt.adjust_path(new_name, final_parent, conflict[2])
1559
 
                new_conflicts.add((c_type, 'Moved existing file to', 
1560
 
                                   conflict[2], conflict[1]))
 
1999
                existing_file, new_file = conflict[2], conflict[1]
1561
2000
            else:
1562
 
                tt.adjust_path(new_name, final_parent, conflict[1])
1563
 
                new_conflicts.add((c_type, 'Moved existing file to', 
1564
 
                                  conflict[1], conflict[2]))
 
2001
                existing_file, new_file = conflict[1], conflict[2]
 
2002
            new_name = tt.final_name(existing_file)+'.moved'
 
2003
            tt.adjust_path(new_name, final_parent, existing_file)
 
2004
            new_conflicts.add((c_type, 'Moved existing file to', 
 
2005
                               existing_file, new_file))
1565
2006
        elif c_type == 'parent loop':
1566
2007
            # break the loop by undoing one of the ops that caused the loop
1567
2008
            cur = conflict[1]
1580
2021
            except KeyError:
1581
2022
                tt.create_directory(trans_id)
1582
2023
                new_conflicts.add((c_type, 'Created directory', trans_id))
 
2024
                try:
 
2025
                    tt.final_name(trans_id)
 
2026
                except NoFinalPath:
 
2027
                    if path_tree is not None:
 
2028
                        file_id = tt.final_file_id(trans_id)
 
2029
                        entry = path_tree.inventory[file_id]
 
2030
                        parent_trans_id = tt.trans_id_file_id(entry.parent_id)
 
2031
                        tt.adjust_path(entry.name, parent_trans_id, trans_id)
1583
2032
        elif c_type == 'unversioned parent':
1584
2033
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1585
2034
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
 
2035
        elif c_type == 'non-directory parent':
 
2036
            parent_id = conflict[1]
 
2037
            parent_parent = tt.final_parent(parent_id)
 
2038
            parent_name = tt.final_name(parent_id)
 
2039
            parent_file_id = tt.final_file_id(parent_id)
 
2040
            new_parent_id = tt.new_directory(parent_name + '.new',
 
2041
                parent_parent, parent_file_id)
 
2042
            _reparent_transform_children(tt, parent_id, new_parent_id)
 
2043
            if parent_file_id is not None:
 
2044
                tt.unversion_file(parent_id)
 
2045
            new_conflicts.add((c_type, 'Created directory', new_parent_id))
1586
2046
    return new_conflicts
1587
2047
 
1588
2048
 
1612
2072
                                   file_id=modified_id, 
1613
2073
                                   conflict_path=conflicting_path,
1614
2074
                                   conflict_file_id=conflicting_id)
 
2075
 
 
2076
 
 
2077
class _FileMover(object):
 
2078
    """Moves and deletes files for TreeTransform, tracking operations"""
 
2079
 
 
2080
    def __init__(self):
 
2081
        self.past_renames = []
 
2082
        self.pending_deletions = []
 
2083
 
 
2084
    def rename(self, from_, to):
 
2085
        """Rename a file from one path to another.  Functions like os.rename"""
 
2086
        try:
 
2087
            os.rename(from_, to)
 
2088
        except OSError, e:
 
2089
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
 
2090
                raise errors.FileExists(to, str(e))
 
2091
            raise
 
2092
        self.past_renames.append((from_, to))
 
2093
 
 
2094
    def pre_delete(self, from_, to):
 
2095
        """Rename a file out of the way and mark it for deletion.
 
2096
 
 
2097
        Unlike os.unlink, this works equally well for files and directories.
 
2098
        :param from_: The current file path
 
2099
        :param to: A temporary path for the file
 
2100
        """
 
2101
        self.rename(from_, to)
 
2102
        self.pending_deletions.append(to)
 
2103
 
 
2104
    def rollback(self):
 
2105
        """Reverse all renames that have been performed"""
 
2106
        for from_, to in reversed(self.past_renames):
 
2107
            os.rename(to, from_)
 
2108
        # after rollback, don't reuse _FileMover
 
2109
        past_renames = None
 
2110
        pending_deletions = None
 
2111
 
 
2112
    def apply_deletions(self):
 
2113
        """Apply all marked deletions"""
 
2114
        for path in self.pending_deletions:
 
2115
            delete_any(path)
 
2116
        # after apply_deletions, don't reuse _FileMover
 
2117
        past_renames = None
 
2118
        pending_deletions = None