← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-05-03 19:49:12 UTC
  • mfrom: (2476.1.1 shared_repo_layouts)
  • Revision ID: pqm@pqm.ubuntu.com-20070503194912-pzlcms91kk2uqfdo
(John Arbash Meinel) Add doc/shared_repository_layouts.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
import errno
19
19
from stat import S_ISREG
20
20
 
 
21
from bzrlib.lazy_import import lazy_import
 
22
lazy_import(globals(), """
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    delta,
 
26
    errors,
 
27
    inventory
 
28
    )
 
29
""")
21
30
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
22
31
                           ReusingTransform, NotVersionedError, CantMoveRoot,
23
 
                           ExistingLimbo, ImmortalLimbo)
 
32
                           ExistingLimbo, ImmortalLimbo, NoFinalPath)
24
33
from bzrlib.inventory import InventoryEntry
25
34
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
26
35
                            delete_any)
27
36
from bzrlib.progress import DummyProgress, ProgressPhase
 
37
from bzrlib.symbol_versioning import deprecated_function, zero_fifteen
28
38
from bzrlib.trace import mutter, warning
29
 
import bzrlib.ui 
 
39
from bzrlib import tree
 
40
import bzrlib.ui
30
41
import bzrlib.urlutils as urlutils
31
42
 
32
43
 
71
82
     * set_executability
72
83
    """
73
84
    def __init__(self, tree, pb=DummyProgress()):
74
 
        """Note: a write lock is taken on the tree.
 
85
        """Note: a tree_write lock is taken on the tree.
75
86
        
76
87
        Use TreeTransform.finalize() to release the lock
77
88
        """
78
89
        object.__init__(self)
79
90
        self._tree = tree
80
 
        self._tree.lock_write()
 
91
        self._tree.lock_tree_write()
81
92
        try:
82
93
            control_files = self._tree._control_files
83
94
            self._limbodir = urlutils.local_path_from_url(
97
108
        self._new_contents = {}
98
109
        self._removed_contents = set()
99
110
        self._new_executability = {}
 
111
        self._new_reference_revision = {}
100
112
        self._new_id = {}
101
113
        self._non_present_ids = {}
102
114
        self._r_new_id = {}
259
271
        New file takes the permissions of any existing file with that id,
260
272
        unless mode_id is specified.
261
273
        """
262
 
        f = file(self._limbo_name(trans_id), 'wb')
263
 
        unique_add(self._new_contents, trans_id, 'file')
264
 
        for segment in contents:
265
 
            f.write(segment)
266
 
        f.close()
 
274
        name = self._limbo_name(trans_id)
 
275
        f = open(name, 'wb')
 
276
        try:
 
277
            try:
 
278
                unique_add(self._new_contents, trans_id, 'file')
 
279
            except:
 
280
                # Clean up the file, it never got registered so
 
281
                # TreeTransform.finalize() won't clean it up.
 
282
                f.close()
 
283
                os.unlink(name)
 
284
                raise
 
285
 
 
286
            f.writelines(contents)
 
287
        finally:
 
288
            f.close()
267
289
        self._set_mode(trans_id, mode_id, S_ISREG)
268
290
 
269
291
    def _set_mode(self, trans_id, mode_id, typefunc):
279
301
        except KeyError:
280
302
            return
281
303
        try:
282
 
            mode = os.stat(old_path).st_mode
 
304
            mode = os.stat(self._tree.abspath(old_path)).st_mode
283
305
        except OSError, e:
284
306
            if e.errno == errno.ENOENT:
285
307
                return
337
359
        else:
338
360
            unique_add(self._new_executability, trans_id, executability)
339
361
 
 
362
    def set_tree_reference(self, revision_id, trans_id):
 
363
        """Set the reference associated with a directory"""
 
364
        unique_add(self._new_reference_revision, trans_id, revision_id)
 
365
 
340
366
    def version_file(self, file_id, trans_id):
341
367
        """Schedule a file to become versioned."""
342
368
        assert file_id is not None
444
470
        try:
445
471
            return self._new_name[trans_id]
446
472
        except KeyError:
447
 
            return os.path.basename(self._tree_id_paths[trans_id])
 
473
            try:
 
474
                return os.path.basename(self._tree_id_paths[trans_id])
 
475
            except KeyError:
 
476
                raise NoFinalPath(trans_id, self)
448
477
 
449
478
    def by_parent(self):
450
479
        """Return a map of parent: children for known parents.
463
492
 
464
493
    def path_changed(self, trans_id):
465
494
        """Return True if a trans_id's path has changed."""
466
 
        return trans_id in self._new_name or trans_id in self._new_parent
 
495
        return (trans_id in self._new_name) or (trans_id in self._new_parent)
 
496
 
 
497
    def new_contents(self, trans_id):
 
498
        return (trans_id in self._new_contents)
467
499
 
468
500
    def find_conflicts(self):
469
501
        """Find any violations of inventory or filesystem invariants"""
495
527
                        self.tree_kind(t) == 'directory'])
