/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Martin Pool
  • Date: 2007-04-19 08:03:19 UTC
  • mto: This revision was merged to the branch mainline in revision 2461.
  • Revision ID: mbp@sourcefrog.net-20070419080319-amc7f3frr64lxolq
Make timestamps use existing format_date; document that function more

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
 
41
import bzrlib.urlutils as urlutils
30
42
 
31
43
 
32
44
ROOT_PARENT = "root-parent"
70
82
     * set_executability
71
83
    """
72
84
    def __init__(self, tree, pb=DummyProgress()):
73
 
        """Note: a write lock is taken on the tree.
 
85
        """Note: a tree_write lock is taken on the tree.
74
86
        
75
87
        Use TreeTransform.finalize() to release the lock
76
88
        """
77
89
        object.__init__(self)
78
90
        self._tree = tree
79
 
        self._tree.lock_write()
 
91
        self._tree.lock_tree_write()
80
92
        try:
81
93
            control_files = self._tree._control_files
82
 
            self._limbodir = control_files.controlfilename('limbo')
 
94
            self._limbodir = urlutils.local_path_from_url(
 
95
                control_files.controlfilename('limbo'))
83
96
            try:
84
97
                os.mkdir(self._limbodir)
85
98
            except OSError, e:
95
108
        self._new_contents = {}
96
109
        self._removed_contents = set()
97
110
        self._new_executability = {}
 
111
        self._new_reference_revision = {}
98
112
        self._new_id = {}
99
113
        self._non_present_ids = {}
100
114
        self._r_new_id = {}
101
115
        self._removed_id = set()
102
116
        self._tree_path_ids = {}
103
117
        self._tree_id_paths = {}
 
118
        self._realpaths = {}
 
119
        # Cache of realpath results, to speed up canonical_path
 
120
        self._relpaths = {}
 
121
        # Cache of relpath results, to speed up canonical_path
104
122
        self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
105
123
        self.__done = False
106
124
        self._pb = pb
211
229
    def canonical_path(self, path):
212
230
        """Get the canonical tree-relative path"""
213
231
        # don't follow final symlinks
214
 
        dirname, basename = os.path.split(self._tree.abspath(path))
215
 
        dirname = os.path.realpath(dirname)
216
 
        return self._tree.relpath(pathjoin(dirname, basename))
 
232
        abs = self._tree.abspath(path)
 
233
        if abs in self._relpaths:
 
234
            return self._relpaths[abs]
 
235
        dirname, basename = os.path.split(abs)
 
236
        if dirname not in self._realpaths:
 
237
            self._realpaths[dirname] = os.path.realpath(dirname)
 
238
        dirname = self._realpaths[dirname]
 
239
        abs = pathjoin(dirname, basename)
 
240
        if dirname in self._relpaths:
 
241
            relpath = pathjoin(self._relpaths[dirname], basename)
 
242
            relpath = relpath.rstrip('/\\')
 
243
        else:
 
244
            relpath = self._tree.relpath(abs)
 
245
        self._relpaths[abs] = relpath
 
246
        return relpath
217
247
 
218
248
    def trans_id_tree_path(self, path):
219
249
        """Determine (and maybe set) the transaction ID for a tree path."""
241
271
        New file takes the permissions of any existing file with that id,
242
272
        unless mode_id is specified.
243
273
        """
244
 
        f = file(self._limbo_name(trans_id), 'wb')
245
 
        unique_add(self._new_contents, trans_id, 'file')
246
 
        for segment in contents:
247
 
            f.write(segment)
248
 
        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()
249
289
        self._set_mode(trans_id, mode_id, S_ISREG)
250
290
 
251
291
    def _set_mode(self, trans_id, mode_id, typefunc):
261
301
        except KeyError:
262
302
            return
263
303
        try:
264
 
            mode = os.stat(old_path).st_mode
 
304
            mode = os.stat(self._tree.abspath(old_path)).st_mode
265
305
        except OSError, e:
266
306
            if e.errno == errno.ENOENT:
267
307
                return
319
359
        else:
320
360
            unique_add(self._new_executability, trans_id, executability)
321
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
 
322
366
    def version_file(self, file_id, trans_id):
323
367
        """Schedule a file to become versioned."""
324
368
        assert file_id is not None
426
470
        try:
427
471
            return self._new_name[trans_id]
428
472
        except KeyError:
429
 
            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)
430
477
 
431
478
    def by_parent(self):
432
479
        """Return a map of parent: children for known parents.
445
492
 
446
493
    def path_changed(self, trans_id):
447
494
        """Return True if a trans_id's path has changed."""
448
 
        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)
449
499
 
450
500
    def find_conflicts(self):
451
501
        """Find any violations of inventory or filesystem invariants"""
477
527
                        self.tree_kind(t) == 'directory'])
478
528
        for trans_id in self._removed_id:
479
529
            file_id = self.tree_file_id(trans_id)
480
 
            if self._tree.inventory[file_id].kind in ('directory', 
481
 
                                                      'root_directory'):
 
530
            if self._tree.inventory[file_id].kind == 'directory':
482
531
                parents.append(trans_id)
483
532
 
484
533
        for parent_id in parents:
521
570
        if child_id is None:
522
571
            return lexists(self._tree.abspath(childpath))
523
572
        else:
524
 
            if tt.final_parent(child_id) != parent_id:
 
573
            if self.final_parent(child_id) != parent_id:
525
574
                return False
526
 
            if child_id in tt._removed_contents:
 
575
            if child_id in self._removed_contents:
527
576
                # XXX What about dangling file-ids?
528
577
                return False
529
578
            else:
537
586
            parent_id = trans_id
538
587
            while parent_id is not ROOT_PARENT:
539
588
                seen.add(parent_id)
540
 
                parent_id = self.final_parent(parent_id)
 
589
                try:
 
590
                    parent_id = self.final_parent(parent_id)
 
591
                except KeyError:
 
592
                    break
541
593
                if parent_id == trans_id:
542
594
                    conflicts.append(('parent loop', trans_id))
543
595
                if parent_id in seen:
617
669
            last_name = None
618
670
            last_trans_id = None
619
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
620
679
                if name == last_name:
621
680
                    conflicts.append(('duplicate', last_trans_id, trans_id,
622
681
                    name))
623
 
                try:
624
 
                    kind = self.final_kind(trans_id)
625
 
                except NoSuchFile:
626
 
                    kind = None
627
 
                file_id = self.final_file_id(trans_id)
628
 
                if kind is not None or file_id is not None:
629
 
                    last_name = name
630
 
                    last_trans_id = trans_id
 
682
                last_name = name
 
683
                last_trans_id = trans_id
631
684
        return conflicts
632
685
 
633
686
    def _duplicate_ids(self):
685
738
        conflicts = self.find_conflicts()
686
739
        if len(conflicts) != 0:
687
740
            raise MalformedTransform(conflicts=conflicts)
688
 
        limbo_inv = {}
689
741
        inv = self._tree.inventory
 
742
        inventory_delta = []
690
743
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
691
744
        try:
692
745
            child_pb.update('Apply phase', 0, 2)
693
 
            self._apply_removals(inv, limbo_inv)
 
746
            self._apply_removals(inv, inventory_delta)
694
747
            child_pb.update('Apply phase', 1, 2)
695
 
            modified_paths = self._apply_insertions(inv, limbo_inv)
 
748
            modified_paths = self._apply_insertions(inv, inventory_delta)
696
749
        finally:
697
750
            child_pb.finished()
698
 
        self._tree._write_inventory(inv)
 
751
        self._tree.apply_inventory_delta(inventory_delta)
699
752
        self.__done = True
700
753
        self.finalize()
701
754
        return _TransformResults(modified_paths)
704
757
        """Generate the limbo name of a file"""
705
758
        return pathjoin(self._limbodir, trans_id)
706
759
 
707
 
    def _apply_removals(self, inv, limbo_inv):
 
760
    def _apply_removals(self, inv, inventory_delta):
708
761
        """Perform tree operations that remove directory/inventory names.
709
762
        
710
763
        That is, delete files that are to be deleted, and put any files that
733
786
                        file_id = self._tree.inventory.root.file_id
734
787
                    else:
735
788
                        file_id = self.tree_file_id(trans_id)
736
 
                    del inv[file_id]
737
 
                elif trans_id in self._new_name or trans_id in self._new_parent:
738
 
                    file_id = self.tree_file_id(trans_id)
739
 
                    if file_id is not None:
740
 
                        limbo_inv[trans_id] = inv[file_id]
741
 
                        del inv[file_id]
 
789
                    assert file_id is not None
 
790
                    inventory_delta.append((path, None, file_id, None))
742
791
        finally:
743
792
            child_pb.finished()
744
793
 
745
 
    def _apply_insertions(self, inv, limbo_inv):
 
794
    def _apply_insertions(self, inv, inventory_delta):
746
795
        """Perform tree operations that insert directory/inventory names.