496
528
        for trans_id in self._removed_id:
497
529
            file_id = self.tree_file_id(trans_id)
498
 
            if self._tree.inventory[file_id].kind in ('directory', 
499
 
                                                      'root_directory'):
 
530
            if self._tree.inventory[file_id].kind == 'directory':
500
531
                parents.append(trans_id)
501
532
 
502
533
        for parent_id in parents:
539
570
        if child_id is None:
540
571
            return lexists(self._tree.abspath(childpath))
541
572
        else:
542
 
            if tt.final_parent(child_id) != parent_id:
 
573
            if self.final_parent(child_id) != parent_id:
543
574
                return False
544
 
            if child_id in tt._removed_contents:
 
575
            if child_id in self._removed_contents:
545
576
                # XXX What about dangling file-ids?
546
577
                return False
547
578
            else:
555
586
            parent_id = trans_id
556
587
            while parent_id is not ROOT_PARENT:
557
588
                seen.add(parent_id)
558
 
                parent_id = self.final_parent(parent_id)
 
589
                try:
 
590
                    parent_id = self.final_parent(parent_id)
 
591
                except KeyError:
 
592
                    break
559
593
                if parent_id == trans_id:
560
594
                    conflicts.append(('parent loop', trans_id))
561
595
                if parent_id in seen:
635
669
            last_name = None
636
670
            last_trans_id = None
637
671
            for name, trans_id in name_ids:
 
672
                try:
 
673
                    kind = self.final_kind(trans_id)
 
674
                except NoSuchFile:
 
675
                    kind = None
 
676
                file_id = self.final_file_id(trans_id)
 
677
                if kind is None and file_id is None:
 
678
                    continue
638
679
                if name == last_name:
639
680
                    conflicts.append(('duplicate', last_trans_id, trans_id,
640
681
                    name))
641
 
                try:
642
 
                    kind = self.final_kind(trans_id)
643
 
                except NoSuchFile:
644
 
                    kind = None
645
 
                file_id = self.final_file_id(trans_id)
646
 
                if kind is not None or file_id is not None:
647
 
                    last_name = name
648
 
                    last_trans_id = trans_id
 
682
                last_name = name
 
683
                last_trans_id = trans_id
649
684
        return conflicts
650
685
 
651
686
    def _duplicate_ids(self):
703
738
        conflicts = self.find_conflicts()
704
739
        if len(conflicts) != 0:
705
740
            raise MalformedTransform(conflicts=conflicts)
706
 
        limbo_inv = {}
707
741
        inv = self._tree.inventory
 
742
        inventory_delta = []
708
743
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
709
744
        try:
710
745
            child_pb.update('Apply phase', 0, 2)
711
 
            self._apply_removals(inv, limbo_inv)
 
746
            self._apply_removals(inv, inventory_delta)
712
747
            child_pb.update('Apply phase', 1, 2)
713
 
            modified_paths = self._apply_insertions(inv, limbo_inv)
 
748
            modified_paths = self._apply_insertions(inv, inventory_delta)
714
749
        finally:
715
750
            child_pb.finished()
716
 
        self._tree._write_inventory(inv)
 
751
        self._tree.apply_inventory_delta(inventory_delta)
717
752
        self.__done = True
718
753
        self.finalize()
719
754
        return _TransformResults(modified_paths)
722
757
        """Generate the limbo name of a file"""
723
758
        return pathjoin(self._limbodir, trans_id)
724
759
 
725
 
    def _apply_removals(self, inv, limbo_inv):
 
760
    def _apply_removals(self, inv, inventory_delta):
726
761
        """Perform tree operations that remove directory/inventory names.
727
762
        
728
763
        That is, delete files that are to be deleted, and put any files that
751
786
                        file_id = self._tree.inventory.root.file_id
752
787
                    else:
753
788
                        file_id = self.tree_file_id(trans_id)
754
 
                    del inv[file_id]
755
 
                elif trans_id in self._new_name or trans_id in self._new_parent:
756
 
                    file_id = self.tree_file_id(trans_id)
757
 
                    if file_id is not None:
758
 
                        limbo_inv[trans_id] = inv[file_id]
759
 
                        del inv[file_id]
 
789
                    assert file_id is not None
 
790
                    inventory_delta.append((path, None, file_id, None))
760
791
        finally:
761
792
            child_pb.finished()
762
793
 
763
 
    def _apply_insertions(self, inv, limbo_inv):
 
794
    def _apply_insertions(self, inv, inventory_delta):
764
795
        """Perform tree operations that insert directory/inventory names.
765
796
        
766
797
        That is, create any files that need to be created, and restore from
772
803
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
773
804
        try:
774
805
            for num, (path, trans_id) in enumerate(new_paths):
 
806
                new_entry = None
775
807
                child_pb.update('adding file', num, len(new_paths))
776
808
                try:
777
809
                    kind = self._new_contents[trans_id]
793
825
                if trans_id in self._new_id:
794
826
                    if kind is None:
795
827
                        kind = file_kind(self._tree.abspath(path))
796
 
                    inv.add_path(path, kind, self._new_id[trans_id])
797
 
                elif trans_id in self._new_name or trans_id in\
798
 
                    self._new_parent:
799
 
                    entry = limbo_inv.get(trans_id)
800
 
                    if entry is not None:
801
 
                        entry.name = self.final_name(trans_id)
802
 
                        parent_path = os.path.dirname(path)
803
 
                        entry.parent_id = \
804
 
                            self._tree.inventory.path2id(parent_path)
805
 
                        inv.add(entry)
806
 
 
807
 
                # requires files and inventory entries to be in place
 
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])
 
839
                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
 
808
856
                if trans_id in self._new_executability:
809
 
                    self._set_executability(path, inv, trans_id)
 
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)
 
861
                    else:
 
862
                        old_path = None
 
863
                    inventory_delta.append((old_path, path,
 
864
                                            new_entry.file_id,
 
865
                                            new_entry))
810
866
        finally:
811
867
            child_pb.finished()
812
868
        return modified_paths
813
869
 
814
 
    def _set_executability(self, path, inv, trans_id):
 
870
    def _set_executability(self, path, entry, trans_id):
815
871
        """Set the executability of versioned files """
816
 
        file_id = inv.path2id(path)
817
872
        new_executability = self._new_executability[trans_id]
818
 
        inv[file_id].executable = new_executability
 
873
        entry.executable = new_executability
819
874
        if supports_executable():
820
875
            abspath = self._tree.abspath(path)
821
876
            current_mode = os.stat(abspath).st_mode
882
937
        self.create_symlink(target, trans_id)
883
938
        return trans_id
884
939
 
 
940
    def _affected_ids(self):
 
941
        """Return the set of transform ids affected by the transform"""
 
942
        trans_ids = set(self._removed_id)
 
943
        trans_ids.update(self._new_id.keys())
 
944
        trans_ids.update(self._removed_contents)
 
945
        trans_ids.update(self._new_contents.keys())
 
946
        trans_ids.update(self._new_executability.keys())
 
947
        trans_ids.update(self._new_name.keys())
 
948
        trans_ids.update(self._new_parent.keys())
 
949
        return trans_ids
 
950
 
 
951
    def _get_file_id_maps(self):
 
952
        """Return mapping of file_ids to trans_ids in the to and from states"""
 
953
        trans_ids = self._affected_ids()
 
954
        from_trans_ids = {}
 
955
        to_trans_ids = {}
 
956
        # Build up two dicts: trans_ids associated with file ids in the
 
957
        # FROM state, vs the TO state.
 
958
        for trans_id in trans_ids:
 
959
            from_file_id = self.tree_file_id(trans_id)
 
960
            if from_file_id is not None:
 
961
                from_trans_ids[from_file_id] = trans_id
 
962
            to_file_id = self.final_file_id(trans_id)
 
963
            if to_file_id is not None:
 
964
                to_trans_ids[to_file_id] = trans_id
 
965
        return from_trans_ids, to_trans_ids
 
966
 
 
967
    def _from_file_data(self, from_trans_id, from_versioned, file_id):
 
968
        """Get data about a file in the from (tree) state
 
969
 
 
970
        Return a (name, parent, kind, executable) tuple
 
971
        """
 
972
        from_path = self._tree_id_paths.get(from_trans_id)
 
973
        if from_versioned:
 
974
            # get data from working tree if versioned
 
975
            from_entry = self._tree.inventory[file_id]
 
976
            from_name = from_entry.name
 
977
            from_parent = from_entry.parent_id
 
978
        else:
 
979
            from_entry = None
 
980
            if from_path is None:
 
981
                # File does not exist in FROM state
 
982
                from_name = None
 
983
                from_parent = None
 
984
            else:
 
985
                # File exists, but is not versioned.  Have to use path-
 
986
                # splitting stuff
 
987
                from_name = os.path.basename(from_path)
 
988
                tree_parent = self.get_tree_parent(from_trans_id)
 
989
                from_parent = self.tree_file_id(tree_parent)
 
990
        if from_path is not None:
 
991
            from_kind, from_executable, from_stats = \
 
992
                self._tree._comparison_data(from_entry, from_path)
 
993
        else:
 
994
            from_kind = None
 
995
            from_executable = False
 
996
        return from_name, from_parent, from_kind, from_executable
 
997
 
 
998
    def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
 