747
796
        
748
797
        That is, create any files that need to be created, and restore from
754
803
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
755
804
        try:
756
805
            for num, (path, trans_id) in enumerate(new_paths):
 
806
                new_entry = None
757
807
                child_pb.update('adding file', num, len(new_paths))
758
808
                try:
759
809
                    kind = self._new_contents[trans_id]
775
825
                if trans_id in self._new_id:
776
826
                    if kind is None:
777
827
                        kind = file_kind(self._tree.abspath(path))
778
 
                    inv.add_path(path, kind, self._new_id[trans_id])
779
 
                elif trans_id in self._new_name or trans_id in\
780
 
                    self._new_parent:
781
 
                    entry = limbo_inv.get(trans_id)
782
 
                    if entry is not None:
783
 
                        entry.name = self.final_name(trans_id)
784
 
                        parent_path = os.path.dirname(path)
785
 
                        entry.parent_id = \
786
 
                            self._tree.inventory.path2id(parent_path)
787
 
                        inv.add(entry)
788
 
 
789
 
                # 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
 
790
856
                if trans_id in self._new_executability:
791
 
                    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))
792
866
        finally:
793
867
            child_pb.finished()
794
868
        return modified_paths
795
869
 
796
 
    def _set_executability(self, path, inv, trans_id):
 
870
    def _set_executability(self, path, entry, trans_id):
797
871
        """Set the executability of versioned files """
798
 
        file_id = inv.path2id(path)
799
872
        new_executability = self._new_executability[trans_id]
800
 
        inv[file_id].executable = new_executability
 
873
        entry.executable = new_executability
801
874
        if supports_executable():
802
875
            abspath = self._tree.abspath(path)
803
876
            current_mode = os.stat(abspath).st_mode
829
902
        parent_id is the transaction id of the parent directory of the file.
830
903
        contents is an iterator of bytestrings, which will be used to produce
831
904
        the file.
832
 
        file_id is the inventory ID of the file, if it is to be versioned.
 
905
        :param file_id: The inventory ID of the file, if it is to be versioned.
 
906
        :param executable: Only valid when a file_id has been supplied.
833
907
        """
834
908
        trans_id = self._new_entry(name, parent_id, file_id)
 
909
        # TODO: rather than scheduling a set_executable call,
 
910
        # have create_file create the file with the right mode.
835
911
        self.create_file(contents, trans_id)
836
912
        if executable is not None:
837
913
            self.set_executability(executable, trans_id)
861
937
        self.create_symlink(target, trans_id)
862
938
        return trans_id
863
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
 
864
1080
def joinpath(parent, child):
865
1081
    """Join tree-relative paths, handling the tree root specially"""
866
1082
    if parent is None or parent == "":
902
1118
    file_ids.sort(key=tree.id2path)
903
1119
    return file_ids
904
1120
 
 
1121
 
905
1122
def build_tree(tree, wt):
906
 
    """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)
907
1150
    file_trans_id = {}
908
1151
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
909
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()
910
1164
    tt = TreeTransform(wt)
 
1165
    divert = set()
911
1166
    try:
912
1167
        pp.next_phase()
913
 
        file_trans_id[wt.get_root_id()] = tt.trans_id_tree_file_id(wt.get_root_id())
914
 
        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())
915
1170
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
916
1171
        try:
917
 
            for num, file_id in enumerate(file_ids):
918
 
                pb.update("Building tree", num, len(file_ids))
919
 
                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))
920
1175
                if entry.parent_id is None:
921
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
922
1198
                if entry.parent_id not in file_trans_id:
923
 
                    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))
924
1202
                parent_id = file_trans_id[entry.parent_id]
925
 
                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,
926
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)
927
1209
        finally:
928
1210
            pb.finished()
929
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
930
1222
        tt.apply()
931
1223
    finally:
932
1224
        tt.finalize()
933
1225
        top_pb.finished()
934
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
 
935
1276
def new_by_entry(tt, entry, parent_id, tree):
936
1277
    """Create a new file according to its inventory entry"""
937
1278
    name = entry.name
941
1282
        executable = tree.is_executable(entry.file_id)
942
1283
        return tt.new_file(name, parent_id, contents, entry.file_id, 
943
1284
                           executable)
944
 
    elif kind == 'directory':
945
 
        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 
946
1290
    elif kind == 'symlink':
947
1291
        target = tree.get_symlink_target(entry.file_id)
948
1292
        return tt.new_symlink(name, parent_id, target, entry.file_id)
 