999
        """Get data about a file in the to (target) state
 
1000
 
 
1001
        Return a (name, parent, kind, executable) tuple
 
1002
        """
 
1003
        to_name = self.final_name(to_trans_id)
 
1004
        try:
 
1005
            to_kind = self.final_kind(to_trans_id)
 
1006
        except NoSuchFile:
 
1007
            to_kind = None
 
1008
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
 
1009
        if to_trans_id in self._new_executability:
 
1010
            to_executable = self._new_executability[to_trans_id]
 
1011
        elif to_trans_id == from_trans_id:
 
1012
            to_executable = from_executable
 
1013
        else:
 
1014
            to_executable = False
 
1015
        return to_name, to_parent, to_kind, to_executable
 
1016
 
 
1017
    def _iter_changes(self):
 
1018
        """Produce output in the same format as Tree._iter_changes.
 
1019
 
 
1020
        Will produce nonsensical results if invoked while inventory/filesystem
 
1021
        conflicts (as reported by TreeTransform.find_conflicts()) are present.
 
1022
 
 
1023
        This reads the Transform, but only reproduces changes involving a
 
1024
        file_id.  Files that are not versioned in either of the FROM or TO
 
1025
        states are not reflected.
 
1026
        """
 
1027
        final_paths = FinalPaths(self)
 
1028
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
 
1029
        results = []
 
1030
        # Now iterate through all active file_ids
 
1031
        for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
 
1032
            modified = False
 
1033
            from_trans_id = from_trans_ids.get(file_id)
 
1034
            # find file ids, and determine versioning state
 
1035
            if from_trans_id is None:
 
1036
                from_versioned = False
 
1037
                from_trans_id = to_trans_ids[file_id]
 
1038
            else:
 
1039
                from_versioned = True
 
1040
            to_trans_id = to_trans_ids.get(file_id)
 
1041
            if to_trans_id is None:
 
1042
                to_versioned = False
 
1043
                to_trans_id = from_trans_id
 
1044
            else:
 
1045
                to_versioned = True
 
1046
 
 
1047
            from_name, from_parent, from_kind, from_executable = \
 
1048
                self._from_file_data(from_trans_id, from_versioned, file_id)
 
1049
 
 
1050
            to_name, to_parent, to_kind, to_executable = \
 
1051
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
 
1052
 
 
1053
            if not from_versioned:
 
1054
                from_path = None
 
1055
            else:
 
1056
                from_path = self._tree_id_paths.get(from_trans_id)
 
1057
            if not to_versioned:
 
1058
                to_path = None
 
1059
            else:
 
1060
                to_path = final_paths.get_path(to_trans_id)
 
1061
            if from_kind != to_kind:
 
1062
                modified = True
 
1063
            elif to_kind in ('file', 'symlink') and (
 
1064
                to_trans_id != from_trans_id or
 
1065
                to_trans_id in self._new_contents):
 
1066
                modified = True
 
1067
            if (not modified and from_versioned == to_versioned and
 
1068
                from_parent==to_parent and from_name == to_name and
 
1069
                from_executable == to_executable):
 
1070
                continue
 
1071
            results.append((file_id, (from_path, to_path), modified,
 
1072
                   (from_versioned, to_versioned),
 
1073
                   (from_parent, to_parent),
 
1074
                   (from_name, to_name),
 
1075
                   (from_kind, to_kind),
 
1076
                   (from_executable, to_executable)))
 
1077
        return iter(sorted(results, key=lambda x:x[1]))
 
1078
 
 
1079
 
885
1080
def joinpath(parent, child):
886
1081
    """Join tree-relative paths, handling the tree root specially"""
887
1082
    if parent is None or parent == "":
923
1118
    file_ids.sort(key=tree.id2path)
924
1119
    return file_ids
925
1120
 
 
1121
 
926
1122
def build_tree(tree, wt):
927
 
    """Create working tree for a branch, using a Transaction."""
 
1123
    """Create working tree for a branch, using a TreeTransform.
 
1124
    
 
1125
    This function should be used on empty trees, having a tree root at most.
 
1126
    (see merge and revert functionality for working with existing trees)
 
1127
 
 
1128
    Existing files are handled like so:
 
1129
    
 
1130
    - Existing bzrdirs take precedence over creating new items.  They are
 
1131
      created as '%s.diverted' % name.
 
1132
    - Otherwise, if the content on disk matches the content we are building,
 
1133
      it is silently replaced.
 
1134
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
 
1135
    """
 
1136
    wt.lock_tree_write()
 
1137
    try:
 
1138
        tree.lock_read()
 
1139
        try:
 
1140
            return _build_tree(tree, wt)
 
1141
        finally:
 
1142
            tree.unlock()
 
1143
    finally:
 
1144
        wt.unlock()
 
1145
 
 
1146
def _build_tree(tree, wt):
 
1147
    """See build_tree."""
 
1148
    if len(wt.inventory) > 1:  # more than just a root
 
1149
        raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
928
1150
    file_trans_id = {}
929
1151
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
930
1152
    pp = ProgressPhase("Build phase", 2, top_pb)
 
1153
    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
 
1157
        # expensive operation (flush) every time the root id
 
1158
        # is set within the tree, nor setting the root and thus
 
1159
        # marking the tree as dirty, because we use two different
 
1160
        # 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)
 
1163
            wt.flush()
931
1164
    tt = TreeTransform(wt)
 
1165
    divert = set()
932
1166
    try:
933
1167
        pp.next_phase()
934
 
        file_trans_id[wt.get_root_id()] = tt.trans_id_tree_file_id(wt.get_root_id())
935
 
        file_ids = topology_sorted_ids(tree)
 
1168
        file_trans_id[wt.get_root_id()] = \
 
1169
            tt.trans_id_tree_file_id(wt.get_root_id())
936
1170
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
937
1171
        try:
938
 
            for num, file_id in enumerate(file_ids):
939
 
                pb.update("Building tree", num, len(file_ids))
940
 
                entry = tree.inventory[file_id]
 
1172
            for num, (tree_path, entry) in \
 
1173
                enumerate(tree.inventory.iter_entries_by_dir()):
 
1174
                pb.update("Building tree", num, len(tree.inventory))
941
1175
                if entry.parent_id is None:
942
1176
                    continue
 
1177
                reparent = False
 
1178
                file_id = entry.file_id
 
1179
                target_path = wt.abspath(tree_path)
 
1180
                try:
 
1181
                    kind = file_kind(target_path)
 
1182
                except NoSuchFile:
 
1183
                    pass
 
1184
                else:
 
1185
                    if kind == "directory":
 
1186
                        try:
 
1187
                            bzrdir.BzrDir.open(target_path)
 
1188
                        except errors.NotBranchError:
 
1189
                            pass
 
1190
                        else:
 
1191
                            divert.add(file_id)
 
1192
                    if (file_id not in divert and
 
1193
                        _content_match(tree, entry, file_id, kind,
 
1194
                        target_path)):
 
1195
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
 
1196
                        if kind == 'directory':
 
1197
                            reparent = True
943
1198
                if entry.parent_id not in file_trans_id:
944
 
                    raise repr(entry.parent_id)
 
1199
                    raise AssertionError(
 
1200
                        'entry %s parent id %r is not in file_trans_id %r'
 
1201
                        % (entry, entry.parent_id, file_trans_id))
945
1202
                parent_id = file_trans_id[entry.parent_id]
946
 
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id, 
 
1203
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
947
1204
                                                      tree)
 
1205
                if reparent:
 
1206
                    new_trans_id = file_trans_id[file_id]
 
1207
                    old_parent = tt.trans_id_tree_path(tree_path)
 
1208
                    _reparent_children(tt, old_parent, new_trans_id)
948
1209
        finally:
949
1210
            pb.finished()
950
1211
        pp.next_phase()
 
1212
        divert_trans = set(file_trans_id[f] for f in divert)
 
1213
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
 
1214
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
 
1215
        conflicts = cook_conflicts(raw_conflicts, tt)
 
1216
        for conflict in conflicts:
 
1217
            warning(conflict)
 
1218
        try:
 
1219
            wt.add_conflicts(conflicts)
 
1220
        except errors.UnsupportedOperation:
 
1221
            pass
951
1222
        tt.apply()
952
1223
    finally:
953
1224
        tt.finalize()
954
1225
        top_pb.finished()
955
1226
 
 
1227
 
 
1228
def _reparent_children(tt, old_parent, new_parent):
 
1229
    for child in tt.iter_tree_children(old_parent):
 
1230
        tt.adjust_path(tt.final_name(child), new_parent, child)
 
1231
 
 
1232
 
 
1233
def _content_match(tree, entry, file_id, kind, target_path):
 
1234
    if entry.kind != kind:
 
1235
        return False
 
1236
    if entry.kind == "directory":
 
1237
        return True
 
1238
    if entry.kind == "file":
 
1239
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
 
1240
            return True
 
1241
    elif entry.kind == "symlink":
 
1242
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
 
1243
            return True
 
1244
    return False
 
1245
 
 
1246
 
 
1247
def resolve_checkout(tt, conflicts, divert):
 
1248
    new_conflicts = set()
 
1249
    for c_type, conflict in ((c[0], c) for c in conflicts):
 
1250
        # Anything but a 'duplicate' would indicate programmer error
 
1251
        assert c_type == 'duplicate', c_type
 
1252
        # Now figure out which is new and which is old
 
1253
        if tt.new_contents(conflict[1]):
 
1254
            new_file = conflict[1]
 
1255
            old_file = conflict[2]
 
1256
        else:
 