1293
    else:
 
1294
        raise errors.BadFileKindError(name, kind)
949
1295
 
950
1296
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
951
1297
    """Create new file contents according to an inventory entry."""
952
1298
    if entry.kind == "file":
953
 
        if lines == None:
 
1299
        if lines is None:
954
1300
            lines = tree.get_file(entry.file_id).readlines()
955
1301
        tt.create_file(lines, trans_id, mode_id=mode_id)
956
1302
    elif entry.kind == "symlink":
964
1310
        tt.set_executability(entry.executable, trans_id)
965
1311
 
966
1312
 
 
1313
@deprecated_function(zero_fifteen)
967
1314
def find_interesting(working_tree, target_tree, filenames):
968
 
    """Find the ids corresponding to specified filenames."""
969
 
    if not filenames:
970
 
        interesting_ids = None
971
 
    else:
972
 
        interesting_ids = set()
973
 
        for tree_path in filenames:
974
 
            not_found = True
975
 
            for tree in (working_tree, target_tree):
976
 
                file_id = tree.inventory.path2id(tree_path)
977
 
                if file_id is not None:
978
 
                    interesting_ids.add(file_id)
979
 
                    not_found = False
980
 
            if not_found:
981
 
                raise NotVersionedError(path=tree_path)
982
 
    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()
983
1328
 
984
1329
 
985
1330
def change_entry(tt, file_id, working_tree, target_tree, 
1023
1368
 
1024
1369
 
1025
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):
1026
1375
    """Produce a backup-style name that appears to be available"""
1027
1376
    def name_gen():
1028
1377
        counter = 1
1029
1378
        while True:
1030
 
            yield "%s.~%d~" % (entry.name, counter)
 
1379
            yield "%s.~%d~" % (name, counter)
1031
1380
            counter += 1
1032
 
    for name in name_gen():
1033
 
        if not tt.has_named_child(by_parent, parent_trans_id, name):
1034
 
            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
 
1035
1385
 
1036
1386
def _entry_changes(file_id, entry, working_tree):
1037
1387
    """Determine in which ways the inventory entry has changed.
1045
1395
    try:
1046
1396
        working_kind = working_tree.kind(file_id)
1047
1397
        has_contents = True
1048
 
    except OSError, e:
1049
 
        if e.errno != errno.ENOENT:
1050
 
            raise
 
1398
    except NoSuchFile:
1051
1399
        has_contents = False
1052
1400
        contents_mod = True
1053
1401
        meta_mod = False
1054
1402
    if has_contents is True:
1055
 
        real_e_kind = entry.kind
1056
 
        if real_e_kind == 'root_directory':
1057
 
            real_e_kind = 'directory'
1058
 
        if real_e_kind != working_kind:
 
1403
        if entry.kind != working_kind:
1059
1404
            contents_mod, meta_mod = True, False
1060
1405
        else:
1061
1406
            cur_entry._read_tree_state(working_tree.id2path(file_id), 
1065
1410
    return has_contents, contents_mod, meta_mod
1066
1411
 
1067
1412
 
1068
 
def revert(working_tree, target_tree, filenames, backups=False, 
1069
 
           pb=DummyProgress()):
 
1413
def revert(working_tree, target_tree, filenames, backups=False,
 
1414
           pb=DummyProgress(), change_reporter=None):
1070
1415
    """Revert a working tree's contents to those of a target tree."""
1071
 
    interesting_ids = find_interesting(working_tree, target_tree, filenames)
1072
 
    def interesting(file_id):
1073
 
        return interesting_ids is None or file_id in interesting_ids
1074
 
 
 
1416
    target_tree.lock_read()
1075
1417
    tt = TreeTransform(working_tree, pb)
1076
1418
    try:
1077
 
        merge_modified = working_tree.merge_modified()
1078
 
        trans_id = {}
1079
 
        def trans_id_file_id(file_id):
1080
 
            try:
1081
 
                return trans_id[file_id]
1082
 
            except KeyError:
1083
 
                return tt.trans_id_tree_file_id(file_id)
1084
 
 
1085
 
        pp = ProgressPhase("Revert phase", 4, pb)
1086
 
        pp.next_phase()
1087
 
        sorted_interesting = [i for i in topology_sorted_ids(target_tree) if
1088
 
                              interesting(i)]
1089
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1090
 
        try:
1091
 
            by_parent = tt.by_parent()
1092
 
            for id_num, file_id in enumerate(sorted_interesting):