1257
            new_file = conflict[2]
 
1258
            old_file = conflict[1]
 
1259
 
 
1260
        # We should only get here if the conflict wasn't completely
 
1261
        # resolved
 
1262
        final_parent = tt.final_parent(old_file)
 
1263
        if new_file in divert:
 
1264
            new_name = tt.final_name(old_file)+'.diverted'
 
1265
            tt.adjust_path(new_name, final_parent, new_file)
 
1266
            new_conflicts.add((c_type, 'Diverted to',
 
1267
                               new_file, old_file))
 
1268
        else:
 
1269
            new_name = tt.final_name(old_file)+'.moved'
 
1270
            tt.adjust_path(new_name, final_parent, old_file)
 
1271
            new_conflicts.add((c_type, 'Moved existing file to',
 
1272
                               old_file, new_file))
 
1273
    return new_conflicts
 
1274
 
 
1275
 
956
1276
def new_by_entry(tt, entry, parent_id, tree):
957
1277
    """Create a new file according to its inventory entry"""
958
1278
    name = entry.name
962
1282
        executable = tree.is_executable(entry.file_id)
963
1283
        return tt.new_file(name, parent_id, contents, entry.file_id, 
964
1284
                           executable)
965
 
    elif kind == 'directory':
966
 
        return tt.new_directory(name, parent_id, entry.file_id)
 
1285
    elif kind in ('directory', 'tree-reference'):
 
1286
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
 
1287
        if kind == 'tree-reference':
 
1288
            tt.set_tree_reference(entry.reference_revision, trans_id)
 
1289
        return trans_id 
967
1290
    elif kind == 'symlink':
968
1291
        target = tree.get_symlink_target(entry.file_id)
969
1292
        return tt.new_symlink(name, parent_id, target, entry.file_id)
 
1293
    else:
 
1294
        raise errors.BadFileKindError(name, kind)
970
1295
 
971
1296
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
972
1297
    """Create new file contents according to an inventory entry."""
973
1298
    if entry.kind == "file":
974
 
        if lines == None:
 
1299
        if lines is None:
975
1300
            lines = tree.get_file(entry.file_id).readlines()
976
1301
        tt.create_file(lines, trans_id, mode_id=mode_id)
977
1302
    elif entry.kind == "symlink":
985
1310
        tt.set_executability(entry.executable, trans_id)
986
1311
 
987
1312
 
 
1313
@deprecated_function(zero_fifteen)
988
1314
def find_interesting(working_tree, target_tree, filenames):
989
 
    """Find the ids corresponding to specified filenames."""
990
 
    if not filenames:
991
 
        interesting_ids = None
992
 
    else:
993
 
        interesting_ids = set()
994
 
        for tree_path in filenames:
995
 
            not_found = True
996
 
            for tree in (working_tree, target_tree):
997
 
                file_id = tree.inventory.path2id(tree_path)
998
 
                if file_id is not None:
999
 
                    interesting_ids.add(file_id)
1000
 
                    not_found = False
1001
 
            if not_found:
1002
 
                raise NotVersionedError(path=tree_path)
1003
 
    return interesting_ids
 
1315
    """Find the ids corresponding to specified filenames.
 
1316
    
 
1317
    Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
 
1318
    """
 
1319
    working_tree.lock_read()
 
1320
    try:
 
1321
        target_tree.lock_read()
 
1322
        try:
 
1323
            return working_tree.paths2ids(filenames, [target_tree])
 
1324
        finally:
 
1325
            target_tree.unlock()
 
1326
    finally:
 
1327
        working_tree.unlock()
1004
1328
 
1005
1329
 
1006
1330
def change_entry(tt, file_id, working_tree, target_tree, 
1044
1368
 
1045
1369
 
1046
1370
def get_backup_name(entry, by_parent, parent_trans_id, tt):
 
1371
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
 
1372
 
 
1373
 
 
1374
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1047
1375
    """Produce a backup-style name that appears to be available"""
1048
1376
    def name_gen():
1049
1377
        counter = 1
1050
1378
        while True:
1051
 
            yield "%s.~%d~" % (entry.name, counter)
 
1379
            yield "%s.~%d~" % (name, counter)
1052
1380
            counter += 1
1053
 
    for name in name_gen():
1054
 
        if not tt.has_named_child(by_parent, parent_trans_id, name):
1055
 
            return name
 
1381
    for new_name in name_gen():
 
1382
        if not tt.has_named_child(by_parent, parent_trans_id, new_name):
 
1383
            return new_name
 
1384
 
1056
1385
 
1057
1386
def _entry_changes(file_id, entry, working_tree):
1058
1387
    """Determine in which ways the inventory entry has changed.
1071
1400
        contents_mod = True
1072
1401
        meta_mod = False
1073
1402
    if has_contents is True:
1074
 
        real_e_kind = entry.kind
1075
 
        if real_e_kind == 'root_directory':
1076
 
            real_e_kind = 'directory'
1077
 
        if real_e_kind != working_kind:
 
1403
        if entry.kind != working_kind:
1078
1404
            contents_mod, meta_mod = True, False
1079
1405
        else:
1080
1406
            cur_entry._read_tree_state(working_tree.id2path(file_id), 
1084
1410
    return has_contents, contents_mod, meta_mod
1085
1411
 
1086
1412
 
1087
 
def revert(working_tree, target_tree, filenames, backups=False, 
1088
 
           pb=DummyProgress()):
 
1413
def revert(working_tree, target_tree, filenames, backups=False,
 
1414
           pb=DummyProgress(), change_reporter=None):
1089
1415
    """Revert a working tree's contents to those of a target tree."""
1090
 
    interesting_ids = find_interesting(working_tree, target_tree, filenames)
1091
 
    def interesting(file_id):
1092
 
        return interesting_ids is None or file_id in interesting_ids
1093
 
 
 
1416
    target_tree.lock_read()
1094
1417
    tt = TreeTransform(working_tree, pb)
1095
1418
    try:
1096
 
        merge_modified = working_tree.merge_modified()
1097
 
        trans_id = {}
1098
 
        def trans_id_file_id(file_id):
1099
 
            try:
1100
 
                return trans_id[file_id]
1101
 
            except KeyError:
1102
 
                return tt.trans_id_tree_file_id(file_id)
1103
 
 
1104
 
        pp = ProgressPhase("Revert phase", 4, pb)
1105
 
        pp.next_phase()
1106
 
        sorted_interesting = [i for i in topology_sorted_ids(target_tree) if
1107
 
                              interesting(i)]
1108
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1109
 
        try:
1110
 
            by_parent = tt.by_parent()
1111
 
            for id_num, file_id in enumerate(sorted_interesting):
1112
 
                child_pb.update("Reverting file", id_num+1, 
1113
 
                                len(sorted_interesting))
1114
 
                if file_id not in working_tree.inventory:
1115
 
                    entry = target_tree.inventory[file_id]
1116
 
                    parent_id = trans_id_file_id(entry.parent_id)
1117
 
                    e_trans_id = new_by_entry(tt, entry, parent_id, target_tree)
1118
 
                    trans_id[file_id] = e_trans_id
1119
 
                else:
1120
 
                    backup_this = backups
1121
 
                    if file_id in merge_modified:
1122
 
                        backup_this = False
1123
 
                        del merge_modified[file_id]
1124
 
                    change_entry(tt, file_id, working_tree, target_tree, 
1125
 
                                 trans_id_file_id, backup_this, trans_id,
1126
 
                                 by_parent)
1127
 
        finally:
1128
 
            child_pb.finished()
1129
 
        pp.next_phase()
1130
 
        wt_interesting = [i for i in working_tree.inventory if interesting(i)]
1131
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1132
 
        try:
1133
 
            for id_num, file_id in enumerate(wt_interesting):
1134
 
                child_pb.update("New file check", id_num+1, 
1135
 
                                len(sorted_interesting))
1136
 
                if file_id not in target_tree:
1137
 
                    trans_id = tt.trans_id_tree_file_id(file_id)
1138
 
                    tt.unversion_file(trans_id)
1139
 
                    if file_id in merge_modified:
1140
 
                        tt.delete_contents(trans_id)
1141
 
                        del merge_modified[file_id]
 
1419
        pp = ProgressPhase("Revert phase", 3, pb)
 
1420
        pp.next_phase()
 
1421
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1422
        try:
 
1423
            _alter_files(working_tree, target_tree, tt, child_pb,
 
1424
                         filenames, backups)
1142
1425
        finally:
1143
1426
            child_pb.finished()
1144
1427
        pp.next_phase()
1148
1431
        finally:
1149
1432
            child_pb.finished()
1150
1433
        conflicts = cook_conflicts(raw_conflicts, tt)
 
1434
        if change_reporter:
 
1435
            change_reporter = delta._ChangeReporter(
 
1436
                unversioned_filter=working_tree.is_ignored)
 
1437
            delta.report_changes(tt._iter_changes(), change_reporter)
1151
1438
        for conflict in conflicts:
1152
1439
            warning(conflict)
1153
1440
        pp.next_phase()
1154
1441
        tt.apply()
1155
1442
        working_tree.set_merge_modified({})
1156
1443
    finally:
 
1444
        target_tree.unlock()
1157
1445
        tt.finalize()
1158
1446
        pb.clear()
1159
1447
    return conflicts
1160
1448
 
1161
1449
 
1162
 
def resolve_conflicts(tt, pb=DummyProgress()):
 
1450
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
 
1451
                 backups):
 
1452
    merge_modified = working_tree.merge_modified()
 