1093
 
                child_pb.update("Reverting file", id_num+1, 
1094
 
                                len(sorted_interesting))
1095
 
                if file_id not in working_tree.inventory:
1096
 
                    entry = target_tree.inventory[file_id]
1097
 
                    parent_id = trans_id_file_id(entry.parent_id)
1098
 
                    e_trans_id = new_by_entry(tt, entry, parent_id, target_tree)
1099
 
                    trans_id[file_id] = e_trans_id
1100
 
                else:
1101
 
                    backup_this = backups
1102
 
                    if file_id in merge_modified:
1103
 
                        backup_this = False
1104
 
                        del merge_modified[file_id]
1105
 
                    change_entry(tt, file_id, working_tree, target_tree, 
1106
 
                                 trans_id_file_id, backup_this, trans_id,
1107
 
                                 by_parent)
1108
 
        finally:
1109
 
            child_pb.finished()
1110
 
        pp.next_phase()
1111
 
        wt_interesting = [i for i in working_tree.inventory if interesting(i)]
1112
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1113
 
        try:
1114
 
            for id_num, file_id in enumerate(wt_interesting):
1115
 
                child_pb.update("New file check", id_num+1, 
1116
 
                                len(sorted_interesting))
1117
 
                if file_id not in target_tree:
1118
 
                    trans_id = tt.trans_id_tree_file_id(file_id)
1119
 
                    tt.unversion_file(trans_id)
1120
 
                    if file_id in merge_modified:
1121
 
                        tt.delete_contents(trans_id)
1122
 
                        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)
1123
1425
        finally:
1124
1426
            child_pb.finished()
1125
1427
        pp.next_phase()
1129
1431
        finally:
1130
1432
            child_pb.finished()
1131
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)
1132
1438
        for conflict in conflicts:
1133
1439
            warning(conflict)
1134
1440
        pp.next_phase()
1135
1441
        tt.apply()
1136
1442
        working_tree.set_merge_modified({})
1137
1443
    finally:
 
1444
        target_tree.unlock()
1138
1445
        tt.finalize()
1139
1446
        pb.clear()
1140
1447
    return conflicts
1141
1448
 
1142
1449
 
1143
 
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):
1144
1529
    """Make many conflict-resolution attempts, but die if they fail"""
 
1530
    if pass_func is None:
 
1531
        pass_func = conflict_pass
1145
1532
    new_conflicts = set()
1146
1533
    try:
1147
1534
        for n in range(10):
1149
1536
            conflicts = tt.find_conflicts()
1150
1537
            if len(conflicts) == 0:
1151
1538
                return new_conflicts
1152
 
            new_conflicts.update(conflict_pass(tt, conflicts))
 
1539
            new_conflicts.update(pass_func(tt, conflicts))
1153
1540
        raise MalformedTransform(conflicts=conflicts)
1154
1541
    finally:
1155
1542
        pb.clear()
1188
1575
            trans_id = conflict[1]
1189
1576
            try:
1190
1577
                tt.cancel_deletion(trans_id)
1191
 
                new_conflicts.add((c_type, 'Not deleting', trans_id))
 
1578
                new_conflicts.add(('deleting parent', 'Not deleting', 
 
1579
                                   trans_id))
1192
1580
            except KeyError:
1193
1581
                tt.create_directory(trans_id)
1194
 
                new_conflicts.add((c_type, 'Created directory.', trans_id))
 
1582
                new_conflicts.add((c_type, 'Created directory', trans_id))
1195
1583
        elif c_type == 'unversioned parent':
1196
1584
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1197
1585
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
1198
1586
    return new_conflicts
1199
1587
 
 
1588
 
1200
1589
def cook_conflicts(raw_conflicts, tt):
1201
1590
    """Generate a list of cooked conflicts, sorted by file path"""
1202
 
    def key(conflict):
1203
 
        if conflict.path is not None:
1204
 
            return conflict.path, conflict.typestring
1205
 
        elif getattr(conflict, "conflict_path", None) is not None:
1206
 
            return conflict.conflict_path, conflict.typestring
1207
 
        else:
1208
 
            return None, conflict.typestring
 
1591
    from bzrlib.conflicts import Conflict
 
1592
    conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
 
1593
    return sorted(conflict_iter, key=Conflict.sort_key)
1209
1594
 
1210
 
    return sorted(list(iter_cook_conflicts(raw_conflicts, tt)), key=key)
1211
1595
 
1212
1596
def iter_cook_conflicts(raw_conflicts, tt):
1213
1597
    from bzrlib.conflicts import Conflict