1453
    change_list = target_tree._iter_changes(working_tree,
 
1454
        specific_files=specific_files, pb=pb)
 
1455
    if target_tree.inventory.root is None:
 
1456
        skip_root = True
 
1457
    else:
 
1458
        skip_root = False
 
1459
    basis_tree = None
 
1460
    try:
 
1461
        for id_num, (file_id, path, changed_content, versioned, parent, name,
 
1462
                kind, executable) in enumerate(change_list):
 
1463
            if skip_root and file_id[0] is not None and parent[0] is None:
 
1464
                continue
 
1465
            trans_id = tt.trans_id_file_id(file_id)
 
1466
            mode_id = None
 
1467
            if changed_content:
 
1468
                keep_content = False
 
1469
                if kind[0] == 'file' and (backups or kind[1] is None):
 
1470
                    wt_sha1 = working_tree.get_file_sha1(file_id)
 
1471
                    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)
 
1475
                        if basis_tree is None:
 
1476
                            basis_tree = working_tree.basis_tree()
 
1477
                            basis_tree.lock_read()
 
1478
                        if file_id in basis_tree:
 
1479
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
 
1480
                                keep_content = True
 
1481
                        elif kind[1] is None and not versioned[1]:
 
1482
                            keep_content = True
 
1483
                if kind[0] is not None:
 
1484
                    if not keep_content:
 
1485
                        tt.delete_contents(trans_id)
 
1486
                    elif kind[1] is not None:
 
1487
                        parent_trans_id = tt.trans_id_file_id(parent[0])
 
1488
                        by_parent = tt.by_parent()
 
1489
                        backup_name = _get_backup_name(name[0], by_parent,
 
1490
                                                       parent_trans_id, tt)
 
1491
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
 
1492
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
 
1493
                        if versioned == (True, True):
 
1494
                            tt.unversion_file(trans_id)
 
1495
                            tt.version_file(file_id, new_trans_id)
 
1496
                        # New contents should have the same unix perms as old
 
1497
                        # contents
 
1498
                        mode_id = trans_id
 
1499
                        trans_id = new_trans_id
 
1500
                if kind[1] == 'directory':
 
1501
                    tt.create_directory(trans_id)
 
1502
                elif kind[1] == 'symlink':
 
1503
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
 
1504
                                      trans_id)
 
1505
                elif kind[1] == 'file':
 
1506
                    tt.create_file(target_tree.get_file_lines(file_id),
 
1507
                                   trans_id, mode_id)
 
1508
                    # preserve the execute bit when backing up
 
1509
                    if keep_content and executable[0] == executable[1]:
 
1510
                        tt.set_executability(executable[1], trans_id)
 
1511
                else:
 
1512
                    assert kind[1] is None
 
1513
            if versioned == (False, True):
 
1514
                tt.version_file(file_id, trans_id)
 
1515
            if versioned == (True, False):
 
1516
                tt.unversion_file(trans_id)
 
1517
            if (name[1] is not None and 
 
1518
                (name[0] != name[1] or parent[0] != parent[1])):
 
1519
                tt.adjust_path(
 
1520
                    name[1], tt.trans_id_file_id(parent[1]), trans_id)
 
1521
            if executable[0] != executable[1] and kind[1] == "file":
 
1522
                tt.set_executability(executable[1], trans_id)
 
1523
    finally:
 
1524
        if basis_tree is not None:
 
1525
            basis_tree.unlock()
 
1526
 
 
1527
 
 
1528
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1163
1529
    """Make many conflict-resolution attempts, but die if they fail"""
 
1530
    if pass_func is None:
 
1531
        pass_func = conflict_pass
1164
1532
    new_conflicts = set()
1165
1533
    try:
1166
1534
        for n in range(10):
1168
1536
            conflicts = tt.find_conflicts()
1169
1537
            if len(conflicts) == 0:
1170
1538
                return new_conflicts
1171
 
            new_conflicts.update(conflict_pass(tt, conflicts))
 
1539
            new_conflicts.update(pass_func(tt, conflicts))
1172
1540
        raise MalformedTransform(conflicts=conflicts)
1173
1541
    finally:
1174
1542
        pb.clear()
1207
1575
            trans_id = conflict[1]
1208
1576
            try:
1209
1577
                tt.cancel_deletion(trans_id)
1210
 
                new_conflicts.add((c_type, 'Not deleting', trans_id))
 
1578
                new_conflicts.add(('deleting parent', 'Not deleting', 
 
1579
                                   trans_id))
1211
1580
            except KeyError:
1212
1581
                tt.create_directory(trans_id)
1213
 
                new_conflicts.add((c_type, 'Created directory.', trans_id))
 
1582
                new_conflicts.add((c_type, 'Created directory', trans_id))
1214
1583
        elif c_type == 'unversioned parent':
1215
1584
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1216
1585
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))